* Copyright (C) 2011, 2013 Bernard Leach <leachbj@bouncycastle.org> and others.

*

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*******************************************************************************/

* A GitX style staging view with embedded commit dialog.

*/

  /**

   * Staging view id

   */

  public static final String VIEW_ID = "org.eclipse.egit.ui.StagingView"; //$NON-NLS-1$

  private static final String EMPTY_STRING = ""; //$NON-NLS-1$

  private FormToolkit toolkit;

  private Form form;

  private Section stagedSection;

  private Section unstagedSection;

  private Section commitMessageSection;

  private TreeViewer stagedViewer;

  private TreeViewer unstagedViewer;

  private ToggleableWarningLabel warningLabel;

  private Text filterText;

  private SpellcheckableMessageArea commitMessageText;

  private Text committerText;

  private Text authorText;

  private CommitMessageComponent commitMessageComponent;

  private boolean reactOnSelection = true;

  private ISelectionListener selectionChangedListener;

  private ToolBarManager unstagedToolBarManager;

  private ToolBarManager stagedToolBarManager;

  private Action listPresentationAction;

  private Action treePresentationAction;

  private Action compactTreePresentationAction;

  private Action unstagedExpandAllAction;

  private Action unstagedCollapseAllAction;

  private Action stagedExpandAllAction;

  private Action stagedCollapseAllAction;

  private Repository currentRepository;

  private Presentation presentation = Presentation.LIST;

  private Set<IPath> pathsToExpandInStaged = new HashSet<IPath>();

  private Set<IPath> pathsToExpandInUnstaged = new HashSet<IPath>();

  /**

   * Presentation mode of the staged/unstaged files.

   */

  public enum Presentation {

    /** Show files in flat list */

    LIST,

    /** Show folder structure in full tree */

    TREE,

    /**

     * Show folder structure in compact tree (folders with only one child

     * are folded into parent)

     */

    COMPACT_TREE;

  }

  static class StagingViewUpdate {

    Repository repository;

    IndexDiffData indexDiff;

    Collection<String> changedResources;

    StagingViewUpdate(Repository theRepository,

        IndexDiffData theIndexDiff, Collection<String> theChanges) {

      this.repository = theRepository;

      this.indexDiff = theIndexDiff;

      this.changedResources = theChanges;

    }

  }

  static class StagingDragListener extends DragSourceAdapter {

    private ISelectionProvider provider;

    public StagingDragListener(ISelectionProvider provider) {

      this.provider = provider;

    }

    public void dragStart(DragSourceEvent event) {

      event.doit = !provider.getSelection().isEmpty();

    }

    public void dragFinished(DragSourceEvent event) {

      if (LocalSelectionTransfer.getTransfer().isSupportedType(

          event.dataType))

        LocalSelectionTransfer.getTransfer().setSelection(null);

    }

    public void dragSetData(DragSourceEvent event) {

      IStructuredSelection selection = (IStructuredSelection) provider

          .getSelection();

      if (selection.isEmpty())

        return;

      if (LocalSelectionTransfer.getTransfer().isSupportedType(

          event.dataType)) {

        LocalSelectionTransfer.getTransfer().setSelection(selection);

        return;

      }

      if (FileTransfer.getInstance().isSupportedType(event.dataType)) {

        List<String> files = new ArrayList<String>();

        for (Object selected : selection.toList())

          if (selected instanceof StagingEntry) {

            StagingEntry entry = (StagingEntry) selected;

            File file = new File(

                entry.getRepository().getWorkTree(),

                entry.getPath());

            if (file.exists())

              files.add(file.getAbsolutePath());

          }

        if (!files.isEmpty()) {

          event.data = files.toArray(new String[files.size()]);

          return;

        }

      }

    }

  }

  static class TreeDecoratingLabelProvider extends DecoratingLabelProvider {

    ILabelProvider provider;

    ILabelDecorator decorator;

    public TreeDecoratingLabelProvider(ILabelProvider provider,

        ILabelDecorator decorator) {

      super(provider, decorator);

      this.provider = provider;

      this.decorator = decorator;

    }

    public Image getColumnImage(Object element) {

      Image image = provider.getImage(element);

      if (image != null && decorator != null) {

        Image decorated = decorator.decorateImage(image, element);

        if (decorated != null)

          return decorated;

      }

      return image;

    }

    public String getText(Object element) {

      return provider.getText(element);

    }

  }

  static class StagingViewSearchThread extends Thread {

    private StagingView stagingView;

    private static final Object lock = new Object();

    private volatile static int globalThreadIndex = 0;

    private int currentThreadIx;

    public StagingViewSearchThread(StagingView stagingView) {

      super("staging_view_filter_thread" + ++globalThreadIndex); //$NON-NLS-1$

      this.stagingView = stagingView;

      currentThreadIx = globalThreadIndex;

    }

    public void run() {

      synchronized (lock) {

        if (currentThreadIx < globalThreadIndex)

          return;

        stagingView.refreshViewersPreservingExpandedElements();

      }

    }

  }

  private final IPreferenceChangeListener prefListener = new IPreferenceChangeListener() {

    public void preferenceChange(PreferenceChangeEvent event) {

      if (!RepositoryUtil.PREFS_DIRECTORIES.equals(event.getKey()))

        return;

      final Repository repo = currentRepository;

      if (repo == null)

        return;

      if (Activator.getDefault().getRepositoryUtil().contains(repo))

        return;

      reload(null);

    }

  };

  private Action signedOffByAction;

  private Action addChangeIdAction;

  private Action amendPreviousCommitAction;

  private Action openNewCommitsAction;

  private Action columnLayoutAction;

  private Action fileNameModeAction;

  private Action refreshAction;

  private SashForm stagingSashForm;

  private IndexDiffChangedListener myIndexDiffListener = new IndexDiffChangedListener() {

    public void indexDiffChanged(Repository repository,

        IndexDiffData indexDiffData) {

      reload(repository);

    }

  };

  private IndexDiffCacheEntry cacheEntry;

  private UndoRedoActionGroup undoRedoActionGroup;

  private Button commitButton;

  private Button commitAndPushButton;

  private Section rebaseSection;

  private Button rebaseContinueButton;

  private Button rebaseSkipButton;

  private Button rebaseAbortButton;

  private ListenerHandle refsChangedListener;

  private LocalResourceManager resources = new LocalResourceManager(

      JFaceResources.getResources());

  private boolean disposed;

  private Image getImage(ImageDescriptor descriptor) {

    return (Image) this.resources.get(descriptor);

  }

  @Override

  public void createPartControl(Composite parent) {

    GridLayoutFactory.fillDefaults().applyTo(parent);

    toolkit = new FormToolkit(parent.getDisplay());

    parent.addDisposeListener(new DisposeListener() {

      public void widgetDisposed(DisposeEvent e) {

        if (!commitMessageComponent.isAmending()

            && userEnteredCommitMessage())

          saveCommitMessageComponentState();

        else

          deleteCommitMessageComponentState();

        resources.dispose();

        toolkit.dispose();

      }

    });

    form = toolkit.createForm(parent);

    form.setImage(getImage(UIIcons.REPOSITORY));

    form.setText(UIText.StagingView_NoSelectionTitle);

    GridDataFactory.fillDefaults().grab(true, true).applyTo(form);

    toolkit.decorateFormHeading(form);

    GridLayoutFactory.swtDefaults().applyTo(form.getBody());

    SashForm horizontalSashForm = new SashForm(form.getBody(), SWT.NONE);

    toolkit.adapt(horizontalSashForm, true, true);

    GridDataFactory.fillDefaults().grab(true, true)

        .applyTo(horizontalSashForm);

    stagingSashForm = new SashForm(horizontalSashForm,

        getStagingFormOrientation());

    toolkit.adapt(stagingSashForm, true, true);

    GridDataFactory.fillDefaults().grab(true, true)

        .applyTo(stagingSashForm);

    unstagedSection = toolkit.createSection(stagingSashForm,

        ExpandableComposite.TITLE_BAR);

    createUnstagedToolBarComposite();

    Composite unstagedComposite = toolkit

        .createComposite(unstagedSection);

    toolkit.paintBordersFor(unstagedComposite);

    unstagedSection.setClient(unstagedComposite);

    GridLayoutFactory.fillDefaults().extendedMargins(2, 2, 2, 2)

        .applyTo(unstagedComposite);

    unstagedViewer = createTree(unstagedComposite);

    GridDataFactory.fillDefaults().grab(true, true)

        .applyTo(unstagedViewer.getControl());

    unstagedViewer.getTree().setData(FormToolkit.KEY_DRAW_BORDER,

        FormToolkit.TREE_BORDER);

    unstagedViewer.setLabelProvider(createLabelProvider(unstagedViewer));

    unstagedViewer.setContentProvider(createStagingContentProvider(true));

    unstagedViewer.addDragSupport(DND.DROP_MOVE | DND.DROP_COPY

        | DND.DROP_LINK,

        new Transfer[] { LocalSelectionTransfer.getTransfer(),

            FileTransfer.getInstance() }, new StagingDragListener(

            unstagedViewer));

    unstagedViewer.addDropSupport(DND.DROP_MOVE,

        new Transfer[] { LocalSelectionTransfer.getTransfer() },

        new DropTargetAdapter() {

          public void drop(DropTargetEvent event) {

            // Bug 411466: It is very important that detail is set

            // to DND.DROP_COPY. If it was left as DND.DROP_MOVE and

            // the drag comes from the Navigator view, the code in

            // NavigatorDragAdapter would delete the resources.

            event.detail = DND.DROP_COPY;

            if (event.data instanceof IStructuredSelection) {

              final IStructuredSelection selection = (IStructuredSelection) event.data;

              unstage(selection);

            }

          }

          public void dragOver(DropTargetEvent event) {

            event.detail = DND.DROP_MOVE;

          }

        });

    unstagedViewer.addOpenListener(new IOpenListener() {

      public void open(OpenEvent event) {

        compareWith(event);

      }

    });

    enableAutoExpand(unstagedViewer);

    addListenerToDisableAutoExpandOnCollapse(unstagedViewer);

    Composite rebaseAndCommitComposite = toolkit.createComposite(horizontalSashForm);

    rebaseAndCommitComposite.setLayout(GridLayoutFactory.fillDefaults().create());

    rebaseSection = toolkit.createSection(rebaseAndCommitComposite,

        ExpandableComposite.TITLE_BAR);

    rebaseSection.setText(UIText.StagingView_RebaseLabel);

    Composite rebaseComposite = toolkit.createComposite(rebaseSection);

    toolkit.paintBordersFor(rebaseComposite);

    rebaseSection.setClient(rebaseComposite);

    rebaseSection.setLayoutData(GridDataFactory.fillDefaults().create());

    rebaseComposite.setLayout(GridLayoutFactory.fillDefaults()

        .numColumns(3).equalWidth(true).create());

    GridDataFactory buttonGridData = GridDataFactory.fillDefaults().align(

        SWT.FILL, SWT.CENTER);

    this.rebaseAbortButton = toolkit.createButton(rebaseComposite,

        UIText.StagingView_RebaseAbort, SWT.PUSH);

    rebaseAbortButton.addSelectionListener(new SelectionAdapter() {

      @Override

      public void widgetSelected(SelectionEvent e) {

        rebaseAbort();

      }

    });

    rebaseAbortButton.setImage(getImage(UIIcons.REBASE_ABORT));

    buttonGridData.applyTo(rebaseAbortButton);

    this.rebaseSkipButton = toolkit.createButton(rebaseComposite,

        UIText.StagingView_RebaseSkip, SWT.PUSH);

    rebaseSkipButton.addSelectionListener(new SelectionAdapter() {

      @Override

      public void widgetSelected(SelectionEvent e) {

        rebaseSkip();

      }

    });

    rebaseSkipButton.setImage(getImage(UIIcons.REBASE_SKIP));

    buttonGridData.applyTo(rebaseSkipButton);

    this.rebaseContinueButton = toolkit.createButton(rebaseComposite,

        UIText.StagingView_RebaseContinue, SWT.PUSH);

    rebaseContinueButton.addSelectionListener(new SelectionAdapter() {

      @Override

      public void widgetSelected(SelectionEvent e) {

        rebaseContinue();

      }

    });

    rebaseContinueButton.setImage(getImage(UIIcons.REBASE_CONTINUE));

    buttonGridData.applyTo(rebaseContinueButton);

    showControl(rebaseSection, false);

    commitMessageSection = toolkit.createSection(rebaseAndCommitComposite,

        ExpandableComposite.TITLE_BAR);

    commitMessageSection.setText(UIText.StagingView_CommitMessage);

    commitMessageSection.setLayoutData(GridDataFactory.fillDefaults()

        .grab(true, true).create());

    Composite commitMessageToolbarComposite = toolkit

        .createComposite(commitMessageSection);

    commitMessageToolbarComposite.setBackground(null);

    commitMessageToolbarComposite.setLayout(createRowLayoutWithoutMargin());

    commitMessageSection.setTextClient(commitMessageToolbarComposite);

    ToolBarManager commitMessageToolBarManager = new ToolBarManager(

        SWT.FLAT | SWT.HORIZONTAL);

    amendPreviousCommitAction = new Action(

        UIText.StagingView_Ammend_Previous_Commit, IAction.AS_CHECK_BOX) {

      public void run() {

        commitMessageComponent.setAmendingButtonSelection(isChecked());

        updateMessage();

      }

    };

    amendPreviousCommitAction.setImageDescriptor(UIIcons.AMEND_COMMIT);

    commitMessageToolBarManager.add(amendPreviousCommitAction);

    signedOffByAction = new Action(UIText.StagingView_Add_Signed_Off_By,

        IAction.AS_CHECK_BOX) {

      public void run() {

        commitMessageComponent.setSignedOffButtonSelection(isChecked());

      }

    };

    signedOffByAction.setImageDescriptor(UIIcons.SIGNED_OFF);

    commitMessageToolBarManager.add(signedOffByAction);

    addChangeIdAction = new Action(UIText.StagingView_Add_Change_ID,

        IAction.AS_CHECK_BOX) {

      public void run() {

        commitMessageComponent.setChangeIdButtonSelection(isChecked());

      }

    };

    addChangeIdAction.setImageDescriptor(UIIcons.GERRIT);

    commitMessageToolBarManager.add(addChangeIdAction);

    commitMessageToolBarManager

        .createControl(commitMessageToolbarComposite);

    Composite commitMessageComposite = toolkit

        .createComposite(commitMessageSection);

    commitMessageSection.setClient(commitMessageComposite);

    GridLayoutFactory.fillDefaults().numColumns(1)

        .applyTo(commitMessageComposite);

    warningLabel = new ToggleableWarningLabel(commitMessageComposite,

        SWT.NONE);

    GridDataFactory.fillDefaults().grab(true, false).exclude(true)

        .applyTo(warningLabel);

    Composite commitMessageTextComposite = toolkit

        .createComposite(commitMessageComposite);

    toolkit.paintBordersFor(commitMessageTextComposite);

    GridDataFactory.fillDefaults().grab(true, true)

        .applyTo(commitMessageTextComposite);

    GridLayoutFactory.fillDefaults().numColumns(1)

        .extendedMargins(2, 2, 2, 2)

        .applyTo(commitMessageTextComposite);

    final CommitProposalProcessor commitProposalProcessor = new CommitProposalProcessor() {

      @Override

      protected Collection<String> computeFileNameProposals() {

        return getStagedFileNames();

      }

      @Override

      protected Collection<String> computeMessageProposals() {

        return CommitMessageHistory.getCommitHistory();

      }

    };

    commitMessageText = new CommitMessageArea(commitMessageTextComposite,

        EMPTY_STRING, toolkit.getBorderStyle()) {

      @Override

      protected CommitProposalProcessor getCommitProposalProcessor() {

        return commitProposalProcessor;

      }

      @Override

      protected IHandlerService getHandlerService() {

        return CommonUtils.getService(getSite(), IHandlerService.class);

      }

    };

    commitMessageText.setData(FormToolkit.KEY_DRAW_BORDER,

        FormToolkit.TEXT_BORDER);

    GridDataFactory.fillDefaults().grab(true, true)

        .applyTo(commitMessageText);

    UIUtils.addBulbDecorator(commitMessageText.getTextWidget(),

        UIText.CommitDialog_ContentAssist);

    Composite composite = toolkit.createComposite(commitMessageComposite);

    toolkit.paintBordersFor(composite);

    GridDataFactory.fillDefaults().grab(true, false).applyTo(composite);

    GridLayoutFactory.swtDefaults().numColumns(2).applyTo(composite);

    toolkit.createLabel(composite, UIText.StagingView_Author)

        .setForeground(

            toolkit.getColors().getColor(IFormColors.TB_TOGGLE));

    authorText = toolkit.createText(composite, null);

    authorText

        .setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);

    authorText.setLayoutData(GridDataFactory.fillDefaults()

        .grab(true, false).create());

    toolkit.createLabel(composite, UIText.StagingView_Committer)

        .setForeground(

            toolkit.getColors().getColor(IFormColors.TB_TOGGLE));

    committerText = toolkit.createText(composite, null);

    committerText.setData(FormToolkit.KEY_DRAW_BORDER,

        FormToolkit.TEXT_BORDER);

    committerText.setLayoutData(GridDataFactory.fillDefaults()

        .grab(true, false).create());

    Composite buttonsContainer = toolkit.createComposite(composite);

    GridDataFactory.fillDefaults().grab(true, false).span(2, 1)

        .indent(0, 8).applyTo(buttonsContainer);

    GridLayoutFactory.fillDefaults().numColumns(2)

        .applyTo(buttonsContainer);

    Label filler = toolkit.createLabel(buttonsContainer, ""); //$NON-NLS-1$

    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL)

        .grab(true, true).applyTo(filler);

    Composite commitButtonsContainer = toolkit

        .createComposite(buttonsContainer);

    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)

        .applyTo(commitButtonsContainer);

    GridLayoutFactory.fillDefaults().numColumns(2).equalWidth(true)

        .applyTo(commitButtonsContainer);

    this.commitAndPushButton = toolkit.createButton(commitButtonsContainer,

        UIText.StagingView_CommitAndPush, SWT.PUSH);

    commitAndPushButton.addSelectionListener(new SelectionAdapter() {

      @Override

      public void widgetSelected(SelectionEvent e) {

        commit(true);

      }

    });

    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)

        .applyTo(commitAndPushButton);

    this.commitButton = toolkit.createButton(commitButtonsContainer,

        UIText.StagingView_Commit, SWT.PUSH);

    commitButton.setImage(getImage(UIIcons.COMMIT));

    commitButton.setText(UIText.StagingView_Commit);

    commitButton.addSelectionListener(new SelectionAdapter() {

      @Override

      public void widgetSelected(SelectionEvent e) {

        commit(false);

      }

    });

    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER)

        .applyTo(commitButton);

    stagedSection = toolkit.createSection(stagingSashForm,

        ExpandableComposite.TITLE_BAR);

    createStagedToolBarComposite();

    Composite stagedComposite = toolkit.createComposite(stagedSection);

    toolkit.paintBordersFor(stagedComposite);

    stagedSection.setClient(stagedComposite);

    GridLayoutFactory.fillDefaults().extendedMargins(2, 2, 2, 2)

        .applyTo(stagedComposite);

    stagedViewer = createTree(stagedComposite);

    GridDataFactory.fillDefaults().grab(true, true)

        .applyTo(stagedViewer.getControl());

    stagedViewer.getTree().setData(FormToolkit.KEY_DRAW_BORDER,

        FormToolkit.TREE_BORDER);

    stagedViewer.setLabelProvider(createLabelProvider(stagedViewer));

    stagedViewer.setContentProvider(createStagingContentProvider(false));

    stagedViewer.addDragSupport(

        DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK,

        new Transfer[] { LocalSelectionTransfer.getTransfer(),

            FileTransfer.getInstance() }, new StagingDragListener(

            stagedViewer));

    stagedViewer.addDropSupport(DND.DROP_MOVE,

        new Transfer[] { LocalSelectionTransfer.getTransfer() },

        new DropTargetAdapter() {

          public void drop(DropTargetEvent event) {

            // Bug 411466: It is very important that detail is set

            // to DND.DROP_COPY. If it was left as DND.DROP_MOVE and

            // the drag comes from the Navigator view, the code in

            // NavigatorDragAdapter would delete the resources.

            event.detail = DND.DROP_COPY;

            if (event.data instanceof IStructuredSelection) {

              final IStructuredSelection selection = (IStructuredSelection) event.data;

              stage(selection);

            }

          }

          public void dragOver(DropTargetEvent event) {

            event.detail = DND.DROP_MOVE;

          }

        });

    stagedViewer.addOpenListener(new IOpenListener() {

      public void open(OpenEvent event) {

        compareWith(event);

      }

    });

    enableAutoExpand(stagedViewer);

    addListenerToDisableAutoExpandOnCollapse(stagedViewer);

    selectionChangedListener = new ISelectionListener() {

      public void selectionChanged(IWorkbenchPart part,

          ISelection selection) {

        if (!reactOnSelection || part == getSite().getPart())

          return;

        // this may happen if we switch between editors

        if (part instanceof IEditorPart) {

          IEditorInput input = ((IEditorPart) part).getEditorInput();

          if (input instanceof IFileEditorInput)

            reactOnSelection(new StructuredSelection(

                ((IFileEditorInput) input).getFile()));

        } else

          reactOnSelection(selection);

      }

    };