| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/org/documents/epl-v10.php |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.android.ide.eclipse.adt.internal.editors.layout.gle2; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate; |
| import com.google.common.collect.Maps; |
| |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IPartListener2; |
| import org.eclipse.ui.IPartService; |
| import org.eclipse.ui.IViewReference; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchPartReference; |
| import org.eclipse.ui.IWorkbenchWindow; |
| |
| import java.util.Map; |
| |
| /** |
| * The {@link LayoutWindowCoordinator} keeps track of Eclipse window events (opening, closing, |
| * fronting, etc) and uses this information to manage the propertysheet and outline |
| * views such that they are always(*) showing: |
| * <ul> |
| * <li> If the Property Sheet and Outline Eclipse views are showing, it does nothing. |
| * "Showing" means "is open", not necessary "is visible", e.g. in a tabbed view |
| * there could be a different view on top. |
| * <li> If just the outline is showing, then the property sheet is shown in a sashed |
| * pane below or to the right of the outline (depending on the dominant dimension |
| * of the window). |
| * <li> TBD: If just the property sheet is showing, should the outline be showed |
| * inside that window? Not yet done. |
| * <li> If the outline is *not* showing, then the outline is instead shown |
| * <b>inside</b> the editor area, in a right-docked view! This right docked view |
| * also includes the property sheet! |
| * <li> If the property sheet is not showing (which includes not showing in the outline |
| * view as well), then it will be shown inside the editor area, along with the outline |
| * which should also be there (since if the outline was showing outside the editor |
| * area, the property sheet would have docked there). |
| * <li> When the editor is maximized, then all views are temporarily hidden. In this |
| * case, the property sheet and outline will show up inside the editor. |
| * When the editor view is un-maximized, the view state will return to what it |
| * was before. |
| * </ul> |
| * </p> |
| * There is one coordinator per workbench window, shared between all editors in that window. |
| * <p> |
| * TODO: Rename this class to AdtWindowCoordinator. It is used for more than just layout |
| * window coordination now. For example, it's also used to dispatch {@code activated()} and |
| * {@code deactivated()} events to all the XML editors, to ensure that key bindings are |
| * properly dispatched to the right editors in Eclipse 4.x. |
| */ |
| public class LayoutWindowCoordinator implements IPartListener2 { |
| static final String PROPERTY_SHEET_PART_ID = "org.eclipse.ui.views.PropertySheet"; //$NON-NLS-1$ |
| static final String OUTLINE_PART_ID = "org.eclipse.ui.views.ContentOutline"; //$NON-NLS-1$ |
| /** The workbench window */ |
| private final IWorkbenchWindow mWindow; |
| /** Is the Eclipse property sheet ViewPart open? */ |
| private boolean mPropertiesOpen; |
| /** Is the Eclipse outline ViewPart open? */ |
| private boolean mOutlineOpen; |
| /** Is the editor maximized? */ |
| private boolean mEditorMaximized; |
| /** |
| * Has the coordinator been initialized? We may have to delay initialization |
| * and perform it lazily if the workbench window does not have an active |
| * page when the coordinator is first started |
| */ |
| private boolean mInitialized; |
| |
| /** Map from workbench windows to each layout window coordinator instance for that window */ |
| private static Map<IWorkbenchWindow, LayoutWindowCoordinator> sCoordinators = |
| Maps.newHashMapWithExpectedSize(2); |
| |
| /** |
| * Returns the coordinator for the given window. |
| * |
| * @param window the associated window |
| * @param create whether to create the window if it does not already exist |
| * @return the new coordinator, never null if {@code create} is true |
| */ |
| @Nullable |
| public static LayoutWindowCoordinator get(@NonNull IWorkbenchWindow window, boolean create) { |
| synchronized (LayoutWindowCoordinator.class){ |
| LayoutWindowCoordinator coordinator = sCoordinators.get(window); |
| if (coordinator == null && create) { |
| coordinator = new LayoutWindowCoordinator(window); |
| |
| IPartService service = window.getPartService(); |
| if (service != null) { |
| // What if the editor part is *already* open? How do I deal with that? |
| service.addPartListener(coordinator); |
| } |
| |
| sCoordinators.put(window, coordinator); |
| } |
| |
| return coordinator; |
| } |
| } |
| |
| |
| /** Disposes this coordinator (when a window is closed) */ |
| public void dispose() { |
| IPartService service = mWindow.getPartService(); |
| if (service != null) { |
| service.removePartListener(this); |
| } |
| |
| synchronized (LayoutWindowCoordinator.class){ |
| sCoordinators.remove(mWindow); |
| } |
| } |
| |
| /** |
| * Returns true if the main editor window is maximized |
| * |
| * @return true if the main editor window is maximized |
| */ |
| public boolean isEditorMaximized() { |
| return mEditorMaximized; |
| } |
| |
| private LayoutWindowCoordinator(@NonNull IWorkbenchWindow window) { |
| mWindow = window; |
| |
| initialize(); |
| } |
| |
| private void initialize() { |
| if (mInitialized) { |
| return; |
| } |
| |
| IWorkbenchPage activePage = mWindow.getActivePage(); |
| if (activePage == null) { |
| return; |
| } |
| |
| mInitialized = true; |
| |
| // Look up current state of the properties and outline windows (in case |
| // they have already been opened before we added our part listener) |
| IViewReference ref = findPropertySheetView(activePage); |
| if (ref != null) { |
| IWorkbenchPart part = ref.getPart(false /*restore*/); |
| if (activePage.isPartVisible(part)) { |
| mPropertiesOpen = true; |
| } |
| } |
| ref = findOutlineView(activePage); |
| if (ref != null) { |
| IWorkbenchPart part = ref.getPart(false /*restore*/); |
| if (activePage.isPartVisible(part)) { |
| mOutlineOpen = true; |
| } |
| } |
| if (!syncMaximizedState(activePage)) { |
| syncActive(); |
| } |
| } |
| |
| static IViewReference findPropertySheetView(IWorkbenchPage activePage) { |
| return activePage.findViewReference(PROPERTY_SHEET_PART_ID); |
| } |
| |
| static IViewReference findOutlineView(IWorkbenchPage activePage) { |
| return activePage.findViewReference(OUTLINE_PART_ID); |
| } |
| |
| /** |
| * Checks the maximized state of the page and updates internal state if |
| * necessary. |
| * <p> |
| * This is used in Eclipse 4.x, where the {@link IPartListener2} does not |
| * fire {@link IPartListener2#partHidden(IWorkbenchPartReference)} when the |
| * editor is maximized anymore (see issue |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=382120 for details). |
| * Instead, the layout editor listens for resize events, and upon resize it |
| * looks up the part state and calls this method to ensure that the right |
| * maximized state is known to the layout coordinator. |
| * |
| * @param page the active workbench page |
| * @return true if the state changed, false otherwise |
| */ |
| public boolean syncMaximizedState(IWorkbenchPage page) { |
| boolean maximized = isPageZoomed(page); |
| if (mEditorMaximized != maximized) { |
| mEditorMaximized = maximized; |
| syncActive(); |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean isPageZoomed(IWorkbenchPage page) { |
| IWorkbenchPartReference reference = page.getActivePartReference(); |
| if (reference != null && reference instanceof IEditorReference) { |
| int state = page.getPartState(reference); |
| boolean maximized = (state & IWorkbenchPage.STATE_MAXIMIZED) != 0; |
| return maximized; |
| } |
| |
| // If the active reference isn't the editor, then the editor can't be maximized |
| return false; |
| } |
| |
| /** |
| * Syncs the given editor's view state such that the property sheet and or |
| * outline are shown or hidden according to the visibility of the global |
| * outline and property sheet views. |
| * <p> |
| * This is typically done when a layout editor is fronted. For view updates |
| * when the view is already showing, the {@link LayoutWindowCoordinator} |
| * will automatically handle the current fronted window. |
| * |
| * @param editor the editor to sync |
| */ |
| private void sync(@Nullable GraphicalEditorPart editor) { |
| if (editor == null) { |
| return; |
| } |
| if (mEditorMaximized) { |
| editor.showStructureViews(true /*outline*/, true /*properties*/, true /*layout*/); |
| } else if (mOutlineOpen) { |
| editor.showStructureViews(false /*outline*/, false /*properties*/, true /*layout*/); |
| editor.getCanvasControl().getOutlinePage().setShowPropertySheet(!mPropertiesOpen); |
| } else { |
| editor.showStructureViews(true /*outline*/, !mPropertiesOpen /*properties*/, |
| true /*layout*/); |
| } |
| } |
| |
| private void sync(IWorkbenchPart part) { |
| if (part instanceof AndroidXmlEditor) { |
| LayoutEditorDelegate editor = LayoutEditorDelegate.fromEditor((IEditorPart) part); |
| if (editor != null) { |
| sync(editor.getGraphicalEditor()); |
| } |
| } |
| } |
| |
| private void syncActive() { |
| IWorkbenchPage activePage = mWindow.getActivePage(); |
| if (activePage != null) { |
| IEditorPart editor = activePage.getActiveEditor(); |
| sync(editor); |
| } |
| } |
| |
| private void propertySheetClosed() { |
| mPropertiesOpen = false; |
| syncActive(); |
| } |
| |
| private void propertySheetOpened() { |
| mPropertiesOpen = true; |
| syncActive(); |
| } |
| |
| private void outlineClosed() { |
| mOutlineOpen = false; |
| syncActive(); |
| } |
| |
| private void outlineOpened() { |
| mOutlineOpen = true; |
| syncActive(); |
| } |
| |
| // ---- Implements IPartListener2 ---- |
| |
| @Override |
| public void partOpened(IWorkbenchPartReference partRef) { |
| // We ignore partOpened() and partClosed() because these methods are only |
| // called when a view is opened in the first perspective, and closed in the |
| // last perspective. The outline is typically used in multiple perspectives, |
| // so closing it in the Java perspective does *not* fire a partClosed event. |
| // There is no notification for "part closed in perspective" (see issue |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=54559 for details). |
| // However, the workaround we can use is to listen to partVisible() and |
| // partHidden(). These will be called more often than we'd like (e.g. |
| // when the tab order causes a view to be obscured), however, we can use |
| // the workaround of looking up IWorkbenchPage.findViewReference(id) after |
| // partHidden(), which will return null if the view is closed in the current |
| // perspective. For partOpened, we simply look in partVisible() for whether |
| // our flags tracking the view state have been initialized already. |
| } |
| |
| @Override |
| public void partClosed(IWorkbenchPartReference partRef) { |
| // partClosed() doesn't get called when a window is closed unless it has |
| // been closed in *all* perspectives. See partOpened() for more. |
| } |
| |
| @Override |
| public void partHidden(IWorkbenchPartReference partRef) { |
| IWorkbenchPage activePage = mWindow.getActivePage(); |
| if (activePage == null) { |
| return; |
| } |
| initialize(); |
| |
| // See if this looks like the window was closed in this workspace |
| // See partOpened() for an explanation. |
| String id = partRef.getId(); |
| if (PROPERTY_SHEET_PART_ID.equals(id)) { |
| if (activePage.findViewReference(id) == null) { |
| propertySheetClosed(); |
| return; |
| } |
| } else if (OUTLINE_PART_ID.equals(id)) { |
| if (activePage.findViewReference(id) == null) { |
| outlineClosed(); |
| return; |
| } |
| } |
| |
| // Does this look like a window getting maximized? |
| syncMaximizedState(activePage); |
| } |
| |
| @Override |
| public void partVisible(IWorkbenchPartReference partRef) { |
| IWorkbenchPage activePage = mWindow.getActivePage(); |
| if (activePage == null) { |
| return; |
| } |
| initialize(); |
| |
| String id = partRef.getId(); |
| if (mEditorMaximized) { |
| // Return to their non-maximized state |
| mEditorMaximized = false; |
| syncActive(); |
| } |
| |
| IWorkbenchPart part = partRef.getPart(false /*restore*/); |
| sync(part); |
| |
| // See partOpened() for an explanation |
| if (PROPERTY_SHEET_PART_ID.equals(id)) { |
| if (!mPropertiesOpen) { |
| propertySheetOpened(); |
| assert mPropertiesOpen; |
| } |
| } else if (OUTLINE_PART_ID.equals(id)) { |
| if (!mOutlineOpen) { |
| outlineOpened(); |
| assert mOutlineOpen; |
| } |
| } |
| } |
| |
| @Override |
| public void partInputChanged(IWorkbenchPartReference partRef) { |
| } |
| |
| @Override |
| public void partActivated(IWorkbenchPartReference partRef) { |
| IWorkbenchPart part = partRef.getPart(false); |
| if (part instanceof AndroidXmlEditor) { |
| ((AndroidXmlEditor)part).activated(); |
| } |
| } |
| |
| @Override |
| public void partBroughtToTop(IWorkbenchPartReference partRef) { |
| } |
| |
| @Override |
| public void partDeactivated(IWorkbenchPartReference partRef) { |
| IWorkbenchPart part = partRef.getPart(false); |
| if (part instanceof AndroidXmlEditor) { |
| ((AndroidXmlEditor)part).deactivated(); |
| } |
| } |
| } |
