s.TaskScheduleContentProvider_Unscheduled);
  }
  
  protected boolean select(ITask task)
  {
    return (!task.isCompleted()) && (TaskScheduleContentProvider.access$1(task));
  }
}

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

import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;

class TaskListView$14
  implements ISelectionChangedListener
{
  TaskListView$14(TaskListView paramTaskListView) {}
  
  public void selectionChanged(SelectionChangedEvent event)
  {
    TaskListView.access$10(this$0, true);
  }
}

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

import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.mylyn.internal.tasks.ui.actions.TaskListViewActionGroup;

class TaskListView$20
  implements IMenuListener
{
  TaskListView$20(TaskListView paramTaskListView) {}
  
  public void menuAboutToShow(IMenuManager manager)
  {
    TaskListView.access$17(this$0).fillContextMenu(manager);
  }
}

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

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.internal.tasks.core.IRepositoryChangeListener;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryAdapter;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryChangeEvent;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryDelta;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryDelta.Type;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;

class TaskRepositoriesNavigatorContentProvider$Listener
  extends TaskRepositoryAdapter
  implements IRepositoryChangeListener
{
  private TaskRepositoriesNavigatorContentProvider$Listener(TaskRepositoriesNavigatorContentProvider paramTaskRepositoriesNavigatorContentProvider) {}
  
  public void repositoryAdded(TaskRepository repository)
  {
    refresh(repository);
  }
  
  protected void refresh(TaskRepository repository)
  {
    if (TaskRepositoriesNavigatorContentProvider.access$0(this$0) != null) {
      Display.getDefault().asyncExec(new Runnable()
      {
        public void run()
        {
          if ((TaskRepositoriesNavigatorContentProvider.access$0(this$0) != null) && (TaskRepositoriesNavigatorContentProvider.access$0(this$0).getControl() != null) && (!TaskRepositoriesNavigatorContentProvider.access$0(this$0).getControl().isDisposed())) {
            TaskRepositoriesNavigatorContentProvider.access$0(this$0).refresh();
          }
        }
      });
    }
  }
  
  public void repositoryRemoved(TaskRepository repository)
  {
    refresh(repository);
  }
  
  public void repositoryUrlChanged(TaskRepository repository, String oldUrl)
  {
    refresh(repository);
  }
  
  public void repositoryChanged(TaskRepositoryChangeEvent event)
  {
    TaskRepositoryDelta.Type type = event.getDelta().getType();
    if ((type == TaskRepositoryDelta.Type.ALL) || (type == TaskRepositoryDelta.Type.PROPERTY) || 
      (type == TaskRepositoryDelta.Type.OFFLINE)) {
      refresh(event.getRepository());
    }
  }
}

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

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

class PriorityDropDownAction$3
  extends Action
{
  PriorityDropDownAction$3(PriorityDropDownAction paramPriorityDropDownAction, String $anonymous0, int $anonymous1)
  {
    super($anonymous0, $anonymous1);
  }
  
  public void run()
  {
    TasksUiPlugin.getDefault().getPreferenceStore().setValue("org.eclipse.mylyn.tasks.ui.filters.priority", ITask.PriorityLevel.P3.toString());
    PriorityDropDownAction.access$0(this$0).displayPrioritiesAbove(TaskListView.PRIORITY_LEVELS[2]);
  }
}

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

import org.eclipse.ui.IPageListener;
import org.eclipse.ui.IWorkbenchPage;

class TaskListView$1
  implements IPageListener
{
  TaskListView$1(TaskListView paramTaskListView) {}
  
  public void pageActivated(IWorkbenchPage page)
  {
    TaskListView.access$0(this$0).indicateActiveTaskWorkingSet();
  }
  
  public void pageClosed(IWorkbenchPage page) {}
  
  public void pageOpened(IWorkbenchPage page) {}
}

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

import java.util.HashSet;
import java.util.Set;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.internal.tasks.core.Category;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
import org.eclipse.mylyn.tasks.core.IRepositoryManager;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUi;

