root/branches/0.2/controlexample/coolbartab.d

/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
module controlexample.coolbartab;

 private {
import swt.all;
import controlexample.tab;
import controlexample.controlexample;
}


class CoolBarTab : Tab {
    Button dropDownButton, lockedButton, flatButton;

    /* Example widgets and group that contains them */
    CoolBar coolBar;
    CoolItem pushItem, dropDownItem, radioItem, checkItem;
    Group coolBarGroup;
    
    Point[] sizes;
    int[] wrapIndices;
    int[] order;
    
    /**
     * Creates the Tab within a given instance_ren of ControlExample.
     */
    this(ControlExample instance_ren) {
        super(instance_ren);
    }
    
    /**
     * Creates the "Other" group.
     */
    void createOtherGroup () {
        super.createOtherGroup ();
    
        /* Create display controls specific to this example */
        lockedButton = new Button (otherGroup, SWT.CHECK);
        lockedButton.setText (ControlExample.getResourceString("Locked"));
    
        /* Add the listeners */
        lockedButton.handleEvent(this, SWT.Selection, &setWidgetLocked);
    }
    
    /**
     * Creates the "Example" group.
     */
    void createExampleGroup () {
        super.createExampleGroup ();
        coolBarGroup = new Group (exampleGroup, SWT.NONE);
        coolBarGroup.setLayout (new GridLayout ());
        coolBarGroup.setLayoutData (new GridData (GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_FILL));
        coolBarGroup.setText ("CoolBar");
    }
    
