blindhelper.java

lumaQQ的源文件

	 * @return
	 * 		Group对象, 如果索引超出范围，返回null
	 */
	public Group getGroup(int index) {
		if(index < 0)
			return null;
		
		if(index == 0)
			return myFriendGroup;		
		
		index--;
		if(index < normalGroups.size())
			return normalGroups.get(index);
		
		index -= normalGroups.size();
		switch(index) {
			case 0:
				return strangerGroup;
			case 1:
				return blacklistGroup;
			case 2:
				return clusterGroup;
			case 3:
				return latestGroup;
			default:
				return null;
		}
	}
	
	/**
	 * 得到好友组，第0个好友组是我的好友组
	 * 
	 * @param index
	 * 		好友组索引
	 * @return
	 * 		Group
	 */
	public Group getFriendGroup(int index) {
		if(index < 0)
			return null;
		if(index == 0)
			return myFriendGroup;
		return normalGroups.get(index - 1);
	}
	
	/**
	 * @return
	 * 		需要上传的组数目
	 */
	public int getUploadGroupCount() {
		return normalGroups.size() + 1;
	}
	
	/**
	 * @return
	 * 		返回组总数
	 */
	public int getGroupCount() {
		return normalGroups.size() + 6;
	}
	
	/**
	 * 设置最近联系人组的可见性
	 * 
	 * @param b
	 * 		true表示可见
	 */
	public void setLatestGroupVisible(boolean b) {
		Blind blind = main.getBlind();
		QTreeViewer<Model> viewer = viewers.get(latestGroup);
		if(b)
			blind.showSlat(viewer.getQTree());
		else
			blind.hideSlat(viewer.getQTree());
	}
	
	/**
	 * 设置黑名单可见性
	 * 
	 * @param b
	 * 		true表示可见
	 */
	public void setBlacklistGroupVisible(boolean b) {
		Blind blind = main.getBlind();
		QTreeViewer<Model> viewer = viewers.get(blacklistGroup);
		if(isTreeMode()) 
			viewers.get(myFriendGroup).refresh();
		else {
			if(b)
				blind.showSlat(viewer.getQTree());
			else
				blind.hideSlat(viewer.getQTree());			
		}
	}
	
	/**
	 * 重设整个model
	 * 
	 * @param groupNames
	 * 		组名列表，不包括我的好友组
	 * @param friends
	 * 		所有下载项
	 */
	public void resetModel(List<String> groupNames, List<DownloadFriendEntry> friends) {	
		// 清除旧的数据
		ModelRegistry.clearGroup(myFriendGroup, false);
		ModelRegistry.clearGroup(clusterGroup, false);
		for(Group g : normalGroups)
			ModelRegistry.clearGroup(g, true);
		
		// 把旧的内容保存下来
		Map<Integer, User> oldUsers = new HashMap<Integer, User>();
		Map<Integer, Cluster> oldClusters = new HashMap<Integer, Cluster>();
		for(User u : myFriendGroup.users)
			oldUsers.put(u.qq, u);
		int size = clusterGroup.clusters.size();
		for(int i = size - 1; i >= 0; i--) {
			Cluster c = clusterGroup.clusters.get(i);
			if(c.clusterType == ClusterType.DIALOG_CONTAINER)
				continue;
			c.removeAllSubClusters();
			oldClusters.put(c.clusterId, c);	
		}
		for(Group g : normalGroups) {
			for(User u : g.users)
				oldUsers.put(u.qq, u);
			g.removeAllUsers();
		}
		normalGroups.clear();
		myFriendGroup.removeAllUsers();
		clusterGroup.removeAllCluster();
		
		// 创建新的组
		for(String name : groupNames) {
			Group g = new Group();
			g.name = name;
			g.expanded = false;
			normalGroups.add(g);
			ModelRegistry.addGroup(g);
		}
		
		// 添加新的组
		boolean showNick = main.getOptionHelper().isShowNick();
		size = getUploadGroupCount();
		List<DownloadFriendEntry> needInfos = new ArrayList<DownloadFriendEntry>();		
		for(DownloadFriendEntry entry : friends) {
			if(entry.isCluster()) {
				// 如果这个组存在，使用老对象，如果不存在，新建一个Cluster对象
				Cluster c = oldClusters.get(entry.qqNum);
				if(c == null) {
					needInfos.add(entry);
					c = new Cluster();
					c.clusterId = entry.qqNum;
					c.name = String.valueOf(entry.qqNum);
					c.headId = 1;
					c.clusterType = ClusterType.NORMAL;
					
					// 创建两个dummy，一个是群内组织，一个是讨论组
					Dummy orgDummy = new Dummy();
					orgDummy.dummyType = DummyType.CLUSTER_ORGANIZATION;
					orgDummy.name = cluster_organization;
					c.addDummy(orgDummy);
					Dummy subDummy = new Dummy();
					subDummy.dummyType = DummyType.SUBJECTS;
					subDummy.name = cluster_subject;
					c.addDummy(subDummy);
				}
				// 注册cluster
				clusterGroup.addCluster(c);
				ModelRegistry.addCluster(c);
			} else {
				if(entry.group >= size)
					entry.group = 0;
				
				User u = oldUsers.get(entry.qqNum);
				
				if(u == null) {
					needInfos.add(entry);
					u = new User();
					u.qq = entry.qqNum;
					u.nick = String.valueOf(u.qq);
					u.remark = main.getConfigHelper().getRemark(u.qq);
					u.displayName = showNick ? u.nick : ((u.remark == null) ? u.nick : u.remark.getName());
				} else {
					u.status = Status.OFFLINE;				
				}
				getFriendGroup(entry.group).addUser(u);
			}
		}
		
		// 添加多人对话
		Cluster dialogContainer = new Cluster();				
		dialogContainer.name = cluster_dialogs;
		dialogContainer.clusterType = ClusterType.DIALOG_CONTAINER;
		clusterGroup.addCluster(dialogContainer);
		ModelRegistry.addCluster(dialogContainer);
		
		// 刷新
		main.getDisplay().syncExec(new Runnable() {
			public void run() {		
				resetMode();
			}
		});
		
		// 得到新的model的信息
		for(DownloadFriendEntry dfe : needInfos) {
			if(dfe.isCluster() && dfe.qqNum != 0) {
				main.getClient().getClusterInfo(dfe.qqNum);
				main.getClient().getSubjectList(dfe.qqNum);
			} else
				main.getClient().getUserInfo(dfe.qqNum);
		}
		
		// 得到多人对话列表
		main.getClient().getDialogList();
		
		// 恢复图标的跳动和闪烁，然后关闭提示框
		main.getDisplay().syncExec(new Runnable() {
			public void run() {
			    resetAllImageEffect();
			}				
		});
	}
	
	/**
	 * 设置是否显示昵称
	 * 
	 * @param b
	 * 		true表示显示昵称
	 */
	public void setShowNick(boolean b) {
		// 刷新所有用户的显示名称
		for(Iterator<User> i = ModelRegistry.getUserIterator(); i.hasNext(); ) {
			User u = i.next();
			if(!u.group.isCluster())
				u.displayName = b ? u.nick : (u.hasRemarkName() ? u.getRemarkName() : u.nick); 
		}
		
		// 刷新群中所有成员的显示名称
		for(Iterator<Cluster> i = ModelRegistry.getClustetIterator(); i.hasNext(); ) {
			Cluster c = i.next();
			for(User u : c.members.values()) {
				User regUser = ModelRegistry.getUser(u.qq);
				if(regUser == null)
					regUser = u;
				u.displayName = u.hasCardName() ? u.cardName : 
					(b ? regUser.nick : 
						((regUser.hasRemarkName() ? regUser.getRemarkName() : regUser.nick)));
			}
		}
	}
	
	/**
	 * 设置是否只显示在线用户
	 * 
	 * @param b
	 * 		true表示只显示在线用户
	 */
	public void setShowOnlineOnly(boolean b) {
		for(Group g : viewers.keySet()) {
			if(!g.isLatest())
				viewers.get(g).setFilter(b ? onlineFilter : null);				
		}
	}
	
	/**
	 * @return
	 * 		当前的qtree viewer
	 */
	public QTreeViewer<Model> getCurrentViewer() {
		return getViewer(getCurrentGroup());
	}
	
	/**
	 * 刷新model，同时刷新链接到这个model的model
	 * 
	 * @param m
	 */
	public void refreshModel(Model m) {
    	QTreeViewer<Model> viewer = getViewer(m);
		viewer.refresh(m);    	
	}

	/**
	 * 在当前组的后面添加一个组，如果处于树形模式，则处理有点不一样
	 */
	public void addGroup() {
		Group g = new Group();
		g.name = "Input Group Name";
		g.groupType = GroupType.FRIEND_GROUP;
		g.expanded = false;
		ModelRegistry.addGroup(g);
		if(isTreeMode()) {
			normalGroups.add(g);
			viewers.put(g, viewers.get(myFriendGroup));
			refreshGroup(myFriendGroup);
			viewers.get(myFriendGroup).editText(g);
		} else {
			Blind blind = main.getBlind();
			int index = Math.min(normalGroups.size(), blind.getCurrentSlatIndex()) + 1;
			normalGroups.add(index - 1, g);
			
			OptionHelper options = main.getOptionHelper();
			MouseListener itemMouseListener = new ItemMouseListener(main);
			MouseTrackListener itemMouseTrackListener = new ItemMouseTrackListener(main);
			DropTargetListener groupDropTargetListener = new GroupDropTargetListener(main);
			DragSourceListener itemDragSourceListener = new ItemDragSourceListener();
			IQTreeListener qtreeListener = new DefaultQTreeListener(main);
			Transfer[] dummyTransfer = new Transfer[] { TextTransfer.getInstance() };
			QTreeViewer<Model> viewer = new QTreeViewer<Model>(blind);
			viewer.setContentProvider(new GroupContentProvider(g));
			viewer.setLabelProvider(ModelLabelProvider.INSTANCE);
			viewer.setSorter(ModelSorter.INSTANCE);
			viewer.setInput(this);
			viewer.addDragSupport(DND.DROP_MOVE, dummyTransfer, itemDragSourceListener);
			viewer.getQTree().addMouseListener(itemMouseListener);
			viewer.getQTree().addMouseTrackListener(itemMouseTrackListener);
			viewer.getQTree().addQTreeListener(qtreeListener);
			viewers.put(g, viewer);
			blind.addSlat(index, viewer.getQTree());
			blind.addSlatDropSupport(viewer.getQTree(), DND.DROP_MOVE, dummyTransfer, groupDropTargetListener);			
			changeViewerLayout(viewer, 0, options.isShowSmallHead() ? ItemLayout.HORIZONTAL : ItemLayout.VERTICAL);			
			Slat slat = blind.getSlat(index);
			slat.addSlatListener(new GroupNameChangedListener(main));
			slat.editText();
		}		
		main.setGroupDirty(true);
	}

	/**
	 * 删除当前组
	 * 
	 * @param g
	 * 		要删除的组对象
	 */
	public void removeGroup(Group g) {
		QTreeViewer<Model> viewer = viewers.remove(g);
		if(viewer == null)
			return;
		ModelRegistry.clearGroup(g, true);
		normalGroups.remove(g);
		Blind blind = main.getBlind();
		if(!isTreeMode())
			blind.removeSlat(viewer.getQTree());	
		refreshAll();
		main.setGroupDirty(true);
	}

	/**
	 * 添加一个Cluster对象
	 * 
	 * @param clusterId
	 * 		id
	 * @param creator
	 * 		true表示我是这个群的创建者
	 * @return
	 * 		创建的Cluster对象
	 */
	public Cluster addCluster(int clusterId, boolean creator) {
		// 找到群组的索引
		Cluster c = ModelRegistry.getCluster(clusterId);
		if(c == null) {
			// 新建一个群Model
			c = new Cluster();
			c.clusterId = clusterId;
			c.headId = 1;	
			// 设置creator
			if(creator)
				c.creator = main.getMyModel().qq;
			// 创建两个dummy，一个是群内组织，一个是讨论组
			Dummy orgDummy = new Dummy();
			orgDummy.dummyType = DummyType.CLUSTER_ORGANIZATION;
			orgDummy.name = cluster_organization;
			c.addDummy(orgDummy);
			Dummy subDummy = new Dummy();
			subDummy.dummyType = DummyType.SUBJECTS;
			subDummy.name = cluster_subject;
			c.addDummy(subDummy);
			// 添加这个model
			clusterGroup.addCluster(c);
			ModelRegistry.addCluster(c);
			refreshGroup(clusterGroup);
			// 如果我是创建者，则激活群
			if(creator)
			    main.getClient().activateCluster(clusterId);
			// 请求得到这个群的信息和成员列表
			main.getClient().getClusterInfo(clusterId);
			main.getClient().getSubjectList(clusterId);
		}			
		// 返回model
		return c;
	}

	/**
	 * 添加一个临时群
	 * 
	 * @param type
	 * @param clusterId
	 * @param parentClusterId
	 * @return
	 */
	public Cluster addTempCluster(byte type, int clusterId, int parentClusterId) {
		// 查找父群
		Cluster parent = ModelRegistry.getCluster(parentClusterId);
		if(parent == null)
			return null;
		// 找到群组的索引
		Cluster c = ModelRegistry.getCluster(clusterId);
		if(c == null) {
			// 新建一个群Model
			c = new Cluster();
			c.clusterId = clusterId;
			c.headId = 4;
			c.parentClusterId = parentClusterId;
			c.creator = main.getMyModel().qq;
			c.clusterType = ClusterType.valueOfTemp(type);
			// 添加这个model
			clusterGroup.addCluster(c);
			parent.addSubCluster(c);
			ModelRegistry.addCluster(c);
			refreshGroup(clusterGroup);
			// 请求得到这个群的信息和成员列表
			main.getClient().activateTempCluster(type, clusterId, parentClusterId);
			main.getClient().getTempClusterInfo(type, clusterId, parentClusterId);
		}			
		// 返回model
		return c;	
	}

	/**
	 * 删除一个群的model，如果存在这个群的相关窗口，也将关闭他们
	 * 
	 * @param clusterId
	 * 		群的内部ID
	 * @return
	 * 		成功则返回true
	 */
	public boolean removeCluster(int clusterId) {
	    ShellRegistry shellRegistry = main.getShellRegistry();
	    UIHelper uiHelper = main.getUIHelper();
	    
		// 找到群组
	    Cluster c = ModelRegistry.removeCluster(clusterId);
	    if(c == null || c.clusterType == DIALOG_CONTAINER)
	    	return false;	    

		// 删除群
	    clusterGroup.removeCluster(c);
	    if(c.clusterType != NORMAL) {
	    	Cluster parent = ModelRegistry.getCluster(c.parentClusterId);
	    	if(parent != null)
	    		parent.removeSubCluster(c);
	    }
	    refreshGroup(clusterGroup);
		// 关闭群相关窗口
		if(shellRegistry.hasClusterInfoWindow(c)) {
			shellRegistry.removeClusterInfoWindow(c).close();
		}
		if(shellRegistry.hasSendClusterIMWindow(c)) {
			shellRegistry.removeSendClusterIMWindow(c).close();
		}
		// 把这个群的消息从队列中删除
		main.getMessageQueue().removeMessage(clusterId);
		// 调整动画状态
		resetGroupImageEffect(clusterGroup);
		uiHelper.resetTrayImageEffect();
		// 返回true表示成功
		return true;
	}
	
	/**
	 * 添加一个好友的View part到blind控件中
	 * 
	 * @param qq
	 * 			好友QQ号
	 */
	public void addFriend(int qq) {
		// 首先查看是否已经有了这个好友，如果有了，返回
		User f = ModelRegistry.getUser(qq);
		if(f != null && f.isFriend())
			return;
		
		// 首先我们判断加入好友目的组的哈希表中是否有该项，如果有，则加入到指定的组
		// 如果没有或者指定的组已经不存在，加入到第一个好友组中
		if(addTo.containsKey(qq)) {
			Group g = addTo.remove(qq);
			addFriend(qq, g);
			return;
		}
		
		// 出一个窗口要用户选择一个组，然后把这个好友添加到用户选择的组中
		SelectGroupDialog sgd = new SelectGroupDialog(main.getShell());
		sgd.setModel(getFriendGroupList());
		Group g = sgd.open();
		if(g != null)
			addFriend(qq, g);
	}	
	
	/**
	 * 添加一个好友
	 * 
	 * @param qqNum 
	 * 			好友号码
	 * @param g
	 * 			要添加到的好友组Group
	 */
	public void addFriend(int qq, Group g) {
		boolean ani = false; 
		User f = ModelRegistry.getUser(qq);
		if(f == null) {
			/* 如果是null，那么还没有这个好友，添加之 */