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

tructuredSelection;
import org.eclipse.mylyn.internal.tasks.ui.actions.OpenWithBrowserAction;

class AbstractTaskEditorPage$19
  extends AbstractTaskEditorPage.MenuCreator
{
  AbstractTaskEditorPage$19(AbstractTaskEditorPage paramAbstractTaskEditorPage, Action paramAction)
  {
    super(paramAbstractTaskEditorPage);
  }
  
  protected void initialize(MenuManager menuManager)
  {
    OpenWithBrowserAction openWithBrowserAction = new OpenWithBrowserAction();
    openWithBrowserAction.selectionChanged(new StructuredSelection(AbstractTaskEditorPage.access$6(this$0)));
    menuManager.add(openWithBrowserAction);
    menuManager.add(new Separator());
    menuManager.add(val$historyAction);
  }
}

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

class AttributeEditorFactory$2
  extends LayoutHint
{
  AttributeEditorFactory$2(AttributeEditorFactory paramAttributeEditorFactory, LayoutHint.RowSpan $anonymous0, LayoutHint.ColumnSpan $anonymous1)
  {
    super($anonymous0, $anonymous1);
  }
  
  public int getPriority()
  {
    return 11;
  }
}

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

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.mylyn.tasks.core.TaskRepository;

public abstract class AbstractRenderingEngine
{
  public abstract String renderAsHtml(TaskRepository paramTaskRepository, String paramString, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
}

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

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

class TaskEditor$2
  extends FocusAdapter
{
  TaskEditor$2(TaskEditor paramTaskEditor) {}
  
  public void focusLost(FocusEvent e)
  {
    TaskEditor.access$2(this$0).setSelection(0);
  }
}

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

import org.eclipse.jface.action.Action;
import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.commons.workbench.forms.CommonFormUtil;
import org.eclipse.mylyn.internal.tasks.ui.editors.Messages;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.forms.widgets.Section;

class AbstractTaskEditorPart$MaximizePartAction
  extends Action
{
  private static final String COMMAND_ID = "org.eclipse.mylyn.tasks.ui.command.maximizePart";
  private static final int SECTION_HEADER_HEIGHT = 50;
  private int originalHeight = -2;
  
  public AbstractTaskEditorPart$MaximizePartAction(AbstractTaskEditorPart paramAbstractTaskEditorPart)
  {
    super(Messages.TaskEditorRichTextPart_Maximize, 2);
    setImageDescriptor(CommonImages.PART_MAXIMIZE);
    setToolTipText(Messages.TaskEditorRichTextPart_Maximize);
    setActionDefinitionId("org.eclipse.mylyn.tasks.ui.command.maximizePart");
    setChecked(false);
  }
  
  public void run()
  {
    if (((this$0.getControl() instanceof Section)) && (!((Section)this$0.getControl()).isExpanded())) {
      CommonFormUtil.setExpanded((Section)this$0.getControl(), true);
    }
    Control control = this$0.getLayoutControl();
    if ((control == null) || (!(control.getLayoutData() instanceof GridData))) {
      return;
    }
    GridData gd = (GridData)control.getLayoutData();
    if (originalHeight == -2) {
      originalHeight = heightHint;
    }
    int heightHint;
    int heightHint;
    if (isChecked()) {
      heightHint = this$0.getManagedForm().getForm().getClientArea().height - 50;
    } else {
      heightHint = originalHeight;
    }
    if (heightHint == heightHint) {
      return;
    }
    heightHint = heightHint;
    minimumHeight = heightHint;
    if (widthHint == -1) {
      widthHint = 300;
    }
    this$0.getTaskEditorPage().reflow();
    CommonFormUtil.ensureVisible(control);
  }
}

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

import org.eclipse.mylyn.tasks.core.data.TaskDataModelEvent;
import org.eclipse.mylyn.tasks.core.data.TaskDataModelListener;
import org.eclipse.ui.forms.IManagedForm;

class AbstractTaskEditorPage$25
  extends TaskDataModelListener
{
  AbstractTaskEditorPage$25(AbstractTaskEditorPage paramAbstractTaskEditorPage) {}
  
  public void attributeChanged(TaskDataModelEvent event)
  {
    IManagedForm form = this$0.getManagedForm();
    if (form != null) {
      form.dirtyStateChanged();
    }
  }
}

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

import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.commons.ui.SelectionProviderAdapter;

class TaskEditor$9
  extends SelectionProviderAdapter
{
  TaskEditor$9(TaskEditor paramTaskEditor) {}
  
  public ISelection getSelection()
  {
    return new StructuredSelection(TaskEditor.access$7(this$0));
  }
}

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

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.internal.tasks.core.TaskList;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;
import org.eclipse.ui.services.IDisposable;

class AbstractTaskEditorPage$NotInTaskListListener
  extends HyperlinkAdapter
  implements ITaskListChangeListener, IDisposable
{
  public AbstractTaskEditorPage$NotInTaskListListener(AbstractTaskEditorPage paramAbstractTaskEditorPage)
  {
    TasksUiPlugin.getTaskList().addChangeListener(this);
  }
  
  public void linkActivated(HyperlinkEvent e)
  {
    TasksUiPlugin.getTaskList().addTaskIfAbsent(AbstractTaskEditorPage.access$6(this$0));
    this$0.getTaskEditor().setMessage(null, 0);
  }
  
  public void containersChanged(Set<TaskContainerDelta> containers)
  {
    for (TaskContainerDelta taskContainerDelta : containers) {
      if ((AbstractTaskEditorPage.access$6(this$0).equals(taskContainerDelta.getElement())) && 
        (taskContainerDelta.getKind().equals(TaskContainerDelta.Kind.ADDED))) {
        PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable()
        {
          public void run()
          {
            this$0.getTaskEditor().setMessage(null, 0);
          }
        });
      }
    }
  }
  
