hostcanvas.java

J2ME上的一个播放器,可以更换皮肤.开源软件.

package inline.ui;

import inline.ui.*;
import inline.sys.*;
import java.util.*;
import javax.microedition.lcdui.*;
import inline.ui.ce.CanvasElement;
import inline.ui.ce.InList;
import inline.ui.lo.*;

public class HostCanvas extends Canvas
{
    protected static final int DEFAULT_BACKGROUND_COLOR = 0x000000;
    protected static final int DEFAULT_FOREGROUND_COLOR = -2; // invert
	
    public final static String CANVAS_BACKGROUND = "CanvasBack";
    public final static String CANVAS_MIDDLERAMP = "CanvasMRmp";
    public final static String CANVAS_FOREGROUND = "CanvasFore";
    public final static String CANVAS_ANIMATION = "Animation";
    public final static String CANVAS_FLASHOFF = "FlashOff";
    
    private int BACKGROUND_COLOR;
    private int MIDDLERAMP_COLOR;
    private int FOREGROUND_COLOR;
    
    private Vector elements;
    private Hashtable accelerators;
    private int focus;
    protected InList menu;
    protected CanvasElement menulabel;
    private LayoutManager layman;
    private boolean menu_visible;
    private int menu_key;
    private int tag;
    private boolean backlighinsens;
    protected static Canvas lastvisible;
    
    private boolean shown;
    
    private HostCanvas previous;
    
    public HostCanvas()
    {
        elements = new Vector();
	accelerators = new Hashtable();
	layman = new LayoutManager(); 
        focus = 0;
	shown = false;
	menu = null;
	menu_visible = false;
	tag = 0;
    }

    protected void setMenu(Vector llist)
    {
	setMenu(llist, CanvasElement.MENU_SOFT, Graphics.HCENTER|Graphics.BOTTOM);
    }
    
    protected void setMenu(Vector llist, int mmkey, int anchor)
    {
	menu = new InList(this,0,0,0,0);
	menu.setLines(llist);
	menu.hasBorder(true);
	menu.layout(anchor);
//	menu.setStyleable(true);
	menu_key = mmkey;
	if (menulabel!=null) menulabel.setVisible(true);
    }

    protected void fixColors()
    {
	if (Base.getOption(CANVAS_BACKGROUND)!=null)
	{
	    BACKGROUND_COLOR = Base.getOptionIntDefault(CANVAS_BACKGROUND, DEFAULT_BACKGROUND_COLOR);
	}
	else
	{
	    BACKGROUND_COLOR = DEFAULT_BACKGROUND_COLOR;
	    FOREGROUND_COLOR = BACKGROUND_COLOR ^ 0xffffff;
	    MIDDLERAMP_COLOR = -3;
	}
	
	FOREGROUND_COLOR = Base.getOptionIntDefault(CANVAS_FOREGROUND, -2);
	    
	if (FOREGROUND_COLOR==-2)
	{
	    FOREGROUND_COLOR = BACKGROUND_COLOR ^ 0xffffff;
	}

	MIDDLERAMP_COLOR = Base.getOptionIntDefault(CANVAS_MIDDLERAMP, -3);
    }
    
    // if true then don't process keyPress
    protected boolean keyPreview(int keyCode)
    {
	return false;
    }
    
    protected void addElement(CanvasElement ce)
    {
        elements.addElement(ce);
	int ac = ce.getAccelerator();
	if (ac != 0)
	{
	    accelerators.put(new Integer(ac), ce);
	}
    }
    
    protected void addElement(CanvasElement ce, Panel panel)
    {
        addElement(ce);
	panel.addCanvasElement(ce);
    }

    protected void addElement(CanvasElement ce, Panel panel, int vw, int vh)
    {
        addElement(ce);
	panel.addCanvasElement(ce,vw, vh);
    }

    public void focus(CanvasElement ce)
    {
        focus = elements.indexOf(ce);
    }
    
    public void focusNext()
    {
	boolean cc = true;
	int cecount = elements.size();
        while(cc && (cecount>0))
	{
	    focus++;
	    if (focus>=elements.size())
	    {
		focus = 0;
	    }
	    CanvasElement ce = (CanvasElement)elements.elementAt(focus);
	    cc = !ce.canFocus();
	    cecount--;
	}
	if (cc==false)
	{
	    repaint();
	}
    }

    public void focusPrevious()
    {
	boolean cc = true;
	int cecount = elements.size();
        while(cc && (cecount>0))
	{
            focus--;
	    if (focus<0)
	    {
		focus = elements.size()-1;
	    }
	    CanvasElement ce = (CanvasElement)elements.elementAt(focus);
	    cc = !ce.canFocus();
	    cecount--;
	}
	if (cc==false)
	{
	    repaint();
	}
    }

