blindhelper.java

lumaQQ的源文件

		});
		
		MouseListener slatMouseListener = new MouseAdapter() {
			@Override
			public void mouseUp(MouseEvent e) {
				/*
				 * 点击我的好友组时，收起或者恢复展开状态，但是如果
				 * 我的好友组不是当前组，则不应该执行以下代码
				 */
				if(main.getBlind().getPreviousSlat() == 0) {
					QTreeViewer<Model> viewer = getViewer(myFriendGroup);
					if(viewer.isAllRootCollapsed())
						viewer.restoreExpandStatus();
					else {
						viewer.saveExpandStatus();
						viewer.getQTree().goTop();
						viewer.collapseAll();					
					}					
				}
			}
		};
		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 FriendTreeModeContentProvider(main));
		viewer.setLabelProvider(ModelLabelProvider.INSTANCE);
		viewer.setSorter(ModelSorter.INSTANCE);
		viewer.setInput(this);
		viewer.addDragSupport(DND.DROP_MOVE, dummyTransfer, itemDragSourceListener);
		viewer.addDropSupport(DND.DROP_MOVE, dummyTransfer, groupDropTargetListener);
		viewer.getQTree().addMouseListener(itemMouseListener);
		viewer.getQTree().addMouseTrackListener(itemMouseTrackListener);
		viewer.getQTree().addQTreeListener(qtreeListener);
		viewers.put(myFriendGroup, viewer);
		viewers.put(blacklistGroup, viewer);
		viewers.put(strangerGroup, viewer);
		for(Group g : normalGroups)
			viewers.put(g, viewer);
		blind.addSlat(viewer.getQTree());
		blind.addSlatDropSupport(viewer.getQTree(), DND.DROP_MOVE, dummyTransfer, groupDropTargetListener);
		blind.getSlat(0).addMouseListener(slatMouseListener);
		
		// 群组
		viewer = new QTreeViewer<Model>(blind);
		viewer.setContentProvider(new GroupContentProvider(clusterGroup));
		viewer.setLabelProvider(ModelLabelProvider.INSTANCE);
		viewer.setSorter(ModelSorter.INSTANCE);
		viewer.setInput(this);
		viewer.addDragSupport(DND.DROP_MOVE, dummyTransfer, new ClusterDragSourceListener());
		viewer.addDropSupport(DND.DROP_MOVE, dummyTransfer, new ClusterDropTargetListener(main));
		viewer.getQTree().addMouseListener(itemMouseListener);
		viewer.getQTree().addMouseTrackListener(itemMouseTrackListener);
		viewer.getQTree().addQTreeListener(qtreeListener);
		viewers.put(clusterGroup, viewer);
		blind.addSlat(viewer.getQTree());
		
		// 最近联系人组
		viewer = new QTreeViewer<Model>(blind);
		viewer.setContentProvider(new GroupContentProvider(latestGroup));
		viewer.setLabelProvider(ModelLabelProvider.INSTANCE);
		viewer.setSorter(LatestSorter.INSTANCE);
		viewer.setInput(this);
		viewer.addDragSupport(DND.DROP_MOVE, dummyTransfer, itemDragSourceListener);
		viewer.getQTree().addMouseListener(itemMouseListener);
		viewer.getQTree().addMouseTrackListener(itemMouseTrackListener);
		viewers.put(latestGroup, viewer);
		blind.addSlat(viewer.getQTree());
	}	
	
	/**
	 * 初始化model
	 */
	@SuppressWarnings("unchecked")
	public void initModels() {
		main.getBlind().removeAll();
		viewers.clear();
		ModelRegistry.clearAll();
		normalGroups.clear();
		// 初始化，载入分组文件
		ConfigHelper configHelper = main.getConfigHelper();
		File groupFile = new File(LumaQQ.GROUPS);
		if(!configHelper.checkGroupFile(groupFile))
			return;
		XGroups groups = GroupUtil.load(groupFile);
		if(groups == null)
			return;
		
		Group g = null;
		
		for(XGroup group : (List<XGroup>)groups.getGroup()) {
			// 创建Group
			GroupType groupType = GroupType.valueOf(group.getType()); 
			switch(groupType) {
				case BLACKLIST_GROUP:
					blacklistGroup = ModelUtils.createGroup(group);
					g = blacklistGroup;
					break;
				case CLUSTER_GROUP:
					clusterGroup = ModelUtils.createGroup(group);
					g = clusterGroup;
					break;
				case DEFAULT_FRIEND_GROUP:
					myFriendGroup = ModelUtils.createGroup(group);
					g = myFriendGroup;
					break;
				case FRIEND_GROUP:
					g = ModelUtils.createGroup(group);
					normalGroups.add(g);
					break;
				case LATEST_GROUP:
					latestGroup = ModelUtils.createGroup(group);
					g = latestGroup;
					break;
				case STRANGER_GROUP:
					strangerGroup = ModelUtils.createGroup(group);
					g = strangerGroup;
					break;
			}
			
			if(g == null)
				continue;
			
			g.groupType = groupType;
			
			// 创建User或者Cluster
			if(g == clusterGroup) {
				// 添加一个多人对话容器
				Cluster dialogContainer = new Cluster();				
				dialogContainer.name = cluster_dialogs;
				dialogContainer.clusterType = ClusterType.DIALOG_CONTAINER;
				g.addCluster(dialogContainer);
				ModelRegistry.addCluster(dialogContainer);
				
				// 添加其他群
				List<Cluster> subClusters = new ArrayList<Cluster>();				
				for(XCluster cluster : (List<XCluster>)group.getCluster()) {
					Cluster c = ModelUtils.createCluster(cluster);
					g.addCluster(c);
					ModelRegistry.addCluster(c);
					
					// 创建Cluster中的member
					for(XUser user : (List<XUser>)cluster.getUser()) {
						if(user.getQq() == 0)
							continue;
						User u = ModelUtils.createUser(user);
					    u.remark = main.getConfigHelper().getRemark(u.qq);
						if(u.hasCardName())
							u.displayName = u.cardName;
						c.addMember(u);
					}
					
					if(c.isPermanent()) {
						// 创建两个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);
					} else {
						subClusters.add(c);
					}
					
					// 添加群中的组织
					for(XOrganization org : (List<XOrganization>)cluster.getOrganization()) {
						Organization o = ModelUtils.createOrganization(org);
						c.addOrganization(o);
					}
				}
				
				// 建立父子群关系，如果父群是null，则为多人对话
				for(Cluster c : subClusters) {
					Cluster parent = c.getParentCluster();
					if(parent == null)
						dialogContainer.addSubCluster(c);
					else
						parent.addSubCluster(c);
				}
			} else if(g == latestGroup) {
				for(XUser user : (List<XUser>)group.getUser()) {
					if(user.getQq() == 0)
						continue;
					User u = ModelUtils.createUser(user);
					u.remark = main.getConfigHelper().getRemark(u.qq);
					g.addUser(u);
				}
				for(XCluster cluster : (List<XCluster>)group.getCluster()) {
					Cluster c = ModelUtils.createCluster(cluster);
					g.addCluster(c);
				}
			} else {
				// 创建用户
				for(XUser user : (List<XUser>)group.getUser()) {
					User u = ModelUtils.createUser(user);
					u.remark = main.getConfigHelper().getRemark(u.qq);
					g.addUser(u);
				}
			}
		}
	}

	/**
	 * 重设blind显示模式 
	 */
	private void resetMode() {
		main.getBlind().removeAll();
		viewers.clear();
		OptionHelper options = main.getOptionHelper();
		setShowSignature(options.isShowSignature());
		setShowCustomHead(options.isShowCustomHead());
		if(isTreeMode())
			initTreeMode();
		else
			initTraditionalMode();
		
		setShowOnlineOnly(options.isShowOnlineOnly());
		setShowNick(options.isShowNick());
		setShowSmallHead(options.isShowSmallHead());
		setBackground(main.getGroupColor());
		setLatestGroupVisible(options.isEnableLatest());
		setBlacklistGroupVisible(options.isShowBlacklist());
	}

	/**
	 * 修改当前slat的文本 
	 */
	public void editCurrentSlatText() {
		Blind blind = main.getBlind();
		Slat slat = blind.getCurrentSlat();
		if(slat != null)
			slat.editText();
	}
	
	/**
	 * @return
	 * 		所有好友组列表
	 */
	public List<Group> getFriendGroupList() {
		List<Group> ret = new ArrayList<Group>();
		ret.add(myFriendGroup);
		ret.addAll(normalGroups);
		return ret;
	}
	
	/**
	 * @return
	 * 		所有用户组列表，也就是除了群组之外的所有组
	 */
	public List<Group> getUserGroupList() {
		List<Group> ret = new ArrayList<Group>();
		ret.add(myFriendGroup);
		ret.addAll(normalGroups);
		ret.add(strangerGroup);
		ret.add(blacklistGroup);
		return ret;
	}
	
	/**
	 * @return
	 * 		能够接收短消息的组
	 */
	public List<Group> getSMSReceivableGroupList() {
		List<Group> ret = new ArrayList<Group>();
		ret.add(myFriendGroup);
		ret.addAll(normalGroups);
		ret.add(strangerGroup);
		ret.add(blacklistGroup);
		return ret;
	}
	
	/**
	 * @return
	 * 		所有需要导出记录的组列表
	 */
	public List<Group> getExportGroupList() {
		List<Group> ret = new ArrayList<Group>();
		ret.add(myFriendGroup);
		ret.addAll(normalGroups);
		ret.add(strangerGroup);
		ret.add(clusterGroup);
		return ret;
	}
	
	/**
	 * @return Returns the treeMode.
	 */
	public boolean isTreeMode() {
		return main.getOptionHelper().isTreeMode();
	}

	/**
	 * @param treeMode The treeMode to set.
	 */
	public void setTreeMode(boolean treeMode) {
		resetMode();
	}

	/**
	 * @return Returns the myFriendGroup.
	 */
	public Group getMyFriendGroup() {
		return myFriendGroup;
	}

	/**
	 * @return Returns the clusterGroup.
	 */
	public Group getClusterGroup() {
		return clusterGroup;
	}

	/**
	 * @return Returns the latestGroup.
	 */
	public Group getLatestGroup() {
		return latestGroup;
	}

	/**
	 * @return Returns the normalGroups.
	 */
	public List<Group> getNormalGroups() {
		return normalGroups;
	}

	/**
	 * @return Returns the blacklistGroup.
	 */
	public Group getBlacklistGroup() {
		return blacklistGroup;
	}

	/**
	 * @return Returns the strangerGroup.
	 */
	public Group getStrangerGroup() {
		return strangerGroup;
	}
	
	/**
	 * 添加一个XGroup元素
	 * 
	 * @param groups
	 * 		XGroups
	 * @param g
	 * 		Group
	 */
	@SuppressWarnings("unchecked")
	private void addXGroup(XGroups groups, Group g) {
		XGroup group = ModelUtils.createXGroup(g);
		groups.getGroup().add(group);
		switch(g.groupType) {
			case CLUSTER_GROUP:
				for(Cluster c : g.clusters) {				
					// 不需要保存多人对话容器
					if(c.clusterType != DIALOG_CONTAINER) {
						XCluster cluster = ModelUtils.createXCluster(c);
						group.getCluster().add(cluster);
						
						for(User u : c.members.values()) {
							XUser user = ModelUtils.createXUser(u);
							cluster.getUser().add(user);
						}					
						
						for(Organization o : c.organizations.values()) {
							XOrganization org = ModelUtils.createXOrganization(o);
							cluster.getOrganization().add(org);
						}
					}
				}
				break;
			case LATEST_GROUP:
				for(User u : g.users) {
					XUser user = ModelUtils.createXUser(u);
					group.getUser().add(user);
				}
				for(Cluster cluster : g.clusters) {
					XCluster c = ModelUtils.createXCluster(cluster);
					group.getCluster().add(c);
				}
				break;
			case BLACKLIST_GROUP:
			case DEFAULT_FRIEND_GROUP:
			case FRIEND_GROUP:
			case STRANGER_GROUP:
				for(User u : g.users) {
					XUser user = ModelUtils.createXUser(u);
					group.getUser().add(user);
				}
				break;
			default:
				SWT.error(SWT.ERROR_INVALID_RANGE);
				break;
		}
	}

	/**
	 * 保存分组信息
	 */
	public void saveModel() {
		if(myFriendGroup == null)
			return;
		
		XGroups groups = GroupFactory.eINSTANCE.createXGroups();
		
		addXGroup(groups, myFriendGroup);
		for(Group g : normalGroups)
			addXGroup(groups, g);
		addXGroup(groups, strangerGroup);
		addXGroup(groups, blacklistGroup);
		addXGroup(groups, clusterGroup);
		addXGroup(groups, latestGroup);
		
		// 写入到文件
		GroupUtil.save(new File(LumaQQ.GROUPS), groups);
	}
	
	/**
	 * 刷新所有视图
	 */
	public void refreshAll() {
		for(QTreeViewer<Model> viewer : viewers.values()) {
			viewer.refresh();
			main.getBlind().refreshSlat(viewer.getQTree());
		}
	}
	
	/**
	 * 把一个组中的用户存到哈希表中
	 * 
	 * @param hash
	 * @param g
	 */
	private void hashFriend(Map<Integer, User> hash, Group g) {
		for(User u : g.users)
			hash.put(u.qq, u);
	}
	
	/**
	 * @return
	 * 		一个包含了所有好友的哈希表
	 */
	public Map<Integer, User> getFriendMap() {
		Map<Integer, User> ret = new HashMap<Integer, User>();
		hashFriend(ret, myFriendGroup);
		for(Group g : normalGroups)
			hashFriend(ret, g);
		return ret;
	}
	
	/**
	 * 添加一个用户到某种组中。如果是添加到群组，则不操作。如果是自定义的
	 * 好友组，不操作。如果是最近联系人组，则添加一个link
	 * 
	 * @param user
	 * 		User对象
	 * @param type
	 * 		组类型
	 */
	public void addUser(User user, GroupType type) {
		User u = user;
		Group g = null;
		switch(type) {
			case BLACKLIST_GROUP:
				g = blacklistGroup;
				break;
			case DEFAULT_FRIEND_GROUP:
				g = myFriendGroup;
				break;
			case LATEST_GROUP:
				g = latestGroup;
				break;
			case STRANGER_GROUP:
				g = strangerGroup;
				break;
			case CLUSTER_GROUP:
			case FRIEND_GROUP:
				return;
			default:
				SWT.error(SWT.ERROR_INVALID_RANGE);
				return;
		}
		g.addUser(u);
	}
	
	/**
	 * @return
	 * 		需要上传的组的名称列表
	 */
	public List<String> getUploadGroupNameList() {
		List<String> ret = new ArrayList<String>();
		for(Group g : normalGroups)
			ret.add(g.name);
		return ret;
	}
	
	/**
	 * 根据索引得到组对象，默认的顺序是，好友是0，然后是自定义组，然后是陌生人，黑名单，
	 * 手机好友，群，最后是最近联系人。一般不应该用这个来的到组对象，因为自定义组个数
	 * 未知。
	 * 
	 * @param index
	 * 		索引