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

ce line #153	-> byte code offset #164
    //   Java source line #159	-> byte code offset #185
    //   Java source line #158	-> byte code offset #194
    //   Java source line #159	-> byte code offset #196
    //   Java source line #160	-> byte code offset #202
    //   Java source line #159	-> byte code offset #205
    //   Java source line #161	-> byte code offset #211
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	215	0	this	OpenRepositoryTaskJob
    //   0	215	1	monitor	org.eclipse.core.runtime.IProgressMonitor
    //   27	63	2	repository	org.eclipse.mylyn.tasks.core.TaskRepository
    //   67	2	3	connector	org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector
    //   78	52	4	taskData	TaskData
    //   162	16	4	e	CoreException
    //   194	9	5	localObject	Object
    // Exception table:
    //   from	to	target	type
    //   68	159	162	org/eclipse/core/runtime/CoreException
    //   68	185	194	finally
  }
}

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

import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;

class TaskListSynchronizationScheduler$1
  extends JobChangeAdapter
{
  TaskListSynchronizationScheduler$1(TaskListSynchronizationScheduler paramTaskListSynchronizationScheduler) {}
  
  public void done(IJobChangeEvent event)
  {
    this$0.jobDone();
  }
}

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

import org.eclipse.osgi.util.NLS;

public class Messages
  extends NLS
{
  private static final String BUNDLE_NAME = "org.eclipse.mylyn.internal.tasks.ui.messages";
  public static String ActiveContextExternalizationParticipant_Active_Task_Context;
  public static String ActivityExternalizationParticipant_Activity_Context;
  public static String ChangeActivityHandleOperation_Activity_migration;
  public static String DialogErrorReporter_Mylyn_Error;
  public static String DialogErrorReporter_Please_report_the_following_error_at;
  public static String DownloadAndOpenTaskAttachmentJob_cannotOpenEditor;
  public static String DownloadAndOpenTaskAttachmentJob_editorTooltip;
  public static String DownloadAndOpenTaskAttachmentJob_failedToDownloadAttachment;
  public static String MoveToCategoryMenuContributor_Set_Category_Menu_Item;
  public static String OpenRepositoryTaskJob_Could_not_find_repository_configuration_for_X;
  public static String OpenRepositoryTaskJob_Opening_Remote_Task;
  public static String OpenRepositoryTaskJob_Opening_repository_task_X;
  public static String OpenRepositoryTaskJob_Please_set_up_repository_via_X;
  public static String OpenRepositoryTaskJob_Repository_Not_Found;
  public static String OpenRepositoryTaskJob_Unable_to_open_task;
  public static String RefactorRepositoryUrlOperation_Repository_URL_update;
  public static String ScheduleDatePicker_Clear;
  public static String ScheduleTaskMenuContributor_Cannot_schedule_completed_tasks;
  public static String ScheduleTaskMenuContributor_Choose_Date_;
  public static String ScheduleTaskMenuContributor_Future;
  public static String ScheduleTaskMenuContributor_Not_Scheduled;
  public static String ScheduleTaskMenuContributor_Schedule_for;
  public static String TaskActivationExternalizationParticipant_Task_Activation_History;
  public static String TaskAttachmentEditorViewer_openingAttachment;
  public static String TaskAttachmentViewerBrowser_browser;
  public static String TaskHistoryDropDown_Activate_Task_;
  public static String TaskHistoryDropDown_Deactivate_Task;
  public static String TaskHistoryDropDown_Open_Active_Task;
  public static String TaskListBackupManager_Error_occured_during_scheduled_tasklist_backup;
  public static String TaskListBackupManager_Scheduled_task_data_backup;
  public static String TaskListNotificationManager_Open_Notification_Job;
  public static String TaskRepositoryLocationUi_Enter_CLIENTCERTIFICATE_password;
  public static String TaskRepositoryLocationUi_Enter_HTTP_password;
  public static String TaskRepositoryLocationUi_Enter_proxy_password;
  public static String TaskRepositoryLocationUi_Enter_repository_password;
  public static String TaskSearchPage_ERROR_Unable_to_present_query_page;
  public static String TaskSearchPage_No_task_found_matching_key_;
  public static String TaskSearchPage_Repository_Search;
  public static String TaskSearchPage_Repository;
  public static String TaskSearchPage_Task_Key_ID;
  public static String TaskSearchPage_Task_Search;
  public static String TasksReminderDialog_Description;
  public static String TasksReminderDialog_Dismiss_All;
  public static String TasksReminderDialog_Dismiss_Selected;
  public static String TasksReminderDialog_Priority;
  public static String TasksReminderDialog_Remind_tommorrow;
  public static String TasksReminderDialog_Reminder_Day;
  public static String TasksReminderDialog_Reminders;
  public static String TasksUiPlugin_Activate_Task;
  public static String TasksUiPlugin_Initializing_Task_List;
  public static String TasksUiPlugin_Task_Repositories;
  public static String TasksUiPlugin_Load_Data_Directory;
  public static String TasksUiPlugin_New_Task;
  public static String TaskTrimWidget__no_active_task_;
  public static String TaskTrimWidget__no_task_active_;
  public static String AbstractRepositoryConnectorUi_Task;
  public static String TaskElementLabelProvider__no_summary_available_;
  public static String TaskHyperlink_Could_not_determine_repository_for_report;
  public static String TaskHyperlink_Open_Task_X_in_X;
  public static String AbstractRetrieveTitleFromUrlJob_Retrieving_summary_from_URL;
  public static String FileStorage_unableToReadAttachmentFile;
  
  static {}
  
  public static void reloadMessages()
  {
    NLS.initializeMessages("org.eclipse.mylyn.internal.tasks.ui.messages", Messages.class);
  }
}

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

