package ilist.ui.generic;
 
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.event.FocusEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;
 
import javax.swing.JComponent;
 
import org.jdesktop.jxlayer.JXLayer;
import org.jdesktop.jxlayer.plaf.AbstractLayerUI;
 
public class CompoundLayerUI<V extends JComponent> extends AbstractLayerUI<V> {
	
	private AbstractLayerUI<V> layer1;
	private AbstractLayerUI<V> layer2;
	
	
	public CompoundLayerUI(AbstractLayerUI<V> layer1, AbstractLayerUI<V> layer2) {
		super();
		this.layer1 = layer1;
		this.layer1.setCompoundLayer(this);
		this.layer2 = layer2;
		this.layer2.setCompoundLayer(this);
	}
 
 
	@Override
	protected void paintLayer(Graphics2D g, JXLayer<V> l) {
		super.paintLayer(g, l);
		this.layer1.paintLayer(g, l);
		this.layer2.paintLayer(g, l);
	}
 
	@Override
	protected void processFocusEvent(FocusEvent e, JXLayer<V> l) {
		super.processFocusEvent(e, l);
		this.layer1.eventDispatched(e, l);
		this.layer2.eventDispatched(e, l);
	}
 
	@Override
	protected void processKeyEvent(KeyEvent e, JXLayer<V> l) {
		super.processKeyEvent(e, l);
		this.layer1.eventDispatched(e, l);
		this.layer2.eventDispatched(e, l);
	}
 
	@Override
	protected void processMouseEvent(MouseEvent e, JXLayer<V> l) {
		super.processMouseEvent(e, l);
		this.layer1.eventDispatched(e, l);
		this.layer2.eventDispatched(e, l);
	}
 
	@Override
	protected void processMouseMotionEvent(MouseEvent e, JXLayer<V> l) {
		super.processMouseMotionEvent(e, l);
		this.layer1.eventDispatched(e, l);
		this.layer2.eventDispatched(e, l);
	}
 
	@Override
	protected void processMouseWheelEvent(MouseWheelEvent e, JXLayer<V> l) {
		super.processMouseWheelEvent(e, l);
		this.layer1.eventDispatched(e, l);
		this.layer2.eventDispatched(e, l);
	}
	
	@Override
	public Dimension getPreferredScrollableViewportSize(JXLayer<V> l) {
		return layer1.getPreferredScrollableViewportSize(l);
	}
 
	@Override
	public int getScrollableBlockIncrement(JXLayer<V> l, Rectangle r, int orientation, int direction) {
		return layer1.getScrollableBlockIncrement(l, r, orientation, direction);
	}
 
	@Override
	public boolean getScrollableTracksViewportHeight(JXLayer<V> l) {
		return layer1.getScrollableTracksViewportHeight(l);
	}
 
	@Override
	public boolean getScrollableTracksViewportWidth(JXLayer<V> l) {
		return layer1.getScrollableTracksViewportWidth(l);
	}
 
	@Override
	public int getScrollableUnitIncrement(JXLayer<V> l, Rectangle r,int orientation, int direction) {
		return layer1.getScrollableUnitIncrement(l, r, orientation, direction);
	}
	
	
	public static class AbstractLayerUI<T extends JComponent> extends org.jdesktop.jxlayer.plaf.AbstractLayerUI<T> {
		
		private CompoundLayerUI compoundLayerUI;
 
		// paintLayer is now public :
		@Override
		public void paintLayer(Graphics2D g, JXLayer<T> l) {
			super.paintLayer(g, l);
		}
		
		protected void setCompoundLayer(CompoundLayerUI compoundLayerUI) {
			this.compoundLayerUI = compoundLayerUI;			
		}
		
		@Override
		protected void setDirty(boolean dirty) {
			super.setDirty(dirty);
			this.compoundLayerUI.setDirty(dirty);
		}
		
	}
 
}

// paintLayer is now public :
@Override
public void paintLayer(Graphics2D g, JXLayer<T> l) {
		super.paintLayer(g, l);
}

