tablecolumnmanager.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:   TableColumnManager.java

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

import com.aelitis.azureus.ui.common.table.TableColumnCore;
import com.aelitis.azureus.ui.common.table.impl.TableColumnImpl;
import java.io.PrintStream;
import java.util.*;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.util.*;
import org.gudy.azureus2.plugins.download.*;
import org.gudy.azureus2.plugins.ui.tables.*;
import org.gudy.azureus2.ui.swt.views.table.TableColumnCoreCreationListener;

// Referenced classes of package org.gudy.azureus2.ui.swt.views.table.utils:
//			CoreTableColumn, TableColumnInfoImpl

public class TableColumnManager
{

	private static final String CONFIG_FILE = "tables.config";
	private static TableColumnManager instance;
	private static AEMonitor class_mon = new AEMonitor("TableColumnManager");
	private Map items;
	private AEMonitor items_mon;
	private Map autoHideOrder;
	private Map mapTablesConfig;
	private static Comparator orderComparator = new Comparator() {

		public int compare(Object arg0, Object arg1)
		{
			if ((arg1 instanceof TableColumn) && (arg0 instanceof TableColumn))
			{
				int iPositionA = ((TableColumn)arg0).getPosition();
				if (iPositionA < 0)
					iPositionA = 65535 + iPositionA;
				int iPositionB = ((TableColumn)arg1).getPosition();
				if (iPositionB < 0)
					iPositionB = 65535 + iPositionB;
				return iPositionA - iPositionB;
			} else
			{
				return 0;
			}
		}

	};
	private Map mapColumnIDsToListener;
	private Map mapDataSourceTypeToColumnIDs;

	private TableColumnManager()
	{
		items_mon = new AEMonitor("TableColumnManager:items");
		autoHideOrder = new LightHashMap();
		mapColumnIDsToListener = new LightHashMap();
		mapDataSourceTypeToColumnIDs = new LightHashMap();
		items = new HashMap();
	}

	public static TableColumnManager getInstance()
	{
		TableColumnManager tablecolumnmanager;
		class_mon.enter();
		if (instance == null)
			instance = new TableColumnManager();
		tablecolumnmanager = instance;
		class_mon.exit();
		return tablecolumnmanager;
		Exception exception;
		exception;
		class_mon.exit();
		throw exception;
	}

	public void addColumns(TableColumnCore itemsToAdd[])
	{
		items_mon.enter();
		for (int i = 0; i < itemsToAdd.length; i++)
		{
			TableColumnCore item = itemsToAdd[i];
			if (item.isRemoved())
				continue;
			String name = item.getName();
			String sTableID = item.getTableID();
			Map mTypes = (Map)items.get(sTableID);
			if (mTypes == null)
			{
				mTypes = new LinkedHashMap();
				items.put(sTableID, mTypes);
			}
			if (!mTypes.containsKey(name))
			{
				mTypes.put(name, item);
				Map mapColumnConfig = getTableConfigMap(sTableID);
				item.loadSettings(mapColumnConfig);
			}
			if (!item.getColumnAdded())
				item.setColumnAdded(true);
		}

		items_mon.exit();
		break MISSING_BLOCK_LABEL_197;
		Exception e;
		e;
		System.out.println("Error while adding Table Column Extension");
		Debug.printStackTrace(e);
		items_mon.exit();
		break MISSING_BLOCK_LABEL_197;
		Exception exception;
		exception;
		items_mon.exit();
		throw exception;
	}

	public void removeColumns(TableColumnCore itemsToRemove[])
	{
		items_mon.enter();
		for (int i = 0; i < itemsToRemove.length; i++)
		{
			TableColumnCore item = itemsToRemove[i];
			String name = item.getName();
			String sTableID = item.getTableID();
			Map mTypes = (Map)items.get(sTableID);
			if (mTypes != null)
				if (mTypes.remove(name) == null);
		}

		items_mon.exit();
		break MISSING_BLOCK_LABEL_119;
		Exception e;
		e;
		System.out.println("Error while adding Table Column Extension");
		Debug.printStackTrace(e);
		items_mon.exit();
		break MISSING_BLOCK_LABEL_119;
		Exception exception;
		exception;
		items_mon.exit();
		throw exception;
	}

