mainqqlistener.mm

lumaqq

		NSArray* members = [c members];
		int count = [members count];
		int packets = (count - 1) / kQQMaxMemberInfoRequest + 1;
		for(int i = 0; i < packets; i++) {
			NSArray* temp = [members subarrayWithRange:NSMakeRange(i * kQQMaxMemberInfoRequest, MIN(kQQMaxMemberInfoRequest, count - i * kQQMaxMemberInfoRequest))];
			[[m_main client] getMemberInfo:[packet internalId] members:temp];
		}
		
		// get cluster version id
		[[m_main client] getVersionId:[packet internalId]];
	}
	
	// refresh outline
	[[m_main clusterOutline] reloadData];
	
	return NO;
}

- (BOOL)handleGetClusterVersionIdOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = (ClusterCommandReplyPacket*)[event object];
	
	// get cluster
	Cluster* c = [m_groupManager cluster:[packet internalId]];
	if(c) {
		if([packet clusterNameCardVersionId] > [c nameCardVersionId]) {
			[[m_main client] batchGetClusterNameCard:[c internalId] versionId:[c nameCardVersionId]];
			[c setNameCardVersionId:[packet clusterNameCardVersionId]];
		}
	}
	
	return NO;
}

- (BOOL)handleBatchGetClusterNameCardOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = (ClusterCommandReplyPacket*)[event object];
	
	// get cluster
	Cluster* c = [m_groupManager cluster:[packet internalId]];
	if(c) {
		ClusterBatchGetCardPacket* request = (ClusterBatchGetCardPacket*)[event outPacket];
		[m_groupManager setClusterNameCards:[c internalId] nameCards:[packet clusterNameCards]];
		if([packet nextStartPosition] != 0) {
			[[m_main client] batchGetClusterNameCard:[c internalId] 
									versionId:[request clusterNameCardVersionId] 
								startPosition:[packet nextStartPosition]];
		} else
			[[m_main clusterOutline] reloadItem:c reloadChildren:YES];
	}
	
	return NO;
}

- (BOOL)handleGetSubjectsOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = (ClusterCommandReplyPacket*)[event object];
	
	[m_groupManager setSubjects:[packet internalId] subjects:[packet subClusters]];
	
	Cluster* c = [m_groupManager cluster:[packet internalId]];
	if(c) {
		Dummy* subjects = [c subjectsDummy];
		[subjects setOperationSuffix:kStringEmpty];
		[[m_main clusterOutline] reloadItem:subjects];
	}
	return YES;
}

- (BOOL)handleGetSubjectsFailed:(QQNotification*)event {
	return [self handleClusterSubOpTimeout:event];
}

- (BOOL)handleClusterSubOpTimeout:(QQNotification*)event {
	ClusterCommandPacket* packet = (ClusterCommandPacket*)[event outPacket];
	
	switch([packet subSubCommand]) {
		case kQQSubSubCommandGetSubjects:
			Cluster* c = [m_groupManager cluster:[packet parentId]];
			if(c) {
				Dummy* subjects = [c subjectsDummy];
				[subjects setOperationSuffix:kStringEmpty];
				[[m_main clusterOutline] reloadItem:subjects];
			}
			break;
	}
	
	return YES;
}

- (BOOL)handleUpdateOrganizationOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = (ClusterCommandReplyPacket*)[event object];
	
	// save organizations
	[m_groupManager setOrganizations:[packet internalId] organizations:[packet organizations]];
	
	// get cluster
	Cluster* c = [m_groupManager cluster:[packet internalId]];
	if(c) {
		Dummy* organizations = [c organizationsDummy];
		[organizations setOperationSuffix:kStringEmpty];
		[[m_main clusterOutline] reloadItem:organizations];
	}
	
	// refresh outline
	[[m_main clusterOutline] reloadData];
	
	return YES;
}

- (BOOL)handleUpdateOrganizationFailed:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = (ClusterCommandReplyPacket*)[event object];
	
	// get cluster
	Cluster* c = [m_groupManager cluster:[packet internalId]];
	if(c) {
		Dummy* organizations = [c organizationsDummy];
		[organizations setOperationSuffix:kStringEmpty];
		[[m_main clusterOutline] reloadItem:organizations];
	}
	
	return YES;
}

- (BOOL)handleUpdateOrganizationTimeout:(QQNotification*)event {
	ClusterCommandPacket* packet = (ClusterCommandPacket*)[event outPacket];
	
	// get cluster
	Cluster* c = [m_groupManager cluster:[packet internalId]];
	if(c) {
		Dummy* organizations = [c organizationsDummy];
		[organizations setOperationSuffix:kStringEmpty];
		[[m_main clusterOutline] reloadItem:organizations];
	}

	return YES;
}

