listview.java

这是一个基于java编写的torrent的P2P源码

			public void run() {
				try {
					row_mon.enter();
					for (int i = 0; i < dataSources.length; i++) {
						Object datasource = dataSources[i];

						if (datasource == null
								|| mapDataSourceToRow.containsKey(datasource)) {
							continue;
						}

						int newPos = (pos >= 0) ? pos : rows.size();
						ListRow row = new ListRow(ListView.this, listComposite, newPos,
								datasource);
						rows.add(newPos, row);
						//System.out.println("addDS pos " + newPos);

						row.fixupPosition();

						mapDataSourceToRow.put(datasource, row);

						new selectionListener(row);

						triggerListenerRowAdded(row);
					}
				} finally {
					row_mon.exit();
					listComposite.layout();
					// SWT Bug on OSX with computeSize being higher than needed..
					Point point = listComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
					point.y = ListRow.ROW_HEIGHT * rows.size();
					sc.setMinSize(point);
					//sc.setMinSize(listComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT));
				}
				//System.out.println(Debug.getCompressedStackTrace());
			}
		});
	}

	public void removeDataSource(final Object datasource, boolean bImmediate) {
		Utils.execSWTThread(new Runnable() {
			public void run() {
				try {
					row_mon.enter();
					ListRow row = (ListRow) mapDataSourceToRow.remove(datasource);
					if (row != null) {
						// Delete row before removing in case delete(..) calls back a method
						// which needs rows.
						row.setSelected(false);
						row.setFocused(false);
						row.delete(false);
						rows.remove(row);

						triggerListenerRowRemoved(row);
					} else {
						//System.out.println("not found " + datasource);
					}
				} finally {
					row_mon.exit();
					// SWT Bug on OSX with computeSize being higher than needed..
					listComposite.layout();
					Point point = listComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
					point.y = ListRow.ROW_HEIGHT * rows.size();
					sc.setMinSize(point);
				}
			}
		});
	}

	public void removeAllDataSources(boolean bImmediate) {
		Utils.execSWTThread(new Runnable() {
			public void run() {

				row_mon.enter();

				try {
					for (Iterator iterator = mapDataSourceToRow.keySet().iterator(); iterator.hasNext();) {
						Object datasource = iterator.next();
						ListRow row = (ListRow) mapDataSourceToRow.get(datasource);

						if (row != null) {
							rows.remove(row);
							row.setSelected(false);
							row.setFocused(false);
							row.delete(false);
						}
					}

					mapDataSourceToRow.clear();
					rows.clear();
				} finally {
					row_mon.exit();
				}
			}
		}, !bImmediate);
	}

	private class selectionListener implements Listener
	{
		private final ListRow row;

		// XXX Copied from TableView!
		private TableCellMouseEvent createMouseEvent(TableCellCore cell, Event e,
				int type) {
			TableCellMouseEvent event = new TableCellMouseEvent();
			event.cell = cell;
			event.eventType = type;
			event.button = e.button;
			// TODO: Change to not use SWT masks
			event.keyboardState = e.stateMask;
			event.skipCoreFunctionality = false;
			Rectangle r = cell.getBounds();
			event.x = e.x - r.x;
			event.y = e.y - r.y;
			return event;
		}

		public selectionListener(ListRow row) {
			this.row = row;
			addListenerAndChildren(row.getComposite(), SWT.MouseDown, this);
			addListenerAndChildren(row.getComposite(), SWT.MouseUp, this);
			addListenerAndChildren(row.getComposite(), SWT.MouseDoubleClick, this);
			//addListenerAndChildren(row.getComposite(), SWT.Traverse, this);
			addListenerAndChildren(row.getComposite(), SWT.DefaultSelection, this);
			//addListenerAndChildren(row.getComposite(), SWT.FocusIn, this);
			//addListenerAndChildren(row.getComposite(), SWT.KeyDown, this);
		}

		public void handleEvent(Event e) {
			int mouseEventType = -1;
			switch (e.type) {
				case SWT.MouseDown: {
					mouseEventType = TableCellMouseEvent.EVENT_MOUSEDOWN;
					break;
				}

				case SWT.MouseDoubleClick: {
					mouseEventType = TableCellMouseEvent.EVENT_MOUSEDOUBLECLICK;
					break;
				}

				case SWT.MouseUp: {
					if ((e.stateMask & SWT.MOD1) > 0) { // control
						boolean select = !row.isSelected();
						row.setSelected(select);
						if (select) {
							row.setFocused(true);
						}
					} else if ((e.stateMask & SWT.MOD2) > 0) { // shift
						ListRow rowFocused = getRowFocused();
						if (rowFocused == null) {
							boolean select = !row.isSelected();
							row.setSelected(select);
							if (select) {
								row.setFocused(true);
							}
						} else {
							int idxStart = rowFocused.getIndex();
							int idxEnd = row.getIndex();

							if (idxEnd != idxStart) {
								int dir = idxStart < idxEnd ? 1 : -1;
								for (int i = idxStart; i != idxEnd; i += dir) {
									ListRow rowToSelect = getRow(i);
									if (rowToSelect != null) {
										rowToSelect.setSelected(true);
									}
								}

								ListRow rowToSelect = getRow(idxEnd);
								if (rowToSelect != null) {
									rowToSelect.setSelected(true);
									rowToSelect.setFocused(true);
								}
							}

						}
					} else {
						setSelectedRows(new ListRow[] { row
						});
					}
					if (listComposite.isDisposed()) {
						return;
					}
					listComposite.setFocus();
					mouseEventType = TableCellMouseEvent.EVENT_MOUSEUP;
					break;
				}

				case SWT.Traverse: {
					e.doit = true;
					System.out.println("Traverse: " + e.detail);
					break;
				}

				case SWT.DefaultSelection: {
					System.out.println("defaultse");
					break;
				}

				case SWT.FocusIn: {
					System.out.println("FI");
					row.setSelected(true);
					break;
				}
			}

			if (mouseEventType != -1) {
				TableCellCore cell = row.getTableCellCore(e.x, e.y);
				if (cell != null) {
					TableColumn tc = cell.getTableColumn();
					TableCellMouseEvent event = createMouseEvent(cell, e, mouseEventType);
					((TableColumnCore) tc).invokeCellMouseListeners(event);
					cell.invokeMouseListeners(event);
					if (event.skipCoreFunctionality) {
						lCancelSelectionTriggeredOn = System.currentTimeMillis();
					}
				}
			}

			if (e.type == SWT.DefaultSelection || e.type == SWT.MouseDoubleClick) {
				_runDefaultAction();
			}

			if (bMouseClickIsDefaultSelection && e.type == SWT.MouseUp) {
				_runDefaultAction();
			}
		}
	}

	private void addListenerAndChildren(Composite composite, int eventType,
			Listener listener) {
		composite.addListener(eventType, listener);

		Control[] children = composite.getChildren();
		for (int i = 0; i < children.length; i++) {
			Control child = children[i];
			child.addListener(eventType, listener);
			if (child instanceof Composite) {
				addListenerAndChildren((Composite) child, eventType, listener);
			}
		}
	}

	public int indexOf(ListRow row) {
		return rows.indexOf(row);
	}

	public int size(boolean bIncludeQueue) {
		int size = rows.size();

		if (bIncludeQueue) {
			if (dataSourcesToAdd != null) {
				size += dataSourcesToAdd.size();
			}
			if (dataSourcesToRemove != null) {
				size += dataSourcesToRemove.size();
			}
		}
		return size;
	}

	public ListRow getRow(int i) {
		if (i < 0 || i >= rows.size()) {
			return null;
		}
		return (ListRow) rows.get(i);
	}

	/**
	 * Get the row associated with a datasource
	 * @param dataSource a reference to a core Datasource object 
	 * 										(not a plugin datasource object)
	 * @return The row, or null
	 */
	public ListRow getRow(Object dataSource) {
		return (ListRow) mapDataSourceToRow.get(dataSource);
	}

	public boolean dataSourceExists(Object dataSource) {
		return mapDataSourceToRow.containsKey(dataSource)
				|| dataSourcesToAdd.contains(dataSource);
	}

	public SWTSkinProperties getSkinProperties() {
		return skinProperties;
	}

	public TableColumnCore[] getVisibleColumns() {
		if (visibleColumns == null) {
			return new TableColumnCore[0];
		}

		return visibleColumns;
	}

	public void updateColumnList(TableColumnCore[] columns,
			String defaultSortColumnID) {
		// XXX Adding Columns only has to be done once per TableID.  
		// Doing it more than once won't harm anything, but it's a waste.
		TableColumnManager tcManager = TableColumnManager.getInstance();
		if (tcManager.getTableColumnCount(sTableID) != columns.length) {
			for (int i = 0; i < columns.length; i++) {
				columns[i].setTableID(sTableID);
				tcManager.addColumn(columns[i]);
			}
		}

		// fixup order
		tcManager.ensureIntegrety(sTableID);

		allColumns = columns;
		//visibleColumns = tcManager.getAllTableColumnCoreAsArray(sTableID);

		ArrayList visibleColumnsList = new ArrayList();
		for (int i = 0; i < columns.length; i++) {
			if (columns[i].getPosition() >= 0) {
				visibleColumnsList.add(columns[i]);
			}
		}
		visibleColumns = (TableColumnCore[]) visibleColumnsList.toArray(new TableColumnCore[0]);
		// TODO: Refresh all rows

		// Initialize the sorter after the columns have been added
		String sSortColumn = defaultSortColumnID;
		boolean bSortAscending = false;
		// For now, set to default column, until we have a way to select sorting
		// on a non-visible column
		//configMan.getStringParameter(sTableID + ".sortColumn", defaultSortColumnID);
		//int iSortDirection = configMan.getIntParameter(CFG_SORTDIRECTION);
		//boolean bSortAscending = configMan.getBooleanParameter(sTableID
				//+ ".sortAsc", iSortDirection == 1 ? false : true);

		TableColumnCore tc = tcManager.getTableColumnCore(sTableID, sSortColumn);
		if (tc == null) {
			tc = visibleColumns[0];
		}
		sortColumn = tc;
		sortColumn.setSortAscending(bSortAscending);
		changeColumnIndicator();
	}

	/**
	 * 
	 */
	private void changeColumnIndicator() {
		if (headerArea != null && !headerArea.isDisposed()) {
			headerArea.redraw();
		}
	}

	public ListRow[] getSelectedRows() {
		selectedRows_mon.enter();
		try {
			ListRow[] rows = new ListRow[selectedRows.size()];
			rows = (ListRow[]) selectedRows.toArray(rows);
			return rows;
		} finally {
			selectedRows_mon.exit();
		}
	}

	public void setSelectedRows(ListRow[] rows) {
		selectedRows_mon.enter();
		try {
			ArrayList rowsToSelect = new ArrayList();
			for (int i = 0; i < rows.length; i++) {
				rowsToSelect.add(rows[i]);
			}
			ListRow[] selectedRows = getSelectedRows();

			// unselect already selected rows that aren't going to be selected anymore
			for (int i = 0; i < selectedRows.length; i++) {
				ListRow selectedRow = selectedRows[i];
				boolean bStillSelected = false;
				for (int j = 0; j < rows.length; j++) {
					ListRow row = rows[j];
					if (row.equals(selectedRow)) {
						bStillSelected = true;
						break;
					}
				}
				if (!bStillSelected) {
					selectedRow.setSelected(false);
				} else {
					rowsToSelect.remove(selectedRow);
				}
			}

			for (Iterator iter = rowsToSelect.iterator(); iter.hasNext();) {
				ListRow row = (ListRow) iter.next();
				row.setSelected(true);
			}

			if (rows.length > 0) {
				rows[0].setFocused(true);
			}
		} finally {
			selectedRows_mon.exit();
		}
	}

	/**
	 * XXX DO NOT CALL FROM LISTVIEW!
	 * 
	 * Adds row to selection list
	 */
	protected void rowSetSelected(ListRow row, boolean bSelected) {
		if (row == null || (selectedRows.indexOf(row) >= 0) == bSelected) {
			return;
		}
		selectedRows_mon.enter();
		try {
			if (bSelected) {
				selectedRows.add(row);
			} else {
				selectedRows.remove(row);
			}
		} finally {
			selectedRows_mon.exit();
		}

		for (Iterator iter = listenersSelection.iterator(); iter.hasNext();) {
			ListSelectionAdapter l = (ListSelectionAdapter) iter.next();
			try {
				if (bSelected) {
					l.selected(row);
				} else {
					l.deselected(row);
				}
			} catch (Exception e) {
				Debug.out(e);
			}
		}
	}

	public ListRow getRowFocused() {
		return rowFocused;
	}

	protected void rowSetFocused(ListRow row) {
		rowFocused = row;

		if (row != null) {
			rowShow(row);
		}

		for (Iterator iter = listenersSelection.iterator(); iter.hasNext();) {
			ListSelectionAdapter l = (ListSelectionAdapter) iter.next();
			try {
				l.focusChanged(row);
			} catch (Exception e) {
				Debug.out(e);
			}
		}
	}

	public boolean rowIsSelected(ListRow row) {
		selectedRows_mon.enter();
		return selectedRows.indexOf(row) >= 0;
	}

	public void rowShow(ListRow row) {
		// move into view
		if (row == null) {
			return;
		}

		Control child = row.getComposite();