org.eclipse.mylyn.tasks.ui_3.7.1.v20120425-0100

import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;

public class NewQueryAction
  extends Action
  implements IViewActionDelegate, IExecutableExtension
{
  private final String ID = "org.eclipse.mylyn.tasks.ui.new.query";
  private final String LABEL_NEW_QUERY = Messages.NewQueryAction_new_query_;
  private boolean skipRepositoryPage;
  
  public NewQueryAction()
  {
    setText(LABEL_NEW_QUERY);
    setToolTipText(LABEL_NEW_QUERY);
    setId("org.eclipse.mylyn.tasks.ui.new.query");
    setImageDescriptor(TasksUiImages.QUERY_NEW);
  }
  
  public void run(IAction action)
  {
    run();
  }
  
  public void run()
  {
    IWizard wizard = null;
    if (skipRepositoryPage)
    {
      TaskRepository taskRepository = TasksUiUtil.getSelectedRepository();
      AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(taskRepository.getConnectorKind());
      wizard = connectorUi.getQueryWizard(taskRepository, null);
      ((Wizard)wizard).setForcePreviousAndNextButtons(true);
      if ((connectorUi instanceof LocalRepositoryConnectorUi)) {
        wizard.performFinish();
      }
    }
    else
    {
      wizard = new NewQueryWizard();
    }
    WizardDialog dialog = new WizardDialog(WorkbenchUtil.getShell(), wizard);
    dialog.create();
    dialog.setBlockOnOpen(true);
    dialog.open();
  }
  
  public void setInitializationData(IConfigurationElement config, String propertyName, Object data)
    throws CoreException
  {
    if ("skipFirstPage".equals(data)) {
      skipRepositoryPage = true;
    }
  }
  
  public void init(IViewPart view) {}
  
  public void selectionChanged(IAction action, ISelection selection) {}
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.NewQueryAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import java.util.List;
import org.eclipse.jface.action.Action;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
import org.eclipse.mylyn.tasks.core.IRepositoryElement;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITaskContainer;

public abstract class AbstractTaskAction
  extends Action
{
  protected List<IRepositoryElement> selectedElements;
  
  public void run()
  {
    for (IRepositoryElement element : selectedElements) {
      if ((element instanceof ITask))
      {
        AbstractTask repositoryTask = (AbstractTask)element;
        performActionOnTask(repositoryTask);
      }
      else if ((element instanceof IRepositoryQuery))
      {
        RepositoryQuery repositoryQuery = (RepositoryQuery)element;
        for (ITask queryHit : repositoryQuery.getChildren()) {
          performActionOnTask(queryHit);
        }
      }
      else if ((element instanceof ITaskContainer))
      {
        ITaskContainer container = (ITaskContainer)element;
        for (ITask task : container.getChildren()) {
          if (task != null)
          {
            ITask repositoryTask = task;
            performActionOnTask(repositoryTask);
          }
        }
      }
    }
  }
  
  protected abstract void performActionOnTask(ITask paramITask);
  
  protected boolean containsArchiveContainer(List<AbstractTaskContainer> selectedElements)
  {
    return false;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.AbstractTaskAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
import org.eclipse.mylyn.internal.tasks.core.TaskList;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.tasks.core.IRepositoryManager;
import org.eclipse.mylyn.tasks.core.IRepositoryModel;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.AbstractRepositoryConnectorUi;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;

public class QueryCloneAction
  extends Action
  implements IViewActionDelegate
{
  protected ISelection selection;
  
  public void init(IViewPart view) {}
  
  public void run(IAction action)
  {
    run(getSelectedQuery(selection));
  }
  
  public void selectionChanged(IAction action, ISelection selection)
  {
    this.selection = selection;
    IRepositoryQuery selectedQuery = getSelectedQuery(selection);
    action.setEnabled(true);
    if (selectedQuery != null) {
      action.setEnabled(true);
    } else {
      action.setEnabled(false);
    }
  }
  
  protected RepositoryQuery getSelectedQuery(ISelection newSelection)
  {
    if ((selection instanceof StructuredSelection)) {
      if (((StructuredSelection)selection).size() == 1)
      {
        Object selectedObject = ((StructuredSelection)selection).getFirstElement();
        if ((selectedObject instanceof IRepositoryQuery)) {
          return (RepositoryQuery)selectedObject;
        }
      }
    }
    return null;
  }
  
  public void run(RepositoryQuery selectedQuery)
  {
    if (selectedQuery == null)
    {
      MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), 
        Messages.QueryCloneAction_Clone_Query, Messages.QueryCloneAction_No_query_selected);
      return;
    }
    List<RepositoryQuery> queries = new ArrayList();
    queries.add(selectedQuery);
    
    List<RepositoryQuery> clonedQueries = new ArrayList(queries.size());
    for (RepositoryQuery query : queries)
    {
      TaskRepository repository = TasksUi.getRepositoryManager().getRepository(query.getConnectorKind(), 
        query.getRepositoryUrl());
      RepositoryQuery clonedQuery = (RepositoryQuery)TasksUi.getRepositoryModel().createRepositoryQuery(
        repository);
      clonedQuery.setSummary(NLS.bind(Messages.QueryCloneAction_Copy_of_X, query.getSummary()));
      clonedQuery.setUrl(query.getUrl());
      Map<String, String> attributes = query.getAttributes();
      for (Map.Entry<String, String> entry : attributes.entrySet()) {
        clonedQuery.setAttribute((String)entry.getKey(), (String)entry.getValue());
      }
      clonedQueries.add(clonedQuery);
    }
    for (RepositoryQuery query : clonedQueries)
    {
      TasksUiPlugin.getTaskList().addQuery(query);
      AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(query.getConnectorKind());
      if (!TasksUiInternal.openEditQueryDialog(connectorUi, query)) {
        TasksUiPlugin.getTaskList().deleteQuery(query);
      }
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.QueryCloneAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import java.io.File;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.commons.workbench.WorkbenchUtil;
import org.eclipse.mylyn.internal.tasks.ui.util.ImportExportUtil;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;

public class ExportAction
  implements IViewActionDelegate
{
  private ISelection selection;
  
  public void init(IViewPart view) {}
  
  public void run(IAction action)
  {
    if ((selection.isEmpty()) || (!(selection instanceof StructuredSelection)))
    {
      MessageDialog.openError(WorkbenchUtil.getShell(), Messages.ExportAction_Dialog_Title, 
        Messages.ExportAction_Nothing_selected);
      return;
    }
    FileDialog dialog = new FileDialog(WorkbenchUtil.getShell(), 40960);
    dialog.setText(Messages.ExportAction_Dialog_Title);
    ImportExportUtil.configureFilter(dialog);
    dialog.setFileName("mylyn-tasks.xml.zip");
    String path = dialog.open();
    if (path != null)
    {
      File file = new File(path);
      if ((file.exists()) && 
        (!MessageDialog.openConfirm(WorkbenchUtil.getShell(), Messages.ExportAction_Dialog_Title, 
        NLS.bind(Messages.ExportAction_X_exists_Do_you_wish_to_overwrite, file.getPath())))) {
        return;
      }
      try
      {
        ImportExportUtil.export(file, (IStructuredSelection)selection);
      }
      catch (CoreException e)
      {
        StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", 
          "Problems encountered during export", e));
        TasksUiInternal.displayStatus(Messages.ExportAction_Dialog_Title, new MultiStatus(
          "org.eclipse.mylyn.tasks.core", 0, new IStatus[] { e.getStatus() }, 
          Messages.ExportAction_Problems_encountered, e));
      }
    }
  }
  
  public void selectionChanged(IAction action, ISelection selection)
  {
    this.selection = selection;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.ExportAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.action.Action;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITaskActivationListener;
import org.eclipse.mylyn.tasks.core.ITaskActivityManager;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;

public class ToggleTaskActivationAction
  extends Action
  implements ITaskActivationListener
{
  public static final String ID = "org.eclipse.mylyn.tasks.ui.actions.task.activation.toggle";
  private final ITask task;
  
  public ToggleTaskActivationAction(ITask task)
  {
    Assert.isNotNull(task);
    this.task = task;
    setId("org.eclipse.mylyn.tasks.ui.actions.task.activation.toggle");
    setImageDescriptor(TasksUiImages.CONTEXT_ACTIVE_CENTERED);
    update();
    TasksUi.getTaskActivityManager().addActivationListener(this);
  }
  
  public void dispose()
  {
    TasksUi.getTaskActivityManager().removeActivationListener(this);
  }
  
  private void update()
  {
    setChecked(task.isActive());
    if (task.isActive())
    {
      setText(Messages.ToggleTaskActivationAction_Deactivate_Task);
      setToolTipText(Messages.ToggleTaskActivationAction_Deactivate_Task);
    }
    else
    {
      setText(Messages.ToggleTaskActivationAction_Activate_Task);
      setToolTipText(Messages.ToggleTaskActivationAction_Activate_Task);
    }
  }
  
  public void run()
  {
    if (!task.isActive()) {
      TasksUiInternal.activateTaskThroughCommand(task);
    } else {
      TasksUi.getTaskActivityManager().deactivateTask(task);
    }
    update();
  }
  
  public void taskActivated(ITask task)
  {
    update();
  }
  
  public void taskDeactivated(ITask task)
  {
    update();
  }
  
  public void preTaskActivated(ITask task) {}
  
  public void preTaskDeactivated(ITask task) {}
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.ToggleTaskActivationAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.jface.action.Action;

public class TaskEditorCopyAction
  extends Action
{
  public TaskEditorCopyAction()
  {
    setText("TaskInfoEditor.copy.text");
  }
  
  public void run() {}
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.TaskEditorCopyAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import java.util.List;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.action.Separator;
import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.commons.workbench.WorkbenchUtil;
import org.eclipse.mylyn.internal.tasks.ui.views.AbstractTaskListPresentation;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;

public class PresentationDropDownSelectionAction
  extends Action
  implements IMenuCreator
{
  public static final String ID = "org.eclipse.mylyn.tasklist.actions.presentationselection";
  private final TaskListView view;
  private Menu dropDownMenu;
  
  public PresentationDropDownSelectionAction(TaskListView view)
  {
    this.view = view;
    setMenuCreator(this);
    setText(Messages.PresentationDropDownSelectionAction_Task_Presentation);
    setToolTipText(Messages.PresentationDropDownSelectionAction_Task_Presentation);
    setId("org.eclipse.mylyn.tasklist.actions.presentationselection");
    setEnabled(true);
    setImageDescriptor(CommonImages.PRESENTATION);
  }
  
  private void addActionsToMenu()
  {
    PresentationSelectionAction action;
    for (AbstractTaskListPresentation presentation : ) {
      if (presentation.isPrimary())
      {
        action = new PresentationSelectionAction(view, presentation);
        ActionContributionItem item = new ActionContributionItem(action);
        item.fill(dropDownMenu, -1);
      }
    }
    boolean separatorAdded = false;
    for (AbstractTaskListPresentation presentation : TaskListView.getPresentations()) {
      if ((WorkbenchUtil.allowUseOf(presentation)) && 
        (!presentation.isPrimary()))
      {
        if (!separatorAdded)
        {
          new Separator().fill(dropDownMenu, -1);
          separatorAdded = true;
        }
        PresentationSelectionAction action = new PresentationSelectionAction(view, presentation);
        ActionContributionItem item = new ActionContributionItem(action);
        item.fill(dropDownMenu, -1);
      }
    }
  }
  
  public void run()
  {
    AbstractTaskListPresentation current = view.getCurrentPresentation();
    List<AbstractTaskListPresentation> all = TaskListView.getPresentations();
    int size = all.size();
    if (size == 0) {
      return;
    }
    int index = all.indexOf(current) + 1;
    for (int i = 0; i < size; i++)
    {
      AbstractTaskListPresentation presentation = (AbstractTaskListPresentation)all.get(index % size);
      if (presentation.isPrimary())
      {
        view.applyPresentation(presentation);
        return;
      }
      index++;
    }
    index = all.indexOf(current) + 1;
    if (index < size) {
      view.applyPresentation((AbstractTaskListPresentation)all.get(index));
    } else {
      view.applyPresentation((AbstractTaskListPresentation)all.get(0));
    }
  }
  
  public void dispose()
  {
    if (dropDownMenu != null)
    {
      dropDownMenu.dispose();
      dropDownMenu = null;
    }
  }
  
  public Menu getMenu(Control parent)
  {
    if (dropDownMenu != null) {
      dropDownMenu.dispose();
    }
    dropDownMenu = new Menu(parent);
    addActionsToMenu();
    return dropDownMenu;
  }
  
  public Menu getMenu(Menu parent)
  {
    if (dropDownMenu != null) {
      dropDownMenu.dispose();
    }
    dropDownMenu = new Menu(parent);
    addActionsToMenu();
    return dropDownMenu;
  }
  
  public static class PresentationSelectionAction
    extends Action
  {
    private final AbstractTaskListPresentation presentation;
    private final TaskListView view;
    
    public PresentationSelectionAction(TaskListView view, AbstractTaskListPresentation presentation)
    {
      this.view = view;
      this.presentation = presentation;
      setText(presentation.getName());
      setImageDescriptor(presentation.getImageDescriptor());
      update();
    }
    
    public void update()
    {
      setChecked(view.getCurrentPresentation().getId().equals(presentation.getId()));
    }
    
    public void run()
    {
      view.applyPresentation(presentation);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.PresentationDropDownSelectionAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import java.lang.reflect.InvocationTargetException;
import org.eclipse.compare.CompareConfiguration;
import org.eclipse.compare.CompareEditorInput;
import org.eclipse.compare.structuremergeviewer.DiffNode;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.mylyn.tasks.core.ITaskAttachment;

class CompareAttachmentsAction$1
  extends CompareEditorInput
{
  CompareAttachmentsAction$1(CompareAttachmentsAction paramCompareAttachmentsAction, CompareConfiguration $anonymous0, ITaskAttachment paramITaskAttachment1, ITaskAttachment paramITaskAttachment2)
  {
    super($anonymous0);
  }
  
  public String getTitle()
  {
    return 
      Messages.CompareAttachmentsAction_Compare__ + val$attachment1.getFileName() + " - " + val$attachment2.getFileName() + ")";
  }
  
  protected Object prepareInput(IProgressMonitor pm)
    throws InvocationTargetException
  {
    CompareAttachmentsAction.CompareItem left = new CompareAttachmentsAction.CompareItem(this$0, val$attachment1);
    CompareAttachmentsAction.CompareItem right = new CompareAttachmentsAction.CompareItem(this$0, val$attachment2);
    return new DiffNode(left, right);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.CompareAttachmentsAction.1
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;

public class EditRepositoryPropertiesAction
  extends AbstractTaskRepositoryAction
  implements IViewActionDelegate
{
  private static final String ID = "org.eclipse.mylyn.tasklist.repositories.properties";
  
  public EditRepositoryPropertiesAction()
  {
    super(Messages.EditRepositoryPropertiesAction_Properties);
    setId("org.eclipse.mylyn.tasklist.repositories.properties");
    setEnabled(false);
  }
  
  public void run()
  {
    TaskRepository taskRepository = getTaskRepository(getStructuredSelection());
    if (taskRepository != null) {
      TasksUiUtil.openEditRepositoryWizard(taskRepository);
    }
  }
  
  public void init(IViewPart view) {}
  
  public void run(IAction action)
  {
    run();
  }
  
  public void selectionChanged(IAction action, ISelection selection)
  {
    if ((selection instanceof IStructuredSelection))
    {
      selectionChanged((IStructuredSelection)selection);
      action.setEnabled(isEnabled());
    }
    else
    {
      clearCache();
      action.setEnabled(false);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.EditRepositoryPropertiesAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import java.util.List;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.mylyn.commons.core.ICoreRunnable;
import org.eclipse.mylyn.internal.tasks.core.ITaskListRunnable;

class DeleteAction$2
  implements ICoreRunnable
{
  DeleteAction$2(DeleteAction paramDeleteAction, List paramList, boolean paramBoolean) {}
  
  /* Error */
  public void run(IProgressMonitor monitor)
    throws CoreException
  {
    // Byte code:
    //   0: aload_1
    //   1: getstatic 66	org/eclipse/mylyn/internal/tasks/ui/actions/Messages:DeleteAction_Delete_in_progress	Ljava/lang/String;
    //   4: iconst_m1
    //   5: invokeinterface 73 3 0
    //   10: aload_0
    //   11: getfield 64	org/eclipse/mylyn/internal/tasks/ui/actions/DeleteAction$2:val$toDelete	Ljava/util/List;
    //   14: invokestatic 70	org/eclipse/mylyn/internal/tasks/ui/actions/DeleteAction:prepareDeletion	(Ljava/util/Collection;)V
    //   17: invokestatic 69	org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin:getTaskList	()Lorg/eclipse/mylyn/internal/tasks/core/TaskList;
    //   20: new 35	org/eclipse/mylyn/internal/tasks/ui/actions/DeleteAction$2$1
    //   23: dup
    //   24: aload_0
    //   25: aload_0
    //   26: getfield 64	org/eclipse/mylyn/internal/tasks/ui/actions/DeleteAction$2:val$toDelete	Ljava/util/List;
    //   29: aload_0
    //   30: getfield 63	org/eclipse/mylyn/internal/tasks/ui/actions/DeleteAction$2:val$deleteOnServer	Z
    //   33: invokespecial 71	org/eclipse/mylyn/internal/tasks/ui/actions/DeleteAction$2$1:<init>	(Lorg/eclipse/mylyn/internal/tasks/ui/actions/DeleteAction$2;Ljava/util/List;Z)V
    //   36: aload_1
    //   37: invokevirtual 68	org/eclipse/mylyn/internal/tasks/core/TaskList:run	(Lorg/eclipse/mylyn/internal/tasks/core/ITaskListRunnable;Lorg/eclipse/core/runtime/IProgressMonitor;)V
    //   40: goto +12 -> 52
    //   43: astore_2
    //   44: aload_1
    //   45: invokeinterface 72 1 0
    //   50: aload_2
    //   51: athrow
    //   52: aload_1
    //   53: invokeinterface 72 1 0
    //   58: return
    // Line number table:
    //   Java source line #151	-> byte code offset #0
    //   Java source line #152	-> byte code offset #10
    //   Java source line #153	-> byte code offset #17
    //   Java source line #161	-> byte code offset #36
    //   Java source line #153	-> byte code offset #37
    //   Java source line #162	-> byte code offset #43
    //   Java source line #163	-> byte code offset #44
    //   Java source line #164	-> byte code offset #50
    //   Java source line #163	-> byte code offset #52
    //   Java source line #165	-> byte code offset #58
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	59	0	this	2
    //   0	59	1	monitor	IProgressMonitor
    //   43	8	2	localObject	Object
    // Exception table:
    //   from	to	target	type
    //   0	43	43	finally
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.DeleteAction.2
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.mylyn.commons.workbench.WorkbenchUtil;
import org.eclipse.mylyn.internal.tasks.ui.dialogs.UiLegendDialog;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;

public class ShowTasksUiLegendAction
  implements IWorkbenchWindowActionDelegate, IViewActionDelegate
{
  public void dispose() {}
  
  public void init(IWorkbenchWindow window) {}
  
  public void run(IAction action)
  {
    UiLegendDialog uiLegendDialog = new UiLegendDialog(WorkbenchUtil.getShell());
    uiLegendDialog.open();
  }
  
  public void selectionChanged(IAction action, ISelection selection) {}
  
  public void init(IViewPart view) {}
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.ShowTasksUiLegendAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

class TaskEditorScheduleAction$1$1
  implements Runnable
{
  TaskEditorScheduleAction$1$1(TaskEditorScheduleAction.1 param1) {}
  
  public void run()
  {
    TaskEditorScheduleAction.1.access$0(this$1).updateImageDescriptor();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.TaskEditorScheduleAction.1.1
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.jface.action.Action;
import org.eclipse.mylyn.internal.tasks.ui.views.AbstractTaskListPresentation;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;

public class PresentationDropDownSelectionAction$PresentationSelectionAction
  extends Action
{
  private final AbstractTaskListPresentation presentation;
  private final TaskListView view;
  
  public PresentationDropDownSelectionAction$PresentationSelectionAction(TaskListView view, AbstractTaskListPresentation presentation)
  {
    this.view = view;
    this.presentation = presentation;
    setText(presentation.getName());
    setImageDescriptor(presentation.getImageDescriptor());
    update();
  }
  
  public void update()
  {
    setChecked(view.getCurrentPresentation().getId().equals(presentation.getId()));
  }
  
  public void run()
  {
    view.applyPresentation(presentation);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.PresentationDropDownSelectionAction.PresentationSelectionAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.tasks.core.ITask;

public class DeleteTaskEditorAction
  extends DeleteAction
{
  public static final String ID = "org.eclipse.mylyn.editor.actions.delete";
  private final ITask task;
  
  public DeleteTaskEditorAction(ITask task)
  {
    Assert.isNotNull(task);
    this.task = task;
    setId("org.eclipse.mylyn.editor.actions.delete");
    setActionDefinitionId(null);
    
    setImageDescriptor(CommonImages.REMOVE);
  }
  
  public DeleteTaskEditorAction()
  {
    setText(Messages.DeleteTaskEditorAction_Delete_Task);
    setId("org.eclipse.mylyn.editor.actions.delete");
    setActionDefinitionId(null);
    task = null;
  }
  
  public IStructuredSelection getStructuredSelection()
  {
    if (task != null) {
      return new StructuredSelection(task);
    }
    return super.getStructuredSelection();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.DeleteTaskEditorAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.ui.actions.ActionContext;
import org.eclipse.ui.actions.ActionGroup;

public class CommentActionGroup
  extends ActionGroup
{
  private CopyCommentDetailsAction copyDetailsAction;
  private CopyCommenterNameAction copyCommenterNameAction;
  private boolean initialized;
  
  private void initialize()
  {
    if (initialized) {
      return;
    }
    initialized = true;
    copyDetailsAction = new CopyCommentDetailsAction();
    copyCommenterNameAction = new CopyCommenterNameAction();
  }
  
  public void fillContextMenu(IMenuManager manager)
  {
    updateActions();
    manager.add(copyDetailsAction);
    manager.add(copyCommenterNameAction);
  }
  
  private void updateActions()
  {
    initialize();
    IStructuredSelection selection = getStructuredSelection();
    copyDetailsAction.selectionChanged(selection);
    copyCommenterNameAction.selectionChanged(selection);
  }
  
  public IStructuredSelection getStructuredSelection()
  {
    ActionContext context = getContext();
    if (context != null)
    {
      ISelection selection = context.getSelection();
      if ((selection instanceof IStructuredSelection)) {
        return (IStructuredSelection)selection;
      }
    }
    return StructuredSelection.EMPTY;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.CommentActionGroup
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.ui.TaskElementLabelProvider;

class TaskSelectionDialog$TaskHistoryItemsComparator
  implements Comparator<Object>
{
  Map<AbstractTask, Integer> positionByTask = new HashMap();
  
  public TaskSelectionDialog$TaskHistoryItemsComparator(List<AbstractTask> arg1)
  {
    for (int i = 0; i < history.size(); i++) {
      positionByTask.put((AbstractTask)history.get(i), Integer.valueOf(i));
    }
  }
  
  public int compare(Object o1, Object o2)
  {
    Integer p1 = (Integer)positionByTask.get(o1);
    Integer p2 = (Integer)positionByTask.get(o2);
    if ((p1 != null) && (p2 != null)) {
      return p2.compareTo(p1);
    }
    return TaskSelectionDialog.access$4(this$0).getText(o1).compareTo(TaskSelectionDialog.access$4(this$0).getText(o2));
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.TaskSelectionDialog.TaskHistoryItemsComparator
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;

class SynchronizeEditorAction$1$1
  implements Runnable
{
  SynchronizeEditorAction$1$1(SynchronizeEditorAction.1 param1, TaskEditor paramTaskEditor) {}
  
  /* Error */
  public void run()
  {
    // Byte code:
    //   0: aload_0
    //   1: getfield 33	org/eclipse/mylyn/internal/tasks/ui/actions/SynchronizeEditorAction$1$1:val$editor	Lorg/eclipse/mylyn/tasks/ui/editors/TaskEditor;
    //   4: invokevirtual 35	org/eclipse/mylyn/tasks/ui/editors/TaskEditor:refreshPages	()V
    //   7: goto +21 -> 28
    //   10: astore_1
    //   11: aload_0
    //   12: getfield 33	org/eclipse/mylyn/internal/tasks/ui/actions/SynchronizeEditorAction$1$1:val$editor	Lorg/eclipse/mylyn/tasks/ui/editors/TaskEditor;
    //   15: ifnull +11 -> 26
    //   18: aload_0
    //   19: getfield 33	org/eclipse/mylyn/internal/tasks/ui/actions/SynchronizeEditorAction$1$1:val$editor	Lorg/eclipse/mylyn/tasks/ui/editors/TaskEditor;
    //   22: iconst_0
    //   23: invokevirtual 36	org/eclipse/mylyn/tasks/ui/editors/TaskEditor:showBusy	(Z)V
    //   26: aload_1
    //   27: athrow
    //   28: aload_0
    //   29: getfield 33	org/eclipse/mylyn/internal/tasks/ui/actions/SynchronizeEditorAction$1$1:val$editor	Lorg/eclipse/mylyn/tasks/ui/editors/TaskEditor;
    //   32: ifnull +11 -> 43
    //   35: aload_0
    //   36: getfield 33	org/eclipse/mylyn/internal/tasks/ui/actions/SynchronizeEditorAction$1$1:val$editor	Lorg/eclipse/mylyn/tasks/ui/editors/TaskEditor;
    //   39: iconst_0
    //   40: invokevirtual 36	org/eclipse/mylyn/tasks/ui/editors/TaskEditor:showBusy	(Z)V
    //   43: return
    // Line number table:
    //   Java source line #72	-> byte code offset #0
    //   Java source line #73	-> byte code offset #10
    //   Java source line #74	-> byte code offset #11
    //   Java source line #75	-> byte code offset #18
    //   Java source line #77	-> byte code offset #26
    //   Java source line #74	-> byte code offset #28
    //   Java source line #75	-> byte code offset #35
    //   Java source line #78	-> byte code offset #43
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	44	0	this	1
    //   10	17	1	localObject	Object
    // Exception table:
    //   from	to	target	type
    //   0	10	10	finally
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.SynchronizeEditorAction.1.1
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.jface.action.IAction;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.actions.ActionDelegate;

public class OpenTaskAction
  extends ActionDelegate
  implements IWorkbenchWindowActionDelegate
{
  private IWorkbenchWindow window;
  
  public void init(IWorkbenchWindow window)
  {
    this.window = window;
  }
  
  public void run(IAction action)
  {
    TaskSelectionDialog dlg = new TaskSelectionDialog(window.getShell(), true);
    dlg.setTitle(Messages.OpenTaskAction_Open_Task);
    dlg.setMessage(Messages.OpenTaskAction_Select_a_task_to_open__);
    dlg.setShowExtendedOpeningOptions(true);
    if (dlg.open() != 0) {
      return;
    }
    if (dlg.getResult() != null)
    {
      Object[] arrayOfObject;
      int j = (arrayOfObject = dlg.getResult()).length;
      for (int i = 0; i < j; i++)
      {
        Object result = arrayOfObject[i];
        if ((result instanceof ITask))
        {
          AbstractTask task = (AbstractTask)result;
          if (dlg.getOpenInBrowser()) {
            TasksUiUtil.openWithBrowser(task);
          } else {
            TasksUiInternal.refreshAndOpenTaskListElement(task);
          }
        }
      }
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.OpenTaskAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.internal.tasks.core.sync.DeleteTasksJob;

class DeleteAction$3
  extends JobChangeAdapter
{
  DeleteAction$3(DeleteAction paramDeleteAction, DeleteTasksJob paramDeleteTasksJob) {}
  
  public void done(IJobChangeEvent event)
  {
    if ((val$deleteTaskJob.getStatus() != null) && (!val$deleteTaskJob.getStatus().isOK())) {
      StatusHandler.log(val$deleteTaskJob.getStatus());
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.DeleteAction.3
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;

public class GroupSubTasksAction
  extends Action
{
  public static final String ID = "org.eclipse.mylyn.tasklist.actions.filter.subtasks";
  
  public GroupSubTasksAction()
  {
    setText(Messages.GroupSubTasksAction_Group_Subtasks);
    setToolTipText(Messages.GroupSubTasksAction_Group_Subtasks);
    setId("org.eclipse.mylyn.tasklist.actions.filter.subtasks");
    setChecked(TasksUiPlugin.getDefault()
      .getPreferenceStore()
      .getBoolean("org.eclipse.mylyn.tasks.ui.group.subtasks"));
  }
  
  public void run()
  {
    TasksUiPlugin.getDefault().getPreferenceStore().setValue("org.eclipse.mylyn.tasks.ui.group.subtasks", isChecked());
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.GroupSubTasksAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskCategory;
import org.eclipse.mylyn.internal.tasks.core.ITaskList;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.ui.actions.BaseSelectionListenerAction;

public class RemoveFromCategoryAction
  extends BaseSelectionListenerAction
{
  public static final String ID = "org.eclipse.mylyn.tasklist.actions.remove";
  
  public RemoveFromCategoryAction()
  {
    super(Messages.RemoveFromCategoryAction_Remove_From_Category);
    setId("org.eclipse.mylyn.tasklist.actions.remove");
    setImageDescriptor(CommonImages.REMOVE);
  }
  
  public void run()
  {
    IStructuredSelection selection = getStructuredSelection();
    for (Object selectedObject : selection.toList()) {
      if ((selectedObject instanceof ITask))
      {
        AbstractTask task = (AbstractTask)selectedObject;
        AbstractTaskCategory category = TaskCategory.getParentTaskCategory(task);
        if (category != null) {
          TasksUiInternal.getTaskList().removeFromContainer(category, task);
        }
      }
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.RemoveFromCategoryAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.IWorkingSetEditWizard;

class TaskSelectionDialog$EditWorkingSetAction
  extends Action
{
  public TaskSelectionDialog$EditWorkingSetAction(TaskSelectionDialog paramTaskSelectionDialog)
  {
    super(Messages.TaskSelectionDialog_Edit_Active_Working_Set_, 1);
  }
  
  public void run()
  {
    IWorkingSetEditWizard wizard = PlatformUI.getWorkbench()
      .getWorkingSetManager()
      .createWorkingSetEditWizard(TaskSelectionDialog.access$0(this$0));
    if (wizard != null)
    {
      WizardDialog dlg = new WizardDialog(this$0.getShell(), wizard);
      dlg.open();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.TaskSelectionDialog.EditWorkingSetAction
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.mylyn.commons.workbench.AdaptiveRefreshPolicy;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListFilteredTree;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;

class FocusTaskListAction$1
  implements DisposeListener
{
  FocusTaskListAction$1(FocusTaskListAction paramFocusTaskListAction) {}
  
  public void widgetDisposed(DisposeEvent e)
  {
    FocusTaskListAction.access$0(this$0).getFilteredTree().getRefreshPolicy().removeListener(this$0);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.FocusTaskListAction.1
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.mylyn.internal.tasks.ui.actions;

import org.eclipse.mylyn.commons.ui.ClipboardCopier.TextProvider;
import org.eclipse.mylyn.tasks.core.IRepositoryPerson;
import org.eclipse.mylyn.tasks.core.ITaskComment;

class CopyCommentDetailsAction$1
  implements C
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 70 71 72 73 74 75 76 77 78 79

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