source: trunk/src/org/expeditee/items/widgets/SwingWidget.java@ 1511

package org.expeditee.items.widgets;

import java.awt.Component;
import java.awt.Container;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ContainerEvent;
import java.awt.event.ContainerListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

import javax.swing.JComponent;

import org.expeditee.core.bounds.AxisAlignedBoxBounds;
import org.expeditee.gio.EcosystemManager;
import org.expeditee.gio.EcosystemManager.Ecosystem;
import org.expeditee.gio.swing.SwingGraphicsManager;
import org.expeditee.gio.swing.SwingMiscManager;
import org.expeditee.gui.DisplayController;
import org.expeditee.items.ItemParentStateChangedEvent;
import org.expeditee.items.Text;
import org.expeditee.items.UserAppliedPermission;

public abstract class SwingWidget extends Widget implements ContainerListener, KeyListener
{
        // A flag for signifying whether the swing components are ready to paint.
        // If the swing components has not been layed out, if they are painted they
        // will not draw in the correct positions.
        // Also for setting AWT and Swing -Related drawing options after
        // construction
        private boolean _isReadyToPaint = false;

        protected JComponent _swingComponent;
                
        protected SwingWidget(Text source, JComponent component, int minWidth, int maxWidth, int minHeight, int maxHeight)
        {
                super(source, minWidth, maxWidth, minHeight, maxHeight);

                if (component == null) {
                        throw new NullPointerException("component");
                }
                                
                _swingComponent = component;
                _swingComponent.setFocusable(true);
                addKeyListenerToWidget();
                addThisAsContainerListenerToContent();
                onBoundsChanged();
                
                System.err.println("SwingWidget::Suppressed static setDefaultLightWeightPopupEnabled to false.");
                //JPopupMenu.setDefaultLightWeightPopupEnabled(false);
        }

        public JComponent getComponent()
        {
                return _swingComponent;
        }
        
        @Override
    public void keyTyped(KeyEvent e) {
                
                int keyCode = e.getKeyCode();
        
        if (keyCode >= KeyEvent.VK_F1 && keyCode <= KeyEvent.VK_F12) {
                //((SwingInputManager) EcosystemManager.getInputManager()).keyTyped(e);
        }
    }

        @Override
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();
                
