001: /*******************************************************************************
002: * Copyright (c) 2005, 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.Collections;
014: import java.util.Comparator;
015: import java.util.HashMap;
016: import java.util.Iterator;
017: import java.util.List;
018: import java.util.Map;
019:
020: import org.eclipse.core.commands.Command;
021: import org.eclipse.core.commands.CommandManager;
022: import org.eclipse.core.commands.IParameter;
023: import org.eclipse.core.commands.Parameterization;
024: import org.eclipse.core.commands.ParameterizedCommand;
025: import org.eclipse.core.commands.common.NotDefinedException;
026: import org.eclipse.core.commands.contexts.ContextManager;
027:
028: import org.eclipse.core.runtime.Assert;
029:
030: import org.eclipse.swt.SWT;
031: import org.eclipse.swt.events.SelectionAdapter;
032: import org.eclipse.swt.events.SelectionEvent;
033: import org.eclipse.swt.graphics.GC;
034: import org.eclipse.swt.graphics.Image;
035: import org.eclipse.swt.layout.GridData;
036: import org.eclipse.swt.layout.GridLayout;
037: import org.eclipse.swt.widgets.Button;
038: import org.eclipse.swt.widgets.Composite;
039: import org.eclipse.swt.widgets.Control;
040: import org.eclipse.swt.widgets.Label;
041: import org.eclipse.swt.widgets.Link;
042: import org.eclipse.swt.widgets.Table;
043: import org.eclipse.swt.widgets.TableColumn;
044:
045: import org.eclipse.jface.bindings.BindingManager;
046: import org.eclipse.jface.bindings.Scheme;
047: import org.eclipse.jface.bindings.TriggerSequence;
048: import org.eclipse.jface.resource.ImageDescriptor;
049: import org.eclipse.jface.resource.JFaceResources;
050: import org.eclipse.jface.viewers.ArrayContentProvider;
051: import org.eclipse.jface.viewers.CheckStateChangedEvent;
052: import org.eclipse.jface.viewers.CheckboxTableViewer;
053: import org.eclipse.jface.viewers.ICheckStateListener;
054: import org.eclipse.jface.viewers.IStructuredSelection;
055: import org.eclipse.jface.viewers.ITableLabelProvider;
056: import org.eclipse.jface.viewers.LabelProvider;
057: import org.eclipse.jface.viewers.ViewerComparator;
058:
059: import org.eclipse.ui.PlatformUI;
060: import org.eclipse.ui.commands.ICommandService;
061: import org.eclipse.ui.dialogs.PreferencesUtil;
062: import org.eclipse.ui.keys.IBindingService;
063: import org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;
064: import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
065:
066: import org.eclipse.jdt.core.JavaCore;
067:
068: import org.eclipse.jdt.internal.corext.util.Messages;
069:
070: import org.eclipse.jdt.ui.PreferenceConstants;
071:
072: import org.eclipse.jdt.internal.ui.JavaPlugin;
073: import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
074: import org.eclipse.jdt.internal.ui.text.java.CompletionProposalCategory;
075: import org.eclipse.jdt.internal.ui.text.java.CompletionProposalComputerRegistry;
076: import org.eclipse.jdt.internal.ui.util.PixelConverter;
077: import org.eclipse.jdt.internal.ui.util.SWTUtil;
078: import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
079:
080: /**
081: *
082: * @since 3.2
083: */
084: final class CodeAssistAdvancedConfigurationBlock extends
085: OptionsConfigurationBlock {
086:
087: private static final Key PREF_EXCLUDED_CATEGORIES = getJDTUIKey(PreferenceConstants.CODEASSIST_EXCLUDED_CATEGORIES);
088: private static final Key PREF_CATEGORY_ORDER = getJDTUIKey(PreferenceConstants.CODEASSIST_CATEGORY_ORDER);
089: private static final Key PREF_CODEASSIST_TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC = getJDTCoreKey(JavaCore.TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC);
090:
091: private static Key[] getAllKeys() {
092: return new Key[] { PREF_EXCLUDED_CATEGORIES,
093: PREF_CATEGORY_ORDER,
094: PREF_CODEASSIST_TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC };
095: }
096:
097: private final class DefaultTableLabelProvider extends LabelProvider
098: implements ITableLabelProvider {
099:
100: /*
101: * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object, int)
102: */
103: public Image getColumnImage(Object element, int columnIndex) {
104: if (columnIndex == 0)
105: return ((ModelElement) element).getImage();
106: return null;
107: }
108:
109: /*
110: * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object, int)
111: */
112: public String getColumnText(Object element, int columnIndex) {
113: switch (columnIndex) {
114: case 0:
115: return ((ModelElement) element).getName();
116: case 1:
117: return ((ModelElement) element).getKeybindingAsString();
118: default:
119: Assert.isTrue(false);
120: return null;
121: }
122: }
123:
124: /*
125: * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
126: */
127: public String getText(Object element) {
128: return getColumnText(element, 0); // needed to make the sorter work
129: }
130: }
131:
132: private final class SeparateTableLabelProvider extends
133: LabelProvider implements ITableLabelProvider {
134:
135: /*
136: * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object, int)
137: */
138: public Image getColumnImage(Object element, int columnIndex) {
139: if (columnIndex == 0)
140: return ((ModelElement) element).getImage();
141: return null;
142: }
143:
144: /*
145: * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object, int)
146: */
147: public String getColumnText(Object element, int columnIndex) {
148: switch (columnIndex) {
149: case 0:
150: return ((ModelElement) element).getName();
151: default:
152: Assert.isTrue(false);
153: return null;
154: }
155: }
156: }
157:
158: private final Comparator fCategoryComparator = new Comparator() {
159: private int getRank(Object o) {
160: return ((ModelElement) o).getRank();
161: }
162:
163: public int compare(Object o1, Object o2) {
164: return getRank(o1) - getRank(o2);
165: }
166: };
167:
168: private final class PreferenceModel {
169: private static final int LIMIT = 65535;
170: private static final String COLON = ":"; //$NON-NLS-1$
171: private static final String SEPARATOR = "\0"; //$NON-NLS-1$
172:
173: private final List fElements;
174: /**
175: * The read-only list of elements.
176: */
177: final List elements;
178:
179: public PreferenceModel(
180: CompletionProposalComputerRegistry registry) {
181: List categories = registry.getProposalCategories();
182: fElements = new ArrayList();
183: for (Iterator it = categories.iterator(); it.hasNext();) {
184: CompletionProposalCategory category = (CompletionProposalCategory) it
185: .next();
186: if (category.hasComputers()) {
187: fElements.add(new ModelElement(category, this ));
188: }
189: }
190: Collections.sort(fElements, fCategoryComparator);
191: elements = Collections.unmodifiableList(fElements);
192: }
193:
194: public void moveUp(ModelElement category) {
195: int index = fElements.indexOf(category);
196: if (index > 0) {
197: Object item = fElements.remove(index);
198: fElements.add(index - 1, item);
199: writeOrderPreference(null, false);
200: }
201: }
202:
203: public void moveDown(ModelElement category) {
204: int index = fElements.indexOf(category);
205: if (index < fElements.size() - 1) {
206: Object item = fElements.remove(index);
207: fElements.add(index + 1, item);
208: writeOrderPreference(null, false);
209: }
210: }
211:
212: private void writeInclusionPreference(ModelElement changed,
213: boolean isInDefaultCategory) {
214: StringBuffer buf = new StringBuffer();
215: for (Iterator it = fElements.iterator(); it.hasNext();) {
216: ModelElement item = (ModelElement) it.next();
217: boolean included = changed == item ? isInDefaultCategory
218: : item.isInDefaultCategory();
219: if (!included)
220: buf.append(item.getId() + SEPARATOR);
221: }
222:
223: String newValue = buf.toString();
224: String oldValue = setValue(PREF_EXCLUDED_CATEGORIES,
225: newValue);
226: validateSettings(PREF_EXCLUDED_CATEGORIES, oldValue,
227: newValue);
228: }
229:
230: private void writeOrderPreference(ModelElement changed,
231: boolean isSeparate) {
232: StringBuffer buf = new StringBuffer();
233: int i = 0;
234: for (Iterator it = fElements.iterator(); it.hasNext(); i++) {
235: ModelElement item = (ModelElement) it.next();
236: boolean separate = changed == item ? isSeparate : item
237: .isSeparateCommand();
238: int rank = separate ? i : i + LIMIT;
239: buf.append(item.getId() + COLON + rank + SEPARATOR);
240: }
241:
242: String newValue = buf.toString();
243: String oldValue = setValue(PREF_CATEGORY_ORDER, newValue);
244: validateSettings(PREF_CATEGORY_ORDER, oldValue, newValue);
245: }
246:
247: private boolean readInclusionPreference(
248: CompletionProposalCategory cat) {
249: String[] ids = getTokens(
250: getValue(PREF_EXCLUDED_CATEGORIES), SEPARATOR);
251: for (int i = 0; i < ids.length; i++) {
252: if (ids[i].equals(cat.getId()))
253: return false;
254: }
255: return true;
256: }
257:
258: private int readOrderPreference(CompletionProposalCategory cat) {
259: String[] sortOrderIds = getTokens(
260: getValue(PREF_CATEGORY_ORDER), SEPARATOR);
261: for (int i = 0; i < sortOrderIds.length; i++) {
262: String[] idAndRank = getTokens(sortOrderIds[i], COLON);
263: if (idAndRank[0].equals(cat.getId()))
264: return Integer.parseInt(idAndRank[1]);
265: }
266: return LIMIT + 1;
267: }
268:
269: public void update() {
270: Collections.sort(fElements, fCategoryComparator);
271: }
272: }
273:
274: private final class ModelElement {
275: private final CompletionProposalCategory fCategory;
276: private final Command fCommand;
277: private final IParameter fParam;
278: private final PreferenceModel fPreferenceModel;
279:
280: ModelElement(CompletionProposalCategory category,
281: PreferenceModel model) {
282: fCategory = category;
283: ICommandService commandSvc = (ICommandService) PlatformUI
284: .getWorkbench().getAdapter(ICommandService.class);
285: fCommand = commandSvc
286: .getCommand("org.eclipse.jdt.ui.specific_content_assist.command"); //$NON-NLS-1$
287: IParameter type;
288: try {
289: type = fCommand.getParameters()[0];
290: } catch (NotDefinedException x) {
291: Assert.isTrue(false);
292: type = null;
293: }
294: fParam = type;
295: fPreferenceModel = model;
296: }
297:
298: Image getImage() {
299: return CodeAssistAdvancedConfigurationBlock.this
300: .getImage(fCategory.getImageDescriptor());
301: }
302:
303: String getName() {
304: return fCategory.getDisplayName();
305: }
306:
307: String getKeybindingAsString() {
308: final Parameterization[] params = { new Parameterization(
309: fParam, fCategory.getId()) };
310: final ParameterizedCommand pCmd = new ParameterizedCommand(
311: fCommand, params);
312: String key = getKeyboardShortcut(pCmd);
313: return key;
314: }
315:
316: boolean isInDefaultCategory() {
317: return fPreferenceModel.readInclusionPreference(fCategory);
318: }
319:
320: void setInDefaultCategory(boolean included) {
321: if (included != isInDefaultCategory())
322: fPreferenceModel.writeInclusionPreference(this ,
323: included);
324: }
325:
326: String getId() {
327: return fCategory.getId();
328: }
329:
330: int getRank() {
331: int rank = getInternalRank();
332: if (rank > PreferenceModel.LIMIT)
333: return rank - PreferenceModel.LIMIT;
334: return rank;
335: }
336:
337: void moveUp() {
338: fPreferenceModel.moveUp(this );
339: }
340:
341: void moveDown() {
342: fPreferenceModel.moveDown(this );
343: }
344:
345: private int getInternalRank() {
346: return fPreferenceModel.readOrderPreference(fCategory);
347: }
348:
349: boolean isSeparateCommand() {
350: return getInternalRank() < PreferenceModel.LIMIT;
351: }
352:
353: void setSeparateCommand(boolean separate) {
354: if (separate != isSeparateCommand())
355: fPreferenceModel.writeOrderPreference(this , separate);
356: }
357:
358: void update() {
359: fCategory.setIncluded(isInDefaultCategory());
360: int rank = getInternalRank();
361: fCategory.setSortOrder(rank);
362: fCategory.setSeparateCommand(rank < PreferenceModel.LIMIT);
363: }
364: }
365:
366: /** element type: {@link ModelElement}. */
367: private final PreferenceModel fModel;
368: private final Map fImages = new HashMap();
369:
370: private CheckboxTableViewer fDefaultViewer;
371: private CheckboxTableViewer fSeparateViewer;
372: private Button fUpButton;
373: private Button fDownButton;
374:
375: CodeAssistAdvancedConfigurationBlock(
376: IStatusChangeListener statusListener,
377: IWorkbenchPreferenceContainer container) {
378: super (statusListener, null, getAllKeys(), container);
379: fModel = new PreferenceModel(CompletionProposalComputerRegistry
380: .getDefault());
381: }
382:
383: /*
384: * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#createContents(org.eclipse.swt.widgets.Composite)
385: */
386: protected Control createContents(Composite parent) {
387:
388: ScrolledPageContent scrolled = new ScrolledPageContent(parent,
389: SWT.H_SCROLL | SWT.V_SCROLL);
390:
391: scrolled.setExpandHorizontal(true);
392: scrolled.setExpandVertical(true);
393:
394: Composite composite = new Composite(scrolled, SWT.NONE);
395: int columns = 2;
396: GridLayout layout = new GridLayout(columns, false);
397: layout.marginWidth = 0;
398: layout.marginHeight = 0;
399: composite.setLayout(layout);
400:
401: createDefaultLabel(composite, columns);
402: createDefaultViewer(composite, columns);
403: createKeysLink(composite, columns);
404:
405: createFiller(composite, columns);
406:
407: createSeparateLabel(composite, columns);
408: createSeparateSection(composite);
409:
410: createFiller(composite, columns);
411:
412: createParameterTimeoutControl(composite, columns);
413:
414: updateControls();
415: if (fModel.elements.size() > 0) {
416: fDefaultViewer.getTable().select(0);
417: fSeparateViewer.getTable().select(0);
418: handleTableSelection();
419: }
420:
421: scrolled.setContent(composite);
422: scrolled.setMinSize(composite.computeSize(SWT.DEFAULT,
423: SWT.DEFAULT));
424: return scrolled;
425: }
426:
427: private void createDefaultLabel(Composite composite, int h_span) {
428: final ICommandService commandSvc = (ICommandService) PlatformUI
429: .getWorkbench().getAdapter(ICommandService.class);
430: final Command command = commandSvc
431: .getCommand(ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
432: ParameterizedCommand pCmd = new ParameterizedCommand(command,
433: null);
434: String key = getKeyboardShortcut(pCmd);
435: if (key == null)
436: key = PreferencesMessages.CodeAssistAdvancedConfigurationBlock_no_shortcut;
437:
438: PixelConverter pixelConverter = new PixelConverter(composite);
439: int width = pixelConverter.convertWidthInCharsToPixels(40);
440:
441: Label label = new Label(composite, SWT.NONE | SWT.WRAP);
442: label
443: .setText(Messages
444: .format(
445: PreferencesMessages.CodeAssistAdvancedConfigurationBlock_page_description,
446: new Object[] { key }));
447: GridData gd = new GridData(GridData.FILL, GridData.FILL, true,
448: false, h_span, 1);
449: gd.widthHint = width;
450: label.setLayoutData(gd);
451:
452: createFiller(composite, h_span);
453:
454: label = new Label(composite, SWT.NONE | SWT.WRAP);
455: label
456: .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_default_table_description);
457: gd = new GridData(GridData.FILL, GridData.FILL, true, false,
458: h_span, 1);
459: gd.widthHint = width;
460: label.setLayoutData(gd);
461: }
462:
463: private void createDefaultViewer(Composite composite, int h_span) {
464: fDefaultViewer = CheckboxTableViewer.newCheckList(composite,
465: SWT.SINGLE | SWT.BORDER);
466: Table table = fDefaultViewer.getTable();
467: table.setHeaderVisible(true);
468: table.setLinesVisible(false);
469: table.setLayoutData(new GridData(GridData.FILL,
470: GridData.BEGINNING, false, false, h_span, 1));
471:
472: TableColumn nameColumn = new TableColumn(table, SWT.NONE);
473: nameColumn
474: .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_default_table_category_column_title);
475: nameColumn.setResizable(false);
476: TableColumn keyColumn = new TableColumn(table, SWT.NONE);
477: keyColumn
478: .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_default_table_keybinding_column_title);
479: keyColumn.setResizable(false);
480:
481: fDefaultViewer.addCheckStateListener(new ICheckStateListener() {
482: public void checkStateChanged(CheckStateChangedEvent event) {
483: boolean checked = event.getChecked();
484: ModelElement element = (ModelElement) event
485: .getElement();
486: element.setInDefaultCategory(checked);
487: }
488: });
489:
490: fDefaultViewer.setContentProvider(new ArrayContentProvider());
491:
492: DefaultTableLabelProvider labelProvider = new DefaultTableLabelProvider();
493: fDefaultViewer.setLabelProvider(labelProvider);
494: fDefaultViewer.setInput(fModel.elements);
495: fDefaultViewer.setComparator(new ViewerComparator()); // sort alphabetically
496:
497: final int ICON_AND_CHECKBOX_WITH = 50;
498: final int HEADER_MARGIN = 20;
499: int minNameWidth = computeWidth(table, nameColumn.getText())
500: + HEADER_MARGIN;
501: int minKeyWidth = computeWidth(table, keyColumn.getText())
502: + HEADER_MARGIN;
503: for (int i = 0; i < fModel.elements.size(); i++) {
504: minNameWidth = Math.max(minNameWidth, computeWidth(table,
505: labelProvider.getColumnText(fModel.elements.get(i),
506: 0))
507: + ICON_AND_CHECKBOX_WITH);
508: minKeyWidth = Math.max(minKeyWidth, computeWidth(table,
509: labelProvider.getColumnText(fModel.elements.get(i),
510: 1)));
511: }
512:
513: nameColumn.setWidth(minNameWidth);
514: keyColumn.setWidth(minKeyWidth);
515: }
516:
517: private void createKeysLink(Composite composite, int h_span) {
518: Link link = new Link(composite, SWT.NONE | SWT.WRAP);
519: link
520: .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_key_binding_hint);
521: link.addSelectionListener(new SelectionAdapter() {
522: public void widgetSelected(SelectionEvent e) {
523: PreferencesUtil.createPreferenceDialogOn(getShell(),
524: e.text, null, null);
525: }
526: });
527:
528: PixelConverter pixelConverter = new PixelConverter(composite);
529: int width = pixelConverter.convertWidthInCharsToPixels(40);
530:
531: // limit the size of the Link as it would take all it can get
532: GridData gd = new GridData(GridData.FILL, GridData.FILL, false,
533: false, h_span, 1);
534: gd.widthHint = width;
535: link.setLayoutData(gd);
536: }
537:
538: private void createFiller(Composite composite, int h_span) {
539: Label filler = new Label(composite, SWT.NONE);
540: filler.setVisible(false);
541: filler.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false,
542: false, h_span, 1));
543: }
544:
545: private void createSeparateLabel(Composite composite, int h_span) {
546: PixelConverter pixelConverter = new PixelConverter(composite);
547: int width = pixelConverter.convertWidthInCharsToPixels(40);
548:
549: Label label = new Label(composite, SWT.NONE | SWT.WRAP);
550: label
551: .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_separate_table_description);
552: GridData gd = new GridData(GridData.FILL, GridData.FILL, false,
553: false, h_span, 1);
554: gd.widthHint = width;
555: label.setLayoutData(gd);
556: }
557:
558: private void createSeparateSection(Composite composite) {
559: createSeparateViewer(composite);
560: createButtonList(composite);
561: }
562:
563: private void createSeparateViewer(Composite composite) {
564: fSeparateViewer = CheckboxTableViewer.newCheckList(composite,
565: SWT.SINGLE | SWT.BORDER);
566: Table table = fSeparateViewer.getTable();
567: table.setHeaderVisible(false);
568: table.setLinesVisible(false);
569: table.setLayoutData(new GridData(GridData.FILL,
570: GridData.BEGINNING, true, false, 1, 1));
571:
572: TableColumn nameColumn = new TableColumn(table, SWT.NONE);
573: nameColumn
574: .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_separate_table_category_column_title);
575: nameColumn.setResizable(false);
576:
577: fSeparateViewer.setContentProvider(new ArrayContentProvider());
578:
579: ITableLabelProvider labelProvider = new SeparateTableLabelProvider();
580: fSeparateViewer.setLabelProvider(labelProvider);
581: fSeparateViewer.setInput(fModel.elements);
582:
583: final int ICON_AND_CHECKBOX_WITH = 50;
584: final int HEADER_MARGIN = 20;
585: int minNameWidth = computeWidth(table, nameColumn.getText())
586: + HEADER_MARGIN;
587: for (int i = 0; i < fModel.elements.size(); i++) {
588: minNameWidth = Math.max(minNameWidth, computeWidth(table,
589: labelProvider.getColumnText(fModel.elements.get(i),
590: 0))
591: + ICON_AND_CHECKBOX_WITH);
592: }
593:
594: nameColumn.setWidth(minNameWidth);
595:
596: fSeparateViewer
597: .addCheckStateListener(new ICheckStateListener() {
598: public void checkStateChanged(
599: CheckStateChangedEvent event) {
600: boolean checked = event.getChecked();
601: ModelElement element = (ModelElement) event
602: .getElement();
603: element.setSeparateCommand(checked);
604: }
605: });
606:
607: table.addSelectionListener(new SelectionAdapter() {
608: public void widgetSelected(SelectionEvent e) {
609: handleTableSelection();
610: }
611: });
612:
613: }
614:
615: private void createButtonList(Composite parent) {
616: Composite composite = new Composite(parent, SWT.NONE);
617: composite.setLayoutData(new GridData(SWT.BEGINNING,
618: SWT.BEGINNING, false, false));
619:
620: GridLayout layout = new GridLayout();
621: layout.marginWidth = 0;
622: layout.marginHeight = 0;
623: composite.setLayout(layout);
624:
625: fUpButton = new Button(composite, SWT.PUSH | SWT.CENTER);
626: fUpButton
627: .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_Up);
628: fUpButton.addSelectionListener(new SelectionAdapter() {
629: public void widgetSelected(SelectionEvent e) {
630: int index = getSelectionIndex();
631: if (index != -1) {
632: ((ModelElement) fModel.elements.get(index))
633: .moveUp();
634: fSeparateViewer.refresh();
635: handleTableSelection();
636: }
637: }
638: });
639: fUpButton.setLayoutData(new GridData());
640: SWTUtil.setButtonDimensionHint(fUpButton);
641:
642: fDownButton = new Button(composite, SWT.PUSH | SWT.CENTER);
643: fDownButton
644: .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_Down);
645: fDownButton.addSelectionListener(new SelectionAdapter() {
646: public void widgetSelected(SelectionEvent e) {
647: int index = getSelectionIndex();
648: if (index != -1) {
649: ((ModelElement) fModel.elements.get(index))
650: .moveDown();
651: fSeparateViewer.refresh();
652: handleTableSelection();
653: }
654: }
655: });
656: fDownButton.setLayoutData(new GridData());
657: SWTUtil.setButtonDimensionHint(fDownButton);
658: }
659:
660: private void createParameterTimeoutControl(Composite composite,
661: int h_span) {
662: Composite timeoutComposite = new Composite(composite, SWT.NONE);
663: GridLayout layout = new GridLayout(4, false);
664: layout.marginWidth = 0;
665: layout.marginHeight = 0;
666: timeoutComposite.setLayout(layout);
667: GridData gd = new GridData(GridData.FILL, GridData.FILL, true,
668: false, h_span, 1);
669: timeoutComposite.setLayoutData(gd);
670:
671: PixelConverter pixelConverter = new PixelConverter(composite);
672: String str = PreferencesMessages.CodeAssistAdvancedConfigurationBlock_parameterNameFromAttachedJavadoc_timeout;
673: addTextField(
674: timeoutComposite,
675: str,
676: PREF_CODEASSIST_TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC,
677: 0, pixelConverter.convertWidthInCharsToPixels(7));
678:
679: Label ms = new Label(timeoutComposite, SWT.NONE);
680: gd = new GridData();
681: ms.setLayoutData(gd);
682: ms
683: .setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_parameterNameFromAttachedJavadoc_timeout_ms);
684:
685: }
686:
687: private void handleTableSelection() {
688: ModelElement item = getSelectedItem();
689: if (item != null) {
690: int index = getSelectionIndex();
691: fUpButton.setEnabled(index > 0);
692: fDownButton.setEnabled(index < fModel.elements.size() - 1);
693: } else {
694: fUpButton.setEnabled(false);
695: fDownButton.setEnabled(false);
696: }
697: }
698:
699: private ModelElement getSelectedItem() {
700: return (ModelElement) ((IStructuredSelection) fSeparateViewer
701: .getSelection()).getFirstElement();
702: }
703:
704: private int getSelectionIndex() {
705: return fSeparateViewer.getTable().getSelectionIndex();
706: }
707:
708: /*
709: * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#updateControls()
710: */
711: protected void updateControls() {
712: super .updateControls();
713:
714: fModel.update();
715: updateCheckedState();
716: fDefaultViewer.refresh();
717: fSeparateViewer.refresh();
718: handleTableSelection();
719: }
720:
721: private void updateCheckedState() {
722: final int size = fModel.elements.size();
723: List defaultChecked = new ArrayList(size);
724: List separateChecked = new ArrayList(size);
725:
726: for (Iterator it = fModel.elements.iterator(); it.hasNext();) {
727: ModelElement element = (ModelElement) it.next();
728: if (element.isInDefaultCategory())
729: defaultChecked.add(element);
730: if (element.isSeparateCommand())
731: separateChecked.add(element);
732: }
733:
734: fDefaultViewer.setCheckedElements(defaultChecked
735: .toArray(new Object[defaultChecked.size()]));
736: fSeparateViewer.setCheckedElements(separateChecked
737: .toArray(new Object[separateChecked.size()]));
738: }
739:
740: /*
741: * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#processChanges(org.eclipse.ui.preferences.IWorkbenchPreferenceContainer)
742: */
743: protected boolean processChanges(
744: IWorkbenchPreferenceContainer container) {
745: for (Iterator it = fModel.elements.iterator(); it.hasNext();) {
746: ModelElement item = (ModelElement) it.next();
747: item.update();
748: }
749:
750: return super .processChanges(container);
751: }
752:
753: /*
754: * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#validateSettings(org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock.Key, java.lang.String, java.lang.String)
755: */
756: protected void validateSettings(Key changedKey, String oldValue,
757: String newValue) {
758: if (changedKey == PREF_CODEASSIST_TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC) {
759: final StatusInfo status = new StatusInfo();
760: if (newValue.length() == 0)
761: status
762: .setError(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_parameterNameFromAttachedJavadoc_timeout_emptyInput);
763: else {
764: try {
765: int number = Integer.parseInt(newValue);
766: int min = 0;
767: int max = 5000;
768: if (number < min || number > max) {
769: String msgFormat = PreferencesMessages.CodeAssistAdvancedConfigurationBlock_parameterNameFromAttachedJavadoc_timeout_invalidRange;
770: String msg = Messages.format(msgFormat,
771: new Object[] { new Integer(min),
772: new Integer(max) });
773: status.setError(msg);
774: }
775: } catch (NumberFormatException ex) {
776: String msgFormat = PreferencesMessages.CodeAssistAdvancedConfigurationBlock_parameterNameFromAttachedJavadoc_timeout_invalidInput;
777: String msg = Messages.format(msgFormat, newValue);
778: status.setError(msg);
779: }
780: }
781: fContext.statusChanged(status);
782: }
783: }
784:
785: /*
786: * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#getFullBuildDialogStrings(boolean)
787: */
788: protected String[] getFullBuildDialogStrings(
789: boolean workspaceSettings) {
790: // no builds triggered by our settings
791: return null;
792: }
793:
794: /*
795: * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#dispose()
796: */
797: public void dispose() {
798: for (Iterator it = fImages.values().iterator(); it.hasNext();) {
799: Image image = (Image) it.next();
800: image.dispose();
801: }
802:
803: super .dispose();
804: }
805:
806: private int computeWidth(Control control, String name) {
807: if (name == null)
808: return 0;
809: GC gc = new GC(control);
810: try {
811: gc.setFont(JFaceResources.getDialogFont());
812: return gc.stringExtent(name).x + 10;
813: } finally {
814: gc.dispose();
815: }
816: }
817:
818: private static BindingManager fgLocalBindingManager;
819: static {
820: fgLocalBindingManager = new BindingManager(
821: new ContextManager(), new CommandManager());
822: final IBindingService bindingService = (IBindingService) PlatformUI
823: .getWorkbench().getService(IBindingService.class);
824: final Scheme[] definedSchemes = bindingService
825: .getDefinedSchemes();
826: if (definedSchemes != null) {
827: try {
828: for (int i = 0; i < definedSchemes.length; i++) {
829: final Scheme scheme = definedSchemes[i];
830: final Scheme copy = fgLocalBindingManager
831: .getScheme(scheme.getId());
832: copy.define(scheme.getName(), scheme
833: .getDescription(), scheme.getParentId());
834: }
835: } catch (final NotDefinedException e) {
836: JavaPlugin.log(e);
837: }
838: }
839: fgLocalBindingManager.setLocale(bindingService.getLocale());
840: fgLocalBindingManager.setPlatform(bindingService.getPlatform());
841: }
842:
843: private static String getKeyboardShortcut(
844: ParameterizedCommand command) {
845: IBindingService bindingService = (IBindingService) PlatformUI
846: .getWorkbench().getAdapter(IBindingService.class);
847: fgLocalBindingManager.setBindings(bindingService.getBindings());
848: try {
849: Scheme activeScheme = bindingService.getActiveScheme();
850: if (activeScheme != null)
851: fgLocalBindingManager.setActiveScheme(activeScheme);
852: } catch (NotDefinedException e) {
853: JavaPlugin.log(e);
854: }
855:
856: TriggerSequence[] bindings = fgLocalBindingManager
857: .getActiveBindingsDisregardingContextFor(command);
858: if (bindings.length > 0)
859: return bindings[0].format();
860: return null;
861: }
862:
863: private Image getImage(ImageDescriptor imgDesc) {
864: if (imgDesc == null)
865: return null;
866:
867: Image img = (Image) fImages.get(imgDesc);
868: if (img == null) {
869: img = imgDesc.createImage(false);
870: fImages.put(imgDesc, img);
871: }
872: return img;
873: }
874:
875: }
|