/*******************************************************************************
 * Copyright (c) 2004, 2008 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
 *     Chris Gross chris.gross@us.ibm.com Bug 107443
 *     Matthew Hatem Matthew_Hatem@notesdev.ibm.com Bug 189953
 *******************************************************************************/
package org.eclipse.ui.internal;

import org.eclipse.jface.action.ContributionItem;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.util.Geometry;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
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.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Sash;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.ui.ISizeProvider;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.internal.dnd.DragUtil;
import org.eclipse.ui.internal.presentations.PresentablePart;
import org.eclipse.ui.internal.presentations.SystemMenuFastView;
import org.eclipse.ui.internal.presentations.SystemMenuFastViewOrientation;
import org.eclipse.ui.internal.presentations.SystemMenuSizeFastView;
import org.eclipse.ui.internal.presentations.UpdatingActionContributionItem;
import org.eclipse.ui.presentations.AbstractPresentationFactory;
import org.eclipse.ui.presentations.IPresentablePart;
import org.eclipse.ui.presentations.IStackPresentationSite;
import org.eclipse.ui.presentations.StackPresentation;

/**
 * Handles the presentation of an active fastview. A fast view pane docks to one side of a
 * parent composite, and is capable of displaying a single view. The view may be resized.
 * Displaying a new view will hide any view currently being displayed in the pane. 
 * 
 * Currently, the fast view pane does not own or contain the view. It only controls the view's 
 * position and visibility.  
 * 
 * @see org.eclipse.ui.internal.FastViewBar
 */
public class FastViewPane {
    private int side = SWT.LEFT;

    private PresentablePart currentPane;

    private Composite clientComposite;
    
    private int minSize = 10;

    private int size;

    private Sash sash;
    
    private AbstractPresentationFactory presFactory;

    // Traverse listener -- listens to ESC and closes the active fastview 
    private Listener escapeListener = new Listener() {
        public void handleEvent(Event event) {
            if (event.character == SWT.ESC) {
                if (currentPane != null) {
                    currentPane.getPane().getPage().hideFastView();
                }
            }
        }
    };