    public boolean isFocused(CanvasElement ce)
    {
        return focus == elements.indexOf(ce);
    }
    
    protected void prePaint()
    {
	if (!shown) fixColors();
	shown=true;
    }
    
    public void paint(Graphics g) 
    {
	prePaint();
	
        synchronized (g) 
        {
	    boolean clip = (g.getClipWidth() != getWidth() || 
			    g.getClipHeight() != getHeight() || 
			    g.getClipX() != 0 || 
			    g.getClipY() != 0);

            g.setColor(BACKGROUND_COLOR);
            g.fillRect(g.getClipX(), g.getClipY(), g.getClipWidth(), g.getClipHeight());

	    Vector elms = elements;
	    if (clip) elms = findClippingElements(g);
	    
            for(int i = 0;i<elms.size();i++)
            {
		CanvasElement ce = (CanvasElement)elms.elementAt(i);
                if (ce!=null && ce.isVisible())
                {
                    ce.paint(g);
                }
            }
	    
	    if (menu!=null && menu_visible)
	    {
		menu.paint(g);
	    }

/*
g.setColor(0);
g.drawString("TEST",10,10,0);
*/
	
	}
    }

    private Vector findClippingElements(Graphics g)
    {
	Vector elms = new Vector();
	
	for(int i = 0;i<elements.size();i++)
        {
	    CanvasElement ce = (CanvasElement)elements.elementAt(i);
            if (ce!=null)
	    {
		if (g.getClipX()<=ce.getX() &&
		    g.getClipY()<=ce.getY() &&
		    g.getClipX()+g.getClipWidth()>=ce.getX()+ce.getRWidth() &&
		    g.getClipY()+g.getClipHeight()>=ce.getY()+ce.getRHeight())
		{
		    elms.addElement(ce);
		}
	    }
	}
	
	return elms;
    }
    
    public void keyPressed(int keyCode)
    {
	manageBacklight();
	
	if (keyPreview(keyCode))
	{
	    return;
	}
	if (menu!=null && (keyCode == menu_key || 
		(menu_key == CanvasElement.MENU_SOFT && keyCode == '3')))
	{
	    menu_visible = !menu_visible;
	    if (menu_visible) 
	    {
		menu.setSelectedIndex(0);
		menu.startInactivityTimer();
	    }
	    repaint();
	    return;
	}

	if (!menu_visible)
	{
	    if (keyCode == CanvasElement.LEFT_SOFT)
	    {
		focusPrevious();
	    }
	    else if (keyCode == CanvasElement.RIGHT_SOFT)
	    {
		focusNext();
	    }
	}
	else
	{
	    if (keyCode == CanvasElement.LEFT_SOFT
		    || keyCode == CanvasElement.RIGHT_SOFT)
	    {
		menuHide();
	    }
	    else
	    {
		menu.keyPressed(keyCode);
	    }
	    return;
	}
	
	if (elements.size()>0)
	{
	    CanvasElement ce = (CanvasElement)elements.elementAt(focus);
	    if (ce!=null)
	    {
		ce.keyPressed(keyCode);
	    }
	    Object accobj = accelerators.get(new Integer(keyCode));
	    if (accobj != null)
	    {
	        try 
	        {
		    selectPreview(accobj);
		}
	        catch(Exception e)
	        {
/*#Emulator#*///<editor-fold>
//--		    System.err.println(e);
/*$Emulator$*///</editor-fold>
	        }
	    }
	}
    }

    public void keyReleased(int keyCode)
    {
	if (menu_visible)
	{
	    menu.keyReleased(keyCode);
	    return;
	}
	
	if (elements.size()>0)
	{
            CanvasElement ce = (CanvasElement)elements.elementAt(focus);
	    if (ce!=null)
	    {
		ce.keyReleased(keyCode);
	    }
	}
    }
    
    protected void onTimer(int tag, long delta, Object object)
    {
	// deliver timer to canvaselement
	if (object != null && object instanceof CanvasElement)
	{
	    CanvasElement ce = (CanvasElement)object;
	    ce.onTimer(tag, delta);
	}
    }
        
    public Timer newFixedRateTimer(Timer timer, int tag, long delay, long period, Object object)
    {
	killTimer(timer);
	try
        {
	    timer = new Timer();
	    timer.scheduleAtFixedRate(new HostCanvasTimer(this, tag, object), delay, period);
	}
	catch(Exception e)
        {
	    Log.fire(e.toString());
        }
	
	return timer;
    }
    
    public Timer newSingleShotTimer(Timer timer, int tag, long period, Object object)
    {
	killTimer(timer);
	try
        {
	    timer = new Timer();
	    timer.schedule(new HostCanvasTimer(this, tag, object), period);
	}
	catch(Exception e)
        {
	    Log.fire(e.toString());
        }
	
	return timer;
    }

