;
    this$0.markDirty(AttributePart.access$1(this$0).getControl());
  }
}

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

import org.eclipse.swt.custom.TextChangeListener;
import org.eclipse.swt.custom.TextChangedEvent;
import org.eclipse.swt.custom.TextChangingEvent;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.events.VerifyEvent;
import org.eclipse.swt.events.VerifyListener;
import org.eclipse.swt.widgets.Button;

public class TaskEditorActionPart$SelectButtonListener
  implements ModifyListener, VerifyListener, SelectionListener, FocusListener, TextChangeListener
{
  private final Button button;
  
  public TaskEditorActionPart$SelectButtonListener(TaskEditorActionPart paramTaskEditorActionPart, Button button)
  {
    this.button = button;
  }
  
  public void modifyText(ModifyEvent e)
  {
    selected();
  }
  
  public void verifyText(VerifyEvent e)
  {
    selected();
  }
  
  public void widgetSelected(SelectionEvent e)
  {
    selected();
  }
  
  public void widgetDefaultSelected(SelectionEvent e)
  {
    selected();
  }
  
  public void focusGained(FocusEvent event)
  {
    selected();
  }
  
  public void focusLost(FocusEvent e) {}
  
  public void textChanged(TextChangedEvent event)
  {
    selected();
  }
  
  public void textSet(TextChangedEvent event)
  {
    selected();
  }
  
  public void textChanging(TextChangingEvent event) {}
  
  private void selected()
  {
    TaskEditorActionPart.access$0(this$0, button, true);
  }
}

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

import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;

class TaskEditorCommentPart$CommentGroupViewer$1
  extends Canvas
{
  TaskEditorCommentPart$CommentGroupViewer$1(TaskEditorCommentPart.CommentGroupViewer paramCommentGroupViewer, Composite $anonymous0, int $anonymous1)
  {
    super($anonymous0, $anonymous1);
  }
  
  public Point computeSize(int wHint, int hHint, boolean changed)
  {
    return new Point(wHint == -1 ? 1 : wHint, 1);
  }
}

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

import org.eclipse.jface.text.TextAttribute;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.RuleBasedScanner;
import org.eclipse.jface.text.rules.SingleLineRule;
import org.eclipse.jface.text.rules.Token;
import org.eclipse.mylyn.commons.ui.compatibility.CommonColors;

class RepositoryTextViewerConfiguration$RepositoryTextScanner
  extends RuleBasedScanner
{
  public RepositoryTextViewerConfiguration$RepositoryTextScanner(RepositoryTextViewerConfiguration.Mode mode)
  {
    IToken quoteToken = new Token(new TextAttribute(CommonColors.TEXT_QUOTED));
    IRule[] rules = new IRule[1];
    SingleLineRule quoteRule = new SingleLineRule(">", null, quoteToken, '\000', true);
    quoteRule.setColumnConstraint(0);
    rules[0] = quoteRule;
    setRules(rules);
  }
}

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

import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;

class PriorityEditor$1
  extends SelectionAdapter
{
  PriorityEditor$1(PriorityEditor paramPriorityEditor, Composite paramComposite) {}
  
  public void widgetSelected(SelectionEvent e)
  {
    if (PriorityEditor.access$0(this$0) == null) {
      PriorityEditor.access$2(this$0, PriorityEditor.access$1(this$0));
    }
    Point location = val$parent.toDisplay(PriorityEditor.access$1(this$0).getLocation());
    y += access$3this$0).getBounds().height;
    if (PriorityEditor.access$4(this$0) != null)
    {
      MenuItem[] items = PriorityEditor.access$0(this$0).getItems();
      MenuItem[] arrayOfMenuItem1;
      int j = (arrayOfMenuItem1 = items).length;
      for (int i = 0; i < j; i++)
      {
        MenuItem item = arrayOfMenuItem1[i];
        item.setSelection(PriorityEditor.access$4(this$0).equals(item.getData()));
      }
    }
    PriorityEditor.access$0(this$0).setLocation(location);
    PriorityEditor.access$0(this$0).setVisible(true);
  }
}

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

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.mylyn.tasks.core.RepositoryStatus;
import org.eclipse.mylyn.tasks.ui.editors.AbstractRenderingEngine;