    /**
     * Creates the "Example" widgets.
     */
    void createExampleWidgets () {
        int style = getDefaultStyle(), itemStyle = 0;

        /* Compute the widget style */
        int toolBarStyle = SWT.FLAT;
        if (borderButton.getSelection()) style |= SWT.BORDER;
        if (flatButton.getSelection()) style |= SWT.FLAT;
        if (dropDownButton.getSelection()) itemStyle |= SWT.DROP_DOWN;
    
        /*
        * Create the example widgets.
        */
        coolBar = new CoolBar (coolBarGroup, style);
        
        /* create the push button toolbar */
        ToolBar toolBar = new ToolBar (coolBar, toolBarStyle);
        ToolItem item = new ToolItem (toolBar, SWT.PUSH);
        item.setImage (instance_ren.images[ControlExample.ciClosedFolder]);
        item.setToolTipText ("SWT.PUSH");
        item = new ToolItem (toolBar, SWT.PUSH);
        item.setImage (instance_ren.images[ControlExample.ciOpenFolder]);
        item.setToolTipText ("SWT.PUSH");
        item = new ToolItem (toolBar, SWT.PUSH);
        item.setImage (instance_ren.images[ControlExample.ciTarget]);
        item.setToolTipText ("SWT.PUSH");
        item = new ToolItem (toolBar, SWT.SEPARATOR);
        item = new ToolItem (toolBar, SWT.PUSH);
        item.setImage (instance_ren.images[ControlExample.ciClosedFolder]);
        item.setToolTipText ("SWT.PUSH");
        item = new ToolItem (toolBar, SWT.PUSH);
        item.setImage (instance_ren.images[ControlExample.ciOpenFolder]);
        item.setToolTipText ("SWT.PUSH");       
        pushItem = new CoolItem (coolBar, itemStyle);
        pushItem.setControl (toolBar);
        Point pushSize = (cast(Control)toolBar).computeSize(SWT.DEFAULT, SWT.DEFAULT);
        pushSize = pushItem.computeSize(pushSize.x, pushSize.y);
        pushItem.setSize(pushSize);
        pushItem.setMinimumSize(item.getWidth(), pushSize.y);
        pushItem.handleSelection(this, &onCoolItemSelection);
                
        /* create the dropdown toolbar */
        toolBar = new ToolBar (coolBar, toolBarStyle);
        item = new ToolItem (toolBar, SWT.DROP_DOWN);
        item.setImage (instance_ren.images[ControlExample.ciOpenFolder]);
        item.setToolTipText ("SWT.DROP_DOWN");
        item.handleSelection (this, &onDropDownSelection);
        item = new ToolItem (toolBar, SWT.DROP_DOWN);
        item.setImage (instance_ren.images[ControlExample.ciClosedFolder]);
        item.setToolTipText ("SWT.DROP_DOWN");
        item.handleSelection(this, &onDropDownSelection);
        dropDownItem = new CoolItem (coolBar, itemStyle);
        dropDownItem.setControl (toolBar);
        Point dropSize = (cast(Control)toolBar).computeSize(SWT.DEFAULT, SWT.DEFAULT);
        dropSize = dropDownItem.computeSize(dropSize.x, dropSize.y);
        dropDownItem.setSize(dropSize);
        dropDownItem.setMinimumSize(item.getWidth(), dropSize.y);
        dropDownItem.handleSelection(this, &onCoolItemSelection);
                
        /* create the radio button toolbar */
        toolBar = new ToolBar (coolBar, toolBarStyle);
        item = new ToolItem (toolBar, SWT.RADIO);
        item.setImage (instance_ren.images[ControlExample.ciClosedFolder]);
        item.setToolTipText ("SWT.RADIO");
        item = new ToolItem (toolBar, SWT.RADIO);
        item.setImage (instance_ren.images[ControlExample.ciClosedFolder]);
        item.setToolTipText ("SWT.RADIO");
        item = new ToolItem (toolBar, SWT.RADIO);
        item.setImage (instance_ren.images[ControlExample.ciClosedFolder]);
        item.setToolTipText ("SWT.RADIO");
        radioItem = new CoolItem (coolBar, itemStyle);
        radioItem.setControl (toolBar);
        Point radioSize = (cast(Control)toolBar).computeSize(SWT.DEFAULT, SWT.DEFAULT);
        radioSize = radioItem.computeSize(radioSize.x, radioSize.y);
        radioItem.setSize(radioSize);
        radioItem.setMinimumSize(item.getWidth(), radioSize.y);
        radioItem.handleSelection(this, &onCoolItemSelection);
        
        /* create the check button toolbar */
        toolBar = new ToolBar (coolBar, toolBarStyle);
        item = new ToolItem (toolBar, SWT.CHECK);
        item.setImage (instance_ren.images[ControlExample.ciClosedFolder]);
        item.setToolTipText ("SWT.CHECK");
        item = new ToolItem (toolBar, SWT.CHECK);
        item.setImage (instance_ren.images[ControlExample.ciTarget]);
        item.setToolTipText ("SWT.CHECK");
        item = new ToolItem (toolBar, SWT.CHECK);
        item.setImage (instance_ren.images[ControlExample.ciOpenFolder]);
        item.setToolTipText ("SWT.CHECK");
        item = new ToolItem (toolBar, SWT.CHECK);
        item.setImage (instance_ren.images[ControlExample.ciTarget]);
        item.setToolTipText ("SWT.CHECK");
        checkItem = new CoolItem (coolBar, itemStyle);
        checkItem.setControl (toolBar);
        Point checkSize = (cast(Control)toolBar).computeSize(SWT.DEFAULT, SWT.DEFAULT);
        checkSize = checkItem.computeSize(checkSize.x, checkSize.y);
        checkItem.setSize(checkSize);
        checkItem.setMinimumSize(item.getWidth(), checkSize.y);
        checkItem.handleSelection(this, &onCoolItemSelection);
        
        /* if we have saved state, restore it */
        if (order !== null) {
            coolBar.setItemLayout(order, wrapIndices, sizes);
            /* 
             * special case: because setItemLayout will restore the items
             * to the sizes the user left them at, the preferred size may not
             * be the same as the actual size. Thus we must explicitly set
             * the preferred sizes.
             */
            pushItem.setPreferredSize(pushSize);
            dropDownItem.setPreferredSize(dropSize);
            radioItem.setPreferredSize(radioSize);
            checkItem.setPreferredSize(checkSize);
        }
        else {
            int[] intArr = new int[2];
            intArr[0] = 1;
            intArr[1] = 3;
            coolBar.setWrapIndices(intArr);
        }
        
        /* add a listener to resize the group box to match the coolbar */
        coolBar.handleEvent(this, SWT.Resize, delegate(Event e) {
            CoolBarTab c = cast(CoolBarTab)e.cData;
            c.exampleGroup.layout();
        });
    }
    
