/*******************************************************************************
 * Copyright (c) 2004, 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.presentations.util;

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

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
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.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.ui.presentations.IStackPresentationSite;
import org.eclipse.ui.presentations.PresentationUtil;

/**
 * @since 3.1
 */
public abstract class AbstractTabFolder {
    
    private List listeners = new ArrayList(1);

    private Control toolbar;
    private int state;

    public abstract Point computeSize(int widthHint, int heightHint);

    public abstract AbstractTabItem add(int index, int flags);

    public abstract Composite getContentParent();
    public abstract void setContent(Control newContent);
    
    public abstract AbstractTabItem[] getItems();

    public abstract AbstractTabItem getSelection();
    public abstract void setSelection(AbstractTabItem toSelect);
    public abstract void setSelectedInfo(PartInfo info);
    public abstract void enablePaneMenu(boolean enabled);
    private int activeState = IStackPresentationSite.STATE_RESTORED;
    
	private Listener menuListener = new Listener() {
		/* (non-Javadoc)
		 * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
		 */
		public void handleEvent(Event event) {
			Point globalPos = new Point(event.x, event.y);
		    handleContextMenu(globalPos, event);			
		}
	};

    private Listener dragListener = new Listener() {
        public void handleEvent(Event e) {
            Point globalPos = ((Control)e.widget).toDisplay(e.x, e.y);
            handleDragStarted(globalPos, e);
        }
    };
	
	private MouseListener mouseListener = new MouseAdapter() {
		
		// If we single-click on an empty space on the toolbar, move focus to the
		// active control
		public void mouseDown(MouseEvent e) {
			Point p = ((Control)e.widget).toDisplay(e.x, e.y);

			handleMouseDown(p, e);
		}
		
		
		// If we double-click on the toolbar, maximize the presentation
		public void mouseDoubleClick(MouseEvent e) {
			Point p = ((Control)e.widget).toDisplay(e.x, e.y);

			handleDoubleClick(p, e);						
		}
	};
    
    public void setActive(int activeState) {
        this.activeState = activeState;
    }
    
    public int getActive() {
        return activeState;
    }

    /**
     * Returns the location where the pane menu should be opened when activated
     * by a keyboard shortcut (display coordinates)
     * 
     * @return the location for the pane menu (display coordinates)
     * @since 3.1
     */
    public Point getPaneMenuLocation() {
        return getControl().toDisplay(new Point(0,0));
    }

    /**
     * Returns the location where the part list should be opened when activated
     * by a keyboard shortcut (display coordinates)
     * 
     * @return the location for the part list (display coordinates)
     * @since 3.1
     */
    public Point getPartListLocation() {
        return getSystemMenuLocation();
    }

    /**
     * Returns the location where the pane menu should be opened when activated
     * by a keyboard shortcut (display coordinates)
     * 
     * @return the location for the pane menu (display coordinates)
     * @since 3.1
     */
    public Point getSystemMenuLocation() {
        return getControl().toDisplay(new Point(0,0));
    }
    
    /**
     * Returns the parent composite that should be used for creating the toolbar.
     * Any control passed into setToolbar must have this composite as its parent.
     * 
     * @return the parent composite that should be used for creating the toolbar
     * 
     * @since 3.1
     */
    public abstract Composite getToolbarParent();

    /**
     * Returns the main control for this folder.
     * 
     * @return the main control for the folder
     * @since 3.1
     */
    public abstract Control getControl();
    
    public AbstractTabItem getItem(int idx) {
        return getItems()[idx];
    }

    public AbstractTabItem getItem(Point toFind) {
        AbstractTabItem[] items = getItems();
        
        for (int i = 0; i < items.length; i++) {
            AbstractTabItem item = items[i];
            
            if (item.getBounds().contains(toFind)) {
                return item;
            }
        }
        
        return null;
    }
    
    public AbstractTabItem findItem(Object dataToFind) {
        AbstractTabItem[] items = getItems();
        
        for (int i = 0; i < items.length; i++) {
            AbstractTabItem item = items[i];
            
            if (item.getData() == dataToFind) {
                return item;
            }
        }
        
        return null;
    }
    
    /**
     * Returns the index of the given item, or -1 if the given item is
     * not found in this tab folder. Subclasses should override this if
     * the underlying SWT widget has an equivalent method
     * 
     * @param item item to find
     * @return the index of the given item or -1
     */
    public int indexOf(AbstractTabItem item) {
        AbstractTabItem[] items = getItems();

        for (int idx = 0; idx < items.length; idx++) {
            AbstractTabItem next = items[idx];

            if (next == item) {
                return idx;
            }
        }

        return -1;
    }

    public int getItemCount() {
        return getItems().length;
    }

    public void setToolbar(Control toolbarControl) {
        this.toolbar = toolbarControl;
    }

    public final Control getToolbar() {
        return toolbar;
    }

    /**
     * Sets the current state for the folder
     * 
     * @param state one of the IStackPresentationSite.STATE_* constants
     */
    public void setState(int state) {
        this.state = state;
    }

