/*******************************************************************************
 * Copyright (c) 2005 Stefan Zeiger 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.novocode.com/legal/epl-v10.html
 * 
 * Contributors:
 *     Stefan Zeiger (szeiger@novocode.com) - initial API and implementation
 *******************************************************************************/

module dwtx.novocode.ishell.DesktopForm;

import dwt.DWT;
import dwt.graphics.Color;
import dwt.graphics.Rectangle;
import dwt.widgets.Composite;
import dwt.widgets.Control;
import dwt.widgets.Display;
import dwt.widgets.Event;
import dwt.widgets.Listener;
import dwt.widgets.Shell;

import dwtx.novocode.ishell.internal.DesktopListener;
import dwtx.novocode.ishell.InternalShell;

import tango.core.Array;


/**
 * A desktop which manages internal shells.
 *
 * @author Stefan Zeiger (szeiger@novocode.com)
 * @since Jan 21, 2005
 * @version $Id: DesktopForm.java 344 2005-07-09 22:37:51 +0000 (Sat, 09 Jul 2005) szeiger $
 */

class DesktopForm : Composite
{
    private static const InternalShell[] EMPTY_INTERNALSHELL_ARRAY/** = new InternalShell[0]*/;
    private static const int FIRST_SHELL_LOCATION = 32;
    private static const int SHELL_LOCATION_OFFSET = 16;

    private InternalShell activeShell;
    private DesktopListener[] desktopListeners;
    private InternalShell[] allShells;
    private InternalShell[] visibleShells;
    private int nextShellLocation = FIRST_SHELL_LOCATION;
    private bool showMaximizedTitle;
    private bool autoMaximize = true;
    private bool enableCtrlTab = true;
    private bool allowDeactivate;
    private Shell shell;
    private InternalShell ishell;
    private Listener mouseDownFilter, focusInFilter, traverseFilter;


    this(Composite parent, int style)
    {
        super(parent, style);
        Display display = getDisplay();
        shell = getShell();

        Color bg = display.getSystemColor(DWT.COLOR_TITLE_INACTIVE_BACKGROUND);
        setBackground(bg);
        int brightness = bg.getRed() + bg.getGreen() + bg.getBlue();
        setForeground(display.getSystemColor(brightness > 400 ? DWT.COLOR_BLACK : DWT.COLOR_WHITE));

        addListener(DWT.Resize, dgListener(&onResize));

        mouseDownFilter = dgListener(&onMouseDownFilter);
        focusInFilter = dgListener(&onFocusInFilter);
        traverseFilter = dgListener(&onTraverseFilter);

        display.addFilter(DWT.MouseDown, mouseDownFilter);
        display.addFilter(DWT.FocusIn, focusInFilter);
        display.addFilter(DWT.Traverse, traverseFilter);

        addListener(DWT.Dispose, dgListener(&onDispose));
    }


    private void onResize(Event event)
    {
        Rectangle ca = getClientArea();
        foreach(c; getChildren())
        {
            if(cast(InternalShell)c !is null)
                (cast(InternalShell)c).desktopResized(ca);
        }
    }


    private void onMouseDownFilter(Event event)
    {
        if(!(cast(Control)event.widget !is null)) return;
        Control c = cast(Control)event.widget;
        if(c.getShell() !is shell) return;
        bool[] desktopHit = new bool[1];
        InternalShell ishell = getInternalShell(c, desktopHit);
        if(desktopHit[0] && allowDeactivate) activate(null);
        if(ishell is null) return;
        activate(ishell);
    }


    private void onFocusInFilter(Event event)
    {
        if(!(cast(Control)event.widget !is null)) return;
        Control c = cast(Control)event.widget;
        if(c.getShell() !is shell) return;
        bool[] desktopHit = new bool[1];
        ishell = getInternalShell(c, desktopHit);
        if(desktopHit[0] && allowDeactivate) activate(null);
        if(ishell is null) return;
        ishell.focusControl = c;
    }


    private void onTraverseFilter(Event event)
    {
        if(!enableCtrlTab) return;
        if(!event.doit) return; // don't steal traverse event if a control wants to handle it directly
        if((event.stateMask & DWT.CTRL) is 0) return;
        if(event.detail !is DWT.TRAVERSE_TAB_NEXT && event.detail !is DWT.TRAVERSE_TAB_PREVIOUS) return;
        if(!(cast(Control)event.widget !is null)) return;
        Control c = cast(Control)event.widget;
        if(c.getShell() !is shell) return;
        bool[] desktopHit = new bool[1];
        InternalShell ishell = getInternalShell(c, desktopHit);
        if(ishell !is null || desktopHit[0])
        {
            if(event.detail is DWT.TRAVERSE_TAB_NEXT) activateNextShell();
            else activatePreviousShell();
            event.doit = false;
        }
    }