    private DefaultStackPresentationSite site = new DefaultStackPresentationSite() {
        /* (non-Javadoc)
         * @see org.eclipse.ui.internal.skins.IPresentationSite#setState(int)
         */
        public void setState(int newState) {
            super.setState(newState);
            PartPane pane = currentPane.getPane();
            switch (newState) {
            case IStackPresentationSite.STATE_MINIMIZED:
                
                pane.getPage().hideFastView();
                break;
            case IStackPresentationSite.STATE_MAXIMIZED:
                pane.setZoomed(true);
                sash.setVisible(false);
                this.getPresentation().setBounds(getBounds());
                break;
            case IStackPresentationSite.STATE_RESTORED:
                pane.setZoomed(false);
                sash.setVisible(true);
                this.getPresentation().setBounds(getBounds());
                break;
            default:
            }
        }

        public void flushLayout() {
        	
        }
        
        public void close(IPresentablePart part) {
            if (!isCloseable(part)) {
                return;
            }
            IWorkbenchPartReference ref = currentPane.getPane().getPartReference();
            if (ref instanceof IViewReference) {
                currentPane.getPane().getPage().hideView((IViewReference)ref);
            }
        }

        public void close(IPresentablePart[] parts) {
            for (int idx = 0; idx < parts.length; idx++) {
                close(parts[idx]);
            }
        }

        /* (non-Javadoc)
         * @see org.eclipse.ui.internal.skins.IPresentationSite#dragStart(org.eclipse.ui.internal.skins.IPresentablePart, boolean)
         */
        public void dragStart(IPresentablePart beingDragged,
                Point initialPosition, boolean keyboard) {
            dragStart(initialPosition, keyboard);
        }

        /* (non-Javadoc)
         * @see org.eclipse.ui.internal.skins.IPresentationSite#dragStart(boolean)
         */
        public void dragStart(Point initialPosition, boolean keyboard) {
            if (!isPartMoveable()) {
				return;
			}

            PartPane pane = currentPane.getPane();

            Control control = this.getPresentation().getControl();

            Rectangle bounds = Geometry.toDisplay(clientComposite, control
                    .getBounds());

            WorkbenchPage page = pane.getPage();

            page.hideFastView();
            if (page.isZoomed()) {
                page.zoomOut();
            }

            DragUtil.performDrag(pane, bounds, initialPosition, !keyboard);
        }

        public IPresentablePart getSelectedPart() {
            return currentPane;
        }

        public void addSystemActions(IMenuManager menuManager) {
        	ViewStackTrimToolBar vstt = getTrim();
        	
            appendToGroupIfPossible(menuManager,
                    "misc", new SystemMenuFastViewOrientation(currentPane.getPane(), vstt)); //$NON-NLS-1$

            // Only add the 'Fast View' menu entry if the
        	// pane is showing a 'legacy' fast view
        	if (vstt == null) {
	            appendToGroupIfPossible(menuManager,
	                    "misc", new UpdatingActionContributionItem(fastViewAction)); //$NON-NLS-1$
        	}
        	
            appendToGroupIfPossible(menuManager,
                    "size", new SystemMenuSizeFastView(FastViewPane.this)); //$NON-NLS-1$
        }

        /**
         * Returns the ViewStackTrimToolBar which has caused the FV to be shown. If
         * <code>null</code> then we can assume it was the legacy FastViewBar.
         */
        private ViewStackTrimToolBar getTrim() {
        	if (currentPane == null || currentPane.getPane() == null)
        		return null;

            ViewStackTrimToolBar trim = null;

        	PartPane pane = currentPane.getPane();
        	if (pane instanceof ViewPane) {
        		ViewPane vp = (ViewPane) pane;
                Perspective persp = vp.getPage().getActivePerspective();
                IViewReference viewRef = vp.getViewReference();
                FastViewManager fvm = persp.getFastViewManager();
                
                String trimId = null;
                if (fvm != null)
                	trimId = fvm.getIdForRef(viewRef);

                if (trimId != null && !trimId.equals(FastViewBar.FASTVIEWBAR_ID))
                	trim = fvm.getViewStackTrimToolbar(trimId);
        	}
        	
        	return trim;
        }
        
        public boolean isPartMoveable(IPresentablePart toMove) {
            return isPartMoveable();
        }

        public boolean isStackMoveable() {
            // a fast view stack is moveable iff its part is moveable
            return isPartMoveable();
        }

        private boolean isPartMoveable() {
            if (currentPane == null) {
				return false;
			}
            Perspective perspective = currentPane.getPane().getPage()
                    .getActivePerspective();
            if (perspective == null) {
                // Shouldn't happen -- can't have a FastViewPane without a perspective
                return false;
            }
            
            IWorkbenchPartReference ref = currentPane.getPane().getPartReference();
            
            if (ref instanceof IViewReference) {
                return perspective.isMoveable((IViewReference)ref);
            }
            return true;
        }

        public boolean supportsState(int newState) {
            if (currentPane == null) {
				return false;
			}
            if (currentPane.getPane().getPage().isFixedLayout()) {
				return false;
			}
            return true;
        }

        public IPresentablePart[] getPartList() {
            return new IPresentablePart[] {getSelectedPart()};
        }

        /* (non-Javadoc)
         * @see org.eclipse.ui.presentations.IStackPresentationSite#getProperty(java.lang.String)
         */
        public String getProperty(String id) {
            // fast views stacks do not get arbitrary user properties.
            return null;
        }
    };

    private SystemMenuFastView fastViewAction = new SystemMenuFastView(site);

    private static void appendToGroupIfPossible(IMenuManager m, String groupId,
            ContributionItem item) {
        try {
            m.appendToGroup(groupId, item);
        } catch (IllegalArgumentException e) {
            m.add(item);
        }
    }

    private Listener mouseDownListener = new Listener() {
        public void handleEvent(Event event) {
            if (event.widget instanceof Control) {
                Control control = (Control) event.widget;

                if (control.getShell() != clientComposite.getShell()) {
                    return;
                }

                if (event.widget instanceof ToolBar) {
                    // Ignore mouse down on actual tool bar buttons
                    Point pt = new Point(event.x, event.y);
                    ToolBar toolBar = (ToolBar) event.widget;
                    if (toolBar.getItem(pt) != null) {
						return;
					}
                }

                Point loc = DragUtil.getEventLoc(event);

            	// 'Extrude' the rect -before- converting to Display coords
            	// to avoid Right-to-Left issues
                Rectangle bounds = clientComposite.getBounds();
                if (site.getState() != IStackPresentationSite.STATE_MAXIMIZED) {
                    bounds = Geometry.getExtrudedEdge(bounds, size + getSashSize(), side);
                }
                
                // Now map the bounds to display coords
                bounds = clientComposite.getDisplay().map(clientComposite, null, bounds);

                if (!bounds.contains(loc)) {
                    site.setState(IStackPresentationSite.STATE_MINIMIZED);
                }
            }
        }
    };