- (BOOL)handleGetMemberInfoOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = (ClusterCommandReplyPacket*)[event object];
	
	// set member infos
	[m_groupManager setMemberInfos:[packet memberInfos]];
	
	// get online members
	[[m_main client] getOnlineMember:[packet internalId]];
	
	// sort cluster
	Cluster* c = [m_groupManager cluster:[packet internalId]];
	if(c)
		[c sortAll];
		
	// refresh outline
	[[m_main clusterOutline] reloadData];
	
	return NO;
}

- (BOOL)handleGetOnlineMemberOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = (ClusterCommandReplyPacket*)[event object];
	
	// set status
	[m_groupManager setOnlineMembers:[packet memberQQs]];
	
	// sort cluster
	Cluster* c = [m_groupManager cluster:[packet internalId]];
	if(c)
		[c sortAll];
	
	// refresh outline
	[[m_main clusterOutline] reloadData];
	
	return NO;
}

- (BOOL)handleRemoveFriendFromServerListOK:(QQNotification*)event {
	FriendDataOpPacket* packet = (FriendDataOpPacket*)[event outPacket];
	User* user = [[m_groupManager user:[packet QQ]] retain];
	
	// get dest group
	NSNumber* key = [NSNumber numberWithUnsignedInt:[user QQ]];
	NSNumber* toGroupInteger = [[m_main removeFriendGroupMapping] objectForKey:key];
	
	if(toGroupInteger) {
		// clear mapping
		[[m_main removeFriendGroupMapping] removeObjectForKey:key];
		
		// get dest group, if dest group isn't friendly, move user
		// if dest group is blacklist, remove self from his friend list
		int toGroup = [toGroupInteger intValue];
		Group* group = [m_groupManager group:toGroup];
		if(group != nil && ![group isFriendly]) {
			Group* oldGroup = [m_groupManager group:[user groupIndex]];
			[m_groupManager moveUser:user toGroupIndex:toGroup];
			if(oldGroup)
				[[m_main userOutline] reloadItem:oldGroup reloadChildren:YES];
			[[m_main userOutline] reloadItem:group reloadChildren:YES];
			if([group isBlacklist]) {
				[[m_main client] removeSelfFrom:[user QQ]];
				
				// clear messages from this user
				[[m_main messageQueue] removeMessageFromUser:[user QQ]];
			}
		} else
			[m_main removeUserFromOutline:user];
	} else
		[m_main removeUserFromOutline:user];
	
	[user release];
	return NO;
}

- (BOOL)handleExitTempClusterOK:(QQNotification*)event {
	return [self handleExitClusterOK:event];
}

- (BOOL)handleExitClusterOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = [event object];
	Cluster* cluster = [m_groupManager cluster:[packet internalId]];
	if(cluster) {
		[m_groupManager removeCluster:cluster];
		[[m_main clusterOutline] reloadData];
	}
	return NO;
}

- (BOOL)handleSendIMOK:(QQNotification*)event {
	// add to recent contact
	PreferenceCache* cache = [PreferenceCache cache:[m_me QQ]];
	
	// get receiver object
	SendIMPacket* packet = (SendIMPacket*)[event outPacket];
	User* user = [m_groupManager user:[packet receiver]];

	// check user friendship
	if(user) {
		Group* group = [m_groupManager group:[user groupIndex]];
		if((group == nil || [group isStranger] && ![group isBlacklist]) && [cache keepStrangerInRecentContact] || group && [group isFriendly]) {
			[m_groupManager addRecentContact:user];
			[m_main reloadRecent];
		}
	}
	
	return NO;
}

- (BOOL)handleSendClusterIMOK:(QQNotification*)event {
	// get cluster object
	ClusterSendIMExPacket* packet = (ClusterSendIMExPacket*)[event outPacket];
	Cluster* cluster = [m_groupManager cluster:[packet internalId]];
	
	// add to recent
	if(cluster) {
		[m_groupManager addRecentContact:cluster];
		[m_main reloadRecent];
	}
	
	return NO;
}

- (BOOL)handleSMSSent:(QQNotification*)event {
	SendSMSPacket* request = (SendSMSPacket*)[event outPacket];
	NSEnumerator* e = [[request mobiles] objectEnumerator];
	while(NSString* mobile = [e nextObject]) {
		Mobile* m = [m_groupManager mobile:mobile];
		if(m)
			[m_groupManager addRecentContact:m];
	}
	e = [[request QQs] objectEnumerator];
	while(NSNumber* qq = [e nextObject]) {
		User* u = [m_groupManager user:[qq intValue]];
		if(u)
			[m_groupManager addRecentContact:u];
	}
	[m_main reloadRecent];
	
	return NO;
}

