[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / editors / EventsViewEditor.java

/*******************************************************************************
* Copyright (c) 2012 Ericsson
 * 
 * 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:
 *   Patrick Tasse - Initial API and implementation
 *******************************************************************************/

package org.eclipse.linuxtools.tmf.ui.editors;

import java.io.FileNotFoundException;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
import org.eclipse.linuxtools.tmf.ui.project.handlers.Messages;
import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfNavigatorContentProvider;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectRegistry;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
import org.eclipse.linuxtools.tmf.ui.views.events.TmfEventsView;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.ide.IGotoMarker;
import org.eclipse.ui.part.EditorPart;

/**
 * 
 * This editor is used to open a trace in the Events view
 * and set the trace as the current experiment.
 * It intercepts the IGotoMarker adapter and dispatches
 * the handling to the Events view' events table.
 * The editor then closes itself and hides the
 * editor area if no other editor is open.
 *
 */
public class EventsViewEditor extends TmfEditor {

    /**
     * The editor ID
     */
    public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.eventsView"; //$NON-NLS-1$

    private IFile fFile;
    @SuppressWarnings("rawtypes")
    private ITmfTrace fTrace;
    private IMarker fGotoMarker;
    private boolean fEditorAreaVisible;

    /*
     * (non-Javadoc)
     * @see org.eclipse.ui.part.EditorPart#doSave(org.eclipse.core.runtime.IProgressMonitor)
     */
    @Override
    public void doSave(IProgressMonitor monitor) {
    }

    @Override
    public void doSaveAs() {
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.ui.part.EditorPart#init(org.eclipse.ui.IEditorSite, org.eclipse.ui.IEditorInput)
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public void init(IEditorSite site, IEditorInput input) throws PartInitException {
        fEditorAreaVisible = site.getPage().isEditorAreaVisible();
        if (input instanceof TmfEditorInput) {
            fFile = ((TmfEditorInput) input).getFile();
            fTrace = ((TmfEditorInput) input).getTrace();
        } else if (input instanceof IFileEditorInput) {
            fFile = ((IFileEditorInput) input).getFile();
            if (fFile == null) {
                throw new PartInitException("Invalid IFileEditorInput: " + input); //$NON-NLS-1$
            }
            TmfExperiment currentExperiment = TmfExperiment.getCurrentExperiment();
            if (currentExperiment != null && fFile.equals(currentExperiment.getBookmarksFile())) {
                fTrace = currentExperiment;
                super.setSite(site);
                super.setInput(input);
                return;
            }
            try {
                String traceTypeId = fFile.getPersistentProperty(TmfTraceElement.TRACETYPE);
                if (traceTypeId == null) {
                    throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
                }
                if (traceTypeId.equals(TmfExperiment.class.getCanonicalName())) {
                    // Special case: experiment bookmark resource
                    TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
                    ncp.getChildren(fFile.getProject()); // force the model to be populated
                    TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
                    if (project == null) {
                        throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
                    }
                    for (ITmfProjectModelElement projectElement : project.getExperimentsFolder().getChildren()) {
                        String traceName = fFile.getParent().getName();
                        if (projectElement.getName().equals(traceName)) {
                            TmfExperimentElement experimentElement = (TmfExperimentElement) projectElement;
                            // Instantiate the experiment's traces
                            List<TmfTraceElement> traceEntries = experimentElement.getTraces();
                            int nbTraces = traceEntries.size();
                            int cacheSize = Integer.MAX_VALUE;
                            ITmfTrace<?>[] traces = new ITmfTrace[nbTraces];
                            for (int i = 0; i < nbTraces; i++) {
                                TmfTraceElement traceElement = traceEntries.get(i);
                                ITmfTrace trace = traceElement.instantiateTrace();
                                TmfEvent traceEvent = traceElement.instantiateEvent();
                                if (trace == null || traceEvent == null) {
                                    for (int j = 0; j < i; j++) {
                                        traces[j].dispose();
                                    }
                                    throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
                                }
                                try {
                                    trace.initTrace(traceElement.getName(), traceElement.getLocation().getPath(), traceEvent.getClass(), false);
                                } catch (FileNotFoundException e) {
                                }
                                trace.setResource(traceElement.getResource());
                                cacheSize = Math.min(cacheSize, trace.getCacheSize());
                                traces[i] = trace;
                            }
                            TmfExperiment experiment = new TmfExperiment(TmfEvent.class, experimentElement.getName(), traces, cacheSize);
                            experiment.setBookmarksFile(fFile);
                            fTrace = experiment;
                            TmfExperiment.setCurrentExperiment(experiment);
                            TmfSignalManager.dispatchSignal(new TmfExperimentSelectedSignal(this, experiment));
                            break;
                        }
                    }
                } else if (traceTypeId.equals(TmfTrace.class.getCanonicalName())) {
                    // Special case: trace bookmark resource
                    TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
                    ncp.getChildren(fFile.getProject()); // force the model to be populated
                    TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
                    for (ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
                        String traceName = fFile.getParent().getName();
                        if (projectElement.getName().equals(traceName)) {
                            TmfTraceElement traceElement = (TmfTraceElement) projectElement;
                            // Instantiate the experiment trace
                            ITmfTrace trace = traceElement.instantiateTrace();
                            TmfEvent traceEvent = traceElement.instantiateEvent();
                            if (trace == null || traceEvent == null) {
                                throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
                            }
                            try {
                                trace.initTrace(traceElement.getName(), traceElement.getLocation().getPath(), traceEvent.getClass(), false);
                            } catch (FileNotFoundException e) {
                            }
                            trace.setResource(traceElement.getResource());
                            ITmfTrace[] traces = new ITmfTrace[] { trace };
                            TmfExperiment experiment = new TmfExperiment(traceEvent.getClass(), traceElement.getName(), traces, trace.getCacheSize());
                            experiment.setBookmarksFile(fFile);
                            fTrace = experiment;
                            TmfExperiment.setCurrentExperiment(experiment);
                            TmfSignalManager.dispatchSignal(new TmfExperimentSelectedSignal(this, experiment));
                            break;
                        }
                    }
                } else {
                    TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
                    ncp.getChildren(fFile.getProject()); // force the model to be populated
                    TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
                    for (ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
                        if (projectElement.getResource().equals(fFile)) {
                            TmfTraceElement traceElement = (TmfTraceElement) projectElement;
                            // Instantiate the experiment trace
                            ITmfTrace trace = traceElement.instantiateTrace();
                            TmfEvent traceEvent = traceElement.instantiateEvent();
                            if (trace == null || traceEvent == null) {
                                throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
                            }
                            try {
                                trace.initTrace(traceElement.getName(), traceElement.getLocation().getPath(), traceEvent.getClass(), true);
                            } catch (FileNotFoundException e) {
                            }
                            if (trace instanceof TmfTrace) {
                                ((TmfTrace) trace).setResource(traceElement.getResource());
                            }
                            ITmfTrace[] traces = new ITmfTrace[] { trace };
                            TmfExperiment experiment = new TmfExperiment(traceEvent.getClass(), traceElement.getName(), traces, trace.getCacheSize());
                            experiment.setBookmarksFile(fFile);
                            fTrace = experiment;
                            TmfExperiment.setCurrentExperiment(experiment);
                            TmfSignalManager.dispatchSignal(new TmfExperimentSelectedSignal(this, experiment));
                            break;
                        }
                    }
                }
            } catch (InvalidRegistryObjectException e) {
                e.printStackTrace();
            } catch (PartInitException e) {
                throw e;
            } catch (CoreException e) {
                e.printStackTrace();
            }
            input = new TmfEditorInput(fFile, fTrace);
        } else {
            throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
        }
        if (fTrace == null) {
            throw new PartInitException("Invalid IEditorInput: " + fFile.getName()); //$NON-NLS-1$
        }
        super.setSite(site);
        super.setInput(input);
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.ui.part.EditorPart#isDirty()
     */
    @Override
    public boolean isDirty() {
        return false;
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.ui.part.EditorPart#isSaveAsAllowed()
     */
    @Override
    public boolean isSaveAsAllowed() {
        return false;
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)
     */
    @Override
    public void createPartControl(Composite parent) {
        setPartName(getEditorInput().getName());
    }

    /*
     * (non-Javadoc)
     * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
     */
    @Override
    public void setFocus() {
        Display.getDefault().asyncExec(new Runnable() {
            @Override
            public void run() {
                EditorPart editorPart = EventsViewEditor.this;
                IWorkbenchPage page = editorPart.getEditorSite().getPage();
                page.closeEditor(editorPart, false);
                if (page.getEditorReferences().length == 0) {
                    page.setEditorAreaVisible(fEditorAreaVisible);
                }
                try {
                    IViewPart viewPart = page.showView(TmfEventsView.ID);
                    if (fGotoMarker != null) {
                        IGotoMarker adapter = (IGotoMarker) viewPart.getAdapter(IGotoMarker.class);
                        if (adapter != null) {
                            adapter.gotoMarker(fGotoMarker);
                        }
                    }
                } catch (PartInitException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.part.WorkbenchPart#getAdapter(java.lang.Class)
     */
    @SuppressWarnings("rawtypes")
    @Override
    public Object getAdapter(Class adapter) {
        if (IGotoMarker.class.equals(adapter)) {
            return new IGotoMarker() {
                @Override
                public void gotoMarker(IMarker marker) {
                    fGotoMarker = marker;
                }
            };
        }
        return super.getAdapter(adapter);
    }

}
Commit	Line	Data
09d11238 PT	1	/*******************************************************************************
	2	* Copyright (c) 2012 Ericsson
	3	*
	4	* All rights reserved. This program and the accompanying materials are
	5	* made available under the terms of the Eclipse Public License v1.0 which
	6	* accompanies this distribution, and is available at
	7	* http://www.eclipse.org/legal/epl-v10.html
	8	*
	9	* Contributors:
	10	* Patrick Tasse - Initial API and implementation
	11	*******************************************************************************/
	12
	13	package org.eclipse.linuxtools.tmf.ui.editors;
	14
	15	import java.io.FileNotFoundException;
	16	import java.util.List;
	17
a1091415	18	import org.eclipse.core.resources.IFile;
09d11238	19	import org.eclipse.core.resources.IMarker;
09d11238 PT	20	import org.eclipse.core.runtime.CoreException;
	21	import org.eclipse.core.runtime.IProgressMonitor;
	22	import org.eclipse.core.runtime.InvalidRegistryObjectException;
	23	import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
	24	import org.eclipse.linuxtools.tmf.core.experiment.TmfExperiment;
	25	import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
	26	import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager;
	27	import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
	28	import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
	29	import org.eclipse.linuxtools.tmf.ui.project.handlers.Messages;
	30	import org.eclipse.linuxtools.tmf.ui.project.model.ITmfProjectModelElement;
	31	import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
	32	import org.eclipse.linuxtools.tmf.ui.project.model.TmfNavigatorContentProvider;
	33	import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectElement;
	34	import org.eclipse.linuxtools.tmf.ui.project.model.TmfProjectRegistry;
	35	import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
	36	import org.eclipse.linuxtools.tmf.ui.views.events.TmfEventsView;
	37	import org.eclipse.swt.widgets.Composite;
	38	import org.eclipse.swt.widgets.Display;
	39	import org.eclipse.ui.IEditorInput;
	40	import org.eclipse.ui.IEditorSite;
	41	import org.eclipse.ui.IFileEditorInput;
	42	import org.eclipse.ui.IViewPart;
	43	import org.eclipse.ui.IWorkbenchPage;
	44	import org.eclipse.ui.PartInitException;
	45	import org.eclipse.ui.ide.IGotoMarker;
	46	import org.eclipse.ui.part.EditorPart;
	47
	48	/**
	49	*
	50	* This editor is used to open a trace in the Events view
	51	* and set the trace as the current experiment.
	52	* It intercepts the IGotoMarker adapter and dispatches
	53	* the handling to the Events view' events table.
	54	* The editor then closes itself and hides the
	55	* editor area if no other editor is open.
	56	*
	57	*/
	58	public class EventsViewEditor extends TmfEditor {
	59
	60	/**
	61	* The editor ID
	62	*/
	63	public static final String ID = "org.eclipse.linuxtools.tmf.ui.editors.eventsView"; //$NON-NLS-1$
	64
a1091415	65	private IFile fFile;
09d11238 PT	66	@SuppressWarnings("rawtypes")
	67	private ITmfTrace fTrace;
	68	private IMarker fGotoMarker;
	69	private boolean fEditorAreaVisible;
	70
	71	/*
	72	* (non-Javadoc)
	73	* @see org.eclipse.ui.part.EditorPart#doSave(org.eclipse.core.runtime.IProgressMonitor)
	74	*/
	75	@Override
	76	public void doSave(IProgressMonitor monitor) {
	77	}
	78
	79	@Override
	80	public void doSaveAs() {
	81	}
	82
	83	/*
	84	* (non-Javadoc)
	85	* @see org.eclipse.ui.part.EditorPart#init(org.eclipse.ui.IEditorSite, org.eclipse.ui.IEditorInput)
	86	*/
	87	@SuppressWarnings({ "unchecked", "rawtypes" })
	88	@Override
	89	public void init(IEditorSite site, IEditorInput input) throws PartInitException {
	90	fEditorAreaVisible = site.getPage().isEditorAreaVisible();
	91	if (input instanceof TmfEditorInput) {
a1091415	92	fFile = ((TmfEditorInput) input).getFile();
09d11238 PT	93	fTrace = ((TmfEditorInput) input).getTrace();
09d11238 PT	94	} else if (input instanceof IFileEditorInput) {
a1091415 PT	95	fFile = ((IFileEditorInput) input).getFile();
a1091415 PT	96	if (fFile == null) {
09d11238 PT	97	throw new PartInitException("Invalid IFileEditorInput: " + input); //$NON-NLS-1$
	98	}
	99	TmfExperiment currentExperiment = TmfExperiment.getCurrentExperiment();
a1091415	100	if (currentExperiment != null && fFile.equals(currentExperiment.getBookmarksFile())) {
09d11238 PT	101	fTrace = currentExperiment;
	102	super.setSite(site);
	103	super.setInput(input);
	104	return;
	105	}
	106	try {
a1091415	107	String traceTypeId = fFile.getPersistentProperty(TmfTraceElement.TRACETYPE);
09d11238 PT	108	if (traceTypeId == null) {
	109	throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
	110	}
	111	if (traceTypeId.equals(TmfExperiment.class.getCanonicalName())) {
	112	// Special case: experiment bookmark resource
	113	TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
a1091415 PT	114	ncp.getChildren(fFile.getProject()); // force the model to be populated
a1091415 PT	115	TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
09d11238 PT	116	if (project == null) {
	117	throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
	118	}
	119	for (ITmfProjectModelElement projectElement : project.getExperimentsFolder().getChildren()) {
a1091415	120	String traceName = fFile.getParent().getName();
09d11238 PT	121	if (projectElement.getName().equals(traceName)) {
	122	TmfExperimentElement experimentElement = (TmfExperimentElement) projectElement;
	123	// Instantiate the experiment's traces
	124	List<TmfTraceElement> traceEntries = experimentElement.getTraces();
	125	int nbTraces = traceEntries.size();
	126	int cacheSize = Integer.MAX_VALUE;
	127	ITmfTrace<?>[] traces = new ITmfTrace[nbTraces];
	128	for (int i = 0; i < nbTraces; i++) {
	129	TmfTraceElement traceElement = traceEntries.get(i);
	130	ITmfTrace trace = traceElement.instantiateTrace();
	131	TmfEvent traceEvent = traceElement.instantiateEvent();
	132	if (trace == null \|\| traceEvent == null) {
	133	for (int j = 0; j < i; j++) {
	134	traces[j].dispose();
	135	}
	136	throw new PartInitException(Messages.OpenExperimentHandler_NoTraceType);
	137	}
	138	try {
0710697b	139	trace.initTrace(traceElement.getName(), traceElement.getLocation().getPath(), traceEvent.getClass(), false);
09d11238 PT	140	} catch (FileNotFoundException e) {
09d11238 PT	141	}
a1091415	142	trace.setResource(traceElement.getResource());
09d11238 PT	143	cacheSize = Math.min(cacheSize, trace.getCacheSize());
	144	traces[i] = trace;
	145	}
	146	TmfExperiment experiment = new TmfExperiment(TmfEvent.class, experimentElement.getName(), traces, cacheSize);
a1091415	147	experiment.setBookmarksFile(fFile);
09d11238 PT	148	fTrace = experiment;
	149	TmfExperiment.setCurrentExperiment(experiment);
	150	TmfSignalManager.dispatchSignal(new TmfExperimentSelectedSignal(this, experiment));
	151	break;
	152	}
	153	}
	154	} else if (traceTypeId.equals(TmfTrace.class.getCanonicalName())) {
	155	// Special case: trace bookmark resource
	156	TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
a1091415 PT	157	ncp.getChildren(fFile.getProject()); // force the model to be populated
a1091415 PT	158	TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
09d11238	159	for (ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
a1091415	160	String traceName = fFile.getParent().getName();
09d11238 PT	161	if (projectElement.getName().equals(traceName)) {
	162	TmfTraceElement traceElement = (TmfTraceElement) projectElement;
	163	// Instantiate the experiment trace
	164	ITmfTrace trace = traceElement.instantiateTrace();
	165	TmfEvent traceEvent = traceElement.instantiateEvent();
	166	if (trace == null \|\| traceEvent == null) {
	167	throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
	168	}
	169	try {
0710697b	170	trace.initTrace(traceElement.getName(), traceElement.getLocation().getPath(), traceEvent.getClass(), false);
09d11238 PT	171	} catch (FileNotFoundException e) {
09d11238 PT	172	}
a1091415	173	trace.setResource(traceElement.getResource());
09d11238 PT	174	ITmfTrace[] traces = new ITmfTrace[] { trace };
09d11238 PT	175	TmfExperiment experiment = new TmfExperiment(traceEvent.getClass(), traceElement.getName(), traces, trace.getCacheSize());
a1091415	176	experiment.setBookmarksFile(fFile);
09d11238 PT	177	fTrace = experiment;
	178	TmfExperiment.setCurrentExperiment(experiment);
	179	TmfSignalManager.dispatchSignal(new TmfExperimentSelectedSignal(this, experiment));
	180	break;
	181	}
	182	}
	183	} else {
	184	TmfNavigatorContentProvider ncp = new TmfNavigatorContentProvider();
a1091415 PT	185	ncp.getChildren(fFile.getProject()); // force the model to be populated
a1091415 PT	186	TmfProjectElement project = TmfProjectRegistry.getProject(fFile.getProject());
09d11238	187	for (ITmfProjectModelElement projectElement : project.getTracesFolder().getChildren()) {
a1091415	188	if (projectElement.getResource().equals(fFile)) {
09d11238 PT	189	TmfTraceElement traceElement = (TmfTraceElement) projectElement;
	190	// Instantiate the experiment trace
	191	ITmfTrace trace = traceElement.instantiateTrace();
	192	TmfEvent traceEvent = traceElement.instantiateEvent();
	193	if (trace == null \|\| traceEvent == null) {
	194	throw new PartInitException(Messages.OpenTraceHandler_NoTraceType);
	195	}
	196	try {
0710697b	197	trace.initTrace(traceElement.getName(), traceElement.getLocation().getPath(), traceEvent.getClass(), true);
09d11238 PT	198	} catch (FileNotFoundException e) {
	199	}
	200	if (trace instanceof TmfTrace) {
	201	((TmfTrace) trace).setResource(traceElement.getResource());
	202	}
	203	ITmfTrace[] traces = new ITmfTrace[] { trace };
	204	TmfExperiment experiment = new TmfExperiment(traceEvent.getClass(), traceElement.getName(), traces, trace.getCacheSize());
a1091415	205	experiment.setBookmarksFile(fFile);
09d11238 PT	206	fTrace = experiment;
	207	TmfExperiment.setCurrentExperiment(experiment);
	208	TmfSignalManager.dispatchSignal(new TmfExperimentSelectedSignal(this, experiment));
	209	break;
	210	}
	211	}
	212	}
	213	} catch (InvalidRegistryObjectException e) {
	214	e.printStackTrace();
	215	} catch (PartInitException e) {
	216	throw e;
	217	} catch (CoreException e) {
	218	e.printStackTrace();
	219	}
a1091415	220	input = new TmfEditorInput(fFile, fTrace);
09d11238 PT	221	} else {
	222	throw new PartInitException("Invalid IEditorInput: " + input.getClass()); //$NON-NLS-1$
	223	}
	224	if (fTrace == null) {
a1091415	225	throw new PartInitException("Invalid IEditorInput: " + fFile.getName()); //$NON-NLS-1$
09d11238 PT	226	}
	227	super.setSite(site);
	228	super.setInput(input);
	229	}
	230
	231	/*
	232	* (non-Javadoc)
	233	* @see org.eclipse.ui.part.EditorPart#isDirty()
	234	*/
	235	@Override
	236	public boolean isDirty() {
	237	return false;
	238	}
	239
	240	/*
	241	* (non-Javadoc)
	242	* @see org.eclipse.ui.part.EditorPart#isSaveAsAllowed()
	243	*/
	244	@Override
	245	public boolean isSaveAsAllowed() {
	246	return false;
	247	}
	248
	249	/*
	250	* (non-Javadoc)
	251	* @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)
	252	*/
	253	@Override
	254	public void createPartControl(Composite parent) {
	255	setPartName(getEditorInput().getName());
	256	}
	257
	258	/*
	259	* (non-Javadoc)
	260	* @see org.eclipse.ui.part.WorkbenchPart#setFocus()
	261	*/
	262	@Override
	263	public void setFocus() {
	264	Display.getDefault().asyncExec(new Runnable() {
	265	@Override
	266	public void run() {
	267	EditorPart editorPart = EventsViewEditor.this;
	268	IWorkbenchPage page = editorPart.getEditorSite().getPage();
	269	page.closeEditor(editorPart, false);
	270	if (page.getEditorReferences().length == 0) {
	271	page.setEditorAreaVisible(fEditorAreaVisible);
	272	}
	273	try {
	274	IViewPart viewPart = page.showView(TmfEventsView.ID);
	275	if (fGotoMarker != null) {
	276	IGotoMarker adapter = (IGotoMarker) viewPart.getAdapter(IGotoMarker.class);
	277	if (adapter != null) {
	278	adapter.gotoMarker(fGotoMarker);
	279	}
	280	}
	281	} catch (PartInitException e) {
	282	e.printStackTrace();
	283	}
	284	}
	285	});
	286	}
	287
	288	/* (non-Javadoc)
	289	* @see org.eclipse.ui.part.WorkbenchPart#getAdapter(java.lang.Class)
290	*/
291	@SuppressWarnings("rawtypes")
292	@Override
293	public Object getAdapter(Class adapter) {
294	if (IGotoMarker.class.equals(adapter)) {
295	return new IGotoMarker() {
296	@Override
297	public void gotoMarker(IMarker marker) {
298	fGotoMarker = marker;
299	}
300	};
301	}
302	return super.getAdapter(adapter);
303	}
304
305	}