  public void dispose()
  {
    TasksUiPlugin.getTaskList().removeChangeListener(this);
  }
}

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

import org.eclipse.jface.resource.CompositeImageDescriptor;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;

class TaskEditor$10
  extends CompositeImageDescriptor
{
  TaskEditor$10(TaskEditor paramTaskEditor, Image paramImage, Point paramPoint, int paramInt1, Rectangle paramRectangle, int paramInt2) {}
  
  protected void drawCompositeImage(int width, int height)
  {
    if (val$image != null) {
      drawImage(val$image.getImageData(), val$size.x + val$padding, (height - val$image.getBounds().height) / 2);
    }
  }
  
  protected Point getSize()
  {
    return new Point(val$size.x + val$padding + val$imageBounds.width, val$height);
  }
}

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

import org.eclipse.jface.fieldassist.ControlDecoration;
import org.eclipse.mylyn.tasks.core.data.TaskDataModel;
import org.eclipse.mylyn.tasks.core.data.TaskDataModelListener;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;

class AttributeEditorToolkit$3
  implements DisposeListener
{
  AttributeEditorToolkit$3(ControlDecoration paramControlDecoration, AbstractAttributeEditor paramAbstractAttributeEditor, TaskDataModelListener paramTaskDataModelListener) {}
  
  public void widgetDisposed(DisposeEvent e)
  {
    val$decoration.dispose();
    val$attributeEditor.getModel().removeModelListener(val$validationListener);
  }
}

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

public enum LayoutHint$RowSpan
{
  MULTIPLE,  SINGLE;
}

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

import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorAttachmentPart;

class AbstractTaskEditorPage$7
  extends TaskEditorPartDescriptor
{
  AbstractTaskEditorPage$7(AbstractTaskEditorPage paramAbstractTaskEditorPage, String $anonymous0)
  {
    super($anonymous0);
  }
  
  public AbstractTaskEditorPart createPart()
  {
    return new TaskEditorAttachmentPart();
  }
}

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

import org.eclipse.mylyn.internal.tasks.ui.editors.Messages;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITask.SynchronizationState;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;