final class BrowserPreviewViewer$1PreviewWikiJob
  extends Job
{
  private String htmlText;
  private IStatus jobStatus;
  private final String sourceText;
  
  public BrowserPreviewViewer$1PreviewWikiJob(BrowserPreviewViewer paramBrowserPreviewViewer, String sourceText)
  {
    super(Messages.BrowserPreviewViewer_Formatting_Wiki_Text);
    if (sourceText == null) {
      throw new IllegalArgumentException("source text must not be null");
    }
    this.sourceText = sourceText;
  }
  
  public String getHtmlText()
  {
    return htmlText;
  }
  
  public IStatus getStatus()
  {
    return jobStatus;
  }
  
  protected IStatus run(IProgressMonitor monitor)
  {
    if (BrowserPreviewViewer.access$1(this$0) == null)
    {
      jobStatus = new RepositoryStatus(BrowserPreviewViewer.access$2(this$0), 1, "org.eclipse.mylyn.tasks.ui", 
        7, 
        Messages.BrowserPreviewViewer_The_repository_does_not_support_HTML_preview);
      return Status.OK_STATUS;
    }
    jobStatus = Status.OK_STATUS;
    try
    {
      htmlText = BrowserPreviewViewer.access$1(this$0).renderAsHtml(BrowserPreviewViewer.access$2(this$0), sourceText, monitor);
    }
    catch (CoreException e)
    {
      jobStatus = e.getStatus();
    }
    return Status.OK_STATUS;
  }
}

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

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.hyperlink.IHyperlink;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.AbstractTaskHyperlinkDetector;
import org.eclipse.mylyn.tasks.ui.TaskHyperlink;

public class TaskRelationHyperlinkDetector
  extends AbstractTaskHyperlinkDetector
{
  private static Pattern HYPERLINK_PATTERN = Pattern.compile("([^\\s,]+)");
  
  public IHyperlink[] detectHyperlinks(ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks)
  {
    if (region.getLength() > 0) {
      return super.detectHyperlinks(textViewer, region, canShowMultipleHyperlinks);
    }
    if (textViewer.getDocument() == null) {
      return null;
    }
    TaskRepository taskRepository = getTaskRepository(textViewer);
    if (taskRepository != null)
    {
      String prefix = extractPrefix(textViewer, region.getOffset());
      String postfix = extractPostfix(textViewer, region.getOffset());
      String taskKey = prefix + postfix;
      if (taskKey.length() > 0)
      {
        Region hyperlinkRegion = new Region(region.getOffset() - prefix.length(), taskKey.length());
        return new IHyperlink[] { new TaskHyperlink(hyperlinkRegion, taskRepository, taskKey) };
      }
    }
    return null;
  }
  
  protected List<IHyperlink> detectHyperlinks(ITextViewer textViewer, String content, int index, int contentOffset)
  {
    List<IHyperlink> links = null;
    Matcher m;
    for (Iterator localIterator = getTaskRepositories(textViewer).iterator(); localIterator.hasNext(); m.find())
    {
      TaskRepository repository = (TaskRepository)localIterator.next();
      m = HYPERLINK_PATTERN.matcher(content);
      continue;
      if (links == null) {
        links = new ArrayList();
      }
      Region region = new Region(contentOffset + m.start(), m.end() - m.start());
      links.add(new TaskHyperlink(region, repository, m.group()));
    }
    return links;
  }
  
  private String extractPrefix(ITextViewer viewer, int offset)
  {
    int i = offset;
    IDocument document = viewer.getDocument();
    if (i > document.getLength()) {
      return "";
    }
    try
    {
      if (isSeparator(document.getChar(i))) {
        return "";
      }
      while (i > 0)
      {
        char ch = document.getChar(i - 1);
        if (isSeparator(ch)) {
          break;
        }
        i--;
      }
      return document.get(i, offset - i);
    }
    catch (BadLocationException localBadLocationException) {}
    return "";
  }
  
  private String extractPostfix(ITextViewer viewer, int offset)
  {
    int i = offset;
    IDocument document = viewer.getDocument();
    int length = document.getLength();
    if (i > length) {
      return "";
    }
    try
    {
      if (isSeparator(document.getChar(i))) {
        return "";
      }
      while (i < length - 1)
      {
        char ch = document.getChar(i + 1);
        if (isSeparator(ch)) {
          break;
        }
        i++;
      }
      return document.get(offset, i - offset + 1);
    }
    catch (BadLocationException localBadLocationException) {}
    return "";
  }
  
  private boolean isSeparator(char ch)
  {
    return (Character.isWhitespace(ch)) || (ch == ',');
  }
}

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

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.eclipse.core.runtime.Assert;
import org.eclipse.mylyn.internal.tasks.core.RepositoryModel;
import org.eclipse.mylyn.internal.tasks.core.TaskList;
import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.util.AttachmentUtil;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryPerson;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITaskAttachment;
import org.eclipse.mylyn.tasks.core.ITaskComment;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMetaData;
import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.mylyn.tasks.core.data.TaskRelation;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.osgi.util.NLS;

public class TaskEditorOutlineNode
{
  public static final String LABEL_COMMENTS = Messages.TaskEditorOutlineNode_Comments;
  public static final String LABEL_DESCRIPTION = Messages.TaskEditorOutlineNode_Description;
  public static final String LABEL_NEW_COMMENT = Messages.TaskEditorOutlineNode_New_Comment;
  public static final String LABEL_ATTACHMENTS = Messages.TaskEditorOutlineNode_Attachments;
  public static final String LABEL_ATTRIBUTES = Messages.TaskEditorOutlineNode_Attributes;
  public static final String LABEL_RELATED_TASKS = Messages.TaskEditorOutlineNode_Related_Tasks;
  private List<TaskEditorOutlineNode> children;
  private final String label;
  private TaskEditorOutlineNode parent;
  private final TaskAttribute taskAttribute;
  private ITaskComment taskComment;
  private ITaskAttachment taskAttachment;
  private TaskRelation taskRelation;
  private TaskRepository taskRepository;
  
  private static TaskEditorOutlineNode createNode(TaskData taskData, String attributeId, String label)
  {
    TaskAttribute taskAttribute = taskData.getRoot().getMappedAttribute(attributeId);
    if (taskAttribute != null)
    {
      if (label == null) {
        label = taskAttribute.getValue();
      }
      return new TaskEditorOutlineNode(label, taskAttribute);
    }
    return null;
  }
  
  private static TaskEditorOutlineNode createNode(TaskAttribute taskAttribute)
  {
    String type = taskAttribute.getMetaData().getType();
    if ("comment".equals(type))
    {
      ITaskComment taskComment = TasksUiPlugin.getRepositoryModel().createTaskComment(taskAttribute);
      if (taskComment != null)
      {
        taskAttribute.getTaskData().getAttributeMapper().updateTaskComment(taskComment, taskAttribute);
        StringBuilder sb = new StringBuilder();
        sb.append(taskComment.getNumber());
        sb.append(": ");
        IRepositoryPerson author = taskComment.getAuthor();
        if (author != null) {
          sb.append(author.toString());
        }
        Date creationDate = taskComment.getCreationDate();
        if (creationDate != null)
        {
          sb.append(" (");
          sb.append(EditorUtil.formatDateTime(creationDate));
          sb.append(")");
        }
        TaskEditorOutlineNode node = new TaskEditorOutlineNode(sb.toString(), taskAttribute);
        node.setTaskComment(taskComment);
        return node;
      }
    }
    else if ("attachment".equals(type))
    {
      ITaskAttachment taskAttachment = TasksUiPlugin.getRepositoryModel().createTaskAttachment(taskAttribute);
      if (taskAttachment != null)
      {
        taskAttribute.getTaskData().getAttributeMapper().updateTaskAttachment(taskAttachment, taskAttribute);
        StringBuilder sb = new StringBuilder();
        sb.append(taskAttribute.getTaskData().getAttributeMapper().getValueLabel(taskAttribute));
        sb.append(": ");
        if (AttachmentUtil.isContext(taskAttachment)) {
          sb.append(Messages.AttachmentTableLabelProvider_Task_Context);
        } else if (taskAttachment.isPatch()) {
          sb.append(Messages.AttachmentTableLabelProvider_Patch);
        } else {
          sb.append(taskAttachment.getFileName());
        }
        TaskEditorOutlineNode node = new TaskEditorOutlineNode(sb.toString(), taskAttribute);
        node.setTaskAttachment(taskAttachment);
        return node;
      }
    }
    else
    {
      String label = taskAttribute.getTaskData().getAttributeMapper().getLabel(taskAttribute);
      if (label.endsWith(":")) {
        label = label.substring(0, label.length() - 1);
      }
      return new TaskEditorOutlineNode(label, taskAttribute);
    }
    return null;
  }
  
  public static TaskEditorOutlineNode parse(TaskData taskData, boolean includeAttributes)
  {
    TaskEditorOutlineNode rootNode = createNode(taskData, "task.common.summary", null);
    if (rootNode == null) {
      rootNode = new TaskEditorOutlineNode(Messages.TaskEditorOutlineNode_Task_ + taskData.getTaskId());
    }
    Collection<TaskRelation> relations;
    if (includeAttributes)
    {
      TaskList taskList = TasksUiPlugin.getTaskList();
      TaskEditorOutlineNode relatedTasksNode = new TaskEditorOutlineNode(LABEL_RELATED_TASKS);
      rootNode.addChild(relatedTasksNode);
      AbstractRepositoryConnector connector = TasksUi.getRepositoryConnector(taskData.getConnectorKind());
      relations = connector.getTaskRelations(taskData);
      TaskRepositoryManager manager = TasksUiPlugin.getRepositoryManager();
      TaskRepository taskRepository = manager.getRepository(taskData.getConnectorKind(), 
        taskData.getRepositoryUrl());
      String label;
      if (relations != null) {
        for (TaskRelation taskRelation : relations)
        {
          ITask task = taskList.getTask(taskData.getRepositoryUrl(), taskRelation.getTaskId());
          String label;
          if (task != null)
          {
            String label;
            if (task.getTaskKey() != null) {
              label = NLS.bind(Messages.TaskEditorOutlineNode_TaskRelation_Label, 
                new Object[] { task.getTaskKey(), task.getSummary() });
            } else {
              label = task.getSummary();
            }
          }
          else
          {
            label = NLS.bind(Messages.TaskEditorOutlineNode_TaskRelation_Label, 
              new Object[] { taskRelation.getTaskId(), Messages.TaskEditorOutlineNode_unknown_Label });
          }
          TaskEditorOutlineNode childNode = new TaskEditorOutlineNode(label);
          
          childNode.setTaskRelation(taskRelation);
          childNode.setTaskRepository(taskRepository);
          relatedTasksNode.addChild(childNode);
        }
      }
      TaskEditorOutlineNode attributesNode = new TaskEditorOutlineNode(LABEL_ATTRIBUTES);
      rootNode.addChild(attributesNode);
      Object attributes = taskData.getRoot().getAttributes();
      for (TaskAttribute attribute : ((Map)attributes).values()) {
        if ("task.common.kind.default".equals(attribute.getMetaData().getKind()))
        {
          TaskEditorOutlineNode node = createNode(attribute);
          if (node != null) {
            attributesNode.addChild(node);
          }
        }
      }
    }
    addNode(rootNode, taskData, "task.common.description", LABEL_DESCRIPTION);
    List<TaskAttribute> attachments = taskData.getAttributeMapper().getAttributesByType(taskData, 
      "attachment");
    TaskEditorOutlineNode node;
    if (attachments.size() > 0)
    {
      TaskEditorOutlineNode attachmentNode = new TaskEditorOutlineNode(LABEL_ATTACHMENTS);
      rootNode.addChild(attachmentNode);
      for (TaskAttribute attachmentAttribute : attachments)
      {
        node = createNode(attachmentAttribute);
        if (node != null) {
          attachmentNode.addChild(node);
        }
      }
    }
    List<TaskAttribute> comments = taskData.getAttributeMapper().getAttributesByType(taskData, 
      "comment");
    if (comments.size() > 0)
    {
      TaskEditorOutlineNode commentsNode = new TaskEditorOutlineNode(LABEL_COMMENTS);
      rootNode.addChild(commentsNode);
      for (TaskAttribute commentAttribute : comments)
      {
        TaskEditorOutlineNode node = createNode(commentAttribute);
        if (node != null) {
          commentsNode.addChild(node);
        }
      }
    }
    addNode(rootNode, taskData, "task.common.comment.new", LABEL_NEW_COMMENT);
    return rootNode;
  }
  
  private static TaskEditorOutlineNode addNode(TaskEditorOutlineNode parentNode, TaskData taskData, String attributeId, String label)
  {
    TaskEditorOutlineNode node = createNode(taskData, attributeId, label);
    if (node != null) {
      parentNode.addChild(node);
    }
    return node;
  }
  
  public TaskEditorOutlineNode(String label)
  {
    this(label, null);
  }
  
  public TaskEditorOutlineNode(String label, TaskAttribute taskAttribute)
  {
    this.label = label;
    this.taskAttribute = taskAttribute;
  }
  
  public void addChild(TaskEditorOutlineNode node)
  {
    Assert.isNotNull(node);
    if (children == null) {
      children = new ArrayList();
    }
    parent = this;
    children.add(node);
  }
  
  public TaskEditorOutlineNode getChild(String label)
  {
    if (children != null) {
      for (TaskEditorOutlineNode child : children) {
        if (child.getLabel().equals(label)) {
          return child;
        }
      }
    }
    return null;
  }
  
  public boolean equals(Object o)
  {
    if ((o instanceof TaskEditorOutlineNode))
    {
      TaskEditorOutlineNode node = (TaskEditorOutlineNode)o;
      return getLabel().equals(node.getLabel());
    }
    return false;
  }
  
  public TaskEditorOutlineNode[] getChildren()
  {
    return children == null ? 
      new TaskEditorOutlineNode[0] : 
      (TaskEditorOutlineNode[])children.toArray(new TaskEditorOutlineNode[children.size()]);
  }
  
  public ITaskComment getTaskComment()
  {
    return taskComment;
  }
  
  public void setTaskComment(ITaskComment taskComment)
  {
    this.taskComment = taskComment;
  }
  
  public TaskAttribute getData()
  {
    return taskAttribute;
  }
  
  public String getLabel()
  {
    return label;
  }
  
  public TaskEditorOutlineNode getParent()
  {
    return parent;
  }
  
  public int hashCode()
  {
    return getLabel().hashCode();
  }
  
  public String toString()
  {
    return getLabel();
  }
  
  public ITaskAttachment getTaskAttachment()
  {
    return taskAttachment;
  }
  
  public void setTaskAttachment(ITaskAttachment taskAttachment)
  {
    this.taskAttachment = taskAttachment;
  }
  
  public TaskRelation getTaskRelation()
  {
    return taskRelation;
  }
  
  public void setTaskRelation(TaskRelation taskRelation)
  {
    this.taskRelation = taskRelation;
  }
  
  public TaskRepository getTaskRepository()
  {
    return taskRepository;
  }
  
  public void setTaskRepository(TaskRepository taskRepository)
  {
    this.taskRepository = taskRepository;
  }
}

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

import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;

class TaskEditorCommentPart$CommentViewer$3
  extends MouseAdapter
{
  TaskEditorCommentPart$CommentViewer$3(TaskEditorCommentPart.CommentViewer paramCommentViewer) {}
  
  public void mouseDown(MouseEvent e)
  {
    TaskEditorCommentPart.CommentViewer.access$2(this$1).getTaskEditorPage().selectionChanged(TaskEditorCommentPart.CommentViewer.access$1(this$1));
  }
}

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

import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
import org.eclipse.ui.forms.events.ExpansionAdapter;
import org.eclipse.ui.forms.events.ExpansionEvent;
import org.eclipse.ui.forms.widgets.FormToolkit;

class TaskEditorAttachmentPart$5
  extends ExpansionAdapter
{
  TaskEditorAttachmentPart$5(TaskEditorAttachmentPart paramTaskEditorAttachmentPart, FormToolkit paramFormToolkit) {}
  
  public void expansionStateChanged(ExpansionEvent event)
  {
    if (TaskEditorAttachmentPart.access$0(this$0) == null)
    {
      TaskEditorAttachmentPart.access$2(this$0, val$toolkit, TaskEditorAttachmentPart.access$1(this$0));
      this$0.getTaskEditorPage().reflow();
    }
  }
}

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

import org.eclipse.swt.custom.StackLayout;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

class RichTextEditor$3
  extends StackLayout
{
  RichTextEditor$3(RichTextEditor paramRichTextEditor) {}
  
  protected Point computeSize(Composite composite, int hint, int hint2, boolean flushCache)
  {
    return topControl.computeSize(hint, hint2, flushCache);
  }
}

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

import java.util.Set;
import org.eclipse.mylyn.internal.tasks.core.ITaskListChangeListener;
import org.eclipse.mylyn.internal.tasks.core.TaskContainerDelta;

public class TaskListChangeAdapter
  implements ITaskListChangeListener
{
  public void containersChanged(Set<TaskContainerDelta> containers) {}
}

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

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

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

import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.WorkbenchPlugin;

class EditorBusyIndicator$Animator
  implements Runnable
{
  int imageDataIndex = 0;
  private final Image[] images;
  private boolean stopped;
  
  public EditorBusyIndicator$Animator(EditorBusyIndicator paramEditorBusyIndicator, Image[] images)
  {
    this.images = images;
  }
  
  public void run()
  {
    if (stopped) {
      return;
    }
    try
    {
      Image image = images[imageDataIndex];
      imageDataIndex = ((imageDataIndex + 1) % images.length);
      if (EditorBusyIndicator.access$0(this$0, image)) {
        PlatformUI.getWorkbench().getDisplay().timerExec(90, this);
      }
    }
    catch (Exception e)
    {
      WorkbenchPlugin.log(e);
    }
  }
  
  public void stop()
  {
    stopped = true;
  }
}

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

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.widgets.Display;

class BrowserPreviewViewer$2
  extends JobChangeAdapter
{
  BrowserPreviewViewer$2(BrowserPreviewViewer paramBrowserPreviewViewer, Browser paramBrowser, BrowserPreviewViewer.1PreviewWikiJob param1PreviewWikiJob) {}
  
  public void done(IJobChangeEvent event)
  {
    if (!val$browser.isDisposed()) {
      if (val$job.getStatus().isOK()) {
        val$browser.getDisplay().asyncExec(new Runnable()
        {
          public void run()
          {
            BrowserPreviewViewer.access$3(this$0, val$browser, val$job.getHtmlText());
          }
        });
      } else {
        val$browser.getDisplay().asyncExec(new Runnable()
        {
          public void run()
          {
            TasksUiInternal.displayStatus(Messages.BrowserPreviewViewer_Error, val$job.getStatus());
          }
        });
      }
    }
    super.done(event);
  }
}

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

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

class QuickOutlineDialog$5
  implements ModifyListener
{
  QuickOutlineDialog$5(QuickOutlineDialog paramQuickOutlineDialog) {}
  
  public void modifyText(ModifyEvent e)
  {
    String text = ((Text)widget).getText();
    int length = text.length();
    if (length > 0)
    {
      if (text.charAt(length - 1) != '*') {
        text = text + '*';
      }
      if (text.charAt(0) != '*') {
        text = '*' + text;
      }
    }
    QuickOutlineDialog.access$3(this$0, text, true);
  }
}

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

import org.eclipse.ui.dialogs.PatternFilter;

public final class QuickOutlineDialog$Filter
  extends PatternFilter
{
  public QuickOutlineDialog$Filter(QuickOutlineDialog paramQuickOutlineDialog) {}
  
  protected boolean wordMatches(String text)
  {
    return super.wordMatches(text);
  }
}

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

import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineNode;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineNodeLabelProvider;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMetaData;
import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.swt.graphics.Image;

public class QuickOutlineLabelProvider
  extends TaskEditorOutlineNodeLabelProvider
{
  public String getText(Object element)
  {
    String result = "";
    if ((element instanceof TaskData))
    {
      TaskData node = (TaskData)element;
      result = node.getTaskId();
    }
    else if ((element instanceof TaskAttribute))
    {
      TaskAttribute node = (TaskAttribute)element;
      TaskAttributeMetaData meta = node.getMetaData();
      if (meta != null)
      {
        String lable = meta.getLabel();
        if (lable != null) {
          result = lable + " (" + node.getId() + ")";
        } else if ("attachment".equals(meta.getType())) {
          result = "Attachment: " + node.getValue();
        } else if ("comment".equals(meta.getType())) {
          result = "Comment: " + node.getValue();
        } else {
          result = "<" + node.getId() + ">";
        }
      }
    }
    else if ((element instanceof TaskEditorOutlineNode))
    {
      result = super.getText(element);
    }
    else if ((element instanceof String))
    {
      result = (String)element;
    }
    return result;
  }
  
  public Image getImage(Object element)
  {
    if ((element instanceof TaskEditorOutlineNode)) {
      return super.getImage(element);
    }
    return null;
  }
}

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

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.handlers.HandlerUtil;

public class ShowQuickOutlineHandler
  extends AbstractHandler
{
  public Object execute(ExecutionEvent event)
    throws ExecutionException
  {
    IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
    QuickOutlineDialog dialog = new QuickOutlineDialog(window);
    dialog.open();
    dialog.setFocus();
    return null;
  }
}

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

import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.widgets.TreeItem;

class QuickOutlineDialog$OpenListener
  implements IOpenListener, IDoubleClickListener, MouseListener
{
  private final Viewer viewer;
  
  public QuickOutlineDialog$OpenListener(QuickOutlineDialog paramQuickOutlineDialog, Viewer viewer)
  {
    this.viewer = viewer;
  }
  
  public void mouseDoubleClick(MouseEvent e)
  {
    setSelection(e);
  }
  
  public void mouseDown(MouseEvent e)
  {
    setSelection(e);
  }
  
  public void mouseUp(MouseEvent e) {}
  
  public void doubleClick(DoubleClickEvent event)
  {
    open(null);
  }
  
  public void open(OpenEvent event)
  {
    AbstractTaskEditorPage taskEditorPage = this$0.getTaskEditorPage();
    if (taskEditorPage == null) {
      return;
    }
    StructuredSelection selection = (StructuredSelection)viewer.getSelection();
    Object select = selection.getFirstElement();
    taskEditorPage.selectReveal(select);
  }
  
  private void setSelection(MouseEvent event)
  {
    try
    {
      Object selection = ((org.eclipse.swt.widgets.Tree)event.getSource()).getSelection()[0].getData();
      viewer.setSelection(new StructuredSelection(selection));
      open(null);
    }
    catch (Exception localException) {}
  }
}

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

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.PopupDialog;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlExtension;
import org.eclipse.jface.text.IInformationControlExtension2;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ILabelDecorator;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.commons.workbench.DecoratingPatternStyledCellLabelProvider;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineContentProvider;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorOutlineNode;
import org.eclipse.mylyn.tasks.core.data.TaskRelation;
import org.eclipse.mylyn.tasks.ui.editors.AbstractTaskEditorPage;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.FontMetrics;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
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.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.dialogs.PatternFilter;
import org.eclipse.ui.forms.editor.IFormPage;

public class QuickOutlineDialog
  extends PopupDialog
  implements IInformationControl, IInformationControlExtension, IInformationControlExtension2, DisposeListener
{
  public static final String ID_VIEWER = "org.eclipse.mylyn.internal.tasks.ui.taskdata.quick";
  private TreeViewer viewer;
  private Text filterText;
  private Filter namePatternFilter;
  private OpenListener openListener;
  private final IWorkbenchWindow window;
  
  public final class Filter
    extends PatternFilter
  {
    public Filter() {}
    
    protected boolean wordMatches(String text)
    {
      return super.wordMatches(text);
    }
  }
  
  public final class TaskEditorOutlineLabelDecorator
    implements ILabelDecorator
  {
    public TaskEditorOutlineLabelDecorator() {}
    
    public String decorateText(String text, Object element)
    {
      if ((element instanceof TaskEditorOutlineNode))
      {
        TaskEditorOutlineNode node = (TaskEditorOutlineNode)element;
        if (node.getTaskRelation() != null) {
          return NLS.bind(Messages.QuickOutlineDialog_Node_Label_Decoration, text, node.getTaskRelation()
            .toString());
        }
      }
      return null;
    }
    
    public void addListener(ILabelProviderListener listener) {}
    
    public void dispose() {}
    
    public boolean isLabelProperty(Object element, String property)
    {
      return false;
    }
    
    public void removeListener(ILabelProviderListener listener) {}
    
    public Image decorateImage(Image image, Object element)
    {
      return null;
    }
  }
  
  private class OpenListener
    implements IOpenListener, IDoubleClickListener, MouseListener
  {
    private final Viewer viewer;
    
    public OpenListener(Viewer viewer)
    {
      this.viewer = viewer;
    }
    
    public void mouseDoubleClick(MouseEvent e)
    {
      setSelection(e);
    }
    
    public void mouseDown(MouseEvent e)
    {
      setSelection(e);
    }
    
    public void mouseUp(MouseEvent e) {}
    
    public void doubleClick(DoubleClickEvent event)
    {
      open(null);
    }
    
    public void open(OpenEvent event)
    {
      AbstractTaskEditorPage taskEditorPage = getTaskEditorPage();
      if (taskEditorPage == null) {
        return;
      }
      StructuredSelection selection = (StructuredSelection)viewer.getSelection();
      Object select = selection.getFirstElement();
      taskEditorPage.selectReveal(select);
    }
    
    private void setSelection(MouseEvent event)
    {
      try
      {
        Object selection = ((Tree)event.getSource()).getSelection()[0].getData();
        viewer.setSelection(new StructuredSelection(selection));
        open(null);
      }
      catch (Exception localException) {}
    }
  }
  
  public QuickOutlineDialog(IWorkbenchWindow window)
  {
    super(window.getShell(), 16, true, true, true, true, true, null, null);
    this.window = window;
    setInfoText(Messages.QuickOutlineDialog_Press_Esc_Info_Text);
    create();
  }
  
  public boolean close()
  {
    retu