containerview.java

j2me polish学习的经典代码

//#condition polish.usePolishGui
/*
 * Created on Oct 27, 2004 at 7:03:40 PM.
 *
 * Copyright (c) 2004-2005 Robert Virkus / Enough Software
 *
 * This file is part of J2ME Polish.
 *
 * J2ME Polish is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * J2ME Polish 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with J2ME Polish; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Commercial licenses are also available, please
 * refer to the accompanying LICENSE.txt or visit
 * http://www.j2mepolish.org for details.
 */
// package de.enough.polish.ui;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;

//import de.enough.polish.util.ArrayList;
//import de.enough.polish.util.TextUtil;

/**
 * <p>Is responsible for visual representation and interpretation of user-input.</p>
 * <p>Copyright Enough Software 2004, 2005</p>
 * <pre>
 * history
 *        Oct 27, 2004 - rob creation
 * </pre>
 * @author Robert Virkus, [e-mail]
 */
public class ContainerView {
	//#if polish.css.columns || polish.useTable
		//#define tmp.useTable
		//#ifdef polish.css.columns-width.star
			//# private int starIndex;
		//#endif
//# 			
	//#endif
	
	private static final int NO_COLUMNS = 0;
	private static final int EQUAL_WIDTH_COLUMNS = 1;
	private static final int NORMAL_WIDTH_COLUMNS = 2;
	private static final int STATIC_WIDTH_COLUMNS = 3;

	protected int yOffset;
	protected int contentWidth;
	protected int contentHeight;
	protected int focusedIndex = -1;
	/** this field is set automatically, so that subclasses can use it for referencing the parent-container */
	protected Container parentContainer;
	/** determines whether any animation of this view should be (re) started at the next possibility. this is set to "true" in each showNotify() method. */
	protected boolean restartAnimation;
	protected int paddingVertical;
	protected int paddingHorizontal;
	protected int layout;
	protected boolean focusFirstElement;
	protected int appearanceMode;
	protected boolean isFocused;
	protected Item focusedItem;
	
	// table support:
	protected int columnsSetting = NO_COLUMNS;
	protected int numberOfColumns;
	protected int[] columnsWidths;
	protected int[] rowsHeights;
	protected int numberOfRows;
	protected boolean isLayoutCenter;
	protected boolean isLayoutRight;
	
	protected boolean allowCycling = true;
	
	//#if polish.css.view-type-left-x-offset
		//# protected int leftXOffset;
	//#endif
	//#if polish.css.view-type-right-x-offset
		//# protected int rightXOffset;
	//#endif
	//#if polish.css.view-type-top-y-offset
		//# protected int topYOffset;
	//#endif


	/**
	 * Creates a new view
	 */
	protected ContainerView() {
		super();
	}
	
	/**
	 * Initialises this item. 
	 * The implementation needs to calculate and set the contentWidth and 
	 * contentHeight fields. 
	 * The style of the focused item has already been set.
	 *  
	 * @param parent the Container which uses this view, use parent.getItems() for retrieving all items. 
	 * @param firstLineWidth the maximum width of the first line 
	 * @param lineWidth the maximum width of any following lines
	 * @see #contentWidth
	 * @see #contentHeight
	 */
	protected void initContent( Container parent, int firstLineWidth, int lineWidth ) {
		//#debug
		//# System.out.println("ContainerView: intialising content for " + this + " with vertical-padding " + this.paddingVertical );
		//#if polish.Container.allowCycling != false
			this.allowCycling = parent.allowCycling;
			if (parent.parent == null ||
					 ( (parent.parent instanceof Container)  && ((Container)parent.parent).getItems().length>1) )
			{
				this.allowCycling = false;
			}
		//#endif
		//#if polish.css.view-type-left-x-offset
			//# lineWidth -= this.leftXOffset;
		//#endif
		//#if polish.css.view-type-right-x-offset
			//# lineWidth -= this.rightXOffset;
		//#endif

		
		this.parentContainer = parent;
		Item[] myItems = parent.items;

		//#ifdef tmp.useTable
			//# if (this.columnsSetting == NO_COLUMNS || myItems.length <= 1) {
		//#endif
			// look at the layout of the parentContainer, since the SHRINK layout can be set outside of the setStyle method as well:
			boolean isLayoutShrink = (this.parentContainer.layout & Item.LAYOUT_SHRINK) == Item.LAYOUT_SHRINK;
			int myContentWidth = 0;
			int myContentHeight = 0;
			boolean hasFocusableItem = false;
			for (int i = 0; i < myItems.length; i++) {
				Item item = myItems[i];
				//System.out.println("initalising " + item.getClass().getName() + ":" + i);
				int width = item.getItemWidth( firstLineWidth, lineWidth );
				int height = item.getItemHeight( firstLineWidth, lineWidth );
				// now the item should have a style, so it can be safely focused
				// without loosing the style information:
				if (item.appearanceMode != Item.PLAIN) {
					hasFocusableItem = true;
				}
				if (isLayoutShrink && i == this.focusedIndex) {
					width = 0;
				}
				if (width > myContentWidth) {
					myContentWidth = width; 
				}
				item.yTopPos = myContentHeight;
				item.yBottomPos = myContentHeight + item.itemHeight;
				myContentHeight += height + this.paddingVertical;
			}
			if (hasFocusableItem) {
				this.appearanceMode = Item.INTERACTIVE;
				if (isLayoutShrink && this.focusedItem != null) {
					Item item = this.focusedItem;
					//System.out.println("container has shrinking layout and contains focuse item " + item);
					item.isInitialised = false;
					boolean doExpand = item.isLayoutExpand;
					int width;
					if (doExpand) {
						item.isLayoutExpand = false;
						width = item.getItemWidth( lineWidth, lineWidth );
						item.isInitialised = false;
						item.isLayoutExpand = true;
					} else {
						width = item.itemWidth;
					}
					if (width > myContentWidth) {
						myContentWidth = width;
					}
				}
			} else {
				this.appearanceMode = Item.PLAIN;
			}
			
			//#if polish.css.view-type-top-y-offset
				//# this.contentHeight = myContentHeight + this.topYOffset;
			//#else
				this.contentHeight = myContentHeight;
			//#endif
			this.contentWidth = myContentWidth;
			//System.out.println("ContainerView.initContent(): contentWidth=" + this.contentWidth );
			return;
		//#ifdef tmp.useTable
		//# }
		//#endif
		
		//#ifdef tmp.useTable
			//# // columns are used
			//# boolean isNormalWidthColumns = (this.columnsSetting == NORMAL_WIDTH_COLUMNS);
			//#ifdef polish.css.columns-width.star
				//# if (this.columnsSetting == STATIC_WIDTH_COLUMNS) {
					//# if (this.starIndex != -1) {
						//# int combinedWidth = 0;
						//# for (int i = 0; i < this.numberOfColumns; i++) {
							//# combinedWidth += this.columnsWidths[i];
						//# }
						//# this.columnsWidths[this.starIndex] = lineWidth - combinedWidth;
					//# }
				//# } else {
			//#else
				//#	if (this.columnsSetting != STATIC_WIDTH_COLUMNS) {
			//#endif
				//# int availableColumnWidth;
				//# if (isNormalWidthColumns) {
					//# // this.columnsSetting == NORMAL_WIDTH_COLUMNS
					//# // each column should use as much space as it can use
					//# // without ousting the other columns
					//# // (the calculation will be finished below)
					//# availableColumnWidth = lineWidth - ((this.numberOfColumns -1) * this.paddingHorizontal);
				//# } else {
					//# // each column should take an equal share
					//# availableColumnWidth = 
						//# (lineWidth - ((this.numberOfColumns -1) * this.paddingHorizontal))
						//# / this.numberOfColumns;
				//# }
				//# //System.out.println("available column width: " + availableColumnWidth );
				//# this.columnsWidths = new int[ this.numberOfColumns ];
				//# for (int i = 0; i < this.numberOfColumns; i++) {
					//# this.columnsWidths[i] = availableColumnWidth;
				//# }
			//# }
//# 				
			//#if polish.css.colspan
				//# ArrayList rowHeightsList = new ArrayList( (myItems.length / this.numberOfColumns) + (myItems.length % 2) + 1 );
			//#else
				//# this.numberOfRows = (myItems.length / this.numberOfColumns) + (myItems.length % 2);
				//# this.rowsHeights = new int[ this.numberOfRows ];
			//#endif
			//# int maxRowHeight = 0;
			//# int columnIndex = 0;
			//# int rowIndex = 0;
			//# int[] maxColumnWidths = null;
			//# if (isNormalWidthColumns) {
				//# maxColumnWidths = new int[ this.numberOfColumns ];
			//# }
			//# int maxWidth = 0; // important for "equal" columns-width
			//# int myContentHeight = 0;
			//# boolean hasFocusableItem = false;
			//# //System.out.println("starting init of " + myItems.length + " container items.");
			//# for (int i=0; i< myItems.length; i++) {
				//# Item item = myItems[i];
				//# if (item.appearanceMode != Item.PLAIN) {
					//# hasFocusableItem = true;
				//# }
				//# int availableWidth = this.columnsWidths[columnIndex];
				//#if polish.css.colspan
					//# int itemColSpan = item.colSpan;
					//# if (!item.isInitialised && item.style != null) {
						//# Integer colSpanInt = item.style.getIntProperty(106);
						//# if ( colSpanInt != null ) {
							//# itemColSpan = colSpanInt.intValue();
							//# //System.out.println("colspan of item " + i + "/" + item + ", column " + columnIndex + ": " + itemColSpan);
						//# }
					//# }
					//# //System.out.println("ContainerView.init(): colspan of item " + i + "=" + itemColSpan);
					//# if (itemColSpan > 1) {
						//# // okay, this item stretched beyond one column,
						//# // so let's calculate the correct available cell width
						//# // and switch to the right column index:
						//# int maxColSpan = this.numberOfColumns - columnIndex;
						//# if (itemColSpan > maxColSpan) {
							//#debug error
							//# System.err.println("Warning: colspan " + itemColSpan + " is invalid at column " + columnIndex + " of a table with " + this.numberOfColumns + " columns, now using maximum possible value " + maxColSpan + ".");
							//# itemColSpan = maxColSpan;
						//# }
//# 						
						//# // adjust the available width only when
						//# // each column has an equal size or when
						//# // the column widths are static,
						//# // otherwise the complete row width
						//# // is available anyhow:
						//# if (!isNormalWidthColumns) {
							//# if (itemColSpan == maxColSpan) {
								//# availableWidth = 0;
								//# for (int j = 0; j < columnIndex; j++) {
									//# availableWidth += this.paddingHorizontal + this.columnsWidths[j];
								//# }
								//# availableWidth = lineWidth - availableWidth;
							//# } else {
								//# for (int j = columnIndex + 1; j < columnIndex + itemColSpan; j++) {
									//# availableWidth += this.paddingHorizontal + this.columnsWidths[j];
								//# }								
							//# }
							//# //System.out.println("ContainerView.init(): adjusted availableWidth for item " + i + ": " + availableWidth);
						//# }
					//# }
				//#endif
				//# //System.out.println( i + ": available with: " + availableWidth + ", item.isInitialized=" + item.isInitialised + ", itemWidth=" + item.getItemWidth( availableWidth, availableWidth ));
				//# if (item.isInitialised && item.itemWidth > availableWidth) {
					//# item.isInitialised = false;
				//# }
				//# int width = item.getItemWidth( availableWidth, availableWidth );
				//# //System.out.println("got item width");
				//# int height = item.getItemHeight( availableWidth, availableWidth );
//# 								
				//# if (height > maxRowHeight) {
					//# maxRowHeight = height;
				//# }
				//#if polish.css.colspan
					//# if (itemColSpan == 1) {
				//#endif
						//# if (isNormalWidthColumns && width > maxColumnWidths[columnIndex ]) {
							//# maxColumnWidths[ columnIndex ] = width;
						//# }
						//# if (width > maxWidth ) {
							//# maxWidth = width;
						//# }
				//#if polish.css.colspan
					//# }
				//#endif
				//#if polish.css.colspan
					//# if (item.colSpan != itemColSpan) {
						//#debug
						//# System.out.println("initializing new colspan of item " + i + "/" + item + ", column " + columnIndex + ": " + itemColSpan);
						//# item.colSpan = itemColSpan;
						//# item.isInitialised = false;
					//# }
					//# columnIndex += itemColSpan;
				//#else
					//# columnIndex++;
				//#endif
				//# item.yTopPos = myContentHeight;
				//# item.yBottomPos = myContentHeight + height;
				//# if (columnIndex == this.numberOfColumns) {
					//# //System.out.println("starting new row: rowIndex=" + rowIndex + "  numberOfRows: " + numberOfRows);
					//# columnIndex = 0;
					//#if polish.css.colspan
						//# //System.out.println("ContainerView.init(): adding new row " + rowIndex + " with height " + maxRowHeight + ", contentHeight=" + myContentHeight + ", item " + i);
						//# rowHeightsList.add( new Integer( maxRowHeight ) );
					//#else
						//# this.rowsHeights[rowIndex] = maxRowHeight;						
					//#endif
					//# myContentHeight += maxRowHeight + this.paddingVertical;
					//# maxRowHeight = 0;
					//# rowIndex++;
				//# }
			//# } // for each item
			//# if (hasFocusableItem) {
				//# this.appearanceMode = Item.INTERACTIVE;
			//# } else {
				//# this.appearanceMode = Item.PLAIN;
			//# }
			//# if (columnIndex != 0) {
				//# // last row is not completely filled.
				//#if polish.css.colspan
					//# rowHeightsList.add( new Integer( maxRowHeight ) );
				//#endif
				//# myContentHeight += maxRowHeight;
			//# }
			//#if polish.css.colspan
				//# this.numberOfRows = rowHeightsList.size();
				//# //System.out.println("ContainerView.init(): numberOfRows=" + this.numberOfRows + ", rowIndex=" + rowIndex);
				//# this.rowsHeights = new int[ this.numberOfRows ];
//# 				
				//# for (int i = 0; i < this.numberOfRows; i++) {
					//# this.rowsHeights[i] = ((Integer) rowHeightsList.get(i)).intValue();
				//# }
			//#endif
			//# // now save the worked out dimensions:
			//# if (isNormalWidthColumns) {
				//# // Each column should use up as much space as 
				//# // needed in the "normal" columns-width mode.
				//# // Each column which takes less than available 
				//# // the available-row-width / number-of-columns
				//# // can keep, but the others might need to be adjusted,
				//# // in case the complete width of the table is wider
				//# // than the allowed width.
//# 				
				//# int availableRowWidth = lineWidth - ((this.numberOfColumns -1) * this.paddingHorizontal);
				//# int availableColumnWidth = availableRowWidth / this.numberOfColumns;
				//# int usedUpWidth = 0;
				//# int leftColumns = this.numberOfColumns;
				//# int completeWidth = 0;
				//# for (int i = 0; i < maxColumnWidths.length; i++) {
					//# int maxColumnWidth = maxColumnWidths[i];
					//# if (maxColumnWidth <= availableColumnWidth) {
						//# usedUpWidth += maxColumnWidth;
						//# leftColumns--;
					//# }
					//# completeWidth += maxColumnWidth;
				//# }
				//# if (completeWidth <= availableRowWidth) {
					//# // okay, the table is fine just how it is
					//# this.columnsWidths = maxColumnWidths;
				//# } else {
					//# // okay, some columns need to be adjusted:
					//# // re-initialise the table:
					//# int leftAvailableColumnWidth = (availableRowWidth - usedUpWidth) / leftColumns;
					//# int[] newMaxColumnWidths = new int[ this.numberOfColumns ];
					//# myContentHeight = 0;