blindhelper.java

lumaQQ的源文件

			f = new User();
			f.qq = qq;
			f.nick = String.valueOf(qq);
			f.displayName = f.nick;
			if(!main.getOptionHelper().isShowNick()) {
			    Remark remark = main.getConfigHelper().getRemark(qq);
			    if(remark != null)
			    	f.remark = remark;
			}
		} else {
			// 移动好友
			Group srcGroup = f.group;
			ani = hasAnimation(f);
			if(ani)
				stopAnimation(srcGroup, f);
			srcGroup.removeUser(f);
			refreshGroup(srcGroup);
			resetGroupImageEffect(srcGroup);
		}
		
		// 添加好友到目的组并调整动画状态
		g.addUser(f);
		refreshGroup(g);		
		if(ani)
			startBounce(g, f);
		resetGroupImageEffect(g);
		
		// 添加到组中，同时请求得到这个好友的信息和刷新在线好友列表
		main.addOnline(f);
		main.getClient().getUserInfo(qq);			
		main.getClient().getFriendOnline();
		
		// 分组信息已改变
		main.setGroupDirty(true);
		
		// 更新服务器端列表
		// 这个功能不再使用，因为LumaQQ会允许不自动更新分组信息，所以，这里搞成自动的会带来问题
		//client.addFriendToList(group, qqNum);
	}		
	
	/**
	 * 停止某个组中某个model的动画
	 * 
	 * @param g
	 * @param m
	 */
	public void stopAnimation(Group g, Model m) {
		QTreeViewer<Model> viewer = getViewer(g);
		if(viewer != null)
			viewer.stopAnimation(m);
	}
	
	/**
	 * 开始跳动一个item
	 * 
	 * @param g
	 * @param m
	 */
	public void startBounce(Group g, Model m) {
		QTreeViewer<Model> viewer = getViewer(g);
		if(viewer != null)
			viewer.startAnimation(m, Animation.ICON_BOUNCE);
	}
	
	/**
	 * 停止Blind上所有的动画效果，如果有的话
	 */
	public void stopAllEffectOnBlind() {
		main.getBlind().stopAllAnimation();
		for(QTreeViewer<Model> viewer : viewers.values())
			viewer.getQTree().stopAllAnimation();
	}
	
	/**
	 * @param g
	 * @return
	 * 		true表示组的Slat上有一个动画
	 */
	public boolean hasGroupAnimation(Group g) {
		QTreeViewer<Model> viewer = viewers.get(g);
		if(viewer == null)
			return false;
		
		int index = main.getBlind().indexOf(viewer.getQTree());
		return main.getBlind().hasSlatAnimation(index);
	}
	
	/**
	 * 得到索引g指定的组，检查它目前是否需要闪烁图标，根据检查结果重置图标特效状态
	 * 
	 * @param g
	 * 		组索引
	 */
	public void resetGroupImageEffect(Group g) {
		if(g == null)
			return;
		
	    MessageQueue mq = main.getMessageQueue();
	    Resources res = Resources.getInstance();
    
	    // 如果是群组
	    if(g.isCluster()) {
	    	stopBlinkGroupImage(g);
	    	
			int sender = mq.nextClusterIMSender();
			Cluster c = ModelRegistry.getCluster(sender);
			if(c == null)
				return;			
			switch(c.clusterType) {
				case NORMAL:
					startBlinkGroupImage(c.group, res.getClusterHead(c.headId));
					startBounceImage(c);
					break;
				case SUBJECT:
					startBlinkGroupImage(c.group, res.getImage(Resources.icoDialog));
					startBlinkText(c.getParentCluster().getSubjectDummy());
					startBounceImage(c.getParentCluster());
					break;
				case DIALOG:
					startBlinkGroupImage(c.group, res.getImage(Resources.icoDialog));
					startBlinkText(c.getParentCluster());
					break;
			}
			return;
	    }
	    
		// 检查这个组还有没有消息，没有了就停止闪烁，有就闪烁下一个消息发送者的头像	
	    // 如果是树形模式，处理有些不同，需要检查是否还有普通消息	    
	    stopBlinkGroupImage(g);
	    stopBlinkText(g);
		if(isTreeMode()) {
			int groupSender = mq.nextGroupSender(g);
			User uGS = ModelRegistry.getUser(groupSender);
			int sender = mq.nextBlinkableIMSender();
			User uS = ModelRegistry.getUser(sender);
			if(uS != null) {
				if(uS.isTM())
					startBlinkGroupImage(g, res.getImage(uS.female ? Resources.icoTMFemale16 : Resources.icoTMMale16));
				else
					startBlinkGroupImage(g, HeadFactory.getOnlineHead(uS));	
			}
			if(uGS != null)
				startBlinkText(uGS.group);				
		} else if(mq.hasGroupMessage(g)) {
			int sender = mq.nextGroupSender(g);
			User u = ModelRegistry.getUser(sender);
			if(u != null) {
				if(u.isTM())
					startBlinkGroupImage(g, res.getImage(u.female ? Resources.icoTMFemale16 : Resources.icoTMMale16));
				else
					startBlinkGroupImage(g, HeadFactory.getOnlineHead(u));	
			}
		}
	}
	
	/**
	 * 重设组内好友或者群的动画状态
	 * 
	 * @param g
	 * 		Group 
	 */
	public void resetUserClusterImageEffect(Group g) {
		MessageQueue mq = main.getMessageQueue();
		
		QTreeViewer<Model> viewer = null;
		viewer = viewers.get(g);
		if(viewer == null)
			return;
		
		switch(g.groupType) {
			case CLUSTER_GROUP:
				for(Cluster c : g.clusters) {
					if(mq.hasMessage(c.clusterId))
						viewer.startAnimation(c, Animation.ICON_BOUNCE);
				}
				break;
			case DEFAULT_FRIEND_GROUP:
			case FRIEND_GROUP:
			case STRANGER_GROUP:
				for(User u : g.users) {
					if(mq.hasMessage(u.qq))
						viewer.startAnimation(u, Animation.ICON_BOUNCE);
				}
				break;
			default:
				break;
		}
	}
	
	/**
	 * 重置所有动画状态
	 */
	public void resetAllImageEffect() {
		resetGroupImageEffect(myFriendGroup);
		resetUserClusterImageEffect(myFriendGroup);
		
		resetGroupImageEffect(strangerGroup);
		resetUserClusterImageEffect(strangerGroup);
		
		resetGroupImageEffect(clusterGroup);
		resetUserClusterImageEffect(clusterGroup);
		
		for(Group g : normalGroups) {
			resetGroupImageEffect(g);
			resetUserClusterImageEffect(g);
		}
		
		main.getUIHelper().resetTrayImageEffect();
	}

	/**
	 * 展开组
	 * 
	 * @param g
	 */
	public void expandGroup(Group g) {
		g.expanded = true;
		QTreeViewer<Model> viewer = getViewer(g);
		viewer.expandItem(g);
		viewer.refresh();
	}
	
	/**
	 * 收起组
	 * 
	 * @param g
	 */
	public void collapseGroup(Group g) {
		g.expanded = false;
		QTreeViewer<Model> viewer = getViewer(g);
		viewer.collapseItem(g);
		viewer.refresh();
	}
	
	/**
	 * 移动一个用户到一个组中
	 * 
	 * @param user
	 * @param destGroup
	 */
	public void moveUser(User user, Group destGroup) {
		/*
		 * 移动用户到这个组，判断各种情况
		 * 1. 好友组到好友组，简单移动
		 * 2. 好友组到陌生人组，删除
		 * 3. 好友组到黑名单组，删除且删除自己
		 * 4. 陌生人组到黑名单组，删除自己
		 * 5. 黑名单组到陌生人组，简单移动 
		 */ 
		Group srcGroup = user.group;
		if(srcGroup == destGroup)
			return;
		switch(srcGroup.groupType) {
			case DEFAULT_FRIEND_GROUP:
			case FRIEND_GROUP:
				switch(destGroup.groupType) {
					case DEFAULT_FRIEND_GROUP:
					case FRIEND_GROUP:
						simpleMove(user, srcGroup, destGroup);
						break;
					case STRANGER_GROUP:
						remove(false, user, destGroup);
						break;
					case BLACKLIST_GROUP:
						remove(true, user, destGroup);
						break;
					default:
						break;
				}
				break;
			case STRANGER_GROUP:
				switch(destGroup.groupType) {
					case DEFAULT_FRIEND_GROUP:
					case FRIEND_GROUP:
					    main.getShellLauncher().openAddReceiveSystemMessageShell(user);
						addTo.put(user.qq, destGroup);
						main.getClient().addFriend(user.qq);
						break;
					case BLACKLIST_GROUP:
						remove(true, user, destGroup);
						break;
					default:
						break;
				}
				break;
			case BLACKLIST_GROUP:
				switch(destGroup.groupType) {
					case DEFAULT_FRIEND_GROUP:
					case FRIEND_GROUP:
					    main.getShellLauncher().openAddReceiveSystemMessageShell(user);
						addTo.put(user.qq, destGroup);
						main.getClient().addFriend(user.qq);
						break;
					case STRANGER_GROUP:
						simpleMove(user, srcGroup, destGroup);
						break;
					default:
						break;
				}
				break;
			default:
				break;
		}
	}
	
	/**
	 * 简单移动
	 * @param user
	 * @param srcGroup
	 * @param destGroup
	 */
	public void simpleMove(User user, Group srcGroup, Group destGroup) {		
		boolean hasAnimation = hasAnimation(user);
		if(hasAnimation)
			stopAnimation(srcGroup, user);
		srcGroup.removeUser(user);
		refreshGroup(srcGroup);
		resetGroupImageEffect(srcGroup);
		
		if(destGroup != null) {
			destGroup.addUser(user);
			refreshGroup(destGroup);
			if(hasAnimation)
				startBounce(destGroup, user);
			resetGroupImageEffect(destGroup);
		}
		if(srcGroup.isFriendly())
			main.setGroupDirty(true);			
	}

	/**
	 * 删除一个用户到指定组中
	 * 
	 * @param destBlacklist
	 * 		目的组是否是黑名单
	 * @param f
	 * @param destGroup
	 */
	private void remove(boolean destBlacklist, User f, Group destGroup) {
		MessageBox box = new MessageBox(main.getShell(), SWT.ICON_WARNING | SWT.YES | SWT.NO);
		box.setText(message_box_common_warning_title);		
		if(destBlacklist)
			box.setMessage(NLS.bind(hint_delete_friend_and_remove_self, String.valueOf(f.qq)));
		else
			box.setMessage(NLS.bind(hint_delete_friend, String.valueOf(f.qq)));
		if(box.open() == SWT.YES) {
			ReceiveSystemMessageShell rsms = new ReceiveSystemMessageShell(main);
			rsms.setFriendModel(f);
			rsms.open(ReceiveSystemMessageShell.DELETE_MODE);
			main.deleteFriendFromServer(f.qq, true, destBlacklist, destGroup);
		}
	}

	/**
	 * 同步最近联系人中的信息
	 * 
	 * @param f
	 * 		需要同步的好友
	 */
	public void synchronizeLatest(User f) {    	
		User u = latestGroup.getUser(f.qq);
    	if(u != null) {
    		u.infoCopy(f);
    		refreshGroup(latestGroup);
    	}
	}
	
	/**
	 * 同步最近联系人中的信息，不立刻刷新
	 * 
	 * @param f
	 * 		需要同步的好友
	 */
	public void synchronizeLatestDelayRefresh(User f) {    	
		User u = latestGroup.getUser(f.qq);
    	if(u != null)
    		u.infoCopy(f);
	}
	
	/**
	 * 同步最近联系人中的群
	 * 
	 * @param c
	 */
	public void synchronizeLatest(Cluster c) {
		Cluster cInLatest = latestGroup.getCluster(c.clusterId);
		if(cInLatest != null) {
			cInLatest.infoCopy(c);
			refreshGroup(latestGroup);
		}
	}
	
	/**
	 * 更新最近联系人组，如果不存在这个用户，则添加
	 * 
	 * @param f
	 */
	public void updateLatest(User f) {
		f.lastMessageTime = System.currentTimeMillis();
	    // 得到最近联系人设定最大数量
	    int max = main.getOptionHelper().getLatestSize();
	    // 得到当前联系人数量
	    int num = latestGroup.users.size() + latestGroup.clusters.size();
	    // 删除多余的联系人
	    if(max > 0) {
		    while(num >= max) {
		    	removeLRUModel();
		    	num--;
		    }
		    // 如果没有这个人，添加
		    if(!latestGroup.hasUser(f.qq)) {
		    	try {
					latestGroup.addUser((User)f.clone());
				} catch(CloneNotSupportedException e) {
				}
		    }
	    }
	    main.getBlindHelper().synchronizeLatest(f);
	}
	
	/**
	 * 更新最近联系人组，如果不存在这个群，则添加
	 * 
	 * @param c
	 */
	public void updateLatest(Cluster c) {
		c.lastMessageTime = System.currentTimeMillis();
	    // 得到最近联系人设定最大数量
	    int max = main.getOptionHelper().getLatestSize();
	    // 得到当前联系人数量
	    int num = latestGroup.users.size() + latestGroup.clusters.size();
	    // 删除多余的联系人
	    if(max > 0) {
		    while(num >= max) {
		    	removeLRUModel();
		    	num--;
		    }
		    // 如果没有这个人，添加
		    if(!latestGroup.hasCluster(c.clusterId)) {
		    	try {
					latestGroup.addCluster((Cluster)c.clone());
				} catch(CloneNotSupportedException e) {
				}
		    }
	    }
	    main.getBlindHelper().synchronizeLatest(c);
	}
	
	/**
	 * 删除掉最近联系人中lastMessageTime最小的model
	 */
	private void removeLRUModel() {
		User lruUser = null;
		Cluster lruCluster = null;
		long min = Long.MAX_VALUE;
		for(User f : latestGroup.users) {
			if(f.lastMessageTime < min) {
				min = f.lastMessageTime;
				lruUser = f;
			}
		}
		for(Cluster c : latestGroup.clusters) {
			if(c.lastMessageTime < min) {
				min = c.lastMessageTime;
				lruCluster = c;
			}
		}		
		if(lruCluster != null)
			latestGroup.removeCluster(lruCluster);
		else if(lruUser != null)
			latestGroup.removeUser(lruUser);
	}
	
	/**
	 * 同步最近联系人中的状态
	 * 
	 * @param f
	 * 		需要同步的好友
	 * @param redraw
	 * 		true表示立刻刷新
	 */
	public void synchronizedLatestStatus(User f, boolean redraw) {
    	if(latestGroup.hasUser(f.qq)) {
    		User u = latestGroup.getUser(f.qq);
    		u.status = f.status;
    		if(redraw)
    			refreshGroup(latestGroup);
    	}
	}

	/**
	 * 设置是否显示个性签名
	 * 
	 * @param b
	 */
	public void setShowSignature(boolean b) {
		ModelLabelProvider.INSTANCE.setShowSignature(b);
	}
	
	/**
	 * 设置是否显示自定义头像
	 * 
	 * @param b
	 */
	public void setShowCustomHead(boolean b) {
		ModelLabelProvider.INSTANCE.setShowCustomHead(b);
	}
}