case-study/jdt-after/ui/org/eclipse/jdt/internal/ui/preferences/CodeAssistAdvancedConfigurationBlock.java

   1 /*******************************************************************************
   2  * Copyright (c) 2005, 2011 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package org.eclipse.jdt.internal.ui.preferences;
  12
  13 import java.util.ArrayList;
  14 import java.util.Collections;
  15 import java.util.Comparator;
  16 import java.util.HashMap;
  17 import java.util.Iterator;
  18 import java.util.List;
  19 import java.util.Map;
  20
  21 import org.eclipse.swt.SWT;
  22 import org.eclipse.swt.events.SelectionAdapter;
  23 import org.eclipse.swt.events.SelectionEvent;
  24 import org.eclipse.swt.graphics.GC;
  25 import org.eclipse.swt.graphics.Image;
  26 import org.eclipse.swt.layout.GridData;
  27 import org.eclipse.swt.layout.GridLayout;
  28 import org.eclipse.swt.widgets.Button;
  29 import org.eclipse.swt.widgets.Composite;
  30 import org.eclipse.swt.widgets.Control;
  31 import org.eclipse.swt.widgets.Label;
  32 import org.eclipse.swt.widgets.Link;
  33 import org.eclipse.swt.widgets.Table;
  34 import org.eclipse.swt.widgets.TableColumn;
  35
  36 import org.eclipse.core.commands.Command;
  37 import org.eclipse.core.commands.CommandManager;
  38 import org.eclipse.core.commands.IParameter;
  39 import org.eclipse.core.commands.Parameterization;
  40 import org.eclipse.core.commands.ParameterizedCommand;
  41 import org.eclipse.core.commands.common.NotDefinedException;
  42 import org.eclipse.core.commands.contexts.ContextManager;
  43
  44 import org.eclipse.core.runtime.Assert;
  45
  46 import org.eclipse.jface.bindings.BindingManager;
  47 import org.eclipse.jface.bindings.Scheme;
  48 import org.eclipse.jface.bindings.TriggerSequence;
  49 import org.eclipse.jface.layout.PixelConverter;
  50 import org.eclipse.jface.resource.ImageDescriptor;
  51 import org.eclipse.jface.resource.JFaceResources;
  52 import org.eclipse.jface.viewers.ArrayContentProvider;
  53 import org.eclipse.jface.viewers.CheckStateChangedEvent;
  54 import org.eclipse.jface.viewers.CheckboxTableViewer;
  55 import org.eclipse.jface.viewers.ICheckStateListener;
  56 import org.eclipse.jface.viewers.IStructuredSelection;
  57 import org.eclipse.jface.viewers.ITableLabelProvider;
  58 import org.eclipse.jface.viewers.LabelProvider;
  59 import org.eclipse.jface.viewers.ViewerComparator;
  60
  61 import org.eclipse.ui.PlatformUI;
  62 import org.eclipse.ui.commands.ICommandService;
  63 import org.eclipse.ui.dialogs.PreferencesUtil;
  64 import org.eclipse.ui.keys.IBindingService;
  65 import org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;
  66
  67 import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
  68
  69 import org.eclipse.jdt.core.JavaCore;
  70
  71 import org.eclipse.jdt.internal.corext.util.Messages;
  72
  73 import org.eclipse.jdt.ui.PreferenceConstants;
  74
  75 import org.eclipse.jdt.internal.ui.JavaPlugin;
  76 import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
  77 import org.eclipse.jdt.internal.ui.text.java.CompletionProposalCategory;
  78 import org.eclipse.jdt.internal.ui.text.java.CompletionProposalComputerRegistry;
  79 import org.eclipse.jdt.internal.ui.util.SWTUtil;
  80 import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
  81
  82
  83 /**
  84  *
  85  * @since 3.2
  86  */
  87 public final class CodeAssistAdvancedConfigurationBlock extends OptionsConfigurationBlock {
  88
  89         private static final Key PREF_EXCLUDED_CATEGORIES= getJDTUIKey(PreferenceConstants.CODEASSIST_EXCLUDED_CATEGORIES);
  90         private static final Key PREF_CATEGORY_ORDER= getJDTUIKey(PreferenceConstants.CODEASSIST_CATEGORY_ORDER);
  91         private static final Key PREF_CODEASSIST_TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC= getJDTCoreKey(JavaCore.TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC);
  92
  93         private static Key[] getAllKeys() {
  94                 return new Key[] {
  95                                 PREF_EXCLUDED_CATEGORIES,
  96                                 PREF_CATEGORY_ORDER,
  97                                 PREF_CODEASSIST_TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC
  98                 };
  99         }
 100
 101         final class DefaultTableLabelProvider extends LabelProvider implements ITableLabelProvider {
 102
 103                 /*
 104                  * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object, int)
 105                  */
 106                 public Image getColumnImage(Object element, int columnIndex) {
 107                         if (columnIndex == 0)
 108                                 return ((ModelElement) element).getImage();
 109                         return null;
 110                 }
 111
 112                 /*
 113                  * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object, int)
 114                  */
 115                 public String getColumnText(Object element, int columnIndex) {
 116                         switch (columnIndex) {
 117                     case 0:
 118                         return ((ModelElement) element).getName();
 119                     case 1:
 120                         return ((ModelElement) element).getKeybindingAsString();
 121                     default:
 122                         Assert.isTrue(false);
 123                         return null;
 124             }
 125                 }
 126
 127                 /*
 128                  * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
 129                  */
 130                 @Override
 131                 public String getText(Object element) {
 132                     return getColumnText(element, 0); // needed to make the sorter work
 133                 }
 134         }
 135
 136         private final class SeparateTableLabelProvider extends LabelProvider implements ITableLabelProvider {
 137
 138                 /*
 139                  * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang.Object, int)
 140                  */
 141                 public Image getColumnImage(Object element, int columnIndex) {
 142                         if (columnIndex == 0)
 143                                 return ((ModelElement) element).getImage();
 144                         return null;
 145                 }
 146
 147                 /*
 148                  * @see org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang.Object, int)
 149                  */
 150                 public String getColumnText(Object element, int columnIndex) {
 151                         switch (columnIndex) {
 152                                 case 0:
 153                                         return ((ModelElement) element).getName();
 154                                 default:
 155                                         Assert.isTrue(false);
 156                                 return null;
 157                         }
 158                 }
 159         }
 160
 161         private final Comparator<ModelElement> fCategoryComparator= new Comparator<ModelElement>() {
 162                 private int getRank(ModelElement o) {
 163                         return o.getRank();
 164                 }
 165
 166                 public int compare(ModelElement o1, ModelElement o2) {
 167                         return getRank(o1) - getRank(o2);
 168                 }
 169         };
 170
 171         public final class PreferenceModel {
 172                 public static final int LIMIT= 65535;
 173                 private static final String COLON= ":"; //$NON-NLS-1$
 174                 private static final String SEPARATOR= "\0"; //$NON-NLS-1$
 175
 176                 private final List<ModelElement> fElements;
 177                 /**
 178                  * The read-only list of elements.
 179                  */
 180                 final List<ModelElement> elements;
 181
 182                 public PreferenceModel(CompletionProposalComputerRegistry registry) {
 183                         List<CompletionProposalCategory> categories= registry.getProposalCategories();
 184                         fElements= new ArrayList<ModelElement>();
 185                         for (Iterator<CompletionProposalCategory> it= categories.iterator(); it.hasNext();) {
 186                                 CompletionProposalCategory category= it.next();
 187                                 if (category.hasComputers()) {
 188                                         fElements.add(new ModelElement(category, this));
 189                                 }
 190                         }
 191                         Collections.sort(fElements, fCategoryComparator);
 192                         elements= Collections.unmodifiableList(fElements);
 193                 }
 194
 195         public void moveUp(ModelElement category) {
 196                 int index= fElements.indexOf(category);
 197                         if (index > 0) {
 198                                 ModelElement item= fElements.remove(index);
 199                                 fElements.add(index - 1, item);
 200                                 writeOrderPreference(null, false);
 201                         }
 202         }
 203
 204         public void moveDown(ModelElement category) {
 205                 int index= fElements.indexOf(category);
 206                         if (index < fElements.size() - 1) {
 207                                 ModelElement item= fElements.remove(index);
 208                                 fElements.add(index + 1, item);
 209                                 writeOrderPreference(null, false);
 210                         }
 211         }
 212
 213         private void writeInclusionPreference(ModelElement changed, boolean isInDefaultCategory) {
 214                 StringBuffer buf= new StringBuffer();
 215                 for (Iterator<ModelElement> it= fElements.iterator(); it.hasNext();) {
 216                         ModelElement item= it.next();
 217                         boolean included= changed == item ? isInDefaultCategory : item.isInDefaultCategory();
 218                         if (!included)
 219                                 buf.append(item.getId() + SEPARATOR);
 220                 }
 221
 222                 String newValue= buf.toString();
 223                 String oldValue= setValue(PREF_EXCLUDED_CATEGORIES, newValue);
 224                 validateSettings(PREF_EXCLUDED_CATEGORIES, oldValue, newValue);
 225         }
 226
 227         private void writeOrderPreference(ModelElement changed, boolean isSeparate) {
 228                 StringBuffer buf= new StringBuffer();
 229                 int i= 0;
 230                 for (Iterator<ModelElement> it= fElements.iterator(); it.hasNext(); i++) {
 231                         ModelElement item= it.next();
 232                         boolean separate= changed == item ? isSeparate : item.isSeparateCommand();
 233                         int rank= separate ? i : i + LIMIT;
 234                         buf.append(item.getId() + COLON + rank + SEPARATOR);
 235                 }
 236
 237                 String newValue= buf.toString();
 238                 String oldValue= setValue(PREF_CATEGORY_ORDER, newValue);
 239                 validateSettings(PREF_CATEGORY_ORDER, oldValue, newValue);
 240         }
 241
 242
 243         private boolean readInclusionPreference(CompletionProposalCategory cat) {
 244                 String[] ids= getTokens(getValue(PREF_EXCLUDED_CATEGORIES), SEPARATOR);
 245                 for (int i= 0; i < ids.length; i++) {
 246                         if (ids[i].equals(cat.getId()))
 247                                 return false;
 248                 }
 249                 return true;
 250         }
 251
 252         private int readOrderPreference(CompletionProposalCategory cat) {
 253                 String[] sortOrderIds= getTokens(getValue(PREF_CATEGORY_ORDER), SEPARATOR);
 254                 for (int i= 0; i < sortOrderIds.length; i++) {
 255                         String[] idAndRank= getTokens(sortOrderIds[i], COLON);
 256                         if (idAndRank[0].equals(cat.getId()))
 257                                 return Integer.parseInt(idAndRank[1]);
 258                 }
 259                         return LIMIT - 1;
 260         }
 261
 262         public void update() {
 263                         Collections.sort(fElements, fCategoryComparator);
 264         }
 265
 266                 public int generated_3960557514315752614(CodeAssistAdvancedConfigurationBlock codeassistadvancedconfigurationblock, Table table, DefaultTableLabelProvider labelProvider, int minKeyWidth, int i) {
 267                         minKeyWidth= Math.max(minKeyWidth, codeassistadvancedconfigurationblock.computeWidth(table, labelProvider.getColumnText(elements.get(i), 1)));
 268                         return minKeyWidth;
 269                 }
 270
 271                 public int generated_6182656614106464974(CodeAssistAdvancedConfigurationBlock codeassistadvancedconfigurationblock, Table table, TableColumn nameColumn, ITableLabelProvider labelProvider) {
 272                         codeassistadvancedconfigurationblock.fSeparateViewer.setInput(elements);
 273
 274                         final int ICON_AND_CHECKBOX_WITH= 50;
 275                         final int HEADER_MARGIN= 20;
 276                         int minNameWidth= codeassistadvancedconfigurationblock.computeWidth(table, nameColumn.getText()) + HEADER_MARGIN;
 277                         for (int i= 0; i < elements.size(); i++) {
 278                                 minNameWidth= Math.max(minNameWidth, codeassistadvancedconfigurationblock.computeWidth(table, labelProvider.getColumnText(elements.get(i), 0)) + ICON_AND_CHECKBOX_WITH);
 279                         }
 280                         return minNameWidth;
 281                 }
 282
 283                 public void generated_8683826732335652639(CodeAssistAdvancedConfigurationBlock codeassistadvancedconfigurationblock, ModelElement item) {
 284                         if (item != null) {
 285                                 int index= codeassistadvancedconfigurationblock.getSelectionIndex();
 286                                 codeassistadvancedconfigurationblock.fUpButton.setEnabled(index > 0);
 287                                 codeassistadvancedconfigurationblock.fDownButton.setEnabled(index < elements.size() - 1);
 288                         } else {
 289                                 codeassistadvancedconfigurationblock.fUpButton.setEnabled(false);
 290                                 codeassistadvancedconfigurationblock.fDownButton.setEnabled(false);
 291                         }
 292                 }
 293
 294                 public int generated_4704470300960025110(CodeAssistAdvancedConfigurationBlock codeassistadvancedconfigurationblock) {
 295                         final int size= elements.size();
 296                         return size;
 297                 }
 298         }
 299
 300         public final class ModelElement {
 301                 public final CompletionProposalCategory fCategory;
 302                 private final Command fCommand;
 303                 private final IParameter fParam;
 304                 private final PreferenceModel fPreferenceModel;
 305
 306                 ModelElement(CompletionProposalCategory category, PreferenceModel model) {
 307                         fCategory= category;
 308                         ICommandService commandSvc= (ICommandService) PlatformUI.getWorkbench().getAdapter(ICommandService.class);
 309                         fCommand= commandSvc.getCommand("org.eclipse.jdt.ui.specific_content_assist.command"); //$NON-NLS-1$
 310                         IParameter type;
 311                         try {
 312                                 type= fCommand.getParameters()[0];
 313                         } catch (NotDefinedException x) {
 314                                 Assert.isTrue(false);
 315                                 type= null;
 316                         }
 317                         fParam= type;
 318                         fPreferenceModel= model;
 319                 }
 320                 Image getImage() {
 321                         return CodeAssistAdvancedConfigurationBlock.this.getImage(fCategory.getImageDescriptor());
 322                 }
 323                 String getName() {
 324                         return fCategory.getDisplayName();
 325                 }
 326                 String getKeybindingAsString() {
 327                         final Parameterization[] params= { new Parameterization(fParam, fCategory.getId()) };
 328                         final ParameterizedCommand pCmd= new ParameterizedCommand(fCommand, params);
 329                         String key= getKeyboardShortcut(pCmd);
 330                         return key;
 331                 }
 332                 boolean isInDefaultCategory() {
 333                         return fPreferenceModel.readInclusionPreference(fCategory);
 334                 }
 335                 void setInDefaultCategory(boolean included) {
 336                         if (included != isInDefaultCategory())
 337                                 fPreferenceModel.writeInclusionPreference(this, included);
 338                 }
 339                 String getId() {
 340                         return fCategory.getId();
 341                 }
 342                 int getRank() {
 343                         int rank= getInternalRank();
 344                         if (rank > PreferenceModel.LIMIT)
 345                                 return rank - PreferenceModel.LIMIT;
 346                         return rank;
 347                 }
 348                 void moveUp() {
 349                         fPreferenceModel.moveUp(this);
 350                 }
 351                 void moveDown() {
 352                         fPreferenceModel.moveDown(this);
 353                 }
 354                 private int getInternalRank() {
 355                         return fPreferenceModel.readOrderPreference(fCategory);
 356                 }
 357                 boolean isSeparateCommand() {
 358                         return getInternalRank() < PreferenceModel.LIMIT;
 359                 }
 360
 361                 void setSeparateCommand(boolean separate) {
 362                         if (separate != isSeparateCommand())
 363                                 fPreferenceModel.writeOrderPreference(this, separate);
 364                 }
 365
 366                 void update() {
 367                         fCategory.setIncluded(isInDefaultCategory());
 368                         int rank= getInternalRank();
 369                         fCategory.generated_7994815616900856385(rank);
 370                 }
 371         }
 372
 373         /** element type: {@link ModelElement}. */
 374         private final PreferenceModel fModel;
 375         private final Map<ImageDescriptor, Image> fImages= new HashMap<ImageDescriptor, Image>();
 376
 377         private CheckboxTableViewer fDefaultViewer;
 378         private CheckboxTableViewer fSeparateViewer;
 379         private Button fUpButton;
 380         private Button fDownButton;
 381
 382         CodeAssistAdvancedConfigurationBlock(IStatusChangeListener statusListener, IWorkbenchPreferenceContainer container) {
 383                 super(statusListener, null, getAllKeys(), container);
 384                 fModel= new PreferenceModel(CompletionProposalComputerRegistry.getDefault());
 385         }
 386
 387         /*
 388          * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#createContents(org.eclipse.swt.widgets.Composite)
 389          */
 390         @Override
 391         protected Control createContents(Composite parent) {
 392
 393                 ScrolledPageContent scrolled= new ScrolledPageContent(parent, SWT.H_SCROLL | SWT.V_SCROLL);
 394
 395                 scrolled.generated_1458660277537825336();
 396
 397                 Composite composite= new Composite(scrolled, SWT.NONE);
 398                 int columns= 2;
 399                 GridLayout layout= new GridLayout(columns, false);
 400                 layout.marginWidth= 0;
 401                 layout.marginHeight= 0;
 402                 composite.setLayout(layout);
 403
 404
 405                 createDefaultLabel(composite, columns);
 406                 createDefaultViewer(composite, columns);
 407                 createKeysLink(composite, columns);
 408
 409                 createFiller(composite, columns);
 410
 411                 createSeparateLabel(composite, columns);
 412         createSeparateSection(composite);
 413
 414         createFiller(composite, columns);
 415
 416                 createParameterTimeoutControl(composite, columns);
 417
 418                 updateControls();
 419                 if (fModel.elements.size() > 0) {
 420                         fDefaultViewer.getTable().select(0);
 421                         fSeparateViewer.getTable().select(0);
 422                         handleTableSelection();
 423                 }
 424
 425                 scrolled.setContent(composite);
 426                 scrolled.setMinSize(composite.computeSize(SWT.DEFAULT, SWT.DEFAULT));
 427                 return scrolled;
 428         }
 429
 430         private void createDefaultLabel(Composite composite, int h_span) {
 431             final ICommandService commandSvc= (ICommandService) PlatformUI.getWorkbench().getAdapter(ICommandService.class);
 432                 final Command command= commandSvc.getCommand(ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS);
 433                 ParameterizedCommand pCmd= new ParameterizedCommand(command, 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.setText(Messages.format(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_page_description, new Object[] { key }));
 443                 GridData gd= new GridData(GridData.FILL, GridData.FILL, true, false, h_span, 1);
 444                 gd.widthHint= width;
 445                 label.setLayoutData(gd);
 446
 447                 createFiller(composite, h_span);
 448
 449                 label= new Label(composite, SWT.NONE | SWT.WRAP);
 450                 label.setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_default_table_description);
 451                 gd= new GridData(GridData.FILL, GridData.FILL, true, false, h_span, 1);
 452                 gd.widthHint= width;
 453                 label.setLayoutData(gd);
 454     }
 455
 456         private void createDefaultViewer(Composite composite, int h_span) {
 457                 fDefaultViewer= CheckboxTableViewer.newCheckList(composite, SWT.SINGLE | SWT.BORDER);
 458                 Table table= fDefaultViewer.getTable();
 459                 table.setHeaderVisible(true);
 460                 table.setLinesVisible(false);
 461                 table.setLayoutData(new GridData(GridData.FILL, GridData.BEGINNING, false, false, h_span, 1));
 462
 463                 TableColumn nameColumn= new TableColumn(table, SWT.NONE);
 464                 nameColumn.setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_default_table_category_column_title);
 465                 nameColumn.setResizable(false);
 466                 TableColumn keyColumn= new TableColumn(table, SWT.NONE);
 467                 keyColumn.setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_default_table_keybinding_column_title);
 468                 keyColumn.setResizable(false);
 469
 470                 fDefaultViewer.addCheckStateListener(new ICheckStateListener() {
 471                         public void checkStateChanged(CheckStateChangedEvent event) {
 472                                 boolean checked= event.getChecked();
 473                                 ModelElement element= (ModelElement) event.getElement();
 474                                 element.setInDefaultCategory(checked);
 475                         }
 476                 });
 477
 478                 fDefaultViewer.setContentProvider(new ArrayContentProvider());
 479
 480                 DefaultTableLabelProvider labelProvider= new DefaultTableLabelProvider();
 481                 fDefaultViewer.setLabelProvider(labelProvider);
 482                 fDefaultViewer.setInput(fModel.elements);
 483                 fDefaultViewer.setComparator(new ViewerComparator()); // sort alphabetically
 484
 485                 final int ICON_AND_CHECKBOX_WITH= 50;
 486                 final int HEADER_MARGIN= 20;
 487                 int minNameWidth= computeWidth(table, nameColumn.getText()) + HEADER_MARGIN;
 488                 int minKeyWidth= computeWidth(table, keyColumn.getText()) + HEADER_MARGIN;
 489                 for (int i= 0; i < fModel.elements.size(); i++) {
 490                         minNameWidth= Math.max(minNameWidth, computeWidth(table, labelProvider.getColumnText(fModel.elements.get(i), 0)) + ICON_AND_CHECKBOX_WITH);
 491                         minKeyWidth= fModel.generated_3960557514315752614(this, table, labelProvider, minKeyWidth, i);
 492                 }
 493
 494                 nameColumn.setWidth(minNameWidth);
 495                 keyColumn.setWidth(minKeyWidth);
 496         }
 497
 498         private void createKeysLink(Composite composite, int h_span) {
 499             Link link= new Link(composite, SWT.NONE | SWT.WRAP);
 500                 link.setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_key_binding_hint);
 501                 link.addSelectionListener(new SelectionAdapter() {
 502                         @Override
 503                         public void widgetSelected(SelectionEvent e) {
 504                                 PreferencesUtil.createPreferenceDialogOn(getShell(), e.text, null, null);
 505                         }
 506                 });
 507
 508                 PixelConverter pixelConverter= new PixelConverter(composite);
 509                 int width= pixelConverter.convertWidthInCharsToPixels(40);
 510
 511                 // limit the size of the Link as it would take all it can get
 512                 GridData gd= new GridData(GridData.FILL, GridData.FILL, false, false, h_span, 1);
 513                 gd.widthHint= width;
 514                 link.setLayoutData(gd);
 515     }
 516
 517         private void createFiller(Composite composite, int h_span) {
 518             Label filler= new Label(composite, SWT.NONE);
 519                 filler.setVisible(false);
 520                 filler.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, h_span, 1));
 521     }
 522
 523         private void createSeparateLabel(Composite composite, int h_span) {
 524                 PixelConverter pixelConverter= new PixelConverter(composite);
 525                 int width= pixelConverter.convertWidthInCharsToPixels(40);
 526
 527                 Label label= new Label(composite, SWT.NONE | SWT.WRAP);
 528                 label.setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_separate_table_description);
 529                 GridData gd= new GridData(GridData.FILL, GridData.FILL, false, false, h_span, 1);
 530                 gd.widthHint= width;
 531                 label.setLayoutData(gd);
 532         }
 533
 534         private void createSeparateSection(Composite composite) {
 535                 createSeparateViewer(composite);
 536                 createButtonList(composite);
 537         }
 538
 539         private void createSeparateViewer(Composite composite) {
 540                 fSeparateViewer= CheckboxTableViewer.newCheckList(composite, SWT.SINGLE | SWT.BORDER);
 541                 Table table= fSeparateViewer.getTable();
 542                 table.setHeaderVisible(false);
 543                 table.setLinesVisible(false);
 544                 table.setLayoutData(new GridData(GridData.FILL, GridData.BEGINNING, true, false, 1, 1));
 545
 546                 TableColumn nameColumn= new TableColumn(table, SWT.NONE);
 547                 nameColumn.setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_separate_table_category_column_title);
 548                 nameColumn.setResizable(false);
 549
 550                 fSeparateViewer.setContentProvider(new ArrayContentProvider());
 551
 552                 ITableLabelProvider labelProvider= new SeparateTableLabelProvider();
 553                 fSeparateViewer.setLabelProvider(labelProvider);
 554                 int minNameWidth= fModel.generated_6182656614106464974(this, table, nameColumn, labelProvider);
 555
 556                 nameColumn.setWidth(minNameWidth);
 557
 558                 fSeparateViewer.addCheckStateListener(new ICheckStateListener() {
 559                         public void checkStateChanged(CheckStateChangedEvent event) {
 560                                 boolean checked= event.getChecked();
 561                                 ModelElement element= (ModelElement) event.getElement();
 562                                 element.setSeparateCommand(checked);
 563                         }
 564                 });
 565
 566                 table.addSelectionListener(new SelectionAdapter() {
 567                         @Override
 568                         public void widgetSelected(SelectionEvent e) {
 569                                 handleTableSelection();
 570                         }
 571                 });
 572
 573         }
 574
 575         private void createButtonList(Composite parent) {
 576                 Composite composite= new Composite(parent, SWT.NONE);
 577                 composite.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING, false, false));
 578
 579                 GridLayout layout= new GridLayout();
 580                 layout.marginWidth= 0;
 581                 layout.marginHeight= 0;
 582                 composite.setLayout(layout);
 583
 584                 fUpButton= new Button(composite, SWT.PUSH | SWT.CENTER);
 585         fUpButton.setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_Up);
 586         fUpButton.addSelectionListener(new SelectionAdapter() {
 587                 @Override
 588                         public void widgetSelected(SelectionEvent e) {
 589                         int index= getSelectionIndex();
 590                         if (index != -1) {
 591                                 fModel.elements.get(index).moveUp();
 592                                 fSeparateViewer.refresh();
 593                                 handleTableSelection();
 594                         }
 595                 }
 596         });
 597         fUpButton.setLayoutData(new GridData());
 598         SWTUtil.setButtonDimensionHint(fUpButton);
 599
 600         fDownButton= new Button(composite, SWT.PUSH | SWT.CENTER);
 601         fDownButton.setText(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_Down);
 602         fDownButton.addSelectionListener(new SelectionAdapter() {
 603                 @Override
 604                         public void widgetSelected(SelectionEvent e) {
 605                         int index= getSelectionIndex();
 606                         if (index != -1) {
 607                                 fModel.elements.get(index).moveDown();
 608                                 fSeparateViewer.refresh();
 609                                 handleTableSelection();
 610                         }
 611                 }
 612         });
 613         fDownButton.setLayoutData(new GridData());
 614         SWTUtil.setButtonDimensionHint(fDownButton);
 615         }
 616
 617         private void createParameterTimeoutControl(Composite composite, int h_span) {
 618                 Composite timeoutComposite= new Composite(composite, SWT.NONE);
 619                 GridLayout layout= new GridLayout(4, false);
 620                 layout.marginWidth= 0;
 621                 layout.marginHeight= 0;
 622                 timeoutComposite.setLayout(layout);
 623                 GridData gd= new GridData(GridData.FILL, GridData.FILL, true, false, h_span, 1);
 624                 timeoutComposite.setLayoutData(gd);
 625
 626                 PixelConverter pixelConverter= new PixelConverter(composite);
 627                 String str= PreferencesMessages.CodeAssistAdvancedConfigurationBlock_parameterNameFromAttachedJavadoc_timeout;
 628                 addTextField(timeoutComposite, str, PREF_CODEASSIST_TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC, 0, pixelConverter.convertWidthInCharsToPixels(7));
 629
 630         }
 631
 632         private void handleTableSelection() {
 633                 ModelElement item= getSelectedItem();
 634                 fModel.generated_8683826732335652639(this, item);
 635         }
 636
 637         private ModelElement getSelectedItem() {
 638                 return (ModelElement) ((IStructuredSelection) fSeparateViewer.getSelection()).getFirstElement();
 639         }
 640
 641         private int getSelectionIndex() {
 642                 return fSeparateViewer.getTable().getSelectionIndex();
 643         }
 644
 645         /*
 646          * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#updateControls()
 647          */
 648         @Override
 649         protected void updateControls() {
 650                 super.updateControls();
 651
 652                 fModel.update();
 653                 updateCheckedState();
 654                 fDefaultViewer.refresh();
 655                 fSeparateViewer.refresh();
 656                 handleTableSelection();
 657         }
 658
 659         private void updateCheckedState() {
 660                 final int size= fModel.generated_4704470300960025110(this);
 661                 List<ModelElement> defaultChecked= new ArrayList<ModelElement>(size);
 662                 List<ModelElement> separateChecked= new ArrayList<ModelElement>(size);
 663
 664                 for (Iterator<ModelElement> it= fModel.elements.iterator(); it.hasNext();) {
 665                         ModelElement element= it.next();
 666                         if (element.isInDefaultCategory())
 667                                 defaultChecked.add(element);
 668                         if (element.isSeparateCommand())
 669                                 separateChecked.add(element);
 670                 }
 671
 672                 fDefaultViewer.setCheckedElements(defaultChecked.toArray(new Object[defaultChecked.size()]));
 673                 fSeparateViewer.setCheckedElements(separateChecked.toArray(new Object[separateChecked.size()]));
 674         }
 675
 676         /*
 677          * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#processChanges(org.eclipse.ui.preferences.IWorkbenchPreferenceContainer)
 678          */
 679         @Override
 680         protected boolean processChanges(IWorkbenchPreferenceContainer container) {
 681                 for (Iterator<ModelElement> it= fModel.elements.iterator(); it.hasNext();) {
 682                         ModelElement item= it.next();
 683                         item.update();
 684                 }
 685
 686                 return super.processChanges(container);
 687         }
 688
 689         /*
 690          * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#validateSettings(org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock.Key, java.lang.String, java.lang.String)
 691          */
 692         @Override
 693         protected void validateSettings(Key changedKey, String oldValue, String newValue) {
 694                 if (changedKey == PREF_CODEASSIST_TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC) {
 695                         final StatusInfo status= new StatusInfo();
 696                         status.generated_9109049189476184915(newValue, this);
 697                 }
 698         }
 699
 700         /*
 701          * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#getFullBuildDialogStrings(boolean)
 702          */
 703         @Override
 704         protected String[] getFullBuildDialogStrings(boolean workspaceSettings) {
 705                 // no builds triggered by our settings
 706                 return null;
 707         }
 708
 709         /*
 710          * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#dispose()
 711          */
 712         @Override
 713         public void dispose() {
 714                 for (Iterator<Image> it= fImages.values().iterator(); it.hasNext();) {
 715                         Image image= it.next();
 716                         image.dispose();
 717                 }
 718
 719                 super.dispose();
 720         }
 721
 722         private int computeWidth(Control control, String name) {
 723                 if (name == null)
 724                         return 0;
 725                 GC gc= new GC(control);
 726                 try {
 727                         gc.setFont(JFaceResources.getDialogFont());
 728                         return gc.stringExtent(name).x + 10;
 729                 } finally {
 730                         gc.dispose();
 731                 }
 732         }
 733
 734         private static BindingManager fgLocalBindingManager;
 735         static {
 736                 fgLocalBindingManager= new BindingManager(new ContextManager(), new CommandManager());
 737                 final IBindingService bindingService= (IBindingService)PlatformUI.getWorkbench().getService(IBindingService.class);
 738                 final Scheme[] definedSchemes= bindingService.getDefinedSchemes();
 739                 if (definedSchemes != null) {
 740                         try {
 741                                 for (int i = 0; i < definedSchemes.length; i++) {
 742                                         final Scheme scheme= definedSchemes[i];
 743                                         final Scheme copy= fgLocalBindingManager.getScheme(scheme.getId());
 744                                         copy.define(scheme.getName(), scheme.getDescription(), scheme.getParentId());
 745                                 }
 746                         } catch (final NotDefinedException e) {
 747                                 JavaPlugin.log(e);
 748                         }
 749                 }
 750                 fgLocalBindingManager.setLocale(bindingService.getLocale());
 751                 fgLocalBindingManager.setPlatform(bindingService.getPlatform());
 752         }
 753
 754         private static String getKeyboardShortcut(ParameterizedCommand command) {
 755                 IBindingService bindingService= (IBindingService) PlatformUI.getWorkbench().getAdapter(IBindingService.class);
 756                 fgLocalBindingManager.setBindings(bindingService.getBindings());
 757                 try {
 758                         Scheme activeScheme= bindingService.getActiveScheme();
 759                         if (activeScheme != null)
 760                                 fgLocalBindingManager.setActiveScheme(activeScheme);
 761                 } catch (NotDefinedException e) {
 762                         JavaPlugin.log(e);
 763                 }
 764
 765                 TriggerSequence[] bindings= fgLocalBindingManager.getActiveBindingsDisregardingContextFor(command);
 766                 if (bindings.length > 0)
 767                         return bindings[0].format();
 768                 return null;
 769         }
 770
 771         private Image getImage(ImageDescriptor imgDesc) {
 772                 if (imgDesc == null)
 773                         return null;
 774
 775                 Image img= fImages.get(imgDesc);
 776                 if (img == null) {
 777                         img= imgDesc.createImage(false);
 778                         fImages.put(imgDesc, img);
 779                 }
 780                 return img;
 781         }
 782
 783 }