Attachment #52703 for bug #153957

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 25-30 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/EditorSashContainer.java (-1 / +63 lines)
25	import org.eclipse.swt.widgets.Control;	25	import org.eclipse.swt.widgets.Control;
26	import org.eclipse.ui.IMemento;	26	import org.eclipse.ui.IMemento;
27	import org.eclipse.ui.PlatformUI;	27	import org.eclipse.ui.PlatformUI;
		28	import org.eclipse.ui.internal.layout.ITrimManager;
28	import org.eclipse.ui.internal.presentations.PresentationSerializer;	29	import org.eclipse.ui.internal.presentations.PresentationSerializer;
29	import org.eclipse.ui.presentations.StackPresentation;	30	import org.eclipse.ui.presentations.StackPresentation;
30		31
Lines 307-313 Link Here
307	}	308	}
308	mapIDtoPart.put(partID, workbook);	309	mapIDtoPart.put(partID, workbook);
309	}	310	}
310	return result;	311
		312	// Trim Stack Support
		313	Integer trimState = memento.getInteger(IWorkbenchConstants.TAG_PART_TRIMSTATE);
		314	if (trimState != null && trimState.intValue() != LayoutPart.TRIMSTATE_NORMAL)
		315	setTrimState(trimState.intValue());
		316
		317	return result;
311	}	318	}
312		319
313	/**	320	/**
Lines 353-358 Link Here
353	.getRatio());	360	.getRatio());
354	}	361	}
355	}	362	}
		363
		364	// Trim Stack Support
		365	if (getTrimState() != LayoutPart.TRIMSTATE_NORMAL)
		366	memento.putInteger(IWorkbenchConstants.TAG_PART_TRIMSTATE, getTrimState());
		367
356	return result;	368	return result;
357	}	369	}
358		370
Lines 531-534 Link Here
531	}	543	}
532	return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, 0, "", null); //$NON-NLS-1$	544	return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, 0, "", null); //$NON-NLS-1$
533	}	545	}
		546
		547	// Trim Stack Support
		548	public void setTrimState(int newTrimState) {
		549	if (newTrimState == getTrimState())
		550	return;
		551
		552	// Remember the new state
		553	int oldTrimState = getTrimState();
		554
		555	// set the new one
		556	super.setTrimState(newTrimState);
		557
		558	WorkbenchWindow wbw = (WorkbenchWindow) getWorkbenchWindow();
		559	if (wbw == null)
		560	return;
		561
		562	// Access workbench context
		563	Perspective persp = page.getActivePerspective();
		564	ITrimManager tbm = wbw.getTrimManager();
		565	EditorAreaTrimPart viewStackTrim = (EditorAreaTrimPart) tbm.getTrim(getID());
		566
		567	// NOTE: The part visibility is handled by the Perspective
		568	// for legacy reasons. All this does is show/hide the trim...
		569
		570	// Are we moving the View Stack -to- the trim?
		571	if (oldTrimState == LayoutPart.TRIMSTATE_NORMAL) {
		572	// Is it already in the trim?
		573	if (viewStackTrim == null) {
		574	// If it's not already in the trim...create it
		575	int side = SWT.BOTTOM;
		576	if (persp != null)
		577	side = persp.calcStackSide(getBounds());
		578
		579	viewStackTrim = new EditorAreaTrimPart(wbw, this);
		580	viewStackTrim.dock(side);
		581	tbm.addTrim(side, viewStackTrim);
		582	}
		583
		584	tbm.setTrimVisible(viewStackTrim, true);
		585	}
		586
		587	// Are we restoring the View Stack -from- the trim?
		588	if (newTrimState == LayoutPart.TRIMSTATE_NORMAL) {
		589	if (viewStackTrim == null)
		590	return;
		591
		592	// hide the trim widget
		593	tbm.setTrimVisible(viewStackTrim, false);
		594	}
		595	}
534	}	596	}

Lines 118-123 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/IWorkbenchConstants.java (+2 lines)
118		118
119	public static final String TAG_PART_NAME = "partName"; //$NON-NLS-1$	119	public static final String TAG_PART_NAME = "partName"; //$NON-NLS-1$
120		120
		121	public static final String TAG_PART_TRIMSTATE = "inTrim"; //$NON-NLS-1$
		122
121	public static final String TAG_RELATIVE = "relative"; //$NON-NLS-1$	123	public static final String TAG_RELATIVE = "relative"; //$NON-NLS-1$
122		124
123	public static final String TAG_RELATIONSHIP = "relationship"; //$NON-NLS-1$	125	public static final String TAG_RELATIONSHIP = "relationship"; //$NON-NLS-1$

Lines 10-16 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/ViewSashContainer.java (-1 / +69 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.ui.internal;	11	package org.eclipse.ui.internal;
12		12
		13	import java.util.ArrayList;
13	import java.util.HashMap;	14	import java.util.HashMap;
		15	import java.util.Iterator;
		16	import java.util.List;
14	import java.util.Map;	17	import java.util.Map;
15		18
16	import org.eclipse.core.runtime.IStatus;	19	import org.eclipse.core.runtime.IStatus;
Lines 19-24 Link Here
19	import org.eclipse.swt.widgets.Control;	22	import org.eclipse.swt.widgets.Control;
20	import org.eclipse.ui.IMemento;	23	import org.eclipse.ui.IMemento;
21	import org.eclipse.ui.PlatformUI;	24	import org.eclipse.ui.PlatformUI;
		25	import org.eclipse.ui.internal.layout.ITrimManager;
		26	import org.eclipse.ui.internal.layout.IWindowTrim;
22		27
23	/**	28	/**
24	* Represents the top level container.	29	* Represents the top level container.
Lines 197-205 Link Here
197	}	202	}
198	}	203	}
199		204
200	// If this is a folder save the contents.	205	// If this is a folder (ViewStack) save the contents.
201	if (folder != null) {	206	if (folder != null) {
202	childMem.putString(IWorkbenchConstants.TAG_FOLDER, "true");//$NON-NLS-1$	207	childMem.putString(IWorkbenchConstants.TAG_FOLDER, "true");//$NON-NLS-1$
		208
203	IMemento folderMem = childMem	209	IMemento folderMem = childMem
204	.createChild(IWorkbenchConstants.TAG_FOLDER);	210	.createChild(IWorkbenchConstants.TAG_FOLDER);
205	result.add(folder.saveState(folderMem));	211	result.add(folder.saveState(folderMem));
Lines 304-307 Link Here
304		310
305	super.replace(oldChild, newChild);	311	super.replace(oldChild, newChild);
306	}	312	}
		313
		314	// Trim Stack Support
		315
		316	/**
		317	* Restore any parts that are in the trim due
		318	* to a zoom (maximize) operation
		319	*/
		320	public boolean restoreZoomedTrimParts() {
		321	boolean needsLayout = false;
		322	LayoutPart[] children = getChildren();
		323	for (int i = 0; i < children.length; i++) {
		324	if (children[i].getTrimState() == LayoutPart.TRIMSTATE_ZOOMEDTOTRIM) {
		325	// All parts in the trim must have placeholders
		326	if (children[i] instanceof PartPlaceholder) {
		327	// restore the part from the trim
		328	PartPlaceholder ph = (PartPlaceholder) children[i];
		329	ph.setTrimState(LayoutPart.TRIMSTATE_NORMAL);
		330	needsLayout = true;
		331	}
		332	}
		333	}
		334
		335	return needsLayout;
		336	}
		337
		338	/**
		339	* @return A list containibg all trim representing a LayoutPart
		340	*/
		341	public List getTrimForParts() {
		342	List trim = new ArrayList();
		343
		344	// If a part is in the trim then get the trim element using the part's
		345	// id
		346	WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
		347	ITrimManager tbm = wbw.getTrimManager();
		348	LayoutPart[] children = getChildren();
		349	for (int i = 0; i < children.length; i++) {
		350	if (children[i].getTrimState() == LayoutPart.TRIMSTATE_IN_TRIM
		351	\|\| children[i].getTrimState() == LayoutPart.TRIMSTATE_ZOOMEDTOTRIM) {
		352	IWindowTrim partTrim = tbm.getTrim(children[i].getID());
		353	if (partTrim != null)
		354	trim.add(partTrim);
		355	}
		356	}
		357
		358	return trim;
		359	}
		360
		361	/**
		362	* Show any trim representing parts of this layout
		363	* @param visible true to show the trim, false to hide it
		364	*/
		365	public void setTrimVisible(boolean visible) {
		366	List partTrim = getTrimForParts();
		367	WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
		368	ITrimManager tbm = wbw.getTrimManager();
		369	for (Iterator trimPartIter = partTrim.iterator(); trimPartIter
		370	.hasNext();) {
		371	IWindowTrim trimForPart = (IWindowTrim) trimPartIter.next();
		372	tbm.setTrimVisible(trimForPart, visible);
		373	}
		374	}
307	}	375	}

Lines 34-39 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/LayoutPart.java (+36 lines)
34		34
35	public static final String PROP_VISIBILITY = "PROP_VISIBILITY"; //$NON-NLS-1$	35	public static final String PROP_VISIBILITY = "PROP_VISIBILITY"; //$NON-NLS-1$
36		36
		37	// Trim Stack Support
		38	public final static int TRIMSTATE_NORMAL = 0; // 'normal'...in the presentation
		39	public final static int TRIMSTATE_IN_TRIM = 1; // 'minimized'...in the trim but wont restore on an unzoom
		40	public final static int TRIMSTATE_ZOOMEDTOTRIM = 2; // 'zoomed'...in the trim as a result of a 'zoom' on some other part
		41
		42	protected int trimState = TRIMSTATE_NORMAL;
		43
37	/**	44	/**
38	* Number of times deferUpdates(true) has been called without a corresponding	45	* Number of times deferUpdates(true) has been called without a corresponding
39	* deferUpdates(false)	46	* deferUpdates(false)
Lines 485-488 Link Here
485	*/	492	*/
486	public void testInvariants() {	493	public void testInvariants() {
487	}	494	}
		495
		496	// Trim Stack Support
		497
		498	/**
		499	* @return Returns the trimState.
		500	*/
		501	public int getTrimState() {
		502	return trimState;
		503	}
		504
		505	/**
		506	* @param trimState The trimState to set.
		507	*/
		508	public void setTrimState(int trimState) {
		509	this.trimState = trimState;
		510	}
		511
		512	/**
		513	* Causes a layout part to refresh its state.
		514	* This is called by the Perspective to cause
		515	* any necessary trim to be constructed on activation
		516	*/
		517	public void createInitialTrim() {
		518	if (trimState != LayoutPart.TRIMSTATE_NORMAL) {
		519	int curState = getTrimState();
		520	trimState = LayoutPart.TRIMSTATE_NORMAL;
		521	setTrimState(curState);
		522	}
		523	}
488	}	524	}

Lines 53-62 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/IWorkbenchGraphicConstants.java (-2 / +4 lines)
53		53
54	//Fast view enabled and disabled icons	54	//Fast view enabled and disabled icons
55	public final static String IMG_ETOOL_NEW_FASTVIEW = "IMG_ETOOL_NEW_FASTVIEW"; //$NON-NLS-1$	55	public final static String IMG_ETOOL_NEW_FASTVIEW = "IMG_ETOOL_NEW_FASTVIEW"; //$NON-NLS-1$
56	public final static String IMG_ETOOL_RESTORE_FASTVIEW = "IMG_ETOOL_RESTORE_FASTVIEW"; //$NON-NLS-1$
57
58	public final static String IMG_DTOOL_NEW_FASTVIEW = "IMG_DTOOL_NEW_FASTVIEW"; //$NON-NLS-1$	56	public final static String IMG_DTOOL_NEW_FASTVIEW = "IMG_DTOOL_NEW_FASTVIEW"; //$NON-NLS-1$
59		57
		58	// TrimStack buttons
		59	public final static String IMG_ETOOL_RESTORE_TRIMPART = "IMG_ETOOL_RESTORE_TRIMPART"; //$NON-NLS-1$
		60	public final static String IMG_ETOOL_EDITOR_TRIMPART = "IMG_ETOOL_EDITOR_TRIMPART"; //$NON-NLS-1$
		61
60	// local toolbars	62	// local toolbars
61		63
62	public final static String IMG_LCL_CLOSE_VIEW = "IMG_LCL_CLOSE_VIEW"; //$NON-NLS-1$	64	public final static String IMG_LCL_CLOSE_VIEW = "IMG_LCL_CLOSE_VIEW"; //$NON-NLS-1$

Lines 908-913 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/PartStack.java (-1 / +23 lines)
908	String activeTabID = memento	908	String activeTabID = memento
909	.getString(IWorkbenchConstants.TAG_ACTIVE_PAGE_ID);	909	.getString(IWorkbenchConstants.TAG_ACTIVE_PAGE_ID);
910		910
		911	// Trim Stack Support
		912	Integer trimState = memento.getInteger(IWorkbenchConstants.TAG_PART_TRIMSTATE);
		913	if (trimState != null && trimState.intValue() != LayoutPart.TRIMSTATE_NORMAL)
		914	setTrimState(trimState.intValue());
		915
911	// Read the page elements.	916	// Read the page elements.
912	IMemento[] children = memento.getChildren(IWorkbenchConstants.TAG_PAGE);	917	IMemento[] children = memento.getChildren(IWorkbenchConstants.TAG_PAGE);
913	if (children != null) {	918	if (children != null) {
Lines 1011-1016 Link Here
1011	memento.putString(IWorkbenchConstants.TAG_ACTIVE_PAGE_ID, requestedCurrent	1016	memento.putString(IWorkbenchConstants.TAG_ACTIVE_PAGE_ID, requestedCurrent
1012	.getCompoundId());	1017	.getCompoundId());
1013	}	1018	}
		1019
		1020	// Trim Stack Support
		1021	if (getTrimState() != LayoutPart.TRIMSTATE_NORMAL)
		1022	memento.putInteger(IWorkbenchConstants.TAG_PART_TRIMSTATE, getTrimState());
