sitoryCredentialsDialog_Save_Password;
  public static String TaskRepositoryCredentialsDialog_Saved_passwords_are_stored_that_is_difficult;
  public static String TaskRepositoryCredentialsDialog_Task_Repository;
  public static String TaskRepositoryCredentialsDialog_User_ID;
  public static String TaskRepositoryCredentialsDialog_Filename;
  public static String UiLegendControl_Active_task;
  public static String UiLegendControl_Adjust_Colors_and_Fonts_;
  public static String UiLegendControl_Also_see_the_Getting_Started_documentation_online;
  public static String UiLegendControl_Category;
  public static String UiLegendControl_Completed;
  public static String UiLegendControl_Completed_today;
  public static String UiLegendControl_Conflicting_changes;
  public static String UiLegendControl_Date_range;
  public static String UiLegendControl__default_;
  public static String UiLegendControl_Focus_view_on_active_task;
  public static String UiLegendControl_Has_due_date;
  public static String UiLegendControl_http_www_eclipse_org_mylyn_start;
  public static String UiLegendControl_Inactive_task_with_context;
  public static String UiLegendControl_Inactive_task_with_no_context;
  public static String UiLegendControl_Incoming_changes;
  public static String UiLegendControl_New_task;
  public static String UiLegendControl_Open_Task_List_;
  public static String UiLegendControl_Outgoing_changes;
  public static String UiLegendControl_Past_Due_date;
  public static String UiLegendControl_Past_scheduled_date;
  public static String UiLegendControl_Priorities;
  public static String UiLegendControl_Query;
  public static String UiLegendControl_Scheduled_for_today;
  public static String UiLegendControl_Synchronization;
  public static String UiLegendControl_Synchronization_failed;
  public static String UiLegendControl_Task;
  public static String UiLegendControl_Task_Activity;
  public static String UiLegendControl_Task_Context;
  public static String UiLegendControl_Tasks;
  public static String UiLegendControl_Tasks_UI_Legend;
  public static String UiLegendControl_Unsubmitted_outgoing_changes;
  public static String UiLegendDialog_Close_Dialog;
  
  static {}
  
  public static void reloadMessages()
  {
    NLS.initializeMessages("org.eclipse.mylyn.internal.tasks.ui.dialogs.messages", Messages.class);
  }
}

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

import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;

class AbstractWorkingSetDialogCOPY$4
  extends SelectionAdapter
{
  AbstractWorkingSetDialogCOPY$4(AbstractWorkingSetDialogCOPY paramAbstractWorkingSetDialogCOPY) {}
  
  public void widgetSelected(SelectionEvent e)
  {
    this$0.selectAllSets();
  }
}

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

import org.eclipse.jface.preference.PreferenceDialog;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.PreferencesUtil;
import org.eclipse.ui.forms.events.HyperlinkEvent;
import org.eclipse.ui.forms.events.IHyperlinkListener;

class UiLegendControl$3
  implements IHyperlinkListener
{
  UiLegendControl$3(UiLegendControl paramUiLegendControl) {}
  
  public void linkActivated(HyperlinkEvent e)
  {
    PreferenceDialog dlg = PreferencesUtil.createPreferenceDialogOn(PlatformUI.getWorkbench()
      .getActiveWorkbenchWindow()
      .getShell(), "org.eclipse.ui.preferencePages.ColorsAndFonts", 
      new String[] { "org.eclipse.ui.preferencePages.ColorsAndFonts" }, null);
    dlg.open();
  }
  
  public void linkEntered(HyperlinkEvent e) {}
  
  public void linkExited(HyperlinkEvent e) {}
}

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

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.wizard.IWizard;
import org.eclipse.mylyn.internal.tasks.ui.wizards.LocalRepositorySettingsPage;
import org.eclipse.mylyn.internal.tasks.ui.wizards.NewLocalTaskWizard;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITaskMapping;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.AbstractRepositoryConnectorUi;
import org.eclipse.mylyn.tasks.ui.wizards.ITaskRepositoryPage;