import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.TaskActivationAdapter;

class TaskTrimWidget$1
  extends TaskActivationAdapter
{
  TaskTrimWidget$1(TaskTrimWidget paramTaskTrimWidget) {}
  
  public void taskActivated(ITask task)
  {
    TaskTrimWidget.access$0(this$0, task);
    this$0.indicateActiveTask();
  }
  
  public void taskDeactivated(ITask task)
  {
    TaskTrimWidget.access$0(this$0, null);
    this$0.indicateNoActiveTask();
  }
}

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

import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.tasks.core.ITask.PriorityLevel;

public class TaskPriorityFilter
  extends AbstractTaskListFilter
{
  private static final String PRIORITY_PREFIX = "P";
  private String priorityLevel = ITask.PriorityLevel.P5.toString();
  
  public TaskPriorityFilter()
  {
    displayPrioritiesAbove(TaskListView.getCurrentPriorityLevel());
  }
  
  public void displayPrioritiesAbove(String level)
  {
    priorityLevel = level;
  }
  
  public boolean select(Object parent, Object element)
  {
    if ((element instanceof AbstractTaskContainer))
    {
      AbstractTaskContainer taskContainer = (AbstractTaskContainer)element;
      String priority = taskContainer.getPriority();
      if ((priority == null) || (!priority.startsWith("P"))) {
        return true;
      }
      if (priorityLevel.compareTo(taskContainer.getPriority()) >= 0) {
        return true;
      }
      return false;
    }
    return true;
  }
}

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

import org.eclipse.mylyn.tasks.ui.TasksUiUtil;

class OpenRepositoryTaskJob$3
  implements Runnable
{
  OpenRepositoryTaskJob$3(OpenRepositoryTaskJob paramOpenRepositoryTaskJob) {}
  
  public void run()
  {
    TasksUiUtil.openUrl(OpenRepositoryTaskJob.access$1(this$0));
  }
}

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

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

class TaskTrimWidget$8
  implements IMenuListener
{
  TaskTrimWidget$8(TaskTrimWidget paramTaskTrimWidget) {}
  
  public void menuAboutToShow(IMenuManager manager)
  {
    TaskTrimWidget.access$7(this$0).fillContextMenu(manager);
    
    ObjectActionContributorManager.getManager().contributeObjectActions(null, manager, 
      TaskTrimWidget.access$8(this$0));
  }
}

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

import java.lang.reflect.InvocationTargetException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.mylyn.tasks.ui.wizards.AbstractRepositoryQueryPage;
import org.eclipse.mylyn.tasks.ui.wizards.ITaskSearchPageContainer;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.progress.IProgressService;

