diff options
Diffstat (limited to 'eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/LayoutWindowCoordinator.java')
| -rw-r--r-- | eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/LayoutWindowCoordinator.java | 394 |
1 files changed, 0 insertions, 394 deletions
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/LayoutWindowCoordinator.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/LayoutWindowCoordinator.java deleted file mode 100644 index 56b86aa85..000000000 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/LayoutWindowCoordinator.java +++ /dev/null @@ -1,394 +0,0 @@ -/* - * 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(); - } - } -}
\ No newline at end of file |