Attachment #74118 for bug #153835

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 153835
Collapse All | Expand All





package org.openide.awt;

import java.awt.Component;
import java.awt.Insets;
import java.awt.dnd.*;
import java.awt.event.*;
import java.io.IOException;
import java.util.EventListener;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EventObject;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.AbstractButton;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JSeparator;
import javax.swing.JToolBar;
import javax.swing.UIManager;
import javax.swing.plaf.metal.MetalLookAndFeel;
import javax.swing.plaf.synth.Region;
import javax.swing.plaf.synth.SynthConstants;
import javax.swing.plaf.synth.SynthContext;
import javax.swing.plaf.synth.SynthLookAndFeel;
import javax.swing.plaf.synth.SynthStyle;
import javax.swing.plaf.synth.SynthStyleFactory;
import org.openide.cookies.InstanceCookie;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.FolderInstance;
import org.openide.util.ImageUtilities;
import org.openide.util.Task;
import org.openide.util.actions.Presenter;
import org.openide.util.datatransfer.ExTransferable;

/**
 * Toolbar provides a component which is useful for displaying commonly used


    static final Logger LOG = Logger.getLogger(Toolbar.class.getName());
    
    /** 5 pixels is tolerance of toolbar height so toolbar can be high (BASIC_HEIGHT + HEIGHT_TOLERANCE)
        but it will be set to BASIC_HEIGHT high. */
    static int HEIGHT_TOLERANCE = 5;
    /** TOP of toolbar empty border. */
    static int TOP = 2;
    /** LEFT of toolbar empty border. */
    static int LEFT = 3;
    /** BOTTOM of toolbar empty border. */
    static int BOTTOM = 2;
    /** RIGHT of toolbar empty border. */
    static int RIGHT = 3;
    /** Residual size of the toolbar when dragged far right */
    static int RESIDUAL_WIDTH = 16;
   

    /** is toolbar floatable */
    private boolean floatable;
    /** Toolbar DnDListener */
    private DnDListener listener;
    /** Toolbar mouse listener */
    private ToolbarMouseListener mouseListener;
    /** display name of the toolbar */
    private String displayName;
    

        isJdk16 = javaVersion.startsWith( "1.6" );
    }
    
    private static final int customFontHeightCorrection;
    
    static {
        int customFontSize = UIManager.getInt( "customFontSize" );
        if( customFontSize < 1 ) 
            customFontSize = 1;
            
        int defaultFontSize = UIManager.getInt( "nbDefaultFontSize" );
        if( defaultFontSize <= 0 ) 
            defaultFontSize = 11;
        
        customFontHeightCorrection = Math.max( customFontSize - defaultFontSize, 0 );
    }
    
    private static Class synthIconClass = null;
        
    private static boolean testExecuted = false;
    
    /** Create a new Toolbar with empty name. */
    public Toolbar () {
        this (""); // NOI18N

        this (name, name, f);
    }
        
    Toolbar(DataFolder folder) {
        super();
        backingFolder = folder;
        initAll(folder.getName(), false);
        putClientProperty("folder", folder); //NOI18N
    }
    
    /** 
     * Test if SynthIcon is available and can be used for painting native Toolbar
     * D&D handle. If not use our own handle. Reflection is used here as it is Sun
     * proprietary API.
     */
    private static boolean useSynthIcon () {
        if (!testExecuted) {
            testExecuted = true;
            try {
                synthIconClass = Class.forName("sun.swing.plaf.synth.SynthIcon");
            } catch (ClassNotFoundException exc) {
                LOG.log(Level.INFO, null, exc);
            }
        }
        return (synthIconClass != null);
    }
    
    private void initDnD() {
        DropTarget dt = new DropTarget(this, getDnd());
    }
    
    DataFolder getFolder() {
        return backingFolder;
    }
    

    @Override
    public void paint( Graphics g ) {
        super.paint( g );
        if( -1 != dropTargetButtonIndex ) {
            paintDropGesture( g );
        }
    }
    
    private void updateDropGesture( DropTargetDragEvent e ) {
        Point p = e.getLocation();
        Component c = getComponentAt(p);
        int index = Toolbar.this.getComponentIndex(c);
        if( index == 0 ) {
            //dragging over toolbar's grip
            resetDropGesture();
        } else {
            //find out whether we want to drop before or after this component
            boolean b = p.x <= c.getLocation().x + c.getWidth() / 2;
            if( index != dropTargetButtonIndex || b != insertBefore ) {
                dropTargetButtonIndex = index;
                insertBefore = b;
                repaint();
            }
        }
    }
    
    private void resetDropGesture() {
        dropTargetButtonIndex = -1;
        repaint();
    }
    
    private void paintDropGesture( Graphics g ) {
        Component c = getComponentAtIndex( dropTargetButtonIndex );
        if( null == c )
            return;
        
        Point location = c.getLocation();
        int cursorLocation = location.x;
        if( !insertBefore ) {
            cursorLocation += c.getWidth();
            if( dropTargetButtonIndex == getComponentCount()-1 )
                cursorLocation -= 3;
        }
        drawDropLine( g, cursorLocation );
    }
    
    private void drawDropLine( Graphics g, int x ) {
        Color oldColor = g.getColor();
        g.setColor( Color.black );
        int height = getHeight();
        g.drawLine( x, 3, x, height-4 );
        g.drawLine( x-1, 3, x-1, height-4 );

        g.drawLine( x+1, 2, x+1+2, 2 );
        g.drawLine( x+1, height-3, x+1+2, height-3 );

        g.drawLine( x-2, 2, x-2-2, 2 );
        g.drawLine( x-2, height-3, x-2-2, height-3 );
        g.setColor( oldColor );
    }
    
    /**
     * Remove a toolbar button represented by the given Transferable.
     */
    private void removeButton( Transferable t ) {
        try {
            Object o = null;
            if( t.isDataFlavorSupported( buttonDataFlavor ) ) {
                o = t.getTransferData( buttonDataFlavor ); //XXX
            }
            if( null != o && o instanceof DataObject ) {
                ((DataObject) o).delete();
                repaint();
                if( backingFolder.getChildren().length == 0 ) {
                    javax.swing.SwingUtilities.invokeLater(new java.lang.Runnable() {

                                                               public void run() {
                                                                   try {
                                                                       backingFolder.delete();
                                                                   }
                                                                   catch (java.io.IOException e) {
                                                                       LOG.log(Level.WARNING,
                                                                                         null,
                                                                                         e);
                                                                   }
                                                               }
                                                           });
                }
            }
        } catch( UnsupportedFlavorException ex ) {
            Exceptions.printStackTrace(ex);
        } catch (IOException ioe) {
            Exceptions.printStackTrace(ioe);
        }
    }
    
    /**
     * Perform the drop operation.
     *
     * @return True if the drop has been successful.
     */
    private boolean handleDrop( Transferable t ) {
        try {
            Object o;
            if( t.isDataFlavorSupported( actionDataFlavor ) ) {
                o = t.getTransferData( actionDataFlavor );
                if( o instanceof Node ) {
                    DataObject dobj = ((Node)o).getLookup().lookup( DataObject.class );
                    return addButton( dobj, dropTargetButtonIndex-1, insertBefore );
                }
            } else {
                o = t.getTransferData( buttonDataFlavor );
                if( o instanceof DataObject ) {
                    return moveButton( (DataObject)o, dropTargetButtonIndex-1, insertBefore );
                }
            }
        } catch (UnsupportedFlavorException e) {
            Exceptions.printStackTrace(e);
        } catch (IOException ioe) {
            Exceptions.printStackTrace(ioe);
        }
        return false;
    }

    /**
     * Component index of the button under the drag cursor, or -1 when the cursor
     * is above the toolbar drag handle
     */
    int dropTargetButtonIndex = -1;
    /**
     * Component index of the button being dragged, only used when dragging a button
     * within the same toolbar.
     */
    int dragSourceButtonIndex = -1;
    /**
     * True if the button being dragged should be dropped BEFORE the button 
     * under the drag cursor.
     */
    boolean insertBefore = true;
    /**
     * True indicates the toolbar instance whose button is being dragged.
     */
    boolean isDragSourceToolbar = false;
    
    private static DataFlavor buttonDataFlavor = new DataFlavor( DataObject.class, "Toolbar Item" );
    private static DataFlavor actionDataFlavor = new DataFlavor( Node.class, "Action Node" );

    private DnDSupport dnd;
    private class DnDSupport implements DragSourceListener, DragGestureListener, DropTargetListener, DragSourceMotionListener {
        private DragSource dragSource = new DragSource();
        
        private Cursor dragMoveCursor = DragSource.DefaultMoveDrop;
        private Cursor dragNoDropCursor = DragSource.DefaultMoveNoDrop;
        private Cursor dragRemoveCursor = Utilities.createCustomCursor( Toolbar.this, ImageUtilities.loadImage( "org/openide/loaders/delete.gif"), "NO_ACTION_MOVE" );
        private Map<Component, DragGestureRecognizer> recognizers = new HashMap<Component, DragGestureRecognizer>();
        
        public DnDSupport() {
            dragSource.addDragSourceMotionListener(this);
        }
        
        public void register(Component c) {
            DragGestureRecognizer dgr = recognizers.get( c );
            if( null == dgr ) {
                dgr = dragSource.createDefaultDragGestureRecognizer(c, DnDConstants.ACTION_MOVE, this);
                recognizers.put( c, dgr );
            }
        }

        public void unregister(Component c) {
            DragGestureRecognizer dgr = recognizers.get( c );
            if( null != dgr ) {
                dgr.removeDragGestureListener( this );
                recognizers.remove( c );
            }
        }
        
        public void dragEnter(DragSourceDragEvent e) {
            //handled in dragMouseMoved
        }

        public void dragOver(DragSourceDragEvent e) {
            //handled in dragMouseMoved
        }
        
        public void dragExit(DragSourceEvent e) {
            //handled in dragMouseMoved
            resetDropGesture();
        }

        public void dragDropEnd(DragSourceDropEvent e) {
            isDragSourceToolbar = false;
            Component sourceComponent = e.getDragSourceContext().getComponent();
            if( sourceComponent instanceof JButton ) {
                ((JButton)sourceComponent).getModel().setRollover( false );
            }
            sourceComponent.repaint();
            resetDropGesture();
            if ( e.getDropSuccess() == false && !isInToolbarPanel( e.getLocation() ) ) {
                removeButton( e.getDragSourceContext().getTransferable() );
            }
        }
        
        public void dragGestureRecognized(DragGestureEvent e) {
            if( !ToolbarPool.getDefault().isInEditMode()
                    || "QuickSearch".equals(getName()) )  //HACK (137286)- there's not better way...
                return;
            try {
                 Component c = e.getComponent();
                 //do not allow to drag toolbar separators
                 if( c instanceof JToolBar.Separator || "grip".equals( c.getName() ) )
                     return;
                 Transferable t = null;
                 if (c instanceof JComponent) {
                     final DataObject dob = (DataObject) ((JComponent) c).getClientProperty("file");
                     if (dob != null) {
                         t = new ExTransferable.Single( buttonDataFlavor ) {
                             public Object getData() {
                                 return dob;
                             }
                         };
                     }
                 }
                 if( c instanceof JButton ) {
                     ((JButton)c).getModel().setArmed( false );
                     ((JButton)c).getModel().setPressed( false );
                     ((JButton)c).getModel().setRollover( true );
                 }
                 if (t != null) {
                    dragSourceButtonIndex = Toolbar.this.getComponentIndex( c );
                    isDragSourceToolbar = true;
                    dragSource.startDrag(e, dragMoveCursor, t, this);
                 }
                
              } catch ( InvalidDnDOperationException idoe ) {
                    Exceptions.printStackTrace(idoe);
              }
        }

        public void dropActionChanged (DragSourceDragEvent e) {
            //ignore
        }
        
        public void drop(DropTargetDropEvent dtde) {
            boolean res = false;
            try {
                if( validateDropPosition() ) {
                    res = handleDrop( dtde.getTransferable() );
                }
            } finally {
                dtde.dropComplete(res);
            }
            resetDropGesture();
        }
        
        public void dragExit(DropTargetEvent dte) {
            resetDropGesture();
        }
        
        public void dropActionChanged(DropTargetDragEvent dtde) {
            //ignore
        }

        public void dragEnter(DropTargetDragEvent e) {
            if( e.isDataFlavorSupported( buttonDataFlavor ) 
                || e.isDataFlavorSupported( actionDataFlavor ) ) {
                e.acceptDrag(DnDConstants.ACTION_COPY_OR_MOVE);
            } else {
                e.rejectDrag();
            }
        }

        public void dragOver(DropTargetDragEvent e) {
            if( e.isDataFlavorSupported( buttonDataFlavor ) 
                || e.isDataFlavorSupported( actionDataFlavor ) ) {
                updateDropGesture( e );
                if( !validateDropPosition() ) {
                    e.rejectDrag();
                } else {
                    e.acceptDrag( DnDConstants.ACTION_COPY_OR_MOVE );
                }
            } else {
                e.rejectDrag();
            }
        }

        public void dragMouseMoved(DragSourceDragEvent e) {
            DragSourceContext context = e.getDragSourceContext();
            int action = e.getDropAction();
            if ((action & DnDConstants.ACTION_MOVE) != 0) {
                context.setCursor( dragMoveCursor );
            } else {
                if( isInToolbarPanel( e.getLocation() ) ) 
                    context.setCursor( dragNoDropCursor );
                else
                    context.setCursor( dragRemoveCursor );
            }
        }
    }
    
    private boolean isInToolbarPanel( Point p ) {
        Component c = ToolbarPool.getDefault();
        SwingUtilities.convertPointFromScreen( p, c );
        return c.contains( p );
    }
    
    /**
     * Add a new toolbar button represented by the given DataObject.
     */
    private boolean addButton( DataObject dobj, int dropIndex, boolean dropBefore ) throws IOException {
        if( null == dobj )
            return false;
        //check if the dropped button (action) already exists in this toolbar
        String objName = dobj.getName();
        DataObject[] children = backingFolder.getChildren();
        for( int i=0; i<children.length; i++ ) {
            //TODO is comparing DataObject names ok?
            if( objName.equals( children[i].getName() ) ) {
                //user dropped to toolbat a new button that already exists in this toolbar
                //just move the existing button to a new position
                isDragSourceToolbar = true;
                return moveButton( children[i], dropIndex, dropBefore );
            }
        }

        DataObject objUnderCursor = getDataObjectUnderDropCursor( dropIndex, dropBefore );

        DataShadow shadow = DataShadow.create( backingFolder, dobj );
        
        //find the added object
        DataObject newObj = null;
        children = backingFolder.getChildren();
        for( int i=0; i<children.length; i++ ) {
            if( objName.equals( children[i].getName() ) ) {
                newObj = children[i];
                break;
            }
        }
        
        if( null != newObj )
            reorderButtons( newObj, objUnderCursor ); //put the button to its proper position
        
        return true;
    }
    
    /**
     * Move toolbar button to a new position.
     */
    private boolean moveButton( DataObject ob, int dropIndex, boolean dropBefore ) throws IOException {
        //find out which button is currently under the drag cursor
        DataObject objUnderCursor = getDataObjectUnderDropCursor( dropIndex, dropBefore );

        if( !isDragSourceToolbar ) {
            //move button to the new toolbar
            ob.move(backingFolder);                 
        }

        reorderButtons( ob, objUnderCursor );
        //else we're dragging a button to an empty toolbar
        return true;
    }
    
    private void reorderButtons( DataObject objToMove, DataObject objUnderCursor ) throws IOException {
        java.util.List<DataObject> children = 
                new ArrayList<DataObject>( Arrays.asList( backingFolder.getChildren() ) );
        if( null == objUnderCursor ) {
            children.remove( objToMove );
            children.add( objToMove );
        } else {
            int targetIndex = children.indexOf( objUnderCursor );
            int currentIndex = children.indexOf( objToMove );
            if( currentIndex < targetIndex )
                targetIndex--;
            children.remove( objToMove );
            children.add( targetIndex, objToMove );
        }

        backingFolder.setOrder( children.toArray( new DataObject[children.size()]) );
    }
    
    private DataObject getDataObjectUnderDropCursor( int dropIndex, boolean dropBefore ) {
        DataObject[] buttons = backingFolder.getChildren();
        DataObject objUnderCursor = null;
        if( buttons.length > 0 ) {
            if( !dropBefore )
                dropIndex++;
            if( dropIndex < buttons.length && dropIndex >= 0 ) {
                objUnderCursor = buttons[dropIndex];
            }
        }
        return objUnderCursor;
    }
    
    private boolean validateDropPosition() {
               //the drag cursor cannot be positioned above toolbar's drag handle
        return dropTargetButtonIndex >= 0
               //when toolbar has buttons '1 2 3 4 5' and we're dragging button 3,
               //do not allow drop between buttons 2 and 3 and also between buttons 3 and 3
               && !(isDragSourceToolbar && (dragSourceButtonIndex == dropTargetButtonIndex  //drop index 3
                                        || (dropTargetButtonIndex == dragSourceButtonIndex-1 && !insertBefore) //drop index 2
                                        || (dropTargetButtonIndex == dragSourceButtonIndex+1 && insertBefore))) //drop index 4
               //dragging a button to an empty toolbar
               || (dropTargetButtonIndex < 0 && getComponentCount() == 1);
    }

    /** Start tracking content of the underlaying folder if not doing so yet */
    final Folder waitFinished() {
        // check for too early call (from constructor and UI.setUp...)

        }
        
        super.addImpl (c, constraints, idx);
        if( !("grip".equals(c.getName()) || (c instanceof JToolBar.Separator)) ) {
            getDnd().register(c);
        }
    }

    /**
     * Create a new <code>Toolbar</code>.

     * toolbar layout manager.
     * @return basic toolbar height
     * @since 4.15
     * @deprecated Returns preferred icon size.
     */
    public static int getBasicHeight () {
        return ToolbarPool.getDefault().getPreferredIconSize();
            return 44;
        } else {
            return 34;
        }
    }
    
    private void initAll(String name, boolean f) {
        floatable = f;
        mouseListener = null;

        setName (name);
        
        setFloatable (f);
        String lAndF = UIManager.getLookAndFeel().getName();
        
        if (lAndF.equals("Windows")) {
            //Get rid of extra height, also allow for minimalist main
            //window
            setBorder(Boolean.getBoolean("netbeans.small.main.window") ?
                BorderFactory.createEmptyBorder(1,1,1,1) : 
                BorderFactory.createEmptyBorder()); //NOI18N
        } else if (!"Aqua".equals(UIManager.getLookAndFeel().getID()) && !"GTK".equals(UIManager.getLookAndFeel().getID())){
            Border b = UIManager.getBorder ("ToolBar.border"); //NOI18N
            
            if ((b==null) || (b instanceof javax.swing.plaf.metal.MetalBorders.ToolBarBorder))  
                b=BorderFactory.createEtchedBorder (EtchedBorder.LOWERED);
            setBorder (new CompoundBorder ( 
                   b,
                   new EmptyBorder (TOP, LEFT, BOTTOM, RIGHT))
                   );  
             
        }
        
        if (!"Aqua".equals(UIManager.getLookAndFeel().getID())) {
            putClientProperty("JToolBar.isRollover", Boolean.TRUE); // NOI18N
        }
        addGrip();

        getAccessibleContext().setAccessibleName(displayName == null ? getName() : displayName);
        getAccessibleContext().setAccessibleDescription(getName());
    }

        }
    }
    
    @Override
    public Dimension getPreferredSize() {
        String lfid = UIManager.getLookAndFeel().getID();
        int minheight;
        
        if (ToolbarPool.getDefault().getPreferredIconSize() == 24) {
            if ("Aqua".equals(lfid)) {
                minheight = 29 + 8;
            } else if ("Metal".equals(lfid)) {
                minheight = 36 + 8;
            } else if ("Windows".equals(lfid)) {
                minheight = isXPTheme() ? (23 + 8) : (27 + 8);
            } else if ("GTK".equals(lfid)) {
                minheight = 32 + 8;
            } else {
                minheight = 28 + 8;
            }
        } else {
            if ("Aqua".equals(lfid)) {
                minheight = 29;
            } else if ("Metal".equals(lfid)) {
                minheight = 36;
            } else if ("Windows".equals(lfid)) {
                minheight = isXPTheme() ? 23 : 27;
            } else if ("GTK".equals(lfid)) {
                minheight = 32;
            } else {
                minheight = 28;
            }
        }
        Dimension result = super.getPreferredSize();
        result.height = Math.max (result.height, minheight);
        return result;
    }

    /** Removes all ACTION components. */
    @Override
    public void removeAll () {
        for( int i=0; i<getComponentCount(); i++ ) {
            getDnd().unregister( getComponent(i) );
        }
        super.removeAll();
        addGrip();
    }

    /**
     * When Toolbar is floatable, ToolbarBump is added as Grip as first toolbar component
     * modified by Michael Wever, to use l&f's grip/bump. */
    void addGrip () {
        //HACK (137286)- there's not better way...
        if (floatable && !"QuickSearch".equals(getName()) ) { //NOI18N
            /** Uses L&F's grip **/
            String lfID = UIManager.getLookAndFeel().getID();
            JPanel dragarea = null;
            // #98888: recognize JGoodies L&F properly
            if (lfID.endsWith("Windows")) {
                if (isXPTheme()) {
                    dragarea = (JPanel) new ToolbarXP();
                } else {
                    dragarea = (JPanel) new ToolbarGrip();
                }
            } else if (lfID.equals("Aqua")) {
                dragarea = (JPanel) new ToolbarAqua();
            } else if (lfID.equals("GTK")) {
                dragarea = (JPanel) new ToolbarGtk();
                //setFloatable(true);
            } else {
                //Default for Metal and uknown L&F
                dragarea = (JPanel)new ToolbarBump();
            }
            if (mouseListener == null) {
                mouseListener = new ToolbarMouseListener ();
            }
            
            if (dragarea != null) {
                dragarea.addMouseListener (mouseListener);
                dragarea.addMouseMotionListener (mouseListener);

                dragarea.setName ("grip");
                add (dragarea);
            }
        }
    }

    /** Compute with HEIGHT_TOLERANCE number of rows for specific toolbar height.
     * @param height of some toolbar
     * @return number of rows
     * @deprecated Always returns 1
     */
    static public int rowCount (int height) {
        return 1;
    }

    /** Set DnDListener to Toolbar.
     * @param l DndListener for toolbar
     * @deprecated
     */
    public void setDnDListener (DnDListener l) {
        listener = l;

        this.displayName = displayName;
    }
    
    private static final void setToolTipText (JComponent comp, String text) {
        comp.setToolTipText(Actions.cutAmpersand(text));
    }

    /** Fire drag of Toolbar
     * @param dx distance of horizontal dragging
     * @param dy distance of vertical dragging
     * @param type type of toolbar dragging
     */
    protected void fireDragToolbar (int dx, int dy, int type) {
        if (listener != null)
            listener.dragToolbar (new DnDEvent (this, getName(), dx, dy, type));
    }

    /** Fire drop of Toolbar
     * @param dx distance of horizontal dropping
     * @param dy distance of vertical dropping
     * @param type type of toolbar dropping
     */
    protected void fireDropToolbar (int dx, int dy, int type) {
        if (listener != null)
            listener.dropToolbar (new DnDEvent (this, getName(), dx, dy, type));
    }

    synchronized final MouseInputListener mouseDelegate () {
        if (mouseListener == null) mouseListener = new ToolbarMouseListener ();
        return mouseListener;
    }

    /** Toolbar mouse listener. */
    class ToolbarMouseListener extends MouseInputAdapter {
        /** Is toolbar dragging now. */
        private boolean dragging = false;
        /** Start point of dragging. */
        private Point startPoint = null;

        /** Invoked when a mouse button has been pressed on a component. */
        @Override
        public void mousePressed (MouseEvent e) {
            startPoint = e.getPoint();
        }

        /** Invoked when a mouse button has been released on a component. */
        @Override
        public void mouseReleased (MouseEvent e) {
            if (dragging) {
                
                int dx = getX() + e.getX() - startPoint.x > getParent().getWidth() - RESIDUAL_WIDTH ?
                0 : e.getX() - startPoint.x;
                
                fireDropToolbar (dx,
                                 e.getY() - startPoint.y,
                                 DnDEvent.DND_ONE);
                dragging = false;
            }
        }

        /** Invoked when a mouse button is pressed on a component and then dragged. */
        @Override
        public void mouseDragged (MouseEvent e) {
            int m = e.getModifiers();
            int type = DnDEvent.DND_ONE;
            int dx;
            
            if (e.isControlDown())
                type = DnDEvent.DND_LINE;
            else if (((m & InputEvent.BUTTON2_MASK) != 0) ||
                     ((m & InputEvent.BUTTON3_MASK) != 0))
                type = DnDEvent.DND_END;
            if (startPoint == null) {
                startPoint = new Point (e.getX(), e.getY());
            }
            
            if ( getX() + e.getX() + startPoint.x > getParent().getWidth() - RESIDUAL_WIDTH ) {
                if ( getX() >= getParent().getWidth() - RESIDUAL_WIDTH ) {
                    dx = 0;
                }
                else {
                    dx = getParent().getWidth() - RESIDUAL_WIDTH - getX();
                }
            }
            else {
                dx = e.getX() - startPoint.x; 
            }
            
            fireDragToolbar ( dx,
                             e.getY() - startPoint.y,
                             type);
            dragging = true;
        }

    } // end of inner class ToolbarMouseListener

    /**
     * This class can be used to produce a <code>Toolbar</code> instance from
     * the given <code>DataFolder</code>.

         */
        @Override
        protected InstanceCookie acceptCookie (InstanceCookie cookie)
            throws IOException, ClassNotFoundException {
            boolean is;
            
            if (cookie instanceof InstanceCookie.Of) {

         * @return the updated <code>ToolbarPool</code> representee
         */
        protected Object createInstance(final InstanceCookie[] cookies)
            throws IOException, ClassNotFoundException {
            // refresh the toolbar's content
            Toolbar.this.removeAll();
            for (int i = 0; i < cookies.length; i++) {
                try {
                    Object obj = cookies[i].instanceCreate();
                    Object file = cookiesToObjects.get(obj);

                    if (obj instanceof Presenter.Toolbar) {
                        obj = ((Presenter.Toolbar) obj).getToolbarPresenter();
                    }
                    if (obj instanceof Component) {
                        // remove border and grip if requested. "Fixed" toolbar
                        // item has to live alone in toolbar now
                        if ((obj instanceof JComponent) &&
                            "Fixed".equals(((JComponent) obj).getClientProperty("Toolbar"))) {
                            floatable = false;
                            org.openide.awt.Toolbar.this.removeAll();
                            setBorder(null);
                        }
                        if (obj instanceof javax.swing.JComponent) {
                            if (ToolbarPool.getDefault().getPreferredIconSize() == 24) {
                                ((JComponent) obj).putClientProperty("PreferredIconSize", new Integer(24));
                                ((javax.swing.JComponent) obj).putClientProperty("PreferredIconSize",
                                                                                 new java.lang.Integer(24));
                            }
                            ((JComponent) obj).putClientProperty("file", file);
                                                                             file);
                        }
                        Toolbar.this.add((Component) obj);
                        continue;
                    }
                    if (obj instanceof Action) {
                        Action a = (Action) obj;
                        JButton b = new DefaultIconButton();

                        if (ToolbarPool.getDefault().getPreferredIconSize() == 24) {
                            b.putClientProperty("PreferredIconSize", new Integer(24));
                            b.putClientProperty("PreferredIconSize",
                                                new java.lang.Integer(24));
                        }
                        if (null == a.getValue(Action.SMALL_ICON)
                            && (null == a.getValue(Action.NAME) || a.getValue(Action.NAME).toString().length() == 0)) {
                            a.putValue(Action.SMALL_ICON, new ImageIcon( ImageUtilities.loadImage( "org/openide/loaders/unknown.gif") ));
                             0)) {
                            a.putValue(javax.swing.Action.SMALL_ICON,
                                       new ImageIcon( ImageUtilities.loadImage( "org/openide/loaders/unknown.gif") ));
                        }
                        org.openide.awt.Actions.connect(b, a);
                        b.putClientProperty("file", file);


    } // end of inner class Folder

    /** Bumps for floatable toolbar */
    private final class ToolbarBump extends JPanel {
        /** Top gap. */
        static final int TOPGAP = 2;
        /** Bottom gap. */
        static final int BOTGAP = 2;
        /** Width of bump element. */
        static final int WIDTH = 6;
        
        /** Minimum size. */
        Dimension dim;
        /** Maximum size. */
        Dimension max;

        static final long serialVersionUID =-8819972936203315277L;

        /** Create new ToolbarBump. */
        public ToolbarBump () {
            super();
            int width = WIDTH;
            dim = new Dimension (width, width);
            max = new Dimension (width, Integer.MAX_VALUE);
            Toolbar.setToolTipText (this, Toolbar.this.getDisplayName());
        }

        /** Paint bumps to specific Graphics. */
        @Override
        public void paint (Graphics g) {
            Dimension size = this.getSize ();
            int height = size.height - BOTGAP;
            g.setColor (this.getBackground ());

            for (int x = 0; x+1 < size.width; x+=4) {
                for (int y = TOPGAP; y+1 < height; y+=4) {
                    g.setColor (this.getBackground ().brighter ());
                    g.drawLine (x, y, x, y);
                    if (x+5 < size.width && y+5 < height) {
                        g.drawLine (x+2, y+2, x+2, y+2);
                    }
                    g.setColor (this.getBackground ().darker ().darker ());
                    g.drawLine (x+1, y+1, x+1, y+1);
                    if (x+5 < size.width && y+5 < height) {
                        g.drawLine (x+3, y+3, x+3, y+3);
                    }
                }
            }
        }

        /** @return minimum size */
        @Override
        public Dimension getMinimumSize () {
            return dim;
        }

        /** @return preferred size */
        @Override
        public Dimension getPreferredSize () {
            return this.getMinimumSize ();
        }

        @Override
        public Dimension getMaximumSize () {
            return max;
        }
    } // end of inner class ToolbarBump

    /** Bumps for floatable toolbar GTK L&F */
    private final class ToolbarGtk extends JPanel {
        /** Top gap. */
        int TOPGAP;
        /** Bottom gap. */
        int BOTGAP;
        /** Width of bump element. */
        static final int WIDTH = 6;
        
        /** Minimum size. */
        Dimension dim;
        /** Maximum size. */
        Dimension max;

        static final long serialVersionUID = -8819972936203315277L;
        
        /** Create new ToolbarBump. */
        public ToolbarGtk () {
            super();
            int width = WIDTH;
            if (useSynthIcon()) {
                TOPGAP = 0;
                BOTGAP = 0;
            } else {
                TOPGAP = 2;
                BOTGAP = 2;
            }
            dim = new Dimension (width, width);
            max = new Dimension (width, Integer.MAX_VALUE);
            Toolbar.setToolTipText (this, Toolbar.this.getDisplayName());
        }
        
        /** Paint bumps to specific Graphics. */
        @Override
        public void paint (Graphics g) {
            if (useSynthIcon()) {
                int height = Toolbar.this.getHeight() - BOTGAP;
                Icon icon = UIManager.getIcon("ToolBar.handleIcon");
                Region region = Region.TOOL_BAR;
                SynthStyleFactory sf = SynthLookAndFeel.getStyleFactory();
                SynthStyle style = sf.getStyle(Toolbar.this, region);
                SynthContext context = new SynthContext(Toolbar.this, region, style, SynthConstants.DEFAULT);

                // for vertical toolbar, you'll need to ask for getIconHeight() instead
                Method m = null;
                try {
                    m = synthIconClass.getMethod("getIconWidth",Icon.class, SynthContext.class);
                } catch (NoSuchMethodException exc) {
                    LOG.log(Level.WARNING, null, exc);
                }
                int width = 0;
                //width = SynthIcon.getIconWidth(icon, context);
                try {
                    width = (Integer) m.invoke(null, new Object [] {icon, context});
                } catch (IllegalAccessException exc) {
                    LOG.log(Level.WARNING, null, exc);
                } catch (InvocationTargetException exc) {
                    LOG.log(Level.WARNING, null, exc);
                }
                try {
                    m = synthIconClass.getMethod("paintIcon",Icon.class,SynthContext.class,                            
                    Graphics.class,Integer.TYPE,Integer.TYPE,Integer.TYPE,Integer.TYPE);
                } catch (NoSuchMethodException exc) {
                    LOG.log(Level.WARNING, null, exc);
                }
                //SynthIcon.paintIcon(icon, context, g, 0, 0, width, height);
                try {
                    m.invoke(null, new Object [] {icon,context,g,new Integer(0),new Integer(-1),
                    new Integer(width),new Integer(height)});
                } catch (IllegalAccessException exc) {
                    LOG.log(Level.WARNING, null, exc);
                } catch (InvocationTargetException exc) {
                    LOG.log(Level.WARNING, null, exc);
                }                    
            } else {
                Dimension size = this.getSize();
                int height = size.height - BOTGAP;
                g.setColor (this.getBackground ());

                for (int x = 0; x+1 < size.width; x+=4) {
                    for (int y = TOPGAP; y+1 < height; y+=4) {
                        g.setColor (this.getBackground ().brighter ());
                        g.drawLine (x, y, x, y);
                        if (x+5 < size.width && y+5 < height) {
                            g.drawLine (x+2, y+2, x+2, y+2);
                        }
                        g.setColor (this.getBackground ().darker ().darker ());
                        g.drawLine (x+1, y+1, x+1, y+1);
                        if (x+5 < size.width && y+5 < height) {
                            g.drawLine (x+3, y+3, x+3, y+3);
                        }
                    }
                }
            }
        }

        /** @return minimum size */
        @Override
        public Dimension getMinimumSize () {
            return dim;
        }

        /** @return preferred size */
        @Override
        public Dimension getPreferredSize () {
            return new Dimension(WIDTH,Toolbar.this.getHeight() - BOTGAP - TOPGAP);
        }

        @Override
        public Dimension getMaximumSize () {
            return max;
        }
    } // end of inner class ToolbarGtk
    
    /** Recognizes if XP theme is set.
     * @return true if XP theme is set, false otherwise
     */
    private static Boolean isXP = null;
    private static boolean isXPTheme () {
        if (isXP == null) {
            Boolean xp = (Boolean)Toolkit.getDefaultToolkit().
            getDesktopProperty("win.xpstyle.themeActive"); //NOI18N
            isXP = Boolean.TRUE.equals(xp)? Boolean.TRUE : Boolean.FALSE;
        }
        return isXP.booleanValue();
    }    
    
    private final class ToolbarAqua extends JPanel {
        /** Width of grip */
        static final int WIDTH = 8;
        /** Minimum size. */
        Dimension dim;
        /** Maximum size. */
        Dimension max;
        static final long serialVersionUID =-8819972972003315277L;

        public ToolbarAqua() {
            dim = new Dimension (WIDTH, WIDTH);
            max = new Dimension (WIDTH, Integer.MAX_VALUE);
            Toolbar.setToolTipText (this, Toolbar.this.getDisplayName());
        }
        
        @Override
        public void paintComponent (Graphics g) {
            super.paintComponent(g);
            java.awt.Graphics2D g2d = (Graphics2D) g;
            g2d.addRenderingHints(getHints());
            
            int sz = 5;
            
            int y = ((getHeight() / 2) - (sz / 2)) - 2;
            int x = ((getWidth() / 2) - (sz / 2)) - 2;
            
            GradientPaint gradient = new GradientPaint(x+1, y+1, Color.BLACK,
            x+sz-1, y+sz-1, Color.WHITE);
            
            Paint paint = g2d.getPaint();
            
            g2d.setPaint(gradient);
            g2d.drawArc(x,y,sz,sz,0,359);
            
            g.setColor(new Color(240,240,240));
            g.drawLine(x+(sz/2), y + (sz/2),x+(sz/2), y + (sz/2));

            g2d.setPaint(paint);
        }
        
        /** @return minimum size */
        @Override
        public Dimension getMinimumSize () {
            return dim;
        }
        
        /** @return preferred size */
        @Override
        public Dimension getPreferredSize () {
            return this.getMinimumSize ();
        }
        
        @Override
        public Dimension getMaximumSize () {
            return max;
        }
    }    

    private static java.util.Map<RenderingHints.Key, Object> hintsMap = null;
    @SuppressWarnings("unchecked")
    static final Map getHints() {
        //XXX We REALLY need to put this in a graphics utils lib
        if (hintsMap == null) {
            //Thanks to Phil Race for making this possible
            hintsMap = (Map<RenderingHints.Key, Object>)(Toolkit.getDefaultToolkit().getDesktopProperty("awt.font.desktophints")); //NOI18N
            if (hintsMap == null) {
                hintsMap = new HashMap<RenderingHints.Key, Object>();
                hintsMap.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            }
        }
        return hintsMap;
    }

    @Override
    public void setUI(javax.swing.plaf.ToolBarUI ui) {
        super.setUI(ui);
        if( null != backingFolder && null != processor ) {

        }
    }
    
    private final class ToolbarXP extends JPanel {
        /** Width of grip */
        static final int WIDTH = 7;
        /** Minimum size. */
        Dimension dim;
        /** Maximum size. */
        Dimension max;
        
    /** DnDListener is Drag and Drop listener for Toolbar motion events.
     * @deprecated There is no public support for toolbar drag and drop.
            dim = new Dimension (WIDTH, WIDTH);
            max = new Dimension (WIDTH, Integer.MAX_VALUE);
            Toolbar.setToolTipText (this, Toolbar.this.getDisplayName());
        }
        
        @Override
        public void paintComponent (Graphics g) {
            super.paintComponent(g);
            int x = 3;
            for (int i=4; i < getHeight()-4; i+=4) {
                //first draw the rectangular highlight below each dot
                g.setColor(UIManager.getColor("controlLtHighlight")); //NOI18N
                g.fillRect(x + 1, i + 1, 2, 2);
                //Get the shadow color.  We'll paint the darkest dot first,
                //and work our way to the lightest
                Color col = UIManager.getColor("controlShadow"); //NOI18N
                g.setColor(col);
                //draw the darkest dot
                g.drawLine(x+1, i+1, x+1, i+1);
                
                //Get the color components and calculate the amount each component
                //should increase per dot
                int red = col.getRed();
                int green = col.getGreen();
                int blue = col.getBlue();
                
                //Get the default component background - we start with the dark
                //color, and for each dot, add a percentage of the difference
                //between this and the background color
                Color back = getBackground();
                int rb = back.getRed();
                int gb = back.getGreen();
                int bb = back.getBlue();
                
                //Get the amount to increment each component for each dot
                int incr = (rb - red) / 5;
                int incg = (gb - green) / 5;
                int incb = (bb - blue) / 5;
                
                //Increment the colors
                red += incr;
                green += incg;
                blue += incb;
                //Create a slightly lighter color and draw the dot
                col = new Color(red, green, blue);
                g.setColor(col);
                g.drawLine(x+1, i, x+1, i);
                
                //And do it for the next dot, and so on, for all four dots
                red += incr;
                green += incg;
                blue += incb;
                col = new Color(red, green, blue);
                g.setColor(col);
                g.drawLine(x, i+1, x, i+1);
                
                red += incr;
                green += incg;
                blue += incb;
                col = new Color(red, green, blue);
                g.setColor(col);
                g.drawLine(x, i, x, i);
            }
        }
        
        /** @return minimum size */
        @Override
        public Dimension getMinimumSize() {
            return dim;
        }
        
        /** @return preferred size */
        @Override
        public Dimension getPreferredSize () {
            return this.getMinimumSize ();
        }
        
        @Override
        public Dimension getMaximumSize () {
            return max;
        }
    }
    
  /*
    public static void main(String[] args) {
        JFrame jf = new JFrame();
        jf.getContentPane().add (new ToolbarXP());
        jf.setSize(new java.awt.Dimension(200,200));
        jf.setLocation(20,20);
        jf.show();
    }
   */
    public interface DnDListener extends EventListener {
    
    /** Grip for floatable toolbar, used for Windows Classic L&F */
    private final class ToolbarGrip extends JPanel {
        /** Horizontal gaps. */
        static final int HGAP = 1;
        /** Vertical gaps. */
        static final int VGAP = 2;
        /** Step between two grip elements. */
        static final int STEP = 1;
        /** Width of grip element. */
        static final int WIDTH = 2;

        /** Number of grip elements. */
        int columns;
        /** Minimum size. */
        Dimension dim;
        /** Maximum size. */
        Dimension max;

        static final long serialVersionUID =-8819972936203315276L;

        /** Create new ToolbarGrip for default number of grip elements. */
        public ToolbarGrip () {
            this(1);
        }

        /** Create new ToolbarGrip for specific number of grip elements.
         * @param col number of grip elements
         */
        public ToolbarGrip (int col) {
            super ();
            columns = col;
            int width = (col - 1) * STEP + col * WIDTH + 2 * HGAP;
            dim = new Dimension (width, width);
            max = new Dimension (width, Integer.MAX_VALUE);
            this.setBorder (new EmptyBorder (VGAP, HGAP, VGAP, HGAP));
            Toolbar.setToolTipText (this, Toolbar.this.getDisplayName());
        }

        /** Paint grip to specific Graphics. */
        @Override
        public void paint (Graphics g) {
            Dimension size = this.getSize();
            int top = VGAP;
            int bottom = size.height - 1 - VGAP;
            int height = bottom - top;
            g.setColor ( this.getBackground() );

            for (int i = 0, x = HGAP; i < columns; i++, x += WIDTH + STEP) {
                g.draw3DRect (x, top, WIDTH, height, true); // grip element is 3D rectangle now
            }

        }

        /** @return minimum size */
        @Override
        public Dimension getMinimumSize () {
            return dim;
        }

        /** @return preferred size */
        @Override
        public Dimension getPreferredSize () {
            return this.getMinimumSize();
        }
        
        @Override
        public Dimension getMaximumSize () {
            return max;
        }
        
    } // end of inner class ToolbarGrip

    /** DnDListener is Drag and Drop listener for Toolbar motion events. */
    public interface DnDListener extends java.util.EventListener {
        /** Invoced when toolbar is dragged. */
        public void dragToolbar (DnDEvent e);


    } // end of interface DnDListener


    /** DnDEvent is Toolbar's drag and drop event. 
     * @deprecated
     */
    public static class DnDEvent extends EventObject {
        /** Type of DnDEvent. Dragging with only one Toolbar. */
        public static final int DND_ONE  = 1;

            Icon retValue = super.getIcon();
            if( null == retValue && (null == getText() || getText().length() == 0 ) ) {
                if (unknownIcon == null) {
                    unknownIcon = new ImageIcon( ImageUtilities.loadImage( "org/openide/loaders/unknown.gif") ); //NOI18N
                }
                retValue = unknownIcon;
            }

        }
    }

    private DnDSupport getDnd() {
        if (dnd == null) {
            dnd = new DnDSupport();
        }
        return dnd;
    }
} // end of class Toolbar

Lines 42-60 Link Here

(-)ToolbarPool.java (-140 / +66 lines)
42	package org.openide.awt;	42	package org.openide.awt;
43		43
44		44
45	import java.awt.*;	45	import java.awt.BorderLayout;
46	import java.awt.event.*;	46	import java.awt.Component;
		47	import java.awt.FlowLayout;
		48	import java.awt.event.ActionEvent;
		49	import java.awt.event.ActionListener;
		50	import java.awt.event.MouseEvent;
47	import java.io.IOException;	51	import java.io.IOException;
48	import java.util.*;
49	import java.util.ArrayList;	52	import java.util.ArrayList;
50	import javax.accessibility.*;	53	import java.util.Collections;
51	import javax.swing.*;	54	import java.util.Map;
		55	import java.util.TreeMap;
		56	import java.util.WeakHashMap;
		57	import java.util.logging.Level;
		58	import java.util.logging.Logger;
		59	import javax.accessibility.Accessible;
		60	import javax.accessibility.AccessibleContext;
		61	import javax.accessibility.AccessibleRole;
		62	import javax.swing.ButtonGroup;
		63	import javax.swing.JComponent;
52	import javax.swing.JComponent.AccessibleJComponent;	64	import javax.swing.JComponent.AccessibleJComponent;
53	import javax.swing.border.Border;	65	import javax.swing.JPanel;
		66	import javax.swing.JPopupMenu;
		67	import javax.swing.JRadioButtonMenuItem;
54	import org.openide.cookies.InstanceCookie;	68	import org.openide.cookies.InstanceCookie;
55	import org.openide.filesystems.*;	69	import org.openide.filesystems.FileObject;
56	import org.openide.loaders.*;	70	import org.openide.filesystems.FileUtil;
57	import org.openide.util.*;	71	import org.openide.filesystems.Repository;
		72	import org.openide.loaders.DataFolder;
		73	import org.openide.loaders.FolderInstance;
		74	import org.openide.util.Task;
		75	import org.openide.util.TaskListener;
58		76
59	/**	77	/**
60	* This class keeps track of the current toolbars and their names.	78	* This class keeps track of the current toolbars and their names.
Lines 107-115 Link Here
107	try {	125	try {
108	fo = FileUtil.createFolder(root, "Toolbars"); // NOI18N	126	fo = FileUtil.createFolder(root, "Toolbars"); // NOI18N
109	} catch (IOException ex) {	127	} catch (IOException ex) {
110	Exceptions.printStackTrace(ex);	128	Logger.getLogger(ToolbarPool.class.getName()).log(Level.CONFIG, "Cannot create Toolbars folder.", ex);
111	}	129	}
112	if (fo == null) throw new IllegalStateException("No Toolbars/"); // NOI18N	130	if (fo == null)
		131	throw new IllegalStateException("No Toolbars/"); // NOI18N
113	DataFolder folder = DataFolder.findFolder(fo);	132	DataFolder folder = DataFolder.findFolder(fo);
114	defaultPool = new ToolbarPool(folder);	133	defaultPool = new ToolbarPool(folder);
115	// we mustn't do this in constructor to prevent from	134	// we mustn't do this in constructor to prevent from
Lines 142-166 Link Here
142		161
143	getAccessibleContext().setAccessibleName(instance.instanceName());	162	getAccessibleContext().setAccessibleName(instance.instanceName());
144	getAccessibleContext().setAccessibleDescription(instance.instanceName());	163	getAccessibleContext().setAccessibleDescription(instance.instanceName());
145
146	if ("Windows".equals(UIManager.getLookAndFeel().getID())) {
147	if( isXPTheme() ) {
148	//Set up custom borders for XP
149	setBorder(BorderFactory.createCompoundBorder(
150	upperBorder,
151	BorderFactory.createCompoundBorder(
152	BorderFactory.createMatteBorder(0, 0, 1, 0,
153	fetchColor("controlShadow", Color.DARK_GRAY)),
154	BorderFactory.createMatteBorder(0, 0, 1, 0, mid))
155	)); //NOI18N
156	} else {
157	setBorder( BorderFactory.createEtchedBorder() );
158	}	164	}
159	} else if ("GTK".equals(UIManager.getLookAndFeel().getID())) {
160	//No border
161	setBorder (BorderFactory.createEmptyBorder(0, 0, 0, 0));
162	}
163	}
164		165
165	/**	166	/**
166	* Gets preferred size of icons used by toolbar buttons. Default icon size	167	* Gets preferred size of icons used by toolbar buttons. Default icon size
Lines 185-245 Link Here
185	this.preferredIconSize = preferredIconSize;	186	this.preferredIconSize = preferredIconSize;
186	}	187	}
187		188
188	public Border getBorder() {
189	//Issue 36867, hide border if there are no toolbars. Not the most
190	//performant way to do it; if it has a measurable impact, can be
191	//improved
192	if (center != null && center instanceof Container &&
193	((Container)center).getComponentCount() > 0) {
194
195	boolean show = false;
196	for (int i=0; i < ((Container)center).getComponentCount(); i++) {
197	Component c = ((Container)center).getComponent(i);
198	if (c.isVisible()) {
199	show = true;
200	break;
201	}
202	}
203	if (show) {
204	return super.getBorder();
205	}
206	}
207	return lowerBorder;
208	}
209
210	private static Color fetchColor (String key, Color fallback) {
211	//Fix ExceptionInInitializerError from MainWindow on GTK L&F - use
212	//fallback colors
213	Color result = (Color) UIManager.get(key);
214	if (result == null) {
215	result = fallback;
216	}
217	return result;
218	}
219
220	private static Color mid;
221	static {
222	Color lo = fetchColor("controlShadow", Color.DARK_GRAY); //NOI18N
223	Color hi = fetchColor("control", Color.GRAY); //NOI18N
224
225	int r = (lo.getRed() + hi.getRed()) / 2;
226	int g = (lo.getGreen() + hi.getGreen()) / 2;
227	int b = (lo.getBlue() + hi.getBlue()) / 2;
228	mid = new Color(r, g, b);
229	}
230
231	private static final Border lowerBorder = BorderFactory.createCompoundBorder(
232	BorderFactory.createMatteBorder(0, 0, 1, 0,
233	fetchColor("controlShadow", Color.DARK_GRAY)),
234	BorderFactory.createMatteBorder(0, 0, 1, 0, mid)); //NOI18N
235
236	private static final Border upperBorder = BorderFactory.createCompoundBorder(
237	BorderFactory.createMatteBorder(1, 0, 0, 0,
238	fetchColor("controlShadow", Color.DARK_GRAY)),
239	BorderFactory.createMatteBorder(1, 0, 0, 0,
240	fetchColor("controlLtHighlight", Color.WHITE))); //NOI18N
241
242
243	/** Allows to wait till the content of the pool is initialized. */	189	/** Allows to wait till the content of the pool is initialized. */
244	public final void waitFinished () {	190	public final void waitFinished () {
245	instance.instanceFinished ();	191	instance.instanceFinished ();
Lines 262-276 Link Here
262		208
263	/** Updates the default configuration. */	209	/** Updates the default configuration. */
264	private synchronized void updateDefault () {	210	private synchronized void updateDefault () {
265	Toolbar[] toolbars = getToolbars ();	211	Toolbar[] bars = getToolbars ();
266	name = ""; // NOI18N	212	name = ""; // NOI18N
267		213
268	if (toolbars.length == 1) {	214	if (bars.length == 1) {
269	revalidate(toolbars[0]);	215	revalidate(bars[0]);
270	} else {	216	} else {
271	JPanel tp = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));	217	JPanel tp = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));
272	for (int i = 0; i < toolbars.length; i++) {	218	for (int i = 0; i < bars.length; i++) {
273	tp.add(toolbars[i]);	219	tp.add(bars[i]);
274	}	220	}
275	revalidate(tp);	221	revalidate(tp);
276	}	222	}
Lines 285-291 Link Here
285	revalidate (comp);	231	revalidate (comp);
286	}	232	}
287		233
288	/** Sets DnDListener to all Toolbars. */	234	/** Sets DnDListener to all Toolbars.
		235	* @deprecated
		236	*/
289	public void setToolbarsListener (Toolbar.DnDListener l) {	237	public void setToolbarsListener (Toolbar.DnDListener l) {
290	for (Toolbar t: toolbars.values()) {	238	for (Toolbar t: toolbars.values()) {
291	t.setDnDListener (l);	239	t.setDnDListener (l);
Lines 302-312 Link Here
302	}	250	}
303	add (center = c, BorderLayout.CENTER);	251	add (center = c, BorderLayout.CENTER);
304	center.addMouseListener (listener);	252	center.addMouseListener (listener);
305
306	// java.awt.Window w = javax.swing.SwingUtilities.windowForComponent (this);
307	// if (w != null) {
308	// w.validate();
309	// }
310	}	253	}
311	}	254	}
312		255
Lines 366-372 Link Here
366	activate (config);	309	activate (config);
367	}	310	}
368		311
369	firePropertyChange("configuration", old, name);	312	firePropertyChange("configuration", old, name); //NOI18N
370	}	313	}
371		314
372	/**	315	/**
Lines 402-410 Link Here
402	/** Read accessible context	345	/** Read accessible context
403	* @return - accessible context	346	* @return - accessible context
404	*/	347	*/
		348	@Override
405	public AccessibleContext getAccessibleContext () {	349	public AccessibleContext getAccessibleContext () {
406	if(toolbarAccessibleContext == null) {	350	if(toolbarAccessibleContext == null) {
407	toolbarAccessibleContext = new AccessibleJComponent() {	351	toolbarAccessibleContext = new AccessibleJComponent() {
		352	@Override
408	public AccessibleRole getAccessibleRole() {	353	public AccessibleRole getAccessibleRole() {
409	return AccessibleRole.TOOL_BAR;	354	return AccessibleRole.TOOL_BAR;
410	}	355	}
Lines 413-440 Link Here
413	return toolbarAccessibleContext;	358	return toolbarAccessibleContext;
414	}	359	}
415		360
416	/** Recognizes if XP theme is set.
417	* (copy & paste from org.openide.awt.Toolbar to avoid API changes)
418	* @return true if XP theme is set, false otherwise
419	*/
420	private static Boolean isXP = null;
421	private static boolean isXPTheme () {
422	if (isXP == null) {
423	Boolean xp = (Boolean)Toolkit.getDefaultToolkit().
424	getDesktopProperty("win.xpstyle.themeActive"); //NOI18N
425	isXP = Boolean.TRUE.equals(xp)? Boolean.TRUE : Boolean.FALSE;
426	}
427	return isXP.booleanValue();
428	}
429
430	/**	361	/**
431	* @return True if the Toolbar Customizer is visible and toolbar buttons can be dragged.
432	*/
433	boolean isInEditMode() {
434	return null != getClientProperty( "editMode" );
435	}
436
437	/**
438	* This class is used for delayed setting of configuration after instance	362	* This class is used for delayed setting of configuration after instance
439	* creation is finished. It may happen during IDE start that	363	* creation is finished. It may happen during IDE start that
440	* ToolbarPool.setConfiguration is called before instance is created.	364	* ToolbarPool.setConfiguration is called before instance is created.
Lines 473-478 Link Here
473	* Full name of the data folder's primary file separated by dots.	397	* Full name of the data folder's primary file separated by dots.
474	* @return the name	398	* @return the name
475	*/	399	*/
		400	@Override
476	public String instanceName () {	401	public String instanceName () {
477	return instanceClass().getName();	402	return instanceClass().getName();
478	}	403	}
Lines 481-486 Link Here
481	* Returns the root class of all objects.	406	* Returns the root class of all objects.
482	* @return Object.class	407	* @return Object.class
483	*/	408	*/
		409	@Override
484	public Class instanceClass () {	410	public Class instanceClass () {
485	return ToolbarPool.class;	411	return ToolbarPool.class;
486	}	412	}
Lines 490-497 Link Here
490	* @param cookie the instance cookie to test	416	* @param cookie the instance cookie to test
491	* @return true if the cookie can provide <code>Configuration</code>	417	* @return true if the cookie can provide <code>Configuration</code>
492	*/	418	*/
		419	@Override
493	protected InstanceCookie acceptCookie (InstanceCookie cookie)	420	protected InstanceCookie acceptCookie (InstanceCookie cookie)
494	throws java.io.IOException, ClassNotFoundException {	421	throws java.io.IOException, ClassNotFoundException {
		422
495	Class cls = cookie.instanceClass();	423	Class cls = cookie.instanceClass();
496	if (ToolbarPool.Configuration.class.isAssignableFrom (cls)) {	424	if (ToolbarPool.Configuration.class.isAssignableFrom (cls)) {
497	return cookie;	425	return cookie;
Lines 508-517 Link Here
508	* @param df a <code>DataFolder</code> to create the cookie for	436	* @param df a <code>DataFolder</code> to create the cookie for
509	* @return a <code>Toolbar.Folder</code> for the specified folder	437	* @return a <code>Toolbar.Folder</code> for the specified folder
510	*/	438	*/
		439	@Override
511	protected InstanceCookie acceptFolder (DataFolder df) {	440	protected InstanceCookie acceptFolder (DataFolder df) {
512	InstanceCookie ic = foldersCache.get (df);	441	InstanceCookie ic = foldersCache.get (df);
513	if (ic == null) {	442	if (ic == null) {
514	ic = (FolderInstance)new Toolbar (df, true).waitFinished ();	443	ic = (FolderInstance) new Toolbar(df).waitFinished ();
515	foldersCache.put (df, ic);	444	foldersCache.put (df, ic);
516	}	445	}
517	return ic;	446	return ic;
Lines 533-542 Link Here
533		462
534	for (int i = 0; i < length; i++) {	463	for (int i = 0; i < length; i++) {
535	try {	464	try {
536	java.lang.Object obj = cookies[i].instanceCreate();	465	Object obj = cookies[i].instanceCreate();
537		466
538	if (obj instanceof org.openide.awt.Toolbar) {	467	if (obj instanceof Toolbar) {
539	org.openide.awt.Toolbar toolbar = (org.openide.awt.Toolbar) obj;	468	Toolbar toolbar = (Toolbar) obj;
540		469
541	// should be done by ToolbarPanel in add method	470	// should be done by ToolbarPanel in add method
542	toolbar.removeMouseListener(listener);	471	toolbar.removeMouseListener(listener);
Lines 545-552 Link Here
545	toolbarNames.add(toolbar.getName());	474	toolbarNames.add(toolbar.getName());
546	continue;	475	continue;
547	}	476	}
548	if (obj instanceof org.openide.awt.ToolbarPool.Configuration) {	477	if (obj instanceof ToolbarPool.Configuration) {
549	org.openide.awt.ToolbarPool.Configuration config = (org.openide.awt.ToolbarPool.Configuration) obj;	478	ToolbarPool.Configuration config = (ToolbarPool.Configuration) obj;
550	java.lang.String name = config.getName();	479	java.lang.String name = config.getName();
551		480
552	if (name == null) {	481	if (name == null) {
Lines 555-579 Link Here
555	conf.put(name, config);	484	conf.put(name, config);
556	continue;	485	continue;
557	}	486	}
558	if (obj instanceof java.awt.Component) {	487	if (obj instanceof Component) {
559	java.awt.Component comp = (java.awt.Component) obj;	488	Component comp = (Component) obj;
560	java.lang.String name = comp.getName();	489	String name = comp.getName();
561		490
562	if (name == null) {	491	if (name == null) {
563	name = cookies[i].instanceName();	492	name = cookies[i].instanceName();
564	}	493	}
565	conf.put(name,	494	conf.put(name, new ToolbarPool.ComponentConfiguration(comp));
566	new org.openide.awt.ToolbarPool.ComponentConfiguration(comp));
567	continue;	495	continue;
568	}	496	}
		497	} catch (IOException ex) {
		498	Logger.getLogger(ToolbarPool.class.getName()).log(Level.INFO, "Error while creating toolbars.", ex);
		499	} catch (ClassNotFoundException ex) {
		500	Logger.getLogger(ToolbarPool.class.getName()).log(Level.INFO, "Error while creating toolbars.", ex);
569	}	501	}
570	catch (java.io.IOException ex) {
571	Exceptions.printStackTrace(ex);
572	}	502	}
573	catch (java.lang.ClassNotFoundException ex) {
574	Exceptions.printStackTrace(ex);
575	}
576	}
577	update (toolbars, conf, toolbarNames);	503	update (toolbars, conf, toolbarNames);
578		504
579	return ToolbarPool.this;	505	return ToolbarPool.this;
Lines 581-586 Link Here
581		507
582	/** Recreate the instance in AWT thread.	508	/** Recreate the instance in AWT thread.
583	*/	509	*/
		510	@Override
584	protected Task postCreationTask (Runnable run) {	511	protected Task postCreationTask (Runnable run) {
585	return new AWTTask (run);	512	return new AWTTask (run);
586	}	513	}
Lines 635-643 Link Here
635	* component */	562	* component */
636	private static final class ComponentConfiguration extends JPopupMenu	563	private static final class ComponentConfiguration extends JPopupMenu
637	implements Configuration, ActionListener {	564	implements Configuration, ActionListener {
		565
638	private Component comp;	566	private Component comp;
639		567
640	ComponentConfiguration() {}	568	ComponentConfiguration() {
		569	}
641		570
642	static final long serialVersionUID =-409474484612485719L;	571	static final long serialVersionUID =-409474484612485719L;
643	/** @param comp component that represents this configuration */	572	/** @param comp component that represents this configuration */
Lines 652-657 Link Here
652		581
653	/** @return name of the component	582	/** @return name of the component
654	*/	583	*/
		584	@Override
655	public String getName () {	585	public String getName () {
656	return comp.getName ();	586	return comp.getName ();
657	}	587	}
Lines 662-672 Link Here
662	removeAll ();	592	removeAll ();
663		593
664	// generate list of available toolbar panels	594	// generate list of available toolbar panels
665	Iterator it = Arrays.asList (ToolbarPool.getDefault ().getConfigurations ()).iterator ();
666	ButtonGroup bg = new ButtonGroup ();	595	ButtonGroup bg = new ButtonGroup ();
667	String current = ToolbarPool.getDefault ().getConfiguration ();	596	String current = ToolbarPool.getDefault ().getConfiguration ();
668	while (it.hasNext()) {	597	for( String name : ToolbarPool.getDefault().getConfigurations() ) {
669	final String name = (String)it.next ();
670	JRadioButtonMenuItem mi = new JRadioButtonMenuItem (name, (name.compareTo (current) == 0));	598	JRadioButtonMenuItem mi = new JRadioButtonMenuItem (name, (name.compareTo (current) == 0));
671	mi.addActionListener (this);	599	mi.addActionListener (this);
672	bg.add (mi);	600	bg.add (mi);
Lines 681-688 Link Here
681	public void actionPerformed (ActionEvent evt) {	609	public void actionPerformed (ActionEvent evt) {
682	ToolbarPool.getDefault().setConfiguration (evt.getActionCommand ());	610	ToolbarPool.getDefault().setConfiguration (evt.getActionCommand ());
683	}	611	}
684
685	}	612	}
686
687	} // end of ToolbarPool	613	} // end of ToolbarPool
688		614

Return to bug 153835