- (BOOL)handleSendTempClusterIMOK:(QQNotification*)event {
	TempClusterSendIMPacket* packet = (TempClusterSendIMPacket*)[event outPacket];
	Cluster* cluster = [m_groupManager cluster:[packet internalId]];
	
	// add to recent
	if(cluster) {
		[m_groupManager addRecentContact:cluster];
		[m_main reloadRecent];
	}
	
	return NO;
}

- (BOOL)handleReceivedIM:(QQNotification*)event {
	// if hot key is not enabled, the friend list is not populated, so cache the event
	// until the main UI is ready
	if(![m_main hotKeyEnabled]) {
		[[m_main postponedEventCache] addObject:event];
		return YES;
	}
	
	// save old system message count
	int oldSystemMessageCount = [[m_main messageQueue] systemMessageCount];
	
	BOOL enqueued = NO;
	BOOL jumpIcon = YES;
	PreferenceCache* cache = [PreferenceCache cache:[m_me QQ]];
	ReceivedIMPacket* packet = [event object];
	ReceivedIMPacketHeader* header = [packet imHeader];
	switch([header type]) {
		case kQQIMTypeFriend:
		case kQQIMTypeFriendEx:
		case kQQIMTypeStranger:
		case kQQIMTypeStrangerEx:
			// check normal im type
			if([[packet normalIMHeader] normalIMType] != kQQNormalIMTypeText)
				break;
			
			// get user relationship with me
			BOOL bBlacklist;
			BOOL bIAmHisStranger;
			BOOL bHeIsMyStranger;
			BOOL bNoUser;
			
			// get user and group
			User* user = [m_groupManager user:[header sender]];
			Group* g = (user == nil) ? nil : [m_groupManager group:[user groupIndex]];
			
			// check relationship
			bIAmHisStranger = ([header type] == kQQIMTypeStranger || [header type] == kQQIMTypeStrangerEx);
			bNoUser = user == nil || g == nil;
			bHeIsMyStranger = bNoUser || [g isStranger];
			bBlacklist = !bNoUser && [g isBlacklist];
			
			// if user is in blacklist, don't push message into queue
			// or if user is stranger and you set to reject stranger message, don't push...
			if(bBlacklist)
				break;
			if(bNoUser && bIAmHisStranger)
				break;
			if(bHeIsMyStranger && [cache rejectStrangerMessage])
				break;
			
			// create user if user is nil
			if(user == nil) {
				// create user add to friend or stranger group
				user = [[[User alloc] initWithQQ:[header sender] domain:m_main] autorelease];
				[m_groupManager addUser:user groupIndex:[m_groupManager strangerGroupIndex]];
				[[m_main userOutline] reloadItem:[m_groupManager strangerGroup] reloadChildren:YES];						
				[[m_main client] getUserInfo:[user QQ]];
			}
				
			// get user group, if group is nil, make group point to stranger group
			g = [m_groupManager group:[user groupIndex]];
			if(g == nil) {
				[m_groupManager addUser:user groupIndex:[m_groupManager strangerGroupIndex]];
				[[m_main userOutline] reloadItem:[m_groupManager strangerGroup] reloadChildren:YES];
				g = [m_groupManager strangerGroup];
				[user setGroupIndex:[m_groupManager strangerGroupIndex]];
			}
				
			// get history, add it to history
			History* history = [[m_main historyManager] getHistoryToday:[NSString stringWithFormat:@"%u", [user QQ]]];
			[history addPacket:packet];
			
			// push message to message queue
			[[m_main messageQueue] enqueue:packet];
			enqueued = YES;
			
			// check auto eject option
			// if need eject, open im window, otherwise play sound
			BOOL hasKeyWindow = [[m_main windowRegistry] isNormalIMWindowOrTabFocused:[NSNumber numberWithUnsignedInt:[user QQ]]
																		   mainWindow:m_main];
			if([cache autoEjectMessage] || hasKeyWindow) {
				// open im window
				NSWindowController* winController = [[m_main windowRegistry] showNormalIMWindowOrTab:user mainWindow:m_main];
				
				// activate im window
				[NSApp activateIgnoringOtherApps:YES];
				[[winController window] orderFront:self];
				[[winController window] makeKeyWindow];
				
				// no jump
				enqueued = NO;
				jumpIcon = NO;
			} else {
				[user increaseMessageCount];
				[g increaseMessageCount];
				if([user messageCount] + [user mobileMessageCount] + [user tempSessionMessageCount] == 1) {
					[[TimerTaskManager sharedManager] addTask:[ModelEffectTask taskWithMainWindow:m_main object:user]];