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

tion_Expand_All;
  public static String ExportAction_Dialog_Title;
  public static String ExportAction_Nothing_selected;
  public static String ExportAction_Problems_encountered;
  public static String ExportAction_X_exists_Do_you_wish_to_overwrite;
  public static String FilterCompletedTasksAction_Filter_Completed_Tasks;
  public static String GoIntoAction_Go_Into;
  public static String GoUpAction_Go_Up_To_Root;
  public static String GroupSubTasksAction_Group_Subtasks;
  public static String HideQueryAction_Hidden_Label;
  public static String ImportAction_Dialog_Title;
  public static String ImportAction_Problems_encountered;
  public static String LinkWithEditorAction_Link_with_Editor;
  public static String NewCategoryAction_A_category_with_this_name_already_exists;
  public static String NewCategoryAction_Enter_name;
  public static String NewCategoryAction_Enter_a_name_for_the_Category;
  public static String NewCategoryAction_New_Category;
  public static String NewCategoryAction_New_Category_;
  public static String NewCategoryAction_A_query_with_this_name_already_exists;
  public static String NewQueryAction_new_query_;
  public static String NewSubTaskAction_The_connector_does_not_support_creating_subtasks_for_this_task;
  public static String NewSubTaskAction_Could_not_retrieve_task_data_for_task_;
  public static String NewSubTaskAction_Create_a_new_subtask;
  public static String NewSubTaskAction_Failed_to_create_new_sub_task_;
  public static String NewSubTaskAction_Subtask;
  public static String NewSubTaskAction_Unable_to_create_subtask;
  public static String NewTaskAction_Add_Repository;
  public static String NewTaskAction_new_task;
  public static String NewTaskAction_Show_Wizard_Label;
  public static String NewTaskFromSelectionAction_Comment_;
  public static String NewTaskFromSelectionAction____Created_from_Comment___;
  public static String NewTaskFromSelectionAction_New_Task_from_Selection;
  public static String NewTaskFromSelectionAction_Nothing_selected_to_create_task_from;
  public static String NewTaskFromSelectionAction_URL_;
  public static String OpenRepositoryTask_Could_not_find_matching_repository_task;
  public static String OpenRepositoryTask_Open_Repository_Task;
  public static String OpenRepositoryTask_Open_Task;
  public static String OpenTaskAction_Open_Task;
  public static String OpenTaskAction_Select_a_task_to_open__;
  public static String OpenTaskListElementAction_Open;
  public static String OpenTaskListElementAction_Open_Task_List_Element;
  public static String OpenTasksUiPreferencesAction_Preferences_;
  public static String OpenWithBrowserAction_Open_with_Browser;
  public static String PresentationDropDownSelectionAction_Task_Presentation;
  public static String QueryCloneAction_Clone_Query;
  public static String QueryCloneAction_Copy_of_X;
  public static String QueryCloneAction_No_query_selected;
  public static String RefreshRepositoryTasksAction_Refresh_All_Tasks;
  public static String RemoveFromCategoryAction_Remove_From_Category;
  public static String RenameAction_Rename;
  public static String ShowAllQueriesAction_Show_All_Queries;
  public static String ShowAllQueriesAction_Show_All_Queries_Including_Hidden_Queries;
  public static String ShowInSearchViewAction_Open_in_Search_Label;
  public static String ShowInTaskListAction_Show_In_Task_List;
  public static String ShowNonMatchingSubtasksAction_Show_Non_Matching_Subtasks;
  public static String SynchronizeAutomaticallyAction_Synchronize_Automatically;
  public static String SynchronizeEditorAction_Synchronize;
  public static String SynchronizeEditorAction_Synchronize_Incoming_Changes;
  public static String TaskActivateAction_Activate;
  public static String TaskDeactivateAction_Deactivate;
  public static String TaskEditorScheduleAction_Private_Scheduling;
  public static String TaskListSortAction_Sort_;
  public static String TaskSelectionDialog__matches;
  public static String TaskSelectionDialog_Deselect_Working_Set;
  public static String TaskSelectionDialog_Edit_Active_Working_Set_;
  public static String TaskSelectionDialog_New_Task_;
  public static String TaskSelectionDialog_Open_with_Browser;
  public static String TaskSelectionDialog_Random_Task;
  public static String TaskSelectionDialog_Scanning_tasks;
  public static String TaskSelectionDialog_Search_for_tasks;
  public static String TaskSelectionDialog_Select_Working_Set_;
  public static String TaskSelectionDialog_Selected_item_is_not_a_task;
  public static String TaskSelectionDialog_Show_Completed_Tasks;
  public static String TaskSelectionDialogWithRandom_Feeling_Lazy_Error;
  public static String TaskSelectionDialogWithRandom_Feeling_Lazy_Error_Title;
  public static String TaskSelectionDialogWithRandom_Feeling_Lazy_Tooltip;
  public static String TaskWorkingSetAction_All;
  public static String TaskWorkingSetAction_Deselect_All;
  public static String TaskWorkingSetAction_Edit_Label;
  public static String TaskWorkingSetAction_Select_and_Edit_Working_Sets;
  public static String TaskWorkingSetAction_Sets;
  public static String ToggleAllWorkingSetsAction_Show_All;
  public static String ToggleTaskActivationAction_Activate_Task;
  public static String ToggleTaskActivationAction_Deactivate_Task;
  
  static {}
  
  public static void reloadMessages()
  {
    NLS.initializeMessages("org.eclipse.mylyn.internal.tasks.ui.actions.messages", Messages.class);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.Messages
 * 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.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.actions.ActionDelegate;

public class ActivateTaskDialogAction
  extends ActionDelegate
  implements IWorkbenchWindowActionDelegate
{
  private IWorkbenchWindow window;
  
  public void init(IWorkbenchWindow window)
  {
    this.window = window;
  }
  
  public void run(IAction action)
  {
    TaskSelectionDialogWithRandom dialog = new TaskSelectionDialogWithRandom(window.getShell());
    dialog.setActivateTask(true);
    dialog.setTitle(Messages.ActivateTaskDialogAction_Activate_Task);
    dialog.setMessage(Messages.ActivateTaskDialogAction_Select_a_task_to_activate__);
    if (dialog.open() != 0) {
      return;
    }
    Object result = dialog.getFirstResult();
    if ((result instanceof ITask))
    {
      AbstractTask task = (AbstractTask)result;
      TasksUiInternal.activateTaskThroughCommand(task);
    }
    if (TaskListView.getFromActivePerspective() != null) {
      TaskListView.getFromActivePerspective().refresh();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.ActivateTaskDialogAction
 * 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.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryDelta;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryDelta.Type;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.views.Messages;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryManager;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUi;

public class DisconnectRepositoryAction
  extends Action
  implements ISelectionChangedListener
{
  public static final String LABEL = Messages.DisconnectRepositoryAction_Disconnected;
  private static final String ID = "org.eclipse.mylyn.tasklist.repositories.offline";
  private TaskRepository repository;
  
  public DisconnectRepositoryAction()
  {
    super(LABEL, 2);
    setId("org.eclipse.mylyn.tasklist.repositories.offline");
    setEnabled(false);
  }
  
  public void run()
  {
    repository.setOffline(isChecked());
    TasksUiPlugin.getRepositoryManager().notifyRepositorySettingsChanged(repository, 
      new TaskRepositoryDelta(TaskRepositoryDelta.Type.OFFLINE));
  }
  
  @Deprecated
  public void selectionChanged(IAction action, ISelection selection) {}
  
  public void selectionChanged(SelectionChangedEvent event)
  {
    ISelection selection = event.getSelection();
    if (((selection instanceof IStructuredSelection)) && (((IStructuredSelection)selection).size() == 1))
    {
      Object selectedObject = ((IStructuredSelection)selection).getFirstElement();
      if ((selectedObject instanceof TaskRepository))
      {
        AbstractRepositoryConnector connector = TasksUi.getRepositoryManager().getRepositoryConnector(
          ((TaskRepository)selectedObject).getConnectorKind());
        if (connector.isUserManaged())
        {
          repository = ((TaskRepository)selectedObject);
          setChecked(repository.isOffline());
          setEnabled(true);
          return;
        }
      }
    }
    repository = null;
    setChecked(false);
    setEnabled(false);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.DisconnectRepositoryAction
 * 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.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.wizard.IWizard;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.mylyn.commons.workbench.WorkbenchUtil;
import org.eclipse.mylyn.internal.tasks.ui.wizards.TaskDataImportWizard;
import org.eclipse.ui.IViewActionDelegate;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;

public class RestoreTaskListAction
  extends Action
  implements IViewActionDelegate, IWorkbenchWindowActionDelegate
{
  public void init(IViewPart view) {}
  
  public void run(IAction action)
  {
    run();
  }
  
  public void run()
  {
    IWizard wizard = new TaskDataImportWizard();
    WizardDialog dialog = new WizardDialog(WorkbenchUtil.getShell(), wizard);
    dialog.create();
    dialog.setBlockOnOpen(true);
    dialog.open();
  }
  
  public void selectionChanged(IAction action, ISelection selection) {}
  
  public void dispose() {}
  
  public void init(IWorkbenchWindow window) {}
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.RestoreTaskListAction
 * 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.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.mylyn.commons.core.ICoreRunnable;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.data.AbstractTaskDataHandler;
import org.eclipse.mylyn.tasks.core.data.TaskData;

class NewSubTaskAction$1
  implements ICoreRunnable
{
  NewSubTaskAction$1(NewSubTaskAction paramNewSubTaskAction, boolean[] paramArrayOfBoolean, AbstractTaskDataHandler paramAbstractTaskDataHandler, TaskRepository paramTaskRepository, TaskData paramTaskData1, TaskData paramTaskData2) {}
  
  public void run(IProgressMonitor monitor)
    throws CoreException
  {
    val$result[0] = val$taskDataHandler.initializeSubTaskData(val$taskRepository, val$taskData, val$selectedTaskData, 
      monitor);
  }
}

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

import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.mylyn.internal.tasks.ui.dialogs.AbstractWorkingSetDialogCOPY;
import org.eclipse.mylyn.internal.tasks.ui.workingsets.TaskWorkingSetUpdater;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.internal.dialogs.WorkingSetFilter;
import org.eclipse.ui.internal.dialogs.WorkingSetLabelProvider;

class TaskWorkingSetAction$ConfigureWindowWorkingSetsDialog
  extends AbstractWorkingSetDialogCOPY
{
  private static final int SIZING_SELECTION_WIDGET_HEIGHT = 200;
  private static final int SIZING_SELECTION_WIDGET_WIDTH = 50;
  private final IWorkbenchWindow window;
  private CheckboxTableViewer viewer;
  private Set<String> taskWorkingSetIds;
  
  protected TaskWorkingSetAction$ConfigureWindowWorkingSetsDialog(TaskWorkingSetAction arg1, IWorkbenchWindow window, String[] workingSetIds)
  {
    super(window.getShell(), workingSetIds, true);
    setShellStyle(getShellStyle() | 0x10);
    this.window = window;
    
    setTitle(Messages.TaskWorkingSetAction_Select_and_Edit_Working_Sets);
    setMessage("");
    if ((workingSetIds == null) || (workingSetIds.length == 0))
    {
      taskWorkingSetIds = null;
    }
    else
    {
      taskWorkingSetIds = new HashSet();
      String[] arrayOfString;
      int j = (arrayOfString = workingSetIds).length;
      for (int i = 0; i < j; i++)
      {
        String id = arrayOfString[i];
        taskWorkingSetIds.add(id);
      }
    }
  }
  
  protected Control createDialogArea(Composite parent)
  {
    initializeDialogUnits(parent);
    
    Composite composite = (Composite)super.createDialogArea(parent);
    
    Composite viewerComposite = new Composite(composite, 0);
    GridLayout layout = new GridLayout(2, false);
    marginHeight = (marginWidth = 0);
    horizontalSpacing = convertHorizontalDLUsToPixels(4);
    verticalSpacing = convertVerticalDLUsToPixels(4);
    viewerComposite.setLayout(layout);
    
    GridData data = new GridData(1808);
    heightHint = 200;
    widthHint = 350;
    viewerComposite.setLayoutData(data);
    
    viewer = CheckboxTableViewer.newCheckList(viewerComposite, 2048);
    viewer.getControl().setLayoutData(new GridData(1808));
    viewer.setLabelProvider(new WorkingSetLabelProvider());
    viewer.setContentProvider(new ArrayContentProvider());
    viewer.addFilter(new WorkingSetFilter(taskWorkingSetIds));
    viewer.setInput(window.getWorkbench().getWorkingSetManager().getWorkingSets());
    
    viewer.setCheckedElements(TaskWorkingSetUpdater.getActiveWorkingSets(window).toArray());
    
    viewer.addSelectionChangedListener(new ISelectionChangedListener()
    {
      public void selectionChanged(SelectionChangedEvent event)
      {
        handleSelectionChanged();
      }
    });
    data = new GridData(1808);
    heightHint = 200;
    widthHint = 50;
    
    viewer.getControl().setLayoutData(data);
    addModifyButtons(viewerComposite);
    
    addSelectionButtons(composite);
    
    availableWorkingSetsChanged();
    
    Dialog.applyDialogFont(composite);
    
    return composite;
  }
  
  protected void okPressed()
  {
    Set<IWorkingSet> newList = new HashSet(Arrays.asList(TaskWorkingSetUpdater.getEnabledSets()));
    Set<IWorkingSet> tempList = new HashSet();
    Iterator localIterator2;
    for (Iterator localIterator1 = newList.iterator(); localIterator1.hasNext(); localIterator2.hasNext())
    {
      IWorkingSet workingSet = (IWorkingSet)localIterator1.next();
      localIterator2 = taskWorkingSetIds.iterator(); continue;String id = (String)localIterator2.next();
      if (workingSet.getId().equalsIgnoreCase(id)) {
        tempList.add(workingSet);
      }
    }
    newList.removeAll(tempList);
    
    Object[] selection = viewer.getCheckedElements();
    IWorkingSet[] setsToEnable = new IWorkingSet[selection.length];
    System.arraycopy(selection, 0, setsToEnable, 0, selection.length);
    newList.addAll(new HashSet(Arrays.asList(setsToEnable)));
    
    TaskWorkingSetUpdater.applyWorkingSetsToAllWindows(newList);
    super.okPressed();
  }
  
  protected List<?> getSelectedWorkingSets()
  {
    ISelection selection = viewer.getSelection();
    if ((selection instanceof IStructuredSelection)) {
      return ((IStructuredSelection)selection).toList();
    }
    return null;
  }
  
  protected void availableWorkingSetsChanged()
  {
    viewer.setInput(window.getWorkbench().getWorkingSetManager().getWorkingSets());
    super.availableWorkingSetsChanged();
  }
  
  void handleSelectionChanged()
  {
    updateButtonAvailability();
  }
  
  protected void configureShell(Shell shell)
  {
    super.configureShell(shell);
  }
  
  protected void selectAllSets()
  {
    viewer.setCheckedElements(window.getWorkbench().getWorkingSetManager().getWorkingSets());
    updateButtonAvailability();
  }
  
  protected void deselectAllSets()
  {
    viewer.setCheckedElements(new Object[0]);
    updateButtonAvailability();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.TaskWorkingSetAction.ConfigureWindowWorkingSetsDialog
 * 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.core.TaskMapping;

class NewTaskFromSelectionAction$2
  extends TaskMapping
{
  NewTaskFromSelectionAction$2(NewTaskFromSelectionAction paramNewTaskFromSelectionAction, StringBuilder paramStringBuilder) {}
  
  public String getDescription()
  {
    return val$sb.toString();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.tasks.ui.actions.NewTaskFromSelectionAction.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.IMenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.commons.ui.SelectionProviderAdapter;
import org.eclipse.mylyn.commons.workbench.WorkbenchActionSupport;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditorInput;

public class TaskEditorActionGroup
  extends RepositoryElementActionGroup
{
  private final WorkbenchActionSupport actionSupport;
  private final SynchronizeEditorAction synchronizeEditorAction = new SynchronizeEditorAction();
  private final NewTaskFromSelectionAction newTaskFromSelectionAction = new NewTaskFromSelectionAction();
  
  public TaskEditorActionGroup(WorkbenchActionSupport actionSupport)
  {
    this.actionSupport = actionSupport;
    synchronizeEditorAction.setActionDefinitionId("org.eclipse.ui.file.refresh");
    synchronizeEditorAction.setEnabled(false);
  }
  
  public void fillContextMenu(IMenuManager manager, TaskEditor editor, boolean addClipboard)
  {
    ITask task = editor.getTaskEditorInput().getTask();
    SelectionProviderAdapter selectionProvider = new SelectionProviderAdapter();
    setSelectionProvider(selectionProvider);
    selectionProvider.setSelection(new StructuredSelection(task));
    
    super.fillContextMenu(manager);
    if (addClipboard) {
      addClipboardActions(manager);
    }
    synchronizeEditorAction.selectionChanged(new StructuredSelection(editor));
    
    IStructuredSelection selection = new StructuredSelection(task);
    actionSupport.updateActions(selection);
    newTaskFromSelectionAction.selectionChanged(selection);
    
    manager.add(new Separator());
    if (synchronizeEditorAction.isEnabled()) {
      manager.appendToGroup("repository", synchronizeEditorAction);
    }
  }
  
  public void addClipboardActions(IMenuManager manager)
  {
    manager.prependToGroup("edit", actionSupport.getCopyAction());
    manager.prependToGroup("edit", actionSupport.getCutAction());
    manager.appendToGroup("edit", actionSupport.getPasteAction());
    manager.appendToGroup("edit", actionSupport.getSelectAllAction());
    manager.appendToGroup("edit", newTaskFromSelectionAction);
  }
  
  public SynchronizeEditorAction getSynchronizeEditorAction()
  {
    return synchronizeEditorAction;
  }
  
  public NewTaskFromSelectionAction getNewTaskFromSelectionAction()
  {
    return newTaskFromSelectionAction;
  }
}

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

import java.util.ArrayList;
import java.util.List;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.dialogs.PatternFilter;

public abstract class AbstractSearchHandler
{
  private final List<IFilterChangeListener> listeners = new ArrayList();
  
  public void addFilterChangeListener(IFilterChangeListener listener)
  {
    listeners.add(listener);
  }
  
  public void removeFilterChangeListener(IFilterChangeListener listener)
  {
    listeners.remove(listener);
  }
  
  protected void fireFilterChanged()
  {
    if (listeners.isEmpty()) {
      return;
    }
    IFilterChangeListener[] arrayOfIFilterChangeListener;
    int j = (arrayOfIFilterChangeListener = (IFilterChangeListener[])listeners.toArray(new IFilterChangeListener[listeners.size()])).length;
    for (int i = 0; i < j; i++)
    {
      IFilterChangeListener listener = arrayOfIFilterChangeListener[i];
      listener.filterChanged();
    }
  }
  
  public abstract Composite createSearchComposite(Composite paramComposite);
  
  public abstract PatternFilter createFilter();
  
  public abstract void dispose();
  
  public void adaptTextSearchControl(Text textControl) {}
  
  public static abstract interface IFilterChangeListener
  {
    public abstract void filterChanged();
  }
}

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

public abstract interface AbstractSearchHandler$IFilterChangeListener
{
  public abstract void filterChanged();
}

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

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.internal.tasks.core.ITaskList;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.ui.IWorkbenchWindow;

public class SearchUtil
{
  private static final String EXTENSION_SEARCH_PROVIDER = "org.eclipse.mylyn.tasks.ui.searchProvider";
  private static final String EXTENSION_SEARCH_HANDLER = "org.eclipse.mylyn.tasks.ui.searchHandler";
  private static final String ATTR_CLASS = "class";
  private static AbstractSearchProvider provider;
  
  private static final AbstractSearchProvider getSearchProvider()
  {
    if (provider != null) {
      return provider;
    }
    try
    {
      IExtensionRegistry registry = Platform.getExtensionRegistry();
      
      IConfigurationElement[] configurationElements = registry.getConfigurationElementsFor("org.eclipse.mylyn.tasks.ui.searchProvider");
      if (configurationElements.length > 0)
      {
        if (configurationElements.length > 1) {
          StatusHandler.log(new Status(2, "org.eclipse.mylyn.tasks.ui", 
            "More than one search provider was registered."));
        }
        IConfigurationElement providerConfiguration = configurationElements[0];
        Object object = providerConfiguration.createExecutableExtension("class");
        if ((object instanceof AbstractSearchProvider))
        {
          provider = (AbstractSearchProvider)object;
          return provider;
        }
        StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", 
          "Specified search provider is not of type AbstractSearchProvider."));
      }
      else
      {
        StatusHandler.log(new Status(2, "org.eclipse.mylyn.tasks.ui", 
          "No search provider was registed. Tasks search is not available."));
      }
    }
    catch (Throwable e)
    {
      StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", 
        "Loading of searchProvider extension failed.", e));
    }
    if (provider == null) {
      provider = new NullSearchProvider(null);
    }
    return provider;
  }
  
  public static AbstractSearchHandler createSearchHandler()
  {
    AbstractSearchHandler searchHandler = null;
    try
    {
      IExtensionRegistry registry = Platform.getExtensionRegistry();
      
      IConfigurationElement[] configurationElements = registry.getConfigurationElementsFor("org.eclipse.mylyn.tasks.ui.searchHandler");
      if (configurationElements.length > 0)
      {
        if (configurationElements.length > 1) {
          StatusHandler.log(new Status(2, "org.eclipse.mylyn.tasks.ui", 
            "More than one task list search handler was registered."));
        }
        IConfigurationElement providerConfiguration = configurationElements[0];
        searchHandler = (AbstractSearchHandler)providerConfiguration.createExecutableExtension("class");
      }
    }
    catch (Throwable e)
    {
      StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", 
        "Loading of searchHandler extension failed.", e));
    }
    if (searchHandler == null) {
      searchHandler = new DefaultSearchHandler();
    }
    return searchHandler;
  }
  
  public static boolean supportsTaskSearch()
  {
    return !(getSearchProvider() instanceof NullSearchProvider);
  }
  
  public static void openSearchDialog(IWorkbenchWindow window)
  {
    getSearchProvider().openSearchDialog(window);
  }
  
  public static void runSearchQuery(ITaskList tasklist, TaskRepository repository, IRepositoryQuery repositoryQuery)
  {
    getSearchProvider().runSearchQuery(tasklist, repository, repositoryQuery, false);
  }
  
  public static void runSearchQuery(ITaskList tasklist, TaskRepository repository, IRepositoryQuery repositoryQuery, boolean activateResultView)
  {
    getSearchProvider().runSearchQuery(tasklist, repository, repositoryQuery, activateResultView);
  }
  
  private static class NullSearchProvider
    extends AbstractSearchProvider
  {
    public void openSearchDialog(IWorkbenchWindow window) {}
    
    public void runSearchQuery(ITaskList tasklist, TaskRepository repository, IRepositoryQuery query, boolean activateResultView) {}
  }
}

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

import org.eclipse.mylyn.internal.tasks.core.ITaskList;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.ui.IWorkbenchWindow;

public abstract class AbstractSearchProvider
{
  public abstract void openSearchDialog(IWorkbenchWindow paramIWorkbenchWindow);
  
  public abstract void runSearchQuery(ITaskList paramITaskList, TaskRepository paramTaskRepository, IRepositoryQuery paramIRepositoryQuery, boolean paramBoolean);
}

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

import org.eclipse.mylyn.internal.tasks.core.ITaskList;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.ui.IWorkbenchWindow;

class SearchUtil$NullSearchProvider
  extends AbstractSearchProvider
{
  public void openSearchDialog(IWorkbenchWindow window) {}
  
  public void runSearchQuery(ITaskList tasklist, TaskRepository repository, IRepositoryQuery query, boolean activateResultView) {}
}

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

import org.eclipse.mylyn.commons.workbench.SubstringPatternFilter;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.dialogs.PatternFilter;

public class DefaultSearchHandler
  extends AbstractSearchHandler
{
  public PatternFilter createFilter()
  {
    return new SubstringPatternFilter();
  }
  
  public Composite createSearchComposite(Composite container)
  {
    return null;
  }
  
  public void dispose() {}
}

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

public abstract interface ITaskCommandIds
{
  public static final String OPEN_TASK = "org.eclipse.mylyn.tasks.ui.command.openTask";
  public static final String OPEN_TASK_REMOTE = "org.eclipse.mylyn.tasks.ui.command.openRemoteTask";
  public static final String ACTIVATE_TASK = "org.eclipse.mylyn.tasks.ui.command.activateTask";
  public static final String DEACTIVATE_TASK = "org.eclipse.mylyn.tasks.ui.command.deactivateAllTasks";
  public static final String ADD_TASK_REPOSITORY = "org.eclipse.mylyn.tasks.ui.command.addTaskRepository";
}

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

import java.text.MessageFormat;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.mylyn.tasks.ui.TasksUiUtil;

class OpenRepositoryTaskJob$1
  implements Runnable
{
  OpenRepositoryTaskJob$1(OpenRepositoryTaskJob paramOpenRepositoryTaskJob) {}
  
  public void run()
  {
    MessageDialog.openError(
      null, 
      Messages.OpenRepositoryTaskJob_Repository_Not_Found, 
      
      MessageFormat.format(Messages.OpenRepositoryTaskJob_Could_not_find_repository_configuration_for_X, new Object[] {OpenRepositoryTaskJob.access$0(this$0) }) + 
      "\n" + 
      MessageFormat.format(Messages.OpenRepositoryTaskJob_Please_set_up_repository_via_X, new Object[] {
      Messages.TasksUiPlugin_Task_Repositories }));
    TasksUiUtil.openUrl(OpenRepositoryTaskJob.access$1(this$0));
  }
}

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

import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.tasks.core.ITaskActivityManager;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;

class TaskTrimWidget$6
  extends HyperlinkAdapter
{
  TaskTrimWidget$6(TaskTrimWidget paramTaskTrimWidget) {}
  
  public void linkActivated(HyperlinkEvent e)
  {
    TaskListView taskListView = TaskListView.getFromActivePerspective();
    if ((taskListView != null) && (taskListView.getDrilledIntoCategory() != null)) {
      taskListView.goUpToRoot();
    }
    TasksUiInternal.refreshAndOpenTaskListElement(TasksUi.getTaskActivityManager().getActiveTask());
  }
}

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

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.AbstractTaskRepositoryLinkProvider;

class TasksUiPlugin$12
  implements ISafeRunnable
{
  TasksUiPlugin$12(TasksUiPlugin paramTasksUiPlugin, AbstractTaskRepositoryLinkProvider paramAbstractTaskRepositoryLinkProvider, TaskRepository[] paramArrayOfTaskRepository, IResource paramIResource) {}
  
  public void handleException(Throwable e)
  {
    StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", "Task repository link provider failed: \"" + 
      val$linkProvider.getId() + "\"", e));
  }
  
  public void run()
    throws Exception
  {
    val$repository[0] = val$linkProvider.getTaskRepository(val$resource, TasksUiPlugin.getRepositoryManager());
  }
}

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

import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.IRepositoryElement;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;

class ScheduleDatePicker$2
  extends HyperlinkAdapter
{
  ScheduleDatePicker$2(ScheduleDatePicker paramScheduleDatePicker) {}
  
  public void linkActivated(HyperlinkEvent e)
  {
    this$0.setScheduledDate(null);
    for (IRepositoryElement task : ScheduleDatePicker.access$4(this$0)) {
      if ((task instanceof AbstractTask)) {
        ((AbstractTask)task).setReminded(false);
      }
    }
    ScheduleDatePicker.access$3(this$0);
  }
}

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

import com.ibm.icu.text.Collator;
import java.util.Comparator;
import org.eclipse.ui.IWorkingSet;

public class WorkingSetLabelComparator
  implements Comparator<IWorkingSet>
{
  public int compare(IWorkingSet ws1, IWorkingSet ws2)
  {
    return Collator.getInstance().compare(ws1.getLabel(), ws2.getLabel());
  }
}

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

import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;

class TaskWorkingSetPage$1
  implements ModifyListener
{
  TaskWorkingSetPage$1(TaskWorkingSetPage paramTaskWorkingSetPage) {}
  
  public void modifyText(ModifyEvent e)
  {
    this$0.validateInput();
  }
}

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.ITaskList;
import org.eclipse.mylyn.internal.tasks.core.ITaskListChangeListener;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.core.TaskContainerDelta;
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.monitor.ui.MonitorUi;
import org.eclipse.mylyn.tasks.core.IRepositoryElement;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.IWorkingSetUpdater;
import org.eclipse.ui.PlatformUI;

public class TaskWorkingSetUpdater
  implements IWorkingSetUpdater, ITaskListChangeListener, IResourceChangeListener
{
  public static String ID_TASK_WORKING_SET = "org.eclipse.mylyn.tasks.ui.workingSet";
  private final List<IWorkingSet> workingSets = new CopyOnWriteArrayList();
  
  private static class TaskWorkingSetDelta
  {
    private final IWorkingSet workingSet;
    private final List<Object> elements;
    private boolean changed;
    
    public TaskWorkingSetDelta(IWorkingSet workingSet)
    {
      this.workingSet = workingSet;
      elements = new ArrayList(Arrays.asList(workingSet.getElements()));
    }
    
    public int indexOf(Object element)
    {
      return elements.indexOf(element);
    }
    
    public void set(int index, Object element)
    {
      elements.set(index, element);
      changed = true;
    }
    
    public void remove(int index)
    {
      if (elements.remove(index) != null) {
        changed = true;
      }
    }
    
    public void process()
    {
      if (changed) {
        workingSet.setElements((IAdaptable[])elements.toArray(new IAdaptable[elements.size()]));
      }
    }
  }
  
  private static boolean enabled = true;
  
  public TaskWorkingSetUpdater()
  {
    TasksUiInternal.getTaskList().addChangeListener(this);
    ResourcesPlugin.getWorkspace().addResourceChangeListener(this);
  }
  
  public static void setEnabled(boolean enabled)
  {
    enabled = enabled;
  }
  
  public static boolean isEnabled()
  {
    return enabled;
  }
  
  public void dispose()
  {
    TasksUiInternal.getTaskList().removeChangeListener(this);
  }
  
  public void add(IWorkingSet workingSet)
  {
    checkElementExistence(workingSet);
    synchronized (workingSets)
    {
      workingSets.add(workingSet);
    }
  }
  
  private void checkElementExistence(IWorkingSet workingSet)
  {
    ArrayList<IAdaptable> list = new ArrayList(Arrays.asList(workingSet.getElements()));
    boolean changed = false;
    for (Iterator<IAdaptable> iter = list.iterator(); iter.hasNext();)
    {
      IAdaptable adaptable = (IAdaptable)iter.next();
      boolean remove = false;
      if ((adaptable instanceof AbstractTaskContainer))
      {
        String handle = ((AbstractTaskContainer)adaptable).getHandleIdentifier();
        remove = true;
        for (IRepositoryElement element : TasksUiPlugin.getTaskList().getRootElemen
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