    public void moveSash() {
        final KeyListener listener = new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                if (e.character == SWT.ESC || e.character == '\r') {
                    currentPane.setFocus();
                }
            }
        };
        sash.addFocusListener(new FocusAdapter() {
            public void focusGained(FocusEvent e) {
                sash.setBackground(sash.getDisplay().getSystemColor(
                        SWT.COLOR_LIST_SELECTION));
                sash.addKeyListener(listener);
            }

            public void focusLost(FocusEvent e) {
                sash.setBackground(null);
                sash.removeKeyListener(listener);
            }
        });
        sash.setFocus();
    }

    private Listener resizeListener = new Listener() {
        public void handleEvent(Event event) {
            if (event.type == SWT.Resize && currentPane != null) {
                setSize(size);
            }
        }
    };

    private SelectionAdapter selectionListener = new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {

            if (currentPane != null) {
                Rectangle bounds = clientComposite.getClientArea();
                Point location = new Point(e.x, e.y);
                int distanceFromEdge = Geometry.getDistanceFromEdge(bounds,
                        location, side);

                if (!(side == SWT.TOP || side == SWT.LEFT)) {
                    distanceFromEdge -= getSashSize();
                }

                setSize(distanceFromEdge);

                if (e.detail != SWT.DRAG) {
                    updateFastViewSashBounds();
                    //					getPresentation().getControl().moveAbove(null);
                    //					currentPane.moveAbove(null); 
                    //					sash.moveAbove(null);
                    //currentPane.getControl().redraw();
                    sash.redraw();
                }
            }
        }
    };

    private void setSize(int size) {

        if (size < minSize) {
            size = minSize;
        }
        this.size = size;

        StackPresentation presentation = getPresentation();
        if (presentation == null || presentation.getControl().isDisposed()) {
            return;
        }
        getPresentation().setBounds(getBounds());
        updateFastViewSashBounds();
    }

    /**
     * Returns the current fastview size ratio. Returns 0.0 if there is no fastview visible.
     */
    public float getCurrentRatio() {
        if (currentPane == null) {
            return 0.0f;
        }

        boolean isVertical = !Geometry.isHorizontal(side);
        Rectangle clientArea = clientComposite.getClientArea();

        int clientSize = Geometry.getDimension(clientArea, isVertical);

        return (float) size / (float) clientSize;
    }

    private Rectangle getClientArea() {
        return clientComposite.getClientArea();
    }

    private Rectangle getBounds() {
        Rectangle bounds = getClientArea();

        if (site.getState() == IStackPresentationSite.STATE_MAXIMIZED) {
            return bounds;
        }

        boolean horizontal = Geometry.isHorizontal(side);

        int available = Geometry.getDimension(bounds, !horizontal);

        return Geometry.getExtrudedEdge(bounds, Math.min(
                FastViewPane.this.size, available), side);
    }

    /**
     * Displays the given view as a fastview. The view will be docked to the edge of the
     * given composite until it is subsequently hidden by a call to hideFastView. 
     * 
     * @param newClientComposite
     * @param pane
     * @param newSide
     */
    public void showView(Composite newClientComposite, ViewPane pane,
            int newSide, float sizeRatio) {
        side = newSide;

        if (currentPane != null) {
            hideView();
        }

        currentPane = new PresentablePart(pane, newClientComposite);
        
        fastViewAction.setPane(currentPane);
        clientComposite = newClientComposite;

        clientComposite.addListener(SWT.Resize, resizeListener);

        // Create the control first
        Control ctrl = pane.getControl();
        if (ctrl == null) {
            pane.createControl(clientComposite);
            ctrl = pane.getControl();
        }

        ctrl.addListener(SWT.Traverse, escapeListener);

        // Temporarily use the same appearance as docked views .. eventually, fastviews will
        // be independently pluggable.
        AbstractPresentationFactory factory = getPresentationFactory();
        StackPresentation presentation = factory.createViewPresentation(
                newClientComposite, site);

        site.setPresentation(presentation);
        site.setPresentationState(IStackPresentationSite.STATE_RESTORED);
        presentation.addPart(currentPane, null);
        presentation.selectPart(currentPane);
        presentation.setActive(StackPresentation.AS_ACTIVE_FOCUS);
        presentation.setVisible(true);

        boolean horizontalResize = Geometry.isHorizontal(side); 

        minSize = presentation.computePreferredSize(horizontalResize,
        		ISizeProvider.INFINITE,
        		Geometry.getDimension(getClientArea(), horizontalResize),
				0);
        
        // Show pane fast.
        ctrl.setEnabled(true); // Add focus support.
        Composite parent = ctrl.getParent();

        boolean horizontal = Geometry.isHorizontal(side);

        // Create a sash of the correct style using the factory
        int style = AbstractPresentationFactory.SASHTYPE_FLOATING;
    	if (horizontal)
    		style |= AbstractPresentationFactory.SASHORIENTATION_HORIZONTAL;
    	else
    		style |= AbstractPresentationFactory.SASHORIENTATION_VERTICAL;
        sash = factory.createSash(parent, style);
        
        sash.addSelectionListener(selectionListener);

        Rectangle clientArea = newClientComposite.getClientArea();

        getPresentation().getControl().moveAbove(null);
        currentPane.getPane().moveAbove(null);
        sash.moveAbove(null);

        setSize((int) (Geometry.getDimension(clientArea, !horizontal) * sizeRatio));

        Display display = sash.getDisplay();

        display.addFilter(SWT.MouseDown, mouseDownListener);

        pane.setFocus();
    }

    /**
     * Updates the position of the resize sash.
     */
    private void updateFastViewSashBounds() {
        Rectangle bounds = getBounds();

        int oppositeSide = Geometry.getOppositeSide(side);
        Rectangle newBounds = Geometry.getExtrudedEdge(bounds, -getSashSize(),
                oppositeSide);

        Rectangle oldBounds = sash.getBounds();

        if (!newBounds.equals(oldBounds)) {
            sash.setBounds(newBounds);
        }
    }

    /**
     * Disposes of any active widgetry being used for the fast view pane. Does not dispose
     * of the view itself.
     */
    public void dispose() {
        hideView();
    }
    
    private StackPresentation getPresentation() {
        return site.getPresentation();
    }

    /**
     * Hides the sash for the fastview if it is currently visible. This method may not be
     * required anymore, and might be removed from the public interface.
     */
    public void hideFastViewSash() {
        if (sash != null) {
            sash.setVisible(false);
        }
    }

    /**
     * Hides the currently visible fastview.
     */
    public void hideView() {

        if (clientComposite != null) {
            Display display = clientComposite.getDisplay();

            display.removeFilter(SWT.MouseDown, mouseDownListener);
        }

        if (currentPane == null) {
            return;
        }

        fastViewAction.setPane(null);
        
        //unzoom before hiding
        currentPane.getPane().setZoomed(false);

        if (sash != null) {
            sash.dispose();
            sash = null;
        }

        clientComposite.removeListener(SWT.Resize, resizeListener);

        // Get pane.
        // Hide the right side sash first
        //hideFastViewSash();
        Control ctrl = currentPane.getControl();

        ctrl.removeListener(SWT.Traverse, escapeListener);

        // Hide it completely.
        getPresentation().setVisible(false);
        site.dispose();
        //currentPane.setFastViewSash(null);
        ctrl.setEnabled(false); // Remove focus support.

        currentPane.dispose();
        currentPane = null;
    }

    /**
     * @return Returns the currently visible fastview or null if none
     */
    public ViewPane getCurrentPane() { 
        if (currentPane != null && currentPane.getPane() instanceof ViewPane) {
            return (ViewPane)currentPane.getPane();
        }
        
        return null;
    }

    public void setState(int newState) {
    	site.setState(newState);
    }
    
    public int getState() {
    	return site.getState();
    }
    
    /**
     * 
     */
    public void showSystemMenu() {
        getPresentation().showSystemMenu();
    }
    
    /**
     * 
     */
    public void showPaneMenu() {
        getPresentation().showPaneMenu();
    }
    
    private int getSashSize() {
    	AbstractPresentationFactory factory = getPresentationFactory();
    	
    	// Set up the correct 'style' bits
    	int style = AbstractPresentationFactory.SASHTYPE_FLOATING;
    	if (Geometry.isHorizontal(side))
    		style |= AbstractPresentationFactory.SASHORIENTATION_HORIZONTAL;
    	else
    		style |= AbstractPresentationFactory.SASHORIENTATION_VERTICAL;
    		
    	int size = factory.getSashSize(style);
    	
    	return size;
    }
    
    private AbstractPresentationFactory getPresentationFactory() {
    	if (presFactory == null) {
	    	presFactory = ((WorkbenchWindow) currentPane.getPane().getWorkbenchWindow())
					.getWindowConfigurer().getPresentationFactory();
    	}
        return presFactory;
    }
}