| /******************************************************************************* |
| * Copyright (c) 2005, 2007 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ui.tests.statushandlers.views; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IWorkspaceRunnable; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TableViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.ScrolledComposite; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Spinner; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IPersistableElement; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.WorkspaceModifyOperation; |
| import org.eclipse.ui.internal.WorkbenchPlugin; |
| import org.eclipse.ui.internal.registry.RegistryReader; |
| import org.eclipse.ui.part.ViewPart; |
| import org.eclipse.ui.progress.IProgressService; |
| import org.eclipse.ui.statushandlers.StatusManager; |
| import org.eclipse.ui.tests.statushandlers.jobs.TestJob; |
| import org.eclipse.ui.tests.statushandlers.jobs.UITestJob; |
| |
| /** |
| * A view dedicated to generating status (error. |
| */ |
| public class StatusHandlingView extends ViewPart { |
| |
| private Combo durationField, exceptionField, statusSeverityField; |
| |
| private Spinner percent; |
| |
| private Text delayField, quantityField, rescheduleDelay, statusPluginID; |
| |
| private Button progressNoForkLockField, threadField, jobLockField, |
| systemField, userField, groupField, rescheduleField, |
| returnErrorStatus, showStatusField, logStatusField; |
| |
| private TableViewer statusTableViever; |
| |
| private ContentProvider contentProvider; |
| |
| private List statusItems = Collections.synchronizedList(new ArrayList()); |
| |
| private int statusNo; |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite) |
| */ |
| public void createPartControl(Composite parent) { |
| |
| ScrolledComposite scroller = new ScrolledComposite(parent, SWT.H_SCROLL |
| | SWT.V_SCROLL); |
| |
| Composite body = new Composite(scroller, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| body.setLayout(layout); |
| GridData gd = new GridData(GridData.FILL_BOTH); |
| body.setLayoutData(gd); |
| |
| Composite jobsAndRunnables = new Composite(body, SWT.BORDER); |
| layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.makeColumnsEqualWidth = true; |
| jobsAndRunnables.setLayout(layout); |
| gd = new GridData(GridData.FILL_HORIZONTAL); |
| jobsAndRunnables.setLayoutData(gd); |
| |
| createEntryFieldGroup(jobsAndRunnables); |
| createJobAndRunnableSpecificGroups(jobsAndRunnables); |
| |
| Composite views = new Composite(body, SWT.BORDER); |
| layout = new GridLayout(); |
| views.setLayout(layout); |
| gd = new GridData(GridData.FILL_HORIZONTAL); |
| views.setLayoutData(gd); |
| |
| createShowViewsGroup(views); |
| |
| Composite invalidExtensions = new Composite(body, SWT.BORDER); |
| layout = new GridLayout(); |
| invalidExtensions.setLayout(layout); |
| gd = new GridData(GridData.FILL_HORIZONTAL); |
| invalidExtensions.setLayoutData(gd); |
| |
| createInvalidExtGroup(invalidExtensions); |
| |
| Composite generateStatusToBeShown = new Composite(body, SWT.BORDER); |
| layout = new GridLayout(); |
| generateStatusToBeShown.setLayout(layout); |
| gd = new GridData(GridData.FILL_HORIZONTAL); |
| generateStatusToBeShown.setLayoutData(gd); |
| |
| createShowStatusToBeShowGroup(generateStatusToBeShown); |
| |
| scroller.setContent(body); |
| scroller.setMinSize(body.computeSize(SWT.DEFAULT, SWT.DEFAULT)); |
| scroller.setExpandHorizontal(true); |
| scroller.setExpandVertical(true); |
| |
| } |
| |
| /** |
| * Creates global entry group. |
| * |
| * @param body |
| * parent |
| */ |
| private void createEntryFieldGroup(Composite body) { |
| // duration |
| Label label = new Label(body, SWT.NONE); |
| label.setText("Duration:"); //$NON-NLS-1$ |
| durationField = new Combo(body, SWT.DROP_DOWN | SWT.READ_ONLY); |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| data.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH; |
| durationField.setLayoutData(data); |
| durationField.setToolTipText("Duration of the job/runnable"); |
| durationField.add("0"); //$NON-NLS-1$ |
| durationField.add("1 millisecond"); //$NON-NLS-1$ |
| durationField.add("1 second"); //$NON-NLS-1$ |
| durationField.add("10 seconds"); //$NON-NLS-1$ |
| durationField.add("1 minute"); //$NON-NLS-1$ |
| durationField.add("10 minutes"); //$NON-NLS-1$ |
| durationField.select(3); |
| |
| label = new Label(body, SWT.NONE); |
| label.setText("Throw exception after (% of duration):"); //$NON-NLS-1$ |
| percent = new Spinner(body, SWT.BORDER); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| data.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH; |
| percent.setLayoutData(data); |
| percent |
| .setToolTipText("Exception/Error will be thrown after percent*duration"); |
| percent.setMinimum(1); |
| percent.setMaximum(100); |
| percent.setSelection(50); |
| |
| label = new Label(body, SWT.NONE); |
| label.setText("Exception:"); //$NON-NLS-1$ |
| exceptionField = new Combo(body, SWT.DROP_DOWN | SWT.READ_ONLY); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| data.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH; |
| exceptionField.setLayoutData(data); |
| exceptionField |
| .setToolTipText("Exception/Error to be thrown from the job/runnable"); |
| exceptionField.add("NullPointerException"); //$NON-NLS-1$ |
| exceptionField.add("OutOfMemoryError"); //$NON-NLS-1$ |
| exceptionField.add("IndexOutOfBoundsException");//$NON-NLS-1$ |
| exceptionField.select(0); |
| |
| } |
| |
| /** |
| * Creates groups for run in UI / run in user thread and run job actions. |
| * |
| * @param parent |
| */ |
| private void createJobAndRunnableSpecificGroups(Composite parent) { |
| |
| Composite group = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 1; |
| group.setLayout(layout); |
| GridData gd = new GridData(GridData.FILL_BOTH); |
| gd.horizontalSpan = 2; |
| group.setLayoutData(gd); |
| |
| createRunInUIGroup(group); |
| createRunInUserInterfaceThread(group); |
| createRunJob(group); |
| |
| } |
| |
| private void createRunInUIGroup(Composite parent) { |
| Composite group = new Composite(parent, SWT.BORDER); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.makeColumnsEqualWidth = true; |
| group.setLayout(layout); |
| group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| Button noFork = new Button(group, SWT.PUSH); |
| noFork.setText("Run In UI thread (does not fork)"); //$NON-NLS-1$ |
| noFork.setToolTipText("Use IProgressService.runInUI(...)"); //$NON-NLS-1$ |
| noFork.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| noFork.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| progressNoFork(); |
| } |
| }); |
| |
| progressNoForkLockField = new Button(group, SWT.CHECK); |
| progressNoForkLockField |
| .setText("Lock the workspace (run in workspace)"); //$NON-NLS-1$ |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| progressNoForkLockField.setLayoutData(data); |
| progressNoForkLockField |
| .setToolTipText("Use ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable(){...}) inside the IProgressService.runInUI(...)"); |
| |
| } |
| |
| private void createRunInUserInterfaceThread(Composite parent) { |
| |
| Composite group = new Composite(parent, SWT.BORDER); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.makeColumnsEqualWidth = true; |
| group.setLayout(layout); |
| group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| Button window = new Button(group, SWT.PUSH); |
| window.setText("Runnable in Window"); //$NON-NLS-1$ |
| window |
| .setToolTipText("Use PlatformUI.getWorkbench().getActiveWorkbenchWindow().run(true, true, new IRunnableWithProgress(){...})"); //$NON-NLS-1$ |
| window.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| window.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| runnableInWindow(); |
| } |
| }); |
| } |
| |
| /** |
| * @param parent |
| */ |
| private void createRunJob(Composite parent) { |
| Composite group = new Composite(parent, SWT.BORDER); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.makeColumnsEqualWidth = true; |
| group.setLayout(layout); |
| group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| Label label = new Label(group, SWT.NONE); |
| label.setText("Start delay (ms):"); //$NON-NLS-1$ |
| delayField = new Text(group, SWT.BORDER); |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| data.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH; |
| delayField.setLayoutData(data); |
| delayField.setToolTipText("Delay to start the job"); |
| delayField.setText("0"); //$NON-NLS-1$ |
| |
| label = new Label(group, SWT.NONE); |
| label.setText("Quantity:"); //$NON-NLS-1$ |
| quantityField = new Text(group, SWT.BORDER); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| data.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH; |
| quantityField.setLayoutData(data); |
| quantityField.setToolTipText("How many jobs ought to be started ?"); |
| quantityField.setText("1"); //$NON-NLS-1$ |
| |
| // reschedule delay |
| label = new Label(group, SWT.NONE); |
| label.setText("Reschedule Delay (ms):"); //$NON-NLS-1$ |
| rescheduleDelay = new Text(group, SWT.BORDER); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| data.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH; |
| rescheduleDelay.setLayoutData(data); |
| rescheduleDelay |
| .setToolTipText("Reschedule after ... (see the reschedule checkbox)"); |
| rescheduleDelay.setText("1000"); //$NON-NLS-1$ |
| |
| // thread |
| threadField = new Button(group, SWT.CHECK); |
| threadField.setText("Run in UI thread"); //$NON-NLS-1$ |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| threadField.setLayoutData(data); |
| threadField |
| .setToolTipText("Use org.eclipse.ui.progress.UIJob (instead of org.eclipse.core.runtime.jobs.Job)"); |
| |
| // lock |
| jobLockField = new Button(group, SWT.CHECK); |
| jobLockField.setText("Lock the workspace"); //$NON-NLS-1$ |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| jobLockField.setLayoutData(data); |
| jobLockField |
| .setToolTipText("Reserve exclusive access to workspace - setRule(ResourcesPlugin.getWorkspace().getRoot())"); |
| |
| // system |
| systemField = new Button(group, SWT.CHECK); |
| systemField.setText("System job"); //$NON-NLS-1$ |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| systemField.setLayoutData(data); |
| systemField |
| .setToolTipText("Decide whether the job is a system job /is presented on UI/"); |
| |
| // whether the job is a user job |
| userField = new Button(group, SWT.CHECK); |
| userField.setText("User job"); //$NON-NLS-1$ |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| userField.setLayoutData(data); |
| userField |
| .setToolTipText("Decide whether the job is initiated directly by the UI end user"); |
| |
| // groups |
| groupField = new Button(group, SWT.CHECK); |
| groupField.setText("Run in Group"); //$NON-NLS-1$ |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| groupField.setLayoutData(data); |
| groupField |
| .setToolTipText("Run all of the jobs as a single group (if there is more than one job)"); |
| |
| // reschedule |
| rescheduleField = new Button(group, SWT.CHECK); |
| rescheduleField.setText("Reschedule"); //$NON-NLS-1$ |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| rescheduleField.setLayoutData(data); |
| rescheduleField |
| .setToolTipText("Reschedule the job ('Reschedule Delay' is the period between reschedules)"); |
| |
| // create jobs |
| Button create = new Button(group, SWT.PUSH); |
| create.setText("Create jobs"); //$NON-NLS-1$ |
| create |
| .setToolTipText("Creates and schedules jobs according to above parameters"); //$NON-NLS-1$ |
| create.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| create.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| createJobs(); |
| } |
| }); |
| |
| returnErrorStatus = new Button(group, SWT.CHECK); |
| returnErrorStatus |
| .setText("Return an exception wrapped in a error status"); //$NON-NLS-1$ |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| returnErrorStatus.setLayoutData(data); |
| returnErrorStatus |
| .setToolTipText("Wrap the exception in a MultiStatus instance"); |
| |
| } |
| |
| /** |
| * @param parent |
| */ |
| private void createShowViewsGroup(Composite parent) { |
| |
| Composite group = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.makeColumnsEqualWidth = true; |
| group.setLayout(layout); |
| group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| Button showPartInitExceptionView = new Button(group, SWT.PUSH); |
| showPartInitExceptionView |
| .setText("Show view throwing PartInitException"); //$NON-NLS-1$ |
| showPartInitExceptionView.setLayoutData(new GridData( |
| GridData.FILL_HORIZONTAL)); |
| showPartInitExceptionView.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| |
| try { |
| PlatformUI |
| .getWorkbench() |
| .getActiveWorkbenchWindow() |
| .getActivePage() |
| .showView( |
| "org.eclipseinternal.ui.tests.statushandling.PartInitExceptionView"); |
| } catch (PartInitException e1) { |
| // should not be thrown ! |
| e1.printStackTrace(); |
| } |
| } |
| }); |
| |
| Button showRuntimeExceptionView = new Button(group, SWT.PUSH); |
| showRuntimeExceptionView.setText("Show view throwing RuntimeException"); //$NON-NLS-1$ |
| showRuntimeExceptionView.setLayoutData(new GridData( |
| GridData.FILL_HORIZONTAL)); |
| showRuntimeExceptionView.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| |
| try { |
| PlatformUI |
| .getWorkbench() |
| .getActiveWorkbenchWindow() |
| .getActivePage() |
| .showView( |
| "org.eclipseinternal.ui.tests.statushandling.RuntimeExceptionView"); |
| } catch (PartInitException e1) { |
| // should not be thrown ! |
| e1.printStackTrace(); |
| } |
| } |
| }); |
| |
| Button showRuntimeExceptionEditor = new Button(group, SWT.PUSH); |
| showRuntimeExceptionEditor |
| .setText("Show editor throwing RuntimeException"); //$NON-NLS-1$ |
| showRuntimeExceptionEditor.setLayoutData(new GridData( |
| GridData.FILL_HORIZONTAL)); |
| showRuntimeExceptionEditor.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| |
| try { |
| PlatformUI |
| .getWorkbench() |
| .getActiveWorkbenchWindow() |
| .getActivePage() |
| .openEditor(new IEditorInput() { |
| |
| public boolean exists() { |
| |
| return false; |
| } |
| |
| public ImageDescriptor getImageDescriptor() { |
| |
| return null; |
| } |
| |
| public String getName() { |
| |
| return null; |
| } |
| |
| public IPersistableElement getPersistable() { |
| |
| return null; |
| } |
| |
| public String getToolTipText() { |
| |
| return null; |
| } |
| |
| public Object getAdapter(Class adapter) { |
| |
| return null; |
| } |
| |
| }, |
| "org.eclipseinternal.ui.tests.statushandling.RuntimeExceptionEditor"); |
| } catch (PartInitException e1) { |
| // should not be thrown ! |
| e1.printStackTrace(); |
| } |
| } |
| }); |
| |
| Button showPartInitExceptionEditor = new Button(group, SWT.PUSH); |
| showPartInitExceptionEditor.setText("Show editor throwing PartInit"); //$NON-NLS-1$ |
| showPartInitExceptionEditor.setLayoutData(new GridData( |
| GridData.FILL_HORIZONTAL)); |
| showPartInitExceptionEditor |
| .addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| |
| try { |
| PlatformUI.getWorkbench() |
| .getActiveWorkbenchWindow().getActivePage() |
| .openEditor( |
| new IEditorInput() { |
| |
| public boolean exists() { |
| |
| return false; |
| } |
| |
| public ImageDescriptor getImageDescriptor() { |
| |
| return null; |
| } |
| |
| public String getName() { |
| |
| return null; |
| } |
| |
| public IPersistableElement getPersistable() { |
| |
| return null; |
| } |
| |
| public String getToolTipText() { |
| |
| return null; |
| } |
| |
| public Object getAdapter( |
| Class adapter) { |
| |
| return null; |
| } |
| |
| }, |
| "org.eclipseinternal.ui.tests.statushandling.PartInitExceptionEditor"); |
| } catch (PartInitException e1) { |
| // should not be thrown ! |
| e1.printStackTrace(); |
| } |
| } |
| }); |
| |
| } |
| |
| /** |
| * Creates a group for invalid extension initialization. |
| * |
| * @param parent |
| */ |
| private void createInvalidExtGroup(Composite parent) { |
| |
| Composite group = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.makeColumnsEqualWidth = true; |
| group.setLayout(layout); |
| group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| Button loadInvalidExt = new Button(group, SWT.PUSH); |
| loadInvalidExt |
| .setText("Extensions - invalid references determined at load time"); //$NON-NLS-1$ |
| loadInvalidExt.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| loadInvalidExt.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| |
| SampleRegistryReader reader = new SampleRegistryReader(); |
| reader.readRegistry(Platform.getExtensionRegistry(), |
| "org.eclipse.ui.tests", "sample"); |
| } |
| }); |
| } |
| |
| private void createShowStatusToBeShowGroup(Composite parent) { |
| |
| Composite group = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.makeColumnsEqualWidth = true; |
| group.setLayout(layout); |
| group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| Button handleStatuses = new Button(group, SWT.PUSH); |
| handleStatuses.setText("Handle statuses (StatusManager)"); //$NON-NLS-1$ |
| handleStatuses.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| handleStatuses.addSelectionListener(new SelectionAdapter() { |
| |
| public void widgetSelected(SelectionEvent e) { |
| for (Iterator it = statusItems.iterator(); it.hasNext();) { |
| DisplayedItem di = (DisplayedItem) it.next(); |
| // see SampleStatusHandler |
| // hints and statuses could be easily modified there |
| StatusManager.getManager().handle(di.getStatus(), |
| di.getHint()); |
| } |
| } |
| }); |
| |
| statusTableViever = new TableViewer(group, SWT.MULTI | SWT.BORDER |
| | SWT.V_SCROLL | SWT.VIRTUAL); |
| contentProvider = new ContentProvider(); |
| statusTableViever.setContentProvider(contentProvider); |
| GridData gd = new GridData(GridData.FILL_BOTH); |
| gd.horizontalSpan = 2; |
| statusTableViever.getTable().setLayoutData(gd); |
| statusTableViever.setInput(new Object[0]); |
| |
| Button addStatus = new Button(group, SWT.PUSH); |
| addStatus.setText("Add status to the list"); //$NON-NLS-1$ |
| addStatus.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| addStatus.addSelectionListener(new SelectionAdapter() { |
| |
| public void widgetSelected(SelectionEvent e) { |
| boolean log = logStatusField.getSelection(); |
| boolean show = showStatusField.getSelection(); |
| |
| int hint = StatusManager.NONE; |
| if (log && show) |
| hint = StatusManager.SHOW | StatusManager.LOG; |
| else if (log) |
| hint = StatusManager.LOG; |
| else if (show) |
| hint = StatusManager.SHOW; |
| |
| int severity = IStatus.OK; |
| switch (statusSeverityField.getSelectionIndex()) { |
| case 0: |
| severity = IStatus.OK; |
| break; |
| case 1: |
| severity = IStatus.INFO; |
| break; |
| case 2: |
| severity = IStatus.WARNING; |
| break; |
| case 3: |
| severity = IStatus.CANCEL; |
| break; |
| case 4: |
| severity = IStatus.ERROR; |
| break; |
| } |
| |
| statusNo++; |
| |
| statusItems.add(new DisplayedItem(new Status(severity, |
| statusPluginID.getText(), "A test status No. " |
| + statusNo + " !"), hint)); |
| statusTableViever.refresh(); |
| } |
| }); |
| |
| Button removeStatus = new Button(group, SWT.PUSH); |
| removeStatus.setText("Remove status from the list"); //$NON-NLS-1$ |
| removeStatus.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| removeStatus.addSelectionListener(new SelectionAdapter() { |
| |
| public void widgetSelected(SelectionEvent e) { |
| StructuredSelection sel = (StructuredSelection) statusTableViever |
| .getSelection(); |
| for (Iterator it = sel.iterator(); it.hasNext();) { |
| statusItems.remove(it.next()); |
| } |
| statusTableViever.refresh(); |
| } |
| }); |
| |
| showStatusField = new Button(group, SWT.CHECK); |
| showStatusField.setText("Show status (UI dialog)"); //$NON-NLS-1$ |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| showStatusField.setLayoutData(data); |
| showStatusField |
| .setToolTipText("Sets one of the StatusManager hints for showing statuses (SHOW or SHOWANDLOG)!"); |
| |
| logStatusField = new Button(group, SWT.CHECK); |
| logStatusField.setText("Log status"); //$NON-NLS-1$ |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| logStatusField.setLayoutData(data); |
| logStatusField |
| .setToolTipText("Sets one of the StatusManager hints for logging statuses (LOG or SHOWANDLOG)!"); |
| |
| // duration |
| Label label = new Label(group, SWT.NONE); |
| label.setText("Severity level:"); //$NON-NLS-1$ |
| statusSeverityField = new Combo(group, SWT.DROP_DOWN | SWT.READ_ONLY); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| data.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH; |
| statusSeverityField.setLayoutData(data); |
| statusSeverityField.setToolTipText("Severity of the generated status");//$NON-NLS-1$ |
| statusSeverityField.add("OK"); //$NON-NLS-1$ |
| statusSeverityField.add("INFO"); //$NON-NLS-1$ |
| statusSeverityField.add("WARNING"); //$NON-NLS-1$ |
| statusSeverityField.add("CANCEL"); //$NON-NLS-1$ |
| statusSeverityField.add("ERROR"); //$NON-NLS-1$ |
| statusSeverityField.select(4); |
| |
| Label labelID = new Label(group, SWT.NONE); |
| labelID.setText("ID of the source plugin:"); //$NON-NLS-1$ |
| statusPluginID = new Text(group, SWT.BORDER); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| data.widthHint = IDialogConstants.ENTRY_FIELD_WIDTH; |
| statusPluginID.setLayoutData(data); |
| statusPluginID |
| .setToolTipText("Sets the ID of plugin which 'generated' the status"); |
| statusPluginID.setText(WorkbenchPlugin.PI_WORKBENCH); |
| |
| } |
| |
| public void setFocus() { |
| if (durationField != null && !durationField.isDisposed()) |
| durationField.setFocus(); |
| } |
| |
| /** |
| * |
| */ |
| private void progressNoFork() { |
| try { |
| final long duration = getDuration(); |
| final boolean shouldLock = progressNoForkLockField.getSelection(); |
| final Throwable throwable = getException(); |
| final long throwAfter = getThrowAfter(duration); |
| |
| IProgressService progressService = PlatformUI.getWorkbench() |
| .getProgressService(); |
| progressService.runInUI(progressService, |
| new IRunnableWithProgress() { |
| public void run(IProgressMonitor monitor) |
| throws InterruptedException { |
| if (shouldLock) |
| doRunInWorkspace(duration, throwAfter, |
| throwable, monitor); |
| else |
| doRun(duration, throwAfter, throwable, monitor); |
| } |
| }, ResourcesPlugin.getWorkspace().getRoot()); |
| } catch (InvocationTargetException e) { |
| e.printStackTrace(); |
| } catch (InterruptedException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * @param duration |
| * @param throwAfter |
| * @param toBeThrown |
| * @param monitor |
| */ |
| protected void doRunInWorkspace(final long duration, final long throwAfter, |
| final Throwable toBeThrown, IProgressMonitor monitor) { |
| try { |
| ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| doRun(duration, throwAfter, toBeThrown, monitor); |
| } |
| }, monitor); |
| } catch (CoreException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * @param duration |
| * @param throwAfter |
| * @param toBeThrown |
| * @param monitor |
| */ |
| protected void doRun(long duration, final long throwAfter, |
| final Throwable toBeThrown, IProgressMonitor monitor) { |
| final long sleep = 10; |
| int ticks = (int) (duration / sleep); |
| int ticksToThrow = (int) (throwAfter / sleep); |
| monitor.beginTask("Spinning inside IProgressService", ticks); //$NON-NLS-1$ |
| monitor.setTaskName("Spinning inside IProgressService"); //$NON-NLS-1$ |
| for (int i = 0; i < ticks; i++) { |
| monitor.subTask("Processing tick #" + i); //$NON-NLS-1$ |
| if (monitor.isCanceled()) |
| return; |
| try { |
| Thread.sleep(sleep); |
| } catch (InterruptedException e) { |
| // ignore |
| } |
| if (i == ticksToThrow) { |
| throwException(toBeThrown); |
| // toBeThrown is neither a runtime exception nor an error |
| return; |
| } |
| monitor.worked(1); |
| } |
| } |
| |
| /** |
| * |
| */ |
| protected void createJobs() { |
| int jobCount = Integer.parseInt(quantityField.getText()); |
| boolean ui = threadField.getSelection(); |
| long duration = getDuration(); |
| boolean lock = jobLockField.getSelection(); |
| boolean system = systemField.getSelection(); |
| boolean useGroup = groupField.getSelection(); |
| boolean user = userField.getSelection(); |
| boolean reschedule = rescheduleField.getSelection(); |
| final long rescheduleWait = Long.parseLong(rescheduleDelay.getText()); |
| boolean returnError = returnErrorStatus.getSelection(); |
| Throwable throwable = getException(); |
| long throwAfter = getThrowAfter(duration); |
| |
| int groupIncrement = IProgressMonitor.UNKNOWN; |
| IProgressMonitor group = new NullProgressMonitor(); |
| int total = IProgressMonitor.UNKNOWN; |
| |
| if (jobCount > 1) { |
| total = 100; |
| groupIncrement = 100 / jobCount; |
| } |
| |
| if (useGroup) { |
| group = Job.getJobManager().createProgressGroup(); |
| group.beginTask("Group", total); //$NON-NLS-1$ |
| } |
| |
| long delay = Integer.parseInt(delayField.getText()); |
| for (int i = 0; i < jobCount; i++) { |
| Job result; |
| if (ui) |
| result = new UITestJob(duration, lock, throwAfter, throwable, |
| returnError); |
| else |
| result = new TestJob(duration, lock, reschedule, |
| rescheduleWait, throwAfter, throwable, returnError); |
| |
| result.setProgressGroup(group, groupIncrement); |
| result.setSystem(system); |
| result.setUser(user); |
| result.schedule(delay); |
| } |
| } |
| |
| /** |
| * |
| */ |
| public void runnableInWindow() { |
| |
| final long duration = getDuration(); |
| final long sleep = 10; |
| |
| final Throwable toBeThrown = getException(); |
| final long throwAfter = getThrowAfter(duration); |
| |
| IRunnableWithProgress runnableTest = new WorkspaceModifyOperation() { |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.actions.WorkspaceModifyOperation#execute(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| protected void execute(IProgressMonitor monitor) |
| throws CoreException, InvocationTargetException, |
| InterruptedException { |
| |
| int ticks = (int) (duration / sleep); |
| int ticksToThrow = (int) (throwAfter / sleep); |
| |
| monitor.beginTask( |
| "Spinning inside ApplicationWindow.run()", ticks); //$NON-NLS-1$ |
| monitor.setTaskName("Spinning inside ApplicationWindow.run()"); //$NON-NLS-1$ |
| for (int i = 0; i < ticks; i++) { |
| monitor.subTask("Processing tick #" + i); //$NON-NLS-1$ |
| if (monitor.isCanceled()) |
| return; |
| try { |
| Thread.sleep(sleep); |
| } catch (InterruptedException e) { |
| // ignore |
| } |
| if (i == ticksToThrow) { |
| throwException(toBeThrown); |
| // toBeThrown is neither a runtime exception nor an |
| // error |
| return; |
| } |
| monitor.worked(1); |
| } |
| } |
| |
| }; |
| |
| try { |
| PlatformUI.getWorkbench().getActiveWorkbenchWindow().run(true, |
| true, runnableTest); |
| } catch (InvocationTargetException e) { |
| e.printStackTrace(); |
| } catch (InterruptedException e) { |
| e.printStackTrace(); |
| } |
| |
| } |
| |
| /** |
| * @return duration |
| */ |
| protected long getDuration() { |
| switch (durationField.getSelectionIndex()) { |
| case 0: |
| return 0; |
| case 1: |
| return 1; |
| case 2: |
| return 1000; |
| case 3: |
| return 10000; |
| case 4: |
| return 60000; |
| case 5: |
| default: |
| return 600000; |
| } |
| } |
| |
| /** |
| * @return throwable |
| */ |
| protected Throwable getException() { |
| |
| switch (exceptionField.getSelectionIndex()) { |
| case 0: |
| return new NullPointerException("A sample NullPointerException"); |
| case 1: |
| return new OutOfMemoryError("A sample OutOfMemoryError"); |
| case 2: |
| return new IndexOutOfBoundsException( |
| "A sample IndexOutOfBoundsException"); |
| default: |
| return new NullPointerException("A sample NullPointerException"); |
| |
| } |
| } |
| |
| private long getThrowAfter(long duration) { |
| return Math.round(((double) duration) |
| * (((double) percent.getSelection()) / 100.0)); |
| } |
| |
| private void throwException(Throwable th) { |
| if (th == null) |
| return; |
| |
| if (th instanceof RuntimeException) |
| throw (RuntimeException) th; |
| |
| if (th instanceof Error) { |
| throw (Error) th; |
| } |
| |
| // TODO do something !! the exception cannot be thrown |
| } |
| |
| /** |
| * A registry reader for sample extension point. |
| */ |
| private static class SampleRegistryReader extends RegistryReader { |
| |
| /** |
| * Create a new instance of the receiver. |
| * |
| */ |
| public SampleRegistryReader() { |
| super(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.internal.registry.RegistryReader#readElement(org.eclipse.core.runtime.IConfigurationElement) |
| */ |
| protected boolean readElement(IConfigurationElement element) { |
| |
| String name = element.getName(); |
| |
| if (name != null) { |
| if (!name.equals("requiredElement")) |
| return false; |
| } |
| return true; |
| } |
| } |
| |
| private class ContentProvider implements IStructuredContentProvider { |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object) |
| */ |
| public Object[] getElements(Object inputElement) { |
| return statusItems.toArray(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.IContentProvider#dispose() |
| */ |
| public void dispose() { |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, |
| * java.lang.Object, java.lang.Object) |
| */ |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| |
| } |
| |
| } |
| |
| /** |
| * An item to be displayed in the table. |
| */ |
| private static class DisplayedItem { |
| |
| private int hint; |
| |
| private IStatus status; |
| |
| /** |
| * Constructs a new item. |
| * |
| * @param status |
| * @param hint |
| */ |
| public DisplayedItem(IStatus status, int hint) { |
| if (status == null) |
| throw new IllegalArgumentException(); |
| this.status = status; |
| this.hint = hint; |
| } |
| |
| public String toString() { |
| |
| String severity = "?"; |
| |
| switch (status.getSeverity()) { |
| case IStatus.CANCEL: |
| severity = "Cancel"; |
| break; |
| case IStatus.ERROR: |
| severity = "Error"; |
| break; |
| case IStatus.INFO: |
| severity = "Info"; |
| break; |
| case IStatus.OK: |
| severity = "Ok"; |
| break; |
| case IStatus.WARNING: |
| severity = "Warning"; |
| break; |
| } |
| |
| String stringHint = "?"; |
| |
| switch (hint) { |
| case StatusManager.LOG: |
| stringHint = "LOG"; |
| break; |
| case StatusManager.NONE: |
| stringHint = "NONE"; |
| break; |
| case StatusManager.SHOW: |
| stringHint = "SHOW"; |
| break; |
| case StatusManager.SHOW | StatusManager.LOG: |
| stringHint = "SHOWANDLOG"; |
| break; |
| } |
| |
| return "Severity: " + severity + " PluginID: " |
| + status.getPlugin() + " Hint: " + stringHint; |
| } |
| |
| /** |
| * @return the hint |
| */ |
| public int getHint() { |
| return hint; |
| } |
| |
| /** |
| * @return the status |
| */ |
| public IStatus getStatus() { |
| return status; |
| } |
| } |
| |
| } |