// paintLayer is now public :
@Override
public void paintLayer(Graphics2D g, JXLayer<T> l) {}

import java.awt.Graphics2D;
 
import javax.swing.JComponent;
import javax.swing.JList;
 
import org.jdesktop.jxlayer.JXLayer;
import org.jdesktop.jxlayer.plaf.AbstractLayerUI;
 
public class JListLayerUI extends AbstractLayerUI<JComponent> {
 
    @Override
    protected void paintLayer(Graphics2D g2, JXLayer<JComponent> layer) {
	super.paintLayer(g2, layer);
	JComponent view = layer.getView();
	while (!(view instanceof JList)) {
	    if (view instanceof JXLayer) {
		view = ((JXLayer<?>) view).getView();
	    } else if (view == null) {
		break;
	    } else {
		throw new RuntimeException("Unexpected view encountered");
	    }
	}
	if (view != null) {
	    JList list = (JList) view;
	    int selectedIndex = list.getSelectedIndex();
	    // etc.
	}
    }
 
}

import java.awt.AWTEvent;
import java.awt.Graphics;
import java.util.LinkedHashSet;
 
import javax.swing.JComponent;
 
import org.jdesktop.jxlayer.JXLayer;
import org.jdesktop.jxlayer.plaf.AbstractLayerUI;
import org.jdesktop.jxlayer.plaf.LayerUI;
import org.jdesktop.jxlayer.plaf.item.LayerItemChangeEvent;
import org.jdesktop.jxlayer.plaf.item.LayerItemListener;
 
public class MultiLayerUI<V extends JComponent> extends AbstractLayerUI<V> {
 
    private LayerItemListener layerItemListener = new LayerItemListener() {
 
	@SuppressWarnings("unchecked")
	@Override
	public void layerItemChanged(LayerItemChangeEvent event) {
	    /*
	     * Getting the originating LayerUI. But what to do with it?
	     */
	    @SuppressWarnings("unused")
	    LayerUI<V> layerUI = (LayerUI<V>) event.getSource();
	    /*
	     * When a child LayerUI is changed, then this LayerUI is changed as
	     * well.
	     */
	    MultiLayerUI.this.fireLayerItemChanged();
	}
    };
 
    private LinkedHashSet<LayerUI<V>> uis = new LinkedHashSet<LayerUI<V>>();
 
    public void addLayerUI(LayerUI<V> layerUI) {
	layerUI.addLayerItemListener(layerItemListener);
	uis.add(layerUI);
    }
 
    @Override
    public void eventDispatched(AWTEvent e, JXLayer<V> layer) {
	for (LayerUI<V> layerUI : this.getLayerUIs()) {
	    if (layerUI.isEnabled()) {
		layerUI.eventDispatched(e, layer);
	    }
	}
    }
 
    @SuppressWarnings("unchecked")
    public LayerUI<V>[] getLayerUIs() {
	return (LayerUI<V>[]) uis.toArray(new LayerUI<?>[uis.size()]);
    }
 
    @Override
    public void installUI(JComponent c) {
	super.installUI(c);
	for (LayerUI<V> layerUI : this.getLayerUIs()) {
	    layerUI.installUI(c);
	}
    }
 
    @Override
    public void paint(Graphics g, JComponent component) {
	super.paint(g, component);
	for (LayerUI<V> layerUI : this.getLayerUIs()) {
	    if (layerUI.isEnabled()) {
		layerUI.paint(g.create(), component);
	    }
	}
    }
 
    public void removeAllLayerUIs() {
	for (LayerUI<V> layerUI : getLayerUIs()) {
	    removeLayerUI(layerUI);
	}
	uis.clear();
    }
 
    public void removeLayerUI(LayerUI<V> layerUI) {
	layerUI.removeLayerItemListener(layerItemListener);
	uis.remove(layerUI);
    }
 
    @Override
    public void uninstallUI(JComponent c) {
	super.uninstallUI(c);
	for (LayerUI<V> layerUI : this.getLayerUIs()) {
	    layerUI.uninstallUI(c);
	}
    }
 
}