class AbstractTaskEditorPage$1$1
  implements Runnable
{
  AbstractTaskEditorPage$1$1(AbstractTaskEditorPage.1 param1, ITask paramITask) {}
  
  public void run()
  {
    if ((AbstractTaskEditorPage.access$1(AbstractTaskEditorPage.1.access$0(this$1))) || (AbstractTaskEditorPage.access$2(AbstractTaskEditorPage.1.access$0(this$1)))) {
      return;
    }
    if ((!AbstractTaskEditorPage.1.access$0(this$1).isDirty()) && (val$task.getSynchronizationState() == ITask.SynchronizationState.SYNCHRONIZED))
    {
      AbstractTaskEditorPage.1.access$0(this$1).refresh();
    }
    else
    {
      AbstractTaskEditorPage.1.access$0(this$1).getTaskEditor().setMessage(Messages.AbstractTaskEditorPage_Task_has_incoming_changes, 
        2, new HyperlinkAdapter()
        {
          public void linkActivated(HyperlinkEvent e)
          {
            AbstractTaskEditorPage.1.access$0(this$1).refresh();
          }
        });
      AbstractTaskEditorPage.access$3(AbstractTaskEditorPage.1.access$0(this$1), false);
    }
  }
}

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

import org.eclipse.mylyn.tasks.core.data.TaskDataModel;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;

class AbstractAttributeEditor$2
  implements DisposeListener
{
  AbstractAttributeEditor$2(AbstractAttributeEditor paramAbstractAttributeEditor) {}
  
  public void widgetDisposed(DisposeEvent e)
  {
    this$0.getModel().removeModelListener(AbstractAttributeEditor.access$1(this$0));
  }
}

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

import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.IPluginContribution;
import org.eclipse.ui.forms.editor.IFormPage;

public abstract class AbstractTaskEditorPageFactory
  implements IPluginContribution
{
  public static final int PRIORITY_ADDITIONS = 100;
  public static final int PRIORITY_CONTEXT = 20;
  public static final int PRIORITY_PLANNING = 10;
  public static final int PRIORITY_TASK = 30;
  private String id;
  private String pluginId;
  
  public abstract boolean canCreatePageFor(TaskEditorInput paramTaskEditorInput);
  
  public abstract IFormPage createPage(TaskEditor paramTaskEditor);
  
  public String[] getConflictingIds(TaskEditorInput input)
  {
    return null;
  }
  
  public String getId()
  {
    return id;
  }
  
  public abstract Image getPageImage();
  
  public abstract String getPageText();
  
  public int getPriority()
  {
    return 100;
  }
  
  public void setId(String id)
  {
    this.id = id;
  }
  
  public final String getLocalId()
  {
    return getId();
  }
  
  public final String getPluginId()
  {
    return pluginId;
  }
  
  public final void setPluginId(String pluginId)
  {
    this.pluginId = pluginId;
  }
}

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

import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorPeoplePart;

class AbstractTaskEditorPage$13
  extends TaskEditorPartDescriptor
{
  AbstractTaskEditorPage$13(AbstractTaskEditorPage paramAbstractTaskEditorPage, String $anonymous0)
  {
    super($anonymous0);
  }
  
  public AbstractTaskEditorPart createPart()
  {
    return new TaskEditorPeoplePart();
  }
}

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

import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;

class TaskEditor$3
  extends ControlAdapter
{
  TaskEditor$3(TaskEditor paramTaskEditor) {}
  
  public void controlResized(ControlEvent e)
  {
    TaskEditor.access$3(this$0);
  }
}

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

import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;

class AbstractTaskEditorPage$1$1$1
  extends HyperlinkAdapter
{
  AbstractTaskEditorPage$1$1$1(AbstractTaskEditorPage.1.1 param1) {}
  
  public void linkActivated(HyperlinkEvent e)
  {
    AbstractTaskEditorPage.1.access$0(AbstractTaskEditorPage.1.1.access$0(this$2)).refresh();
  }
}

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

import org.eclipse.mylyn.internal.tasks.ui.actions.SynchronizeEditorAction;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;

class AbstractTaskEditorPage$26
  extends HyperlinkAdapter
{
  AbstractTaskEditorPage$26(AbstractTaskEditorPage paramAbstractTaskEditorPage) {}
  
  public void linkActivated(HyperlinkEvent e)
  {
    if (AbstractTaskEditorPage.access$10(this$0) != null) {
      AbstractTaskEditorPage.access$10(this$0).run();
    }
  }
}

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

class AbstractTaskEditorPage$NotInTaskListListener$1
  implements Runnable
{
  AbstractTaskEditorPage$NotInTaskListListener$1(AbstractTaskEditorPage.NotInTaskListListener paramNotInTaskListListener) {}
  
  public void run()
  {
    AbstractTaskEditorPage.NotInTaskListListener.access$0(this$1).getTaskEditor().setMessage(null, 0);
  }
}

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

import org.eclipse.core.runtime.IStatus;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;

class TaskEditor$11
  extends HyperlinkAdapter
{
  TaskEditor$11(TaskEditor paramTaskEditor, String paramString, IStatus paramIStatus) {}
  
  public void linkActivated(HyperlinkEvent event)
  {
    TasksUiInternal.displayStatus(val$title, val$status);
  }
}

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

import org.eclipse.mylyn.internal.tasks.core.data.ITaskDataManagerListener;
import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManagerEvent;
import org.eclipse.mylyn.internal.tasks.ui.editors.Messages;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITask.SynchronizationState;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;

class AbstractTaskEditorPage$1
  implements ITaskDataManagerListener
{
  AbstractTaskEditorPage$1(AbstractTaskEditorPage paramAbstractTaskEditorPage) {}
  
  public void taskDataUpdated(TaskDataManagerEvent event)
  {
    ITask task = event.getTask();
    if ((task.equals(this$0.getTask())) && (event.getTaskDataUpdated())) {
      refresh(task);
    }
  }
  
  private void refresh(final ITask task)
  {
    PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable()
    {
      public void run()
      {
        if ((AbstractTaskEditorPage.access$1(this$0)) || (AbstractTaskEditorPage.access$2(this$0))) {
          return;
        }
        if ((!this$0.isDirty()) && (task.getSynchronizationState() == ITask.SynchronizationState.SYNCHRONIZED))
        {
          this$0.refresh();
        }
        else
        {
          this$0.getTaskEditor().setMessage(Messages.AbstractTaskEditorPage_Task_has_incoming_changes, 
            2, new HyperlinkAdapter()
            {
              public void linkActivated(HyperlinkEvent e)
              {
                this$0.refresh();
              }
            });
          AbstractTaskEditorPage.access$3(this$0, false);
        }
      }
    });
  }
  
  public void editsDiscarded(TaskDataManagerEvent event)
  {
    if (event.getTask().equals(this$0.getTask())) {
      refresh(event.getTask());
    }
  }
}

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

import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorPlanningPart;

class AbstractTaskEditorPage$8
  extends TaskEditorPartDescriptor
{
  AbstractTaskEditorPage$8(AbstractTaskEditorPage paramAbstractTaskEditorPage, String $anonymous0)
  {
    super($anonymous0);
  }
  
  public AbstractTaskEditorPart createPart()
  {
    return new TaskEditorPlanningPart();
  }
}

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

import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.mylyn.internal.tasks.ui.editors.EditorUtil;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.editor.FormPage;
import org.eclipse.ui.forms.widgets.FormToolkit;

public class TaskFormPage
  extends FormPage
{
  public TaskFormPage(String id, String title)
  {
    super(id, title);
  }
  
  public TaskFormPage(FormEditor editor, String id, String title)
  {
    super(editor, id, title);
  }
  
  protected void fillToolBar(IToolBarManager toolBarManager) {}
  
  protected void createFormContent(IManagedForm managedForm)
  {
    super.createFormContent(managedForm);
    managedForm.getToolkit().setBorderStyle(0);
    EditorUtil.initializeScrollbars(managedForm.getForm());
  }
  
  protected void refresh() {}
}

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

import org.eclipse.core.runtime.Status;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.internal.tasks.core.data.TaskDataManager;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.swt.SWTError;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.widgets.ScrolledForm;
import org.eclipse.ui.internal.browser.BrowserViewer;
import org.eclipse.ui.internal.browser.IBrowserViewerContainer;