public class LocalRepositoryConnectorUi
  extends AbstractRepositoryConnectorUi
{
  public ImageDescriptor getTaskKindOverlay(ITask task)
  {
    return super.getTaskKindOverlay(task);
  }
  
  public IWizard getNewTaskWizard(TaskRepository taskRepository, ITaskMapping selection)
  {
    return new NewLocalTaskWizard(selection);
  }
  
  public IWizard getQueryWizard(TaskRepository repository, IRepositoryQuery queryToEdit)
  {
    return null;
  }
  
  public String getConnectorKind()
  {
    return "local";
  }
  
  public ITaskRepositoryPage getSettingsPage(TaskRepository taskRepository)
  {
    return new LocalRepositorySettingsPage(taskRepository);
  }
  
  public boolean hasSearchPage()
  {
    return false;
  }
}

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

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.mylyn.commons.core.CoreUtil;
import org.eclipse.mylyn.commons.net.AuthenticationCredentials;
import org.eclipse.mylyn.commons.net.AuthenticationType;
import org.eclipse.mylyn.commons.net.Policy;
import org.eclipse.mylyn.commons.net.UnsupportedRequestException;
import org.eclipse.mylyn.commons.workbench.WorkbenchUtil;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryDelta;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryDelta.Type;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryLocation;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
import org.eclipse.mylyn.internal.tasks.ui.dialogs.TaskRepositoryCredentialsDialog;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;

public class TaskRepositoryLocationUi
  extends TaskRepositoryLocation
{
  private static Object lock = new Object();
  
  public TaskRepositoryLocationUi(TaskRepository taskRepository)
  {
    super(taskRepository);
  }
  
  public void requestCredentials(AuthenticationType authType, String message, IProgressMonitor monitor)
    throws UnsupportedRequestException
  {
    if (CoreUtil.TEST_MODE) {
      throw new UnsupportedRequestException();
    }
    AuthenticationCredentials oldCredentials = taskRepository.getCredentials(authType);
    synchronized (lock)
    {
      if (!areEqual(oldCredentials, taskRepository.getCredentials(authType))) {
        return;
      }
      if (Policy.isBackgroundMonitor(monitor)) {
        throw new UnsupportedRequestException();
      }
      PasswordRunner runner = new PasswordRunner(authType, message);
      if (!PlatformUI.getWorkbench().getDisplay().isDisposed())
      {
        PlatformUI.getWorkbench().getDisplay().syncExec(runner);
        if (runner.isCanceled()) {
          throw new OperationCanceledException();
        }
        if (!runner.isChanged()) {
          throw new UnsupportedRequestException();
        }
      }
      else
      {
        throw new UnsupportedRequestException();
      }
    }
  }
  
  private boolean areEqual(AuthenticationCredentials oldCredentials, AuthenticationCredentials credentials)
  {
    if (oldCredentials == null) {
      return credentials == null;
    }
    return oldCredentials.equals(credentials);
  }
  
  private class PasswordRunner
    implements Runnable
  {
    private final AuthenticationType authType;
    private boolean changed;
    private final String message;
    private boolean canceled;
    
    public PasswordRunner(AuthenticationType credentialType, String message)
    {
      authType = credentialType;
      this.message = message;
    }
    
    public boolean isChanged()
    {
      return changed;
    }
    
    public boolean isCanceled()
    {
      return canceled;
    }
    
    public void run()
    {
      Shell shell = WorkbenchUtil.getShell();
      if ((shell != null) && (!shell.isDisposed()))
      {
        TaskRepositoryCredentialsDialog dialog = TaskRepositoryCredentialsDialog.createDialog(shell);
        initializeDialog(dialog);
        int resultCode = dialog.open();
        if (resultCode == 0)
        {
          apply(dialog);
          changed = true;
        }
        else if (resultCode == 1000)
        {
          changed = true;
        }
        else
        {
          canceled = true;
        }
      }
    }
    
    private void initializeDialog(TaskRepositoryCredentialsDialog dialog)
    {
      dialog.setTaskRepository(taskRepository);
      dialog.setFileDialog(AuthenticationType.CERTIFICATE.equals(authType));
      AuthenticationCredentials credentials = taskRepository.getCredentials(authType);
      if (credentials != null)
      {
        dialog.setUsername(credentials.getUserName());
        dialog.setPassword(credentials.getPassword());
      }
      if (message != null) {
        dialog.setMessage(message);
      } else {
        dialog.setMessage(getDefaultMessage());
      }
    }
    
    private String getDefaultMessage()
    {
      if (AuthenticationType.REPOSITORY.equals(authType)) {
        return Messages.TaskRepositoryLocationUi_Enter_repository_password;
      }
      if (AuthenticationType.CERTIFICATE.equals(authType)) {
        return Messages.TaskRepositoryLocationUi_Enter_CLIENTCERTIFICATE_password;
      }
      if (AuthenticationType.HTTP.equals(authType)) {
        return Messages.TaskRepositoryLocationUi_Enter_HTTP_password;
      }
      if (AuthenticationType.PROXY.equals(authType)) {
        return Messages.TaskRepositoryLocationUi_Enter_proxy_password;
      }
      return null;
    }
    
    private void apply(TaskRepositoryCredentialsDialog dialog)
    {
      AuthenticationCredentials credentials = new AuthenticationCredentials(dialog.getUserName(), 
        dialog.getPassword());
      taskRepository.setCredentials(authType, credentials, dialog.getSavePassword());
      TasksUiPlugin.getRepositoryManager().notifyRepositorySettingsChanged(taskRepository, 
        new TaskRepositoryDelta(TaskRepositoryDelta.Type.CREDENTIALS, authType));
    }
  }
}

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