@Deprecated
public abstract class AbstractRepositoryQueryPage2
  extends AbstractRepositoryQueryPage
{
  private Text titleText;
  private Button updateButton;
  private boolean firstTime = true;
  private final AbstractRepositoryConnector connector;
  private boolean needsRepositoryConfiguration = true;
  
  public AbstractRepositoryQueryPage2(String pageName, TaskRepository repository, IRepositoryQuery query)
  {
    super(pageName, repository, query);
    connector = TasksUi.getRepositoryConnector(getTaskRepository().getConnectorKind());
    setTitle(Messages.AbstractRepositoryQueryPage2_Enter_query_parameters);
  }
  
  public void setNeedsRepositoryConfiguration(boolean needsRepositoryConfiguration)
  {
    this.needsRepositoryConfiguration = needsRepositoryConfiguration;
  }
  
  public void createControl(Composite parent)
  {
    Composite composite = new Composite(parent, 0);
    GridDataFactory.fillDefaults().align(4, 4).grab(true, true).applyTo(composite);
    GridLayout layout = new GridLayout(2, false);
    if (inSearchContainer())
    {
      marginWidth = 0;
      marginHeight = 0;
    }
    composite.setLayout(layout);
    
    createTitleGroup(composite);
    
    Composite innerComposite = new Composite(composite, 0);
    GridDataFactory.fillDefaults().align(4, 4).grab(true, true).span(2, 1).applyTo(innerComposite);
    innerComposite.setLayout(new FillLayout());
    createPageContent(innerComposite);
    if (needsRepositoryConfiguration) {
      createUpdateButton(composite);
    } else {
      setDescription(Messages.AbstractRepositoryQueryPage2_Create_a_Query_Page_Description);
    }
    if (getQuery() != null)
    {
      titleText.setText(getQuery().getSummary());
      restoreState(getQuery());
    }
    Dialog.applyDialogFont(composite);
    setControl(composite);
  }
  
  protected abstract void createPageContent(Composite paramComposite);
  
  private void createTitleGroup(Composite control)
  {
    if (inSearchContainer()) {
      return;
    }
    Label titleLabel = new Label(control, 0);
    titleLabel.setText(Messages.AbstractRepositoryQueryPage2__Title_);
    
    titleText = new Text(control, 2048);
    GridDataFactory.fillDefaults().align(4, 128).grab(true, false).applyTo(titleText);
    titleText.addKeyListener(new KeyListener()
    {
      public void keyPressed(KeyEvent e) {}
      
      public void keyReleased(KeyEvent e)
      {
        getContainer().updateButtons();
      }
    });
  }
  
  private Control createUpdateButton(Composite control)
  {
    Composite composite = new Composite(control, 0);
    GridLayout layout = new GridLayout(2, false);
    composite.setLayout(layout);
    GridDataFactory.fillDefaults().align(4, 128).grab(true, false).span(2, 1).applyTo(composite);
    
    updateButton = new Button(composite, 8);
    updateButton.setText(Messages.AbstractRepositoryQueryPage2__Refresh_From_Repository);
    updateButton.setLayoutData(new GridData());
    updateButton.addSelectionListener(new SelectionAdapter()
    {
      public void widgetSelected(SelectionEvent e)
      {
        if (getTaskRepository() != null) {
          AbstractRepositoryQueryPage2.this.updateAttributesFromRepository(true);
        } else {
          MessageDialog.openInformation(
            Display.getCurrent().getActiveShell(), 
            Messages.AbstractRepositoryQueryPage2_Update_Attributes_Failed, 
            Messages.AbstractRepositoryQueryPage2_No_repository_available_please_add_one_using_the_Task_Repositories_view);
        }
      }
    });
    return composite;
  }
  
  public void setVisible(boolean visible)
  {
    super.setVisible(visible);
    if (getSearchContainer() != null) {
      getSearchContainer().setPerformActionEnabled(true);
    }
    if ((visible) && (firstTime))
    {
      firstTime = false;
      if ((!hasRepositoryConfiguration()) && (needsRepositoryConfiguration)) {
        Display.getDefault().asyncExec(new Runnable()
        {
          public void run()
          {
            if ((getControl() != null) && (!getControl().isDisposed())) {
              AbstractRepositoryQueryPage2.this.initializePage();
            }
          }
        });
      } else {
        initializePage();
      }
    }
  }
  
  private void initializePage()
  {
    if (needsRepositoryConfiguration) {
      updateAttributesFromRepository(false);
    }
    boolean restored = getQuery() != null;
    if (inSearchContainer()) {
      restored |= restoreState(null);
    }
  }
  
  protected abstract boolean hasRepositoryConfiguration();
  
  protected AbstractRepositoryConnector getConnector()
  {
    return connector;
  }
  
  private void updateAttributesFromRepository(boolean force)
  {
    if ((!hasRepositoryConfiguration()) || (force))
    {
      setErrorMessage(null);
      try
      {
        IRunnableWithProgress runnable = new IRunnableWithProgress()
        {
          public void run(IProgressMonitor monitor)
            throws InvocationTargetException, InterruptedException
          {
            try
            {
              connector.updateRepositoryConfiguration(getTaskRepository(), monitor);
            }
            catch (CoreException e)
            {
              throw new InvocationTargetException(e);
            }
            catch (OperationCanceledException localOperationCanceledException)
            {
              throw new InterruptedException();
            }
          }
        };
        if (getContainer() != null)
        {
          getContainer().run(true, true, runnable);
        }
        else if (getSearchContainer() != null)
        {
          getSearchContainer().getRunnableContext().run(true, true, runnable);
        }
        else
        {
          IProgressService service = PlatformUI.getWorkbench().getProgressService();
          service.busyCursorWhile(runnable);
        }
      }
      catch (InvocationTargetException e)
      {
        if ((e.getCause() instanceof CoreException)) {
          setErrorMessage(((CoreException)e.getCause()).getStatus().getMessage());
        } else {
          setErrorMessage(e.getCause().getMessage());
        }
        return;
      }
      catch (InterruptedException localInterruptedException)
      {
        return;
      }
    }
    doRefresh();
  }
  
  protected abstract void doRefresh();
  
  public boolean isPageComplete()
  {
    if ((titleText != null) && (titleText.getText().length() > 0)) {
      return true;
    }
    setMessage(Messages.AbstractRepositoryQueryPage2_Enter_a_title);
    return false;
  }
  
  public boolean performSearch()
  {
    if (inSearchContainer()) {
      saveState();
    }
    return super.performSearch();
  }
  
  protected abstract boolean restoreState(IRepositoryQuery paramIRepositoryQuery);
  
  public String getQueryTitle()
  {
    return titleText != null ? titleText.getText() : null;
  }
  
  public void setQueryTitle(String text)
  {
    if (titleText != null) {
      titleText.setText(text);
    }
  }
}

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