public class BrowserFormPage
  extends TaskFormPage
{
  public static final String ID_EDITOR = "org.eclipse.mylyn.tasks.ui.editor.browser";
  private BrowserViewer browserViewer;
  
  public BrowserFormPage(FormEditor editor, String title)
  {
    super(editor, "org.eclipse.mylyn.tasks.ui.editor.browser", title);
  }
  
  protected void createFormContent(IManagedForm managedForm)
  {
    super.createFormContent(managedForm);
    try
    {
      ScrolledForm form = managedForm.getForm();
      form.getBody().setLayout(new FillLayout());
      browserViewer = new BrowserViewer(form.getBody(), 0);
      browserViewer.setLayoutData(null);
      browserViewer.setContainer(new IBrowserViewerContainer()
      {
        public boolean close()
        {
          return false;
        }
        
        public IActionBars getActionBars()
        {
          return getEditorSite().getActionBars();
        }
        
        public void openInExternalBrowser(String url) {}
      });
      managedForm.getForm().setContent(browserViewer);
      String url = getUrl();
      if (url != null) {
        browserViewer.setURL(url);
      }
    }
    catch (SWTError e)
    {
      StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", "Could not create browser page: " + 
        e.getMessage(), e));
    }
    catch (RuntimeException e)
    {
      StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", "Could not create browser page", e));
    }
  }
  
  public Browser getBrowser()
  {
    if (browserViewer == null) {
      return null;
    }
    return browserViewer.getBrowser();
  }
  
  protected String getUrl()
  {
    IEditorInput input = getEditorInput();
    if ((input instanceof TaskEditorInput)) {
      return ((TaskEditorInput)input).getTask().getUrl();
    }
    return null;
  }
  
  public void init(IEditorSite site, IEditorInput input)
  {
    super.init(site, input);
    if ((input instanceof TaskEditorInput)) {
      TasksUiPlugin.getTaskDataManager().setTaskRead(((TaskEditorInput)input).getTask(), true);
    }
  }
  
  protected void refresh()
  {
    init(getEditorSite(), getEditorInput());
  }
}

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

import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;

class AbstractTaskEditorPage$MenuCreator
  implements IMenuCreator
{
  private MenuManager menuManager;
  private Menu menu;
  
  public AbstractTaskEditorPage$MenuCreator(AbstractTaskEditorPage paramAbstractTaskEditorPage) {}
  
  public void dispose()
  {
    if (menu != null)
    {
      menu.dispose();
      menu = null;
    }
    if (menuManager != null)
    {
      menuManager.dispose();
      menuManager = null;
    }
  }
  
  public Menu getMenu(Control parent)
  {
    if (menuManager == null)
    {
      menuManager = new MenuManager();
      initialize(menuManager);
    }
    return menuManager.createContextMenu(parent);
  }
  
  public Menu getMenu(Menu parent)
  {
    return null;
  }
  
  protected void initialize(MenuManager menuManager) {}
}

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

import java.util.Collection;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.swt.widgets.Composite;

class AbstractTaskEditorPage$14
  implements ISafeRunnable
{
  AbstractTaskEditorPage$14(AbstractTaskEditorPage paramAbstractTaskEditorPage, TaskEditorPartDescriptor paramTaskEditorPartDescriptor, Composite paramComposite, Collection paramCollection) {}
  
  public void handleException(Throwable e)
  {
    StatusHandler.log(new Status(4, "org.eclipse.mylyn.tasks.ui", 
      "Error creating task editor part: \"" + val$descriptor.getId() + "\"", e));
  }
  
  public void run()
    throws Exception
  {
    AbstractTaskEditorPart part = val$descriptor.createPart();
    part.setPartId(val$descriptor.getId());
    AbstractTaskEditorPage.access$7(this$0, val$parent, part, val$descriptors);
  }
}

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

import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.internal.tasks.ui.editors.Messages;
import org.eclipse.mylyn.internal.tasks.ui.editors.ToolBarButtonContribution;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;

class AbstractTaskEditorPage$20
  extends ToolBarButtonContribution
{
  AbstractTaskEditorPage$20(AbstractTaskEditorPage paramAbstractTaskEditorPage, String $anonymous0)
  {
    super($anonymous0);
  }
  
  protected Control createButton(Composite composite)
  {
    AbstractTaskEditorPage.access$8(this$0, new Button(composite, 8388608));
    AbstractTaskEditorPage.access$9(this$0).setText(Messages.TaskEditorActionPart_Submit + " ");
    AbstractTaskEditorPage.access$9(this$0).setImage(CommonImages.getImage(TasksUiImages.REPOSITORY_SUBMIT));
    AbstractTaskEditorPage.access$9(this$0).setBackground(null);
    AbstractTaskEditorPage.access$9(this$0).addListener(13, new Listener()
    {
      public void handleEvent(Event e)
      {
        this$0.doSubmit();
      }
    });
    return AbstractTaskEditorPage.access$9(this$0);
  }
}

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

