jnlist.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 454 行

package org.jnode.wt.components;

import org.jnode.wt.events.JNAdjustmentEvent;
import org.jnode.wt.events.JNItemEvent;
import org.jnode.wt.events.JNodeMouseEvent;
import org.jnode.wt.image.JNBufferedImage;
import org.jnode.wt.events.JNAdjustmentListener;
import org.jnode.wt.events.JNItemListener;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.peer.ListPeer;
import java.util.ArrayList;

/**
 * @author Kishore
 */
public class JNList extends JNPanel implements ListPeer, JNAdjustmentListener, ItemSelectable, JNItemListener {

    private JNScrollBar listScroller = null;
    private JNMenu listItemsPanel = null;

    private int eachListItemHeight = 28;
    // This variable is modified by scrollbar.
    //private int visibleStartItem = 0;
    // This variable is calculated in setSize() method.
    private int num_viewable_items_in_List = 1;

    //private int currentScrollValue = 0;

    private JNBufferedImage listItemsBImage = null;

    static final int SCROLLBAR_WIDTH = 20;

    private int indexofFirstVisibleLabel = 0;
    private int endLabIndex = 1;
    private int numof_firstLabelPixels_visible = 0;

    private ButtonGroup aButtonGroup = null;

    protected ArrayList itemListeners = new ArrayList();

    private boolean isBufferedImageReady = false;

    /**
     * JNList constructor comment.
     */
    public JNList() {
        super();

        init();
    }
/*
 * Kishore.
 */
    private void _menu_processMouseEvent(JNodeMouseEvent event) {

        int refLabeIndex = ((numof_firstLabelPixels_visible * -1) + event.getY()) / eachListItemHeight;

        int resultLabel = indexofFirstVisibleLabel + refLabeIndex;

//	System.out.println(resultLabel+" ============================");
        JNLabel comp = null;

        if (resultLabel >= 0) {
            comp = (JNLabel) listItemsPanel.getComponent(resultLabel);
        }



/*	System.out.println("numoffirstLabelPixels= " +numof_firstLabelPixels_invisible);
	System.out.println("y value= " +event.getY());
	System.out.println("resultLabel= "+resultLabel);

	System.out.println("-----------------------");*/

        if (comp != null) {
            boolean b = comp.isSelected();
            if (b == true) {
//			System.out.println("\nList hell sending^^^ "+ false);
                comp.setSelected(false);
            } else {
//			System.out.println("\nList hell sending^^^ "+ true);
                comp.setSelected(true);
            }

            comp.processMouseEvent(event);
        }
    }

    private void _recalcBufferedImage() {
        if (indexofFirstVisibleLabel < 0 || endLabIndex < 0) {
            return;
        }
        // ---
        Graphics biG = listItemsBImage.getGraphics();
        /* Clear BUffereImage. */
        biG.setColor(Color.white);
        biG.fillRect(0, 0, listItemsBImage.getWidth(), listItemsBImage.getHeight());
        // ----

        org.jnode.wt.components.JNComponent[] comps = listItemsPanel.getComponents();
        int ty = numof_firstLabelPixels_visible;
        JNLabel lab = null;
        for (int i = indexofFirstVisibleLabel; i <= endLabIndex; i++) {
            lab = (JNLabel) comps[i];

            int transY = ty;
            biG.translate(0, transY);
            lab.internallyPaint(biG);
            biG.translate(0, -transY);
//			System.out.println(tempy+" ---- "+lab.getText()+"  t=>"+ (tempy+28));
            ty = ty + eachListItemHeight;
        }
//System.out.println("---------------------- MENU.Height"+listItemsPanel.getHeight());

        /* paint the ItemsLabelPanel into BufferedImage.
            and this BufferedImage will be drawn to screen in internallyPaint */
//	listItemsPanel.update( biG );
    }

    public void add(String s) {
        //listItemsPanel.add( new JNLabel(s) );

        JNLabel lab = new JNLabel(s);
//		lab.setSize(lab.getPreferredSize());
        lab.setSize((int) listItemsPanel.getSize().getWidth(), eachListItemHeight);

        lab.addItemListener(this);

        listItemsPanel.add(lab);

        if (null == aButtonGroup)
            aButtonGroup = new ButtonGroup();

        aButtonGroup.add(lab);

        recalcScrollMinMax();

        //int i = 0;
    }

