root/dwt/custom/CTabFolder.d

/*******************************************************************************
 * Copyright (c) 2000, 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
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwt.custom.CTabFolder;

import dwt.DWT;
import dwt.DWTException;
import dwt.accessibility.ACC;
import dwt.accessibility.Accessible;
import dwt.accessibility.AccessibleAdapter;
import dwt.accessibility.AccessibleControlAdapter;
import dwt.accessibility.AccessibleControlEvent;
import dwt.accessibility.AccessibleEvent;
import dwt.events.SelectionAdapter;
import dwt.events.SelectionEvent;
import dwt.events.SelectionListener;
import dwt.graphics.Color;
import dwt.graphics.Font;
import dwt.graphics.FontData;
import dwt.graphics.GC;
import dwt.graphics.Image;
import dwt.graphics.Point;
import dwt.graphics.RGB;
import dwt.graphics.Rectangle;
import dwt.graphics.Region;
import dwt.widgets.Composite;
import dwt.widgets.Control;
import dwt.widgets.Display;
import dwt.widgets.Event;
import dwt.widgets.Layout;
import dwt.widgets.Listener;
import dwt.widgets.Menu;
import dwt.widgets.MenuItem;
import dwt.widgets.TypedListener;
import dwt.custom.CTabItem;
import dwt.custom.CTabFolder2Listener;
import dwt.custom.CTabFolderListener;
import dwt.custom.CTabFolderLayout;
import dwt.custom.CTabFolderEvent;

import dwt.dwthelper.utils;
import tango.util.Convert;
static import tango.text.convert.Utf;

/**
 *
 * Instances of this class implement the notebook user interface
 * metaphor.  It allows the user to select a notebook page from
 * set of pages.
 * <p>
 * The item children that may be added to instances of this class
 * must be of type <code>CTabItem</code>.
 * <code>Control</code> children are created and then set into a
 * tab item using <code>CTabItem#setControl</code>.
 * </p><p>
 * Note that although this class is a subclass of <code>Composite</code>,
 * it does not make sense to set a layout on it.
 * </p><p>
 * <dl>
 * <dt><b>Styles:</b></dt>
 * <dd>CLOSE, TOP, BOTTOM, FLAT, BORDER, SINGLE, MULTI</dd>
 * <dt><b>Events:</b></dt>
 * <dd>Selection</dd>
 * <dd>"CTabFolder2"</dd>
 * </dl>
 * <p>
 * Note: Only one of the styles TOP and BOTTOM
 * may be specified.
 * </p><p>
 * IMPORTANT: This class is <em>not</em> intended to be subclassed.
 * </p>
 *
 * @see <a href="http://www.eclipse.org/swt/snippets/#ctabfolder">CTabFolder, CTabItem snippets</a>
 * @see <a href="http://www.eclipse.org/swt/examples.php">DWT Example: CustomControlExample</a>
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
 */

public class CTabFolder : Composite {

    /**
     * marginWidth specifies the number of pixels of horizontal margin
     * that will be placed along the left and right edges of the form.
     *
     * The default value is 0.
     */
    public int marginWidth = 0;
    /**
     * marginHeight specifies the number of pixels of vertical margin
     * that will be placed along the top and bottom edges of the form.
     *
     * The default value is 0.
     */
    public int marginHeight = 0;

    /**
     * A multiple of the tab height that specifies the minimum width to which a tab
     * will be compressed before scrolling arrows are used to navigate the tabs.
     *
     * NOTE This field is badly named and can not be fixed for backwards compatibility.
     * It should not be capitalized.
     *
     * @deprecated This field is no longer used.  See setMinimumCharacters(int)
     */
    public int MIN_TAB_WIDTH = 4;

    /**
     * Color of innermost line of drop shadow border.
     *
     * NOTE This field is badly named and can not be fixed for backwards compatibility.
     * It should be capitalized.
     *
     * @deprecated drop shadow border is no longer drawn in 3.0
     */
    public static RGB borderInsideRGB;
    /**
     * Color of middle line of drop shadow border.
     *
     * NOTE This field is badly named and can not be fixed for backwards compatibility.
     * It should be capitalized.
     *
     * @deprecated drop shadow border is no longer drawn in 3.0
     */
    public static RGB borderMiddleRGB;
    /**
     * Color of outermost line of drop shadow border.
     *
     * NOTE This field is badly named and can not be fixed for backwards compatibility.
     * It should be capitalized.
     *
     * @deprecated drop shadow border is no longer drawn in 3.0
     */
    public static RGB borderOutsideRGB;

