All Downloads are FREE. Search and download functionalities are using the official Maven repository.

javax.microedition.lcdui.Item Maven / Gradle / Ivy

The newest version!
/*
 *  MicroEmulator
 *  Copyright (C) 2001 Bartek Teodorczyk 
 *  Copyright (C) 2005 Andres Navarro
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Contributor(s):
 *    3GLab
 */
 
package javax.microedition.lcdui;

import java.util.Vector;

import org.microemu.device.DeviceFactory;
import org.microemu.device.ui.ItemUI;

public abstract class Item
{

	static final int OUTOFITEM = Integer.MAX_VALUE;

	public static final int LAYOUT_DEFAULT          = 0x0000;

    public static final int LAYOUT_LEFT             = 0x0001;
    public static final int LAYOUT_RIGHT            = 0x0002;
    public static final int LAYOUT_CENTER           = 0x0003;

    public static final int LAYOUT_TOP              = 0x0010;
    public static final int LAYOUT_BOTTOM           = 0x0020;
    public static final int LAYOUT_VCENTER          = 0x0030;

    public static final int LAYOUT_NEWLINE_BEFORE   = 0x0100;
    public static final int LAYOUT_NEWLINE_AFTER    = 0x0200;

    public static final int LAYOUT_SHRINK           = 0x0400;
    public static final int LAYOUT_EXPAND           = 0x0800;
    public static final int LAYOUT_VSHRINK          = 0x1000;
    public static final int LAYOUT_VEXPAND          = 0x2000;

    public static final int LAYOUT_2                = 0x4000;


    public static final int PLAIN = 0;
    public static final int HYPERLINK = 1;
    public static final int BUTTON = 2;
    
    ItemUI ui;

	StringComponent labelComponent;
	Screen owner = null;
	private boolean focus = false;
	
	// MIDP2
	int layout;
	Vector commands;
    Command defaultCommand;
    ItemCommandListener commandListener;
    
    // -1 means unlocked, otherwise it is the application requested preffered size
    // for the actual one use the getPrefXXXX() method package access
    int prefWidth;
    
    int prefHeight;
  
    Item(String label) {
		labelComponent = new StringComponent(label);
		commands = new Vector();
		setPreferredSize(-1, -1);
	}
	
    void setUI(ItemUI ui) {
    	this.ui = ui;
    }
    
	public void addCommand(Command cmd) {
	    if (cmd == null)
	        throw new NullPointerException();
	
	    if (!commands.contains(cmd)) {
	        // Now insert it in order
	        boolean inserted = false;
	          
	        for (int i = 0; i < commands.size(); i++) {
	            if (cmd.getPriority() < ((Command)commands.elementAt(i)).getPriority()) {
	                commands.insertElementAt(cmd, i);
	                inserted = true;
	                break;
	            }
	        }
	        if (!inserted) {
	          // Not inserted just place it at the end
	              commands.addElement(cmd);
	        }
	    	repaintOwner();
        }

	}
  
	public String getLabel()
	{
		return labelComponent.getText();
	}

	public int getLayout() {
		return layout;
	}
	
	public int getMinimumHeight() {
		if (labelComponent != null)
			return labelComponent.getHeight();
		else 
			return 0;
    }

    public int getMinimumWidth() {
    	return getMaximumWidth();
    }
    
    public int getPreferredHeight() {
        int ret = prefHeight;
        int min = getMinimumHeight();
        int max = getMaximumHeight();

        if (ret == -1)
        	return min;
        
        if (ret < min)
        	ret = min;
        else if (ret > max)
        	ret = max;
    	return ret;
    }

    public int getPreferredWidth() {
        int ret = prefWidth;
        int min = getMinimumWidth();
        int max = getMaximumWidth();
        
        if (ret == -1)
        	return max;
        	
        if (ret < min)
        	ret = min;
        else if (ret > max)
        	ret = max;
    	return ret;
    }

