org.eclipse.team.ui_3.6.101.R37x_v20111109-0800

e(val$event, prompt);
    if (prompt) {
      RefreshUserNotificationPolicy.access$1(this$0, val$event);
    }
    setToolTipText(getToolTipText());
    if (val$event.isLink())
    {
      ISynchronizeView view = TeamUI.getSynchronizeManager().showSynchronizeViewInActivePage();
      if (view != null) {
        view.display(RefreshUserNotificationPolicy.access$0(this$0));
      }
    }
  }
  
  public String getToolTipText()
  {
    boolean prompt = val$event.getStatus().getCode() == 0;
    if (prompt) {
      return TeamUIMessages.RefreshSubscriberJob_2a;
    }
    return NLS.bind(TeamUIMessages.RefreshSubscriberJob_2b, new String[] { Utils.shortenText(100, RefreshUserNotificationPolicy.access$0(this$0).getName()) });
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.RefreshUserNotificationPolicy.2
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.osgi.util.NLS;
import org.eclipse.team.internal.ui.TeamUIMessages;
import org.eclipse.team.internal.ui.Utils;

class RefreshUserNotificationPolicy$3
  implements Runnable
{
  final RefreshUserNotificationPolicy this$0;
  private final IRefreshEvent val$event;
  
  RefreshUserNotificationPolicy$3(RefreshUserNotificationPolicy paramRefreshUserNotificationPolicy, IRefreshEvent paramIRefreshEvent)
  {
    this$0 = paramRefreshUserNotificationPolicy;val$event = paramIRefreshEvent;
  }
  
  public void run()
  {
    String title = val$event.getRefreshType() == 1 ? 
      NLS.bind(TeamUIMessages.RefreshCompleteDialog_4a, new String[] { Utils.getTypeName(RefreshUserNotificationPolicy.access$0(this$0)) }) : 
      NLS.bind(TeamUIMessages.RefreshCompleteDialog_4, new String[] { Utils.getTypeName(RefreshUserNotificationPolicy.access$0(this$0)) });
    
    MessageDialog.openInformation(Utils.getShell(null), title, val$event.getStatus().getMessage());
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.RefreshUserNotificationPolicy.3
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Display;
import org.eclipse.team.core.synchronize.SyncInfo;
import org.eclipse.team.core.synchronize.SyncInfoTree;
import org.eclipse.team.internal.core.subscribers.SubscriberSyncInfoCollector;
import org.eclipse.team.internal.ui.TeamUIMessages;
import org.eclipse.team.internal.ui.TeamUIPlugin;
import org.eclipse.team.internal.ui.Utils;
import org.eclipse.team.internal.ui.synchronize.actions.OpenInCompareAction;
import org.eclipse.team.ui.TeamUI;
import org.eclipse.team.ui.synchronize.ISynchronizeManager;
import org.eclipse.team.ui.synchronize.ISynchronizeParticipant;
import org.eclipse.team.ui.synchronize.ISynchronizeView;
import org.eclipse.team.ui.synchronize.SubscriberParticipant;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;

public class RefreshUserNotificationPolicy
  implements IRefreshSubscriberListener
{
  private ISynchronizeParticipant participant;
  
  public RefreshUserNotificationPolicy(ISynchronizeParticipant participant)
  {
    this.participant = participant;
  }
  
  public void refreshStarted(IRefreshEvent event)
  {
    TeamUIPlugin.getStandardDisplay().asyncExec(new Runnable()
    {
      private final IRefreshEvent val$event;
      
      public void run()
      {
        if ((val$event.getRefreshType() == 2) && (val$event.getParticipant() == participant))
        {
          ISynchronizeView view = TeamUI.getSynchronizeManager().showSynchronizeViewInActivePage();
          if (view != null) {
            view.display(participant);
          }
        }
      }
    });
  }
  
  public ActionFactory.IWorkbenchAction refreshDone(IRefreshEvent event)
  {
    if (event.getParticipant() != participant) {
      return null;
    }
    int severity = event.getStatus().getSeverity();
    if ((severity == 8) || (severity == 4)) {
      return null;
    }
    new WorkbenchAction()
    {
      private final IRefreshEvent val$event;
      
      public void run()
      {
        boolean prompt = val$event.getStatus().getCode() == 0;
        
        prompt = handleRefreshDone(val$event, prompt);
        if (prompt) {
          RefreshUserNotificationPolicy.this.notifyIfNeededModal(val$event);
        }
        setToolTipText(getToolTipText());
        if (val$event.isLink())
        {
          ISynchronizeView view = TeamUI.getSynchronizeManager().showSynchronizeViewInActivePage();
          if (view != null) {
            view.display(participant);
          }
        }
      }
      
      public String getToolTipText()
      {
        boolean prompt = val$event.getStatus().getCode() == 0;
        if (prompt) {
          return TeamUIMessages.RefreshSubscriberJob_2a;
        }
        return NLS.bind(TeamUIMessages.RefreshSubscriberJob_2b, new String[] { Utils.shortenText(100, participant.getName()) });
      }
    };
  }
  
  private void notifyIfNeededModal(IRefreshEvent event)
  {
    TeamUIPlugin.getStandardDisplay().asyncExec(new Runnable()
    {
      private final IRefreshEvent val$event;
      
      public void run()
      {
        String title = val$event.getRefreshType() == 1 ? 
          NLS.bind(TeamUIMessages.RefreshCompleteDialog_4a, new String[] { Utils.getTypeName(participant) }) : 
          NLS.bind(TeamUIMessages.RefreshCompleteDialog_4, new String[] { Utils.getTypeName(participant) });
        
        MessageDialog.openInformation(Utils.getShell(null), title, val$event.getStatus().getMessage());
      }
    });
  }
  
  protected boolean handleRefreshDone(IRefreshEvent event, boolean prompt)
  {
    if ((participant instanceof SubscriberParticipant))
    {
      SubscriberParticipant sp = (SubscriberParticipant)participant;
      SyncInfo[] infos = ((RefreshChangeListener)event.getChangeDescription()).getChanges();
      List selectedResources = new ArrayList();
      selectedResources.addAll(Arrays.asList(((RefreshChangeListener)event.getChangeDescription()).getResources()));
      for (int i = 0; i < infos.length; i++) {
        selectedResources.add(infos[i].getLocal());
      }
      IResource[] resources = (IResource[])selectedResources.toArray(new IResource[selectedResources.size()]);
      if ((resources.length == 1) && (resources[0].getType() == 1))
      {
        IResource file = resources[0];
        SyncInfo info = sp.getSubscriberSyncInfoCollector().getSyncInfoSet().getSyncInfo(file);
        if (info != null)
        {
          OpenInCompareAction.openCompareEditor(participant, info, null);
          prompt = false;
        }
      }
    }
    return prompt;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.RefreshUserNotificationPolicy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.team.internal.ui.TeamUIMessages;
import org.eclipse.team.ui.TeamUI;
import org.eclipse.team.ui.synchronize.ISynchronizeManager;
import org.eclipse.team.ui.synchronize.SubscriberParticipant;

class RefreshUserNotificationPolicyInModalDialog$1
  extends WorkbenchAction
{
  final RefreshUserNotificationPolicyInModalDialog this$0;
  private final IRefreshEvent val$event;
  
  RefreshUserNotificationPolicyInModalDialog$1(RefreshUserNotificationPolicyInModalDialog paramRefreshUserNotificationPolicyInModalDialog, IRefreshEvent paramIRefreshEvent)
  {
    this$0 = paramRefreshUserNotificationPolicyInModalDialog;val$event = paramIRefreshEvent;
  }
  
  public void run()
  {
    if (val$event.getStatus().getCode() == 0)
    {
      MessageDialog.openInformation(RefreshUserNotificationPolicyInModalDialog.access$0(this$0), TeamUIMessages.OpenComparedDialog_noChangeTitle, TeamUIMessages.OpenComparedDialog_noChangesMessage);
      return;
    }
    this$0.compareAndOpenDialog(val$event, RefreshUserNotificationPolicyInModalDialog.access$1(this$0));
    setEnabled(false);
  }
  
  public void dispose()
  {
    if (TeamUI.getSynchronizeManager().get(RefreshUserNotificationPolicyInModalDialog.access$1(this$0).getId(), RefreshUserNotificationPolicyInModalDialog.access$1(this$0).getSecondaryId()) == null) {
      RefreshUserNotificationPolicyInModalDialog.access$1(this$0).dispose();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.RefreshUserNotificationPolicyInModalDialog.1
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.CompareConfiguration;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
import org.eclipse.team.ui.synchronize.ISynchronizeParticipant;
import org.eclipse.team.ui.synchronize.ParticipantPageSaveablePart;

class RefreshUserNotificationPolicyInModalDialog$2
  extends ParticipantPageSaveablePart
{
  final RefreshUserNotificationPolicyInModalDialog this$0;
  
  RefreshUserNotificationPolicyInModalDialog$2(RefreshUserNotificationPolicyInModalDialog paramRefreshUserNotificationPolicyInModalDialog, Shell $anonymous0, CompareConfiguration $anonymous1, ISynchronizePageConfiguration $anonymous2, ISynchronizeParticipant $anonymous3)
  {
    super($anonymous0, $anonymous1, $anonymous2, $anonymous3);this$0 = paramRefreshUserNotificationPolicyInModalDialog;
  }
  
  public String getTitle()
  {
    return RefreshUserNotificationPolicyInModalDialog.access$2(this$0);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.RefreshUserNotificationPolicyInModalDialog.2
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.CompareConfiguration;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.team.internal.ui.TeamUIMessages;
import org.eclipse.team.ui.TeamUI;
import org.eclipse.team.ui.synchronize.ISynchronizeManager;
import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
import org.eclipse.team.ui.synchronize.ISynchronizeParticipant;
import org.eclipse.team.ui.synchronize.ParticipantPageSaveablePart;
import org.eclipse.team.ui.synchronize.SubscriberParticipant;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;

public class RefreshUserNotificationPolicyInModalDialog
  implements IRefreshSubscriberListener
{
  private SubscriberParticipant participant;
  private ISynchronizePageConfiguration configuration;
  private Shell shell;
  private String title;
  
  public RefreshUserNotificationPolicyInModalDialog(Shell shell, String title, ISynchronizePageConfiguration configuration, SubscriberParticipant participant)
  {
    this.title = title;
    this.configuration = configuration;
    this.participant = participant;
    this.shell = shell;
  }
  
  public void refreshStarted(IRefreshEvent event) {}
  
  public ActionFactory.IWorkbenchAction refreshDone(IRefreshEvent event)
  {
    if (event.getParticipant() != participant) {
      return null;
    }
    int severity = event.getStatus().getSeverity();
    if ((severity == 8) || (severity == 4)) {
      return null;
    }
    new WorkbenchAction()
    {
      private final IRefreshEvent val$event;
      
      public void run()
      {
        if (val$event.getStatus().getCode() == 0)
        {
          MessageDialog.openInformation(shell, TeamUIMessages.OpenComparedDialog_noChangeTitle, TeamUIMessages.OpenComparedDialog_noChangesMessage);
          return;
        }
        compareAndOpenDialog(val$event, participant);
        setEnabled(false);
      }
      
      public void dispose()
      {
        if (TeamUI.getSynchronizeManager().get(participant.getId(), participant.getSecondaryId()) == null) {
          participant.dispose();
        }
      }
    };
  }
  
  /* Error */
  protected void compareAndOpenDialog(IRefreshEvent event, SubscriberParticipant participant)
  {
    // Byte code:
    //   0: new 44	org/eclipse/compare/CompareConfiguration
    //   3: dup
    //   4: invokespecial 98	org/eclipse/compare/CompareConfiguration:<init>	()V
    //   7: astore_3
    //   8: new 51	org/eclipse/team/internal/ui/synchronize/RefreshUserNotificationPolicyInModalDialog$2
    //   11: dup
    //   12: aload_0
    //   13: aconst_null
    //   14: invokestatic 99	org/eclipse/team/internal/ui/Utils:getShell	(Lorg/eclipse/ui/IWorkbenchSite;)Lorg/eclipse/swt/widgets/Shell;
    //   17: aload_3
    //   18: aload_0
    //   19: getfield 95	org/eclipse/team/internal/ui/synchronize/RefreshUserNotificationPolicyInModalDialog:configuration	Lorg/eclipse/team/ui/synchronize/ISynchronizePageConfiguration;
    //   22: aload_2
    //   23: invokespecial 101	org/eclipse/team/internal/ui/synchronize/RefreshUserNotificationPolicyInModalDialog$2:<init>	(Lorg/eclipse/team/internal/ui/synchronize/RefreshUserNotificationPolicyInModalDialog;Lorg/eclipse/swt/widgets/Shell;Lorg/eclipse/compare/CompareConfiguration;Lorg/eclipse/team/ui/synchronize/ISynchronizePageConfiguration;Lorg/eclipse/team/ui/synchronize/ISynchronizeParticipant;)V
    //   26: astore 4
    //   28: new 52	org/eclipse/team/ui/synchronize/ParticipantPageDialog
    //   31: dup
    //   32: aload_0
    //   33: getfield 94	org/eclipse/team/internal/ui/synchronize/RefreshUserNotificationPolicyInModalDialog:shell	Lorg/eclipse/swt/widgets/Shell;
    //   36: aload 4
    //   38: aload_2
    //   39: invokespecial 104	org/eclipse/team/ui/synchronize/ParticipantPageDialog:<init>	(Lorg/eclipse/swt/widgets/Shell;Lorg/eclipse/team/ui/SaveablePartAdapter;Lorg/eclipse/team/ui/synchronize/ISynchronizeParticipant;)V
    //   42: astore 5
    //   44: aload 5
    //   46: iconst_1
    //   47: invokevirtual 103	org/eclipse/team/ui/synchronize/ParticipantPageDialog:setBlockOnOpen	(Z)V
    //   50: aload 5
    //   52: invokevirtual 102	org/eclipse/team/ui/synchronize/ParticipantPageDialog:open	()I
    //   55: pop
    //   56: goto +13 -> 69
    //   59: astore 6
    //   61: aload 4
    //   63: invokevirtual 105	org/eclipse/team/ui/synchronize/ParticipantPageSaveablePart:dispose	()V
    //   66: aload 6
    //   68: athrow
    //   69: aload 4
    //   71: invokevirtual 105	org/eclipse/team/ui/synchronize/ParticipantPageSaveablePart:dispose	()V
    //   74: return
    // Line number table:
    //   Java source line #68	-> byte code offset #0
    //   Java source line #69	-> byte code offset #8
    //   Java source line #75	-> byte code offset #28
    //   Java source line #76	-> byte code offset #44
    //   Java source line #77	-> byte code offset #50
    //   Java source line #78	-> byte code offset #59
    //   Java source line #79	-> byte code offset #61
    //   Java source line #80	-> byte code offset #66
    //   Java source line #79	-> byte code offset #69
    //   Java source line #81	-> byte code offset #74
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	75	0	this	RefreshUserNotificationPolicyInModalDialog
    //   0	75	1	event	IRefreshEvent
    //   0	75	2	participant	SubscriberParticipant
    //   7	11	3	cc	CompareConfiguration
    //   26	44	4	input	ParticipantPageSaveablePart
    //   42	9	5	dialog	org.eclipse.team.ui.synchronize.ParticipantPageDialog
    //   59	8	6	localObject	Object
    // Exception table:
    //   from	to	target	type
    //   28	59	59	finally
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.RefreshUserNotificationPolicyInModalDialog
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.variants.IResourceVariant;
import org.eclipse.team.internal.core.mapping.ResourceVariantFileRevision;
import org.eclipse.team.internal.ui.StorageTypedElement;
import org.eclipse.team.internal.ui.history.FileRevisionEditorInput;
import org.eclipse.ui.IEditorInput;

public class RemoteResourceTypedElement
  extends StorageTypedElement
{
  private IResourceVariant remote;
  
  public RemoteResourceTypedElement(IResourceVariant remote, String encoding)
  {
    super(encoding);
    Assert.isNotNull(remote);
    this.remote = remote;
  }
  
  public String getName()
  {
    return remote.getName();
  }
  
  public String getType()
  {
    if (remote.isContainer()) {
      return "FOLDER";
    }
    return super.getType();
  }
  
  protected IStorage fetchContents(IProgressMonitor monitor)
    throws TeamException
  {
    return remote.getStorage(monitor);
  }
  
  public IEditorInput getDocumentKey(Object element)
  {
    if ((element == this) && (getBufferedStorage() != null)) {
      return new FileRevisionEditorInput(new ResourceVariantFileRevision(remote), getBufferedStorage(), getLocalEncoding());
    }
    return null;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.RemoteResourceTypedElement
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.structuremergeviewer.ICompareInput;
import org.eclipse.core.resources.IResource;
import org.eclipse.team.internal.ui.mapping.CompareInputChangeNotifier;

class SaveablesCompareEditorInput$1
  extends CompareInputChangeNotifier
{
  final SaveablesCompareEditorInput this$0;
  
  SaveablesCompareEditorInput$1(SaveablesCompareEditorInput paramSaveablesCompareEditorInput)
  {
    this$0 = paramSaveablesCompareEditorInput;
  }
  
  protected IResource[] getResources(ICompareInput input)
  {
    IResource leftResource = SaveablesCompareEditorInput.access$1(this$0, SaveablesCompareEditorInput.access$0(this$0));
    IResource rightResource = SaveablesCompareEditorInput.access$1(this$0, SaveablesCompareEditorInput.access$2(this$0));
    if ((leftResource == null) && (rightResource == null)) {
      return new IResource[0];
    }
    if ((leftResource == null) && (rightResource != null)) {
      return new IResource[] { rightResource };
    }
    if ((leftResource != null) && (rightResource == null)) {
      return new IResource[] { leftResource };
    }
    return new IResource[] { leftResource, rightResource };
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.1
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.swt.graphics.Point;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchSite;
import org.eclipse.ui.actions.OpenWithMenu;

class SaveablesCompareEditorInput$10
  extends OpenWithMenu
{
  private final IWorkbenchSite val$ws;
  private final ITextViewer val$v;
  
  SaveablesCompareEditorInput$10(IWorkbenchPage $anonymous0, IAdaptable $anonymous1, IWorkbenchSite paramIWorkbenchSite, ITextViewer paramITextViewer)
  {
    super($anonymous0, $anonymous1);val$ws = paramIWorkbenchSite;val$v = paramITextViewer;
  }
  
  protected void openEditor(IEditorDescriptor editorDescriptor, boolean openUsingDescriptor)
  {
    super.openEditor(editorDescriptor, openUsingDescriptor);
    IEditorPart editor = val$ws.getPage().getActiveEditor();
    Point selectedRange = val$v.getSelectedRange();
    SaveablesCompareEditorInput.access$11(editor, x, y);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.10
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.jface.text.ITextViewer;
import org.eclipse.swt.graphics.Point;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchSite;
import org.eclipse.ui.actions.OpenFileAction;

class SaveablesCompareEditorInput$11
  extends OpenFileAction
{
  private final IWorkbenchSite val$ws;
  private final ITextViewer val$v;
  
  SaveablesCompareEditorInput$11(IWorkbenchPage $anonymous0, IWorkbenchSite paramIWorkbenchSite, ITextViewer paramITextViewer)
  {
    super($anonymous0);val$ws = paramIWorkbenchSite;val$v = paramITextViewer;
  }
  
  public void run()
  {
    super.run();
    IEditorPart editor = val$ws.getPage().getActiveEditor();
    Point selectedRange = val$v.getSelectedRange();
    SaveablesCompareEditorInput.access$11(editor, x, y);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.11
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
import org.eclipse.ui.ide.IGotoMarker;

class SaveablesCompareEditorInput$12
  extends WorkspaceModifyOperation
{
  private final IEditorInput val$input;
  private final int val$offset;
  private final int val$length;
  private final IGotoMarker val$gotoMarkerTarget;
  
  SaveablesCompareEditorInput$12(IEditorInput paramIEditorInput, int paramInt1, int paramInt2, IGotoMarker paramIGotoMarker)
  {
    val$input = paramIEditorInput;val$offset = paramInt1;val$length = paramInt2;val$gotoMarkerTarget = paramIGotoMarker;
  }
  
  /* Error */
  protected void execute(org.eclipse.core.runtime.IProgressMonitor monitor)
    throws org.eclipse.core.runtime.CoreException
  {
    // Byte code:
    //   0: aconst_null
    //   1: astore_2
    //   2: aload_0
    //   3: getfield 61	org/eclipse/team/internal/ui/synchronize/SaveablesCompareEditorInput$12:val$input	Lorg/eclipse/ui/IEditorInput;
    //   6: checkcast 35	org/eclipse/ui/IFileEditorInput
    //   9: invokeinterface 67 1 0
    //   14: ldc 3
    //   16: invokeinterface 64 2 0
    //   21: astore_2
    //   22: aload_2
    //   23: ldc 2
    //   25: aload_0
    //   26: getfield 60	org/eclipse/team/internal/ui/synchronize/SaveablesCompareEditorInput$12:val$offset	I
    //   29: invokeinterface 66 3 0
    //   34: aload_2
    //   35: ldc 1
    //   37: aload_0
    //   38: getfield 60	org/eclipse/team/internal/ui/synchronize/SaveablesCompareEditorInput$12:val$offset	I
    //   41: aload_0
    //   42: getfield 59	org/eclipse/team/internal/ui/synchronize/SaveablesCompareEditorInput$12:val$length	I
    //   45: iadd
    //   46: invokeinterface 66 3 0
    //   51: aload_0
    //   52: getfield 62	org/eclipse/team/internal/ui/synchronize/SaveablesCompareEditorInput$12:val$gotoMarkerTarget	Lorg/eclipse/ui/ide/IGotoMarker;
    //   55: aload_2
    //   56: invokeinterface 68 2 0
    //   61: goto +16 -> 77
    //   64: astore_3
    //   65: aload_2
    //   66: ifnull +9 -> 75
    //   69: aload_2
    //   70: invokeinterface 65 1 0
    //   75: aload_3
    //   76: athrow
    //   77: aload_2
    //   78: ifnull +9 -> 87
    //   81: aload_2
    //   82: invokeinterface 65 1 0
    //   87: return
    // Line number table:
    //   Java source line #880	-> byte code offset #0
    //   Java source line #882	-> byte code offset #2
    //   Java source line #883	-> byte code offset #22
    //   Java source line #884	-> byte code offset #34
    //   Java source line #886	-> byte code offset #51
    //   Java source line #888	-> byte code offset #64
    //   Java source line #889	-> byte code offset #65
    //   Java source line #890	-> byte code offset #69
    //   Java source line #891	-> byte code offset #75
    //   Java source line #889	-> byte code offset #77
    //   Java source line #890	-> byte code offset #81
    //   Java source line #892	-> byte code offset #87
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	88	0	this	12
    //   0	88	1	monitor	org.eclipse.core.runtime.IProgressMonitor
    //   1	81	2	marker	org.eclipse.core.resources.IMarker
    //   64	12	3	localObject	Object
    // Exception table:
    //   from	to	target	type
    //   2	64	64	finally
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.12
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.structuremergeviewer.ICompareInput;
import org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener;

class SaveablesCompareEditorInput$2
  implements ICompareInputChangeListener
{
  final SaveablesCompareEditorInput this$0;
  
  SaveablesCompareEditorInput$2(SaveablesCompareEditorInput paramSaveablesCompareEditorInput)
  {
    this$0 = paramSaveablesCompareEditorInput;
  }
  
  public void compareInputChanged(ICompareInput source)
  {
    if (source == this$0.getCompareResult())
    {
      boolean closed = false;
      if (source.getKind() == 0) {
        closed = this$0.closeEditor(true);
      }
      if (!closed) {
        SaveablesCompareEditorInput.access$5(this$0);
      }
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.2
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.Saveable;

class SaveablesCompareEditorInput$3
  implements IPropertyListener
{
  final SaveablesCompareEditorInput this$0;
  
  SaveablesCompareEditorInput$3(SaveablesCompareEditorInput paramSaveablesCompareEditorInput)
  {
    this$0 = paramSaveablesCompareEditorInput;
  }
  
  public void propertyChanged(Object source, int propId)
  {
    if (propId == 257) {
      SaveablesCompareEditorInput.access$7(this$0, SaveablesCompareEditorInput.access$6(this$0).isDirty());
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.3
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.Saveable;

class SaveablesCompareEditorInput$4
  implements IPropertyListener
{
  final SaveablesCompareEditorInput this$0;
  
  SaveablesCompareEditorInput$4(SaveablesCompareEditorInput paramSaveablesCompareEditorInput)
  {
    this$0 = paramSaveablesCompareEditorInput;
  }
  
  public void propertyChanged(Object source, int propId)
  {
    if (propId == 257) {
      SaveablesCompareEditorInput.access$9(this$0, SaveablesCompareEditorInput.access$8(this$0).isDirty());
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.4
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.IPropertyChangeNotifier;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;

class SaveablesCompareEditorInput$5
  implements DisposeListener
{
  final SaveablesCompareEditorInput this$0;
  private final IPropertyChangeNotifier val$dsp;
  private final IPropertyChangeListener val$lpcl;
  private final IPropertyChangeListener val$rpcl;
  
  SaveablesCompareEditorInput$5(SaveablesCompareEditorInput paramSaveablesCompareEditorInput, IPropertyChangeNotifier paramIPropertyChangeNotifier, IPropertyChangeListener paramIPropertyChangeListener1, IPropertyChangeListener paramIPropertyChangeListener2)
  {
    this$0 = paramSaveablesCompareEditorInput;val$dsp = paramIPropertyChangeNotifier;val$lpcl = paramIPropertyChangeListener1;val$rpcl = paramIPropertyChangeListener2;
  }
  
  public void widgetDisposed(DisposeEvent e)
  {
    val$dsp.removePropertyChangeListener(val$lpcl);
    val$dsp.removePropertyChangeListener(val$rpcl);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.5
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;

class SaveablesCompareEditorInput$6
  implements Runnable
{
  final SaveablesCompareEditorInput this$0;
  
  SaveablesCompareEditorInput$6(SaveablesCompareEditorInput paramSaveablesCompareEditorInput)
  {
    this$0 = paramSaveablesCompareEditorInput;
  }
  
  public void run()
  {
    IEditorPart part = SaveablesCompareEditorInput.access$10(this$0).findEditor(
      this$0);
    SaveablesCompareEditorInput.access$10(this$0).closeEditor(part, false);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.6
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.ITypedElement;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.ui.Saveable;

class SaveablesCompareEditorInput$7
  implements IMenuListener
{
  final SaveablesCompareEditorInput this$0;
  private final Saveable val$lLeftSaveable;
  private final ITypedElement val$lLeftElement;
  private final ISelectionProvider val$pSelectionProvider;
  
  SaveablesCompareEditorInput$7(SaveablesCompareEditorInput paramSaveablesCompareEditorInput, Saveable paramSaveable, ITypedElement paramITypedElement, ISelectionProvider paramISelectionProvider)
  {
    this$0 = paramSaveablesCompareEditorInput;val$lLeftSaveable = paramSaveable;val$lLeftElement = paramITypedElement;val$pSelectionProvider = paramISelectionProvider;
  }
  
  public void menuAboutToShow(IMenuManager manager)
  {
    SaveablesCompareEditorInput.handleMenuAboutToShow(manager, this$0.getContainer(), val$lLeftSaveable, val$lLeftElement, val$pSelectionProvider);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.7
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.ITypedElement;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.ui.Saveable;

class SaveablesCompareEditorInput$8
  implements IMenuListener
{
  final SaveablesCompareEditorInput this$0;
  private final Saveable val$lRightSaveable;
  private final ITypedElement val$lRightElement;
  private final ISelectionProvider val$pSelectionProvider;
  
  SaveablesCompareEditorInput$8(SaveablesCompareEditorInput paramSaveablesCompareEditorInput, Saveable paramSaveable, ITypedElement paramITypedElement, ISelectionProvider paramISelectionProvider)
  {
    this$0 = paramSaveablesCompareEditorInput;val$lRightSaveable = paramSaveable;val$lRightElement = paramITypedElement;val$pSelectionProvider = paramISelectionProvider;
  }
  
  public void menuAboutToShow(IMenuManager manager)
  {
    SaveablesCompareEditorInput.handleMenuAboutToShow(manager, this$0.getContainer(), val$lRightSaveable, val$lRightElement, val$pSelectionProvider);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.8
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.structuremergeviewer.ICompareInput;
import org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener;
import org.eclipse.core.runtime.ISafeRunnable;

class SaveablesCompareEditorInput$9
  implements ISafeRunnable
{
  final SaveablesCompareEditorInput this$0;
  private final ICompareInputChangeListener val$listener;
  private final ICompareInput val$compareResult;
  
  SaveablesCompareEditorInput$9(SaveablesCompareEditorInput paramSaveablesCompareEditorInput, ICompareInputChangeListener paramICompareInputChangeListener, ICompareInput paramICompareInput)
  {
    this$0 = paramSaveablesCompareEditorInput;val$listener = paramICompareInputChangeListener;val$compareResult = paramICompareInput;
  }
  
  public void run()
    throws Exception
  {
    val$listener.compareInputChanged(val$compareResult);
  }
  
  public void handleException(Throwable exception) {}
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.9
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.CompareEditorInput;
import org.eclipse.compare.ICompareContainer;
import org.eclipse.compare.ITypedElement;
import org.eclipse.compare.structuremergeviewer.ICompareInput;
import org.eclipse.ui.ISaveablesLifecycleListener;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.Saveable;
import org.eclipse.ui.SaveablesLifecycleEvent;

class SaveablesCompareEditorInput$InternalResourceSaveableComparison
  extends LocalResourceSaveableComparison
  implements EditableSharedDocumentAdapter.ISharedDocumentAdapterListener
{
  private LocalResourceTypedElement lrte;
  private boolean connected;
  final SaveablesCompareEditorInput this$0;
  
  public SaveablesCompareEditorInput$InternalResourceSaveableComparison(SaveablesCompareEditorInput paramSaveablesCompareEditorInput, ICompareInput input, CompareEditorInput editorInput, ITypedElement element)
  {
    super(input, editorInput, element);this$0 = paramSaveablesCompareEditorInput;connected = false;
    if ((element instanceof LocalResourceTypedElement))
    {
      lrte = ((LocalResourceTypedElement)element);
      if (lrte.isConnected()) {
        registerSaveable(true);
      } else {
        lrte.setSharedDocumentListener(this);
      }
    }
  }
  
  protected void fireInputChange()
  {
    this$0.fireInputChange();
  }
  
  public void dispose()
  {
    super.dispose();
    if (lrte != null) {
      lrte.setSharedDocumentListener(null);
    }
  }
  
  public void handleDocumentConnected()
  {
    if (connected) {
      return;
    }
    connected = true;
    registerSaveable(false);
    if (lrte != null) {
      lrte.setSharedDocumentListener(null);
    }
  }
  
  private void registerSaveable(boolean init)
  {
    ICompareContainer container = this$0.getContainer();
    IWorkbenchPart part = container.getWorkbenchPart();
    if (part != null)
    {
      ISaveablesLifecycleListener lifecycleListener = SaveablesCompareEditorInput.access$4(this$0, part);
      if (!init) {
        lifecycleListener.handleLifecycleEvent(new SaveablesLifecycleEvent(
          part, 3, 
          new Saveable[] { this }, false));
      }
      initializeHashing();
      
      lifecycleListener
        .handleLifecycleEvent(new SaveablesLifecycleEvent(part, 
        1, 
        new Saveable[] { this }, false));
    }
  }
  
  public void handleDocumentDeleted() {}
  
  public void handleDocumentDisconnected() {}
  
  public void handleDocumentFlushed() {}
  
  public void handleDocumentSaved() {}
  
  public boolean equals(Object obj)
  {
    if (this == obj) {
      return true;
    }
    if (!(obj instanceof Saveable)) {
      return false;
    }
    Class tmp20_17 = SaveablesCompareEditorInput.class$0;
    if (tmp20_17 == null)
    {
      tmp20_17;
      try
      {
        tmpTernaryOp = (SaveablesCompareEditorInput.class$0 = Class.forName("org.eclipse.jface.text.IDocument"));
      }
      catch (ClassNotFoundException localClassNotFoundException1)
      {
        throw new NoClassDefFoundError(localClassNotFoundException1.getMessage());
      }
    }
    Object document = getAdapter(tmp20_17);
    if (document != null)
    {
      Class tmp64_61 = SaveablesCompareEditorInput.class$0;
      if (tmp64_61 == null)
      {
        tmp64_61;
        try
        {
          tmpTernaryOp = (SaveablesCompareEditorInput.class$0 = Class.forName("org.eclipse.jface.text.IDocument"));
        }
        catch (ClassNotFoundException localClassNotFoundException2)
        {
          throw new NoClassDefFoundError(localClassNotFoundException2.getMessage());
        }
      }
      Object otherDocument = ((Saveable)obj)
        .getAdapter(tmp64_61);
      return document.equals(otherDocument);
    }
    if ((obj instanceof InternalResourceSaveableComparison))
    {
      InternalResourceSaveableComparison rscm = (InternalResourceSaveableComparison)obj;
      return (rscm.getInput().equals(getInput())) && (lrte.equals(lrte));
    }
    return false;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.InternalResourceSaveableComparison
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.ITypedElement;
import org.eclipse.team.internal.ui.mapping.AbstractCompareInput;
import org.eclipse.team.internal.ui.mapping.CompareInputChangeNotifier;

class SaveablesCompareEditorInput$MyDiffNode
  extends AbstractCompareInput
{
  final SaveablesCompareEditorInput this$0;
  
  public SaveablesCompareEditorInput$MyDiffNode(SaveablesCompareEditorInput paramSaveablesCompareEditorInput, ITypedElement left, ITypedElement right)
  {
    super(3, null, left, right);
    this$0 = paramSaveablesCompareEditorInput;
  }
  
  public SaveablesCompareEditorInput$MyDiffNode(SaveablesCompareEditorInput paramSaveablesCompareEditorInput, ITypedElement ancestor, ITypedElement left, ITypedElement right)
  {
    super(12, ancestor, left, right);
    this$0 = paramSaveablesCompareEditorInput;
  }
  
  public void fireChange()
  {
    super.fireChange();
  }
  
  protected CompareInputChangeNotifier getChangeNotifier()
  {
    return SaveablesCompareEditorInput.access$3(this$0);
  }
  
  public boolean needsUpdate()
  {
    return true;
  }
  
  public void update()
  {
    fireChange();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.team.internal.ui.synchronize.SaveablesCompareEditorInput.MyDiffNode
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.team.internal.ui.synchronize;

import java.lang.reflect.InvocationTargetException;
import org.eclipse.compare.CompareConfiguration;
import org.eclipse.compare.CompareEditorInput;
import org.eclipse.compare.ICompareContainer;
import org.eclipse.compare.IEditableContent;
import org.eclipse.compare.IPropertyChangeNotifier;
import org.eclipse.compare.IResourceProvider;
import org.eclipse.compare.ITypedElement;
import org.eclipse.compare.structuremergeviewer.ICompareInput;
import org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings

Copyright 2006-2019. Infinite Loop Ltd