    /**
     * Creates the "Style" group.
     */
    void createStyleGroup() {
        super.createStyleGroup();
    
        /* Create the extra widget */
        borderButton = new Button (styleGroup, SWT.CHECK);
        borderButton.setText ("SWT.BORDER");
        flatButton = new Button (styleGroup, SWT.CHECK);
        flatButton.setText ("SWT.FLAT");
        Group itemGroup = new Group(styleGroup, SWT.NONE);
        itemGroup.setLayout (new GridLayout ());
        itemGroup.setLayoutData (new GridData (GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_FILL));
        itemGroup.setText(ControlExample.getResourceString("Item_Styles"));
        dropDownButton = new Button (itemGroup, SWT.CHECK);
        dropDownButton.setText ("SWT.DROP_DOWN");
        dropDownButton.handleEvent(this, SWT.Selection, &recreateExampleWidgets);
    }
    
    /**
     * Disposes the "Example" widgets.
     */
    void disposeExampleWidgets () {
        /* store the state of the toolbar if applicable */
        if (coolBar !== null) {
            sizes = coolBar.getItemSizes();
            wrapIndices = coolBar.getWrapIndices();
            order = coolBar.getItemOrder();
        }
        super.disposeExampleWidgets();  
    }

    /**
     * Gets the "Example" widget children's items, if any.
     *
     * @return an array containing the example widget children's items
     */
    Item [] getExampleWidgetItems () {
        return coolBar.getItems();
    }
    
    /**
     * Gets the "Example" widget children.
     */
    Control [] getExampleWidgets () {
        Control[] result;
        result ~= coolBar;
        return result;
    }
    
    /**
     * Gets the text for the tab folder item.
     */
    String getTabText () {
        return "CoolBar";
    }
    
    /**
     * Sets the state of the "Example" widgets.
     */
    void setExampleWidgetState () {
        super.setExampleWidgetState ();
        borderButton.setSelection ((coolBar.getStyle () & SWT.BORDER) != 0);
        flatButton.setSelection ((coolBar.getStyle () & SWT.FLAT) != 0);
        dropDownButton.setSelection ((coolBar.getItem(0).getStyle () & SWT.DROP_DOWN) != 0);
        setWidgetLocked ();
    }
    
    /**
     * Sets the header visible state of the "Example" widgets.
     */
    void setWidgetLocked () {
        coolBar.setLocked (lockedButton.getSelection ());
    }
    
    /**
     * Listens to widgetSelected() events on DWT.DROP_DOWN type ToolItems
     * and opens/closes a menu when appropriate.
     */
 public void onDropDownSelection(SelectionEvent event) {
        Menu menu = null;
        BOOL visible = false;

        void setMenuVisible(BOOL _visible) {
            menu.setVisible(_visible);
            visible = _visible;
        }
        void onMenuHidden(MenuEvent e) { visible = false;}

        // Create the menu if it has not already been created
        if (menu is null) {
            // Lazy create the menu.
            Shell shell = tabFolderPage.getShell();
            menu = new Menu(shell);
// TODO:            
//          menu.handleMenuHide(this, &onMenuHidden);
            
            for (int i = 0; i < 9; ++i) {
                String text = ControlExample.getResourceString("DropDownData_" ~std.string.toString(i));
                if (text.length != 0) {
                    MenuItem menuItem = new MenuItem(menu, SWT.NONE);
                    menuItem.setText(text);
                    /*
                     * Add a menu selection listener so that the menu is hidden
                     * when the user selects an item from the drop down menu.
                     */                  
                    menuItem.handleEvent(menu, SWT.Selection, delegate(Event e) {
                        Menu menu = cast(Menu)e.cData;
                        menu.setVisible(false);
//                      setMenuVisible(false);
                    });
                } else {
                    new MenuItem(menu, SWT.SEPARATOR);
                }
            }
        }
        
        /**
         * A selection event will be fired when a drop down tool
         * item is selected in the main area and in the drop
         * down arrow.  Examine the event detail to determine
         * where the widget was selected.
         */     
        if (event.detail == SWT.ARROW) {
            /*
             * The drop down arrow was selected.
             */
            if (visible) {
                // Hide the menu to give the Arrow the appearance of being a toggle button.
                setMenuVisible(false);
            } else {    
                // Position the menu below and vertically aligned with the the drop down tool button.
                ToolItem toolItem = cast(ToolItem) event.widget;
                ToolBar  toolBar = toolItem.getParent();
                
                Rectangle toolItemBounds = toolItem.getBounds();
                Point point = toolBar.toDisplay(new Point(toolItemBounds.x, toolItemBounds.y));
                menu.setLocation(point.x, point.y + toolItemBounds.height);
                setMenuVisible(true);
            }
        } else {
            /*
             * Main area of drop down tool item selected.
             * An application would invoke the code to perform the action for the tool item.
             */
        }
    }
        

    /**
     * Listens to widgetSelected() events on DWT.DROP_DOWN type CoolItems
     * and opens/closes a menu when appropriate.
     */
    public void onCoolItemSelection(SelectionEvent event) {
        Menu menu = null;
        /**
         * A selection event will be fired when the cool item
         * is selected by its gripper or if the drop down arrow
         * (or 'chevron') is selected. Examine the event detail
         * to determine where the widget was selected.
         */
        if (event.detail == SWT.ARROW) {
            /* If the popup menu is already up (i.e. user pressed arrow twice),
             * then dispose it.
             */
            if (menu !== null) {
                menu.dispose();
                menu = null;
                return;
            }
            
            /* Get the cool item and convert its bounds to display coordinates. */
            CoolItem coolItem = cast(CoolItem) event.widget;
            Rectangle itemBounds = coolItem.getBounds ();
            Point pt = coolBar.toDisplay(new Point (itemBounds.x, itemBounds.y));
            itemBounds.x = pt.x;
            itemBounds.y = pt.y;
            
            /* Get the toolbar from the cool item. */
            ToolBar toolBar = cast(ToolBar) coolItem.getControl ();
            ToolItem[] tools = toolBar.getItems ();
            int toolCount = tools.length;
                            
            /* Convert the bounds of each tool item to display coordinates,
             * and determine which ones are past the bounds of the cool item.
             */
            int i = 0;
            while (i < toolCount) {
                Rectangle toolBounds = tools[i].getBounds ();
                pt = toolBar.toDisplay(new Point(toolBounds.x, toolBounds.y));
                toolBounds.x = pt.x;
                toolBounds.y = pt.y;
                Rectangle intersection = itemBounds.intersection (toolBounds);
                if (!intersection.equals (toolBounds)) break;
                i++;
            }
            
            /* Create a pop-up menu with items for each of the hidden buttons. */
            menu = new Menu (coolBar);
            for (int j = i; j < toolCount; j++) {
                ToolItem tool = tools[j];
                Image image = tool.getImage();
                if (image is null) {
                    new MenuItem (menu, SWT.SEPARATOR);
                } else {
                    if ((tool.getStyle() & SWT.DROP_DOWN) != 0) {
                        MenuItem menuItem = new MenuItem (menu, SWT.CASCADE);
                        menuItem.setImage(image);
                        Menu m = new Menu(menu);
                        menuItem.setMenu(m);
                        for (int k = 0; k < 9; ++k) {
                            String text = ControlExample.getResourceString("DropDownData_" ~std.string.toString(k));
                            if (text.length != 0) {
                                MenuItem mi = new MenuItem(m, SWT.NONE);
                                mi.setText(text);
                                /* Application code to perform the action for the submenu item would go here. */
                            } else {
                                new MenuItem(m, SWT.SEPARATOR);
                            }
                        }
                    } else {
                        MenuItem menuItem = new MenuItem (menu, SWT.NONE);
                        menuItem.setImage(image);
                    }
                    /* Application code to perform the action for the menu item would go here. */

                }
            }
            
            /* Display the pop-up menu at the lower left corner of the arrow button.
             * Dispose the menu when the user is done with it.
             */
            pt = coolBar.toDisplay(new Point(event.x, event.y));
            menu.setLocation (pt.x, pt.y);
            menu.setVisible (true);
            Display display = coolBar.getDisplay ();
            while (menu !== null && !menu.isDisposed() && menu.isVisible ()) {
                if (!display.readAndDispatch ()) display.sleep ();
            }
            if (menu !== null) {
                menu.dispose ();
                menu = null;
            }
        }
    }
}