001: /*******************************************************************************
002: * Copyright (c) 2000, 2007 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.ui.preferences;
011:
012: import java.util.ArrayList;
013: import java.util.HashMap;
014: import java.util.Iterator;
015: import java.util.Map;
016: import java.util.StringTokenizer;
017:
018: import org.eclipse.core.runtime.Assert;
019: import org.eclipse.core.runtime.IStatus;
020:
021: import org.eclipse.swt.SWT;
022: import org.eclipse.swt.events.KeyEvent;
023: import org.eclipse.swt.events.KeyListener;
024: import org.eclipse.swt.events.ModifyEvent;
025: import org.eclipse.swt.events.ModifyListener;
026: import org.eclipse.swt.events.SelectionEvent;
027: import org.eclipse.swt.events.SelectionListener;
028: import org.eclipse.swt.graphics.Image;
029: import org.eclipse.swt.graphics.Point;
030: import org.eclipse.swt.layout.GridData;
031: import org.eclipse.swt.layout.GridLayout;
032: import org.eclipse.swt.widgets.Button;
033: import org.eclipse.swt.widgets.Composite;
034: import org.eclipse.swt.widgets.Control;
035: import org.eclipse.swt.widgets.Label;
036: import org.eclipse.swt.widgets.Table;
037: import org.eclipse.swt.widgets.TableColumn;
038: import org.eclipse.swt.widgets.TableItem;
039: import org.eclipse.swt.widgets.Text;
040:
041: import org.eclipse.jface.action.Action;
042: import org.eclipse.jface.dialogs.Dialog;
043: import org.eclipse.jface.preference.PreferencePage;
044: import org.eclipse.jface.viewers.CheckStateChangedEvent;
045: import org.eclipse.jface.viewers.CheckboxTableViewer;
046: import org.eclipse.jface.viewers.ColumnWeightData;
047: import org.eclipse.jface.viewers.ICheckStateListener;
048: import org.eclipse.jface.viewers.ILabelProviderListener;
049: import org.eclipse.jface.viewers.IStructuredContentProvider;
050: import org.eclipse.jface.viewers.ITableLabelProvider;
051: import org.eclipse.jface.viewers.StructuredSelection;
052: import org.eclipse.jface.viewers.TableLayout;
053: import org.eclipse.jface.viewers.TableViewer;
054: import org.eclipse.jface.viewers.Viewer;
055:
056: import org.eclipse.jdt.internal.corext.util.Messages;
057:
058: import org.eclipse.jdt.ui.PreferenceConstants;
059:
060: import org.eclipse.jdt.internal.ui.JavaPlugin;
061: import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
062: import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
063: import org.eclipse.jdt.internal.ui.text.java.hover.JavaEditorTextHoverDescriptor;
064: import org.eclipse.jdt.internal.ui.util.PixelConverter;
065: import org.eclipse.jdt.internal.ui.util.SWTUtil;
066: import org.eclipse.jdt.internal.ui.util.TableLayoutComposite;
067:
068: /**
069: * Configures Java Editor hover preferences.
070: *
071: * @since 2.1
072: */
073: class JavaEditorHoverConfigurationBlock implements
074: IPreferenceConfigurationBlock {
075:
076: private static final String DELIMITER = PreferencesMessages.JavaEditorHoverConfigurationBlock_delimiter;
077:
078: private static final int ENABLED_PROP = 0;
079: private static final int MODIFIER_PROP = 1;
080:
081: // Data structure to hold the values which are edited by the user
082: private static class HoverConfig {
083:
084: private String fModifierString;
085: private boolean fIsEnabled;
086: private int fStateMask;
087:
088: private HoverConfig(String modifier, int stateMask,
089: boolean enabled) {
090: fModifierString = modifier;
091: fIsEnabled = enabled;
092: fStateMask = stateMask;
093: }
094: }
095:
096: private class JavaEditorTextHoverDescriptorLabelProvider implements
097: ITableLabelProvider {
098:
099: public Image getColumnImage(Object element, int columnIndex) {
100: return null;
101: }
102:
103: public String getColumnText(Object element, int columnIndex) {
104: switch (columnIndex) {
105: case ENABLED_PROP:
106: return ((JavaEditorTextHoverDescriptor) element)
107: .getLabel();
108:
109: case MODIFIER_PROP:
110: TableItem item = (TableItem) fHoverTableViewer
111: .testFindItem(element);
112: int index = fHoverTable.indexOf(item);
113: return fHoverConfigs[index].fModifierString;
114:
115: default:
116: break;
117: }
118:
119: return null;
120: }
121:
122: public void addListener(ILabelProviderListener listener) {
123: }
124:
125: public void dispose() {
126: }
127:
128: public boolean isLabelProperty(Object element, String property) {
129: return false;
130: }
131:
132: public void removeListener(ILabelProviderListener listener) {
133: }
134: }
135:
136: private class JavaEditorTextHoverDescriptorContentProvider
137: implements IStructuredContentProvider {
138:
139: public void inputChanged(Viewer viewer, Object oldInput,
140: Object newInput) {
141: // Do nothing since the viewer listens to resource deltas
142: }
143:
144: public void dispose() {
145: }
146:
147: public boolean isDeleted(Object element) {
148: return false;
149: }
150:
151: public Object[] getElements(Object element) {
152: return (Object[]) element;
153: }
154: }
155:
156: private OverlayPreferenceStore fStore;
157: private HoverConfig[] fHoverConfigs;
158: private Text fModifierEditor;
159: private Table fHoverTable;
160: private TableViewer fHoverTableViewer;
161: private TableColumn fNameColumn;
162: private TableColumn fModifierColumn;
163: private Text fDescription;
164:
165: private PreferencePage fMainPreferencePage;
166:
167: private StatusInfo fStatus;
168:
169: private Map fCheckBoxes = new HashMap();
170: private SelectionListener fCheckBoxListener = new SelectionListener() {
171: public void widgetDefaultSelected(SelectionEvent e) {
172: Button button = (Button) e.widget;
173: fStore.setValue((String) fCheckBoxes.get(button), button
174: .getSelection());
175: }
176:
177: public void widgetSelected(SelectionEvent e) {
178: Button button = (Button) e.widget;
179: fStore.setValue((String) fCheckBoxes.get(button), button
180: .getSelection());
181: }
182: };
183:
184: public JavaEditorHoverConfigurationBlock(
185: PreferencePage mainPreferencePage,
186: OverlayPreferenceStore store) {
187: Assert.isNotNull(mainPreferencePage);
188: Assert.isNotNull(store);
189: fMainPreferencePage = mainPreferencePage;
190: fStore = store;
191: fStore.addKeys(createOverlayStoreKeys());
192: }
193:
194: private OverlayPreferenceStore.OverlayKey[] createOverlayStoreKeys() {
195:
196: ArrayList overlayKeys = new ArrayList();
197:
198: overlayKeys.add(new OverlayPreferenceStore.OverlayKey(
199: OverlayPreferenceStore.BOOLEAN,
200: PreferenceConstants.EDITOR_ANNOTATION_ROLL_OVER));
201:
202: overlayKeys.add(new OverlayPreferenceStore.OverlayKey(
203: OverlayPreferenceStore.STRING,
204: PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIERS));
205: overlayKeys.add(new OverlayPreferenceStore.OverlayKey(
206: OverlayPreferenceStore.STRING,
207: PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIER_MASKS));
208:
209: OverlayPreferenceStore.OverlayKey[] keys = new OverlayPreferenceStore.OverlayKey[overlayKeys
210: .size()];
211: overlayKeys.toArray(keys);
212: return keys;
213: }
214:
215: /**
216: * Creates page for hover preferences.
217: *
218: * @param parent the parent composite
219: * @return the control for the preference page
220: */
221: public Control createControl(Composite parent) {
222:
223: ScrolledPageContent scrolled = new ScrolledPageContent(parent,
224: SWT.H_SCROLL | SWT.V_SCROLL);
225: scrolled.setExpandHorizontal(true);
226: scrolled.setExpandVertical(true);
227:
228: Composite hoverComposite = new Composite(scrolled, SWT.NONE);
229: GridLayout layout = new GridLayout();
230: layout.numColumns = 2;
231: layout.marginWidth = 0;
232: layout.marginHeight = 0;
233: hoverComposite.setLayout(layout);
234:
235: String rollOverLabel = PreferencesMessages.JavaEditorHoverConfigurationBlock_annotationRollover;
236: addCheckBox(hoverComposite, rollOverLabel,
237: PreferenceConstants.EDITOR_ANNOTATION_ROLL_OVER, 0);
238:
239: addFiller(hoverComposite);
240:
241: Label label = new Label(hoverComposite, SWT.NONE);
242: label
243: .setText(PreferencesMessages.JavaEditorHoverConfigurationBlock_hoverPreferences);
244: GridData gd = new GridData(GridData.FILL_HORIZONTAL);
245: gd.horizontalAlignment = GridData.BEGINNING;
246: gd.horizontalSpan = 2;
247: label.setLayoutData(gd);
248:
249: TableLayoutComposite layouter = new TableLayoutComposite(
250: hoverComposite, SWT.NONE);
251: addColumnLayoutData(layouter);
252:
253: // Hover table
254: fHoverTable = new Table(layouter, SWT.H_SCROLL | SWT.V_SCROLL
255: | SWT.SINGLE | SWT.BORDER | SWT.FULL_SELECTION
256: | SWT.CHECK);
257: fHoverTable.setHeaderVisible(true);
258: fHoverTable.setLinesVisible(true);
259:
260: gd = new GridData(GridData.FILL_HORIZONTAL);
261: gd.heightHint = SWTUtil.getTableHeightHint(fHoverTable, 10);
262: gd.horizontalSpan = 2;
263: gd.widthHint = new PixelConverter(parent)
264: .convertWidthInCharsToPixels(30);
265: layouter.setLayoutData(gd);
266:
267: fHoverTable.addSelectionListener(new SelectionListener() {
268: public void widgetSelected(SelectionEvent e) {
269: handleHoverListSelection();
270: }
271:
272: public void widgetDefaultSelected(SelectionEvent e) {
273: }
274: });
275:
276: TableLayout tableLayout = new TableLayout();
277: fHoverTable.setLayout(tableLayout);
278:
279: fNameColumn = new TableColumn(fHoverTable, SWT.NONE);
280: fNameColumn
281: .setText(PreferencesMessages.JavaEditorHoverConfigurationBlock_nameColumnTitle);
282: fNameColumn.setResizable(true);
283:
284: fModifierColumn = new TableColumn(fHoverTable, SWT.NONE);
285: fModifierColumn
286: .setText(PreferencesMessages.JavaEditorHoverConfigurationBlock_modifierColumnTitle);
287: fModifierColumn.setResizable(true);
288:
289: fHoverTableViewer = new CheckboxTableViewer(fHoverTable);
290: fHoverTableViewer.setUseHashlookup(true);
291: fHoverTableViewer
292: .setContentProvider(new JavaEditorTextHoverDescriptorContentProvider());
293: fHoverTableViewer
294: .setLabelProvider(new JavaEditorTextHoverDescriptorLabelProvider());
295:
296: ((CheckboxTableViewer) fHoverTableViewer)
297: .addCheckStateListener(new ICheckStateListener() {
298: /*
299: * @see org.eclipse.jface.viewers.ICheckStateListener#checkStateChanged(org.eclipse.jface.viewers.CheckStateChangedEvent)
300: */
301: public void checkStateChanged(
302: CheckStateChangedEvent event) {
303: String id = ((JavaEditorTextHoverDescriptor) event
304: .getElement()).getId();
305: if (id == null)
306: return;
307: JavaEditorTextHoverDescriptor[] descriptors = getContributedHovers();
308: HoverConfig hoverConfig = null;
309: int i = 0, length = fHoverConfigs.length;
310: while (i < length) {
311: if (id.equals(descriptors[i].getId())) {
312: hoverConfig = fHoverConfigs[i];
313: hoverConfig.fIsEnabled = event
314: .getChecked();
315: fModifierEditor.setEnabled(event
316: .getChecked());
317: fHoverTableViewer
318: .setSelection(new StructuredSelection(
319: descriptors[i]));
320: }
321: i++;
322: }
323: handleHoverListSelection();
324: updateStatus(hoverConfig);
325: }
326: });
327:
328: // Text field for modifier string
329: label = new Label(hoverComposite, SWT.LEFT);
330: label
331: .setText(PreferencesMessages.JavaEditorHoverConfigurationBlock_keyModifier);
332: fModifierEditor = new Text(hoverComposite, SWT.BORDER);
333: gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
334: fModifierEditor.setLayoutData(gd);
335:
336: fModifierEditor.addKeyListener(new KeyListener() {
337: private boolean isModifierCandidate;
338:
339: public void keyPressed(KeyEvent e) {
340: isModifierCandidate = e.keyCode > 0 && e.character == 0
341: && e.stateMask == 0;
342: }
343:
344: public void keyReleased(KeyEvent e) {
345: if (isModifierCandidate && e.stateMask > 0
346: && e.stateMask == e.stateMask
347: && e.character == 0) {// && e.time -time < 1000) {
348: String text = fModifierEditor.getText();
349: Point selection = fModifierEditor.getSelection();
350: int i = selection.x - 1;
351: while (i > -1
352: && Character.isWhitespace(text.charAt(i))) {
353: i--;
354: }
355: boolean needsPrefixDelimiter = i > -1
356: && !String.valueOf(text.charAt(i)).equals(
357: DELIMITER);
358:
359: i = selection.y;
360: while (i < text.length()
361: && Character.isWhitespace(text.charAt(i))) {
362: i++;
363: }
364: boolean needsPostfixDelimiter = i < text.length()
365: && !String.valueOf(text.charAt(i)).equals(
366: DELIMITER);
367:
368: String insertString;
369:
370: if (needsPrefixDelimiter && needsPostfixDelimiter)
371: insertString = Messages
372: .format(
373: PreferencesMessages.JavaEditorHoverConfigurationBlock_insertDelimiterAndModifierAndDelimiter,
374: new String[] { Action
375: .findModifierString(e.stateMask) });
376: else if (needsPrefixDelimiter)
377: insertString = Messages
378: .format(
379: PreferencesMessages.JavaEditorHoverConfigurationBlock_insertDelimiterAndModifier,
380: new String[] { Action
381: .findModifierString(e.stateMask) });
382: else if (needsPostfixDelimiter)
383: insertString = Messages
384: .format(
385: PreferencesMessages.JavaEditorHoverConfigurationBlock_insertModifierAndDelimiter,
386: new String[] { Action
387: .findModifierString(e.stateMask) });
388: else
389: insertString = Action
390: .findModifierString(e.stateMask);
391:
392: if (insertString != null)
393: fModifierEditor.insert(insertString);
394: }
395: }
396: });
397:
398: fModifierEditor.addModifyListener(new ModifyListener() {
399: public void modifyText(ModifyEvent e) {
400: handleModifierModified();
401: }
402: });
403:
404: // Description
405: Label descriptionLabel = new Label(hoverComposite, SWT.LEFT);
406: descriptionLabel
407: .setText(PreferencesMessages.JavaEditorHoverConfigurationBlock_description);
408: gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING);
409: gd.horizontalSpan = 2;
410: descriptionLabel.setLayoutData(gd);
411: fDescription = new Text(hoverComposite, SWT.LEFT | SWT.WRAP
412: | SWT.MULTI | SWT.READ_ONLY | SWT.BORDER);
413: gd = new GridData(GridData.FILL_BOTH);
414: gd.horizontalSpan = 2;
415: fDescription.setLayoutData(gd);
416:
417: initialize();
418:
419: scrolled.setContent(hoverComposite);
420: final Point size = hoverComposite.computeSize(SWT.DEFAULT,
421: SWT.DEFAULT);
422: scrolled.setMinSize(size.x, size.y);
423:
424: Dialog.applyDialogFont(scrolled);
425:
426: return scrolled;
427:
428: }
429:
430: private void addColumnLayoutData(TableLayoutComposite layouter) {
431: layouter.addColumnData(new ColumnWeightData(40, true));
432: layouter.addColumnData(new ColumnWeightData(60, true));
433: }
434:
435: private JavaEditorTextHoverDescriptor[] getContributedHovers() {
436: return JavaPlugin.getDefault()
437: .getJavaEditorTextHoverDescriptors();
438: }
439:
440: public void initialize() {
441: JavaEditorTextHoverDescriptor[] hoverDescs = getContributedHovers();
442: fHoverConfigs = new HoverConfig[hoverDescs.length];
443: for (int i = 0; i < hoverDescs.length; i++)
444: fHoverConfigs[i] = new HoverConfig(hoverDescs[i]
445: .getModifierString(), hoverDescs[i].getStateMask(),
446: hoverDescs[i].isEnabled());
447:
448: fHoverTableViewer.setInput(hoverDescs);
449:
450: initializeFields();
451: }
452:
453: void initializeFields() {
454: fModifierEditor.setEnabled(false);
455:
456: Iterator e = fCheckBoxes.keySet().iterator();
457: while (e.hasNext()) {
458: Button b = (Button) e.next();
459: String key = (String) fCheckBoxes.get(b);
460: b.setSelection(fStore.getBoolean(key));
461: }
462:
463: for (int i = 0; i < fHoverConfigs.length; i++)
464: fHoverTable.getItem(i).setChecked(
465: fHoverConfigs[i].fIsEnabled);
466: fHoverTableViewer.refresh();
467: }
468:
469: public void performOk() {
470: StringBuffer buf = new StringBuffer();
471: StringBuffer maskBuf = new StringBuffer();
472: for (int i = 0; i < fHoverConfigs.length; i++) {
473: buf.append(getContributedHovers()[i].getId());
474: buf.append(JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
475: if (!fHoverConfigs[i].fIsEnabled)
476: buf.append(JavaEditorTextHoverDescriptor.DISABLED_TAG);
477: String modifier = fHoverConfigs[i].fModifierString;
478: if (modifier == null || modifier.length() == 0)
479: modifier = JavaEditorTextHoverDescriptor.NO_MODIFIER;
480: buf.append(modifier);
481: buf.append(JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
482:
483: maskBuf.append(getContributedHovers()[i].getId());
484: maskBuf
485: .append(JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
486: maskBuf.append(fHoverConfigs[i].fStateMask);
487: maskBuf
488: .append(JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
489: }
490: fStore.setValue(
491: PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIERS, buf
492: .toString());
493: fStore.setValue(
494: PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIER_MASKS,
495: maskBuf.toString());
496:
497: JavaPlugin.getDefault().resetJavaEditorTextHoverDescriptors();
498: }
499:
500: public void performDefaults() {
501: restoreFromPreferences();
502: initializeFields();
503: updateStatus(null);
504: }
505:
506: private void restoreFromPreferences() {
507: String compiledTextHoverModifiers = fStore
508: .getString(PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIERS);
509:
510: StringTokenizer tokenizer = new StringTokenizer(
511: compiledTextHoverModifiers,
512: JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
513: HashMap idToModifier = new HashMap(tokenizer.countTokens() / 2);
514:
515: while (tokenizer.hasMoreTokens()) {
516: String id = tokenizer.nextToken();
517: if (tokenizer.hasMoreTokens())
518: idToModifier.put(id, tokenizer.nextToken());
519: }
520:
521: String compiledTextHoverModifierMasks = JavaPlugin
522: .getDefault()
523: .getPreferenceStore()
524: .getString(
525: PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIER_MASKS);
526:
527: tokenizer = new StringTokenizer(compiledTextHoverModifierMasks,
528: JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
529: HashMap idToModifierMask = new HashMap(
530: tokenizer.countTokens() / 2);
531:
532: while (tokenizer.hasMoreTokens()) {
533: String id = tokenizer.nextToken();
534: if (tokenizer.hasMoreTokens())
535: idToModifierMask.put(id, tokenizer.nextToken());
536: }
537:
538: for (int i = 0; i < fHoverConfigs.length; i++) {
539: String modifierString = (String) idToModifier
540: .get(getContributedHovers()[i].getId());
541: boolean enabled = true;
542: if (modifierString == null)
543: modifierString = JavaEditorTextHoverDescriptor.DISABLED_TAG;
544:
545: if (modifierString
546: .startsWith(JavaEditorTextHoverDescriptor.DISABLED_TAG)) {
547: enabled = false;
548: modifierString = modifierString.substring(1);
549: }
550:
551: if (modifierString
552: .equals(JavaEditorTextHoverDescriptor.NO_MODIFIER))
553: modifierString = ""; //$NON-NLS-1$
554:
555: fHoverConfigs[i].fModifierString = modifierString;
556: fHoverConfigs[i].fIsEnabled = enabled;
557: fHoverConfigs[i].fStateMask = JavaEditorTextHoverDescriptor
558: .computeStateMask(modifierString);
559:
560: if (fHoverConfigs[i].fStateMask == -1) {
561: try {
562: fHoverConfigs[i].fStateMask = Integer
563: .parseInt((String) idToModifierMask
564: .get(getContributedHovers()[i]
565: .getId()));
566: } catch (NumberFormatException ex) {
567: fHoverConfigs[i].fStateMask = -1;
568: }
569: }
570: }
571: }
572:
573: private void handleModifierModified() {
574: int i = fHoverTable.getSelectionIndex();
575: if (i == -1)
576: return;
577:
578: String modifiers = fModifierEditor.getText();
579: fHoverConfigs[i].fModifierString = modifiers;
580: fHoverConfigs[i].fStateMask = JavaEditorTextHoverDescriptor
581: .computeStateMask(modifiers);
582:
583: // update table
584: fHoverTableViewer.refresh(getContributedHovers()[i]);
585:
586: updateStatus(fHoverConfigs[i]);
587: }
588:
589: private void handleHoverListSelection() {
590: int i = fHoverTable.getSelectionIndex();
591:
592: if (i == -1) {
593: if (fHoverTable.getSelectionCount() == 0)
594: fModifierEditor.setEnabled(false);
595: return;
596: }
597:
598: boolean enabled = fHoverConfigs[i].fIsEnabled;
599: fModifierEditor.setEnabled(enabled);
600: fModifierEditor.setText(fHoverConfigs[i].fModifierString);
601: String description = getContributedHovers()[i].getDescription();
602: if (description == null)
603: description = ""; //$NON-NLS-1$
604: fDescription.setText(description);
605: }
606:
607: IStatus getStatus() {
608: if (fStatus == null)
609: fStatus = new StatusInfo();
610: return fStatus;
611: }
612:
613: private void updateStatus(HoverConfig hoverConfig) {
614: if (hoverConfig != null && hoverConfig.fIsEnabled
615: && hoverConfig.fStateMask == -1)
616: fStatus = new StatusInfo(
617: IStatus.ERROR,
618: Messages
619: .format(
620: PreferencesMessages.JavaEditorHoverConfigurationBlock_modifierIsNotValid,
621: hoverConfig.fModifierString));
622: else
623: fStatus = new StatusInfo();
624:
625: int i = 0;
626: HashMap stateMasks = new HashMap(fHoverConfigs.length);
627: while (fStatus.isOK() && i < fHoverConfigs.length) {
628: if (fHoverConfigs[i].fIsEnabled) {
629: String label = getContributedHovers()[i].getLabel();
630: Integer stateMask = new Integer(
631: fHoverConfigs[i].fStateMask);
632: if (fHoverConfigs[i].fStateMask == -1)
633: fStatus = new StatusInfo(
634: IStatus.ERROR,
635: Messages
636: .format(
637: PreferencesMessages.JavaEditorHoverConfigurationBlock_modifierIsNotValidForHover,
638: new String[] {
639: fHoverConfigs[i].fModifierString,
640: label }));
641: else if (stateMasks.containsKey(stateMask))
642: fStatus = new StatusInfo(
643: IStatus.ERROR,
644: Messages
645: .format(
646: PreferencesMessages.JavaEditorHoverConfigurationBlock_duplicateModifier,
647: new String[] {
648: label,
649: (String) stateMasks
650: .get(stateMask) }));
651: else
652: stateMasks.put(stateMask, label);
653: }
654: i++;
655: }
656:
657: fMainPreferencePage.setValid(fStatus.isOK());
658: StatusUtil.applyToStatusLine(fMainPreferencePage, fStatus);
659: }
660:
661: private Button addCheckBox(Composite parent, String label,
662: String key, int indentation) {
663: Button checkBox = new Button(parent, SWT.CHECK);
664: checkBox.setText(label);
665:
666: GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
667: gd.horizontalIndent = indentation;
668: gd.horizontalSpan = 2;
669: checkBox.setLayoutData(gd);
670: checkBox.addSelectionListener(fCheckBoxListener);
671:
672: fCheckBoxes.put(checkBox, key);
673:
674: return checkBox;
675: }
676:
677: private void addFiller(Composite composite) {
678: PixelConverter pixelConverter = new PixelConverter(composite);
679: Label filler = new Label(composite, SWT.LEFT);
680: GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
681: gd.horizontalSpan = 2;
682: gd.heightHint = pixelConverter.convertHeightInCharsToPixels(1) / 2;
683: filler.setLayoutData(gd);
684: }
685:
686: /*
687: * @see DialogPage#dispose()
688: */
689: public void dispose() {
690: // nothing to dispose
691: }
692: }
|