    private void onDispose(Event event)
    {
        display.removeFilter(DWT.MouseDown, mouseDownFilter);
        display.removeFilter(DWT.FocusIn, focusInFilter);
        display.removeFilter(DWT.Traverse, traverseFilter);
    }


    void manage(InternalShell ishell)
    {
        Rectangle bounds = getBounds();
        if(nextShellLocation > bounds.height-100 || nextShellLocation > bounds.width-100)
            nextShellLocation = FIRST_SHELL_LOCATION;
        ishell.setLocation(bounds.x+nextShellLocation, bounds.y+nextShellLocation);
        nextShellLocation += SHELL_LOCATION_OFFSET;

        ishell.addListener(DWT.Dispose, dgListener(&onIshellDispose));
        allShells ~= ishell;
        if(ishell.isVisible()) visibleShells ~= ishell;
        notifyDesktopListenersCreate(ishell);
    }


    private void onIshellDispose(Event event)
    {
        allShells.remove(ishell);
        visibleShells.remove(ishell);
        if(ishell is activeShell)
        {
            activateTopmostVisibleShellExcept(ishell);
            if(autoMaximize && !hasVisibleMaximizedShell())
                setAllVisibleMaximized(false);
        }
        notifyDesktopListenersDispose(ishell);
    }


    private InternalShell activateTopmostVisibleShellExcept(InternalShell except)
    {
        Control[] children = getChildren();
        for(int i=0; i<children.length; i++)
        {
            Control c = children[i];
            if(c is except) continue;
            if(cast(InternalShell)c !is null && c.isVisible())
            {
                InternalShell ishell = cast(InternalShell)c;
                activate(ishell);
                return ishell;
            }
        }
        activeShell = null;
        notifyDesktopListenersActivate(null);
        return null;
    }


    void activate(InternalShell ishell)
    {
        if(ishell is activeShell) return;
        checkWidget();
        if(ishell !is null)
        {
            if(!ishell.isVisible()) ishell.setVisible(true);
            if((ishell.getStyle() & DWT.ON_TOP) !is 0)
                ishell.moveAbove(null);
            else
            {
                InternalShell firstRegular = getTopmostRegularShell();
                if(firstRegular !is null && firstRegular !is ishell) ishell.moveAbove(firstRegular);
                else
                {
                    Control[] children = getChildren();
                    if(children.length > 0) ishell.moveAbove(children[0]);
                }
            }
        }
        InternalShell oldActiveShell = activeShell;
        activeShell = ishell;
        if(oldActiveShell !is null) oldActiveShell.redrawDecorationsAfterActivityChange();
        if(ishell !is null)
        {
            if(activeShell.isVisible()) activeShell.redrawDecorationsAfterActivityChange();
            setTabList(/**new Control[] { activeShell }*/[ activeShell ]);
            activeShell.setFocus();
        }
        else
        {
            setTabList(/**new Control[] {}*/[]);
            forceFocus();
        }
        notifyDesktopListenersActivate(ishell);
    }


    private InternalShell getTopmostRegularShell()
    {
        foreach(c; getChildren())
        {
            if(!(cast(InternalShell)c !is null)) continue;
            if((c.getStyle() & DWT.ON_TOP) is 0) return cast(InternalShell)c;
        }
        return null;
    }


    private InternalShell getBottommostOnTopShell()
    {
        Control[] ch = getChildren();
        for(int i=ch.length-1; i>=0; i--)
        {
            Control c = ch[i];
            if(!(cast(InternalShell)c !is null)) continue;
            if((c.getStyle() & DWT.ON_TOP) !is 0) return cast(InternalShell)c;
        }
        return null;
    }


    void shellVisibilityChanged(InternalShell ishell, bool visible)
    {
        if(visible)
        {
            if(!contains(visibleShells, ishell))
            {
                visibleShells ~= ishell;
                if(autoMaximize && !ishell.getMaximized() && (ishell.getStyle() & DWT.MAX) !is 0 && hasVisibleMaximizedShell())
                    ishell.setMaximizedWithoutNotification(true);
            }
            if(ishell.getMaximized())
                ishell.desktopResized(getClientArea());
        }
        else
        {
            visibleShells.remove(ishell);
            if(ishell is activeShell)
            {
                activateTopmostVisibleShellExcept(ishell);
                if(autoMaximize && !hasVisibleMaximizedShell())
                    setAllVisibleMaximized(false);
            }
        }
    }


    private InternalShell getInternalShell(Control c, bool[] desktopHit)
    {
        while(c !is null && c !is /**DesktopForm.*/this)
        {
            if(cast(InternalShell)c !is null && (cast(InternalShell)c).getParent() is this)
                return cast(InternalShell)c;
            c = c.getParent();
        }
        if(desktopHit !is null && c is /**DesktopForm.*/this) desktopHit[0] = true;
        return null;
    }