	public Map getTableColumnsAsMap(Class forDataSourceType, String sTableID)
	{
		Map map;
		items_mon.enter();
		Map mReturn = new LinkedHashMap();
		Map mTypes = getAllTableColumnCore(forDataSourceType, sTableID);
		if (mTypes != null)
			mReturn.putAll(mTypes);
		map = mReturn;
		items_mon.exit();
		return map;
		Exception exception;
		exception;
		items_mon.exit();
		throw exception;
	}

	public int getTableColumnCount(String sTableID)
	{
		Map mTypes = (Map)items.get(sTableID);
		if (mTypes == null)
			return 0;
		else
			return mTypes.size();
	}

	public TableColumnCore[] getAllTableColumnCoreAsArray(Class forDataSourceType, String tableID)
	{
		Map mTypes = getAllTableColumnCore(forDataSourceType, tableID);
		return (TableColumnCore[])(TableColumnCore[])mTypes.values().toArray(new TableColumnCore[mTypes.values().size()]);
	}

	private Map getAllTableColumnCore(Class forDataSourceType, String tableID)
	{
		Map mTypes = null;
		items_mon.enter();
		mTypes = (Map)items.get(tableID);
		if (mTypes == null)
		{
			mTypes = new LinkedHashMap();
			items.put(tableID, mTypes);
		}
		if (forDataSourceType != null)
		{
			List listDST = (List)mapDataSourceTypeToColumnIDs.get(forDataSourceType);
			if (listDST != null)
				doAddCreate(mTypes, forDataSourceType, tableID, listDST);
			if (forDataSourceType.equals(org/gudy/azureus2/plugins/download/DownloadTypeComplete) || forDataSourceType.equals(org/gudy/azureus2/plugins/download/DownloadTypeIncomplete))
			{
				listDST = (List)mapDataSourceTypeToColumnIDs.get(org/gudy/azureus2/plugins/download/Download);
				if (listDST != null && listDST.size() > 0)
					doAddCreate(mTypes, org/gudy/azureus2/plugins/download/Download, tableID, listDST);
			} else
			if (org/gudy/azureus2/plugins/download/Download.equals(forDataSourceType))
			{
				listDST = (List)mapDataSourceTypeToColumnIDs.get(org/gudy/azureus2/plugins/download/DownloadTypeComplete);
				if (listDST != null && listDST.size() > 0)
					doAddCreate(mTypes, org/gudy/azureus2/plugins/download/DownloadTypeComplete, tableID, listDST);
				listDST = (List)mapDataSourceTypeToColumnIDs.get(org/gudy/azureus2/plugins/download/DownloadTypeIncomplete);
				if (listDST != null && listDST.size() > 0)
					doAddCreate(mTypes, org/gudy/azureus2/plugins/download/DownloadTypeIncomplete, tableID, listDST);
			}
		}
		items_mon.exit();
		break MISSING_BLOCK_LABEL_264;
		Exception exception;
		exception;
		items_mon.exit();
		throw exception;
		return mTypes;
	}

	private void doAddCreate(Map mTypes, Class forDataSourceType, String tableID, List listDST)
	{
		Iterator iter = listDST.iterator();
		do
		{
			if (!iter.hasNext())
				break;
			String columnID = (String)iter.next();
			if (!mTypes.containsKey(columnID))
				try
				{
					TableColumnCreationListener l = (TableColumnCreationListener)mapColumnIDsToListener.get((new StringBuilder()).append(forDataSourceType).append(".").append(columnID).toString());
					TableColumnCore tc = null;
					if (l instanceof TableColumnCoreCreationListener)
						tc = ((TableColumnCoreCreationListener)l).createTableColumnCore(forDataSourceType, tableID, columnID);
					if (tc == null)
						tc = new TableColumnImpl(forDataSourceType, tableID, columnID);
					l.tableColumnCreated(tc);
					addColumns(new TableColumnCore[] {
						tc
					});
				}
				catch (Exception e)
				{
					Debug.out(e);
				}
		} while (true);
	}