    public Timer killTimer(Timer timer)
    {
	try
        {
	    if (timer != null)
	    {
		timer.cancel();
		timer = null;
	    }
	}
	catch(Exception e)
        {
	    Log.fire(e.toString());
        }
	
	return timer;
    }

    public void selectPreview(Object obj)
    {
	if (obj == menu)
	{
	    menuHide();
	}
    }
    
    protected void menuHide()
    {
    	menu_visible = false;
	repaint();
    }
    
/*    public void callRepaint()
    {
	if (this.isShown()) repaint();
    }

    public void callRepaint(int x, int y, int w, int h)
    {
	if (this.isShown()) repaint(x,y,w,h);
    }

    public void callServiceRepaints()
    {
	if (this.isShown()) serviceRepaints();
    }*/

    public void manageBacklight()
    {
	manageBacklight(0);
    }

    public void manageBacklight(int period)
    {
	if (backlighinsens==false)
	{
	    int dur = 30; // "30 seconds ought be enough for everyone"
	    if (period>0)
	    {
		dur = period;
	    }
	    else
	    {
		dur = Base.getOptionIntDefault(CANVAS_FLASHOFF,dur);
	    }
	    
	    if (dur>0)
	    {
/*#!Emulator#*///<editor-fold>
		Base.flashBacklight(dur * 1000);  
/*$!Emulator$*///</editor-fold>
	    }
	}
    }
   
    public void turnOffBacklight()
    {
	if (backlighinsens==false)
	{
	    int dur = Base.getOptionIntDefault(CANVAS_FLASHOFF, 30);
		
	    if (dur>0)
	    {
/*#!Emulator#*///<editor-fold>
		Base.flashBacklight(1);
/*$!Emulator$*///</editor-fold>
	    }
	}
    }  

    public void setBacklightInsensibility(boolean val)
    {
	backlighinsens = val;
    }
    
    public int getBackgroundColor()  
    {
	return BACKGROUND_COLOR;
    }

    public int getForegroundColor()
    {
	return FOREGROUND_COLOR;  
    }
    
    public int getMiddleRampColor()
    {
	return MIDDLERAMP_COLOR;  
    }
    
    public void setBackgroundColor(int bgc)  
    {
	BACKGROUND_COLOR = bgc;
    }

    public void setForegroundColor(int fgc)
    {
	FOREGROUND_COLOR = fgc;  
    }
    
    public void setMiddleRampColor(int mgc)
    {
	MIDDLERAMP_COLOR = mgc;  
    }

    public void updateColors()
    {
	fixColors();
	
	// payback for local store of colors 
        for(int i = 0;i<elements.size();i++)
        {
            CanvasElement ce = (CanvasElement)elements.elementAt(i);
            if (ce!=null)
	    {
                ce.fixColors();
            }
        }
    }
    
    public void focus()
    {
	focus(this);
    }

    public void focus(HostCanvas host)
    {
	Base.setCurrentDisplay(host);
    }

    public void setTag(int ttag)
    {
	tag = ttag;
    }

    public int getTag()
    {
	return tag;
    }
    
    protected void sizeChanged(int w, int h)
    {
	if (layman.size()>0)
	{
	    layman.layout(w, h);
	}
	
	if (menu!=null)
	{
	    menu.sizeChanged(w, h);
	}
    }
    
    public void reLayout()
    {
	sizeChanged(getWidth(), getHeight());
    }
    
    public LayoutManager getLayoutManager()
    {
	return layman;
    }

    protected void showNotify()
    {
	if (!layman.isLayoutPerformed())
	{
	    sizeChanged(getWidth(), getHeight());
	}
	
        for(int i = 0;i<elements.size();i++)
        {
            CanvasElement ce = (CanvasElement)elements.elementAt(i);
            if (ce!=null)
	    {
                ce.showNotify();
            }
        }   
	
	manageBacklight();
	lastvisible = this;   
    }
	
    protected void hideNotify()
    {    
        for(int i = 0;i<elements.size();i++)
        {
            CanvasElement ce = (CanvasElement)elements.elementAt(i);
            if (ce!=null)
	    {
                ce.hideNotify();
            }
        }
    }
    
    // this strange function is used to correctly
    // turn off lights on return from background
    protected Canvas getLastVisible()
    {
	return lastvisible;
    }
    
    protected void setPrevious(HostCanvas hc)
    {
	previous = hc;
    }

    protected HostCanvas getPrevious()
    {
	if (previous==null)
	{
	    Log.fire("Prev is not defined");
	}
	
	return previous;
    }
    
    protected void goBack(boolean preview)
    {
	if (previous!=null)
	{
	    if (preview) previous.selectPreview(this);
	    previous.focus();
	}
	else
	{
	    Log.fire("Prev is not defined");
	}
    }   

    protected Vector getElements()
    {
	return elements;
    }
}