1014		1023
1015	Iterator iter = children.iterator();	1024	Iterator iter = children.iterator();
1016	while (iter.hasNext()) {	1025	while (iter.hasNext()) {
Lines 1171-1177 Link Here
1171	// Make a one element list to pass on	1180	// Make a one element list to pass on
1172	List stacks = new ArrayList();	1181	List stacks = new ArrayList();
1173	stacks.add(this);	1182	stacks.add(this);
1174	persp.moveToTrim(stacks, FastViewBar.GROUP_FVB);	1183	persp.movePartsToTrim(stacks, false);
1175	return;	1184	return;
1176	}	1185	}
1177		1186
Lines 1485-1488 Link Here
1485	((IPropertyListener) listeners[i]).propertyChanged(this, id);	1494	((IPropertyListener) listeners[i]).propertyChanged(this, id);
1486	}	1495	}
1487	}	1496	}
		1497
		1498	// TrimStack Support
		1499
		1500	/**
		1501	* Explicitly sets the presentation state. This is used by the
		1502	* new min/max code to force the CTabFolder to show the proper
		1503	* state without going through the 'setState' code (which causes
		1504	* nasty side-effects.
		1505	* @param newState The state to set the presentation to
		1506	*/
		1507	public void setPresentationState(int newState) {
		1508	presentationSite.setPresentationState(newState);
		1509	}