    /**
     * Returns the title area for this control (in the control's coordinate system)
     * 
     * @return
     */
    public abstract Rectangle getTabArea();

    /**
     * Called when the tab folder's shell becomes active or inactive. Subclasses
     * can override this to change the appearance of the tabs based on activation.
     * 
     * @param isActive
     */
    public void shellActive(boolean isActive) {
    }

    /**
     * Adds the given listener to this AbstractTabFolder
     * 
     * @param newListener the listener to add
     */
    public final void addListener(TabFolderListener newListener) {
        listeners.add(newListener);
    }

    /**
     * Removes the given listener from this AbstractTabFolder
     * 
     * @param toRemove the listener to remove
     */
    public final void removeListener(TabFolderListener toRemove) {
        listeners.remove(toRemove);
    }

    public void flushToolbarSize() {
        
    }
    
    protected final void fireEvent(TabFolderEvent e) {
        for (Iterator iter = listeners.iterator(); iter.hasNext();) {
            TabFolderListener next = (TabFolderListener)iter.next();

            next.handleEvent(e);
        }        
    }
    
    protected final void fireEvent(int id) {
        fireEvent(new TabFolderEvent(id));
    }
    
    protected final void fireEvent(int id, AbstractTabItem w) {
        fireEvent(new TabFolderEvent(id, w, 0, 0));
    }
    
    protected final void fireEvent(int id, AbstractTabItem w, Point pos) {
        fireEvent(new TabFolderEvent(id, w, pos));
    }
    
    public void layout(boolean flushCache) {
    }
    
    public void setTabPosition(int tabPosition) {
    }
    
    public int getTabPosition() {
        return SWT.TOP;
    }
    
    public int getState() {
        return state;
    }
    
    protected void attachListeners(Control theControl, boolean recursive) {
        theControl.addListener(SWT.MenuDetect, menuListener);
        theControl.addMouseListener(mouseListener);
        PresentationUtil.addDragListener(theControl, dragListener);
        
        if (recursive && theControl instanceof Composite) {
            Composite composite = (Composite) theControl;
            Control[] children = composite.getChildren();
            
            for (int i = 0; i < children.length; i++) {
                Control control = children[i];
                
                attachListeners(control, recursive);
            }
        }
    }
    
    protected void detachListeners(Control theControl, boolean recursive) {
        theControl.removeListener(SWT.MenuDetect, menuListener);
        theControl.removeMouseListener(mouseListener);
        PresentationUtil.removeDragListener(theControl, dragListener);
        
        if (recursive && theControl instanceof Composite) {
            Composite composite = (Composite) theControl;
            Control[] children = composite.getChildren();
            
            for (int i = 0; i < children.length; i++) {
                Control control = children[i];
                
                detachListeners(control, recursive);
            }
        }
    }
    
    protected void handleContextMenu(Point displayPos, Event e) {
        if (isOnBorder(displayPos)) {
            return;
        }

        AbstractTabItem tab = getItem(displayPos); 
        
        fireEvent(TabFolderEvent.EVENT_SYSTEM_MENU, tab, displayPos);
    }
    
    protected void handleMouseDown(Point displayPos, MouseEvent e) {
        fireEvent(TabFolderEvent.EVENT_GIVE_FOCUS_TO_PART);
    }

    protected void handleDoubleClick(Point displayPos, MouseEvent e) {
        if (isOnBorder(displayPos)) {
            return;
        }
        
		if (getState() == IStackPresentationSite.STATE_MAXIMIZED) {
			fireEvent(TabFolderEvent.EVENT_RESTORE);
		} else {
		    fireEvent(TabFolderEvent.EVENT_MAXIMIZE);
		}
    }
    
    protected void handleDragStarted(Point displayPos, Event e) {

        if (isOnBorder(displayPos)) {
            return;
        }
        
        AbstractTabItem tab = getItem(displayPos);
        fireEvent(TabFolderEvent.EVENT_DRAG_START, tab, displayPos);
    }

    /**
     * Returns true iff the given point is on the border of the folder.
     * By default, double-clicking, context menus, and drag/drop are disabled
     * on the folder's border.
     *  
     * @param toTest a point (display coordinates)
     * @return true iff the point is on the presentation border
     * @since 3.1
     */
    public boolean isOnBorder(Point toTest) {
        return false;
    }
    
    /**
	 * Set the folder to visible. This can be extended to propogate the
	 * visibility request to other components in the subclass.
	 * 
	 * @param visible
	 *            <code>true</code> - the folder is visible.
	 * @since 3.2
	 */
    public void setVisible(boolean visible) {
		getControl().setVisible(visible);
	}

	/**
	 * Cause the folder to hide or show its
	 * Minimize and Maximize affordances.
	 * 
	 * @param show
	 *            <code>true</code> - the min/max buttons are visible.
	 * @since 3.3
	 */
	public void showMinMax(boolean show) {
	}
}