        if (keyCode >= KeyEvent.VK_F1 && keyCode <= KeyEvent.VK_F12) {
                //((SwingInputManager) EcosystemManager.getInputManager()).keyTyped(e);
        }
    }
    
        @Override
    public void keyReleased(KeyEvent e) {
                int keyCode = e.getKeyCode();
        
        if (keyCode >= KeyEvent.VK_F1 && keyCode <= KeyEvent.VK_F12) {
                //((SwingInputManager) EcosystemManager.getInputManager()).keyTyped(e);
        }
    }
        
        /**
         * Makes sure we add our KeyListener to every child component,
         * since it seems that's the only way to make sure we capture key events in Java
         * (without using KeyBindings which seem to only support the keyTyped event)
         */
        @Override
        public void componentAdded(ContainerEvent e) {
                if(e == null || e.getChild() == null) {
                        return;
                }
                keyListenerToChildren(e.getChild(), true);
        }
        
        @Override
        public void componentRemoved(ContainerEvent e) {
                if(e == null || e.getChild() == null) {
                        return;
                }
                keyListenerToChildren(e.getChild(), false);
        }
        
        @Override
        protected void addWidgetContent(final ItemParentStateChangedEvent e) {
                if ((e.getEventType() == ItemParentStateChangedEvent.EVENT_TYPE_ADDED_VIA_OVERLAY || e
                                .getEventType() == ItemParentStateChangedEvent.EVENT_TYPE_SHOWN_VIA_OVERLAY)
                                && e.getOverlayLevel().equals(UserAppliedPermission.none)) {
                        return; // item belongs to a non-active overlay
                }
                
                if(_swingComponent.getParent() == null) {
                        if (e.getEventType() == ItemParentStateChangedEvent.EVENT_TYPE_SHOWN
                                        || e.getEventType() == ItemParentStateChangedEvent.EVENT_TYPE_SHOWN_VIA_OVERLAY
                                        || e.getSource() == DisplayController.getCurrentFrame()) {
                                onBoundsChanged();
                                ((SwingGraphicsManager) EcosystemManager.getGraphicsManager()).getContentPane().add(_swingComponent);
                                layout(_swingComponent);
                        }
                }
        }
        
        @Override
        protected void addKeyListenerToWidget() {
                keyListenerToChildren(_swingComponent, true);
        }
        
        @Override
        protected void addThisAsContainerListenerToContent() {
                _swingComponent.addContainerListener(this);
        }
        
        @Override
        public AxisAlignedBoxBounds getContentBounds() {
                //final Rectangle bounds = _swingComponent.getBounds();
                //final AccessibleContext accessibleContext = _swingComponent.getAccessibleContext();
                //if (accessibleContext != null) {
                //      final Rectangle accessibleBounds = _swingComponent.getAccessibleContext().getAccessibleComponent().getBounds();
                //      return new AxisAlignedBoxBounds(bounds.x, bounds.y, bounds.width, bounds.height + accessibleBounds.height);
                //} else {
                //      return new AxisAlignedBoxBounds(bounds.x, bounds.y, bounds.width, bounds.height);
                //}             
                final Rectangle bounds = _swingComponent.getBounds();
                return new AxisAlignedBoxBounds(bounds.x, bounds.y, bounds.width, bounds.height);
        }
        
        @Override
        protected void layout() {
                layout(_swingComponent);
        }
        
        private void keyListenerToChildren(Component parent, boolean add) {
                List<Component> components = new LinkedList<Component>();
                components.add(parent);
                while(!components.isEmpty()) {
                        Component c = components.remove(0);
                        if(c instanceof Container) {
                                components.addAll(Arrays.asList(((Container)c).getComponents()));
                        }
                        if(add && !Arrays.asList(c.getKeyListeners()).contains(this)) {
                                c.addKeyListener(this);
                        } else if (!add && Arrays.asList(c.getKeyListeners()).contains(this)) {
                                c.removeKeyListener(this);
                }
                }
        }
        
        @Override
        protected void onMoved()
        {
                // Do nothing
        }
        
        @Override
        protected void onSizeChanged()
        {
        onBoundsChanged();
        layout(_swingComponent);
        }

        @Override
        public final void onBoundsChanged()
        {
                if (_swingComponent == null) {
                        return;
                }
                
                if (isFixedSize()) {
                        _swingComponent.setBounds(getX(), getY(), getMaxWidth(), getMaxHeight());
                } else {
                        _swingComponent.setBounds(getX(), getY(), getWidth(), getHeight());
                }
        }

        private void prepareToPaint()
        {
                _isReadyToPaint = true;
                layout(_swingComponent);
                ignoreAWTPainting(_swingComponent);
        }

        private void ignoreAWTPainting(Component c)
        {
                if (c == null) {
                        return;
                }
                
                if (c instanceof JComponent) {
                        ((JComponent) c).setDoubleBuffered(false);
                }
                c.setIgnoreRepaint(true);
                
                if (c instanceof Container) {
                        for (Component child : ((Container) c).getComponents()) {
                                if(child instanceof Container) {
                                        ignoreAWTPainting(child);
                                } else {
                                        if(child instanceof JComponent) {
                                                ((JComponent) child).setDoubleBuffered(false);
                                        }
                                        child.setIgnoreRepaint(true);
                                }
                        }
                }
        }

        /**
         * Due to absolute positioning...
         * 
         * @param parent
         */
        private void layout(Component parent)
        {
                if (parent == null) {
                        return;
                }
                
                parent.validate();

                if (parent instanceof Container) {
                        for (Component child : ((Container) parent).getComponents()) {
                                layout(child);
                        }
                } 
        }

        @Override
        protected final void paintWidget()
        {
                if (!_isReadyToPaint) {
                        prepareToPaint();
                }

                Graphics2D g = SwingMiscManager.getIfUsingSwingGraphicsManager().getCurrentSurface();
                
                paintSwingWidget(g);
        }
        
        /** Can be overridden to enable custom painting of widgets. */
        protected void paintSwingWidget(Graphics2D g)
        {
                final Point location = _swingComponent.getLocation();
                int x = location.x;
                int y = location.y;
                g.translate(x, y);
                _swingComponent.paint(g);
                g.translate(-x, -y);
        }
        
        @Override
        public boolean isSupportedOnEcosystem(Ecosystem type)
        {
                return type == Ecosystem.Swing;
        }
}