	public String[] getTableIDs()
	{
		String as[];
		items_mon.enter();
		Set ids = items.keySet();
		as = (String[])ids.toArray(new String[ids.size()]);
		items_mon.exit();
		return as;
		Exception exception;
		exception;
		items_mon.exit();
		throw exception;
	}

	public String[] appendLists(String list1[], String list2[])
	{
		int size = list1.length + list2.length;
		String list[] = new String[size];
		System.arraycopy(list1, 0, list, 0, list1.length);
		System.arraycopy(list2, 0, list, list1.length, list2.length);
		return list;
	}

	public TableColumnCore getTableColumnCore(String sTableID, String sColumnName)
	{
		Map mTypes = (Map)items.get(sTableID);
		if (mTypes == null)
			return null;
		else
			return (TableColumnCore)mTypes.get(sColumnName);
	}

	public void ensureIntegrety(String sTableID)
	{
		Map mTypes = (Map)items.get(sTableID);
		if (mTypes == null)
			return;
		TableColumnCore tableColumns[] = (TableColumnCore[])(TableColumnCore[])mTypes.values().toArray(new TableColumnCore[mTypes.values().size()]);
		Arrays.sort(tableColumns, getTableColumnOrderComparator());
		int iPos = 0;
		for (int i = 0; i < tableColumns.length; i++)
		{
			int iCurPos = tableColumns[i].getPosition();
			if (iCurPos == -1)
				tableColumns[i].setVisible(false);
			else
				tableColumns[i].setPositionNoShift(iPos++);
		}

	}

	public String getDefaultSortColumnName(String tableID)
	{
		Map mapTableConfig = getTableConfigMap(tableID);
		Object object = mapTableConfig.get("SortColumn");
		if (object instanceof byte[])
			object = new String((byte[])(byte[])object);
		if (object instanceof String)
			return (String)object;
		String s = COConfigurationManager.getStringParameter((new StringBuilder()).append(tableID).append(".sortColumn").toString());
		if (s != null)
		{
			COConfigurationManager.removeParameter((new StringBuilder()).append(tableID).append(".sortColumn").toString());
			COConfigurationManager.removeParameter((new StringBuilder()).append(tableID).append(".sortAsc").toString());
		}
		return s;
	}

	public void setDefaultSortColumnName(String tableID, String columnName)
	{
		Map mapTableConfig = getTableConfigMap(tableID);
		mapTableConfig.put("SortColumn", columnName);
		saveTableConfigs();
	}

	private void saveTableConfigs()
	{
		if (mapTablesConfig != null)
			FileUtil.writeResilientConfigFile("tables.config", mapTablesConfig);
	}

	public void saveTableColumns(Class forDataSourceType, String sTableID)
	{
		try
		{
			Map mapTableConfig = getTableConfigMap(sTableID);
			TableColumnCore tcs[] = getAllTableColumnCoreAsArray(forDataSourceType, sTableID);
			for (int i = 0; i < tcs.length; i++)
				if (tcs[i] != null)
					tcs[i].saveSettings(mapTableConfig);

			saveTableConfigs();
		}
		catch (Exception e)
		{
			Debug.out(e);
		}
	}

	public boolean loadTableColumnSettings(Class forDataSourceType, String sTableID)
	{
		Map mapTableConfig;
		int size;
		mapTableConfig = getTableConfigMap(sTableID);
		size = mapTableConfig.size();
		if (size == 0 || size == 1 && mapTableConfig.containsKey("SortColumn"))
			return false;
		try
		{
			TableColumnCore tcs[] = getAllTableColumnCoreAsArray(forDataSourceType, sTableID);
			for (int i = 0; i < tcs.length; i++)
				if (tcs[i] != null)
					tcs[i].loadSettings(mapTableConfig);

		}
		catch (Exception e)
		{
			Debug.out(e);
		}
		return true;
	}