import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;

class TaskEditor$4
  extends ControlAdapter
{
  TaskEditor$4(TaskEditor paramTaskEditor) {}
  
  public void controlMoved(ControlEvent e)
  {
    TaskEditor.access$3(this$0);
  }
}

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

import org.eclipse.jface.action.ControlContribution;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.mylyn.commons.ui.PlatformUiUtil;
import org.eclipse.mylyn.internal.tasks.ui.editors.Messages;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.forms.FormColors;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.ImageHyperlink;

class TaskEditor$12
  extends ControlContribution
{
  TaskEditor$12(TaskEditor paramTaskEditor, String $anonymous0, TaskRepository paramTaskRepository)
  {
    super($anonymous0);
  }
  
  protected Control createControl(Composite parent)
  {
    FormToolkit toolkit = this$0.getHeaderForm().getToolkit();
    Composite composite = toolkit.createComposite(parent);
    RowLayout layout = new RowLayout();
    if (PlatformUiUtil.hasNarrowToolBar())
    {
      marginTop = 0;
      marginBottom = 0;
      center = true;
    }
    composite.setLayout(layout);
    composite.setBackground(null);
    String label = val$taskRepository.getRepositoryLabel();
    if (label.indexOf("//") != -1) {
      label = label.substring(val$taskRepository.getRepositoryUrl().indexOf("//") + 2);
    }
    ImageHyperlink link = new ImageHyperlink(composite, 0);
    link.setText(label);
    link.setFont(JFaceResources.getBannerFont());
    link.setForeground(toolkit.getColors().getColor("org.eclipse.ui.forms.TITLE"));
    link.setToolTipText(Messages.TaskEditor_Edit_Task_Repository_ToolTip);
    link.addHyperlinkListener(new HyperlinkAdapter()
    {
      public void linkActivated(HyperlinkEvent e)
      {
        TasksUiUtil.openEditRepositoryWizard(val$taskRepository);
      }
    });
    return composite;
  }
}

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

import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.widgets.ScrolledForm;

class AbstractTaskEditorPage$2
  implements Runnable
{
  AbstractTaskEditorPage$2(AbstractTaskEditorPage paramAbstractTaskEditorPage) {}
  
  public void run()
  {
    if ((this$0.getSite() != null) && (this$0.getSite().getPage() != null) && (!this$0.getManagedForm().getForm().isDisposed())) {
      if (this$0.getTaskEditor() != null) {
        this$0.getSite().getPage().closeEditor(this$0.getTaskEditor(), false);
      } else {
        this$0.getSite().getPage().closeEditor(this$0, false);
      }
    }
  }
}

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

import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.ITaskList;
import org.eclipse.mylyn.internal.tasks.ui.editors.TaskEditorActionPart;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.sync.SubmitJob;

