org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/preferences/GitDecoratorPreferencePage.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2007 IBM Corporation and others.
   3  * Copyright (C) 2009, Tor Arne Vestbø <torarnv@gmail.com>
   4  *
   5  * All rights reserved. This program and the accompanying materials
   6  * are made available under the terms of the Eclipse Public License v1.0
   7  * which accompanies this distribution, and is available at
   8  * http://www.eclipse.org/legal/epl-v10.html
   9  *******************************************************************************/
  10 package org.eclipse.egit.ui.internal.preferences;
  11
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.Collections;
  15 import java.util.HashMap;
  16 import java.util.Iterator;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Observable;
  20 import java.util.Observer;
  21
  22 import org.eclipse.core.resources.IResource;
  23 import org.eclipse.egit.ui.Activator;
  24 import org.eclipse.egit.ui.UIPreferences;
  25 import org.eclipse.egit.ui.UIText;
  26 import org.eclipse.egit.ui.internal.SWTUtils;
  27 import org.eclipse.egit.ui.internal.decorators.IDecoratableResource;
  28 import org.eclipse.egit.ui.internal.decorators.GitLightweightDecorator.DecorationHelper;
  29 import org.eclipse.egit.ui.internal.decorators.IDecoratableResource.Staged;
  30 import org.eclipse.jface.dialogs.Dialog;
  31 import org.eclipse.jface.preference.IPreferenceStore;
  32 import org.eclipse.jface.preference.PreferencePage;
  33 import org.eclipse.jface.preference.PreferenceStore;
  34 import org.eclipse.jface.resource.ImageDescriptor;
  35 import org.eclipse.jface.resource.JFaceResources;
  36 import org.eclipse.jface.resource.LocalResourceManager;
  37 import org.eclipse.jface.resource.ResourceManager;
  38 import org.eclipse.jface.util.IPropertyChangeListener;
  39 import org.eclipse.jface.util.PropertyChangeEvent;
  40 import org.eclipse.jface.viewers.DecorationContext;
  41 import org.eclipse.jface.viewers.DecorationOverlayIcon;
  42 import org.eclipse.jface.viewers.IDecoration;
  43 import org.eclipse.jface.viewers.IDecorationContext;
  44 import org.eclipse.jface.viewers.ILabelProvider;
  45 import org.eclipse.jface.viewers.IStructuredContentProvider;
  46 import org.eclipse.jface.viewers.ITreeContentProvider;
  47 import org.eclipse.jface.viewers.LabelProvider;
  48 import org.eclipse.jface.viewers.TreeViewer;
  49 import org.eclipse.jface.viewers.Viewer;
  50 import org.eclipse.jface.window.Window;
  51 import org.eclipse.swt.SWT;
  52 import org.eclipse.swt.events.ModifyEvent;
  53 import org.eclipse.swt.events.ModifyListener;
  54 import org.eclipse.swt.events.SelectionAdapter;
  55 import org.eclipse.swt.events.SelectionEvent;
  56 import org.eclipse.swt.events.SelectionListener;
  57 import org.eclipse.swt.graphics.Color;
  58 import org.eclipse.swt.graphics.Font;
  59 import org.eclipse.swt.graphics.Image;
  60 import org.eclipse.swt.layout.GridData;
  61 import org.eclipse.swt.layout.GridLayout;
  62 import org.eclipse.swt.widgets.Button;
  63 import org.eclipse.swt.widgets.Composite;
  64 import org.eclipse.swt.widgets.Control;
  65 import org.eclipse.swt.widgets.Event;
  66 import org.eclipse.swt.widgets.Label;
  67 import org.eclipse.swt.widgets.Listener;
  68 import org.eclipse.swt.widgets.Scale;
  69 import org.eclipse.swt.widgets.TabFolder;
  70 import org.eclipse.swt.widgets.TabItem;
  71 import org.eclipse.swt.widgets.Text;
  72 import org.eclipse.swt.widgets.TreeItem;
  73 import org.eclipse.ui.ISharedImages;
  74 import org.eclipse.ui.IWorkbench;
  75 import org.eclipse.ui.IWorkbenchPreferencePage;
  76 import org.eclipse.ui.PlatformUI;
  77 import org.eclipse.ui.dialogs.ListSelectionDialog;
  78 import org.eclipse.ui.ide.IDE.SharedImages;
  79 import org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;
  80
  81 /**
  82  * Preference page for customizing Git label decorations
  83  */
  84 public class GitDecoratorPreferencePage extends PreferencePage implements
  85                 IWorkbenchPreferencePage {
  86
  87         private GeneralTab generalTab;
  88
  89         private TextDecorationTab textDecorationTab;
  90
  91         private IconDecorationTab iconDecorationTab;
  92
  93         private Preview preview;
  94
  95         private static final Collection PREVIEW_FILESYSTEM_ROOT;
  96
  97         private static final Map<String, String> FILE_AND_FOLDER_BINDINGS;
  98
  99         private static final Map<String, String> PROJECT_BINDINGS;
 100
 101         private static IPropertyChangeListener themeListener;
 102
 103         static {
 104                 final PreviewResource project = new PreviewResource(
 105                                 "Project", IResource.PROJECT, "master", true, false, true, Staged.NOT_STAGED, false, false); //$NON-NLS-1$ //$NON-NLS-2$1
 106                 final ArrayList<PreviewResource> children = new ArrayList<PreviewResource>();
 107
 108                 children
 109                                 .add(new PreviewResource(
 110                                                 "folder", IResource.FOLDER, null, true, false, true, Staged.NOT_STAGED, false, false)); //$NON-NLS-1$
 111                 children
 112                                 .add(new PreviewResource(
 113                                                 "tracked.txt", IResource.FILE, null, true, false, false, Staged.NOT_STAGED, false, false)); //$NON-NLS-1$
 114                 children
 115                                 .add(new PreviewResource(
 116                                                 "untracked.txt", IResource.FILE, null, false, false, false, Staged.NOT_STAGED, false, false)); //$NON-NLS-1$
 117                 children
 118                                 .add(new PreviewResource(
 119                                                 "ignored.txt", IResource.FILE, null, false, true, false, Staged.NOT_STAGED, false, false)); //$NON-NLS-1$
 120                 children
 121                                 .add(new PreviewResource(
 122                                                 "dirty.txt", IResource.FILE, null, true, false, true, Staged.NOT_STAGED, false, false)); //$NON-NLS-1$
 123                 children
 124                                 .add(new PreviewResource(
 125                                                 "staged.txt", IResource.FILE, null, true, false, false, Staged.MODIFIED, false, false)); //$NON-NLS-1$
 126                 children
 127                                 .add(new PreviewResource(
 128                                                 "partially-staged.txt", IResource.FILE, null, true, false, true, Staged.MODIFIED, false, false)); //$NON-NLS-1$
 129                 children
 130                                 .add(new PreviewResource(
 131                                                 "added.txt", IResource.FILE, null, true, false, false, Staged.ADDED, false, false)); //$NON-NLS-1$
 132                 children
 133                                 .add(new PreviewResource(
 134                                                 "removed.txt", IResource.FILE, null, true, false, false, Staged.REMOVED, false, false)); //$NON-NLS-1$
 135                 children
 136                                 .add(new PreviewResource(
 137                                                 "conflict.txt", IResource.FILE, null, true, false, true, Staged.NOT_STAGED, true, false)); //$NON-NLS-1$
 138                 children
 139                                 .add(new PreviewResource(
 140                                                 "assume-valid.txt", IResource.FILE, null, true, false, false, Staged.NOT_STAGED, false, true)); //$NON-NLS-1$
 141                 project.children = children;
 142                 PREVIEW_FILESYSTEM_ROOT = Collections.singleton(project);
 143
 144                 FILE_AND_FOLDER_BINDINGS = new HashMap<String, String>();
 145                 FILE_AND_FOLDER_BINDINGS.put(DecorationHelper.BINDING_RESOURCE_NAME,
 146                                 UIText.DecoratorPreferencesPage_bindingResourceName);
 147                 FILE_AND_FOLDER_BINDINGS.put(DecorationHelper.BINDING_DIRTY_FLAG,
 148                                 UIText.DecoratorPreferencesPage_bindingDirtyFlag);
 149                 FILE_AND_FOLDER_BINDINGS.put(DecorationHelper.BINDING_STAGED_FLAG,
 150                                 UIText.DecoratorPreferencesPage_bindingStagedFlag);
 151
 152                 PROJECT_BINDINGS = new HashMap<String, String>();
 153                 PROJECT_BINDINGS.put(DecorationHelper.BINDING_RESOURCE_NAME,
 154                                 UIText.DecoratorPreferencesPage_bindingResourceName);
 155                 PROJECT_BINDINGS.put(DecorationHelper.BINDING_DIRTY_FLAG,
 156                                 UIText.DecoratorPreferencesPage_bindingDirtyFlag);
 157                 PROJECT_BINDINGS.put(DecorationHelper.BINDING_STAGED_FLAG,
 158                                 UIText.DecoratorPreferencesPage_bindingStagedFlag);
 159                 PROJECT_BINDINGS.put(DecorationHelper.BINDING_BRANCH_NAME,
 160                                 UIText.DecoratorPreferencesPage_bindingBranchName);
 161         }
 162
 163         /**
 164          * Constructs a decorator preference page
 165          */
 166         public GitDecoratorPreferencePage() {
 167                 setDescription(UIText.DecoratorPreferencesPage_description);
 168         }
 169
 170         /**
 171          * @see PreferencePage#createContents(Composite)
 172          */
 173         protected Control createContents(Composite parent) {
 174
 175                 Composite composite = SWTUtils.createHVFillComposite(parent,
 176                                 SWTUtils.MARGINS_NONE);
 177
 178                 SWTUtils.createPreferenceLink(
 179                                 (IWorkbenchPreferenceContainer) getContainer(), composite,
 180                                 "org.eclipse.ui.preferencePages.Decorators", //$NON-NLS-1$
 181                                 UIText.DecoratorPreferencesPage_labelDecorationsLink);
 182
 183                 TabFolder tabFolder = new TabFolder(composite, SWT.NONE);
 184                 tabFolder.setLayoutData(SWTUtils.createHVFillGridData());
 185
 186                 generalTab = new GeneralTab(tabFolder);
 187                 textDecorationTab = new TextDecorationTab(tabFolder);
 188                 iconDecorationTab = new IconDecorationTab(tabFolder);
 189
 190                 initializeValues();
 191
 192                 preview = new Preview(composite);
 193                 preview.refresh();
 194
 195                 generalTab.addObserver(preview);
 196                 textDecorationTab.addObserver(preview);
 197                 iconDecorationTab.addObserver(preview);
 198
 199                 // TODO: Add help text for this preference page
 200
 201                 themeListener = new IPropertyChangeListener() {
 202                         public void propertyChange(PropertyChangeEvent event) {
 203                                 preview.refresh();
 204                         }
 205                 };
 206                 PlatformUI.getWorkbench().getThemeManager().addPropertyChangeListener(
 207                                 themeListener);
 208
 209                 Dialog.applyDialogFont(parent);
 210
 211                 return composite;
 212         }
 213
 214         /**
 215          * Wrapper class for TabItems used in the preference page TabFolder
 216          *
 217          * The reason for this wrapper is mainly that the class TabItem is not
 218          * supposed to be subclassed.
 219          *
 220          * When controls in the tab change it will emit update() to any registered
 221          * observers. This is currently used for updating the decoration preview.
 222          */
 223         private abstract class Tab extends Observable {
 224                 public abstract void initializeValues(IPreferenceStore store);
 225
 226                 public abstract void performDefaults(IPreferenceStore store);
 227
 228                 public abstract void performOk(IPreferenceStore store);
 229         }
 230
 231         /**
 232          * Tab page for general preferences related to decoration
 233          */
 234         private class GeneralTab extends Tab implements SelectionListener {
 235
 236                 private Button recomputeAncestorDecorations;
 237
 238                 private Scale containerRecurseLimit;
 239
 240                 public GeneralTab(TabFolder parent) {
 241                         Composite composite = SWTUtils.createHVFillComposite(parent,
 242                                         SWTUtils.MARGINS_DEFAULT, 1);
 243
 244                         recomputeAncestorDecorations = SWTUtils
 245                                         .createCheckBox(
 246                                                         composite,
 247                                                         UIText.DecoratorPreferencesPage_recomputeAncestorDecorations);
 248                         recomputeAncestorDecorations
 249                                         .setToolTipText(UIText.DecoratorPreferencesPage_recomputeAncestorDecorationsTooltip);
 250
 251                         SWTUtils.createLabel(composite,
 252                                         UIText.DecoratorPreferencesPage_computeRecursiveLimit);
 253                         containerRecurseLimit = createLabeledScaleControl(composite);
 254                         containerRecurseLimit
 255                                         .setToolTipText(UIText.DecoratorPreferencesPage_computeRecursiveLimitTooltip);
 256
 257                         recomputeAncestorDecorations.addSelectionListener(this);
 258                         containerRecurseLimit.addSelectionListener(this);
 259
 260                         final TabItem tabItem = new TabItem(parent, SWT.NONE);
 261                         tabItem.setText(UIText.DecoratorPreferencesPage_generalTabFolder);
 262                         tabItem.setControl(composite);
 263                 }
 264
 265                 public void initializeValues(IPreferenceStore store) {
 266                         recomputeAncestorDecorations.setSelection(store
 267                                         .getBoolean(UIPreferences.DECORATOR_RECOMPUTE_ANCESTORS));
 268                         containerRecurseLimit.setSelection(store
 269                                         .getInt(UIPreferences.DECORATOR_RECURSIVE_LIMIT));
 270                 }
 271
 272                 public void performDefaults(IPreferenceStore store) {
 273                         recomputeAncestorDecorations
 274                                         .setSelection(store
 275                                                         .getDefaultBoolean(UIPreferences.DECORATOR_RECOMPUTE_ANCESTORS));
 276                         containerRecurseLimit.setSelection(store
 277                                         .getDefaultInt(UIPreferences.DECORATOR_RECURSIVE_LIMIT));
 278                 }
 279
 280                 public void performOk(IPreferenceStore store) {
 281                         store.setValue(UIPreferences.DECORATOR_RECOMPUTE_ANCESTORS,
 282                                         recomputeAncestorDecorations.getSelection());
 283                         store.setValue(UIPreferences.DECORATOR_RECURSIVE_LIMIT,
 284                                         containerRecurseLimit.getSelection());
 285                 }
 286
 287                 public void widgetSelected(SelectionEvent e) {
 288                         setChanged();
 289                         notifyObservers();
 290                 }
 291
 292                 public void widgetDefaultSelected(SelectionEvent e) {
 293                         // Not interesting for us
 294                 }
 295
 296                 private Scale createLabeledScaleControl(Composite parent) {
 297
 298                         final int[] values = new int[] { 0, 1, 2, 3, 5, 10, 15, 20, 50,
 299                                         100, Integer.MAX_VALUE };
 300
 301                         Composite composite = SWTUtils.createHVFillComposite(parent,
 302                                         SWTUtils.MARGINS_DEFAULT);
 303
 304                         Composite labels = SWTUtils.createHVFillComposite(composite,
 305                                         SWTUtils.MARGINS_NONE, values.length);
 306                         GridLayout labelsLayout = (GridLayout) labels.getLayout();
 307                         labelsLayout.makeColumnsEqualWidth = true;
 308                         labelsLayout.horizontalSpacing = 0;
 309                         labels.setLayoutData(SWTUtils.createGridData(-1, -1, SWT.FILL,
 310                                         SWT.FILL, false, false));
 311
 312                         for (int i = 0; i < values.length; ++i) {
 313                                 Label label = SWTUtils.createLabel(labels, "" + values[i]); //$NON-NLS-1$
 314                                 if (i == 0) {
 315                                         label.setAlignment(SWT.LEFT);
 316                                         label.setText("Off"); //$NON-NLS-1$
 317                                 } else if (i == values.length - 1) {
 318                                         label.setAlignment(SWT.RIGHT);
 319                                         label.setText("Inf."); //$NON-NLS-1$
 320                                 } else {
 321                                         label.setAlignment(SWT.CENTER);
 322                                 }
 323                         }
 324
 325                         final Scale scale = new Scale(composite, SWT.HORIZONTAL);
 326                         scale.setLayoutData(SWTUtils.createHVFillGridData());
 327                         scale.setMaximum(values.length - 1);
 328                         scale.setMinimum(0);
 329                         scale.setIncrement(1);
 330                         scale.setPageIncrement(1);
 331
 332                         scale.addListener(SWT.Selection, new Listener() {
 333                                 public void handleEvent(Event event) {
 334                                         // Workaround for GTK treating the slider as stepless
 335                                         scale.setSelection(scale.getSelection());
 336                                 }
 337                         });
 338
 339                         return scale;
 340                 }
 341         }
 342
 343         /**
 344          * The tab page for text-decoration preferences
 345          */
 346         private class TextDecorationTab extends Tab implements ModifyListener {
 347
 348                 private final FormatEditor fileTextFormat;
 349
 350                 private final FormatEditor folderTextFormat;
 351
 352                 private final FormatEditor projectTextFormat;
 353
 354                 public TextDecorationTab(TabFolder parent) {
 355                         Composite composite = SWTUtils.createHVFillComposite(parent,
 356                                         SWTUtils.MARGINS_DEFAULT, 3);
 357
 358                         fileTextFormat = new FormatEditor(composite,
 359                                         UIText.DecoratorPreferencesPage_fileFormatLabel,
 360                                         UIText.DecoratorPreferencesPage_addVariablesAction,
 361                                         FILE_AND_FOLDER_BINDINGS,
 362                                         UIPreferences.DECORATOR_FILETEXT_DECORATION);
 363                         folderTextFormat = new FormatEditor(composite,
 364                                         UIText.DecoratorPreferencesPage_folderFormatLabel,
 365                                         UIText.DecoratorPreferencesPage_addVariablesAction,
 366                                         FILE_AND_FOLDER_BINDINGS,
 367                                         UIPreferences.DECORATOR_FOLDERTEXT_DECORATION);
 368                         projectTextFormat = new FormatEditor(composite,
 369                                         UIText.DecoratorPreferencesPage_projectFormatLabel,
 370                                         UIText.DecoratorPreferencesPage_addVariablesAction,
 371                                         PROJECT_BINDINGS,
 372                                         UIPreferences.DECORATOR_PROJECTTEXT_DECORATION);
 373
 374                         fileTextFormat.addModifyListener(this);
 375                         folderTextFormat.addModifyListener(this);
 376                         projectTextFormat.addModifyListener(this);
 377
 378                         final TabItem tabItem = new TabItem(parent, SWT.NONE);
 379                         tabItem.setText(UIText.DecoratorPreferencesPage_textLabel);
 380                         tabItem.setControl(composite);
 381                 }
 382
 383                 public void initializeValues(IPreferenceStore store) {
 384                         fileTextFormat.initializeValue(store);
 385                         folderTextFormat.initializeValue(store);
 386                         projectTextFormat.initializeValue(store);
 387                 }
 388
 389                 public void performDefaults(IPreferenceStore store) {
 390                         fileTextFormat.performDefaults(store);
 391                         folderTextFormat.performDefaults(store);
 392                         projectTextFormat.performDefaults(store);
 393                 }
 394
 395                 public void performOk(IPreferenceStore store) {
 396                         fileTextFormat.performOk(store);
 397                         folderTextFormat.performOk(store);
 398                         projectTextFormat.performOk(store);
 399                 }
 400
 401                 public void modifyText(ModifyEvent e) {
 402                         setChanged();
 403                         notifyObservers();
 404                 }
 405
 406                 private class FormatEditor extends SelectionAdapter {
 407                         private final Text text;
 408
 409                         private final Map bindings;
 410
 411                         private final String key;
 412
 413                         public FormatEditor(Composite composite, String title,
 414                                         String buttonText, Map bindings, String key) {
 415
 416                                 this.key = key;
 417                                 this.bindings = bindings;
 418
 419                                 final Label label = SWTUtils.createLabel(composite, title);
 420                                 label.setLayoutData(SWTUtils.createGridData(SWT.DEFAULT,
 421                                                 SWT.DEFAULT, false, false));
 422
 423                                 text = SWTUtils.createText(composite);
 424
 425                                 final Button button = new Button(composite, SWT.NONE);
 426                                 button.setText(buttonText);
 427                                 button.setLayoutData(new GridData());
 428
 429                                 button.addSelectionListener(this);
 430                         }
 431
 432                         public void addModifyListener(ModifyListener listener) {
 433                                 text.addModifyListener(listener);
 434                         }
 435
 436                         public String getText() {
 437                                 return text.getText();
 438                         }
 439
 440                         public void widgetSelected(SelectionEvent e) {
 441                                 final ILabelProvider labelProvider = new LabelProvider() {
 442                                         public String getText(Object element) {
 443                                                 return ((Map.Entry) element).getKey()
 444                                                                 + " - " + ((Map.Entry) element).getValue(); //$NON-NLS-1$
 445                                         }
 446                                 };
 447
 448                                 final IStructuredContentProvider contentsProvider = new IStructuredContentProvider() {
 449                                         public Object[] getElements(Object inputElement) {
 450                                                 return ((Collection) inputElement).toArray();
 451                                         }
 452
 453                                         public void dispose() {
 454                                                 // No-op
 455                                         }
 456
 457                                         public void inputChanged(Viewer viewer, Object oldInput,
 458                                                         Object newInput) {
 459                                                 // No-op
 460                                         }
 461                                 };
 462
 463                                 final ListSelectionDialog dialog = new ListSelectionDialog(text
 464                                                 .getShell(), bindings.entrySet(), contentsProvider,
 465                                                 labelProvider,
 466                                                 UIText.DecoratorPreferencesPage_selectVariablesToAdd);
 467                                 dialog.setHelpAvailable(false);
 468                                 dialog
 469                                                 .setTitle(UIText.DecoratorPreferencesPage_addVariablesTitle);
 470                                 if (dialog.open() != Window.OK)
 471                                         return;
 472
 473                                 Object[] result = dialog.getResult();
 474
 475                                 for (int i = 0; i < result.length; i++) {
 476                                         text.insert("{" + ((Map.Entry) result[i]).getKey() + "}"); //$NON-NLS-1$ //$NON-NLS-2$
 477                                 }
 478                         }
 479
 480                         public void performOk(IPreferenceStore store) {
 481                                 store.setValue(key, text.getText());
 482                         }
 483
 484                         public void performDefaults(IPreferenceStore store) {
 485                                 store.setToDefault(key);
 486                                 text.setText(store.getDefaultString(key));
 487                         }
 488
 489                         public void initializeValue(IPreferenceStore store) {
 490                                 text.setText(store.getString(key));
 491                         }
 492                 }
 493         }
 494
 495         /**
 496          * Tab page for icon-related preferences
 497          */
 498         private class IconDecorationTab extends Tab implements SelectionListener {
 499
 500                 private Button showTracked;
 501
 502                 private Button showUntracked;
 503
 504                 private Button showStaged;
 505
 506                 private Button showConflicts;
 507
 508                 private Button showAssumeValid;
 509
 510                 public IconDecorationTab(TabFolder parent) {
 511                         Composite composite = SWTUtils.createHVFillComposite(parent,
 512                                         SWTUtils.MARGINS_DEFAULT, 2);
 513
 514                         showTracked = SWTUtils.createCheckBox(composite,
 515                                         UIText.DecoratorPreferencesPage_iconsShowTracked);
 516                         showUntracked = SWTUtils.createCheckBox(composite,
 517                                         UIText.DecoratorPreferencesPage_iconsShowUntracked);
 518                         showStaged = SWTUtils.createCheckBox(composite,
 519                                         UIText.DecoratorPreferencesPage_iconsShowStaged);
 520                         showConflicts = SWTUtils.createCheckBox(composite,
 521                                         UIText.DecoratorPreferencesPage_iconsShowConflicts);
 522                         showAssumeValid = SWTUtils.createCheckBox(composite,
 523                                         UIText.DecoratorPreferencesPage_iconsShowAssumeValid);
 524
 525                         showTracked.addSelectionListener(this);
 526                         showUntracked.addSelectionListener(this);
 527                         showStaged.addSelectionListener(this);
 528                         showConflicts.addSelectionListener(this);
 529                         showAssumeValid.addSelectionListener(this);
 530
 531                         final TabItem tabItem = new TabItem(parent, SWT.NONE);
 532                         tabItem.setText(UIText.DecoratorPreferencesPage_iconLabel);
 533                         tabItem.setControl(composite);
 534                 }
 535
 536                 public void initializeValues(IPreferenceStore store) {
 537                         showTracked.setSelection(store
 538                                         .getBoolean(UIPreferences.DECORATOR_SHOW_TRACKED_ICON));
 539                         showUntracked.setSelection(store
 540                                         .getBoolean(UIPreferences.DECORATOR_SHOW_UNTRACKED_ICON));
 541                         showStaged.setSelection(store
 542                                         .getBoolean(UIPreferences.DECORATOR_SHOW_STAGED_ICON));
 543                         showConflicts.setSelection(store
 544                                         .getBoolean(UIPreferences.DECORATOR_SHOW_CONFLICTS_ICON));
 545                         showAssumeValid
 546                                         .setSelection(store
 547                                                         .getBoolean(UIPreferences.DECORATOR_SHOW_ASSUME_VALID_ICON));
 548                 }
 549
 550                 public void performDefaults(IPreferenceStore store) {
 551                         showTracked
 552                                         .setSelection(store
 553                                                         .getDefaultBoolean(UIPreferences.DECORATOR_SHOW_TRACKED_ICON));
 554                         showUntracked
 555                                         .setSelection(store
 556                                                         .getDefaultBoolean(UIPreferences.DECORATOR_SHOW_UNTRACKED_ICON));
 557                         showStaged
 558                                         .setSelection(store
 559                                                         .getDefaultBoolean(UIPreferences.DECORATOR_SHOW_STAGED_ICON));
 560                         showConflicts
 561                                         .setSelection(store
 562                                                         .getDefaultBoolean(UIPreferences.DECORATOR_SHOW_CONFLICTS_ICON));
 563                         showAssumeValid
 564                                         .setSelection(store
 565                                                         .getDefaultBoolean(UIPreferences.DECORATOR_SHOW_ASSUME_VALID_ICON));
 566                 }
 567
 568                 public void performOk(IPreferenceStore store) {
 569                         store.setValue(UIPreferences.DECORATOR_SHOW_TRACKED_ICON,
 570                                         showTracked.getSelection());
 571                         store.setValue(UIPreferences.DECORATOR_SHOW_UNTRACKED_ICON,
 572                                         showUntracked.getSelection());
 573                         store.setValue(UIPreferences.DECORATOR_SHOW_STAGED_ICON, showStaged
 574                                         .getSelection());
 575                         store.setValue(UIPreferences.DECORATOR_SHOW_CONFLICTS_ICON,
 576                                         showConflicts.getSelection());
 577                         store.setValue(UIPreferences.DECORATOR_SHOW_ASSUME_VALID_ICON,
 578                                         showAssumeValid.getSelection());
 579                 }
 580
 581                 public void widgetSelected(SelectionEvent e) {
 582                         setChanged();
 583                         notifyObservers();
 584                 }
 585
 586                 public void widgetDefaultSelected(SelectionEvent e) {
 587                         // Not interesting for us
 588                 }
 589         }
 590
 591         /**
 592          * Initializes states of the controls from the preference store.
 593          */
 594         private void initializeValues() {
 595                 final IPreferenceStore store = getPreferenceStore();
 596                 generalTab.initializeValues(store);
 597                 textDecorationTab.initializeValues(store);
 598                 iconDecorationTab.initializeValues(store);
 599                 setValid(true);
 600         }
 601
 602         /**
 603          * @see IWorkbenchPreferencePage#init(IWorkbench)
 604          */
 605         public void init(IWorkbench workbench) {
 606                 // No-op
 607         }
 608
 609         /**
 610          * OK was clicked. Store the preferences to the plugin store
 611          *
 612          * @return whether it is okay to close the preference page
 613          */
 614         public boolean performOk() {
 615                 IPreferenceStore store = getPreferenceStore();
 616                 final boolean okToClose = performOk(store);
 617                 if (store.needsSaving()) {
 618                         Activator.getDefault().savePluginPreferences();
 619                         Activator.broadcastPropertyChange(new PropertyChangeEvent(this,
 620                                         Activator.DECORATORS_CHANGED, null, null));
 621                 }
 622                 return okToClose;
 623         }
 624
 625         /**
 626          * Store the preferences to the given preference store
 627          *
 628          * @param store
 629          *            the preference store to store the preferences to
 630          *
 631          * @return whether it operation succeeded
 632          */
 633         private boolean performOk(IPreferenceStore store) {
 634                 generalTab.performOk(store);
 635                 textDecorationTab.performOk(store);
 636                 iconDecorationTab.performOk(store);
 637                 return true;
 638         }
 639
 640         /**
 641          * Defaults was clicked. Restore the Git decoration preferences to their
 642          * default values
 643          */
 644         protected void performDefaults() {
 645                 IPreferenceStore store = getPreferenceStore();
 646                 generalTab.performDefaults(store);
 647                 textDecorationTab.performDefaults(store);
 648                 iconDecorationTab.performDefaults(store);
 649                 super.performDefaults();
 650                 preview.refresh();
 651         }
 652
 653         /**
 654          * Returns the preference store that belongs to the our plugin.
 655          *
 656          * This is important because we want to store our preferences separately
 657          * from the desktop.
 658          *
 659          * @return the preference store for this plugin
 660          */
 661         protected IPreferenceStore doGetPreferenceStore() {
 662                 return Activator.getDefault().getPreferenceStore();
 663         }
 664
 665         /*
 666          * (non-Javadoc)
 667          *
 668          * @see org.eclipse.jface.dialogs.DialogPage#dispose()
 669          */
 670         public void dispose() {
 671                 PlatformUI.getWorkbench().getThemeManager()
 672                                 .removePropertyChangeListener(themeListener);
 673                 super.dispose();
 674         }
 675
 676         /**
 677          * Preview control for showing how changes in the dialog will affect
 678          * decoration
 679          */
 680         private class Preview extends LabelProvider implements Observer,
 681                         ITreeContentProvider {
 682
 683                 private final ResourceManager fImageCache;
 684
 685                 private final TreeViewer fViewer;
 686
 687                 private DecorationHelper fHelper;
 688
 689                 public Preview(Composite composite) {
 690                         // Has to happen before the tree control is constructed
 691                         reloadDecorationHelper();
 692                         SWTUtils.createLabel(composite,
 693                                         UIText.DecoratorPreferencesPage_preview);
 694                         fImageCache = new LocalResourceManager(JFaceResources
 695                                         .getResources());
 696
 697                         fViewer = new TreeViewer(composite);
 698                         fViewer.getControl().setLayoutData(SWTUtils.createHVFillGridData());
 699                         fViewer.setContentProvider(this);
 700                         fViewer.setLabelProvider(this);
 701                         fViewer.setInput(PREVIEW_FILESYSTEM_ROOT);
 702                         fViewer.expandAll();
 703                         fHelper = new DecorationHelper(new PreferenceStore());
 704                 }
 705
 706                 private void reloadDecorationHelper() {
 707                         PreferenceStore store = new PreferenceStore();
 708                         performOk(store);
 709                         fHelper = new DecorationHelper(store);
 710                 }
 711
 712                 public void refresh() {
 713                         reloadDecorationHelper();
 714                         fViewer.refresh(true);
 715                         setColorsAndFonts(fViewer.getTree().getItems());
 716                 }
 717
 718                 @SuppressWarnings("unused")
 719                 private void setColorsAndFonts(TreeItem[] items) {
 720                         // TODO: Implement colors and fonts
 721                 }
 722
 723                 public void update(Observable o, Object arg) {
 724                         refresh();
 725                 }
 726
 727                 public Object[] getChildren(Object parentElement) {
 728                         return ((PreviewResource) parentElement).children.toArray();
 729                 }
 730
 731                 public Object getParent(Object element) {
 732                         return null;
 733                 }
 734
 735                 public boolean hasChildren(Object element) {
 736                         return !((PreviewResource) element).children.isEmpty();
 737                 }
 738
 739                 public Object[] getElements(Object inputElement) {
 740                         return ((Collection) inputElement).toArray();
 741                 }
 742
 743                 public void dispose() {
 744                         fImageCache.dispose();
 745                 }
 746
 747                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 748                         // No-op
 749                 }
 750
 751                 public String getText(Object element) {
 752                         final PreviewDecoration decoration = getDecoration(element);
 753                         final StringBuffer buffer = new StringBuffer();
 754                         final String prefix = decoration.getPrefix();
 755                         if (prefix != null)
 756                                 buffer.append(prefix);
 757                         buffer.append(((PreviewResource) element).getName());
 758                         final String suffix = decoration.getSuffix();
 759                         if (suffix != null)
 760                                 buffer.append(suffix);
 761                         return buffer.toString();
 762                 }
 763
 764                 public Image getImage(Object element) {
 765                         final String s;
 766                         switch (((PreviewResource) element).type) {
 767                         case IResource.PROJECT:
 768                                 s = SharedImages.IMG_OBJ_PROJECT;
 769                                 break;
 770                         case IResource.FOLDER:
 771                                 s = ISharedImages.IMG_OBJ_FOLDER;
 772                                 break;
 773                         default:
 774                                 s = ISharedImages.IMG_OBJ_FILE;
 775                                 break;
 776                         }
 777                         final Image baseImage = PlatformUI.getWorkbench().getSharedImages()
 778                                         .getImage(s);
 779                         final ImageDescriptor overlay = getDecoration(element).getOverlay();
 780                         if (overlay == null)
 781                                 return baseImage;
 782                         try {
 783                                 return fImageCache.createImage(new DecorationOverlayIcon(
 784                                                 baseImage, overlay, IDecoration.BOTTOM_RIGHT));
 785                         } catch (Exception e) {
 786                                 Activator.logError(e.getMessage(), e);
 787                         }
 788
 789                         return null;
 790                 }
 791
 792                 private PreviewDecoration getDecoration(Object element) {
 793                         PreviewDecoration decoration = new PreviewDecoration();
 794                         fHelper.decorate(decoration, (PreviewResource) element);
 795                         return decoration;
 796                 }
 797         }
 798
 799         private static class PreviewResource implements IDecoratableResource {
 800                 private final String name;
 801
 802                 private final String branch;
 803
 804                 private final int type;
 805
 806                 private Collection children;
 807
 808                 private boolean tracked;
 809
 810                 private boolean ignored;
 811
 812                 private boolean dirty;
 813
 814                 private boolean conflicts;
 815
 816                 private Staged staged;
 817
 818                 private boolean assumeValid;
 819
 820                 public PreviewResource(String name, int type, String branch,
 821                                 boolean tracked, boolean ignored, boolean dirty, Staged staged,
 822                                 boolean conflicts, boolean assumeValid) {
 823
 824                         this.name = name;
 825                         this.branch = branch;
 826                         this.type = type;
 827                         this.children = Collections.EMPTY_LIST;
 828                         this.tracked = tracked;
 829                         this.ignored = ignored;
 830                         this.dirty = dirty;
 831                         this.staged = staged;
 832                         this.conflicts = conflicts;
 833                         this.assumeValid = assumeValid;
 834                 }
 835
 836                 public String getName() {
 837                         return name;
 838                 }
 839
 840                 public int getType() {
 841                         return type;
 842                 }
 843
 844                 public String getBranch() {
 845                         return branch;
 846                 }
 847
 848                 public boolean isTracked() {
 849                         return tracked;
 850                 }
 851
 852                 public boolean isIgnored() {
 853                         return ignored;
 854                 }
 855
 856                 public boolean isDirty() {
 857                         return dirty;
 858                 }
 859
 860                 public Staged staged() {
 861                         return staged;
 862                 }
 863
 864                 public boolean hasConflicts() {
 865                         return conflicts;
 866                 }
 867
 868                 public boolean isAssumeValid() {
 869                         return assumeValid;
 870                 }
 871         }
 872
 873         private class PreviewDecoration implements IDecoration {
 874
 875                 private List<String> prefixes = new ArrayList<String>();
 876
 877                 private List<String> suffixes = new ArrayList<String>();
 878
 879                 private ImageDescriptor overlay = null;
 880
 881                 /**
 882                  * Adds an icon overlay to the decoration
 883                  * <p>
 884                  * Copies the behavior of <code>DecorationBuilder</code> of only
 885                  * allowing the overlay to be set once.
 886                  */
 887                 public void addOverlay(ImageDescriptor overlayImage) {
 888                         if (overlay == null)
 889                                 overlay = overlayImage;
 890                 }
 891
 892                 public void addOverlay(ImageDescriptor overlayImage, int quadrant) {
 893                         addOverlay(overlayImage);
 894                 }
 895
 896                 public void addPrefix(String prefix) {
 897                         prefixes.add(prefix);
 898                 }
 899
 900                 public void addSuffix(String suffix) {
 901                         suffixes.add(suffix);
 902                 }
 903
 904                 public IDecorationContext getDecorationContext() {
 905                         return new DecorationContext();
 906                 }
 907
 908                 public void setBackgroundColor(Color color) {
 909                         // TODO: Add support for color
 910                 }
 911
 912                 public void setForegroundColor(Color color) {
 913                         // TODO: Add support for color
 914                 }
 915
 916                 public void setFont(Font font) {
 917                         // TODO: Add support for fonts
 918                 }
 919
 920                 public ImageDescriptor getOverlay() {
 921                         return overlay;
 922                 }
 923
 924                 public String getPrefix() {
 925                         StringBuffer sb = new StringBuffer();
 926                         for (Iterator<String> iter = prefixes.iterator(); iter.hasNext();) {
 927                                 sb.append(iter.next());
 928                         }
 929                         return sb.toString();
 930                 }
 931
 932                 public String getSuffix() {
 933                         StringBuffer sb = new StringBuffer();
 934                         for (Iterator<String> iter = suffixes.iterator(); iter.hasNext();) {
 935                                 sb.append(iter.next());
 936                         }
 937                         return sb.toString();
 938                 }
 939
 940         }
 941 }