	public Map getTableConfigMap(String sTableID)
	{
		TableColumnManager tablecolumnmanager = this;
		JVM INSTR monitorenter ;
		Map mapTableConfig;
		if (mapTablesConfig == null)
		{
			mapTablesConfig = FileUtil.readResilientConfigFile("tables.config");
			SimpleTimer.addEvent("DisposeTbaleConfigMap", SystemTime.getOffsetTime(30000L), new TimerEventPerformer() {

				final TableColumnManager this$0;

				public void perform(TimerEvent event)
				{
					synchronized (this)
					{
						saveTableConfigs();
						mapTablesConfig = null;
					}
				}

			
			{
				this$0 = TableColumnManager.this;
				super();
			}
			});
		}
		mapTableConfig = (Map)mapTablesConfig.get((new StringBuilder()).append("Table.").append(sTableID).toString());
		if (mapTableConfig == null)
		{
			mapTableConfig = new HashMap();
			mapTablesConfig.put((new StringBuilder()).append("Table.").append(sTableID).toString(), mapTableConfig);
		}
		return mapTableConfig;
		Exception exception;
		exception;
		throw exception;
	}

	public void setAutoHideOrder(String sTableID, String autoHideOrderColumnIDs[])
	{
		ArrayList autoHideOrderList = new ArrayList(autoHideOrderColumnIDs.length);
		for (int i = 0; i < autoHideOrderColumnIDs.length; i++)
		{
			String sColumnID = autoHideOrderColumnIDs[i];
			TableColumnCore column = getTableColumnCore(sTableID, sColumnID);
			if (column != null)
				autoHideOrderList.add(column);
		}

		autoHideOrder.put(sTableID, autoHideOrderList);
	}

	public List getAutoHideOrder(String sTableID)
	{
		List list = (List)autoHideOrder.get(sTableID);
		if (list == null)
			return Collections.EMPTY_LIST;
		else
			return list;
	}

	public void generateDiagnostics(IndentWriter writer)
	{
		items_mon.enter();
		writer.println("TableColumns");
		for (Iterator iter = items.keySet().iterator(); iter.hasNext(); writer.exdent())
		{
			String sTableID = (String)iter.next();
			Map mTypes = (Map)items.get(sTableID);
			writer.indent();
			writer.println((new StringBuilder()).append(sTableID).append(": ").append(mTypes.size()).append(" columns:").toString());
			writer.indent();
			TableColumnCore tc;
			for (Iterator iter2 = mTypes.values().iterator(); iter2.hasNext(); tc.generateDiagnostics(writer))
				tc = (TableColumnCore)iter2.next();

			writer.exdent();
		}

		items_mon.exit();
		break MISSING_BLOCK_LABEL_203;
		Exception e;
		e;
		e.printStackTrace();
		items_mon.exit();
		break MISSING_BLOCK_LABEL_203;
		Exception exception;
		exception;
		items_mon.exit();
		throw exception;
	}

	public static Comparator getTableColumnOrderComparator()
	{
		return orderComparator;
	}

	public void registerColumn(Class forDataSourceType, String columnID, TableColumnCreationListener listener)
	{
		mapColumnIDsToListener.put((new StringBuilder()).append(forDataSourceType).append(".").append(columnID).toString(), listener);
		List list = (List)mapDataSourceTypeToColumnIDs.get(forDataSourceType);
		if (list == null)
		{
			list = new ArrayList(1);
			mapDataSourceTypeToColumnIDs.put(forDataSourceType, list);
		}
		list.add(columnID);
	}

	public void unregisterColumn(Class forDataSourceType, String columnID, TableColumnCreationListener listener)
	{
		mapColumnIDsToListener.remove((new StringBuilder()).append(forDataSourceType).append(".").append(columnID).toString());
		List list = (List)mapDataSourceTypeToColumnIDs.get(forDataSourceType);
		if (list != null)
			list.remove(columnID);
	}

	public TableColumnInfo getColumnInfo(Class forDataSourceType, String forTableID, String columnID)
	{
		TableColumnCore column = getTableColumnCore(forTableID, columnID);
		TableColumnInfoImpl columnInfo = new TableColumnInfoImpl(column);
		List listeners = column.getColumnExtraInfoListeners();
		TableColumnExtraInfoListener l;
		for (Iterator i$ = listeners.iterator(); i$.hasNext(); l.fillTableColumnInfo(columnInfo))
			l = (TableColumnExtraInfoListener)i$.next();

		if (columnInfo.getCategories() == null && !(column instanceof CoreTableColumn))
			columnInfo.addCategories(new String[] {
				"plugin"
			});
		return columnInfo;
	}



}