Attachment #25620 for bug #96129

View | Details | Raw Unified | Return to bug 96129 | Differences between

and this patch




        return null;
    }

    /**
     * Create the part and reference for each inner editor.
     * 
     * @param ref the MultiEditor ref
     * @param part the part
     * @param input the MultiEditor input
     * @return the array of inner references to store in the MultiEditor ref
     */
    IEditorReference[] openMultiEditor(final IEditorReference ref,
            final MultiEditor part, 
            final MultiEditorInput input)
            throws PartInitException {

        String[] editorArray = input.getEditors();

Lines 44-49 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/EditorReference.java (-3 / +38 lines)
44	import org.eclipse.ui.internal.registry.EditorDescriptor;	44	import org.eclipse.ui.internal.registry.EditorDescriptor;
45	import org.eclipse.ui.internal.util.Util;	45	import org.eclipse.ui.internal.util.Util;
46	import org.eclipse.ui.part.IWorkbenchPartOrientation;	46	import org.eclipse.ui.part.IWorkbenchPartOrientation;
		47	import org.eclipse.ui.part.MultiEditor;
		48	import org.eclipse.ui.part.MultiEditorInput;
47	import org.eclipse.ui.presentations.IPresentablePart;	49	import org.eclipse.ui.presentations.IPresentablePart;
48		50
49	public class EditorReference extends WorkbenchPartReference implements	51	public class EditorReference extends WorkbenchPartReference implements
Lines 80-85 Link Here
80		82
81	IEditorInput restoredInput;	83	IEditorInput restoredInput;
82		84
		85	/**
		86	* If the reference is instantiated as a MultiEditor, we need to dispose the
		87	* inner references correctly.
		88	*/
		89	private IEditorReference[] multiEditorChildren = null;
		90
		91
83	public EditorReference(EditorManager manager, IEditorInput input, EditorDescriptor desc) {	92	public EditorReference(EditorManager manager, IEditorInput input, EditorDescriptor desc) {
84	this.manager = manager;	93	this.manager = manager;
85	initListenersAndHandlers();	94	initListenersAndHandlers();
Lines 241-247 Link Here
241	}	250	}
242		251
243	protected void doDisposePart() {	252	protected void doDisposePart() {
244	if (part != null) {	253	if (multiEditorChildren!=null) {
		254	for (int i=0; i<multiEditorChildren.length; ++i) {
		255	EditorReference ref = (EditorReference)multiEditorChildren[i];
		256	if (ref!=null) {
		257	ref.dispose();
		258	}
		259	}
		260	multiEditorChildren = null;
		261	}
		262
		263	if (part != null) {
245	EditorSite site = (EditorSite) ((IEditorPart)part).getEditorSite();	264	EditorSite site = (EditorSite) ((IEditorPart)part).getEditorSite();
246	manager.disposeEditorActionBars((EditorActionBars) site.getActionBars());	265	manager.disposeEditorActionBars((EditorActionBars) site.getActionBars());
247	site.dispose();	266	site.dispose();
Lines 534-540 Link Here
534	throw new PartInitException(NLS.bind(WorkbenchMessages.EditorManager_missing_editor_descriptor, editorID)); //$NON-NLS-1$	553	throw new PartInitException(NLS.bind(WorkbenchMessages.EditorManager_missing_editor_descriptor, editorID)); //$NON-NLS-1$
535	}	554	}
536		555
537	IEditorPart part;	556	IEditorPart part = null;
538		557
539	if (desc.isInternal()) {	558	if (desc.isInternal()) {
540	// Create an editor instance.	559	// Create an editor instance.
Lines 545-550 Link Here
545	UIStats.end(UIStats.CREATE_PART, this, editorID);	564	UIStats.end(UIStats.CREATE_PART, this, editorID);
546	}	565	}
547		566
		567	if (part != null && part instanceof MultiEditor) {
		568	multiEditorChildren = manager.openMultiEditor(this,
		569	(MultiEditor) part, (MultiEditorInput) editorInput);
		570	}
		571
548	} else if (desc.getId().equals(	572	} else if (desc.getId().equals(
549	IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID)) {	573	IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID)) {
550		574
Lines 635-638 Link Here
635		659
636	}	660	}
637		661
638	}	662	/**
		663	* A quick way of finding out if this reference points to a MultiEditor.
		664	* It depends on the fact that a MultiEditor does not lazily
		665	* instantiate it's child editors.
		666	*
		667	* @return true if it has inner editor reference or the input is
		668	* MultiEditorInput.
		669	*/
		670	public boolean isMultiReference() {
		671	return multiEditorChildren!=null \|\| restoredInput instanceof MultiEditorInput;
		672	}
		673	}