	public void notifyStateChanged() {
		Screen owner = getOwner();
		if (owner != null && owner instanceof Form) {
			Form form = (Form) owner;
			form.fireItemStateListener(this);
		}
		
    }

	public void removeCommand(Command cmd) {
        commands.removeElement(cmd);
        if (defaultCommand == cmd)
        	defaultCommand = null;
        repaintOwner();
    }
	
    public void setDefaultCommand(Command cmd) {
    	ui.setDefaultCommand(cmd);
    	
        this.defaultCommand = cmd;
        if (cmd != null) {
            // we should repaint even if the command was added
            // because the command layout could become different
            if (commands.contains(cmd))
            	addCommand(cmd);
            else 
            	repaintOwner();
        } else {
        	repaintOwner();
        }
    }

    public void setItemCommandListener(ItemCommandListener l) {
        this.commandListener = l;
    }
    
    public void setLabel(String label)	
	{
    	ui.setLabel(label);
    	
		labelComponent.setText(label);
		repaint();
	}

    public void setLayout(int layout) {
    	// TODO validate container is not Alert
    	// on add to Alert validate this is default
    	
    	// notice that the vertical and the horizontal
    	// layout policies can't generate conflict
    	// because the center is the or of the two
    	// others (ie VCENTER == (LEFT | RIGHT))
    	if ((( (layout & LAYOUT_SHRINK) != 0) &&
    		  ((layout & LAYOUT_EXPAND) != 0)) ||
    			( ((layout & LAYOUT_VSHRINK) != 0) &&
    	    	(layout & LAYOUT_VEXPAND) != 0) )
    		throw new IllegalArgumentException(
    				"Bad combination of layout policies");
		this.layout = layout;
    	repaint();
    }

    public void setPreferredSize(int width, int height) {
        if (width < -1 || height < -1) {
            throw new IllegalArgumentException();
        }
        this.prefWidth = width;
        this.prefHeight = height;
        repaint();
    }

    //
    // package access methods
    //
    
    // repaint the owner of this item (if any)
    void repaintOwner() {
        Screen owner = getOwner();
        if (owner != null)
        	owner.repaint();
    }
	
  int getHeight()
	{
		return labelComponent.getHeight();
	}
	
	
	boolean isFocusable()
	{
		return false;
	}
	
	
  void keyPressed(int keyCode)
  {
  }
  
    
  abstract int paint(Graphics g);
	
	
	void paintContent(Graphics g)
	{
		labelComponent.paint(g);
	}
	
	
	void repaint()
	{
		if (owner != null) {
			owner.repaint();
		}
	}
	
  
	boolean hasFocus()
	{
		return focus;
	}
  
  
	void setFocus(boolean state)
	{
		focus = state;
	}
  
  
  Screen getOwner()
  {
    return owner;
  }
	
	
  	void setOwner(Screen owner) 
  	{
		this.owner = owner;

		if (owner == null) {
			setFocus(false);
		}
	}
	
	
	boolean select()
	{
		// call the default command (if there is one)
		// however subclasses may override this behaviour
		// (ie popup choices uses select to bring the popup)
		if (defaultCommand != null && commandListener != null) {
			commandListener.commandAction(defaultCommand, this);
			return true;
		} else {
			return false;
		}
	}
  

	int traverse(int gameKeyCode, int top, int bottom, boolean action)
	{
		return 0;
	}

	int getMaximumHeight() {
		if (owner != null) {
			return owner.getHeight() * 10;
		} else {
			return DeviceFactory.getDevice().getDeviceDisplay().getHeight() * 10;
		}
	}
	
	int getMaximumWidth() {
		if (owner != null) {
			return owner.getWidth() - 3;
		} else {
			return DeviceFactory.getDevice().getDeviceDisplay().getWidth() - 3;
		}
	}

	ItemCommandListener getItemCommandListener() {
		return this.commandListener;
	}
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy