tablecellimpl.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   TableCellImpl.java

package org.gudy.azureus2.ui.swt.views.table.impl;

import com.aelitis.azureus.ui.common.table.*;
import java.io.PrintStream;
import java.text.Collator;
import java.util.*;
import org.eclipse.swt.graphics.*;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.config.ParameterListener;
import org.gudy.azureus2.core3.internat.MessageText;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.util.*;
import org.gudy.azureus2.plugins.ui.Graphic;
import org.gudy.azureus2.plugins.ui.SWT.GraphicSWT;
import org.gudy.azureus2.plugins.ui.UIRuntimeException;
import org.gudy.azureus2.plugins.ui.tables.*;
import org.gudy.azureus2.ui.swt.Utils;
import org.gudy.azureus2.ui.swt.components.*;
import org.gudy.azureus2.ui.swt.debug.ObfusticateCellText;
import org.gudy.azureus2.ui.swt.mainwindow.Colors;
import org.gudy.azureus2.ui.swt.plugins.UISWTGraphic;
import org.gudy.azureus2.ui.swt.pluginsimpl.UISWTGraphicImpl;
import org.gudy.azureus2.ui.swt.views.table.*;
import org.gudy.azureus2.ui.swt.views.table.utils.TableColumnSWTUtils;

public class TableCellImpl
	implements TableCellSWT
{
	private static class TextComparator
		implements Comparator
	{

		public int compare(Object arg0, Object arg1)
		{
			return arg0.toString().compareToIgnoreCase(arg1.toString());
		}

		private TextComparator()
		{
		}

	}


	private static final LogIDs LOGID;
	private static final byte FLAG_VALID = 1;
	private static final byte FLAG_SORTVALUEISTEXT = 2;
	private static final byte FLAG_TOOLTIPISAUTO = 4;
	private static final byte FLAG_UPTODATE = 8;
	private static final byte FLAG_DISPOSED = 16;
	private static final byte FLAG_MUSTREFRESH = 32;
	private static final byte FLAG_VISUALLY_CHANGED_SINCE_REFRESH = 64;
	private byte flags;
	private TableRowCore tableRow;
	private Comparable sortValue;
	private BufferedTableItem bufferedTableItem;
	private ArrayList refreshListeners;
	private ArrayList disposeListeners;
	private ArrayList tooltipListeners;
	private ArrayList cellMouseListeners;
	private ArrayList cellMouseMoveListeners;
	private ArrayList cellVisibilityListeners;
	private ArrayList cellSWTPaintListeners;
	private TableColumnCore tableColumn;
	private byte refreshErrLoopCount;
	private byte tooltipErrLoopCount;
	private byte loopFactor;
	private Object oToolTip;
	private int iCursorID;
	private Graphic graphic;
	private ArrayList childCells;
	public boolean bDebug;
	private static AEMonitor this_mon = new AEMonitor("TableCell");
	private static final String CFG_PAINT = "GUI_SWT_bAlternateTablePainting";
	private static boolean bAlternateTablePainting;
	private static int MAX_REFRESHES = 10;
	private static int MAX_REFRESHES_WITHIN_MS = 100;
	private boolean bInRefresh;
	private long lastRefresh;
	private int numFastRefreshes;
	private byte restartRefresh;
	private boolean bInRefreshAsync;
	private int textAlpha;
	public static final Comparator TEXT_COMPARATOR = new TextComparator();

	public TableCellImpl(TableRowCore _tableRow, TableColumnCore _tableColumn, int position, BufferedTableItem item)
	{
		iCursorID = -1;
		graphic = null;
		bDebug = false;
		bInRefresh = false;
		restartRefresh = 0;
		bInRefreshAsync = false;
		textAlpha = 255;
		tableColumn = _tableColumn;
		tableRow = _tableRow;
		flags = 2;
		refreshErrLoopCount = 0;
		tooltipErrLoopCount = 0;
		loopFactor = 0;
		if (item != null)
			bufferedTableItem = item;
		else
			createBufferedTableItem(position);
		tableColumn.invokeCellAddedListeners(this);
	}

	public TableCellImpl(TableRowSWT _tableRow, TableColumnCore _tableColumn, int position)
	{
		this(((TableRowCore) (_tableRow)), _tableColumn, position, null);
	}

	private void createBufferedTableItem(int position)
	{
		BufferedTableRow bufRow = (BufferedTableRow)tableRow;
		if (tableColumn.getType() == 2)
		{
			if (bAlternateTablePainting)
				bufferedTableItem = new BufferedGraphicTableItem2(bufRow, position) {

					final TableCellImpl this$0;

					public void refresh()
					{
						TableCellImpl.this.refresh();
					}

					public void invalidate()
					{
						clearFlag(1);
						redraw();
					}

			
			{
				this$0 = TableCellImpl.this;
				super(x0, x1);
			}
				};
			else
				bufferedTableItem = new BufferedGraphicTableItem1(bufRow, position) {

					final TableCellImpl this$0;

					public void refresh()
					{
						TableCellImpl.this.refresh();
					}

					public void invalidate()
					{
						clearFlag(1);
						redraw();
					}

			
			{
				this$0 = TableCellImpl.this;
				super(x0, x1);
			}
				};
			setOrientationViaColumn();
		} else
		{
			bufferedTableItem = new BufferedTableItemImpl(bufRow, position) {

				final TableCellImpl this$0;

				public void refresh()
				{
					TableCellImpl.this.refresh();
				}

				public void invalidate()
				{
					clearFlag(1);
				}

			
			{
				this$0 = TableCellImpl.this;
				super(x0, x1);
			}
			};
		}
	}

	private void pluginError(Throwable e)
	{
		String sTitleLanguageKey = tableColumn.getTitleLanguageKey();
		String sPosition = bufferedTableItem != null ? (new StringBuilder()).append("").append(bufferedTableItem.getPosition()).append(" (").append(MessageText.getString(sTitleLanguageKey)).append(")").toString() : "null";
		Logger.log(new LogEvent(LOGID, (new StringBuilder()).append("Table Cell Plugin for Column #").append(sPosition).append(" generated an exception ").toString(), e));
	}

	private void pluginError(String s)
	{
		String sTitleLanguageKey = tableColumn.getTitleLanguageKey();
		String sPosition = (new StringBuilder()).append("r").append(tableRow.getIndex()).append(bufferedTableItem != null ? (new StringBuilder()).append("c").append(bufferedTableItem.getPosition()).append(" (").append(MessageText.getString(sTitleLanguageKey)).append(")").toString() : "null").toString();
		Logger.log(new LogEvent(LOGID, 3, (new StringBuilder()).append("Table Cell Plugin for Column #").append(sPosition).append(":").append(s).append("\n  ").append(Debug.getStackTrace(true, true)).toString()));
	}

	private void checkCellForSetting()
	{
		if (isDisposed())
			throw new UIRuntimeException("Table Cell is disposed.");
		else
			return;
	}

	public Object getDataSource()
	{
		TableRowCore row = tableRow;
		TableColumnCore col = tableColumn;
		if (row == null || col == null)
			return null;
		else
			return row.getDataSource(col.getUseCoreDataSource());
	}

	public TableColumn getTableColumn()
	{
		return tableColumn;
	}

	public TableRow getTableRow()
	{
		return tableRow;
	}

	public String getTableID()
	{
		return tableRow.getTableID();
	}

	public boolean isValid()
	{
		return (flags & 1) != 0;
	}

	public Color getForegroundSWT()
	{
		checkCellForSetting();
		return bufferedTableItem.getForeground();
	}

	public Color getBackgroundSWT()
	{
		checkCellForSetting();
		return bufferedTableItem.getBackground();
	}

	public int[] getBackground()
	{
		if (bufferedTableItem == null)
			return null;
		Color color = bufferedTableItem.getBackground();
		if (color == null)
			return null;
		else
			return (new int[] {
				color.getRed(), color.getGreen(), color.getBlue()
			});
	}

	public int[] getForeground()
	{
		if (bufferedTableItem == null)
			return (new int[] {
				0, 0, 0
			});
		Color color = bufferedTableItem.getForeground();
		if (color == null)
			return new int[3];
		else
			return (new int[] {
				color.getRed(), color.getGreen(), color.getBlue()
			});
	}

	public boolean setForeground(Color color)
	{
		checkCellForSetting();
		if (isInvisibleAndCanRefresh())
			return false;
		boolean set = bufferedTableItem.setForeground(color);
		if (set)
			setFlag(64);
		return set;
	}

	public boolean setForeground(int red, int green, int blue)
	{
		checkCellForSetting();
		if (isInvisibleAndCanRefresh())
			return false;
		boolean set;
		if (red < 0 || green < 0 || blue < 0)
			set = bufferedTableItem.setForeground(null);
		else
			set = bufferedTableItem.setForeground(red, green, blue);
		if (set)
			setFlag(64);
		return set;
	}

	public boolean setForeground(int rgb[])
	{
		if (rgb == null || rgb.length < 3)
			return setForeground((Color)null);
		else
			return setForeground(rgb[0], rgb[1], rgb[2]);
	}

	public boolean setForegroundToErrorColor()
	{
		return setForeground(Colors.colorError);
	}

	public boolean setText(String text)
	{
		checkCellForSetting();
		if (text == null)
			text = "";
		boolean bChanged = false;
		if (hasFlag(2) && !text.equals(sortValue))
		{
			bChanged = true;
			sortValue = text;
			tableColumn.setLastSortValueChange(SystemTime.getCurrentTime());
			if (bDebug)
				debug("Setting SortValue to text;");
		}
		if (bufferedTableItem.setText(text) && !hasFlag(2))
			bChanged = true;
		if (bDebug)
			debug((new StringBuilder()).append("setText (").append(bChanged).append(") : ").append(text).toString());
		if (bChanged)
			setFlag(64);
		boolean do_auto = tableColumn.doesAutoTooltip();
		if (!do_auto)
		{
			if (hasFlag(4))
			{
				oToolTip = null;
				clearFlag(4);
			}
		} else
		{
			oToolTip = text;
			setFlag(4);
		}
		return bChanged;
	}

	private boolean isInvisibleAndCanRefresh()
	{
		return !isShown() && (refreshListeners != null || tableColumn.hasCellRefreshListener());
	}

	public String getText()
	{
		if (hasFlag(2) && (sortValue instanceof String))
			return (String)sortValue;
		if (bufferedTableItem == null)
			return null;
		else
			return bufferedTableItem.getText();
	}

	public boolean isShown()
	{
		if (bufferedTableItem == null)
			return false;
		else
			return bufferedTableItem.isShown() && tableRow.getView().isColumnVisible(tableColumn);
	}

	public boolean setSortValue(Comparable valueToSort)
	{
		if (!tableColumn.isSortValueLive() && !(valueToSort instanceof Number) && !(valueToSort instanceof String) && !(valueToSort instanceof TableColumnSortObject))
			tableColumn.setSortValueLive(true);
		return _setSortValue(valueToSort);
	}

	private boolean _setSortValue(Comparable valueToSort)
	{
		checkCellForSetting();
		if (sortValue == valueToSort)
			return false;
		if (hasFlag(2))
		{
			clearFlag(2);
			if (sortValue instanceof String)
				setText((String)sortValue);
		}
		if ((valueToSort instanceof String) && (sortValue instanceof String) && sortValue.equals(valueToSort))
			return false;
		if ((valueToSort instanceof Number) && (sortValue instanceof Number) && sortValue.equals(valueToSort))
			return false;
		if (bDebug)
			debug((new StringBuilder()).append("Setting SortValue to ").append(valueToSort != null ? valueToSort.getClass().getName() : "null").toString());
		tableColumn.setLastSortValueChange(SystemTime.getCurrentTime());
		sortValue = valueToSort;
		if (cellSWTPaintListeners != null || tableColumn.hasCellOtherListeners("SWTPaint"))
			redraw();
		return true;
	}

	public boolean setSortValue(long valueToSort)
	{
		checkCellForSetting();
		if ((sortValue instanceof Long) && ((Long)sortValue).longValue() == valueToSort)
			return false;
		else
			return _setSortValue(new Long(valueToSort));
	}

	public boolean setSortValue(float valueToSort)
	{
		checkCellForSetting();
		if ((sortValue instanceof Float) && ((Float)sortValue).floatValue() == valueToSort)
			return false;
		else
			return _setSortValue(new Float(valueToSort));
	}

	public Comparable getSortValue()
	{
		if (bDebug)
			debug((new StringBuilder()).append("GetSortValue;").append(sortValue != null ? (new StringBuilder()).append(sortValue.getClass().getName()).append(";").append(sortValue.toString()).toString() : "null").toString());
		if (sortValue == null)
		{
			if (bufferedTableItem != null)
				return bufferedTableItem.getText();
			else
				return "";
		} else
		{
			return sortValue;
		}
	}

	public void setToolTip(Object tooltip)
	{
		oToolTip = tooltip;
		clearFlag(4);
	}

	public Object getToolTip()
	{
		return oToolTip;
	}

	public boolean isDisposed()
	{
		return hasFlag(16);
	}

	public int getMaxLines()
	{
		if (bufferedTableItem == null)
			return 1;
		else
			return bufferedTableItem.getMaxLines();
	}

	public Point getSize()
	{
		if (!(bufferedTableItem instanceof BufferedGraphicTableItem))
			return null;
		else
			return ((BufferedGraphicTableItem)bufferedTableItem).getSize();
	}

	public int getWidth()
	{
		Point pt = null;
		if (bufferedTableItem instanceof BufferedGraphicTableItem)
		{
			pt = ((BufferedGraphicTableItem)bufferedTableItem).getSize();
		} else
		{
			Rectangle bounds = bufferedTableItem.getBounds();
			if (bounds != null)
				pt = new Point(bounds.width, bounds.height);
		}
		if (pt == null)
			return -1;
		else
			return pt.x;
	}

	public int getHeight()
	{
		Point pt = null;
		if (bufferedTableItem instanceof BufferedGraphicTableItem)
		{
			pt = ((BufferedGraphicTableItem)bufferedTableItem).getSize();
		} else
		{
			Rectangle bounds = bufferedTableItem.getBounds();
			if (bounds != null)
				pt = new Point(bounds.width, bounds.height);
		}