public class TaskRepositoriesContentProvider
  implements ITreeContentProvider
{
  private final TaskRepositoryManager manager;
  
  public TaskRepositoriesContentProvider()
  {
    manager = ((TaskRepositoryManager)TasksUi.getRepositoryManager());
  }
  
  public void inputChanged(Viewer v, Object oldInput, Object newInput) {}
  
  public void dispose() {}
  
  public Object[] getElements(Object parent)
  {
    Set<Object> objects = new HashSet();
    objects.addAll(manager.getCategories());
    return objects.toArray();
  }
  
  public Object[] getChildren(Object parentElement)
  {
    if ((parentElement instanceof Category))
    {
      Set<Object> objects = new HashSet();
      for (TaskRepository repository : TasksUi.getRepositoryManager().getAllRepositories())
      {
        Category cat = manager.getCategory(repository);
        if (cat.equals(parentElement)) {
          objects.add(repository);
        }
      }
      return objects.toArray();
    }
    return new Object[0];
  }
  
  public Object getParent(Object element)
  {
    return null;
  }
  
  public boolean hasChildren(Object element)
  {
    return element instanceof Category;
  }
}

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

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.core.ITask.PriorityLevel;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;

class PriorityDropDownAction
  extends Action
  implements IMenuCreator
{
  private final TaskListView taskListView;
  private Action priority1;
  private Action priority2;
  private Action priority3;
  private Action priority4;
  private Action priority5;
  private Menu dropDownMenu = null;
  
  public PriorityDropDownAction(TaskListView taskListView)
  {
    this.taskListView = taskListView;
    setText(Messages.PriorityDropDownAction_Filter_Priority_Lower_Than);
    setToolTipText(Messages.PriorityDropDownAction_Filter_Priority_Lower_Than);
    setImageDescriptor(CommonImages.FILTER_PRIORITY);
    setMenuCreator(this);
  }
  
  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 void addActionsToMenu()
  {
    priority1 = new Action("", 2)
    {
      public void run()
      {
        TasksUiPlugin.getDefault().getPreferenceStore().setValue("org.eclipse.mylyn.tasks.ui.filters.priority", ITask.PriorityLevel.P1.toString());
        taskListView.displayPrioritiesAbove(TaskListView.PRIORITY_LEVELS[0]);
      }
    };
    priority1.setEnabled(true);
    priority1.setText(ITask.PriorityLevel.P1.getDescription());
    priority1.setImageDescriptor(CommonImages.PRIORITY_1);
    ActionContributionItem item = new ActionContributionItem(priority1);
    item.fill(dropDownMenu, -1);
    
    priority2 = new Action("", 2)
    {
      public void run()
      {
        TasksUiPlugin.getDefault().getPreferenceStore().setValue("org.eclipse.mylyn.tasks.ui.filters.priority", ITask.PriorityLevel.P2.toString());
        taskListView.displayPrioritiesAbove(TaskListView.PRIORITY_LEVELS[1]);
      }
    };
    priority2.setEnabled(true);
    priority2.setText(ITask.PriorityLevel.P2.getDescription());
    priority2.setImageDescriptor(CommonImages.PRIORITY_2);
    item = new ActionContributionItem(priority2);
    item.fill(dropDownMenu, -1);
    
    priority3 = new Action("", 2)
    {
      public void run()
      {
        TasksUiPlugin.getDefault().getPreferenceStore().setValue("org.eclipse.mylyn.tasks.ui.filters.priority", ITask.PriorityLevel.P3.toString());
        taskListView.displayPrioritiesAbove(TaskListView.PRIORITY_LEVELS[2]);
      }
    };
    priority3.setEnabled(true);
    priority3.setText(ITask.PriorityLevel.P3.getDescription());
    priority3.setImageDescriptor(CommonImages.PRIORITY_3);
    item = new ActionContributionItem(priority3);
    item.fill(dropDownMenu, -1);
    
    priority4 = new Action("", 2)
    {
      public void run()
      {
        TasksUiPlugin.getDefault().getPreferenceStore().setValue("org.eclipse.mylyn.tasks.ui.filters.priority", ITask.PriorityLevel.P4.toString());
        taskListView.displayPrioritiesAbove(TaskListView.PRIORITY_LEVELS[3]);
      }
    };
    priority4.setEnabled(true);
    priority4.setText(ITask.PriorityLevel.P4.getDescription());
    priority4.setImageDescriptor(CommonImages.PRIORITY_4);
    item = new ActionContributionItem(priority4);
    item.fill(dropDownMenu, -1);
    
    priority5 = new Action("", 2)
    {
      public void run()
      {
        TasksUiPlugin.getDefault().getPreferenceStore().setValue("org.eclipse.mylyn.tasks.ui.filters.priority", ITask.PriorityLevel.P5.toString());
        taskListView.displayPrioritiesAbove(TaskListView.PRIORITY_LEVELS[4]);
      }
    };
    priority5.setEnabled(true);
    priority5.setImageDescriptor(CommonImages.PRIORITY_5);
    priority5.setText(ITask.PriorityLevel.P5.getDescription());
    item = new ActionContributionItem(priority5);
    item.fill(dropDownMenu, -1);
    
    updateCheckedState();
  }
  
  void updateCheckedState()
  {
    if (priority1 == null) {
      return;
    }
    String priority = TaskListView.getCurrentPriorityLevel();
    
    priority1.setChecked(false);
    priority2.setChecked(false);
    priority3.setChecked(false);
    priority4.setChecked(false);
    priority5.setChecked(false);
    if (priority.equals(TaskListView.PRIORITY_LEVELS[0]))
    {
      priority1.setChecked(true);
    }
    else if (priority.equals(TaskListView.PRIORITY_LEVELS[1]))
    {
      priority1.setChecked(true);
      priority2.setChecked(true);
    }
    else if (priority.equals(TaskListView.PRIORITY_LEVELS[2]))
    {
      priority1.setChecked(true);
      priority2.setChecked(true);
      priority3.setChecked(true);
    }
    else if (priority.equals(TaskListView.PRIORITY_LEVELS[3]))
    {
      priority1.setChecked(true);
      priority2.setChecked(true);
      priority3.setChecked(true);
      priority4.setChecked(true);
    }
    else if (priority.equals(TaskListView.PRIORITY_LEVELS[4]))
    {
      priority1.setChecked(true);
      priority2.setChecked(true);
      priority3.setChecked(true);
      priority4.setChecked(true);
      priority5.setChecked(true);
    }
  }
  
  public void run()
  {
    setChecked(isChecked());
  }
}

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

import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.ShowInContext;

class TaskListView$27
  implements IShowInSource
{
  TaskListView$27(TaskListView paramTaskListView) {}
  
  public ShowInContext getShowInContext()
  {
    return new ShowInContext(this$0.getViewer().getInput(), this$0.getViewer().getSelection());
  }
}

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

import org.eclipse.swt.widgets.Event;

public abstract interface TaskListToolTip$TaskListToolTipListener
{
  public abstract void toolTipHidden(Event paramEvent);
}

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

import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.mylyn.commons.ui.SelectionProviderAdapter;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;

class TaskListView$8
  extends FocusAdapter
{
  TaskListView$8(TaskListView paramTaskListView) {}
  
  public void focusGained(FocusEvent e)
  {
    TaskListView.access$12(this$0).setSelection(this$0.getViewer().getSelection());
  }
}

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

class TaskListToolTip$ProgressData
{
  int completed;
  int total;
  String text;
  
  public TaskListToolTip$ProgressData(int completed, int total, String text)
  {
    this.completed = completed;
    this.total = total;
    this.text = text;
  }
}

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

import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.TaskRepository;

class UpdateRepositoryConfigurationAction$1
  extends Job
{
  UpdateRepositoryConfigurationAction$1(UpdateRepositoryConfigurationAction paramUpdateRepositoryConfigurationAction, String $anonymous0, String paramString1, TaskRepository paramTaskRepository, AbstractRepositoryConnector paramAbstractRepositoryConnector)
  {
    super($anonymous0);
  }
  
  /* Error */
  protected org.eclipse.core.runtime.IStatus run(org.eclipse.core.runtime.IProgressMonitor monitor)
  {
    // Byte code:
    //   0: aload_1
    //   1: aload_0
    //   2: getfield 48	org/eclipse/mylyn/internal/tasks/ui/views/UpdateRepositoryConfigurationAction$1:val$jobName	Ljava/lang/String;
    //   5: iconst_m1
    //   6: invokeinterface 55 3 0
    //   11: aload_0
    //   12: getfield 49	org/eclipse/mylyn/internal/tasks/ui/views/UpdateRepositoryConfigurationAction$1:this$0	Lorg/eclipse/mylyn/internal/tasks/ui/views/UpdateRepositoryConfigurationAction;
    //   15: aload_0
    //   16: getfield 51	org/eclipse/mylyn/internal/tasks/ui/views/UpdateRepositoryConfigurationAction$1:val$repository	Lorg/eclipse/mylyn/tasks/core/TaskRepository;
    //   19: aload_0
    //   20: getfield 50	org/eclipse/mylyn/internal/tasks/ui/views/UpdateRepositoryConfigurationAction$1:val$connector	Lorg/eclipse/mylyn/tasks/core/AbstractRepositoryConnector;
    //   23: aload_1
    //   24: invokevirtual 53	org/eclipse/mylyn/internal/tasks/ui/views/UpdateRepositoryConfigurationAction:performUpdate	(Lorg/eclipse/mylyn/tasks/core/TaskRepository;Lorg/eclipse/mylyn/tasks/core/AbstractRepositoryConnector;Lorg/eclipse/core/runtime/IProgressMonitor;)V
    //   27: goto +12 -> 39
    //   30: astore_2
    //   31: aload_1
    //   32: invokeinterface 54 1 0
    //   37: aload_2
    //   38: athrow
    //   39: aload_1
    //   40: invokeinterface 54 1 0
    //   45: getstatic 47	org/eclipse/core/runtime/Status:OK_STATUS	Lorg/eclipse/core/runtime/IStatus;
    //   48: areturn
    // Line number table:
    //   Java source line #59	-> byte code offset #0
    //   Java source line #61	-> byte code offset #11
    //   Java source line #62	-> byte code offset #30
    //   Java source line #63	-> byte code offset #31
    //   Java source line #64	-> byte code offset #37
    //   Java source line #63	-> byte code offset #39
    //   Java source line #65	-> byte code offset #45
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	49	0	this	1
    //   0	49	1	monitor	org.eclipse.core.runtime.IProgressMonitor
    //   30	8	2	localObject	Object
    // Exception table:
    //   from	to	target	type
    //   11	30	30	finally
  }
}

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