1488	}	1510	}




                ViewPane pane = (ViewPane) iter.next();
                IViewReference ref = pane.getViewReference();
                
                // Drop only occurs on the global fast view bar
                FastViewBar curFVB = window.getFastViewBar();
                if (curFVB == null && window.getFastViewBar().hasViewRef(ref))
                	curFVB = window.getFastViewBar();
                	
                if (curFVB != null) {
                	curFVB.removeViewRef(ref);

	        // Construct an item to act as a 'menu button' (a la the PerspectiveSwitcher)
	        restoreItem = new  ToolItem(menuTB, SWT.PUSH, 0);
	        
	        Image tbImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_ETOOL_RESTORE_TRIMPART);
	        restoreItem.setImage(tbImage);
	        
	        String menuTip = WorkbenchMessages.StandardSystemToolbar_Restore;

	 * Restore all refs and close the group
	 */
	public void closeGroup() {
//		Perspective persp = window.getActiveWorkbenchPage().getActivePerspective();
//		persp.closeTrimGroup(this);
	}

	/**




    public boolean childIsZoomed(LayoutPart toTest) {
        return false;
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.ui.internal.LayoutPart#setTrimState(int)
     */
    public void setTrimState(int newTrimState) {
    	if (realContainer != null)
    		getRealContainer().setTrimState(newTrimState);
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.ui.internal.LayoutPart#getTrimState()
     */
    public int getTrimState() {
    	if (realContainer != null)
    		return getRealContainer().getTrimState();
    	
    	return super.getTrimState();
    }
}





        declareImage(IWorkbenchGraphicConstants.IMG_ETOOL_NEW_FASTVIEW,
                PATH_ETOOL + "new_fastview.gif", true); //$NON-NLS-1$
        declareImage(IWorkbenchGraphicConstants.IMG_ETOOL_RESTORE_FASTVIEW,
                PATH_ETOOL + "fastview_restore.gif", true); //$NON-NLS-1$
        declareImage(IWorkbenchGraphicConstants.IMG_DTOOL_NEW_FASTVIEW,
                PATH_DTOOL + "new_fastview.gif", true); //$NON-NLS-1$

        declareImage(IWorkbenchGraphicConstants.IMG_ETOOL_RESTORE_TRIMPART,
                PATH_ETOOL + "fastview_restore.gif", true); //$NON-NLS-1$
        declareImage(IWorkbenchGraphicConstants.IMG_ETOOL_EDITOR_TRIMPART,
                PATH_ETOOL + "editor_area.gif", true); //$NON-NLS-1$
        
        declareImage(ISharedImages.IMG_TOOL_FORWARD, PATH_ELOCALTOOL
                + "forward_nav.gif", true); //$NON-NLS-1$
        declareImage(ISharedImages.IMG_TOOL_FORWARD_HOVER, PATH_ELOCALTOOL




/*******************************************************************************
 * Copyright (c) 2006 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.internal;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.MouseTrackListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

/**
 * Implements the 'group' handling for trim groups
 * 
 * @since 3.2
 *
 */
public class FastGroupTrimButton {
	private Canvas button;
	private FastViewBar fvb;
	private int side;
	private Color btnColor;
	
	private Rectangle closeRect;
	private Rectangle restoreRect;
	private Rectangle collapseRect;

	private static final int CTRL_AREA_NONE = 0;
	private static final int CTRL_AREA_CLOSE = 1;
	private static final int CTRL_AREA_RESTORE = 2;
	private static final int CTRL_AREA_COLLAPSE = 3;
	
	private int curCtrlArea = CTRL_AREA_NONE;
	private boolean inControl = false;
	private String toolTip;
	
	public FastGroupTrimButton(Composite parent, FastViewBar fvb) {
		this.fvb = fvb;
		
		if (fvb != null)
			side = fvb.getSide();
		else
			side = SWT.BOTTOM;
		
		btnColor = parent.getDisplay().getSystemColor(SWT.COLOR_BLACK);
		
		button = new Canvas(parent, SWT.NONE);
		button.addPaintListener(new PaintListener() {
			public void paintControl(PaintEvent e) {
				e.gc.setForeground(btnColor);
				paintButtons(e);
			}
		});
		
		button.addMouseTrackListener(new MouseTrackListener() {
			public void mouseEnter(MouseEvent e) {
				inControl = true;
				// Provide 'track' feedback?
			}
			public void mouseExit(MouseEvent e) {
				inControl = false;
				// remove 'track' feedback?
			}
			public void mouseHover(MouseEvent e) {
				button.setToolTipText(toolTip);
			}			
		});
		
		button.addMouseMoveListener(new MouseMoveListener() {
			public void mouseMove(MouseEvent e) {
				if (closeRect.contains(e.x,e.y)) {
					curCtrlArea = CTRL_AREA_CLOSE;
					toolTip = "Close Group"; //$NON-NLS-1$
				}
				else if (restoreRect.contains(e.x,e.y)) {
					curCtrlArea = CTRL_AREA_RESTORE;
					toolTip = "Restore Group"; //$NON-NLS-1$
				}
				else if (collapseRect.contains(e.x,e.y)) {
					curCtrlArea = CTRL_AREA_COLLAPSE;
					toolTip = "Collapse Group"; //$NON-NLS-1$
				}
				else
					curCtrlArea = CTRL_AREA_NONE;
			}
		});
		button.addMouseListener(new MouseListener() {
			public void mouseDoubleClick(MouseEvent e) {}
			public void mouseUp(MouseEvent e) {}
			public void mouseDown(MouseEvent e) {
				if (inControl && curCtrlArea != CTRL_AREA_NONE) {
					switch (curCtrlArea) {
					case CTRL_AREA_CLOSE:
						FastGroupTrimButton.this.fvb.closeGroup();
						break;
					case CTRL_AREA_COLLAPSE:
						FastGroupTrimButton.this.fvb.collapseGroup();
						break;
					case CTRL_AREA_RESTORE:
						FastGroupTrimButton.this.fvb.restoreGroup();
						break;
					}
				}
			}			
		});
	}

	public void setSize(int size) {
		button.setSize(size, size);
	}
	
	protected void paintButtons(PaintEvent e) {
		Rectangle bb = button.getBounds();
		setButtonRects(bb);
		
		paintClose(e.gc);
		paintRestore(e.gc);
		paintCollapse(e.gc);
	}

	private void paintCollapse(GC gc) {
		switch(side) {
		case SWT.BOTTOM:
			drawDownArrow(gc, collapseRect);
			break;
		case SWT.TOP:
			drawUpArrow(gc, collapseRect);
			break;
		case SWT.LEFT:
			drawLeftArrow(gc, collapseRect);
			break;
		case SWT.RIGHT:
			drawRightArrow(gc, collapseRect);
			break;
		}
	}

	private void paintRestore(GC gc) {
		switch(side) {
		case SWT.BOTTOM:
			drawUpArrow(gc, restoreRect);
			break;
		case SWT.TOP:
			drawDownArrow(gc, restoreRect);
			break;
		case SWT.LEFT:
			drawRightArrow(gc, restoreRect);
			break;
		case SWT.RIGHT:
			drawLeftArrow(gc, restoreRect);
			break;
		}
	}

	private void paintClose(GC gc) {
		int border = 2;
		gc.drawLine(closeRect.x+border, closeRect.y+border, (closeRect.x+closeRect.width)-border, (closeRect.y+closeRect.height)-border);
		gc.drawLine((closeRect.x+closeRect.width)-border, closeRect.y+border, closeRect.x+border, (closeRect.y+closeRect.height)-border);
//		int minX = closeRect.x + 2;
//		int maxX = (closeRect.x+closeRect.width) - 2;
//		int stopMax = maxX;
//		int y = (closeRect.y + (closeRect.height)/2) - ((maxX-minX)/2);
//
//		while (minX <= stopMax) {
//			gc.drawLine(minX, y, minX, y);
//			gc.drawLine(maxX, y, maxX, y);
//			minX++; maxX--; y++;
//		}
	}

	private void drawDownArrow(GC gc, Rectangle rect) {
		int y = rect.y + 1;
		int minX = rect.x + 2;
		int maxX = (rect.x+rect.width) - 2;
		
		while (minX <= maxX) {
			gc.drawLine(minX, y, maxX, y);
			y++;
			gc.drawLine(minX, y, maxX, y);
			minX++; maxX--; y++;
		}
	}

	private void drawRightArrow(GC gc, Rectangle rect) {
		int x = rect.x + 1;
		int minY = rect.y + 2;
		int maxY = (rect.y+rect.height) - 2;
		
		while (minY <= maxY) {
			gc.drawLine(x, minY, x, maxY);
			x++;
			gc.drawLine(x, minY, x, maxY);
			minY++; maxY--; x++;
		}
	}

	private void drawUpArrow(GC gc, Rectangle rect) {
		int y = (rect.y+rect.height) - 1;
		int minX = rect.x + 2;
		int maxX = (rect.x+rect.width) - 2;
		
		while (minX <= maxX) {
			gc.drawLine(minX, y, maxX, y);
			y--;
			gc.drawLine(minX, y, maxX, y);
			minX++; maxX--; y--;
		}
	}

	private void drawLeftArrow(GC gc, Rectangle rect) {
		int x = (rect.x+rect.width) - 1;
		int minY = rect.y + 2;
		int maxY = (rect.y+rect.height) - 2;
		
		while (minY <= maxY) {
			gc.drawLine(x, minY, x, maxY);
			x--;
			gc.drawLine(x, minY, x, maxY);
			minY++; maxY--; x--;
		}
	}

	private void setButtonRects(Rectangle bb) {
		int hw = bb.width/2;
		int hh = bb.height/2;

		switch (side) {
		case SWT.BOTTOM:
			closeRect = new Rectangle(bb.x, bb.y+(bb.height/4), hw, hh);
			restoreRect = new Rectangle(bb.x+hw, bb.y, hw, hh);
			collapseRect = new Rectangle(bb.x+hw, bb.y+hh, hw, hh);
			break;
		case SWT.TOP:
			closeRect = new Rectangle(bb.x, bb.y+(bb.height/4), hw, hh);
			collapseRect = new Rectangle(bb.x+hw, bb.y, hw, hh);
			restoreRect = new Rectangle(bb.x+hw, bb.y+hh, hw, hh);
			break;
		case SWT.LEFT:
			closeRect = new Rectangle(bb.x+(bb.width/4), bb.y, hw, hh);
			collapseRect = new Rectangle(bb.x, bb.y+hh, hw, hh);
			restoreRect = new Rectangle(bb.x+hw, bb.y+hh, hw, hh);
			break;
		case SWT.RIGHT:
			closeRect = new Rectangle(bb.x+(bb.width/4), bb.y, hw, hh);
			restoreRect = new Rectangle(bb.x, bb.y+hh, hw, hh);
			collapseRect = new Rectangle(bb.x+hw, bb.y+hh, hw, hh);
			break;
		}
	}

	public Control getControl() {
		return button;
	}
}

Lines 24-31 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/EditorSiteDragAndDropServiceImpl.java (-2 lines)
24	import org.eclipse.swt.widgets.Control;	24	import org.eclipse.swt.widgets.Control;
25	import org.eclipse.ui.PlatformUI;	25	import org.eclipse.ui.PlatformUI;
26	import org.eclipse.ui.dnd.IDragAndDropService;	26	import org.eclipse.ui.dnd.IDragAndDropService;
27	import org.eclipse.ui.internal.WorkbenchWindow;
28	import org.eclipse.ui.internal.WorkbenchWindowConfigurer;
29	import org.eclipse.ui.services.IDisposable;	27	import org.eclipse.ui.services.IDisposable;
30		28
31	/**	29	/**




import org.eclipse.ui.internal.dnd.IDropTarget;
import org.eclipse.ui.internal.dnd.SwtUtil;
import org.eclipse.ui.internal.util.PrefUtil;
import org.eclipse.ui.presentations.IStackPresentationSite;

/**
 * Abstract container that groups various layout

    private LayoutPart zoomedPart;
    
    // 'Smart' zoom
    private LayoutPart smartZoomedPart = null;

    protected WorkbenchPage page;


        this.parent.setBounds(r);
    }

    private void smartZoomIn(LayoutPart zoomingPart, Perspective persp) {
    	// Prevent recursion
    	if (smartZoomedPart != null)
    		return;
    		// Restore the editor area if necessary
    		persp.showEditorArea();
    		
    		// Restore (close) and groups created during a zoom
            persp.restoreZoomGroups();
            
            // we're 'unzoomed'
            smartZoomed = false;
            
            // Remember that we need to trigger a layout
            layoutDirty = true;

            return;
    	}
    	
    	// 'Smart'(?) zoom...'minimize' all view stacks except the
    	// one we're zooming. If we're zooming the editor then -all-
    	// view stacks get minimized
        LayoutPart[] children = getChildren();
        List trimParts = new ArrayList();
        for (int i = 0; i < children.length; i++) {
            if (children[i] != zoomingPart)
            	trimParts.add(children[i]);
    		if (child instanceof EditorSashContainer && child != part) { 
    			persp.hideEditorArea();
    		}
    		else if (child instanceof ViewStack) {
    			if (child != part) {
    				stacks.add(child);
    			}
    		}
        }

        persp.movePartsToTrim(trimParts, true);
        
        // We're -not- really zoomed, don't lie
        zoomedPart = null;
        
        // ...but we're 'zoomed'
        smartZoomedPart = zoomingPart;
        
        if (smartZoomedPart instanceof PartStack) {
        	((PartStack)smartZoomedPart).setPresentationState(IStackPresentationSite.STATE_MAXIMIZED);
        }
        // Remember that we need to trigger a layout
        layoutDirty = true;
    }

    private void smartZoomOut(Perspective persp) {
    	// Prevent recursion
    	if (smartZoomedPart == null)
    		return;
    	
        // we're 'unzoomed'
    	LayoutPart zoomedPartCache = smartZoomedPart;
        smartZoomedPart = null;
		
		// Restore (close) trim parts created during a zoom
        persp.restoreZoomedParts();
        
        if (zoomedPartCache instanceof PartStack) {
        	((PartStack)zoomedPartCache).setPresentationState(IStackPresentationSite.STATE_RESTORED);
        }
        // Remember that we need to trigger a layout
        layoutDirty = true;
    }

     * Note: Method assumes we are active.
     */
    private void zoomOut() {
        // 'Smart'? Zoom out
		Perspective persp = this.getPage().getActivePerspective();
        IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
        boolean useNewMinMax = preferenceStore.getBoolean(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
    	if (useNewMinMax) {
    		smartZoomOut(persp);
    		return;
    	}
    	
        // Sanity check.
        if (!isZoomed()) {
			return;

Lines 567-573 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/WorkbenchMessages.java (-1 / +1 lines)
567	public static String StandardSystemToolbar_Maximize;	567	public static String StandardSystemToolbar_Maximize;
568	public static String StandardSystemToolbar_Restore;	568	public static String StandardSystemToolbar_Restore;
569		569
570	public static String ViewPane_moveToTrim;	570	public static String EditorArea_Tooltip;
571	public static String ViewPane_fastView;	571	public static String ViewPane_fastView;
572	public static String ViewPane_minimizeView;	572	public static String ViewPane_minimizeView;
573	public static String ViewPane_moveView;	573	public static String ViewPane_moveView;

Lines 12-18 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/ViewStack.java (+92 lines)
12	*******************************************************************************/	12	*******************************************************************************/
13	package org.eclipse.ui.internal;	13	package org.eclipse.ui.internal;
14		14
		15	import java.util.Iterator;
		16	import java.util.List;
		17
15	import org.eclipse.jface.action.IMenuManager;	18	import org.eclipse.jface.action.IMenuManager;
		19	import org.eclipse.swt.SWT;
		20	import org.eclipse.ui.IViewReference;
		21	import org.eclipse.ui.internal.layout.ITrimManager;
16	import org.eclipse.ui.internal.presentations.PresentablePart;	22	import org.eclipse.ui.internal.presentations.PresentablePart;
17	import org.eclipse.ui.internal.presentations.PresentationFactoryUtil;	23	import org.eclipse.ui.internal.presentations.PresentationFactoryUtil;
18	import org.eclipse.ui.internal.presentations.SystemMenuDetach;	24	import org.eclipse.ui.internal.presentations.SystemMenuDetach;
Lines 154-157 Link Here
154	public StackPresentation getTestPresentation() {	160	public StackPresentation getTestPresentation() {
155	return getPresentation();	161	return getPresentation();
156	}	162	}
		163
		164
		165	// Trim Stack Support
		166
		167	public void setTrimState(int newTrimState) {
		168	if (newTrimState == getTrimState())
		169	return;
		170
		171	// Remember the new state
		172	int oldTrimState = getTrimState();
		173
		174	// set the new one
		175	super.setTrimState(newTrimState);
		176
		177	WorkbenchWindow wbw = (WorkbenchWindow) getWorkbenchWindow();
		178	if (wbw == null)
		179	return;
		180
		181	// Access workbench context
		182	Perspective persp = page.getActivePerspective();
		183	ITrimManager tbm = wbw.getTrimManager();
		184	ViewStackTrimPart viewStackTrim = (ViewStackTrimPart) tbm.getTrim(getID());
		185
		186	// Are we moving the View Stack -to- the trim?
		187	if (oldTrimState == LayoutPart.TRIMSTATE_NORMAL) {
		188	// Remove the real stack from the presentation
		189	ContainerPlaceholder ph = null;
		190	ph = new ContainerPlaceholder(getID());
		191	ph.setRealContainer(this);
		192	getContainer().replace(this, ph);
		193	page.refreshActiveView();
		194
		195	// Is it already in the trim?
		196	if (viewStackTrim == null) {
		197	// If it's not already in the trim...create it
		198	int side = SWT.BOTTOM;
		199	if (persp != null)
		200	side = persp.calcStackSide(getBounds());
		201
		202	viewStackTrim = new ViewStackTrimPart(wbw, ph);
		203	viewStackTrim.dock(side);
		204	tbm.addTrim(side, viewStackTrim);
		205	}
		206
		207	// Refresh the trim's state and show it
		208	viewStackTrim.setPlaceholder(ph);
		209	viewStackTrim.refresh();
		210
		211	// Make the views 'fast'
		212	if (persp != null) {
		213	List refs = viewStackTrim.getViewRefs();
		214	for (Iterator refIter = refs.iterator(); refIter
		215	.hasNext();) {
		216	IViewReference ref = (IViewReference) refIter.next();
		217	persp.addFastViewHack(ref);
		218	}
		219	}
		220	tbm.setTrimVisible(viewStackTrim, true);
		221	}
		222
		223	// Are we restoring the View Stack -from- the trim?
		224	if (newTrimState == LayoutPart.TRIMSTATE_NORMAL) {
		225	if (viewStackTrim == null)
		226	return;
227
228	// Make the views un-'fast'
229	if (persp != null) {
230	List refs = viewStackTrim.getViewRefs();
231	for (Iterator refIter = refs.iterator(); refIter
232	.hasNext();) {
233	IViewReference ref = (IViewReference) refIter.next();
234	persp.removeFastViewHack(ref);
235	}
236	}
237
238	// hide the trim widget
239	tbm.setTrimVisible(viewStackTrim, false);
240
241	// Restore the real container
242	ContainerPlaceholder ph = viewStackTrim.getPlaceholder();
243	ILayoutContainer container = ph.getContainer();
244	LayoutPart ps = ph.getRealContainer();
245	ph.setRealContainer(null);
246	container.replace(ph, ps);
247	}
248	}
157	}	249	}

Lines 563-569 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/messages.properties (-1 / +1 lines)
563	StandardSystemToolbar_Maximize = Maximize	563	StandardSystemToolbar_Maximize = Maximize
564	StandardSystemToolbar_Restore = Restore	564	StandardSystemToolbar_Restore = Restore
565		565
566	ViewPane_moveToTrim = &Move to Trim	566	EditorArea_Tooltip = Editor Area
567	ViewPane_fastView = &Fast View	567	ViewPane_fastView = &Fast View
568	ViewPane_minimizeView= Mi&nimize	568	ViewPane_minimizeView= Mi&nimize
569	ViewPane_moveView=&View	569	ViewPane_moveView=&View




import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.Geometry;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchPreferenceConstants;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;

import org.eclipse.ui.internal.dnd.DragUtil;
import org.eclipse.ui.internal.intro.IIntroConstants;
import org.eclipse.ui.internal.layout.ITrimManager;
import org.eclipse.ui.internal.layout.IWindowTrim;
import org.eclipse.ui.internal.misc.StatusUtil;
import org.eclipse.ui.internal.presentations.PresentablePart;
import org.eclipse.ui.internal.registry.ActionSetRegistry;
import org.eclipse.ui.internal.registry.IActionSetDescriptor;
import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;

import org.eclipse.ui.internal.registry.PerspectiveExtensionReader;
import org.eclipse.ui.internal.registry.PerspectiveRegistry;
import org.eclipse.ui.internal.registry.StickyViewDescriptor;
import org.eclipse.ui.internal.util.PrefUtil;
import org.eclipse.ui.views.IStickyViewDescriptor;
import org.eclipse.ui.views.IViewDescriptor;
import org.eclipse.ui.views.IViewRegistry;

    private ArrayList perspectiveShortcuts;

    private ArrayList fastViews;
    private List globalFastViews;
    private boolean globalFVBsaved = false;
    private ArrayList fastViewBars;

    private Map mapIDtoViewLayoutRec;


        alwaysOnActionSets = new ArrayList(2);
        alwaysOffActionSets = new ArrayList(2);
        fastViews = new ArrayList(2);
        globalFastViews = new ArrayList(2);
        fastViewBars = new ArrayList(2);
        mapIDtoViewLayoutRec = new HashMap();
    }

	/**
	 * Sets the fast view attribute. Note: The page is expected to update action
	 * bars.
	 */
	public void addFastView(IViewReference ref) {
		addFastView(ref, true);
	}
	
	/**
	 * Sets the fast view attribute. Note: The page is expected to update action
	 * bars.
	 */
	public void addFastView(IViewReference ref, boolean handleLayout) {
		ViewPane pane = (ViewPane) ((WorkbenchPartReference) ref).getPane();
		if (!isFastView(ref)) {
			if (handleLayout) {
				// Only remove the part from the presentation if it
				// is actually in the presentation.
				if (presentation.hasPlaceholder(ref.getId(), ref.getSecondaryId())
						|| pane.getContainer() != null) {
					presentation.removePart(pane);
				}
			}
			
			// We are drag-enabling the pane because it has been disabled
			// when it was removed from the perspective presentation.
			fastViews.add(ref);
			pane.setFast(true);
			Control ctrl = pane.getControl();
			if (ctrl != null) {
				ctrl.setEnabled(false); // Remove focus support.
			}
		}
	}

    /**
     * Moves a part forward in the Z order of a perspective so it is visible.

        return array;
    }

    public void closeTrimGroup(FastViewBar groupBar) {
    	groupBar.restoreGroup();
    	
    	WorkbenchWindow wbw = (WorkbenchWindow)page.getWorkbenchWindow();
    	ITrimManager tbm = wbw.getTrimManager();
    	tbm.removeTrim(groupBar);
    	groupBar.getControl().setVisible(false);
    	groupBar.dispose();
    	
    	fastViewBars.remove(groupBar);
    	
    	tbm.forceLayout();
    }
    
    private String getUniqueGroupId() {
		// Get a unique id
    	boolean found = false;
    	int count = 0;
    	String id = ""; //$NON-NLS-1$
    	while (!found) {
    		id = getDesc().getId() + " (" + count  + ")";  //$NON-NLS-1$//$NON-NLS-2$
    		boolean matchFound = false;
    		for (Iterator fvbIter = fastViewBars.iterator(); fvbIter.hasNext();) {
				FastViewBar fvb = (FastViewBar) fvbIter.next();
				if (fvb.getId().equals(id)) {
					matchFound = true;
					break;
				}
			}
    		
    		if (matchFound)
    			count++;
    		else
    			found = true;
    	}
    	
    	return id;
    }
    
    private int calcStackSide (ViewStack stack) {
    	// Where is the stack in relation to the EditorArea?
    	Rectangle stackBounds = stack.getBounds();
    	Rectangle editorAreaBounds = editorArea.getBounds();
    	
    	if ((stackBounds.x+stackBounds.width) < editorAreaBounds.x)
    		return SWT.LEFT;
    	if (stackBounds.x > (editorAreaBounds.x+editorAreaBounds.width))
    		return SWT.RIGHT;
    	if ((stackBounds.y+stackBounds.height) < editorAreaBounds.y)
    		return SWT.TOP;
    	if (stackBounds.y > (editorAreaBounds.y+editorAreaBounds.height))
    		return SWT.BOTTOM;
    	
    	return SWT.BOTTOM; // shouldn't be able to get here...
    }
    
    public void moveToTrim(List stacks, int style) {
    	if (stacks == null || stacks.size() == 0)
    		return;
    	
    	Shell shell = ((ViewStack)stacks.get(0)).getShell();
    	RectangleAnimation animation = new RectangleAnimation(shell, null, null);
    	
		// Capture the area the stack currently occupies (and its image)
    	for (Iterator stackIter = stacks.iterator(); stackIter.hasNext();) {
			ViewStack stack = (ViewStack) stackIter.next();
			animation.addStartRect(DragUtil.getDisplayBounds(stack.getControl()));
    	}
    	
    	// Iterate through all the stacks, moveing each to the trim
    	List newFVBs = new ArrayList(stacks.size());
    	for (Iterator stackIter = stacks.iterator(); stackIter.hasNext();) {
			ViewStack stack = (ViewStack) stackIter.next();
			
			// Place the stack on the correct side
	    	int side = calcStackSide(stack);
	    	FastViewBar fvb = createFastViewBar(getUniqueGroupId(), style, side);
	    	newFVBs.add(fvb);
	    	
	    	// Add all the views in the stack to teh new FVB
	    	ArrayList refs = new ArrayList();
	    	List parts = stack.getPresentableParts();
	    	for (Iterator partIter = parts.iterator(); partIter.hasNext();) {
	    		PresentablePart part = (PresentablePart) partIter.next();
	    		if (part.getPane().getPartReference() instanceof ViewReference) {
	    			refs.add(part.getPane().getPartReference());
	    		}
			}
	    	fvb.setViewRefs(refs);
	    	
	    	// Set the display orientation based on the stack's geometry
	    	Rectangle stackBounds = stack.getBounds();
	    	int orientation = (stackBounds.width > stackBounds.height) ? SWT.HORIZONTAL : SWT.VERTICAL;
	    	fvb.setOrientation(orientation);
	    	
	    	// Move the views 'into' the new group
	    	fvb.collapseGroup();
    	
    	}

    	// Force a layout
    	WorkbenchWindow wbw = (WorkbenchWindow)page.getWorkbenchWindow();
    	ITrimManager tbm = wbw.getTrimManager();
    	tbm.forceLayout();
    	
    	// Now that the layout is finished we can add the 'end' rects for the animation
    	for (Iterator fvbIter = newFVBs.iterator(); fvbIter.hasNext();) {
			FastViewBar fvb = (FastViewBar) fvbIter.next();
			animation.addEndRect(DragUtil.getDisplayBounds(fvb.getControl()));
		}
    	
    	animation.schedule();
    }
    
    public void restoreZoomGroups() {
		List toClose = new ArrayList();
		
		// Get the groups to close in another list and...
    	for (Iterator fvbIter = fastViewBars.iterator(); fvbIter.hasNext();) {
			FastViewBar fvb = (FastViewBar) fvbIter.next();
			if (fvb.testStyleBit(FastViewBar.ZOOM_GROUP))
				toClose.add(fvb);
		}
    	
    	// ... close them
    	for (Iterator closeIter = toClose.iterator(); closeIter.hasNext();) {
			FastViewBar fvb = (FastViewBar) closeIter.next();
				fvb.closeGroup();
		}
    }
    
    private FastViewBar createFastViewBar(String id, int style, int side) {   	
    	// Create the FVB on the given side
    	WorkbenchWindow wbw = (WorkbenchWindow)page.getWorkbenchWindow();
    	FastViewBar newFVB = new FastViewBar(wbw, style, id);
    	newFVB.createControl(wbw.getShell());
    	newFVB.dock(side);
    	newFVB.getControl().setVisible(true);
    	ITrimManager tbm = wbw.getTrimManager();
    	tbm.addTrim(side, newFVB);
    	
    	fastViewBars.add(newFVB);
    	
    	return newFVB;
    }
    
    /**
     * Returns the new wizard shortcuts associated with this perspective.
     * 

    /**
     * activate.
     */
	protected void onActivate() {
		// Update editor area state.
		if (editorArea.getControl() != null) {
			editorArea.setVisible(isEditorAreaVisible());
		}

		// update the 'global' FVB
		FastViewBar fvb = ((WorkbenchWindow) page.getWorkbenchWindow())
				.getFastViewBar();
		if (fvb != null) {
			fvb.setViewRefs(fastViews);
		}

		// Update fast views.
		// Make sure the control for the fastviews are create so they can
		// be activated.
		for (int i = 0; i < fastViews.size(); i++) {
			ViewPane pane = getPane((IViewReference) fastViews.get(i));
			if (pane != null) {
				Control ctrl = pane.getControl();
				if (ctrl == null) {
					pane.createControl(getClientComposite());
					ctrl = pane.getControl();
				}
				ctrl.setEnabled(false); // Remove focus support.
			}
		}

		// Set the visibility of all fast view pins
		setAllPinsVisible(true);
        // be activated.
        for (int i = 0; i < fastViews.size(); i++) {
            ViewPane pane = getPane((IViewReference) fastViews.get(i));
            if (pane != null) {
                Control ctrl = pane.getControl();
                if (ctrl == null) {
                    pane.createControl(getClientComposite());
                    ctrl = pane.getControl();
                }
                ctrl.setEnabled(false); // Remove focus support.
            }
        }
        
        // update the 'global' FVB
        FastViewBar fvb = ((WorkbenchWindow)page.getWorkbenchWindow()).getFastViewBar();
        if (fvb != null) {
	        fvb.setViewRefs(globalFastViews);
	        globalFVBsaved = false;
        }

		// Show the layout
		presentation.activate(getClientComposite());

		// Trim Stack Support
        IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
        boolean useNewMinMax = preferenceStore.getBoolean(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
    	if (useNewMinMax) {
			// We 'stall' the creation of trim elements until the first activation
			createInitialTrim();
			
			// Show Trim parts -after- activation
			presentation.getLayout().setTrimVisible(true);
			
			// The editor area's trim stack's visibility is the inverse
			// Of the actual editor area
			WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
			ITrimManager tbm = wbw.getTrimManager();
			IWindowTrim eaTrim = tbm.getTrim(editorArea.getID());
			if (eaTrim != null) {
				tbm.setTrimVisible(eaTrim, !isEditorAreaVisible());
			}
	
			// if we're done then force an update...optimize out if possible
			tbm.forceLayout();
    	}
        
        setAllPinsVisible(true);
        presentation.activate(getClientComposite());

		if (shouldHideEditorsOnActivate) {
			// We do this here to ensure that createPartControl is called on the
			// top editor
			// before it is hidden. See bug 20166.
			hideEditorArea();
			shouldHideEditorsOnActivate = false;
		}
	}

    /**
	 * Create any trim necessary to support the current
	 * layout state 
	 */
	private void createInitialTrim() {
		WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
		ITrimManager tbm = wbw.getTrimManager();

		LayoutPart[] children = presentation.getLayout().getChildren();
		for (int i = 0; i < children.length; i++) {
			if (children[i].getTrimState() == LayoutPart.TRIMSTATE_IN_TRIM
					|| children[i].getTrimState() == LayoutPart.TRIMSTATE_ZOOMEDTOTRIM) {
				IWindowTrim partTrim = tbm.getTrim(children[i].getID());
				if (partTrim == null) {
					children[i].createInitialTrim();
				}
			}
		}
	}

	/**
     * deactivate.
     */
	protected void onDeactivate() {
		presentation.deactivate();
		setActiveFastView(null);
		setAllPinsVisible(false);

		// Update fast views.
		for (int i = 0; i < fastViews.size(); i++) {
			ViewPane pane = getPane((IViewReference) fastViews.get(i));
			if (pane != null) {
				Control ctrl = pane.getControl();
				if (ctrl != null) {
    	}
        
        // Update fast views.
        for (int i = 0; i < fastViews.size(); i++) {
            ViewPane pane = getPane((IViewReference) fastViews.get(i));
            if (pane != null) {
                Control ctrl = pane.getControl();
                if (ctrl != null) {
					ctrl.setEnabled(true); // Add focus support.
				}
			}
        }

        // Hide the trim groups
    	ITrimManager tbm = wbw.getTrimManager();
        for (Iterator fvbIter = fastViewBars.iterator(); fvbIter.hasNext();) {
			FastViewBar fvb = (FastViewBar) fvbIter.next();
			tbm.setTrimVisible(fvb, false);
		}

		// Trim Stack Support
        IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
        boolean useNewMinMax = preferenceStore.getBoolean(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
    	if (useNewMinMax) {
			// OK, adjust the trim to hide any view stacks that
			// are -currently- showing in the trim
			presentation.getLayout().setTrimVisible(false);
    	}
	}

    /**
     * Notifies that a part has been activated.

    public void performedShowIn(String partId) {
        showInTimes.put(partId, new Long(System.currentTimeMillis()));
    }

	/**
	 * Sets the fast view attribute. Note: The page is expected to update action
	 * bars.
	 */
	public void removeFastView(IViewReference ref) {
		removeFastView(ref, true);
	}
	
	/**
	 * Sets the fast view attribute. Note: The page is expected to update action
	 * bars.
	 */
	public void removeFastView(IViewReference ref, boolean handleLayout) {
		ViewPane pane = getPane(ref);
		if (isFastView(ref)) {
			if (activeFastView == ref) {
				setActiveFastView(null);
			}
			fastViews.remove(ref);
			pane.setFast(false);
			Control ctrl = pane.getControl();
			if (ctrl != null) {
				ctrl.setEnabled(true); // Modify focus support.
			}
			
			if (handleLayout) {
				// We are disabling the pane because it will be enabled when it
				// is added to the presentation. When a pane is enabled a drop
				// listener is added to it, and we do not want to have multiple
				// listeners for a pane
				presentation.addPart(pane);
			}
		}
	}

    /**
     * Fills a presentation with layout data.

        IMemento views[] = memento.getChildren(IWorkbenchConstants.TAG_VIEW);
        result.merge(createReferences(views));

        // Restore the list of fast views
        memento = memento.getChild(IWorkbenchConstants.TAG_FAST_VIEWS);
        if (memento != null) {
            views = memento.getChildren(IWorkbenchConstants.TAG_VIEW);
            result.merge(createReferences(views));
        }
        
        return result;
    }


            }
        }

        // Restore the list of 'global' fast views
        globalFastViews = new ArrayList();
        IMemento globalFastViewsMem = memento.getChild(IWorkbenchConstants.TAG_GLOBAL_FAST_VIEWS);
        if (globalFastViewsMem != null) {
        	IMemento[] globalRefs = globalFastViewsMem.getChildren(IWorkbenchConstants.TAG_VIEW);
        	for (int i = 0; i < globalRefs.length; i++) {
    			String viewId = globalRefs[i].getID();
                String secondaryId = ViewFactory.extractSecondaryId(viewId);
                if (secondaryId != null) {
                	viewId = ViewFactory.extractPrimaryId(viewId);
                }
                
                // Resolve the ref
                IViewReference ref = viewFactory.getView(viewId, secondaryId);
                globalFastViews.add(ref);
			}
        }
        else {
        	// Old format, all fast views are 'global'
        	globalFastViews = new ArrayList(fastViews);
        }

        // Restore the trim groups
        IMemento groupsMem = memento.getChild(IWorkbenchConstants.TAG_FAST_GROUPS);
        if (groupsMem != null) {
	        IMemento[] group = groupsMem.getChildren(IWorkbenchConstants.TAG_FAST_VIEW_DATA);
	        for (int i = 0; i < group.length; i++) {
	        	String id = group[i].getString(IWorkbenchConstants.TAG_ID);
	        	FastViewBar fvb = createFastViewBar(id, FastViewBar.GROUP_FVB, SWT.BOTTOM);
	        	fvb.restoreState(group[i]);
	
	        	IMemento viewsMem = group[i].getChild(IWorkbenchConstants.TAG_VIEWS);
	    		IMemento[] fvMems = viewsMem.getChildren(IWorkbenchConstants.TAG_VIEW);
	    		ArrayList viewRefs = new ArrayList(fvMems.length);
	    		for (int j = 0; j < fvMems.length; j++) {
	    			String viewId = fvMems[j].getID();
	                String secondaryId = ViewFactory.extractSecondaryId(viewId);
	                if (secondaryId != null) {
	                	viewId = ViewFactory.extractPrimaryId(viewId);
	                }
	                
	                // Resolve the ref
	                IViewReference ref = viewFactory.getView(viewId, secondaryId);
	                viewRefs.add(ref);
	    		}
	        	
	    		fvb.setViewRefs(viewRefs);
			}
        }
        
        HashSet knownActionSetIds = new HashSet();

        // Load the always on action sets.

                    .getKey(ref));
        }

        // Save the set of all fast Views
        if (fastViews.size() > 0) {
            IMemento childMem = memento
                    .createChild(IWorkbenchConstants.TAG_FAST_VIEWS);

            }
        }

        // Save the set of all 'global' fast Views for this perspective        
        // update the list of 'global' fast views
    	WorkbenchWindow wbw = (WorkbenchWindow)page.getWorkbenchWindow();
    	FastViewBar globalFVB = wbw.getFastViewBar();
        if (globalFVB != null && !globalFVBsaved) {
	        globalFastViews = new ArrayList(globalFVB.getViewRefs());
	        globalFVBsaved = true;
        }
    
        IMemento globalFVBMem = memento
                .createChild(IWorkbenchConstants.TAG_GLOBAL_FAST_VIEWS);
        itr = globalFastViews.iterator();
        while (itr.hasNext()) {
            IViewReference ref = (IViewReference) itr.next();
            String id = ViewFactory.getKey(ref);
            globalFVBMem.createChild(IWorkbenchConstants.TAG_VIEW, id);
        }

        // Save the view layout recs.
        for (Iterator i = mapIDtoViewLayoutRec.keySet().iterator(); i.hasNext();) {
            String compoundId = (String) i.next();

            }
        }

        // Save the list of group FVB's
        IMemento fvbMem = memento.createChild(IWorkbenchConstants.TAG_FAST_GROUPS);
        for (Iterator fvbIter = fastViewBars.iterator(); fvbIter.hasNext();) {
        	FastViewBar fvb = (FastViewBar) fvbIter.next();
    		IMemento fastViewBarMem = fvbMem.createChild(IWorkbenchConstants.TAG_FAST_VIEW_DATA);
    		fastViewBarMem.putString(IWorkbenchConstants.TAG_ID, fvb.getId());
    		fvb.saveState(fastViewBarMem);
    		
    		// Store the view references for this FVB
    		List viewRefs = fvb.getViewRefs();
    		IMemento viewsMem = fastViewBarMem.createChild(IWorkbenchConstants.TAG_VIEWS);
    		for (Iterator fvIter = viewRefs.iterator(); fvIter.hasNext();) {
    			IViewReference ref = (IViewReference) fvIter.next();
                String id = ViewFactory.getKey(ref);
                viewsMem.createChild(IWorkbenchConstants.TAG_VIEW, id);
    		}
		}
        
        if (errors > 0) {
            String message = WorkbenchMessages.Perspective_multipleErrors;
            if (errors == 1) {

        }
    }

    public FastViewBar getFVBForRef(IViewReference ref) {
    	for (Iterator fvbIter = fastViewBars.iterator(); fvbIter.hasNext();) {
			FastViewBar fvb = (FastViewBar) fvbIter.next();
			if (fvb.hasViewRef(ref))
				return fvb;
		}
    	
    	return null;
    }
    /**
     * Sets the selection for the shortcut bar icon representing the givevn fast view.
     */
    private void setFastViewIconSelection(IViewReference ref, boolean selected) {
		// First, is it in a Trim Stack?
		ViewStackTrimPart ts = getTrimStackForRef(ref);
		if (ts != null) {
			ts.setIconSelection(ref, selected);
			return;
		}

		WorkbenchWindow window = (WorkbenchWindow) page.getWorkbenchWindow();
		FastViewBar bar = window.getFastViewBar();
		if (bar != null) {
			if (selected) {
				bar.setSelection(ref);
			} else {
				if (ref == bar.getSelection()) {
					bar.setSelection(null);
				}
			}
		}
    }

    /**

        editorHolder = null;
    }

	private ViewStackTrimPart getTrimStackForRef(IViewReference ref) {
		// Is it in a minimized stack?
		List trimParts = presentation.getLayout().getTrimForParts();
		for (Iterator trimIter = trimParts.iterator(); trimIter.hasNext();) {
			IWindowTrim trim = (IWindowTrim) trimIter.next();
			if (trim instanceof ViewStackTrimPart) {
				if (((ViewStackTrimPart) trim).hasViewRef(ref))
					return (ViewStackTrimPart) trim;
			}
		}

		return null;
	}

    /**
     * Shows a fast view.
     * @return whether the view was successfully shown


        saveFastViewWidthRatio();


		// Determine the display orientation
		int side;
		ViewStackTrimPart ts = getTrimStackForRef(ref);
		if (ts != null) {
			side = ts.getViewSide();
		} else {
			WorkbenchWindow window = (WorkbenchWindow) page
					.getWorkbenchWindow();
			FastViewBar bar = window.getFastViewBar();

			if (bar == null) {
				return false;
			}

			side = bar.getViewSide(ref);
		}

        fastViewPane.showView(getClientComposite(), pane, side,
                getFastViewWidthRatio(ref)); 

        int openViewMode = store.getInt(IPreferenceConstants.OPEN_VIEW_MODE);

        if (openViewMode == IPreferenceConstants.OVM_FAST) {
            showFastView(ref);
            addFastView(ref);
        } else if (openViewMode == IPreferenceConstants.OVM_FLOAT
                && presentation.canDetach()) {
            presentation.addDetachedPart(pane);

		return fastViewPane;
	}

	// Trim Stack Support

	/**
	 * Hack to get around 'addFastView' issues
	 * 
	 * @param ref
	 */
	public void addFastViewHack(IViewReference ref) {
		//addFastView(ref, false);
	}

	/**
	 * Hack to get around 'addFastView' issues
	 * 
	 * @param ref
	 */
	public void removeFastViewHack(IViewReference ref) {
		//removeFastView(ref, false);
	}

	/**
	 * Moves any parts that support trim representation into the trim
	 * 
	 * @param parts The parts to (potentially) move to the trim
	 * @param restoreOnUnzoom 'true' iff we want the parts to
	 * automatically restore on an 'unzoom'.
	 */
	public void movePartsToTrim(List parts, boolean restoreOnUnzoom) {
		if (parts == null || parts.size() == 0)
			return;

		Shell shell = page.getWorkbenchWindow().getShell();
		RectangleAnimation animation = new RectangleAnimation(shell, null, null);

		// Capture the area the stack currently occupies (and its image)
		for (Iterator stackIter = parts.iterator(); stackIter.hasNext();) {
			LayoutPart part = (LayoutPart) stackIter.next();
			if (part.getControl() != null)
				animation.addStartRect(DragUtil.getDisplayBounds(part
						.getControl()));
		}

		// Gain access to the trim manager
		WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
		ITrimManager tbm = wbw.getTrimManager();

		// Iterate through all the parts, moving each to the trim
		int newTrimState = restoreOnUnzoom ? LayoutPart.TRIMSTATE_ZOOMEDTOTRIM
				: LayoutPart.TRIMSTATE_IN_TRIM;
		
		// We hide the editor container last so its position can be used
		// to calculate the correct side for other trim
		boolean moveEditorAreaToTrim = false;
		
		List newTrimParts = new ArrayList();
		for (Iterator stackIter = parts.iterator(); stackIter.hasNext();) {
			LayoutPart part = (LayoutPart) stackIter.next();
			
			// for now be careful and only manipulate 'known' part types
			// should generalize...
			if (part instanceof ViewStack) {
				part.setTrimState(newTrimState);
				IWindowTrim partTrim = tbm.getTrim(part.getID());
				if (partTrim != null) {
					newTrimParts.add(partTrim);
				}
			} else if (part instanceof EditorSashContainer) {
				moveEditorAreaToTrim = true;
			}
		}

		if (moveEditorAreaToTrim) {
			editorArea.setTrimState(newTrimState);
			hideEditorArea();

			IWindowTrim partTrim = tbm.getTrim(editorArea.getID());
			if (partTrim != null) {
				newTrimParts.add(partTrim);
			}
		}
		
		// Force a layout if necessary
		if (newTrimParts.size() == 0)
			return;
		
		// OK, we're good to go
		tbm.forceLayout();

		// Now that the layout is finished we can add the 'end' rects for the
		// animation
		for (Iterator tsIter = newTrimParts.iterator(); tsIter.hasNext();) {
			TrimPart ts = (TrimPart) tsIter.next();
			animation.addEndRect(DragUtil.getDisplayBounds(ts.getControl()));
		}

		animation.schedule();
	}

	/**
	 * Restores a part in the trim to the actual layout
	 * @param part The part to restore
	 */
	public void restoreTrimPart(LayoutPart part) {
		// Remove any current fastview
		setActiveFastView(null);

		// Set the part's state to place it back in the layout
		part.setTrimState(LayoutPart.TRIMSTATE_NORMAL);

		if (part == editorArea)
			showEditorArea();
		
		WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
		ITrimManager tbm = wbw.getTrimManager();
		tbm.forceLayout();
	}

	/**
	 * Determine the correct side to initially dock a new
	 * trim part on. We do this by checking its rect against
	 * the editor area.
	 * 
	 * @param stackBounds The bounds of the stack we want to create trim for
	 * @return the SWT side to dock the trim element on
	 */
	public int calcStackSide(Rectangle stackBounds) {
		// Where is the stack in relation to the EditorArea?
		Rectangle editorAreaBounds = editorArea.getBounds();
		
		// Is this the Editor Area
		if (editorAreaBounds.equals(stackBounds))
			return SWT.TOP;
		
		Point stackCenter = Geometry.centerPoint(stackBounds);
		Point editorAreaCenter = Geometry.centerPoint(editorAreaBounds);

		int dx = editorAreaCenter.x - stackCenter.x;
		int dy = editorAreaCenter.y - stackCenter.y;

		if (Math.abs(dx) > Math.abs(dy)) {
			return (dx > 0) ? SWT.LEFT : SWT.RIGHT;
		}

		return (dy > 0) ? SWT.TOP : SWT.BOTTOM;
	}

	/**
	 * Restore any parts that are showing in the trim as
	 * a result of a 'zoom' operation
	 */
	public void restoreZoomedParts() {
		// Remove any current fastview
		setActiveFastView(null);

		// Is the editotr 'zoomed'?
		boolean editorZoomed = (editorHolder != null &&
			editorArea.getTrimState() == LayoutPart.TRIMSTATE_ZOOMEDTOTRIM);
			
		// have the layout restore the parts
		boolean needsLayout = presentation.getLayout().restoreZoomedTrimParts();
		if (needsLayout) {
			// Force a layout
			WorkbenchWindow wbw = (WorkbenchWindow) page.getWorkbenchWindow();
			ITrimManager tbm = wbw.getTrimManager();
			tbm.forceLayout();
		}
		
		if (editorZoomed) {
			editorArea.setTrimState(LayoutPart.TRIMSTATE_NORMAL);
			showEditorArea();
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2006 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.internal;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.ToolItem;

/**
 * A trim element representing the EditorArea
 * 
 * @since 3.3
 *
 */
public class EditorAreaTrimPart extends TrimPart {

	public EditorAreaTrimPart(WorkbenchWindow window, EditorSashContainer editorArea) {
		super(window, editorArea);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.TrimPart#addItems()
	 */
	protected void addItems() {
        // Since we dont have fast view behaviour for ediors we
		// simply restore the editor area on selection
        ToolItem editorAreaItem = new  ToolItem(toolBar, SWT.PUSH, toolBar.getItemCount());        
        Image tbImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_ETOOL_EDITOR_TRIMPART);
        editorAreaItem.setImage(tbImage);       
        String menuTip = WorkbenchMessages.EditorArea_Tooltip;
        editorAreaItem.setToolTipText(menuTip);
        editorAreaItem.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {
				restorePart();
			}
			public void widgetSelected(SelectionEvent e) {
				restorePart();
			}
        });
	}

}




/*******************************************************************************
 * Copyright (c) 2006 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.internal;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.util.Geometry;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.internal.presentations.PresentablePart;
import org.eclipse.ui.internal.presentations.util.TabbedStackPresentation;
import org.eclipse.ui.presentations.IPresentablePart;

/**
 * A trim element representing a ViewStack in the trim.
 * <p>
 * The placeholder must be non-null and its
 * 'real' container must be a <code>ViewStack</code>.
 * </p>
 * 
 * @since 3.3
 *
 */
public class ViewStackTrimPart extends TrimPart {	
	ContainerPlaceholder placeHolder;	
	ViewStack stack;
	
	// The orientation of the fast view pane when showing a view
	int paneOrientation;
	
	/**
	 * Construct a new trim element for the given ViewStack
	 * 
	 * @param window The window hosting the trim
	 * @param placeHolder The placeholder who's real container is
	 * the ViewStack being represented. 
	 */
	public ViewStackTrimPart(WorkbenchWindow window, ContainerPlaceholder placeHolder) {
		super(window, placeHolder.getRealContainer());

		setPlaceholder(placeHolder);

		// Set the display orientation based on the stack's geometry
    	Rectangle stackBounds = stack.getBounds();
    	paneOrientation = (stackBounds.width > stackBounds.height) ? SWT.HORIZONTAL : SWT.VERTICAL;
	}   	

	/**
	 * Sets the current placeholder. This is used by the ViewStack
	 * when its trim state changes, causing it to create a new placeholder.
	 * 
	 * @param placeHolder the current placeholder
	 */
	public void setPlaceholder(ContainerPlaceholder placeHolder) {
		this.placeHolder = placeHolder;
		this.stack = (ViewStack) placeHolder.getRealContainer();
	}

	/**
	 * Add a button for every view reference in the stack being
	 * represented.
	 */
	protected void addItems() {
		List orderedViews = getTrueViewOrder();
		if (orderedViews.size() == 0)
			return;
		
        // Add a button for each view reference in the stack
		for (Iterator iterator = orderedViews.iterator(); iterator.hasNext();) {
			IViewReference ref = (IViewReference) iterator.next();

			// Set up the item's 'look'
			ToolItem viewButton = new ToolItem(toolBar, SWT.CHECK);        
			viewButton.setImage(ref.getTitleImage());       
	        viewButton.setToolTipText(ref.getTitle());
	        viewButton.addSelectionListener(new SelectionListener() {
				public void widgetDefaultSelected(SelectionEvent e) {
					showView(e);
				}
				public void widgetSelected(SelectionEvent e) {
					showView(e);
				}
	        });
	        
	        viewButton.setData(ref);
		}
	}

	/**
	 * Returns the 'side' to place the current fast view on. This should
	 * really be changed...
	 * 
	 * @return The side (calc'd a la the FastViewBar:getViewSide method)
	 */
	public int getPaneOrientation() {
		// determine where the bar is in relation to the workbench window
		Rectangle tsBounds = getControl().getBounds();
		Rectangle wbBounds = getControl().getShell().getBounds();
		
	    if (paneOrientation == SWT.HORIZONTAL) {
	    	if (curSide == SWT.LEFT || curSide == SWT.RIGHT) {
	    		// is the trim bar nearer to the top or the bottom?
	    		if (Geometry.centerPoint(tsBounds).y < Geometry.centerPoint(wbBounds).y)
	    			return SWT.TOP;

	    		return SWT.BOTTOM;
	    	}

    		return curSide;
	    }
	
	    // Vertical
		if (curSide == SWT.TOP || curSide == SWT.BOTTOM) {
			// is the trim bar nearer to the left or the right?
			if (Geometry.centerPoint(tsBounds).x < Geometry.centerPoint(wbBounds).x)
				return SWT.LEFT;

			return SWT.RIGHT;
		}

		return curSide;
	}

	/**
	 * Show the selected view as a fast view.
	 * 
	 * @param e The event causing the view to be shown
	 * 
	 */
	protected void showView(SelectionEvent e) {
		Perspective persp = window.getActiveWorkbenchPage().getActivePerspective();
		ToolItem item = (ToolItem) e.getSource();
		IViewReference ref = (IViewReference) item.getData();
		persp.toggleFastView(ref);
	}

	/**
	 * @return a List of <code>IViewReference</code>
	 * sorted into the order in which they appear in the
	 * visual stack.
	 */
	private List getTrueViewOrder() {
		List orderedViews = new ArrayList();
		if (stack.getPresentation() instanceof TabbedStackPresentation) {
			TabbedStackPresentation tsp = (TabbedStackPresentation) stack.getPresentation();
			
			// KLUDGE!! uses a 'testing only' API
			IPresentablePart[] parts = tsp.getPartList();
			for (int i = 0; i < parts.length; i++) {
				if (parts[i] instanceof PresentablePart) {
					PresentablePart part = (PresentablePart) parts[i];
					IWorkbenchPartReference ref = part.getPane().getPartReference();
					if (ref instanceof IViewReference)
						orderedViews.add(ref);		
				}
			}
		}
		
		return orderedViews;
	}
	
	/**
	 * @param refToFind The reference being checked for
	 * @return true if this stack owns the reference.
	 */
	public boolean hasViewRef(IViewReference refToFind) {
		ToolItem[] items = toolBar.getItems();
		for (int i = 0; i < items.length; i++) {
			IViewReference ref = (IViewReference) items[i].getData();
			if (ref == refToFind)
				return true;
		}
		
		return false;
	}

	/**
	 * @return The list of all view references in the stack
	 */
	public List getViewRefs() {
		List refs = new ArrayList(toolBar.getItemCount());
		ToolItem[] items = toolBar.getItems();
		for (int i = 0; i < items.length; i++) {
			Object data = items[i].getData();
			if (data instanceof IViewReference)
				refs.add(data);
		}
		
		return refs;
	}
	
	/**
	 * @return The side that the fast view pane should be attached to
	 * based on the position of the trim element.
	 */
	public int getViewSide() {
        if (paneOrientation == SWT.HORIZONTAL) {
        	if (curSide == SWT.TOP || curSide == SWT.BOTTOM)
        		return curSide;
        	
        	return SWT.TOP;
        }
        
        // Vertical
        if (curSide == SWT.LEFT || curSide == SWT.RIGHT)
        	return curSide;
        
        // Are we on the left or right 'end' of the trim area?
        Point trimCenter = Geometry.centerPoint(getControl().getBounds());
        Point shellCenter = Geometry.centerPoint(getControl().getShell().getClientArea());
        return (trimCenter.x < shellCenter.x) ? SWT.LEFT : SWT.RIGHT;
	}

	/**
	 * @return the current placeholder
	 */
	public ContainerPlaceholder getPlaceholder() {
		return placeHolder;
	}

	/**
	 * This is used by the Perspective to match the icon's
	 * state to the state of the active fast view.
	 *  
	 * @param refToSet The view reference to set the state of
	 * @param selected The new state for the icon
	 */
	public void setIconSelection(IViewReference refToSet, boolean selected) {
		ToolItem[] items = toolBar.getItems();
		for (int i = 0; i < items.length; i++) {
			IViewReference ref = (IViewReference) items[i].getData();
			if (ref == refToSet)
				items[i].setSelection(selected);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2006 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.internal;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.ui.internal.layout.IWindowTrim;

/**
 * This is the base class to use to represent a LayoutPart when
 * it is being displayed in the trim.
 * <p>
 * It manages the life-cycle of the control and its contents but
 * requres that subclasses populate the ToolBar with its own items
 * and the logic to control them.
 * 
 * @since 3.3
 *
 */
public abstract class TrimPart implements IWindowTrim {
	// State
	protected WorkbenchWindow window;
	protected LayoutPart part;
	
	// Trim State
	protected ToolBar toolBar = null;
	protected int curSide;

	// Abstract methods for subclass's life-cycle
	
	/**
	 * Add the items appropiate for the particular
	 * subclass.
	 */
	protected abstract void addItems();
	
	/**
	 * Constructs a trim element for some LayoutPart
	 * 
	 * @param window The window hosting this trim element
	 * @param part The LayoutPart being represented
	 */
	public TrimPart(WorkbenchWindow window, LayoutPart part) {
		this.window = window;		
		this.part = part;
	}   	

	// TrimPart Life-cycle
	
	/**
	 * Put the stack back into the presentation
	 */
	protected void restorePart() {
		Perspective persp = window.getActiveWorkbenchPage().getActivePerspective();
		
		if (part != null)
			persp.restoreTrimPart(part);
	}

	/**
	 * Clear items added by the subclass. The subclass should
	 * add a dispose listener if it needs to clean up...
	 */
	private void clearContributions() {
		// Clear all items -except- the restore button
		ToolItem[] items = toolBar.getItems();
		for (int i = 1; i < items.length; i++) {
			items[i].dispose();
		}
	}
	
	/**
	 * Cycle the contents of the part in order to pick
	 * up any changes in the actual part that the trim
	 * is representing. 
	 */
	public void refresh() {
		clearContributions();
		addItems();
	}
	
	// IWindowTrim handling

	/**
	 * Create the Toolbar
	 */
	private void createControl() {
		int orientation = (curSide == SWT.TOP || curSide == SWT.BOTTOM) ? 
				SWT.HORIZONTAL : SWT.VERTICAL;
		toolBar = new ToolBar(window.getShell(), orientation);
		
        // Construct the 'restore' button
        ToolItem restoreItem = new  ToolItem(toolBar, SWT.PUSH, 0);        
        Image tbImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_ETOOL_RESTORE_TRIMPART);
        restoreItem.setImage(tbImage);       
        String menuTip = WorkbenchMessages.StandardSystemToolbar_Restore;
        restoreItem.setToolTipText(menuTip);
        restoreItem.addSelectionListener(new SelectionListener() {
			public void widgetDefaultSelected(SelectionEvent e) {
				restorePart();
			}
			public void widgetSelected(SelectionEvent e) {
				restorePart();
			}
        });
        
		// refresh the bar's contents
		addItems();
	}

	private void dispose() {
		if (toolBar != null)
			toolBar.dispose();
		toolBar = null;
	}
	
	public void dock(int dropSide) {
		curSide = dropSide;
	
		// Re-create the toolBar
		dispose();
		createControl();
	}

	public Control getControl() {
		return toolBar;
	}

	public String getDisplayName() {
		return part.getID();
	}

	public int getHeightHint() {
		Point cs =  toolBar.computeSize(SWT.DEFAULT, SWT.DEFAULT);
		return cs.y;
	}

	public String getId() {
		return part.getID();
	}

	public int getValidSides() {
		return SWT.TOP | SWT.BOTTOM | SWT.LEFT | SWT.RIGHT;
	}

	public int getWidthHint() {
		return toolBar.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
	}

	public void handleClose() {
	}

	public boolean isCloseable() {
		return false;
	}

	public boolean isResizeable() {
		return false;
	}

	public int getCurrentSide() {
		return curSide;
	}

}

Return to bug 153957

Lines 35-40 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/PartSashContainer.java (-32 / +42 lines)
35	import org.eclipse.ui.internal.dnd.IDropTarget;	35	import org.eclipse.ui.internal.dnd.IDropTarget;
36	import org.eclipse.ui.internal.dnd.SwtUtil;	36	import org.eclipse.ui.internal.dnd.SwtUtil;
37	import org.eclipse.ui.internal.util.PrefUtil;	37	import org.eclipse.ui.internal.util.PrefUtil;
		38	import org.eclipse.ui.presentations.IStackPresentationSite;
38		39
39	/**	40	/**
40	* Abstract container that groups various layout	41	* Abstract container that groups various layout
Lines 57-63 Link Here
57	private LayoutPart zoomedPart;	58	private LayoutPart zoomedPart;
58		59
59	// 'Smart' zoom	60	// 'Smart' zoom
60	private boolean smartZoomed = false;	61	private LayoutPart smartZoomedPart = null;
61		62
62	protected WorkbenchPage page;	63	protected WorkbenchPage page;
63		64
Lines 853-903 Link Here
853	this.parent.setBounds(r);	854	this.parent.setBounds(r);
854	}	855	}
855		856
856	private void smartZoomIn(LayoutPart part, Perspective persp) {	857	private void smartZoomIn(LayoutPart zoomingPart, Perspective persp) {
857	// HACK!! since we aren't changing the 'state' maximize always	858	// Prevent recursion
858	// get called; 'unzoom' if necessary	859	if (smartZoomedPart != null)
859	if (smartZoomed) {	860	return;
860	// Restore the editor area if necessary
861	persp.showEditorArea();
862
863	// Restore (close) and groups created during a zoom
864	persp.restoreZoomGroups();
865
866	// we're 'unzoomed'
867	smartZoomed = false;
868
869	// Remember that we need to trigger a layout
870	layoutDirty = true;
871
872	return;
873	}
874		861
875	// 'Smart'(?) zoom...'minimize' all view stacks except the	862	// 'Smart'(?) zoom...'minimize' all view stacks except the
876	// one we're zooming. If we're zooming the editor then -all-	863	// one we're zooming. If we're zooming the editor then -all-
877	// view stacks get minimized	864	// view stacks get minimized
878	LayoutPart[] children = getChildren();	865	LayoutPart[] children = getChildren();
879	List stacks = new ArrayList();	866	List trimParts = new ArrayList();
880	for (int i = 0; i < children.length; i++) {	867	for (int i = 0; i < children.length; i++) {
881	LayoutPart child = children[i];	868	if (children[i] != zoomingPart)
882	// Close the editor stack unless it's the 'zooming' part	869	trimParts.add(children[i]);
883	if (child instanceof EditorSashContainer && child != part) {
884	persp.hideEditorArea();
885	}
886	else if (child instanceof ViewStack) {
887	if (child != part) {
888	stacks.add(child);
889	}
890	}
891	}	870	}
892		871
893	persp.moveToTrim(stacks, FastViewBar.GROUP_FVB \| FastViewBar.ZOOM_GROUP);	872	persp.movePartsToTrim(trimParts, true);
894		873
895	// We're -not- really zoomed, don't lie	874	// We're -not- really zoomed, don't lie
896	zoomedPart = null;	875	zoomedPart = null;
897		876
898	// ...but we're 'zoomed'	877	// ...but we're 'zoomed'
899	smartZoomed = true;	878	smartZoomedPart = zoomingPart;
900		879
		880	if (smartZoomedPart instanceof PartStack) {
		881	((PartStack)smartZoomedPart).setPresentationState(IStackPresentationSite.STATE_MAXIMIZED);
		882	}
		883	// Remember that we need to trigger a layout
		884	layoutDirty = true;
		885	}
		886
		887	private void smartZoomOut(Perspective persp) {
		888	// Prevent recursion
		889	if (smartZoomedPart == null)
		890	return;
		891
		892	// we're 'unzoomed'
		893	LayoutPart zoomedPartCache = smartZoomedPart;
		894	smartZoomedPart = null;
		895
		896	// Restore (close) trim parts created during a zoom
		897	persp.restoreZoomedParts();
		898
		899	if (zoomedPartCache instanceof PartStack) {
		900	((PartStack)zoomedPartCache).setPresentationState(IStackPresentationSite.STATE_RESTORED);
		901	}
901	// Remember that we need to trigger a layout	902	// Remember that we need to trigger a layout
902	layoutDirty = true;	903	layoutDirty = true;
903	}	904	}
Lines 1024-1029 Link Here
1024	* Note: Method assumes we are active.	1025	* Note: Method assumes we are active.
1025	*/	1026	*/
1026	private void zoomOut() {	1027	private void zoomOut() {
		1028	// 'Smart'? Zoom out
		1029	Perspective persp = this.getPage().getActivePerspective();
		1030	IPreferenceStore preferenceStore = PrefUtil.getAPIPreferenceStore();
		1031	boolean useNewMinMax = preferenceStore.getBoolean(IWorkbenchPreferenceConstants.ENABLE_NEW_MIN_MAX);
		1032	if (useNewMinMax) {
		1033	smartZoomOut(persp);
		1034	return;
		1035	}
		1036
1027	// Sanity check.	1037	// Sanity check.
1028	if (!isZoomed()) {	1038	if (!isZoomed()) {
1029	return;	1039	return;

Lines 182-191 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/FastViewBar.java (-7 / +5 lines)
182	ViewPane pane = (ViewPane) iter.next();	182	ViewPane pane = (ViewPane) iter.next();
183	IViewReference ref = pane.getViewReference();	183	IViewReference ref = pane.getViewReference();
184		184
185	// Only allow one reference in an FVB per perspective	185	// Drop only occurs on the global fast view bar
186	FastViewBar curFVB = getPage().getActivePerspective().getFVBForRef(ref);	186	FastViewBar curFVB = window.getFastViewBar();
187	if (curFVB == null && window.getFastViewBar().hasViewRef(ref))
188	curFVB = window.getFastViewBar();
189		187
190	if (curFVB != null) {	188	if (curFVB != null) {
191	curFVB.removeViewRef(ref);	189	curFVB.removeViewRef(ref);
Lines 483-489 Link Here
483	// Construct an item to act as a 'menu button' (a la the PerspectiveSwitcher)	481	// Construct an item to act as a 'menu button' (a la the PerspectiveSwitcher)
484	restoreItem = new ToolItem(menuTB, SWT.PUSH, 0);	482	restoreItem = new ToolItem(menuTB, SWT.PUSH, 0);
485		483
486	Image tbImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_ETOOL_RESTORE_FASTVIEW);	484	Image tbImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_ETOOL_RESTORE_TRIMPART);
487	restoreItem.setImage(tbImage);	485	restoreItem.setImage(tbImage);
488		486
489	String menuTip = WorkbenchMessages.StandardSystemToolbar_Restore;	487	String menuTip = WorkbenchMessages.StandardSystemToolbar_Restore;
Lines 1160-1167 Link Here
1160	* Restore all refs and close the group	1158	* Restore all refs and close the group
1161	*/	1159	*/
1162	public void closeGroup() {	1160	public void closeGroup() {
1163	Perspective persp = window.getActiveWorkbenchPage().getActivePerspective();	1161	// Perspective persp = window.getActiveWorkbenchPage().getActivePerspective();
1164	persp.closeTrimGroup(this);	1162	// persp.closeTrimGroup(this);
1165	}	1163	}
1166		1164
1167	/**	1165	/**

Lines 149-152 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/ContainerPlaceholder.java (+18 lines)
149	public boolean childIsZoomed(LayoutPart toTest) {	149	public boolean childIsZoomed(LayoutPart toTest) {
150	return false;	150	return false;
151	}	151	}
		152
		153	/* (non-Javadoc)
		154	* @see org.eclipse.ui.internal.LayoutPart#setTrimState(int)
		155	*/
		156	public void setTrimState(int newTrimState) {
		157	if (realContainer != null)
		158	getRealContainer().setTrimState(newTrimState);
		159	}
		160
		161	/* (non-Javadoc)
		162	* @see org.eclipse.ui.internal.LayoutPart#getTrimState()
		163	*/
		164	public int getTrimState() {
		165	if (realContainer != null)
		166	return getRealContainer().getTrimState();
		167
		168	return super.getTrimState();
		169	}
152	}	170	}

Lines 225-235 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/WorkbenchImages.java (-2 / +5 lines)
225		225
226	declareImage(IWorkbenchGraphicConstants.IMG_ETOOL_NEW_FASTVIEW,	226	declareImage(IWorkbenchGraphicConstants.IMG_ETOOL_NEW_FASTVIEW,
227	PATH_ETOOL + "new_fastview.gif", true); //$NON-NLS-1$	227	PATH_ETOOL + "new_fastview.gif", true); //$NON-NLS-1$
228	declareImage(IWorkbenchGraphicConstants.IMG_ETOOL_RESTORE_FASTVIEW,
229	PATH_ETOOL + "fastview_restore.gif", true); //$NON-NLS-1$
230	declareImage(IWorkbenchGraphicConstants.IMG_DTOOL_NEW_FASTVIEW,	228	declareImage(IWorkbenchGraphicConstants.IMG_DTOOL_NEW_FASTVIEW,
231	PATH_DTOOL + "new_fastview.gif", true); //$NON-NLS-1$	229	PATH_DTOOL + "new_fastview.gif", true); //$NON-NLS-1$
232		230
		231	declareImage(IWorkbenchGraphicConstants.IMG_ETOOL_RESTORE_TRIMPART,
		232	PATH_ETOOL + "fastview_restore.gif", true); //$NON-NLS-1$
		233	declareImage(IWorkbenchGraphicConstants.IMG_ETOOL_EDITOR_TRIMPART,
		234	PATH_ETOOL + "editor_area.gif", true); //$NON-NLS-1$
		235
233	declareImage(ISharedImages.IMG_TOOL_FORWARD, PATH_ELOCALTOOL	236	declareImage(ISharedImages.IMG_TOOL_FORWARD, PATH_ELOCALTOOL
234	+ "forward_nav.gif", true); //$NON-NLS-1$	237	+ "forward_nav.gif", true); //$NON-NLS-1$
235	declareImage(ISharedImages.IMG_TOOL_FORWARD_HOVER, PATH_ELOCALTOOL	238	declareImage(ISharedImages.IMG_TOOL_FORWARD_HOVER, PATH_ELOCALTOOL

Removed Link Here

(-)Eclipse UI/org/eclipse/ui/internal/FastGroupTrimButton.java (-269 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.internal;
12
13	import org.eclipse.swt.SWT;
14	import org.eclipse.swt.events.MouseEvent;
15	import org.eclipse.swt.events.MouseListener;
16	import org.eclipse.swt.events.MouseMoveListener;
17	import org.eclipse.swt.events.MouseTrackListener;
18	import org.eclipse.swt.events.PaintEvent;
19	import org.eclipse.swt.events.PaintListener;
20	import org.eclipse.swt.graphics.Color;
21	import org.eclipse.swt.graphics.GC;
22	import org.eclipse.swt.graphics.Rectangle;
23	import org.eclipse.swt.widgets.Canvas;
24	import org.eclipse.swt.widgets.Composite;
25	import org.eclipse.swt.widgets.Control;
26
27	/**
28	* Implements the 'group' handling for trim groups
29	*
30	* @since 3.2
31	*
32	*/
33	public class FastGroupTrimButton {
34	private Canvas button;
35	private FastViewBar fvb;
36	private int side;
37	private Color btnColor;
38
39	private Rectangle closeRect;
40	private Rectangle restoreRect;
41	private Rectangle collapseRect;
42
43	private static final int CTRL_AREA_NONE = 0;
44	private static final int CTRL_AREA_CLOSE = 1;
45	private static final int CTRL_AREA_RESTORE = 2;
46	private static final int CTRL_AREA_COLLAPSE = 3;
47
48	private int curCtrlArea = CTRL_AREA_NONE;
49	private boolean inControl = false;
50	private String toolTip;
51
52	public FastGroupTrimButton(Composite parent, FastViewBar fvb) {
53	this.fvb = fvb;
54
55	if (fvb != null)
56	side = fvb.getSide();
57	else
58	side = SWT.BOTTOM;
59
60	btnColor = parent.getDisplay().getSystemColor(SWT.COLOR_BLACK);
61
62	button = new Canvas(parent, SWT.NONE);
63	button.addPaintListener(new PaintListener() {
64	public void paintControl(PaintEvent e) {
65	e.gc.setForeground(btnColor);
66	paintButtons(e);
67	}
68	});
69
70	button.addMouseTrackListener(new MouseTrackListener() {
71	public void mouseEnter(MouseEvent e) {
72	inControl = true;
73	// Provide 'track' feedback?
74	}
75	public void mouseExit(MouseEvent e) {
76	inControl = false;
77	// remove 'track' feedback?
78	}
79	public void mouseHover(MouseEvent e) {
80	button.setToolTipText(toolTip);
81	}
82	});
83
84	button.addMouseMoveListener(new MouseMoveListener() {
85	public void mouseMove(MouseEvent e) {
86	if (closeRect.contains(e.x,e.y)) {
87	curCtrlArea = CTRL_AREA_CLOSE;
88	toolTip = "Close Group"; //$NON-NLS-1$
89	}
90	else if (restoreRect.contains(e.x,e.y)) {
91	curCtrlArea = CTRL_AREA_RESTORE;
92	toolTip = "Restore Group"; //$NON-NLS-1$
93	}
94	else if (collapseRect.contains(e.x,e.y)) {
95	curCtrlArea = CTRL_AREA_COLLAPSE;
96	toolTip = "Collapse Group"; //$NON-NLS-1$
97	}
98	else
99	curCtrlArea = CTRL_AREA_NONE;
100	}
101	});
102	button.addMouseListener(new MouseListener() {
103	public void mouseDoubleClick(MouseEvent e) {}
104	public void mouseUp(MouseEvent e) {}
105	public void mouseDown(MouseEvent e) {
106	if (inControl && curCtrlArea != CTRL_AREA_NONE) {
107	switch (curCtrlArea) {
108	case CTRL_AREA_CLOSE:
109	FastGroupTrimButton.this.fvb.closeGroup();
110	break;
111	case CTRL_AREA_COLLAPSE:
112	FastGroupTrimButton.this.fvb.collapseGroup();
113	break;
114	case CTRL_AREA_RESTORE:
115	FastGroupTrimButton.this.fvb.restoreGroup();
116	break;
117	}
118	}
119	}
120	});
121	}
122
123	public void setSize(int size) {
124	button.setSize(size, size);
125	}
126
127	protected void paintButtons(PaintEvent e) {
128	Rectangle bb = button.getBounds();
129	setButtonRects(bb);
130
131	paintClose(e.gc);
132	paintRestore(e.gc);
133	paintCollapse(e.gc);
134	}
135
136	private void paintCollapse(GC gc) {
137	switch(side) {
138	case SWT.BOTTOM:
139	drawDownArrow(gc, collapseRect);
140	break;
141	case SWT.TOP:
142	drawUpArrow(gc, collapseRect);
143	break;
144	case SWT.LEFT:
145	drawLeftArrow(gc, collapseRect);
146	break;
147	case SWT.RIGHT:
148	drawRightArrow(gc, collapseRect);
149	break;
150	}
151	}
152
153	private void paintRestore(GC gc) {
154	switch(side) {
155	case SWT.BOTTOM:
156	drawUpArrow(gc, restoreRect);
157	break;
158	case SWT.TOP:
159	drawDownArrow(gc, restoreRect);
160	break;
161	case SWT.LEFT:
162	drawRightArrow(gc, restoreRect);
163	break;
164	case SWT.RIGHT:
165	drawLeftArrow(gc, restoreRect);
166	break;
167	}
168	}
169
170	private void paintClose(GC gc) {
171	int border = 2;
172	gc.drawLine(closeRect.x+border, closeRect.y+border, (closeRect.x+closeRect.width)-border, (closeRect.y+closeRect.height)-border);
173	gc.drawLine((closeRect.x+closeRect.width)-border, closeRect.y+border, closeRect.x+border, (closeRect.y+closeRect.height)-border);
174	// int minX = closeRect.x + 2;
175	// int maxX = (closeRect.x+closeRect.width) - 2;
176	// int stopMax = maxX;
177	// int y = (closeRect.y + (closeRect.height)/2) - ((maxX-minX)/2);
178	//
179	// while (minX <= stopMax) {
180	// gc.drawLine(minX, y, minX, y);
181	// gc.drawLine(maxX, y, maxX, y);
182	// minX++; maxX--; y++;
183	// }
184	}
185
186	private void drawDownArrow(GC gc, Rectangle rect) {
187	int y = rect.y + 1;
188	int minX = rect.x + 2;
189	int maxX = (rect.x+rect.width) - 2;
190
191	while (minX <= maxX) {
192	gc.drawLine(minX, y, maxX, y);
193	y++;
194	gc.drawLine(minX, y, maxX, y);
195	minX++; maxX--; y++;
196	}
197	}
198
199	private void drawRightArrow(GC gc, Rectangle rect) {
200	int x = rect.x + 1;
201	int minY = rect.y + 2;
202	int maxY = (rect.y+rect.height) - 2;
203
204	while (minY <= maxY) {
205	gc.drawLine(x, minY, x, maxY);
206	x++;
207	gc.drawLine(x, minY, x, maxY);
208	minY++; maxY--; x++;
209	}
210	}
211
212	private void drawUpArrow(GC gc, Rectangle rect) {
213	int y = (rect.y+rect.height) - 1;
214	int minX = rect.x + 2;
215	int maxX = (rect.x+rect.width) - 2;
216
217	while (minX <= maxX) {
218	gc.drawLine(minX, y, maxX, y);
219	y--;
220	gc.drawLine(minX, y, maxX, y);
221	minX++; maxX--; y--;
222	}
223	}
224
225	private void drawLeftArrow(GC gc, Rectangle rect) {
226	int x = (rect.x+rect.width) - 1;
227	int minY = rect.y + 2;
228	int maxY = (rect.y+rect.height) - 2;
229
230	while (minY <= maxY) {
231	gc.drawLine(x, minY, x, maxY);
232	x--;
233	gc.drawLine(x, minY, x, maxY);
234	minY++; maxY--; x--;
235	}
236	}
237
238	private void setButtonRects(Rectangle bb) {
239	int hw = bb.width/2;
240	int hh = bb.height/2;
241
242	switch (side) {
243	case SWT.BOTTOM:
244	closeRect = new Rectangle(bb.x, bb.y+(bb.height/4), hw, hh);
245	restoreRect = new Rectangle(bb.x+hw, bb.y, hw, hh);
246	collapseRect = new Rectangle(bb.x+hw, bb.y+hh, hw, hh);
247	break;
248	case SWT.TOP:
249	closeRect = new Rectangle(bb.x, bb.y+(bb.height/4), hw, hh);
250	collapseRect = new Rectangle(bb.x+hw, bb.y, hw, hh);
251	restoreRect = new Rectangle(bb.x+hw, bb.y+hh, hw, hh);
252	break;
253	case SWT.LEFT:
254	closeRect = new Rectangle(bb.x+(bb.width/4), bb.y, hw, hh);
255	collapseRect = new Rectangle(bb.x, bb.y+hh, hw, hh);
256	restoreRect = new Rectangle(bb.x+hw, bb.y+hh, hw, hh);
257	break;
258	case SWT.RIGHT:
259	closeRect = new Rectangle(bb.x+(bb.width/4), bb.y, hw, hh);
260	restoreRect = new Rectangle(bb.x, bb.y+hh, hw, hh);
261	collapseRect = new Rectangle(bb.x+hw, bb.y+hh, hw, hh);
262	break;
263	}
264	}
265
266	public Control getControl() {
267	return button;
268	}
269	}

Added Link Here

(-)Eclipse (+53 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal;
13
14	import org.eclipse.swt.SWT;
15	import org.eclipse.swt.events.SelectionEvent;
16	import org.eclipse.swt.events.SelectionListener;
17	import org.eclipse.swt.graphics.Image;
18	import org.eclipse.swt.widgets.ToolItem;
19
20	/**
21	* A trim element representing the EditorArea
22	*
23	* @since 3.3
24	*
25	*/
26	public class EditorAreaTrimPart extends TrimPart {
27
28	public EditorAreaTrimPart(WorkbenchWindow window, EditorSashContainer editorArea) {
29	super(window, editorArea);
30	}
31
32	/* (non-Javadoc)
33	* @see org.eclipse.ui.internal.TrimPart#addItems()
34	*/
35	protected void addItems() {
36	// Since we dont have fast view behaviour for ediors we
37	// simply restore the editor area on selection
38	ToolItem editorAreaItem = new ToolItem(toolBar, SWT.PUSH, toolBar.getItemCount());
39	Image tbImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_ETOOL_EDITOR_TRIMPART);
40	editorAreaItem.setImage(tbImage);
41	String menuTip = WorkbenchMessages.EditorArea_Tooltip;
42	editorAreaItem.setToolTipText(menuTip);
43	editorAreaItem.addSelectionListener(new SelectionListener() {
44	public void widgetDefaultSelected(SelectionEvent e) {
45	restorePart();
46	}
47	public void widgetSelected(SelectionEvent e) {
48	restorePart();
49	}
50	});
51	}
52
53	}

Added Link Here

(-)Eclipse (+253 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal;
13
14	import java.util.ArrayList;
15	import java.util.Iterator;
16	import java.util.List;
17
18	import org.eclipse.jface.util.Geometry;
19	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.events.SelectionEvent;
21	import org.eclipse.swt.events.SelectionListener;
22	import org.eclipse.swt.graphics.Point;
23	import org.eclipse.swt.graphics.Rectangle;
24	import org.eclipse.swt.widgets.ToolItem;
25	import org.eclipse.ui.IViewReference;
26	import org.eclipse.ui.IWorkbenchPartReference;
27	import org.eclipse.ui.internal.presentations.PresentablePart;
28	import org.eclipse.ui.internal.presentations.util.TabbedStackPresentation;
29	import org.eclipse.ui.presentations.IPresentablePart;
30
31	/**
32	* A trim element representing a ViewStack in the trim.
33	* <p>
34	* The placeholder must be non-null and its
35	* 'real' container must be a <code>ViewStack</code>.
36	* </p>
37	*
38	* @since 3.3
39	*
40	*/
41	public class ViewStackTrimPart extends TrimPart {
42	ContainerPlaceholder placeHolder;
43	ViewStack stack;
44
45	// The orientation of the fast view pane when showing a view
46	int paneOrientation;
47
48	/**
49	* Construct a new trim element for the given ViewStack
50	*
51	* @param window The window hosting the trim
52	* @param placeHolder The placeholder who's real container is
53	* the ViewStack being represented.
54	*/
55	public ViewStackTrimPart(WorkbenchWindow window, ContainerPlaceholder placeHolder) {
56	super(window, placeHolder.getRealContainer());
57
58	setPlaceholder(placeHolder);
59
60	// Set the display orientation based on the stack's geometry
61	Rectangle stackBounds = stack.getBounds();
62	paneOrientation = (stackBounds.width > stackBounds.height) ? SWT.HORIZONTAL : SWT.VERTICAL;
63	}
64
65	/**
66	* Sets the current placeholder. This is used by the ViewStack
67	* when its trim state changes, causing it to create a new placeholder.
68	*
69	* @param placeHolder the current placeholder
70	*/
71	public void setPlaceholder(ContainerPlaceholder placeHolder) {
72	this.placeHolder = placeHolder;
73	this.stack = (ViewStack) placeHolder.getRealContainer();
74	}
75
76	/**
77	* Add a button for every view reference in the stack being
78	* represented.
79	*/
80	protected void addItems() {
81	List orderedViews = getTrueViewOrder();
82	if (orderedViews.size() == 0)
83	return;
84
85	// Add a button for each view reference in the stack
86	for (Iterator iterator = orderedViews.iterator(); iterator.hasNext();) {
87	IViewReference ref = (IViewReference) iterator.next();
88
89	// Set up the item's 'look'
90	ToolItem viewButton = new ToolItem(toolBar, SWT.CHECK);
91	viewButton.setImage(ref.getTitleImage());
92	viewButton.setToolTipText(ref.getTitle());
93	viewButton.addSelectionListener(new SelectionListener() {
94	public void widgetDefaultSelected(SelectionEvent e) {
95	showView(e);
96	}
97	public void widgetSelected(SelectionEvent e) {
98	showView(e);
99	}
100	});
101
102	viewButton.setData(ref);
103	}
104	}
105
106	/**
107	* Returns the 'side' to place the current fast view on. This should
108	* really be changed...
109	*
110	* @return The side (calc'd a la the FastViewBar:getViewSide method)
111	*/
112	public int getPaneOrientation() {
113	// determine where the bar is in relation to the workbench window
114	Rectangle tsBounds = getControl().getBounds();
115	Rectangle wbBounds = getControl().getShell().getBounds();
116
117	if (paneOrientation == SWT.HORIZONTAL) {
118	if (curSide == SWT.LEFT \|\| curSide == SWT.RIGHT) {
119	// is the trim bar nearer to the top or the bottom?
120	if (Geometry.centerPoint(tsBounds).y < Geometry.centerPoint(wbBounds).y)
121	return SWT.TOP;
122
123	return SWT.BOTTOM;
124	}
125
126	return curSide;
127	}
128
129	// Vertical
130	if (curSide == SWT.TOP \|\| curSide == SWT.BOTTOM) {
131	// is the trim bar nearer to the left or the right?
132	if (Geometry.centerPoint(tsBounds).x < Geometry.centerPoint(wbBounds).x)
133	return SWT.LEFT;
134
135	return SWT.RIGHT;
136	}
137
138	return curSide;
139	}
140
141	/**
142	* Show the selected view as a fast view.
143	*
144	* @param e The event causing the view to be shown
145	*
146	*/
147	protected void showView(SelectionEvent e) {
148	Perspective persp = window.getActiveWorkbenchPage().getActivePerspective();
149	ToolItem item = (ToolItem) e.getSource();
150	IViewReference ref = (IViewReference) item.getData();
151	persp.toggleFastView(ref);
152	}
153
154	/**
155	* @return a List of <code>IViewReference</code>
156	* sorted into the order in which they appear in the
157	* visual stack.
158	*/
159	private List getTrueViewOrder() {
160	List orderedViews = new ArrayList();
161	if (stack.getPresentation() instanceof TabbedStackPresentation) {
162	TabbedStackPresentation tsp = (TabbedStackPresentation) stack.getPresentation();
163
164	// KLUDGE!! uses a 'testing only' API
165	IPresentablePart[] parts = tsp.getPartList();
166	for (int i = 0; i < parts.length; i++) {
167	if (parts[i] instanceof PresentablePart) {
168	PresentablePart part = (PresentablePart) parts[i];
169	IWorkbenchPartReference ref = part.getPane().getPartReference();
170	if (ref instanceof IViewReference)
171	orderedViews.add(ref);
172	}
173	}
174	}
175
176	return orderedViews;
177	}
178
179	/**
180	* @param refToFind The reference being checked for
181	* @return true if this stack owns the reference.
182	*/
183	public boolean hasViewRef(IViewReference refToFind) {
184	ToolItem[] items = toolBar.getItems();
185	for (int i = 0; i < items.length; i++) {
186	IViewReference ref = (IViewReference) items[i].getData();
187	if (ref == refToFind)
188	return true;
189	}
190
191	return false;
192	}
193
194	/**
195	* @return The list of all view references in the stack
196	*/
197	public List getViewRefs() {
198	List refs = new ArrayList(toolBar.getItemCount());
199	ToolItem[] items = toolBar.getItems();
200	for (int i = 0; i < items.length; i++) {
201	Object data = items[i].getData();
202	if (data instanceof IViewReference)
203	refs.add(data);
204	}
205
206	return refs;
207	}
208
209	/**
210	* @return The side that the fast view pane should be attached to
211	* based on the position of the trim element.
212	*/
213	public int getViewSide() {
214	if (paneOrientation == SWT.HORIZONTAL) {
215	if (curSide == SWT.TOP \|\| curSide == SWT.BOTTOM)
216	return curSide;
217
218	return SWT.TOP;
219	}
220
221	// Vertical
222	if (curSide == SWT.LEFT \|\| curSide == SWT.RIGHT)
223	return curSide;
224
225	// Are we on the left or right 'end' of the trim area?
226	Point trimCenter = Geometry.centerPoint(getControl().getBounds());
227	Point shellCenter = Geometry.centerPoint(getControl().getShell().getClientArea());
228	return (trimCenter.x < shellCenter.x) ? SWT.LEFT : SWT.RIGHT;
229	}
230
231	/**
232	* @return the current placeholder
233	*/
234	public ContainerPlaceholder getPlaceholder() {
235	return placeHolder;
236	}
237
238	/**
239	* This is used by the Perspective to match the icon's
240	* state to the state of the active fast view.
241	*
242	* @param refToSet The view reference to set the state of
243	* @param selected The new state for the icon
244	*/
245	public void setIconSelection(IViewReference refToSet, boolean selected) {
246	ToolItem[] items = toolBar.getItems();
247	for (int i = 0; i < items.length; i++) {
248	IViewReference ref = (IViewReference) items[i].getData();
249	if (ref == refToSet)
250	items[i].setSelection(selected);
251	}
252	}
253	}

Added Link Here

(-)Eclipse (+180 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal;
13
14	import org.eclipse.swt.SWT;
15	import org.eclipse.swt.events.SelectionEvent;
16	import org.eclipse.swt.events.SelectionListener;
17	import org.eclipse.swt.graphics.Image;
18	import org.eclipse.swt.graphics.Point;
19	import org.eclipse.swt.widgets.Control;
20	import org.eclipse.swt.widgets.ToolBar;
21	import org.eclipse.swt.widgets.ToolItem;
22	import org.eclipse.ui.internal.layout.IWindowTrim;
23
24	/**
25	* This is the base class to use to represent a LayoutPart when
26	* it is being displayed in the trim.
27	* <p>
28	* It manages the life-cycle of the control and its contents but
29	* requres that subclasses populate the ToolBar with its own items
30	* and the logic to control them.
31	*
32	* @since 3.3
33	*
34	*/
35	public abstract class TrimPart implements IWindowTrim {
36	// State
37	protected WorkbenchWindow window;
38	protected LayoutPart part;
39
40	// Trim State
41	protected ToolBar toolBar = null;
42	protected int curSide;
43
44	// Abstract methods for subclass's life-cycle
45
46	/**
47	* Add the items appropiate for the particular
48	* subclass.
49	*/
50	protected abstract void addItems();
51
52	/**
53	* Constructs a trim element for some LayoutPart
54	*
55	* @param window The window hosting this trim element
56	* @param part The LayoutPart being represented
57	*/
58	public TrimPart(WorkbenchWindow window, LayoutPart part) {
59	this.window = window;
60	this.part = part;
61	}
62
63	// TrimPart Life-cycle
64
65	/**
66	* Put the stack back into the presentation
67	*/
68	protected void restorePart() {
69	Perspective persp = window.getActiveWorkbenchPage().getActivePerspective();
70
71	if (part != null)
72	persp.restoreTrimPart(part);
73	}
74
75	/**
76	* Clear items added by the subclass. The subclass should
77	* add a dispose listener if it needs to clean up...
78	*/
79	private void clearContributions() {
80	// Clear all items -except- the restore button
81	ToolItem[] items = toolBar.getItems();
82	for (int i = 1; i < items.length; i++) {
83	items[i].dispose();
84	}
85	}
86
87	/**
88	* Cycle the contents of the part in order to pick
89	* up any changes in the actual part that the trim
90	* is representing.
91	*/
92	public void refresh() {
93	clearContributions();
94	addItems();
95	}
96
97	// IWindowTrim handling
98
99	/**
100	* Create the Toolbar
101	*/
102	private void createControl() {
103	int orientation = (curSide == SWT.TOP \|\| curSide == SWT.BOTTOM) ?
104	SWT.HORIZONTAL : SWT.VERTICAL;
105	toolBar = new ToolBar(window.getShell(), orientation);
106
107	// Construct the 'restore' button
108	ToolItem restoreItem = new ToolItem(toolBar, SWT.PUSH, 0);
109	Image tbImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_ETOOL_RESTORE_TRIMPART);
110	restoreItem.setImage(tbImage);
111	String menuTip = WorkbenchMessages.StandardSystemToolbar_Restore;
112	restoreItem.setToolTipText(menuTip);
113	restoreItem.addSelectionListener(new SelectionListener() {
114	public void widgetDefaultSelected(SelectionEvent e) {
115	restorePart();
116	}
117	public void widgetSelected(SelectionEvent e) {
118	restorePart();
119	}
120	});
121
122	// refresh the bar's contents
123	addItems();
124	}
125
126	private void dispose() {
127	if (toolBar != null)
128	toolBar.dispose();
129	toolBar = null;
130	}
131
132	public void dock(int dropSide) {
133	curSide = dropSide;
134
135	// Re-create the toolBar
136	dispose();
137	createControl();
138	}
139
140	public Control getControl() {
141	return toolBar;
142	}
143
144	public String getDisplayName() {
145	return part.getID();
146	}
147
148	public int getHeightHint() {
149	Point cs = toolBar.computeSize(SWT.DEFAULT, SWT.DEFAULT);
150	return cs.y;
151	}
152
153	public String getId() {
154	return part.getID();
155	}
156
157	public int getValidSides() {
158	return SWT.TOP \| SWT.BOTTOM \| SWT.LEFT \| SWT.RIGHT;
159	}
160
161	public int getWidthHint() {
162	return toolBar.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
163	}
164
165	public void handleClose() {
166	}
167
168	public boolean isCloseable() {
169	return false;
170	}
171
172	public boolean isResizeable() {
173	return false;
174	}
175
176	public int getCurrentSide() {
177	return curSide;
178	}
179
180	}