    public void addItemListener(JNItemListener lis) {
        itemListeners.add(lis);
    }

    public void adjustmentValueChanged(JNAdjustmentEvent e) {
        double y = e.getValue();  // IF  y is [323]
        double ELIH_D = eachListItemHeight;	//	[50.0]

        double a = y / eachListItemHeight;	//	[6.46]

        int a_int = (int) a;	// [6]

        double b_fraction = a - a_int; // [0.46]

        int b_fraction_100 = (int) (b_fraction * 100); // [46 = 0.46 * 100]

        int firstLabIndex = (int) a;	// [6]

        if (b_fraction_100 > 0)	// [46 > 0]
        {
            firstLabIndex = firstLabIndex - 1;	// [5 = 6-1]
        }

        // y value of first LAbel.
        int firstLabIndex_Y = (int) (ELIH_D * b_fraction) * -1; // [ -46 = (50.0 * 0.46) * -1]

        if (firstLabIndex < 0) {
            firstLabIndex = 0;
            firstLabIndex_Y = 0;
        }


        int lastLabIndex = firstLabIndex + num_viewable_items_in_List + 2;
        /* Q) why 2 ?
           A) one extra label at the top, one extra one at the bottom
         */
        if (lastLabIndex > listItemsPanel.getComponentCount() - 1) {
            lastLabIndex = listItemsPanel.getComponentCount() - 1;
        }


        this.endLabIndex = lastLabIndex;
        /* +++++++++++ */
        indexofFirstVisibleLabel = firstLabIndex;
        numof_firstLabelPixels_visible = firstLabIndex_Y;
        /* +++++++++++ */

        _recalcBufferedImage();

//System.out.println("---------------------- MENU.Height"+listItemsPanel.getHeight());
        repaint();

        /* paint the ItemsLabelPanel into BufferedImage.
            and this BufferedImage will be drawn to screen in internallyPaint */
//	listItemsPanel.update( biG );
    }

    private void calculate_NumVisibleItems() {
        // calclate num_visible_items.
        num_viewable_items_in_List = this.getHeight() / eachListItemHeight;

        if (endLabIndex < 0) ;
        endLabIndex = indexofFirstVisibleLabel + num_viewable_items_in_List + 2;
    }

    public Object[] getSelectedObjects() {
        return itemListeners.toArray();
    }

    private void init() {

        //Dimension d = new Dimension(150, 6 * eachListItemHeight);

//	setSize(d);
//	setPreferredSize(d);

        //Scrollbar
        listScroller = new JNScrollBar(JNScrollBar.VERTICAL);
        // ItemsPanel [MENU]
        listItemsPanel = new JNMenu(JNMenu.MENU_USED_IN_LIST);
        listItemsPanel.setLocation(0, 0);

        listScroller.addAdjustmentListener(this);

//	this.setLayout(null);

        this.add(listScroller);

        /* ListItempanel is created but not directly added to JNList,
           instead a BufferedImage of that size is created, and all drawing done
           to this BuffuredImage, and from the internallyPaint of this[JNList],
           the BufferedImage drawn to JNList SCreen.
    //	this.add( listItemsPanel );	*/

        listScroller.setUnitIncrement(50);

    }

    protected void internallyPaint(Graphics g) {
//	super.internallyPaint(g);
//	System.out.println("                               remove recalcbuffere from jnlist internapaint");

        if (isBufferedImageReady == false) {
            _recalcBufferedImage();
            isBufferedImageReady = true;
        }

        g.drawImage(listItemsBImage, 0, 0, listItemsPanel.getWidth(), this.getHeight(), null);

        g.setColor(Color.black);
        g.drawRect(0, 0, listItemsPanel.getWidth(), this.getHeight());

    }