import java.util.Set;
import org.eclipse.mylyn.internal.tasks.core.ITaskListChangeListener;
import org.eclipse.mylyn.internal.tasks.core.TaskContainerDelta;
import org.eclipse.mylyn.internal.tasks.core.TaskContainerDelta.Kind;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.swt.widgets.Display;

class TaskTrimWidget$2
  implements ITaskListChangeListener
{
  TaskTrimWidget$2(TaskTrimWidget paramTaskTrimWidget) {}
  
  public void containersChanged(Set<TaskContainerDelta> containers)
  {
    if (TaskTrimWidget.access$1(this$0) != null) {
      for (TaskContainerDelta taskContainerDelta : containers) {
        if ((TaskTrimWidget.access$1(this$0).equals(taskContainerDelta.getElement())) && 
          (taskContainerDelta.getKind().equals(TaskContainerDelta.Kind.CONTENT)))
        {
          Display.getDefault().asyncExec(new Runnable()
          {
            public void run()
            {
              if ((TaskTrimWidget.access$1(this$0) != null) && (TaskTrimWidget.access$1(this$0).isActive())) {
                this$0.indicateActiveTask();
              }
            }
          });
          return;
        }
      }
    }
  }
}

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

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.atomic.AtomicInteger;
import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.net.proxy.IProxyChangeEvent;
import org.eclipse.core.net.proxy.IProxyChangeListener;
import org.eclipse.core.net.proxy.IProxyService;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ISaveContext;
import org.eclipse.core.resources.ISaveParticipant;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.operation.IRunnableWithProgress;
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.jface.util.SafeRunnable;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.commons.identity.core.IIdentityService;
import org.eclipse.mylyn.commons.net.WebUtil;
import org.eclipse.mylyn.commons.notifications.core.NotificationEnvironment;
import org.eclipse.mylyn.commons.notifications.feed.ServiceMessageManager;
import org.eclipse.mylyn.commons.notifications.ui.AbstractUiNotification;
import org.eclipse.mylyn.commons.workbench.TaskBarManager;
import org.eclipse.mylyn.internal.discovery.ui.AbstractInstallJob;
import org.eclipse.mylyn.internal.discovery.ui.DiscoveryUi;
import org.eclipse.mylyn.internal.monitor.ui.ActivityContextManager;
import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
import org.eclipse.mylyn.internal.tasks.core.AbstractSearchHandler;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.IRepositoryModelListener;
import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.RepositoryExternalizationParticipant;
import org.eclipse.mylyn.internal.tasks.core.RepositoryModel;
import org.eclipse.mylyn.internal.tasks.core.RepositoryTemplateManager;
import org.eclipse.mylyn.internal.tasks.core.TaskActivationHistory;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
import org.eclipse.mylyn.internal.tasks.core.TaskList;
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.core.data.SynchronizationManger;
import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManager;
import org.eclipse.mylyn.internal.tasks.core.data.TaskDataStore;
import org.eclipse.mylyn.internal.tasks.core.externalization.ExternalizationManager;
import org.eclipse.mylyn.internal.tasks.core.externalization.IExternalizationParticipant;
import org.eclipse.mylyn.internal.tasks.core.externalization.TaskListExternalizationParticipant;
import org.eclipse.mylyn.internal.tasks.core.externalization.TaskListExternalizer;
import org.eclipse.mylyn.internal.tasks.ui.actions.ActivateTaskDialogAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.NewTaskAction;
import org.eclipse.mylyn.internal.tasks.ui.notifications.TaskListNotificationReminder;
import org.eclipse.mylyn.internal.tasks.ui.notifications.TaskListNotifier;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiExtensionReader;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskRepositoriesView;
import org.eclipse.mylyn.tasks.core.AbstractDuplicateDetector;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITask.PriorityLevel;
import org.eclipse.mylyn.tasks.core.ITaskContainer;
import org.eclipse.mylyn.tasks.core.RepositoryTemplate;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.activity.AbstractTaskActivityMonitor;
import org.eclipse.mylyn.tasks.core.context.AbstractTaskContextStore;
import org.eclipse.mylyn.tasks.ui.AbstractRepositoryConnectorUi;
import org.eclipse.mylyn.tasks.ui.AbstractTaskRepositoryLinkProvider;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPageFactory;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IStartup;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.FormColors;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.eclipse.ui.progress.IProgressService;
import org.eclipse.ui.progress.UIJob;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.util.tracker.ServiceTracker;

public class TasksUiPlugin
  extends AbstractUIPlugin
{
  private static final int DELAY_QUERY_REFRESH_ON_STARTUP = 20000;
  private static final int DEFAULT_LINK_PROVIDER_TIMEOUT = 5000;
  public static final String ID_PLUGIN = "org.eclipse.mylyn.tasks.ui";
  private static final String DIRECTORY_METADATA = ".metadata";
  private static final String NAME_DATA_DIR = ".mylyn";
  private static final char DEFAULT_PATH_SEPARATOR = '/';
  private static final int NOTIFICATION_DELAY = 5000;
  private static TasksUiPlugin INSTANCE;
  private static ExternalizationManager externalizationManager;
  private static TaskActivityManager taskActivityManager;
  private static TaskRepositoryManager repositoryManager;
  private static TaskListSynchronizationScheduler synchronizationScheduler;
  private static TaskDataManager taskDataManager;
  private static Map<String, AbstractRepositoryConnectorUi> repositoryConnectorUiMap = new HashMap();
  private TaskListNotificationManager taskListNotificationManager;
  private TaskListBackupManager taskListBackupManager;
  private RepositoryTemplateManager repositoryTemplateManager;
  private ServiceMessageManager serviceMessageManager;
  private final Set<AbstractTaskEditorPageFactory> taskEditorPageFactories = new HashSet();
  private final TreeSet<AbstractTaskRepositoryLinkProvider> repositoryLinkProviders = new TreeSet(
    new OrderComparator(null));
  private TaskListExternalizer taskListExternalizer;
  private final Map<String, Image> brandingIcons = new HashMap();
  private final Map<String, ImageDescriptor> overlayIcons = new HashMap();
  private final Set<AbstractDuplicateDetector> duplicateDetectors = new HashSet();
  private ISaveParticipant saveParticipant;
  private TaskJobFactory taskJobFactory;
  private FormColors formColors;
  private static AbstractTaskContextStore contextStore;
  private final List<AbstractSearchHandler> searchHandlers = new ArrayList();
  private static final boolean DEBUG_HTTPCLIENT = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.mylyn.tasks.ui/debug/httpclient"));
  
  private static final class OrderComparator
    implements Comparator<AbstractTaskRepositoryLinkProvider>
  {
    public int compare(AbstractTaskRepositoryLinkProvider p1, AbstractTaskRepositoryLinkProvider p2)
    {
      return p1.getOrder() - p2.getOrder();
    }
  }
  
  public static enum TaskListSaveMode
  {
    ONE_HOUR,  THREE_HOURS,  DAY;
    
    public String toString()
    {
      switch (this)
      {
      case DAY: 
        return "1 hour";
      case ONE_HOUR: 
        return "3 hours";
      case THREE_HOURS: 
        return "1 day";
      }
      return "3 hours";
    }
    
    public static TaskListSaveMode fromString(String string)
    {
      if (string == null) {
        return null;
      }
      if (string.equals("1 hour")) {
        return ONE_HOUR;
      }
      if (string.equals("3 hours")) {
        return THREE_HOURS;
      }
      if (string.equals("1 day")) {
        return DAY;
      }
      return null;
    }
    
    public static long fromStringToLong(String string)
    {
      long hour = 3600000L;
      switch (fromString(string))
      {
      case DAY: 
        return hour;
      case ONE_HOUR: 
        return hour * 3L;
      case THREE_HOURS: 
        return hour * 24L;
      }
      return hour * 3L;
    }
  }
  
  public static enum ReportOpenMode
  {
    EDITOR,  INTERNAL_BROWSER,  EXTERNAL_BROWSER;
  }
  
  private static ITaskListNotificationProvider REMINDER_NOTIFICATION_PROVIDER = new ITaskListNotificationProvider()
  {
    public Set<AbstractUiNotification> getNotifications()
    {
      Collection<AbstractTask> allTasks = TasksUiPlugin.getTaskList().getAllTasks();
      Set<AbstractUiNotification> reminders = new HashSet();
      for (AbstractTask task : allTasks) {
        if ((TasksUiPlugin.getTaskActivityManager().isPastReminder(task)) && (!task.isReminded()))
        {
          reminders.add(new TaskListNotificationReminder(task));
          task.setReminded(true);
        }
      }
      return reminders;
    }
  };
  private final IPropertyChangeListener PROPERTY_LISTENER = new IPropertyChangeListener()
  {
    public void propertyChange(PropertyChangeEvent event)
    {
      if ((event.getProperty().equals("org.eclipse.mylyn.tasks.ui.planning.end.hour")) || 
        (event.getProperty().equals("org.eclipse.mylyn.tasks.ui.planning.week.start.day"))) {
        TasksUiPlugin.this.updateTaskActivityManager();
      }
      if ((event.getProperty().equals("org.eclipse.mylyn.tasks.ui.repositories.synch.schedule")) || 
        (event.getProperty().equals("org.eclipse.mylyn.tasks.ui.repositories.synch.schedule.miliseconds"))) {
        TasksUiPlugin.this.updateSynchronizationScheduler(false);
      }
      if (event.getProperty().equals("org.eclipse.mylyn.tasks.ui.messages.enabled")) {
        if (getPreferenceStore().getBoolean("org.eclipse.mylyn.tasks.ui.messages.enabled")) {
          serviceMessageManager.start();
        } else {
          serviceMessageManager.stop();
        }
      }
    }
  };
  private AbstractTaskActivityMonitor taskActivityMonitor;
  private ServiceReference proxyServiceReference;
  private IProxyChangeListener proxyChangeListener;
  private static TaskListExternalizationParticipant taskListExternalizationParticipant;
  private final Set<IRepositoryModelListener> listeners = new HashSet();
  private File activationHistoryFile;
  private static TaskList taskList;
  private static RepositoryModel repositoryModel;
  private static TasksUiFactory uiFactory;
  @Deprecated
  public static String LABEL_VIEW_REPOSITORIES = Messages.TasksUiPlugin_Task_Repositories;
  private final AtomicInteger initializationCount = new AtomicInteger();
  private SynchronizationManger synchronizationManger;
  
  private class TasksUiInitializationJob
    extends UIJob
  {
    public TasksUiInitializationJob()
    {
      super();
      setSystem(true);
    }
    
    public IStatus runInUIThread(IProgressMonitor monitor)
    {
      monitor.beginTask("Initializing Task List", 5);
      try
      {
        TasksUiExtensionReader.initWorkbenchUiExtensions();
        
        TasksUiPlugin.externalizationManager.getLoadStatus();
        
        List<String> commandLineArgs = Arrays.asList(Platform.getCommandLineArgs());
        activateTask = !commandLineArgs.contains("-no-activate-task");
        if (activateTask) {
          try
          {
            Field field = Workspace.class.getDeclaredField("crashed");
            field.setAccessible(true);
            value = field.get(ResourcesPlugin.getWorkspace());
            if ((value instanceof Boolean)) {
              activateTask = !((Boolean)value).booleanValue();
            }
          }
          catch (Throwable t)
          {
            t.printStackTrace();
          }
        }
        for (Object value = TasksUiPlugin.taskList.getAllTasks().iterator(); ((Iterator)value).hasNext();)
        {
          AbstractTask task = (AbstractTask)((Iterator)value).next();
          if (task.isActive())
          {
            task.setActive(false);
            if (activateTask)
            {
              TasksUiPlugin.taskActivityManager.activateTask(task);
              activateTask = false;
            }
          }
        }
      }
      catch (Throwable t)
      {
        StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", 
          "Could not initialize task activity", t));
      }
      monitor.worked(1);
      
      initializeNotificationsAndSynchronization();
      
      TasksUiPlugin.this.addSystemTaskBarActions();
      try
      {
        getPreferenceStore().addPropertyChangeListener(PROPERTY_LISTENER);
        
        TaskRepositoriesView repositoriesView = TaskRepositoriesView.getFromActivePerspective();
        if (repositoriesView != null) {
          repositoriesView.getViewer().refresh();
        }
      }
      catch (Throwable t)
      {
        StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", 
          "Could not finish Tasks UI initialization", t));
      }
      finally
      {
        monitor.done();
      }
      return new Status(0, "org.eclipse.mylyn.tasks.ui", 0, "", null);
    }
  }
  
  public TasksUiPlugin()
  {
    INSTANCE = this;
  }
  
  private void addSystemTaskBarActions()
  {
    MenuManager taskBarMenuManager = TaskBarManager.getTaskBarMenuManager();
    if (taskBarMenuManager != null)
    {
      NewTaskAction newTaskAction = new NewTaskAction(Messages.TasksUiPlugin_New_Task, true);
      taskBarMenuManager.add(newTaskAction);
      
      Action activateTaskAction = new Action()
      {
        public void run()
        {
          ActivateTaskDialogAction activateTaskDialogAction = new ActivateTaskDialogAction();
          IWorkbenchWindow window = getWorkbench().getActiveWorkbenchWindow();
          if ((window == null) && (getWorkbench().getWorkbenchWindows().length > 0)) {
            window = getWorkbench().getWorkbenchWindows()[0];
          }
          activateTaskDialogAction.init(window);
          activateTaskDialogAction.run(null);
        }
      };
      activateTaskAction.setImageDescriptor(TasksUiImages.CONTEXT_ACTIVE_CENTERED);
      activateTaskAction.setText(Messages.TasksUiPlugin_Activate_Task);
      taskBarMenuManager.add(activateTaskAction);
      taskBarMenuManager.update(true);
    }
  }
  
  private void updateSynchronizationScheduler(boolean initial)
  {
    if (synchronizationScheduler == null) {
      return;
    }
    boolean enabled = getDefault()
      .getPreferenceStore()
      .getBoolean("org.eclipse.mylyn.tasks.ui.repositories.synch.schedule");
    if (enabled)
    {
      long interval = getDefault()
        .getPreferenceStore()
        .getLong("org.eclipse.mylyn.tasks.ui.repositories.synch.schedule.miliseconds");
      if (initial) {
        synchronizationScheduler.setInterval(20000L, interval);
      } else {
        synchronizationScheduler.setInterval(interval);
      }
    }
    else
    {
      synchronizationScheduler.setInterval(0L);
    }
  }
  
  public void start(BundleContext context)
    throws Exception
  {
    super.start(context);
    try
    {
      if (DEBUG_HTTPCLIENT) {
        initHttpLogging();
      }
      WebUtil.init();
      initializePreferences(getPreferenceStore());
      
      File dataDir = new File(getDataDirectory());
      dataDir.mkdirs();
      
      externalizationManager = new ExternalizationManager(getDataDirectory());
      
      repositoryManager = new TaskRepositoryManager();
      IExternalizationParticipant repositoryParticipant = new RepositoryExternalizationParticipant(
        externalizationManager, repositoryManager);
      externalizationManager.addParticipant(repositoryParticipant);
      
      taskList = new TaskList();
      repositoryModel = new RepositoryModel(taskList, repositoryManager);
      taskListExternalizer = new TaskListExternalizer(repositoryModel, repositoryManager);
      
      taskListExternalizationParticipant = new TaskListExternalizationParticipant(repositoryModel, taskList, 
        taskListExternalizer, externalizationManager, repositoryManager);
      
      externalizationManager.addParticipant(taskListExternalizationParticipant);
      taskList.addChangeListener(taskListExternalizationParticipant);
      
      taskActivityManager = new TaskActivityManager(repositoryManager, taskList);
      
      taskActivityManager.addActivationListener(taskListExternalizationParticipant);
      
      updateTaskActivityManager();
      
      proxyServiceReference = context.getServiceReference(IProxyService.class.getName());
      if (proxyServiceReference != null)
      {
        IProxyService proxyService = (IProxyService)context.getService(proxyServiceReference);
        if (proxyService != null)
        {
          proxyChangeListener = new IProxyChangeListener()
          {
            public void proxyInfoChanged(IProxyChangeEvent event)
            {
              List<TaskRepository> repositories = TasksUiPlugin.repositoryManager.getAllRepositories();
              for (TaskRepository repository : repositories) {
                if (repository.isDefaultProxyEnabled()) {
                  TasksUiPlugin.repositoryManager.notifyRepositorySettingsChanged(repository, 
                    new TaskRepositoryDelta(TaskRepositoryDelta.Type.PROYX));
                }
              }
            }
          };
          proxyService.addProxyChangeListener(proxyChangeListener);
        }
      }
      repositoryTemplateManager = new RepositoryTemplateManager();
      
      TasksUiExtensionReader.initStartupExtensions(taskListExternalizer, repositoryManager);
      
      TaskDataStore taskDataStore = new TaskDataStore(repositoryManager);
      synchronizationManger = new SynchronizationManger(repositoryModel);
      taskDataManager = new TaskDataManager(taskDataStore, repositoryManager, taskList, taskActivityManager, 
        synchronizationManger);
      
      taskJobFactory = new TaskJobFactory(taskList, taskDataManager, repositoryManager, repositoryModel);
      
      taskActivityMonitor = TasksUiExtensionReader.loadTaskActivityMonitor();
      taskActivityMonitor.start(taskActivityManager);
      
      saveParticipant = new ISaveParticipant()
      {
        public void doneSaving(ISaveContext context) {}
        
        public void prepareToSave(ISaveContext context)
          throws CoreException
        {}
        
        public void rollback(ISaveContext context) {}
        
        public void saving(ISaveContext context)
          throws CoreException
        {
          if (context.getKind() == 1) {
            TasksUiPlugin.externalizationManager.stop();
          }
        }
      };
      ResourcesPlugin.getWorkspace().addSaveParticipant(this, saveParticipant);
      
      IPath stateLocation = Platform.getStateLocation(getBundle());
      activationHistoryFile = stateLocation.append("TaskActivationHistory.xml").toFile();
      TaskActivationExternalizationParticipant taskActivationExternalizationParticipant = new TaskActivationExternalizationParticipant(
        externalizationManager, taskList, taskActivityManager.getTaskActivationHistory(), 
        activationHistoryFile);
      taskActivityManager.addActivationListener(taskActivationExternalizationParticipant);
      externalizationManager.addParticipant(taskActivationExternalizationParticipant);
      
      initializeDataSources();
      
      taskListNotificationManager = new TaskListNotificationManager();
      
      String lastMod = getPreferenceStore().getString(
        "org.eclipse.mylyn.tasks.ui.servicemessage.lastmodified");
      String etag = getPreferenceStore().getString("org.eclipse.mylyn.tasks.ui.servicemessage.etag");
      String serviceMessageUrl = getPreferenceStore().getString("org.eclipse.mylyn.tasks.ui.servicemessage.url");
      
      Long checktime = Long.valueOf(getPreferenceStore().getLong("org.eclipse.mylyn.tasks.ui.servicemessage.checktime"));
      
      serviceMessageManager = new ServiceMessageManager(serviceMessageUrl, lastMod, etag, checktime.longValue(), 
        new NotificationEnvironment()
        {
          private Set<String> installedFeatures;
          
          public Set<String> getInstalledFeatures(IProgressMonitor monitor)
          {
            if (installedFeatures == null) {
              installedFeatures = DiscoveryUi.createInstallJob().getInstalledFeatures(monitor);
            }
            return installedFeatures;
          }
        });
      if (getPreferenceStore().getBoolean("org.eclipse.mylyn.tasks.ui.messages.enabled")) {
        serviceMessageManager.start();
      }
      new TasksUiInitializationJob().schedule();
    }
    catch (Exception e)
    {
      StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", "Task list initialization failed", e));
    }
  }
  
  private void initHttpLogging()
  {
    System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
    System.setProperty("org.apache.commons.logging.simplelog.showdatetime", "true");
    System.setProperty("org.apache.commons.logging.simplelog.log.httpclient.wire", "debug");
    System.setProperty("org.apache.commons.logging.simplelog.log.httpclient.wire.header", "debug");
    System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.commons.httpclient", "debug");
    System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.commons.httpclient.HttpConnection", 
      "trace");
    System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.axis.message", "debug");
  }
  
  private void updateTaskActivityManager()
  {
    int endHour = getPreferenceStore().getInt("org.eclipse.mylyn.tasks.ui.planning.end.hour");
    
    TaskActivityUtil.setEndHour(endHour);
    
    int newWeekStartDay = getPreferenceStore().getInt("org.eclipse.mylyn.tasks.ui.planning.week.start.day");
    int oldWeekStartDay = taskActivityManager.getWeekStartDay();
    if (oldWeekStartDay != newWeekStartDay) {
      taskActivityManager.setWeekStartDay(newWeekStartDay);
    }
  }
  
  private void loadTemplateRepositories()
  {
    TaskRepository local = getLocalTaskRepository();
    repositoryManager.applyMigrators(local);
    Iterator localIterator2;
    for (Iterator localIterator1 = repositoryManager.getRepositoryConnectors().iterator(); localIterator1.hasNext(); localIterator2.hasNext())
    {
      AbstractRepositoryConnector connector = (AbstractRepositoryConnector)localIterator1.next();
      localIterator2 = repositoryTemplateManager.getTemplates(connector.getConnectorKind()).iterator(); continue;RepositoryTemplate template = (RepositoryTemplate)localIterator2.next();
      if ((addAutomatically) && (!TaskRepositoryUtil.isAddAutomaticallyDisabled(repositoryUrl))) {
        try
        {
          String repositoryUrl = TaskRepositoryManager.stripSlashes(repositoryUrl);
          TaskRepository taskRepository = repositoryManager.getRepository(connector.getConnectorKind(), 
            repositoryUrl);
          if (taskRepository == null)
          {
            taskRepository = new TaskRepository(connector.getConnectorKind(), repositoryUrl);
            taskRepository.setVersion(version);
            taskRepository.setRepositoryLabel(label);
            taskRepository.setCharacterEncoding(characterEncoding);
            if (anonymous) {
              taskRepository.setProperty(
                "org.eclipse.mylyn.tasklist.repositories.enabled", String.valueOf(false));
            }
            taskRepository.setCreatedFromTemplate(true);
            repositoryManager.addRepository(taskRepository);
            repositoryManager.applyMigrators(taskRepository);
          }
        }
        catch (Throwable t)
        {
          StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", NLS.bind(
            "Could not load repository template for repository {0}", repositoryUrl), t));
        }
      }
    }
  }
  
  public TaskRepository getLocalTaskRepository()
  {
    TaskRepository localRepository = repositoryManager.getRepository("local", 
      "local");
    if (localRepository == null)
    {
      localRepository = new TaskRepository("local", 
        "local");
      localRepository.setVersion("1");
      localRepository.setRepositoryLabel(LocalRepositoryConnector.REPOSITORY_LABEL);
      repositoryManager.addRepository(localRepository);
    }
    return localRepository;
  }
  
  /* Error */
  public void stop(BundleContext context)
    throws Exception
  {
    // Byte code:
    //   0: aload_0
    //   1: getfield 1214	org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin:formColors	Lorg/eclipse/ui/forms/FormColors;
    //   4: ifnull +15 -> 19
    //   7: aload_0
    //   8: getfield 1214	org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin:formColors	Lorg/eclipse/ui/forms/FormColors;
    //   11: invokevirtual 1394	org/eclipse/ui/forms/FormColors:dispose	()V
    //   14: aload_0
    //   15: aconst_null
    //   16: putfield 1214	org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin:formColors	Lorg/eclipse/ui/forms/FormColors;
    //   19: aload_0
    //   20: getfield 1212	org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin:taskActivityMonitor	Lorg/eclipse/mylyn/tasks/core/activity/AbstractTaskActivityMonitor;
    //   23: ifnull +10 -> 33
    //   26: aload_0
    //   27: getfield 1212	org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin:taskActivityMonitor	Lorg/eclipse/mylyn/tasks/core/activity/AbstractTaskActivityMonitor;
    //   30: invokevirtual 1385	org/eclipse/mylyn/tasks/core/activity/AbstractTaskActivityMonitor:stop	()V
    //   33: invokestatic 1262	org/eclipse/core/resources/ResourcesPlugin:getWorkspace	()Lorg/eclipse/core/resources/IWorkspace;
    //   36: ifnull +12 -> 48
    //   39: invokestatic 1262	org/eclipse/core/resources/ResourcesPlugin:getWorkspace	()Lorg/eclipse/core/resources/IWorkspace;
    //   42: aload_0
    //   43: invokeinterface 1423 2 0
    //   48: aload_0
    //   49: getfield 1215	org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin:proxyServiceReference	Lorg/osgi/framework/ServiceReference;
    //   52: ifnull +42 -> 94
    //   55: aload_1
    //   56: aload_0
    //   57: getfield 1215	org/eclipse/mylyn/internal/tasks/ui/TasksUiPlugin:p