    public InternalShell getActiveShell()
    {
        return activeShell;
    }


    public InternalShell[] getVisibleShells()
    {
        checkWidget();
        return visibleShells;
    }


    public InternalShell[] getShells()
    {
        checkWidget();
        return allShells;
    }


    public void setShowMaximizedTitle(bool b)
    {
        checkWidget();
        showMaximizedTitle = b;
        Rectangle ca = getClientArea();
        foreach(c; getChildren())
        {
            if(cast(InternalShell)c !is null)
                (cast(InternalShell)c).desktopResized(ca);
        }
    }


    public bool getShowMaximizedTitle()
    {
        checkWidget();
        return showMaximizedTitle;
    }


    public void setAutoMaximize(bool b)
    {
        checkWidget();
        autoMaximize = b;
        bool hasMax = false;
        foreach(ins; visibleShells)
        {
            if(ins.getMaximized())
            {
                hasMax = true;
                break;
            }
        }
        if(hasMax)
        {
            // Maximize all shells
            foreach(ins; visibleShells)
            {
                if((ins.getStyle() & DWT.MAX) !is 0) ins.setMaximized(true);
            }
        }
    }


    public bool getAutoMaximize()
    {
        checkWidget();
        return autoMaximize;
    }


    public void setEnableCtrlTab(bool b)
    {
        checkWidget();
        this.enableCtrlTab = b;
    }


    public bool getEnableCtrlTab()
    {
        return enableCtrlTab;
    }


    public void setAllowDeactivate(bool b)
    {
        checkWidget();
        this.allowDeactivate = b;
        if(!allowDeactivate && activeShell is null)
            activateTopmostVisibleShellExcept(null);
    }


    public bool getAllowDeactivate()
    {
        return allowDeactivate;
    }


    void shellMaximizedOrRestored(InternalShell ishell, bool maximized)
    {
        setAllVisibleMaximized(maximized);
    }


    private void setAllVisibleMaximized(bool maximized)
    {
        if(autoMaximize) // maximize or restore all shells
        {
            foreach(c; getChildren())
            {
                if(cast(InternalShell)c !is null)
                {
                    InternalShell ishell = cast(InternalShell)c;
                    if((ishell.getStyle() & DWT.MAX) !is 0 && ishell.isVisible())
                        (cast(InternalShell)c).setMaximizedWithoutNotification(maximized);
                }
            }
        }
    }


    private void activateNextShell()
    {
        if(activeShell is null)
        {
            activateTopmostVisibleShellExcept(null);
            return;
        }
        if(visibleShells.length < 2) return;
        InternalShell topReg = getTopmostRegularShell();
        InternalShell botTop = getBottommostOnTopShell();
        if((activeShell.getStyle() & DWT.ON_TOP) !is 0)
        {
            activeShell.moveBelow(botTop);
            if(topReg !is null) activate(topReg);
            else activateTopmostVisibleShellExcept(null);
        }
        else
        {
            activeShell.moveBelow(null);
            activateTopmostVisibleShellExcept(null);
        }
    }


    private void activatePreviousShell()
    {
        if(activeShell is null)
        {
            activateTopmostVisibleShellExcept(null);
            return;
        }
        if(visibleShells.length < 2) return;
        InternalShell topReg = getTopmostRegularShell();
        InternalShell botTop = getBottommostOnTopShell();
        if(activeShell is topReg && botTop !is null) activate(botTop);
        else
        {
            Control[] ch = getChildren();
            for(int i=ch.length-1; i>=0; i--)
            {
                if(cast(InternalShell)ch[i] !is null && ch[i].isVisible())
                {
                    activate(cast(InternalShell)ch[i]);
                    break;
                }
            }
        }
    }


    public void addDesktopListener(DesktopListener l)
    {
        desktopListeners ~= l;
    }


    public void removeDesktopListener(DesktopListener l)
    {
        desktopListeners.remove(l);
    }


    private void notifyDesktopListenersCreate(InternalShell ishell)
    {
        Event event = new Event();
        event.widget = ishell;
        foreach(l; desktopListeners) l.shellCreated(event);
    }


    private void notifyDesktopListenersDispose(InternalShell ishell)
    {
        Event event = new Event();
        event.widget = ishell;
        foreach(l; desktopListeners) l.shellDisposed(event);
    }


    private void notifyDesktopListenersActivate(InternalShell ishell)
    {
        Event event = new Event();
        event.widget = ishell;
        foreach(l; desktopListeners) l.shellActivated(event);
    }


    private bool hasVisibleMaximizedShell()
    {
        foreach(ins; visibleShells)
            if(ins.getMaximized()) return true;
        return false;
    }
}