    /* sizing, positioning */
    int xClient, yClient;
    bool onBottom = false;
    bool single = false;
    bool simple = true;
    int fixedTabHeight = DWT.DEFAULT;
    int tabHeight;
    int minChars = 20;

    /* item management */
    CTabItem items[];
    int firstIndex = -1; // index of the left most visible tab.
    int selectedIndex = -1;
    int[] priority;
    bool mru = false;
    Listener listener;

    /* External Listener management */
    CTabFolder2Listener[] folderListeners;
    // support for deprecated listener mechanism
    CTabFolderListener[] tabListeners;

    /* Selected item appearance */
    Image selectionBgImage;
    Color[] selectionGradientColors;
    int[] selectionGradientPercents;
    bool selectionGradientVertical;
    Color selectionForeground;
    Color selectionBackground;  //selection fade end
    Color selectionFadeStart;

    Color selectionHighlightGradientBegin = null;  //null is no highlight
    //Although we are given new colours all the time to show different states (active, etc),
    //some of which may have a highlight and some not, we'd like to retain the highlight colours
    //as a cache so that we can reuse them if we're again told to show the highlight.
    //We are relying on the fact that only one tab state usually gets a highlight, so only
    //a single cache is required. If that happens to not be true, cache simply becomes less effective,
    //but we don't leak colours.
    Color[] selectionHighlightGradientColorsCache = null;  //null is a legal value, check on access

    /* Unselected item appearance */
    Image bgImage;
    Color[] gradientColors;
    int[] gradientPercents;
    bool gradientVertical;
    bool showUnselectedImage = true;

    static Color borderColor;

    // close, min/max and chevron buttons
    bool showClose = false;
    bool showUnselectedClose = true;

    Rectangle chevronRect;
    int chevronImageState = NORMAL;
    bool showChevron = false;
    Menu showMenu;

    bool showMin = false;
    Rectangle minRect;
    bool minimized = false;
    int minImageState = NORMAL;

    bool showMax = false;
    Rectangle maxRect;
    bool maximized = false;
    int maxImageState = NORMAL;

    Control topRight;
    Rectangle topRightRect;
    int topRightAlignment = DWT.RIGHT;

    // borders and shapes
    int borderLeft = 0;
    int borderRight = 0;
    int borderTop = 0;
    int borderBottom = 0;

    int highlight_margin = 0;
    int highlight_header = 0;

    int[] curve;
    int[] topCurveHighlightStart;
    int[] topCurveHighlightEnd;
    int curveWidth = 0;
    int curveIndent = 0;

    // when disposing CTabFolder, don't try to layout the items or
    // change the selection as each child is destroyed.
    bool inDispose = false;

    // keep track of size changes in order to redraw only affected area
    // on Resize
    Point oldSize;
    Font oldFont;

    // internal constants
    static const int DEFAULT_WIDTH = 64;
    static const int DEFAULT_HEIGHT = 64;
    static const int BUTTON_SIZE = 18;

    static const int[] TOP_LEFT_CORNER = [0,6, 1,5, 1,4, 4,1, 5,1, 6,0];

    //TOP_LEFT_CORNER_HILITE is laid out in reverse (ie. top to bottom)
    //so can fade in same direction as right swoop curve
    static const int[] TOP_LEFT_CORNER_HILITE = [5,2, 4,2, 3,3, 2,4, 2,5, 1,6];

    static const int[] TOP_RIGHT_CORNER = [-6,0, -5,1, -4,1, -1,4, -1,5, 0,6];
    static const int[] BOTTOM_LEFT_CORNER = [0,-6, 1,-5, 1,-4, 4,-1, 5,-1, 6,0];
    static const int[] BOTTOM_RIGHT_CORNER = [-6,0, -5,-1, -4,-1, -1,-4, -1,-5, 0,-6];

    static const int[] SIMPLE_TOP_LEFT_CORNER = [0,2, 1,1, 2,0];
    static const int[] SIMPLE_TOP_RIGHT_CORNER = [-2,0, -1,1, 0,2];
    static const int[] SIMPLE_BOTTOM_LEFT_CORNER = [0,-2, 1,-1, 2,0];
    static const int[] SIMPLE_BOTTOM_RIGHT_CORNER = [-2,0, -1,-1, 0,-2];
    static const int[] SIMPLE_UNSELECTED_INNER_CORNER = [0,0];

    static const int[] TOP_LEFT_CORNER_BORDERLESS = [0,6, 1,5, 1,4, 4,1, 5,1, 6,0];
    static const int[] TOP_RIGHT_CORNER_BORDERLESS = [-7,0, -6,1, -5,1, -2,4, -2,5, -1,6];
    static const int[] BOTTOM_LEFT_CORNER_BORDERLESS = [0,-6, 1,-6, 1,-5, 2,-4, 4,-2, 5,-1, 6,-1, 6,0];
    static const int[] BOTTOM_RIGHT_CORNER_BORDERLESS = [-7,0, -7,-1, -6,-1, -5,-2, -3,-4, -2,-5, -2,-6, -1,-6];

    static const int[] SIMPLE_TOP_LEFT_CORNER_BORDERLESS = [0,2, 1,1, 2,0];
    static const int[] SIMPLE_TOP_RIGHT_CORNER_BORDERLESS= [-3,0, -2,1, -1,2];
    static const int[] SIMPLE_BOTTOM_LEFT_CORNER_BORDERLESS = [0,-3, 1,-2, 2,-1, 3,0];
    static const int[] SIMPLE_BOTTOM_RIGHT_CORNER_BORDERLESS = [-4,0, -3,-1, -2,-2, -1,-3];

    static const int SELECTION_FOREGROUND = DWT.COLOR_LIST_FOREGROUND;
    static const int SELECTION_BACKGROUND = DWT.COLOR_LIST_BACKGROUND;
    static const int BORDER1_COLOR = DWT.COLOR_WIDGET_NORMAL_SHADOW;
    static const int FOREGROUND = DWT.COLOR_WIDGET_FOREGROUND;
    static const int BACKGROUND = DWT.COLOR_WIDGET_BACKGROUND;
    static const int BUTTON_BORDER = DWT.COLOR_WIDGET_DARK_SHADOW;
    static const int BUTTON_FILL = DWT.COLOR_LIST_BACKGROUND;

    static const int NONE = 0;
    static const int NORMAL = 1;
    static const int HOT = 2;
    static const int SELECTED = 3;
    static const RGB CLOSE_FILL;