    public void itemStateChanged(JNItemEvent e) {

        JNAbstractButton item = (JNAbstractButton) e.getItem();

        int id = JNItemEvent.ITEM_STATE_CHANGED;

        int state = -1;

        if (item.isSelected()) {
            state = JNItemEvent.SELECTED;
        } else {
            state = JNItemEvent.DESELECTED;
        }

        JNItemEvent ce = new JNItemEvent(this, id, item, state);

        for (int i = 0; i < itemListeners.size(); i++) {
            ((JNItemListener) itemListeners.get(i)).itemStateChanged(ce);
        }
    }
/*
 * Kishore.
 */
    public void processMouseEvent(JNodeMouseEvent event) {
        /*There are only two components, ScrollBAr and MEnu.*/

        /*IF scrollbar*/
        if (listScroller.getBounds().contains(event.getX(), event.getY())) {
            /* Translate Event X,Y before calling */
            event.translatePoint(listScroller.getX(), listScroller.getY());

            listScroller.processMouseEvent(event);

            return;
        } else   /*it must be inside the MEnu area Area.*/ if (listItemsPanel.getBounds().contains(event.getX(), event.getY())) {
            /* Translate Event X,Y before calling */
            event.translatePoint(listItemsPanel.getX(), listItemsPanel.getY());

            _menu_processMouseEvent(event);

            _recalcBufferedImage();

            repaint();
            return;
        }

        // call super, to call the mouseMotionListeners.
        /* Call to super is not needed as everything is handeled here */
//		super.processMouseEvent(event);

    }

    private void recalcScrollMinMax() {
        int z = 0;

        int totalcomps = listItemsPanel.getComponentCount();
        /* In case when "total numof viewable components" are lessthan visible */
        if (totalcomps < num_viewable_items_in_List) {
            z = totalcomps;
        } else {
            z = totalcomps - num_viewable_items_in_List;
        }

        /* maximum for SCroller is the height of all list items. */
        z = z * eachListItemHeight;

        listScroller.setMinMax(0, z);

    }

    public void recalculate() {
        super.recalculate();

        _recalcBufferedImage();

    }

    public void removeItemListener(JNItemListener lis) {
        itemListeners.remove(lis);
    }

    /*TODO:: this is not needed once GridLayout is done,
               GridLayout will be used for listItemsPanel,
               and a simple listItemsPanel.resize() will do the job.*/
    public void resizeListItemsComponents(int w, int h) {
        org.jnode.wt.components.JNComponent[] comps = listItemsPanel.getComponents();

        for (int i = 0; i < comps.length; i++) {
            comps[i].setSize(w, h);
        }
    }

    public void setSize(int w, int h) {
        super.setSize(w, h);

        // ScrollBar
        int sbrwidth = SCROLLBAR_WIDTH;
        int itemspanelwidth = w - sbrwidth;
        listScroller.setSize(sbrwidth, h);
        listScroller.setLocation(itemspanelwidth, 0);

        // ItemsPanel
        listItemsPanel.setSize(itemspanelwidth, h);

        // BufferedImage for ItemsPanel.
        if ((itemspanelwidth > 0) && (h > 0)) {
            listItemsBImage = new JNBufferedImage(itemspanelwidth, h, JNBufferedImage.TYPE_INT_RGB);
        }


/*TODO:: this is not needed once GridLayout is done,
			GridLayout will be used for listItemsPanel,
			and a simple listItemsPanel.resize() will do the job.*/
        resizeListItemsComponents(itemspanelwidth, h);

        calculate_NumVisibleItems();
        recalcScrollMinMax();


    }

    public void setVisible(boolean b) {
        super.setVisible(b);

        listScroller.setVisible(b);

        _recalcBufferedImage();

        repaint();
    }

    public void add(String item, int index) {
        //TODO: implement it
    }

    public void addItem(String item, int index) {
        //TODO: implement it
    }

    public void clear() {
        //TODO: implement it
    }

    public void delItems(int start_index, int end_index) {
        //TODO: implement it
    }

    public void deselect(int index) {
        //TODO: implement it
    }

    public int[] getSelectedIndexes() {
        //TODO: implement it
        return new int[0];
    }

    public void makeVisible(int index) {
        //TODO: implement it
    }

    public Dimension minimumSize(int s) {
        //TODO: implement it
        return null;
    }

    public Dimension preferredSize(int s) {
        //TODO: implement it
        return null;
    }

    public void removeAll() {
        //TODO: implement it
    }

    public void select(int index) {
        //TODO: implement it
    }

    public void setMultipleMode(boolean multi) {
        //TODO: implement it
    }

    public void setMultipleSelections(boolean multi) {
        //TODO: implement it
    }

    public Dimension getPreferredSize(int i){
        //TODO: implement it
        return null;
    }

    public Dimension getMinimumSize(int i){
        //TODO: implement it
        return null;
    }
}