import java.util.Set;
import org.eclipse.mylyn.internal.tasks.core.TaskContainerDelta;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskListChangeAdapter;
import org.eclipse.mylyn.tasks.core.ITask;

class TaskListFilteredTree$3
  extends TaskListChangeAdapter
{
  TaskListFilteredTree$3(TaskListFilteredTree paramTaskListFilteredTree) {}
  
  public void containersChanged(Set<TaskContainerDelta> containers)
  {
    for (TaskContainerDelta taskContainerDelta : containers) {
      if ((taskContainerDelta.getElement() instanceof ITask))
      {
        TaskListFilteredTree.access$7(this$0);
        break;
      }
    }
  }
}

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

class TaskRepositoriesView$2$1
  implements Runnable
{
  TaskRepositoriesView$2$1(TaskRepositoriesView.2 param2) {}
  
  public void run()
  {
    TaskRepositoriesView.2.access$0(this$1).refresh();
  }
}

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

import org.eclipse.mylyn.internal.tasks.core.ITaskList;
import org.eclipse.mylyn.internal.tasks.core.LocalTask;
import org.eclipse.mylyn.internal.tasks.ui.util.AbstractRetrieveTitleFromUrlJob;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;

class TaskListDropAdapter$2
  extends AbstractRetrieveTitleFromUrlJob
{
  TaskListDropAdapter$2(TaskListDropAdapter paramTaskListDropAdapter, String $anonymous0, LocalTask paramLocalTask, String paramString1)
  {
    super($anonymous0);
  }
  
  protected void titleRetrieved(String pageTitle)
  {
    if (val$newTask.getSummary().equals(val$summary))
    {
      val$newTask.setSummary(pageTitle);
      TasksUiInternal.getTaskList().notifyElementChanged(val$newTask);
    }
  }
}

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

import org.eclipse.mylyn.commons.workbench.PropertiesAction;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.navigator.CommonActionProvider;
import org.eclipse.ui.navigator.ICommonActionExtensionSite;

public class TaskRepositoriesNavigatorActionProvider
  extends CommonActionProvider
{
  private PropertiesAction propertiesAction;
  
  public void init(ICommonActionExtensionSite aSite)
  {
    super.init(aSite);
    
    propertiesAction = new PropertiesAction();
  }
  
  public void fillActionBars(IActionBars actionBars)
  {
    super.fillActionBars(actionBars);
    
    actionBars.setGlobalActionHandler("org.eclipse.ui.navigator.Open", propertiesAction);
  }
}

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

import org.eclipse.mylyn.internal.tasks.ui.actions.ActivateTaskDialogAction;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITaskActivityManager;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;

class TaskListFilteredTree$14
  extends MouseAdapter
{
  TaskListFilteredTree$14(TaskListFilteredTree paramTaskListFilteredTree) {}
  
  public void mouseDown(MouseEvent e)
  {
    if (button == 1)
    {
      ITask activeTask = TasksUi.getTaskActivityManager().getActiveTask();
      if (activeTask == null)
      {
        ActivateTaskDialogAction activateAction = new ActivateTaskDialogAction();
        activateAction.init(PlatformUI.getWorkbench().getActiveWorkbenchWindow());
        activateAction.run(null);
      }
      else
      {
        TasksUiInternal.refreshAndOpenTaskListElement(activeTask);
      }
    }
  }
}

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

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.mylyn.internal.tasks.core.Category;

public class EmptyCategoriesFilter
  extends ViewerFilter
{
  private final TaskRepositoriesContentProvider provider;
  
  public EmptyCategoriesFilter(TaskRepositoriesContentProvider provider)
  {
    this.provider = provider;
  }
  
  public boolean select(Viewer viewer, Object parentElement, Object element)
  {
    if ((element instanceof Category)) {
      return provider.getChildren(element).length > 0;
    }
    return true;
  }
}

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

class TaskScheduleContentProvider$1
  implements Runnable
{
  TaskScheduleContentProvider$1(TaskScheduleContentProvider paramTaskScheduleContentProvider) {}
  
  public void run()
  {
    this$0.taskListView.refresh();
  }
}

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

import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;

class WorkweekProgressBar$2
  implements PaintListener
{
  WorkweekProgressBar$2(WorkweekProgressBar paramWorkweekProgressBar) {}
  
  public void paintControl(PaintEvent e)
  {
    WorkweekProgressBar.access$3(this$0, e);
  }
}

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

import org.eclipse.jface.viewers.DecoratingLabelProvider;
import org.eclipse.jface.viewers.ILabelDecorator;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITaskContainer;
import org.eclipse.mylyn.tasks.core.context.AbstractTaskContextStore;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.swt.graphics.Image;