import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;

class AbstractRepositoryQueryPage2$1
  implements KeyListener
{
  AbstractRepositoryQueryPage2$1(AbstractRepositoryQueryPage2 paramAbstractRepositoryQueryPage2) {}
  
  public void keyPressed(KeyEvent e) {}
  
  public void keyReleased(KeyEvent e)
  {
    AbstractRepositoryQueryPage2.access$0(this$0).updateButtons();
  }
}

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

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Display;

class AbstractRepositoryQueryPage2$2
  extends SelectionAdapter
{
  AbstractRepositoryQueryPage2$2(AbstractRepositoryQueryPage2 paramAbstractRepositoryQueryPage2) {}
  
  public void widgetSelected(SelectionEvent e)
  {
    if (this$0.getTaskRepository() != null) {
      AbstractRepositoryQueryPage2.access$1(this$0, true);
    } else {
      MessageDialog.openInformation(
        Display.getCurrent().getActiveShell(), 
        Messages.AbstractRepositoryQueryPage2_Update_Attributes_Failed, 
        Messages.AbstractRepositoryQueryPage2_No_repository_available_please_add_one_using_the_Task_Repositories_view);
    }
  }
}

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

import org.eclipse.swt.widgets.Control;

class AbstractRepositoryQueryPage2$3
  implements Runnable
{
  AbstractRepositoryQueryPage2$3(AbstractRepositoryQueryPage2 paramAbstractRepositoryQueryPage2) {}
  
  public void run()
  {
    if ((this$0.getControl() != null) && (!this$0.getControl().isDisposed())) {
      AbstractRepositoryQueryPage2.access$2(this$0);
    }
  }
}

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

import org.eclipse.osgi.util.NLS;

public class Messages
  extends NLS
{
  private static final String BUNDLE_NAME = "org.eclipse.mylyn.internal.provisional.tasks.ui.wizards.messages";
  public static String AbstractRepositoryQueryPage2__Refresh_From_Repository;
  public static String AbstractRepositoryQueryPage2__Title_;
  public static String AbstractRepositoryQueryPage2_Create_a_Query_Page_Description;
  public static String AbstractRepositoryQueryPage2_Enter_a_title;
  public static String AbstractRepositoryQueryPage2_Enter_query_parameters;
  public static String AbstractRepositoryQueryPage2_No_repository_available_please_add_one_using_the_Task_Repositories_view;
  public static String AbstractRepositoryQueryPage2_Update_Attributes_Failed;
  
  static {}
  
  public static void reloadMessages()
  {
    NLS.initializeMessages("org.eclipse.mylyn.internal.provisional.tasks.ui.wizards.messages", Messages.class);
  }
}

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

import java.lang.reflect.InvocationTargetException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;

class AbstractRepositoryQueryPage2$4
  implements IRunnableWithProgress
{
  AbstractRepositoryQueryPage2$4(AbstractRepositoryQueryPage2 paramAbstractRepositoryQueryPage2) {}
  
  public void run(IProgressMonitor monitor)
    throws InvocationTargetException, InterruptedException
  {
    try
    {
      AbstractRepositoryQueryPage2.access$3(this$0).updateRepositoryConfiguration(this$0.getTaskRepository(), monitor);
    }
    catch (CoreException e)
    {
      throw new InvocationTargetException(e);
    }
    catch (OperationCanceledException localOperationCanceledException)
    {
      throw new InterruptedException();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.mylyn.internal.provisional.tasks.ui.wizards.AbstractRepositoryQueryPage2.4
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
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