class AbstractTaskEditorPage$SubmitTaskJobListener$1
  implements Runnable
{
  AbstractTaskEditorPage$SubmitTaskJobListener$1(AbstractTaskEditorPage.SubmitTaskJobListener paramSubmitTaskJobListener, SubmitJob paramSubmitJob) {}
  
  private void addTask(ITask newTask)
  {
    AbstractTaskContainer parent = null;
    AbstractTaskEditorPart actionPart = AbstractTaskEditorPage.SubmitTaskJobListener.access$1(this$1).getPart("org.eclipse.mylyn.tasks.ui.editors.parts.actions");
    if ((actionPart instanceof TaskEditorActionPart)) {
      parent = ((TaskEditorActionPart)actionPart).getCategory();
    }
    TasksUiInternal.getTaskList().addTask(newTask, parent);
  }
  
  /* Error */
  public void run()
  {
    // Byte code:
    //   0: aload_0
    //   1: getfield 120	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:val$job	Lorg/eclipse/mylyn/tasks/core/sync/SubmitJob;
    //   4: invokevirtual 133	org/eclipse/mylyn/tasks/core/sync/SubmitJob:getStatus	()Lorg/eclipse/core/runtime/IStatus;
    //   7: ifnonnull +175 -> 182
    //   10: aload_0
    //   11: getfield 121	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:this$1	Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;
    //   14: invokestatic 147	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener:access$1	(Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;)Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage;
    //   17: invokevirtual 140	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage:getTaskRepository	()Lorg/eclipse/mylyn/tasks/core/TaskRepository;
    //   20: invokestatic 131	org/eclipse/mylyn/internal/tasks/ui/util/TasksUiInternal:synchronizeRepositoryInBackground	(Lorg/eclipse/mylyn/tasks/core/TaskRepository;)V
    //   23: aload_0
    //   24: getfield 120	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:val$job	Lorg/eclipse/mylyn/tasks/core/sync/SubmitJob;
    //   27: invokevirtual 134	org/eclipse/mylyn/tasks/core/sync/SubmitJob:getTask	()Lorg/eclipse/mylyn/tasks/core/ITask;
    //   30: aload_0
    //   31: getfield 121	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:this$1	Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;
    //   34: invokestatic 147	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener:access$1	(Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;)Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage;
    //   37: invokevirtual 139	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage:getTask	()Lorg/eclipse/mylyn/tasks/core/ITask;
    //   40: invokevirtual 123	java/lang/Object:equals	(Ljava/lang/Object;)Z
    //   43: ifeq +16 -> 59
    //   46: aload_0
    //   47: getfield 121	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:this$1	Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;
    //   50: invokestatic 147	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener:access$1	(Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;)Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage;
    //   53: invokevirtual 137	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage:refresh	()V
    //   56: goto +106 -> 162
    //   59: aload_0
    //   60: getfield 121	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:this$1	Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;
    //   63: invokestatic 147	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener:access$1	(Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;)Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage;
    //   66: invokevirtual 139	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage:getTask	()Lorg/eclipse/mylyn/tasks/core/ITask;
    //   69: astore_1
    //   70: aload_0
    //   71: getfield 120	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:val$job	Lorg/eclipse/mylyn/tasks/core/sync/SubmitJob;
    //   74: invokevirtual 134	org/eclipse/mylyn/tasks/core/sync/SubmitJob:getTask	()Lorg/eclipse/mylyn/tasks/core/ITask;
    //   77: astore_2
    //   78: aload_0
    //   79: aload_2
    //   80: invokespecial 148	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:addTask	(Lorg/eclipse/mylyn/tasks/core/ITask;)V
    //   83: new 55	org/eclipse/mylyn/internal/tasks/ui/editors/TaskMigrator
    //   86: dup
    //   87: aload_1
    //   88: invokespecial 127	org/eclipse/mylyn/internal/tasks/ui/editors/TaskMigrator:<init>	(Lorg/eclipse/mylyn/tasks/core/ITask;)V
    //   91: astore_3
    //   92: aload_3
    //   93: iconst_1
    //   94: invokevirtual 125	org/eclipse/mylyn/internal/tasks/ui/editors/TaskMigrator:setDelete	(Z)V
    //   97: aload_3
    //   98: aload_0
    //   99: getfield 121	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:this$1	Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;
    //   102: invokestatic 147	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener:access$1	(Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;)Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage;
    //   105: invokevirtual 142	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage:getTaskEditor	()Lorg/eclipse/mylyn/tasks/ui/editors/TaskEditor;
    //   108: invokevirtual 129	org/eclipse/mylyn/internal/tasks/ui/editors/TaskMigrator:setEditor	(Lorg/eclipse/mylyn/tasks/ui/editors/TaskEditor;)V
    //   111: aload_3
    //   112: aload_0
    //   113: getfield 121	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:this$1	Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;
    //   116: invokestatic 147	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener:access$1	(Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;)Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage;
    //   119: invokestatic 143	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage:access$4	(Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage;)Lorg/eclipse/mylyn/tasks/core/AbstractRepositoryConnector;
    //   122: aload_0
    //   123: getfield 121	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:this$1	Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;
    //   126: invokestatic 147	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener:access$1	(Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;)Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage;
    //   129: invokevirtual 140	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage:getTaskRepository	()Lorg/eclipse/mylyn/tasks/core/TaskRepository;
    //   132: aload_2
    //   133: aload_0
    //   134: getfield 121	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener$1:this$1	Lorg/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener;
    //   137: invokestatic 147	org/eclipse/mylyn/tasks/ui/editors/AbstractTaskEditorPage$SubmitTaskJobListener:access$
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd