secure.phpeclipse.com Git - phpeclipse.git/blob

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11
  12 package net.sourceforge.phpdt.internal.ui.preferences;
  13
  14 import java.util.HashMap;
  15 import java.util.StringTokenizer;
  16
  17 import net.sourceforge.phpdt.internal.ui.dialogs.StatusInfo;
  18 import net.sourceforge.phpdt.internal.ui.dialogs.StatusUtil;
  19 import net.sourceforge.phpdt.internal.ui.text.java.hover.JavaEditorTextHoverDescriptor;
  20 import net.sourceforge.phpdt.internal.ui.util.PixelConverter;
  21 import net.sourceforge.phpdt.ui.PreferenceConstants;
  22 import net.sourceforge.phpeclipse.ui.WebUI;
  23 //import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  24
  25 import org.eclipse.core.runtime.IStatus;
  26 import org.eclipse.jface.action.Action;
  27 import org.eclipse.jface.dialogs.Dialog;
  28 import org.eclipse.jface.preference.IPreferenceStore;
  29 //incastrix
  30 //import org.eclipse.jface.text.Assert;
  31 import org.eclipse.core.runtime.Assert;
  32 import org.eclipse.swt.SWT;
  33 import org.eclipse.swt.events.KeyEvent;
  34 import org.eclipse.swt.events.KeyListener;
  35 import org.eclipse.swt.events.ModifyEvent;
  36 import org.eclipse.swt.events.ModifyListener;
  37 import org.eclipse.swt.events.SelectionEvent;
  38 import org.eclipse.swt.events.SelectionListener;
  39 import org.eclipse.swt.graphics.Point;
  40 import org.eclipse.swt.layout.GridData;
  41 import org.eclipse.swt.layout.GridLayout;
  42 import org.eclipse.swt.widgets.Button;
  43 import org.eclipse.swt.widgets.Composite;
  44 import org.eclipse.swt.widgets.Control;
  45 import org.eclipse.swt.widgets.Label;
  46 import org.eclipse.swt.widgets.List;
  47 import org.eclipse.swt.widgets.Text;
  48
  49 /**
  50  * Configures Java Editor hover preferences.
  51  *
  52  * @since 2.1
  53  */
  54 class JavaEditorHoverConfigurationBlock {
  55
  56         private static final String DELIMITER = PreferencesMessages
  57                         .getString("JavaEditorHoverConfigurationBlock.delimiter"); //$NON-NLS-1$
  58
  59         // Data structure to hold the values which are edited by the user
  60         private static class HoverConfig {
  61
  62                 private String fModifierString;
  63
  64                 private boolean fIsEnabled;
  65
  66                 private int fStateMask;
  67
  68                 private HoverConfig(String modifier, int stateMask, boolean enabled) {
  69                         fModifierString = modifier;
  70                         fIsEnabled = enabled;
  71                         fStateMask = stateMask;
  72                 }
  73         }
  74
  75         private IPreferenceStore fStore;
  76
  77         private HoverConfig[] fHoverConfigs;
  78
  79         private Text fModifierEditor;
  80
  81         private Button fEnableField;
  82
  83         private List fHoverList;
  84
  85         private Text fDescription;
  86
  87         private Button fShowHoverAffordanceCheckbox;
  88
  89         private JavaEditorPreferencePage fMainPreferencePage;
  90
  91         private StatusInfo fStatus;
  92
  93         public JavaEditorHoverConfigurationBlock(
  94                         JavaEditorPreferencePage mainPreferencePage, IPreferenceStore store) {
  95                 Assert.isNotNull(mainPreferencePage);
  96                 Assert.isNotNull(store);
  97                 fMainPreferencePage = mainPreferencePage;
  98                 fStore = store;
  99         }
 100
 101         /**
 102          * Creates page for hover preferences.
 103          */
 104         public Control createControl(Composite parent) {
 105
 106                 PixelConverter pixelConverter = new PixelConverter(parent);
 107
 108                 Composite hoverComposite = new Composite(parent, SWT.NULL);
 109                 GridLayout layout = new GridLayout();
 110                 layout.numColumns = 2;
 111                 hoverComposite.setLayout(layout);
 112                 GridData gd = new GridData(GridData.GRAB_HORIZONTAL
 113                                 | GridData.VERTICAL_ALIGN_FILL);
 114                 hoverComposite.setLayoutData(gd);
 115
 116                 Label label = new Label(hoverComposite, SWT.NONE);
 117                 label
 118                                 .setText(PreferencesMessages
 119                                                 .getString("JavaEditorHoverConfigurationBlock.hoverPreferences")); //$NON-NLS-1$
 120                 gd = new GridData(GridData.FILL_HORIZONTAL);
 121                 gd.horizontalAlignment = GridData.BEGINNING;
 122                 gd.horizontalSpan = 2;
 123                 label.setLayoutData(gd);
 124                 gd = new GridData(GridData.GRAB_HORIZONTAL
 125                                 | GridData.VERTICAL_ALIGN_FILL);
 126
 127                 // Hover list
 128                 fHoverList = new List(hoverComposite, SWT.SINGLE | SWT.V_SCROLL
 129                                 | SWT.BORDER);
 130                 gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING
 131                                 | GridData.FILL_HORIZONTAL);
 132                 int listHeight = 10 * fHoverList.getItemHeight();
 133                 gd.heightHint = listHeight;
 134                 fHoverList.setLayoutData(gd);
 135                 fHoverList.addSelectionListener(new SelectionListener() {
 136                         public void widgetSelected(SelectionEvent e) {
 137                                 handleHoverListSelection();
 138                         }
 139
 140                         public void widgetDefaultSelected(SelectionEvent e) {
 141                         }
 142                 });
 143
 144                 Composite stylesComposite = new Composite(hoverComposite, SWT.NONE);
 145                 layout = new GridLayout();
 146                 layout.marginHeight = 0;
 147                 layout.marginWidth = 0;
 148                 layout.numColumns = 2;
 149                 stylesComposite.setLayout(layout);
 150                 gd = new GridData(GridData.FILL_HORIZONTAL);
 151                 gd.heightHint = listHeight + (2 * fHoverList.getBorderWidth());
 152                 stylesComposite.setLayoutData(gd);
 153
 154                 // Enabled checkbox
 155                 fEnableField = new Button(stylesComposite, SWT.CHECK);
 156                 fEnableField.setText(PreferencesMessages
 157                                 .getString("JavaEditorHoverConfigurationBlock.enabled")); //$NON-NLS-1$
 158                 gd = new GridData(GridData.FILL_HORIZONTAL);
 159                 gd.horizontalAlignment = GridData.BEGINNING;
 160                 gd.horizontalSpan = 2;
 161                 fEnableField.setLayoutData(gd);
 162                 fEnableField.addSelectionListener(new SelectionListener() {
 163                         public void widgetSelected(SelectionEvent e) {
 164                                 int i = fHoverList.getSelectionIndex();
 165                                 boolean state = fEnableField.getSelection();
 166                                 fModifierEditor.setEnabled(state);
 167                                 fHoverConfigs[i].fIsEnabled = state;
 168                                 handleModifierModified();
 169                         }
 170
 171                         public void widgetDefaultSelected(SelectionEvent e) {
 172                         }
 173                 });
 174
 175                 // Text field for modifier string
 176                 label = new Label(stylesComposite, SWT.LEFT);
 177                 label.setText(PreferencesMessages
 178                                 .getString("JavaEditorHoverConfigurationBlock.keyModifier")); //$NON-NLS-1$
 179                 fModifierEditor = new Text(stylesComposite, SWT.BORDER);
 180                 gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
 181                 fModifierEditor.setLayoutData(gd);
 182
 183                 fModifierEditor.addKeyListener(new KeyListener() {
 184                         private boolean isModifierCandidate;
 185
 186                         public void keyPressed(KeyEvent e) {
 187                                 isModifierCandidate = e.keyCode > 0 && e.character == 0
 188                                                 && e.stateMask == 0;
 189                         }
 190
 191                         public void keyReleased(KeyEvent e) {
 192                                 if (isModifierCandidate && e.stateMask > 0
 193                                                 && e.stateMask == e.stateMask && e.character == 0) {// &&
 194                                                                                                                                                         // e.time
 195                                                                                                                                                         // -time
 196                                                                                                                                                         // <
 197                                                                                                                                                         // 1000)
 198                                                                                                                                                         // {
 199                                         String text = fModifierEditor.getText();
 200                                         Point selection = fModifierEditor.getSelection();
 201                                         int i = selection.x - 1;
 202                                         while (i > -1 && Character.isWhitespace(text.charAt(i))) {
 203                                                 i--;
 204                                         }
 205                                         boolean needsPrefixDelimiter = i > -1
 206                                                         && !String.valueOf(text.charAt(i))
 207                                                                         .equals(DELIMITER);
 208
 209                                         i = selection.y;
 210                                         while (i < text.length()
 211                                                         && Character.isWhitespace(text.charAt(i))) {
 212                                                 i++;
 213                                         }
 214                                         boolean needsPostfixDelimiter = i < text.length()
 215                                                         && !String.valueOf(text.charAt(i))
 216                                                                         .equals(DELIMITER);
 217
 218                                         String insertString;
 219
 220                                         if (needsPrefixDelimiter && needsPostfixDelimiter)
 221                                                 insertString = PreferencesMessages
 222                                                                 .getFormattedString(
 223                                                                                 "JavaEditorHoverConfigurationBlock.insertDelimiterAndModifierAndDelimiter", new String[] { Action.findModifierString(e.stateMask) }); //$NON-NLS-1$
 224                                         else if (needsPrefixDelimiter)
 225                                                 insertString = PreferencesMessages
 226                                                                 .getFormattedString(
 227                                                                                 "JavaEditorHoverConfigurationBlock.insertDelimiterAndModifier", new String[] { Action.findModifierString(e.stateMask) }); //$NON-NLS-1$
 228                                         else if (needsPostfixDelimiter)
 229                                                 insertString = PreferencesMessages
 230                                                                 .getFormattedString(
 231                                                                                 "JavaEditorHoverConfigurationBlock.insertModifierAndDelimiter", new String[] { Action.findModifierString(e.stateMask) }); //$NON-NLS-1$
 232                                         else
 233                                                 insertString = Action.findModifierString(e.stateMask);
 234
 235                                         if (insertString != null)
 236                                                 fModifierEditor.insert(insertString);
 237                                 }
 238                         }
 239                 });
 240
 241                 fModifierEditor.addModifyListener(new ModifyListener() {
 242                         public void modifyText(ModifyEvent e) {
 243                                 handleModifierModified();
 244                         }
 245                 });
 246
 247                 // Description
 248                 Label descriptionLabel = new Label(stylesComposite, SWT.LEFT);
 249                 descriptionLabel.setText(PreferencesMessages
 250                                 .getString("JavaEditorHoverConfigurationBlock.description")); //$NON-NLS-1$
 251                 gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING);
 252                 gd.horizontalSpan = 2;
 253                 descriptionLabel.setLayoutData(gd);
 254                 fDescription = new Text(stylesComposite, SWT.LEFT | SWT.WRAP
 255                                 | SWT.MULTI | SWT.READ_ONLY | SWT.BORDER);
 256                 gd = new GridData(GridData.FILL_BOTH);
 257                 gd.horizontalSpan = 2;
 258                 fDescription.setLayoutData(gd);
 259
 260                 // Vertical filler
 261                 Label filler = new Label(hoverComposite, SWT.LEFT);
 262                 gd = new GridData(GridData.BEGINNING | GridData.VERTICAL_ALIGN_FILL);
 263                 gd.heightHint = pixelConverter.convertHeightInCharsToPixels(1) / 3;
 264                 filler.setLayoutData(gd);
 265
 266                 // Affordance checkbox
 267                 fShowHoverAffordanceCheckbox = new Button(hoverComposite, SWT.CHECK);
 268                 fShowHoverAffordanceCheckbox.setText(PreferencesMessages
 269                                 .getString("JavaEditorHoverConfigurationBlock.showAffordance")); //$NON-NLS-1$
 270                 gd = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
 271                 gd.horizontalIndent = 0;
 272                 gd.horizontalSpan = 2;
 273                 fShowHoverAffordanceCheckbox.setLayoutData(gd);
 274
 275                 initialize();
 276
 277                 Dialog.applyDialogFont(hoverComposite);
 278                 return hoverComposite;
 279         }
 280
 281         private JavaEditorTextHoverDescriptor[] getContributedHovers() {
 282                 return WebUI.getDefault()
 283                                 .getJavaEditorTextHoverDescriptors();
 284         }
 285
 286         void initialize() {
 287                 JavaEditorTextHoverDescriptor[] hoverDescs = getContributedHovers();
 288                 fHoverConfigs = new HoverConfig[hoverDescs.length];
 289                 for (int i = 0; i < hoverDescs.length; i++) {
 290                         fHoverConfigs[i] = new HoverConfig(hoverDescs[i]
 291                                         .getModifierString(), hoverDescs[i].getStateMask(),
 292                                         hoverDescs[i].isEnabled());
 293                         fHoverList.add(hoverDescs[i].getLabel());
 294                 }
 295                 initializeFields();
 296         }
 297
 298         void initializeFields() {
 299                 fHoverList.getDisplay().asyncExec(new Runnable() {
 300                         public void run() {
 301                                 if (fHoverList != null && !fHoverList.isDisposed()) {
 302                                         fHoverList.select(0);
 303                                         handleHoverListSelection();
 304                                 }
 305                         }
 306                 });
 307                 fShowHoverAffordanceCheckbox
 308                                 .setSelection(fStore
 309                                                 .getBoolean(PreferenceConstants.EDITOR_SHOW_TEXT_HOVER_AFFORDANCE));
 310         }
 311
 312         void performOk() {
 313                 StringBuffer buf = new StringBuffer();
 314                 StringBuffer maskBuf = new StringBuffer();
 315                 for (int i = 0; i < fHoverConfigs.length; i++) {
 316                         buf.append(getContributedHovers()[i].getId());
 317                         buf.append(JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
 318                         if (!fHoverConfigs[i].fIsEnabled)
 319                                 buf.append(JavaEditorTextHoverDescriptor.DISABLED_TAG);
 320                         String modifier = fHoverConfigs[i].fModifierString;
 321                         if (modifier == null || modifier.length() == 0)
 322                                 modifier = JavaEditorTextHoverDescriptor.NO_MODIFIER;
 323                         buf.append(modifier);
 324                         buf.append(JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
 325
 326                         maskBuf.append(getContributedHovers()[i].getId());
 327                         maskBuf.append(JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
 328                         maskBuf.append(fHoverConfigs[i].fStateMask);
 329                         maskBuf.append(JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
 330                 }
 331                 fStore.setValue(PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIERS, buf
 332                                 .toString());
 333                 fStore.setValue(PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIER_MASKS,
 334                                 maskBuf.toString());
 335
 336                 fStore.setValue(PreferenceConstants.EDITOR_SHOW_TEXT_HOVER_AFFORDANCE,
 337                                 fShowHoverAffordanceCheckbox.getSelection());
 338
 339                 WebUI.getDefault().resetJavaEditorTextHoverDescriptors();
 340         }
 341
 342         void performDefaults() {
 343                 restoreFromPreferences();
 344                 initializeFields();
 345         }
 346
 347         private void restoreFromPreferences() {
 348
 349                 fShowHoverAffordanceCheckbox
 350                                 .setSelection(fStore
 351                                                 .getBoolean(PreferenceConstants.EDITOR_SHOW_TEXT_HOVER_AFFORDANCE));
 352
 353                 String compiledTextHoverModifiers = fStore
 354                                 .getString(PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIERS);
 355
 356                 StringTokenizer tokenizer = new StringTokenizer(
 357                                 compiledTextHoverModifiers,
 358                                 JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
 359                 HashMap idToModifier = new HashMap(tokenizer.countTokens() / 2);
 360
 361                 while (tokenizer.hasMoreTokens()) {
 362                         String id = tokenizer.nextToken();
 363                         if (tokenizer.hasMoreTokens())
 364                                 idToModifier.put(id, tokenizer.nextToken());
 365                 }
 366
 367                 String compiledTextHoverModifierMasks = WebUI.getDefault()
 368                                 .getPreferenceStore().getString(
 369                                                 PreferenceConstants.EDITOR_TEXT_HOVER_MODIFIER_MASKS);
 370
 371                 tokenizer = new StringTokenizer(compiledTextHoverModifierMasks,
 372                                 JavaEditorTextHoverDescriptor.VALUE_SEPARATOR);
 373                 HashMap idToModifierMask = new HashMap(tokenizer.countTokens() / 2);
 374
 375                 while (tokenizer.hasMoreTokens()) {
 376                         String id = tokenizer.nextToken();
 377                         if (tokenizer.hasMoreTokens())
 378                                 idToModifierMask.put(id, tokenizer.nextToken());
 379                 }
 380
 381                 for (int i = 0; i < fHoverConfigs.length; i++) {
 382                         String modifierString = (String) idToModifier
 383                                         .get(getContributedHovers()[i].getId());
 384                         boolean enabled = true;
 385                         if (modifierString == null)
 386                                 modifierString = JavaEditorTextHoverDescriptor.DISABLED_TAG;
 387
 388                         if (modifierString
 389                                         .startsWith(JavaEditorTextHoverDescriptor.DISABLED_TAG)) {
 390                                 enabled = false;
 391                                 modifierString = modifierString.substring(1);
 392                         }
 393
 394                         if (modifierString
 395                                         .equals(JavaEditorTextHoverDescriptor.NO_MODIFIER))
 396                                 modifierString = ""; //$NON-NLS-1$
 397
 398                         fHoverConfigs[i].fModifierString = modifierString;
 399                         fHoverConfigs[i].fIsEnabled = enabled;
 400                         fHoverConfigs[i].fStateMask = JavaEditorTextHoverDescriptor
 401                                         .computeStateMask(modifierString);
 402
 403                         if (fHoverConfigs[i].fStateMask == -1) {
 404                                 try {
 405                                         fHoverConfigs[i].fStateMask = Integer
 406                                                         .parseInt((String) idToModifierMask
 407                                                                         .get(getContributedHovers()[i].getId()));
 408                                 } catch (NumberFormatException ex) {
 409                                         fHoverConfigs[i].fStateMask = -1;
 410                                 }
 411                         }
 412                 }
 413         }
 414
 415         private void handleModifierModified() {
 416                 int i = fHoverList.getSelectionIndex();
 417                 String modifiers = fModifierEditor.getText();
 418                 fHoverConfigs[i].fModifierString = modifiers;
 419                 fHoverConfigs[i].fStateMask = JavaEditorTextHoverDescriptor
 420                                 .computeStateMask(modifiers);
 421                 if (fHoverConfigs[i].fIsEnabled && fHoverConfigs[i].fStateMask == -1)
 422                         fStatus = new StatusInfo(
 423                                         IStatus.ERROR,
 424                                         PreferencesMessages
 425                                                         .getFormattedString(
 426                                                                         "JavaEditorHoverConfigurationBlock.modifierIsNotValid", fHoverConfigs[i].fModifierString)); //$NON-NLS-1$
 427                 else
 428                         fStatus = new StatusInfo();
 429                 updateStatus();
 430         }
 431
 432         private void handleHoverListSelection() {
 433                 int i = fHoverList.getSelectionIndex();
 434                 boolean enabled = fHoverConfigs[i].fIsEnabled;
 435                 fEnableField.setSelection(enabled);
 436                 fModifierEditor.setEnabled(enabled);
 437                 fModifierEditor.setText(fHoverConfigs[i].fModifierString);
 438                 String description = getContributedHovers()[i].getDescription();
 439                 if (description == null)
 440                         description = ""; //$NON-NLS-1$
 441                 fDescription.setText(description);
 442         }
 443
 444         IStatus getStatus() {
 445                 if (fStatus == null)
 446                         fStatus = new StatusInfo();
 447                 return fStatus;
 448         }
 449
 450         private void updateStatus() {
 451                 int i = 0;
 452                 HashMap stateMasks = new HashMap(fHoverConfigs.length);
 453                 while (fStatus.isOK() && i < fHoverConfigs.length) {
 454                         if (fHoverConfigs[i].fIsEnabled) {
 455                                 String label = getContributedHovers()[i].getLabel();
 456                                 Integer stateMask = new Integer(fHoverConfigs[i].fStateMask);
 457                                 if (fHoverConfigs[i].fStateMask == -1)
 458                                         fStatus = new StatusInfo(
 459                                                         IStatus.ERROR,
 460                                                         PreferencesMessages
 461                                                                         .getFormattedString(
 462                                                                                         "JavaEditorHoverConfigurationBlock.modifierIsNotValidForHover", new String[] { fHoverConfigs[i].fModifierString, label })); //$NON-NLS-1$
 463                                 else if (stateMasks.containsKey(stateMask))
 464                                         fStatus = new StatusInfo(
 465                                                         IStatus.ERROR,
 466                                                         PreferencesMessages
 467                                                                         .getFormattedString(
 468                                                                                         "JavaEditorHoverConfigurationBlock.duplicateModifier", new String[] { label, (String) stateMasks.get(stateMask) })); //$NON-NLS-1$
 469                                 else
 470                                         stateMasks.put(stateMask, label);
 471                         }
 472                         i++;
 473                 }
 474
 475                 if (fStatus.isOK())
 476                         fMainPreferencePage.updateStatus(fStatus);
 477                 else {
 478                         fMainPreferencePage.setValid(false);
 479                         StatusUtil.applyToStatusLine(fMainPreferencePage, fStatus);
 480                 }
 481         }
 482 }