import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartConstants;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.part.MultiEditor;

public abstract class PartList {
    private IWorkbenchPartReference activePartReference;

    }
    
    public IEditorPart getActiveEditor() {
    	return (IEditorPart)getPart(activeEditorReference);
    }
    
    public IWorkbenchPart getActivePart() {

     * @param ref
     */
    public void setActivePart(IWorkbenchPartReference ref) {
 		if (ref == activePartReference && !isMultiReference(ref)) {
			return;
		}
        
        IWorkbenchPartReference oldPart = activePartReference;
        

    }
    
    public void setActiveEditor(IEditorReference ref) {
		if (ref == activePartReference && !isMultiReference(ref)) {
			return;
		}
        
        // A part can't be activated until it is added
        //Assert.isTrue(ref == null || parts.contains(ref));

    }
    
    /**
     * Return the part for this reference.  A convenience method
     * that handles <code>null</code> cases.
     * 
     * Try and deal with the MultiEditor ... which has implications for
     * which "part" the partListeners should be notified about.
     * 
     * @param ref The reference that might contain a MultiEditor.  This
     * can be <code>null</code>.
     * @return the workbench part, the inner part if it's a MultiEditor,
     * or <code>null</code> if the reference was <code>null</code> or
     * the part hadn't been activated yet.
     */
    protected IWorkbenchPart getPart(IWorkbenchPartReference ref) {
		if (ref==null) {
			return null;
		}
		IWorkbenchPart part = ref.getPart(false);
		if (part != null && part instanceof MultiEditor) {
			part = ((MultiEditor) part).getActiveEditor();
		}
		return part;
	}

	/**
	 * Check a reference to see if it's a ref to a MultiEditor.
	 * @param ref the reference to check.  It can be <code>null</code>.
	 * @return true if the reference is to a MultiEditor.
	 */
	protected boolean isMultiReference(IWorkbenchPartReference ref) {
		return ref instanceof EditorReference
				&& ((EditorReference) ref).isMultiReference();
	}
    
    /**
     * Fire the event indicating that a part reference was just realized. That is, the concrete
     * IWorkbenchPart has been attached to the part reference.
     *




import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.internal.misc.UIListenerLogging;
import org.eclipse.ui.part.MultiEditor;

public class PartService implements IPartService {
    private PartListenerList listeners = new PartListenerList();

     * @param ref
     */
    private void firePartActivated(IWorkbenchPartReference ref) {
        IWorkbenchPart part = getPart(ref);
        if(part != null) {
            UIListenerLogging.logPartListenerEvent(debugListenersKey, this, part, UIListenerLogging.PE_ACTIVATED);
            listeners.firePartActivated(part);

     * @param ref
     */
    public void firePartBroughtToTop(IWorkbenchPartReference ref) {
        IWorkbenchPart part = getPart(ref);
        if(part != null) {
            UIListenerLogging.logPartListenerEvent(debugListenersKey, this, part, UIListenerLogging.PE_PART_BROUGHT_TO_TOP);
            listeners.firePartBroughtToTop(part);

     * @param ref
     */
    public void firePartClosed(IWorkbenchPartReference ref) {
        IWorkbenchPart part = getPart(ref);
        if(part != null) {
            UIListenerLogging.logPartListenerEvent(debugListenersKey, this, part, UIListenerLogging.PE_PART_CLOSED);
            listeners.firePartClosed(part);

     * @param ref
     */
    private void firePartDeactivated(IWorkbenchPartReference ref) {
        IWorkbenchPart part = getPart(ref);
        if(part != null) {
            UIListenerLogging.logPartListenerEvent(debugListenersKey, this, part, UIListenerLogging.PE_PART_DEACTIVATED);
            listeners.firePartDeactivated(part);

     * @param ref
     */
    public void firePartOpened(IWorkbenchPartReference ref) {  
        IWorkbenchPart part = getPart(ref);
        if(part != null) {
            UIListenerLogging.logPartListenerEvent(debugListenersKey, this, part, UIListenerLogging.PE_PART_OPENED);
            listeners.firePartOpened(part);

        IWorkbenchPartReference oldRef = activePart;
        
        // Filter out redundant activation events
        if (oldRef == ref && !isMultiReference(ref)) {
            return;
        }
        

        }
    }

    /**
     * Return the part for this reference.  A convenience method
     * that handles <code>null</code> cases.
     * 
     * Try and deal with the MultiEditor ... which has implications for
     * which "part" the partListeners should be notified about.
     * 
     * @param ref The reference that might contain a MultiEditor.  This
     * can be <code>null</code>.
     * @return the workbench part, the inner part if it's a MultiEditor,
     * or <code>null</code> if the reference was <code>null</code> or
     * the part hadn't been activated yet.
     */
	private IWorkbenchPart getPart(IWorkbenchPartReference ref) {
		if (ref==null) {
			return null;
		}
		IWorkbenchPart part = ref.getPart(false);
		if (part != null && part instanceof MultiEditor) {
			part = ((MultiEditor) part).getActiveEditor();
		}
		return part;
	}
	
	/**
	 * Check a reference to see if it's a ref to a MultiEditor.
	 * @param ref the reference to check.  It can be <code>null</code>.
	 * @return true if the reference is to a MultiEditor.
	 */
	private boolean isMultiReference(IWorkbenchPartReference ref) {
		return ref instanceof EditorReference
				&& ((EditorReference) ref).isMultiReference();
	}
}




        Platform.run(new SafeRunnable(WorkbenchMessages.WorkbenchPage_ErrorActivatingView) { 
                    public void run() {
                        if (part != null) {
                            part.setFocus();
                            PartPane pane = getPane(part);
                            pane.setFocus();
                            PartSite site = (PartSite) part.getSite();

     * @param ref the editor to make active, or <code>null</code> for no active editor
     */
    private void makeActiveEditor(IEditorReference ref) {
        if (ref == getActiveEditorReference() && !isMultiReference(ref)) {
			return;
		}
        
        IEditorPart part = (IEditorPart)getPart(ref, true);
        
        if (part != null) {
            editorMgr.setVisibleEditor(ref, true);
            navigationHistory.markEditor(part);
        }
        

        if (isZoomed())
            zoomOut();

        makeActiveEditor(null);
        makeActive(null);
        
        // Close and dispose the editors.

     * This method is called when the page is deactivated.
     */
    protected void onDeactivate() {
        makeActiveEditor(null);
        makeActive(null);
        if (getActivePerspective() != null)
            getActivePerspective().onDeactivate();

        if (!certifyPart(part))
            return;

        if (part!=null && part instanceof MultiEditor) {
        	part = ((MultiEditor)part).getActiveEditor();
        }
        
        // Real work.
        setActivePart(part);
    }

        }
        
        if (partBeingActivated != null) {
            if (getPart(partBeingActivated, false) != newPart) {
                WorkbenchPlugin.log(new RuntimeException(NLS.bind(
                        "WARNING: Prevented recursive attempt to activate part {0} while still in the middle of activating part {1}", //$NON-NLS-1$
                        getId(newPart), getId(partBeingActivated))));

            if (newPart != null) {
                activationList.setActive(newPart);
                if (newPart instanceof IEditorPart) {
                    makeActiveEditor((IEditorReference)partref);
                    makeActiveEditor(ref);
                }
            }
            activatePart(newPart);

         */
        void setActive(IWorkbenchPart part) {
            if (parts.size() <= 0)
				return;
			IWorkbenchPartReference ref = getReference(part);
			if (ref != null) {
				if (ref == parts.get(parts.size() - 1))
					return;
				parts.remove(ref);
				parts.add(ref);
			}
                if (ref != null) {
	                if (ref == parts.get(parts.size() - 1))
	                    return;
	                parts.remove(ref);
	                parts.add(ref);
                }
            }
        }
        
        /*
		 * Ensures that the given part appears AFTER any other part in the same
		 * container.
		 */
        void bringToTop(IWorkbenchPartReference ref) {
            ILayoutContainer targetContainer = getContainer(ref);
            

        
        return isPartVisible(part);
    }

    /**
     * Return the part for this reference.  A convenience method
     * that handles <code>null</code> cases.
     * 
     * Try and deal with the MultiEditor ... which has implications for
     * which "part" the partListeners should be notified about.
     * 
     * @param ref The reference that might contain a MultiEditor.  This
     * can be <code>null</code>.
     * @param restore <code>true</code> to restore the part
     * @return the workbench part, the inner part if it's a MultiEditor,
     * or <code>null</code> if the reference was <code>null</code> or
     * restore was <code>false</code> and the part hadn't been activated yet.
     */
    protected IWorkbenchPart getPart(IWorkbenchPartReference ref,
    		boolean restore) {
		if (ref==null) {
			return null;
		}
		IWorkbenchPart part = ref.getPart(restore);
		if (part != null && part instanceof MultiEditor) {
			part = ((MultiEditor) part).getActiveEditor();
		}
		return part;
	}

	/**
	 * Check a reference to see if it's a ref to a MultiEditor.
	 * @param ref the reference to check.  It can be <code>null</code>.
	 * @return true if the reference is to a MultiEditor.
	 */
	protected boolean isMultiReference(IWorkbenchPartReference ref) {
		return ref instanceof EditorReference
				&& ((EditorReference) ref).isMultiReference();
	}
}

Lines 55-61 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/WorkbenchPagePartList.java (-1 / +1 lines)
55	protected void fireActivePartChanged(IWorkbenchPartReference oldRef, IWorkbenchPartReference newRef) {	55	protected void fireActivePartChanged(IWorkbenchPartReference oldRef, IWorkbenchPartReference newRef) {
56	partService.setActivePart(newRef);	56	partService.setActivePart(newRef);
57		57
58	IWorkbenchPart realPart = newRef == null? null : newRef.getPart(false);	58	IWorkbenchPart realPart = getPart(newRef);
59	selectionService.setActivePart(realPart);	59	selectionService.setActivePart(realPart);
60	}	60	}
61		61




        return content;
    }

    /**
     * The <code>MultiEditor</code> implementation of this 
     * method extends the <code>EditorPart</code> implementation,
     * and disposes any inner editors.  Subclasses may extend.
     * 
     * @since 3.0
     */
    public void dispose() {
        super.dispose();
        IEditorPart[] editors = getInnerEditors();
        for (int i = 0; i < editors.length; i++) {
            editors[i].dispose();
        }
    }

    /*
     * @see IEditorPart#doSaveAs()
     */

Return to bug 96129

Lines 713-724 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/EditorManager.java (-6 / +11 lines)
713	return null;	713	return null;
714	}	714	}
715		715
716	/*	716	/**
717	* Create the site and action bars for each inner editor.	717	* Create the part and reference for each inner editor.
718	*/	718	*
719	private IEditorReference[] openMultiEditor(final IEditorReference ref,	719	* @param ref the MultiEditor ref
720	final MultiEditor part, final EditorDescriptor desc,	720	* @param part the part
721	final MultiEditorInput input, final boolean setVisible)	721	* @param input the MultiEditor input
		722	* @return the array of inner references to store in the MultiEditor ref
		723	*/
		724	IEditorReference[] openMultiEditor(final IEditorReference ref,
		725	final MultiEditor part,
		726	final MultiEditorInput input)
722	throws PartInitException {	727	throws PartInitException {
723		728
724	String[] editorArray = input.getEditors();	729	String[] editorArray = input.getEditors();

Lines 559-565 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/WorkbenchPage.java (-27 / +61 lines)
559	Platform.run(new SafeRunnable(WorkbenchMessages.WorkbenchPage_ErrorActivatingView) {	559	Platform.run(new SafeRunnable(WorkbenchMessages.WorkbenchPage_ErrorActivatingView) {
560	public void run() {	560	public void run() {
561	if (part != null) {	561	if (part != null) {
562	//part.setFocus();	562	part.setFocus();
563	PartPane pane = getPane(part);	563	PartPane pane = getPane(part);
564	pane.setFocus();	564	pane.setFocus();
565	PartSite site = (PartSite) part.getSite();	565	PartSite site = (PartSite) part.getSite();
Lines 1101-1114 Link Here
1101	* @param ref the editor to make active, or <code>null</code> for no active editor	1101	* @param ref the editor to make active, or <code>null</code> for no active editor
1102	*/	1102	*/
1103	private void makeActiveEditor(IEditorReference ref) {	1103	private void makeActiveEditor(IEditorReference ref) {
1104	if (ref == getActiveEditor()) {	1104	if (ref == getActiveEditorReference() && !isMultiReference(ref)) {
1105	return;	1105	return;
1106	}	1106	}
1107		1107
1108	IEditorPart part = (ref == null) ? null : ref.getEditor(true);	1108	IEditorPart part = (IEditorPart)getPart(ref, true);
1109		1109
1110	if (part != null) {	1110	if (part != null) {
1111	editorMgr.setVisibleEditor(ref, false);	1111	editorMgr.setVisibleEditor(ref, true);
1112	navigationHistory.markEditor(part);	1112	navigationHistory.markEditor(part);
1113	}	1113	}
1114		1114
Lines 1473-1478 Link Here
1473	if (isZoomed())	1473	if (isZoomed())
1474	zoomOut();	1474	zoomOut();
1475		1475
		1476	makeActiveEditor(null);
1476	makeActive(null);	1477	makeActive(null);
1477		1478
1478	// Close and dispose the editors.	1479	// Close and dispose the editors.
Lines 2171-2176 Link Here
2171	* This method is called when the page is deactivated.	2172	* This method is called when the page is deactivated.
2172	*/	2173	*/
2173	protected void onDeactivate() {	2174	protected void onDeactivate() {
		2175	makeActiveEditor(null);
2174	makeActive(null);	2176	makeActive(null);
2175	if (getActivePerspective() != null)	2177	if (getActivePerspective() != null)
2176	getActivePerspective().onDeactivate();	2178	getActivePerspective().onDeactivate();
Lines 2467-2472 Link Here
2467	if (!certifyPart(part))	2469	if (!certifyPart(part))
2468	return;	2470	return;
2469		2471
		2472	if (part!=null && part instanceof MultiEditor) {
		2473	part = ((MultiEditor)part).getActiveEditor();
		2474	}
		2475
2470	// Real work.	2476	// Real work.
2471	setActivePart(part);	2477	setActivePart(part);
2472	}	2478	}
Lines 2814-2820 Link Here
2814	}	2820	}
2815		2821
2816	if (partBeingActivated != null) {	2822	if (partBeingActivated != null) {
2817	if (partBeingActivated.getPart(false) != newPart) {	2823	if (getPart(partBeingActivated, false) != newPart) {
2818	WorkbenchPlugin.log(new RuntimeException(NLS.bind(	2824	WorkbenchPlugin.log(new RuntimeException(NLS.bind(
2819	"WARNING: Prevented recursive attempt to activate part {0} while still in the middle of activating part {1}", //$NON-NLS-1$	2825	"WARNING: Prevented recursive attempt to activate part {0} while still in the middle of activating part {1}", //$NON-NLS-1$
2820	getId(newPart), getId(partBeingActivated))));	2826	getId(newPart), getId(partBeingActivated))));
Lines 2848-2855 Link Here
2848	if (newPart != null) {	2854	if (newPart != null) {
2849	activationList.setActive(newPart);	2855	activationList.setActive(newPart);
2850	if (newPart instanceof IEditorPart) {	2856	if (newPart instanceof IEditorPart) {
2851	IEditorReference ref = (IEditorReference) getReference(newPart);	2857	makeActiveEditor((IEditorReference)partref);
2852	makeActiveEditor(ref);
2853	}	2858	}
2854	}	2859	}
2855	activatePart(newPart);	2860	activatePart(newPart);
Lines 3471-3497 Link Here
3471	*/	3476	*/
3472	void setActive(IWorkbenchPart part) {	3477	void setActive(IWorkbenchPart part) {
3473	if (parts.size() <= 0)	3478	if (parts.size() <= 0)
3474	return;	3479	return;
3475	PartPane pane = ((PartSite) part.getSite()).getPane();	3480	IWorkbenchPartReference ref = getReference(part);
3476	if (pane instanceof MultiEditorInnerPane) {	3481	if (ref != null) {
3477	MultiEditorInnerPane innerPane = (MultiEditorInnerPane) pane;	3482	if (ref == parts.get(parts.size() - 1))
3478	setActive(innerPane.getParentPane().getPartReference().getPart(	3483	return;
3479	true));	3484	parts.remove(ref);
3480	} else {	3485	parts.add(ref);
3481	IWorkbenchPartReference ref = getReference(part);	3486	}
3482	if (ref != null) {
3483	if (ref == parts.get(parts.size() - 1))
3484	return;
3485	parts.remove(ref);
3486	parts.add(ref);
3487	}
3488	}
3489	}	3487	}
3490		3488
3491	/*	3489	/*
3492	* Ensures that the given part appears AFTER any other part in the same	3490	* Ensures that the given part appears AFTER any other part in the same
3493	* container.	3491	* container.
3494	*/	3492	*/
3495	void bringToTop(IWorkbenchPartReference ref) {	3493	void bringToTop(IWorkbenchPartReference ref) {
3496	ILayoutContainer targetContainer = getContainer(ref);	3494	ILayoutContainer targetContainer = getContainer(ref);
3497		3495
Lines 4286-4289 Link Here
4286		4284
4287	return isPartVisible(part);	4285	return isPartVisible(part);
4288	}	4286	}
		4287
		4288	/**
		4289	* Return the part for this reference. A convenience method
		4290	* that handles <code>null</code> cases.
		4291	*
		4292	* Try and deal with the MultiEditor ... which has implications for
		4293	* which "part" the partListeners should be notified about.
		4294	*
		4295	* @param ref The reference that might contain a MultiEditor. This
		4296	* can be <code>null</code>.
		4297	* @param restore <code>true</code> to restore the part
		4298	* @return the workbench part, the inner part if it's a MultiEditor,
		4299	* or <code>null</code> if the reference was <code>null</code> or
		4300	* restore was <code>false</code> and the part hadn't been activated yet.
		4301	*/
		4302	protected IWorkbenchPart getPart(IWorkbenchPartReference ref,
		4303	boolean restore) {
		4304	if (ref==null) {
		4305	return null;
		4306	}
		4307	IWorkbenchPart part = ref.getPart(restore);
		4308	if (part != null && part instanceof MultiEditor) {
		4309	part = ((MultiEditor) part).getActiveEditor();
		4310	}
		4311	return part;
		4312	}
		4313
		4314	/**
		4315	* Check a reference to see if it's a ref to a MultiEditor.
		4316	* @param ref the reference to check. It can be <code>null</code>.
		4317	* @return true if the reference is to a MultiEditor.
		4318	*/
		4319	protected boolean isMultiReference(IWorkbenchPartReference ref) {
		4320	return ref instanceof EditorReference
		4321	&& ((EditorReference) ref).isMultiReference();
		4322	}
4289	}	4323	}

Lines 17-22 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/PartList.java (-7 / +42 lines)
17	import org.eclipse.ui.IWorkbenchPart;	17	import org.eclipse.ui.IWorkbenchPart;
18	import org.eclipse.ui.IWorkbenchPartConstants;	18	import org.eclipse.ui.IWorkbenchPartConstants;
19	import org.eclipse.ui.IWorkbenchPartReference;	19	import org.eclipse.ui.IWorkbenchPartReference;
		20	import org.eclipse.ui.part.MultiEditor;
20		21
21	public abstract class PartList {	22	public abstract class PartList {
22	private IWorkbenchPartReference activePartReference;	23	private IWorkbenchPartReference activePartReference;
Lines 57-63 Link Here
57	}	58	}
58		59
59	public IEditorPart getActiveEditor() {	60	public IEditorPart getActiveEditor() {
60	return activeEditorReference == null ? null :activeEditorReference.getEditor(false);	61	return (IEditorPart)getPart(activeEditorReference);
61	}	62	}
62		63
63	public IWorkbenchPart getActivePart() {	64	public IWorkbenchPart getActivePart() {
Lines 89-97 Link Here
89	* @param ref	90	* @param ref
90	*/	91	*/
91	public void setActivePart(IWorkbenchPartReference ref) {	92	public void setActivePart(IWorkbenchPartReference ref) {
92	if (ref == activePartReference) {	93	if (ref == activePartReference && !isMultiReference(ref)) {
93	return;	94	return;
94	}	95	}
95		96
96	IWorkbenchPartReference oldPart = activePartReference;	97	IWorkbenchPartReference oldPart = activePartReference;
97		98
Lines 109-117 Link Here
109	}	110	}
110		111
111	public void setActiveEditor(IEditorReference ref) {	112	public void setActiveEditor(IEditorReference ref) {
112	if (ref == activeEditorReference) {	113	if (ref == activePartReference && !isMultiReference(ref)) {
113	return;	114	return;
114	}	115	}
115		116
116	// A part can't be activated until it is added	117	// A part can't be activated until it is added
117	//Assert.isTrue(ref == null \|\| parts.contains(ref));	118	//Assert.isTrue(ref == null \|\| parts.contains(ref));
Lines 226-231 Link Here
226	}	227	}
227		228
228	/**	229	/**
		230	* Return the part for this reference. A convenience method
		231	* that handles <code>null</code> cases.
		232	*
		233	* Try and deal with the MultiEditor ... which has implications for
		234	* which "part" the partListeners should be notified about.
		235	*
		236	* @param ref The reference that might contain a MultiEditor. This
		237	* can be <code>null</code>.
		238	* @return the workbench part, the inner part if it's a MultiEditor,
		239	* or <code>null</code> if the reference was <code>null</code> or
		240	* the part hadn't been activated yet.
		241	*/
		242	protected IWorkbenchPart getPart(IWorkbenchPartReference ref) {
		243	if (ref==null) {
		244	return null;
		245	}
		246	IWorkbenchPart part = ref.getPart(false);
		247	if (part != null && part instanceof MultiEditor) {
		248	part = ((MultiEditor) part).getActiveEditor();
		249	}
		250	return part;
		251	}
		252
		253	/**
		254	* Check a reference to see if it's a ref to a MultiEditor.
		255	* @param ref the reference to check. It can be <code>null</code>.
		256	* @return true if the reference is to a MultiEditor.
		257	*/
		258	protected boolean isMultiReference(IWorkbenchPartReference ref) {
		259	return ref instanceof EditorReference
		260	&& ((EditorReference) ref).isMultiReference();
		261	}
		262
		263	/**
229	* Fire the event indicating that a part reference was just realized. That is, the concrete	264	* Fire the event indicating that a part reference was just realized. That is, the concrete
230	* IWorkbenchPart has been attached to the part reference.	265	* IWorkbenchPart has been attached to the part reference.
231	*	266	*

Lines 77-97 Link Here

(-)Eclipse UI/org/eclipse/ui/part/MultiEditor.java (-15 lines)
77	return content;	77	return content;
78	}	78	}
79		79
80	/**
81	* The <code>MultiEditor</code> implementation of this
82	* method extends the <code>EditorPart</code> implementation,
83	* and disposes any inner editors. Subclasses may extend.
84	*
85	* @since 3.0
86	*/
87	public void dispose() {
88	super.dispose();
89	IEditorPart[] editors = getInnerEditors();
90	for (int i = 0; i < editors.length; i++) {
91	editors[i].dispose();
92	}
93	}
94
95	/*	80	/*
96	* @see IEditorPart#doSaveAs()	81	* @see IEditorPart#doSaveAs()
97	*/	82	*/