qqeventprocessor.java

类似于MSN

				}
			);
		}
	}

	// 处理我被其他人添加到某个群的事件
	private void processIAmAddedToCluster(QQEvent e) {
		final ReceiveIMPacket packet = (ReceiveIMPacket)e.getSource();
		ClusterModel c = main.findCluster(packet.header.sender);
		if(c == null) {
			main.display.syncExec(
				new Runnable() {
					public void run() {
						main.addCluster(packet.header.sender, false);
						main.putClusterNotificationAndUpdateAnimate(packet);
					}				
				}
			);
		}
	}

	// 处理接收到群发消息
	private void processReceiveClusterIM(QQEvent e) {
		final ReceiveIMPacket packet = (ReceiveIMPacket)e.getSource();
		main.display.asyncExec(
			new Runnable() {
				public void run() {
					main.putClusterMessageAndUpdateAnimate(packet);
				}				
			}
		);
	}

	// 处理退出群成功事件
	private void processClusterExitClusterSuccess(QQEvent e) {
		final ClusterCommandReplyPacket packet = (ClusterCommandReplyPacket)e.getSource();
		main.display.syncExec(
			new Runnable() {
				public void run() {
					main.removeCluster(packet.clusterId);
				}				
			}
		);
	}

	// 处理得到成员信息成功事件
	private void processClusterGetMemberInfoSuccess(QQEvent e) {
		final ClusterCommandReplyPacket packet = (ClusterCommandReplyPacket)e.getSource();
		main.display.syncExec(
			new Runnable() {
				public void run() {
					ClusterModel c = (ClusterModel)main.findCluster(packet.clusterId);	
					if(c != null) {
						Hashtable members = (Hashtable)c.getProperty("members");
						// 对每个得到信息的成员，设置他们model的属性
						Iterator iter = packet.memberInfos.iterator();
						while(iter.hasNext()) {
							QQFriend friend = (QQFriend)iter.next();
							FriendModel f = (FriendModel)members.get(new Integer(friend.qqNum));
							if(f != null) {
								int faceId = friend.face & 0xFF;
								f.addProperty("nick", friend.nick);
								f.addProperty("name", friend.nick);
								f.addProperty("face", new Integer(faceId));
								f.addProperty("member", String.valueOf(friend.isMember()));
								f.addProperty("contact", ModelUtils.createContact(friend));								
							}
						}
						main.client.getClusterOnlineMember(packet.clusterId);
					}
				}					
			}
		);
	}

	// 处理被系统踢出事件
	private void processKickedOutBySystem() {
		main.display.asyncExec(
			new Runnable() {
				public void run() {
					main.logout();
					MessageBox box = new MessageBox(main.shell, SWT.ICON_WARNING | SWT.OK);
					box.setText(LumaQQ.getResourceString("message.box.common.warning.title"));
					box.setMessage(LumaQQ.getResourceString("message.box.login.twice"));
					box.open();
				}
			}
		);
	}

	// 处理创建群成功事件
	private void processClusterCreateSuccess(QQEvent e) {
		final ClusterCommandReplyPacket packet = (ClusterCommandReplyPacket)e.getSource();
		main.display.syncExec(
			new Runnable() {
				public void run() {
					main.addCluster(packet.clusterId, true);
				}
			}
		);
	}

	// 处理请求发送文件事件
	private void processRequestSendFile(QQEvent e) {
		final ReceiveIMPacket packet = (ReceiveIMPacket)e.getSource();
		main.display.syncExec(
			new Runnable() {
				public void run() {
					main.putSendFileRequestIM(packet);
				}
			}
		);
	}

	// 处理下载分组好友列表失败事件
	private void processDownloadGroupFriendFail(QQEvent e) {
		groupNames = null;
		friends = null;
		main.display.syncExec(
			new Runnable() {
				public void run() {
					main.closeOpDialog(false);
				}				
			}
		);
	}

	// 处理下载分组好友列表成功事件
	private void processDownloadGroupFriendSuccess(QQEvent e) {
		DownloadGroupFriendReplyPacket packet = (DownloadGroupFriendReplyPacket)e.getSource();
		friends = packet.friends;
		if(groupNames != null)
			resetModel();
	}

	// 处理下载分组名称成功事件
	private void processDownloadGroupNameSuccess(QQEvent e) {
		GroupNameOpReplyPacket packet = (GroupNameOpReplyPacket)e.getSource();
		groupNames = packet.groupNames;
		if(friends != null)
			resetModel();
	}

	// 重新设置shutter的model
	private void resetModel() {
		final DefaultShutterModel model = new DefaultShutterModel();
		// 用来保存需要得到信息的好友或者群
		List needInfos = new ArrayList();
		// 用来保存当前有消息的好友或者群，这在后来用来回复图标的闪烁和跳动
		final List hasMessages = new ArrayList();
		// 加入我的好友组model
		GroupModel gModel = new GroupModel(LumaQQ.getResourceString("group.default.friend"));
		model.addTab(gModel);
		// 加入下载到的组
		Iterator iter = groupNames.iterator();
		while(iter.hasNext()) {
			gModel = new GroupModel((String)iter.next());
			model.addTab(gModel);
		}
		// 添加群组
		gModel = new GroupModel(LumaQQ.getResourceString("group.default.cluster"));
		gModel.addProperty("cluster", "true");
		gModel.addProperty("upload", "false");
		model.addTab(gModel);
		int clusterIndex = 0;
		int[] cluster = main.model.findTabIndex(main.clusterMatcher);
		if(cluster != null && cluster.length > 0) {
			// 得到群的索引，当前显然是最后一个tab
			clusterIndex = model.getTabCount() - 1;
			// 得到旧model中的群个数
			int size = main.model.getItemCount(cluster[0]);
			// 逐个添加这些ClusterModel
			for(int i = 0; i < size; i++) {
				ClusterModel c = (ClusterModel)main.model.getItem(cluster[0], i);
				model.addItem(clusterIndex, c);
				if(main.mq.hasMessage(c.getClusterId()))
					hasMessages.add(c);
			}
		}
		// 添加陌生人组
		gModel = new GroupModel(LumaQQ.getResourceString("group.default.stranger"));
		gModel.addProperty("friendly", "false");
		gModel.addProperty("upload", "false");
		model.addTab(gModel);
		// 添加陌生人组中的人
		int[] stranger = main.model.findTabIndex(main.strangerMatcher);
		if(stranger != null && stranger.length > 0) {
			int sIndex = model.getTabCount() - 1;
			int size = main.model.getItemCount(stranger[0]);
			for(int i = 0; i < size; i++)
				model.addItem(sIndex, main.model.getItem(stranger[0], i));			
		}
		// 添加黑名单组
		gModel = new GroupModel(LumaQQ.getResourceString("group.default.blacklist"));
		gModel.addProperty("friendly", "false");
		gModel.addProperty("blacklist", "true");
		gModel.addProperty("upload", "false");
		// 设置黑名单的可见状态
		GroupModel bModel = null;
		final int[] blacklist = main.model.findTabIndex(main.blacklistMatcher);
		if(blacklist != null && blacklist.length > 0) {
			bModel = (GroupModel)main.model.getTab(blacklist[0]);
			gModel.addProperty("visible", bModel.getProperty("visible"));
			// 添加黑名单中的人
			int bIndex = model.getTabCount() - 1;
			int size = main.model.getItemCount(blacklist[0]);
			for(int i = 0; i < size; i++)
				model.addItem(bIndex, main.model.getItem(blacklist[0], i));
		}
		final boolean blacklistVisible = (bModel != null && "false".equals(bModel.getProperty("visible"))) ? false : true;
		model.addTab(gModel);
		// 添加分组中的好友
		int size = friends.size();
		for(int i = 0; i < size; i++) {
			// 得到下载项
			DownloadFriendEntry dfe = (DownloadFriendEntry)friends.get(i);
			if(dfe.isCluster()) {
				if(dfe.isPermanent()) {
					ClusterModel c = main.findCluster(dfe.qqNum);
					// 如果等于null，则添加。不等于null不做什么，因为前面已经添加过了
					if(c == null) {
						needInfos.add(dfe);
						c = new ClusterModel(dfe.qqNum);
						ClusterInfo info = new ClusterInfo();
						info.clusterId = dfe.qqNum;
						c.addProperty("info", info);
						c.addProperty("image", main.icons.getClusterFace(1));
						c.addProperty("face", new Integer(1));
						model.addItem(clusterIndex, c);
					}					
				}
			} else {
				// 搜索目前的model，得到这个好友的model，如果没有找到这个好友，创建一个新model
				//     并把这个model保存到一个list中，因为需要得到这些好友的info。另外，还要
				//     把有消息的好友保存起来，因为在设置新model完成后，要恢复图标的跳动和闪烁
				FriendModel old = main.getFriendModel(dfe.qqNum);
				if(old != null) {
					FriendModel f = old.cloneProperties();
					f.addProperty("status", "offline");
					model.addItem(dfe.group, f);
					if(main.mq.hasMessage(dfe.qqNum))
						hasMessages.add(f);
				} else {
					needInfos.add(dfe);
					FriendModel f = new FriendModel(String.valueOf(dfe.qqNum), main.icons.getFace(0));
					f.addProperty("qq", new Integer(dfe.qqNum));
					f.addProperty("status", "offline");
					f.addProperty("face", new Integer(0));
					f.addProperty("member", "false");
					model.addItem(dfe.group, f);
				}				
			}
		}
		// 新model已经完全构造好了，现在把旧model替换成新model
		main.display.syncExec(
			new Runnable() {
				public void run() {
					main.setModel(model);		
					// 判断黑名单当前是否是隐藏的，如果是，隐藏黑名单
					if(!blacklistVisible) {
						main.shutter.hideTab(blacklist[0], true);
					}
				}				
			}
		);
		// 对于那些没有在旧model中出现的好友或者群，请求得到他们的info
		iter = needInfos.iterator();
		while(iter.hasNext()) {
			DownloadFriendEntry dfe = (DownloadFriendEntry)iter.next();
			if(dfe.isCluster())
				main.client.getClusterInfo(dfe.qqNum);
			else
				main.client.getUserInfo(dfe.qqNum);
		}
		// 得到在线好友
		main.client.getFriendOnline();		
		// 恢复图标的跳动和闪烁，然后关闭提示框
		main.display.syncExec(
			new Runnable() {
				public void run() {
					// 恢复好友的头像跳动
					Iterator iter = hasMessages.iterator();
					while(iter.hasNext()) {
						Object modelObj = iter.next();
						if(modelObj instanceof FriendModel) {
							FriendModel f = (FriendModel)modelObj;
							main.bounceFriendImage(f);							
						} else {
							ClusterModel c = (ClusterModel)modelObj;
							main.bounceClusterImage(c);
						}
					}
				    // 恢复组的头像闪烁
					int tabSize = model.getTabCount();
					for(int i = 0; i < tabSize; i++) 
						main.resetGroupImageEffect(i);
					// 关闭提示框
					main.closeOpDialog(true);
				}				
			}
		);
	}

	// 处理上传分组好友列表失败事件
	private void processUploadGroupFriendFail(QQEvent e) {
		main.display.syncExec(
			new Runnable() {
				public void run() {
					main.closeOpDialog(false);
				}				
			}
		);
	}

	// 处理上传分组好友列表成功事件，
	private void processUploadGroupFriendSuccess(QQEvent e) {
		main.display.syncExec(
			new Runnable() {
				public void run() {
					main.closeOpDialog(true);
				}				
			}
		);
	}

	// 处理连接丢失事件
	private void processConnectionLost() {
		main.display.asyncExec(
			new Runnable() {
				public void run() {
				    /*
				    main.client.getUser().setLoggedIn(false);
					main.client.getUser().setStatus(QQ.QQ_FRIEND_STATUS_OFFLINE);
					main.setIconByStatus();
					MessageBox box = new MessageBox(main.getShell(), SWT.ICON_ERROR | SWT.OK);
					box.setText(LumaQQ.getResourceString("message.box.common.fail.title"));
					box.setMessage(LumaQQ.getResourceString("message.box.connection.lost"));
					box.open();