public class TableDecoratingLabelProvider
  extends DecoratingLabelProvider
  implements ITableLabelProvider
{
  public TableDecoratingLabelProvider(ILabelProvider provider, ILabelDecorator decorator)
  {
    super(provider, decorator);
  }
  
  public Image getColumnImage(Object element, int columnIndex)
  {
    if (!(element instanceof ITaskContainer)) {
      return null;
    }
    if (columnIndex == 0)
    {
      if (((element instanceof ITaskContainer)) && (!(element instanceof ITask))) {
        return super.getImage(element);
      }
      if ((element instanceof AbstractTask))
      {
        AbstractTask task = (AbstractTask)element;
        if (task.isActive()) {
          return CommonImages.getImage(TasksUiImages.CONTEXT_ACTIVE);
        }
        if (TasksUiPlugin.getContextStore().hasContext(task)) {
          return CommonImages.getImage(TasksUiImages.CONTEXT_INACTIVE);
        }
        return CommonImages.getImage(TasksUiImages.CONTEXT_INACTIVE_EMPTY);
      }
      return CommonImages.getImage(TasksUiImages.CONTEXT_INACTIVE_EMPTY);
    }
    if (columnIndex == 1)
    {
      if (((element instanceof ITaskContainer)) || ((element instanceof IRepositoryQuery))) {
        return null;
      }
      return super.getImage(element);
    }
    return null;
  }
  
  public String getColumnText(Object element, int columnIndex)
  {
    return null;
  }
}

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

import org.eclipse.mylyn.internal.tasks.ui.util.TreeWalker.TreeVisitor;

class TaskListView$TaskListRefreshJob$1
  extends TreeWalker.TreeVisitor
{
  TaskListView$TaskListRefreshJob$1(TaskListView.TaskListRefreshJob paramTaskListRefreshJob) {}
  
  public boolean visit(Object object)
  {
    return true;
  }
}

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

import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;

class TaskListView$15
  extends FocusAdapter
{
  TaskListView$15(TaskListView paramTaskListView) {}
  
  public void focusLost(FocusEvent e)
  {
    TaskListView.access$9(this$0).hide();
  }
}

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

import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;

class TaskListView$21
  implements IMenuListener
{
  TaskListView$21(TaskListView paramTaskListView) {}
  
  public void menuAboutToShow(IMenuManager manager)
  {
    TaskListView.access$20(this$0).updateCheckedState();
  }
}

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

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

class PriorityDropDownAction$4
  extends Action
{
  PriorityDropDownAction$4(PriorityDropDownAction paramPriorityDropDownAction, String $anonymous0, int $anonymous1)
  {
    super($anonymous0, $anonymous1);
  }
  
  public void run()
  {
    TasksUiPlugin.getDefault().getPreferenceStore().setValue("org.eclipse.mylyn.tasks.ui.filters.priority", ITask.PriorityLevel.P4.toString());
    PriorityDropDownAction.access$0(this$0).displayPrioritiesAbove(TaskListView.PRIORITY_LEVELS[3]);
  }
}

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

import org.eclipse.mylyn.commons.workbench.DelayedRefreshJob;
import org.eclipse.mylyn.tasks.core.TaskActivityAdapter;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;

class TaskListView$2
  extends TaskActivityAdapter
{
  TaskListView$2(TaskListView paramTaskListView) {}
  
  public void activityReset()
  {
    PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable()
    {
      public void run()
      {
        TaskListView.access$1(this$0).refresh();
      }
    });
  }
}

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

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

class TaskListView$9
  implements ModifyListener
{
  TaskListView$9(TaskListView paramTaskListView) {}
  
  public void modifyText(ModifyEvent e)
  {
    TaskListView.access$13(this$0);
  }
}

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

import org.eclipse.core.runtime.CoreException;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;

class UpdateRepositoryConfigurationAction$2
  implements Runnable
{
  UpdateRepositoryConfigurationAction$2(UpdateRepositoryConfigurationAction paramUpdateRepositoryConfigurationAction, CoreException paramCoreException) {}
  
  public void run()
  {
    TasksUiInternal.displayStatus(
      Messages.UpdateRepositoryConfigurationAction_Error_updating_repository_configuration, 
      val$e.getStatus());
  }
}

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