    static const int CHEVRON_CHILD_ID = 0;
    static const int MINIMIZE_CHILD_ID = 1;
    static const int MAXIMIZE_CHILD_ID = 2;
    static const int EXTRA_CHILD_ID_COUNT = 3;

static this(){
    borderInsideRGB  = new RGB (132, 130, 132);
    borderMiddleRGB  = new RGB (143, 141, 138);
    borderOutsideRGB = new RGB (171, 168, 165);
    CLOSE_FILL = new RGB(252, 160, 160);
}

/**
 * Constructs a new instance of this class given its parent
 * and a style value describing its behavior and appearance.
 * <p>
 * The style value is either one of the style constants defined in
 * class <code>DWT</code> which is applicable to instances of this
 * class, or must be built by <em>bitwise OR</em>'ing together
 * (that is, using the <code>int</code> "|" operator) two or more
 * of those <code>DWT</code> style constants. The class description
 * lists the style constants that are applicable to the class.
 * Style bits are also inherited from superclasses.
 * </p>
 *
 * @param parent a widget which will be the parent of the new instance (cannot be null)
 * @param style the style of widget to construct
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
 * </ul>
 * @exception DWTException <ul>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>
 * </ul>
 *
 * @see DWT#TOP
 * @see DWT#BOTTOM
 * @see DWT#FLAT
 * @see DWT#BORDER
 * @see DWT#SINGLE
 * @see DWT#MULTI
 * @see #getStyle()
 */
public this(Composite parent, int style) {
    chevronRect = new Rectangle(0, 0, 0, 0);
    minRect = new Rectangle(0, 0, 0, 0);
    maxRect = new Rectangle(0, 0, 0, 0);
    topRightRect = new Rectangle(0, 0, 0, 0);
    super(parent, checkStyle (parent, style));
    super.setLayout(new CTabFolderLayout());
    int style2 = super.getStyle();
    oldFont = getFont();
    onBottom = (style2 & DWT.BOTTOM) !is 0;
    showClose = (style2 & DWT.CLOSE) !is 0;
//  showMin = (style2 & DWT.MIN) !is 0; - conflicts with DWT.TOP
//  showMax = (style2 & DWT.MAX) !is 0; - conflicts with DWT.BOTTOM
    single = (style2 & DWT.SINGLE) !is 0;
    borderLeft = borderRight = (style & DWT.BORDER) !is 0 ? 1 : 0;
    borderTop = onBottom ? borderLeft : 0;
    borderBottom = onBottom ? 0 : borderLeft;
    highlight_header = (style & DWT.FLAT) !is 0 ? 1 : 3;
    highlight_margin = (style & DWT.FLAT) !is 0 ? 0 : 2;
    //set up default colors
    Display display = getDisplay();
    selectionForeground = display.getSystemColor(SELECTION_FOREGROUND);
    selectionBackground = display.getSystemColor(SELECTION_BACKGROUND);
    borderColor = display.getSystemColor(BORDER1_COLOR);
    updateTabHeight(false);

    initAccessible();

    // Add all listeners
    listener = new class() Listener {
        public void handleEvent(Event event) {
            switch (event.type) {
                case DWT.Dispose:          onDispose(event); break;
                case DWT.DragDetect:       onDragDetect(event); break;
                case DWT.FocusIn:          onFocus(event);  break;
                case DWT.FocusOut:         onFocus(event);  break;
                case DWT.KeyDown:          onKeyDown(event); break;
                case DWT.MouseDoubleClick: onMouseDoubleClick(event); break;
                case DWT.MouseDown:        onMouse(event);  break;
                case DWT.MouseEnter:       onMouse(event);  break;
                case DWT.MouseExit:        onMouse(event);  break;
                case DWT.MouseMove:        onMouse(event); break;
                case DWT.MouseUp:          onMouse(event); break;
                case DWT.Paint:            onPaint(event);  break;
                case DWT.Resize:           onResize();  break;
                case DWT.Traverse:         onTraverse(event); break;
                default:
            }
        }
    };

    int[] folderEvents = [
        DWT.Dispose,
        DWT.DragDetect,
        DWT.FocusIn,
        DWT.FocusOut,
        DWT.KeyDown,
        DWT.MouseDoubleClick,
        DWT.MouseDown,
        DWT.MouseEnter,
        DWT.MouseExit,
        DWT.MouseMove,
        DWT.MouseUp,
        DWT.Paint,
        DWT.Resize,
        DWT.Traverse,
    ];
    for (int i = 0; i < folderEvents.length; i++) {
        addListener(folderEvents[i], listener);
    }
}
static int checkStyle (Composite parent, int style) {
    int mask = DWT.CLOSE | DWT.TOP | DWT.BOTTOM | DWT.FLAT | DWT.LEFT_TO_RIGHT | DWT.RIGHT_TO_LEFT | DWT.SINGLE | DWT.MULTI;
    style = style & mask;
    // TOP and BOTTOM are mutually exclusive.
    // TOP is the default
    if ((style & DWT.TOP) !is 0) style = style & ~DWT.BOTTOM;
    // SINGLE and MULTI are mutually exclusive.
    // MULTI is the default
    if ((style & DWT.MULTI) !is 0) style = style & ~DWT.SINGLE;
    // reduce the flash by not redrawing the entire area on a Resize event
    style |= DWT.NO_REDRAW_RESIZE;
    //TEMPORARY CODE
    /*
     * The default background on carbon and some GTK themes is not a solid color
     * but a texture.  To show the correct default background, we must allow
     * the operating system to draw it and therefore, we can not use the
     * NO_BACKGROUND style.  The NO_BACKGROUND style is not required on platforms
     * that use double buffering which is true in both of these cases.
     */
    String platform = DWT.getPlatform();
    if ("carbon"==platform || "gtk"==platform) return style; //$NON-NLS-1$ //$NON-NLS-2$

    //TEMPORARY CODE
    /*
     * In Right To Left orientation on Windows, all GC calls that use a brush are drawing
     * offset by one pixel.  This results in some parts of the CTabFolder not drawing correctly.
     * To alleviate some of the appearance problems, allow the OS to draw the background.
     * This does not draw correctly but the result is less obviously wrong.
     */
    if ((style & DWT.RIGHT_TO_LEFT) !is 0) return style;
    if ((parent.getStyle() & DWT.MIRRORED) !is 0 && (style & DWT.LEFT_TO_RIGHT) is 0) return style;

    return style | DWT.NO_BACKGROUND;
}
static void fillRegion(GC gc, Region region) {
    // NOTE: region passed in to this function will be modified
    Region clipping = new Region();
    gc.getClipping(clipping);
    region.intersect(clipping);
    gc.setClipping(region);
    gc.fillRectangle(region.getBounds());
    gc.setClipping(clipping);
    clipping.dispose();
}
/**
 *
 * Adds the listener to the collection of listeners who will
 * be notified when a tab item is closed, minimized, maximized,
 * restored, or to show the list of items that are not
 * currently visible.
 *
 * @param listener the listener which should be notified
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
 * </ul>
 *
 * @exception DWTException <ul>
 *    <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>
 *    <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>
 * </ul>
 *
 * @see CTabFolder2Listener
 * @see #removeCTabFolder2Listener(CTabFolder2Listener)
 *
 * @since 3.0
 */
public void addCTabFolder2Listener(CTabFolder2Listener listener) {
    checkWidget();
    if (listener is null) DWT.error (DWT.ERROR_NULL_ARGUMENT);
    // add to array
    CTabFolder2Listener[] newListeners = new CTabFolder2Listener[folderListeners.length + 1];
    SimpleType!(CTabFolder2Listener).arraycopy(folderListeners, 0, newListeners, 0, folderListeners.length);
    folderListeners = newListeners;
    folderListeners[folderListeners.length - 1] = listener;
}
/**
 * Adds the listener to the collection of listeners who will
 * be notified when a tab item is closed.
 *
 * @param listener the listener which should be notified
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
 * </ul>
 * @exception DWTException <ul>
 *    <li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>
 *    <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>
 * </ul>
 *
 * @see CTabFolderListener
 * @see #removeCTabFolderListener(CTabFolderListener)
 *
 * @deprecated use addCTabFolder2Listener(CTabFolder2Listener)
 */
public void addCTabFolderListener(CTabFolderListener listener) {
    checkWidget();
    if (listener is null) DWT.error (DWT.ERROR_NULL_ARGUMENT);
    // add to array
    CTabFolderListener[] newTabListeners = new CTabFolderListener[tabListeners.length + 1];
    SimpleType!(CTabFolderListener).arraycopy(tabListeners, 0, newTabListeners, 0, tabListeners.length);
    tabListeners = newTabListeners;
    tabListeners[tabListeners.length - 1] = listener;
    // display close button to be backwards compatible
    if (!showClose) {
        showClose = true;
        updateItems();
        redraw();
    }
}
/**
 * Adds the listener to the collection of listeners who will
 * be notified when the user changes the receiver's selection, by sending
 * it one of the messages defined in the <code>SelectionListener</code>
 * interface.
 * <p>
 * <code>widgetSelected</code> is called when the user changes the selected tab.
 * <code>widgetDefaultSelected</code> is not called.
 * </p>
 *
 * @param listener the listener which should be notified when the user changes the receiver's selection
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
 * </ul>
 * @exception DWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 *
 * @see SelectionListener
 * @see #removeSelectionListener
 * @see SelectionEvent
 */
public void addSelectionListener(SelectionListener listener) {
    checkWidget();
    if (listener is null) {
        DWT.error(DWT.ERROR_NULL_ARGUMENT);
    }
    TypedListener typedListener = new TypedListener(listener);
    addListener(DWT.Selection, typedListener);
    addListener(DWT.DefaultSelection, typedListener);
}
void antialias (int[] shape, RGB lineRGB, RGB innerRGB, RGB outerRGB, GC gc){
    // Don't perform anti-aliasing on Mac and WPF because the platform
    // already does it.  The simple style also does not require anti-aliasing.
    if (simple || "carbon".equals(DWT.getPlatform()) || "wpf".equals(DWT.getPlatform())) return; //$NON-NLS-1$
    // Don't perform anti-aliasing on low resolution displays
    if (getDisplay().getDepth() < 15) return;
    if (outerRGB !is null) {
        int index = 0;
        bool left = true;
        int oldY = onBottom ? 0 : getSize().y;
        int[] outer = new int[shape.length];
        for (int i = 0; i < shape.length/2; i++) {
            if (left && (index + 3 < shape.length)) {
                left = onBottom ? oldY <= shape[index+3] : oldY >= shape[index+3];
                oldY = shape[index+1];
            }
            outer[index] = shape[index] + (left ? -1 : +1);
            index++;
            outer[index] = shape[index];
            index++;
        }
        RGB from = lineRGB;
        RGB to = outerRGB;
        int red = from.red + 2*(to.red - from.red)/3;
        int green = from.green + 2*(to.green - from.green)/3;
        int blue = from.blue + 2*(to.blue - from.blue)/3;
        Color color = new Color(getDisplay(), red, green, blue);
        gc.setForeground(color);