import org.eclipse.mylyn.tasks.core.TaskActivityAdapter;

class TaskListFilteredTree$4
  extends TaskActivityAdapter
{
  TaskListFilteredTree$4(TaskListFilteredTree paramTaskListFilteredTree) {}
  
  public void activityReset()
  {
    TaskListFilteredTree.access$7(this$0);
  }
}

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

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.commons.ui.PlatformUiUtil;
import org.eclipse.mylyn.commons.ui.compatibility.CommonFonts;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.core.UnmatchedTaskContainer;
import org.eclipse.mylyn.internal.tasks.ui.AbstractTaskListFilter;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITask.SynchronizationState;
import org.eclipse.mylyn.tasks.core.ITaskContainer;
import org.eclipse.mylyn.tasks.core.context.AbstractTaskContextStore;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.swt.widgets.Widget;

public class CustomTaskListDecorationDrawer
  implements Listener
{
  private final int activationImageOffset;
  private final Image taskActive = CommonImages.getImage(TasksUiImages.CONTEXT_ACTIVE);
  private final Image taskInactive = CommonImages.getImage(TasksUiImages.CONTEXT_INACTIVE_EMPTY);
  private final Image taskInactiveContext = CommonImages.getImage(TasksUiImages.CONTEXT_INACTIVE);
  private final int platformSpecificSquish;
  private final Rectangle lastClippingArea;
  private final boolean tweakClipping;
  private boolean useStrikethroughForCompleted;
  private boolean synchronizationOverlaid;
  private boolean focusedMode;
  private final IPropertyChangeListener PROPERTY_LISTENER = new IPropertyChangeListener()
  {
    public void propertyChange(PropertyChangeEvent event)
    {
      if (event.getProperty().equals("org.eclipse.mylyn.tasks.ui.strikethrough.for.completed"))
      {
        if ((event.getNewValue() instanceof Boolean)) {
          useStrikethroughForCompleted = ((Boolean)event.getNewValue()).booleanValue();
        }
      }
      else if ((event.getProperty().equals("org.eclipse.mylyn.tasks.ui.overlays.incoming.tight")) && 
        ((event.getNewValue() instanceof Boolean))) {
        synchronizationOverlaid = ((Boolean)event.getNewValue()).booleanValue();
      }
    }
  };
  
  public CustomTaskListDecorationDrawer(int activationImageOffset, boolean focusedMode)
  {
    this.activationImageOffset = activationImageOffset;
    lastClippingArea = new Rectangle(0, 0, 0, 0);
    tweakClipping = PlatformUiUtil.isPaintItemClippingRequired();
    platformSpecificSquish = PlatformUiUtil.getTreeItemSquish();
    synchronizationOverlaid = TasksUiPlugin.getDefault()
      .getPreferenceStore()
      .getBoolean("org.eclipse.mylyn.tasks.ui.overlays.incoming.tight");
    useStrikethroughForCompleted = TasksUiPlugin.getDefault()
      .getPreferenceStore()
      .getBoolean("org.eclipse.mylyn.tasks.ui.strikethrough.for.completed");
    this.focusedMode = focusedMode;
    TasksUiPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(PROPERTY_LISTENER);
  }
  
  public void handleEvent(Event event)
  {
    Object data = item.getData();
    Image activationImage = null;
    if ((data instanceof ITask))
    {
      AbstractTask task = (AbstractTask)data;
      if (task.isActive()) {
        activationImage = taskActive;
      } else if (TasksUiPlugin.getContextStore().hasContext(task)) {
        activationImage = taskInactiveContext;
      } else {
        activationImage = taskInactive;
      }
    }
    if ((!CommonFonts.HAS_STRIKETHROUGH) && 
      ((data instanceof AbstractTask & useStrikethroughForCompleted)))
    {
      AbstractTask task = (AbstractTask)data;
      if (task.isCompleted())
      {
        Rectangle bounds = ((TreeItem)item).getTextBounds(0);
        
        int lineY = y + height / 2;
        String itemText = ((TreeItem)item).getText();
        Point extent = gc.textExtent(itemText);
        gc.drawLine(x, lineY, x + x, lineY);
      }
    }
    if ((data instanceof ITaskContainer)) {
      switch (type)
      {
      case 40: 
        if (tweakClipping)
        {
          lastClippingArea.x = x;
          lastClippingArea.y = y;
          lastClippingArea.width = width;
          lastClippingArea.height = height;
        }
        break;
      case 42: 
        Rectangle clipping = null;
        if (tweakClipping)
        {
          clipping = gc.getClipping();
          gc.setClipping(lastClippingArea);
        }
        if (activationImage != null) {
          drawActivationImage(activationImageOffset, event, activationImage);
        }
        if ((data instanceof ITaskContainer)) {
          drawSyncronizationImage((ITaskContainer)data, event);
        }
        if (tweakClipping) {
          gc.setClipping(clipping);
        }
        break;
      }
    }
  }
  
  private void drawSyncronizationImage(ITaskContainer element, Event event)
  {
    Image image = null;
    int offsetX = PlatformUiUtil.getIncomingImageOffset();
    int offsetY = height / 2 - 5;
    if (synchronizationOverlaid)
    {
      offsetX = x + 18 - platformSpecificSquish;
      offsetY += 2;
    }
    if (element != null) {
      if ((element instanceof ITask))
      {
        image = CommonImages.getImage(getSynchronizationImageDescriptor(element, synchronizationOverlaid));
      }
      else
      {
        int imageOffset = 0;
        if ((!hideDecorationOnContainer(element, (TreeItem)item)) && 
          (AbstractTaskListFilter.hasDescendantIncoming(element)))
        {
          if (synchronizationOverlaid) {
            image = CommonImages.getImage(CommonImages.OVERLAY_SYNC_OLD_INCOMMING);
          } else {
            image = CommonImages.getImage(CommonImages.OVERLAY_SYNC_INCOMMING);
          }
        }
        else if ((element instanceof IRepositoryQuery))
        {
          RepositoryQuery query = (RepositoryQuery)element;
          if (query.getStatus() != null)
          {
            image = CommonImages.getImage(CommonImages.OVERLAY_SYNC_WARNING);
            if (synchronizationOverlaid) {
              imageOffset = 11;
            } else {
              imageOffset = 3;
            }
          }
        }
        int additionalSquish = 0;
        if ((platformSpecificSquish > 0) && (synchronizationOverlaid)) {
          additionalSquish = platformSpecificSquish + 3;
        } else if (platformSpecificSquish > 0) {
          additionalSquish = platformSpecificSquish / 2;
        }
        if (synchronizationOverlaid) {
          offsetX = 42 - imageOffset - additionalSquish;
        } else {
          offsetX = 24 - imageOffset - additionalSquish;
        }
      }
    }
    if (image != null) {
      gc.drawImage(image, offsetX, y + offsetY);
    }
  }
  
  private boolean hideDecorationOnContainer(ITaskContainer element, TreeItem treeItem)
  {
    if ((element instanceof ScheduledTaskContainer)) {
      return true;
    }
    if ((element instanceof UnmatchedTaskContainer))
    {
      if (!focusedMode) {
        return false;
      }
      if (AbstractTaskListFilter.hasDescendantIncoming(element)) {
        return true;
      }
    }
    else if ((element instanceof IRepositoryQuery))
    {
      RepositoryQuery query = (RepositoryQuery)element;
      if (query.getStatus() != null) {
        return true;
      }
    }
    if (focusedMode) {
      return false;
    }
    if (((element instanceof IRepositoryQuery)) || ((element instanceof TaskCategory))) {
      return treeItem.getExpanded();
    }
    return false;
  }
  
  private void drawActivationImage(int