tabimwindowcontroller.mm

lumaqq

	id<IMContainer> container = [[item identifier] content];
	if([(id)container isMemberOfClass:[TempSessionIMContainerController class]] &&
	   [[container model] isEqual:user])
		return YES;
	else
		return NO;
}

- (BOOL)isClusterIMTabFocused:(Cluster*)cluster {
	if(![[self window] isKeyWindow])
		return NO;
	
	NSTabViewItem* item = [m_tabView selectedTabViewItem];
	id<IMContainer> container = [[item identifier] content];
	if([(id)container isMemberOfClass:[ClusterIMContainerController class]] &&
	   [[container model] isEqual:cluster])
		return YES;
	else
		return NO;
}

- (BOOL)isMobileIMTabFocused:(Mobile*)mobile {
	if(![[self window] isKeyWindow])
		return NO;
	
	NSTabViewItem* item = [m_tabView selectedTabViewItem];
	id<IMContainer> container = [[item identifier] content];
	if([(id)container isMemberOfClass:[MobileIMContainerController class]] &&
	   [[container model] isEqual:mobile])
		return YES;
	else
		return NO;
}

- (BOOL)isMobileIMTabFocusedByUser:(User*)user {
	if(![[self window] isKeyWindow])
		return NO;
	
	NSTabViewItem* item = [m_tabView selectedTabViewItem];
	id<IMContainer> container = [[item identifier] content];
	if([(id)container isMemberOfClass:[MobileIMContainerController class]] &&
	   [[container model] isEqual:user])
		return YES;
	else
		return NO;
}

- (BOOL)validateMenuItem:(id <NSMenuItem>)menuItem {
	NSString* string = NSStringFromSelector([menuItem action]);
	if([string isEqualToString:@"shiftClose:"]) {
		[menuItem setTitle:L(@"LQCloseAllTab")];
		return [m_containerArray count] > 1;
	} else if([string isEqualToString:@"performClose:"]) {
		if([m_containerArray count] > 1)
			[menuItem setTitle:L(@"LQCloseCurrentTab")];
		else
			[menuItem setTitle:L(@"LQClose")];
		return YES;
	} else
		return [super validateMenuItem:menuItem];
}

#pragma mark -
#pragma mark qq text view delegate

- (void)closeKeyTriggerred:(QQTextView*)textView {
	// close tab, if you don't use tab mode, this key close window
	[m_tabBar closeTab:[m_tabView selectedTabViewItem]];
}

- (void)historyKeyTriggerred:(QQTextView*)textView {
	[self onHistory:textView];
}

- (void)sendKeyTriggerred:(QQTextView*)textView {
	NSTabViewItem* item = [m_tabView selectedTabViewItem];
	[[[item identifier] content] send:self];
}

- (void)switchTabKeyTriggerred:(QQTextView*)textView {
	int count = [m_tabView numberOfTabViewItems];
	int index = [m_tabView indexOfTabViewItem:[m_tabView selectedTabViewItem]];
	
	// search from index + 1 to count - 1
	for(int i = index + 1; i < count; i++) {
		NSTabViewItem* item = [m_tabView tabViewItemAtIndex:i];
		id<IMContainer> container = [[item identifier] content];
		if([container objectCount] > 0) {
			[m_tabView selectTabViewItem:item];
			[[self window] makeFirstResponder:[container inputBox]];
			return;
		}
	}
	
	// search from 0 to index - 1
	for(int i = 0; i < index; i++) {
		NSTabViewItem* item = [m_tabView tabViewItemAtIndex:i];
		id<IMContainer> container = [[item identifier] content];
		if([container objectCount] > 0) {
			[m_tabView selectTabViewItem:item];
			[[self window] makeFirstResponder:[container inputBox]];
			return;
		}
	}
}

#pragma mark -
#pragma mark toolbar delegate

- (NSToolbarItem *)toolbar:(NSToolbar *)toolbar itemForItemIdentifier:(NSString *)itemIdentifier willBeInsertedIntoToolbar:(BOOL)flag {
	id<IMContainer> container = [[[m_tabView selectedTabViewItem] identifier] content];
	NSToolbarItem* item = [container actionItem:itemIdentifier];
	if(item == nil) {
		if([itemIdentifier isEqualToString:_kToolbarItemOwner]) {
			item = [[[NSToolbarItem alloc] initWithItemIdentifier:itemIdentifier] autorelease];
			
			// create control
			HeadControl* headControl = [[[HeadControl alloc] init] autorelease];
			[container refreshHeadControl:headControl];
			[headControl setTarget:self];
			[headControl setAction:@selector(onHeadItem:)];
			
			// set control to item
			[item setView:headControl];
			
			// set size
			[item setMinSize:NSMakeSize(24, 24)];
			[item setMaxSize:NSMakeSize(24, 24)];
			
			// set tooltip
			[item setToolTip:[NSString stringWithFormat:L(@"LQTooltipOwner", @"BaseIMContainer"), [(id)container description]]];
		} else if([itemIdentifier isEqualToString:_kToolbarItemHistory]) {
			item = [[[NSToolbarItem alloc] initWithItemIdentifier:itemIdentifier] autorelease];
			[item setImage:[NSImage imageNamed:kImageChatHistory]];
			[item setTarget:self];
			[item setAction:@selector(onHistory:)];
			[item setToolTip:L(@"LQTooltipHistory", @"BaseIMContainer")];
		} else if([itemIdentifier isEqualToString:_kToolbarItemKeySetting]) {
			item = [[[NSToolbarItem alloc] initWithItemIdentifier:itemIdentifier] autorelease];
			[item setImage:[NSImage imageNamed:kImageHotKey]];
			[item setTarget:self];
			[item setAction:@selector(onKeySetting:)];
			[item setToolTip:L(@"LQTooltipKeySetting", @"BaseIMContainer")];
		}
	} else {
		[item setTarget:self];
		[item setAction:@selector(onToolbarItem:)];
	}
	return item;
}

- (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar *)toolbar {
	if([m_tabView selectedTabViewItem]) {
		id<IMContainer> container = [[[m_tabView selectedTabViewItem] identifier] content];
		NSMutableArray* identifiers = [NSMutableArray arrayWithArray:[container actionIds]];
		[identifiers insertObject:NSToolbarSeparatorItemIdentifier atIndex:0];
		[identifiers insertObject:_kToolbarItemHistory atIndex:0];
		[identifiers insertObject:_kToolbarItemKeySetting atIndex:0];
		[identifiers insertObject:NSToolbarSeparatorItemIdentifier atIndex:0];
		[identifiers insertObject:_kToolbarItemOwner atIndex:0];
		return identifiers;
	} else
		return [NSArray array];
}

- (NSArray *)toolbarAllowedItemIdentifiers:(NSToolbar *)toolbar {
	if([m_tabView selectedTabViewItem]) {
		id<IMContainer> container = [[[m_tabView selectedTabViewItem] identifier] content];
		NSMutableArray* identifiers = [NSMutableArray arrayWithArray:[container actionIds]];
		[identifiers addObject:_kToolbarItemOwner];
		[identifiers addObject:_kToolbarItemHistory];
		[identifiers addObject:_kToolbarItemKeySetting];
		return identifiers;
	} else
		return [NSArray array];
}

#pragma mark -
#pragma mark actions

- (IBAction)shiftClose:(id)sender {
	[self close];
}

- (IBAction)onHeadItem:(id)sender {
	NSTabViewItem* item = [m_tabView selectedTabViewItem];
	[[[item identifier] content] showOwnerInfo:sender];
}

- (IBAction)onToolbarItem:(id)sender {
	NSTabViewItem* item = [m_tabView selectedTabViewItem];
	[[[item identifier] content] performAction:[sender itemIdentifier]];
}

- (IBAction)onKeySetting:(id)sender {
	if(m_shortcutWindowController == nil) {
		m_shortcutWindowController = [[KeyboardShortcutWindowController alloc] initWithQQ:[[m_mainWindowController me] QQ]];
		[NSBundle loadNibNamed:@"KeyboardShortcutWindow" owner:m_shortcutWindowController];
	}
	
	[m_shortcutWindowController beginSheet:[self window]
							 modalDelegate:nil
							didEndSelector:nil];
}

- (IBAction)onHistory:(id)sender {
	NSTabViewItem* item = [m_tabView selectedTabViewItem];
	HistoryDrawerController* historyController = [m_historyRegistry objectForKey:[[item identifier] content]];
	[[historyController drawer] toggle:self];
}

#pragma mark -
#pragma mark alert delegate

- (void)closeTabConfirmAlertDidEnd:(NSAlert *)alert returnCode:(int)returnCode contextInfo:(void *)contextInfo {
	if(returnCode == NSAlertDefaultReturn) {
		m_sheetType = _kSheetCloseTabConfirm;
	}
}

- (void)clusterCommandFailedAlertDidEnd:(NSAlert *)alert returnCode:(int)returnCode contextInfo:(void *)contextInfo {
	m_sheetType = _kSheetClusterCommandFailed;
}

#pragma mark -
#pragma mark PSM Tab delegate

- (void)tabBar:(PSMTabBarControl*)aTabBar willAddTabForItem:(NSTabViewItem*)tabViewItem {
	
}

- (BOOL)tabView:(NSTabView *)tabView shouldCloseTabViewItem:(NSTabViewItem *)tabViewItem {
	id<IMContainer> container = [[tabViewItem identifier] content];
	if([container pendingMessageCount] > 0) {
		if([m_tabView selectedTabViewItem] != tabViewItem)
			[m_tabView selectTabViewItem:tabViewItem];
		[AlertTool showConfirm:[self window]
					   message:L(@"LQWarningHasPendingMessage", @"BaseIMContainer")
				 defaultButton:L(@"LQYes")
			   alternateButton:L(@"LQNo")
					  delegate:self
				didEndSelector:@selector(closeTabConfirmAlertDidEnd:returnCode:contextInfo:)];
		return NO;
	} else
		return YES;
}

- (void)tabView:(NSTabView *)tabView willCloseTabViewItem:(NSTabViewItem *)tabViewItem {
	// check history drawer, if opened, close it
	id<IMContainer> container = [[tabViewItem identifier] content];
	HistoryDrawerController* historyDrawer = [m_historyRegistry objectForKey:container];
	if(historyDrawer) {
		[historyDrawer retain];
		[m_historyRegistry removeObjectForKey:container];
		[[historyDrawer drawer] close];
		[historyDrawer release];
	}
	
	// remove qq listener
	[[m_mainWindowController client] removeQQListener:container];
	
	// remove from registry
	[m_containerArray removeObject:container];
}

- (void)tabView:(NSTabView *)aTabView didCloseTabViewItem:(NSTabViewItem *)tabViewItem {
	// close window if no tab
	if([aTabView numberOfTabViewItems] == 0)
		[self close];
}

- (BOOL)tabView:(NSTabView *)tabView shouldSelectTabViewItem:(NSTabViewItem *)tabViewItem {
	// check history drawer state
	id<IMContainer> container = [[[m_tabView selectedTabViewItem] identifier] content];
	HistoryDrawerController* historyDrawer = [m_historyRegistry objectForKey:container];
	if(historyDrawer == nil)
		m_historyDrawerOpened = NO;
	else {
		int state = [[historyDrawer drawer] state];
		m_historyDrawerOpened = state == NSDrawerOpenState || state == NSDrawerOpeningState;
		if(m_historyDrawerOpened)
			[[historyDrawer drawer] toggle:self];
	}
	
	return YES;
}

- (void)tabView:(NSTabView *)tabView didSelectTabViewItem:(NSTabViewItem *)tabViewItem {
	// get current container
	id<IMContainer> container = [[tabViewItem identifier] content];
	
	// set new window title
	[[self window] setTitle:[(id)container description]];
	
	// install a new toolbar
	NSToolbar* toolbar = [[[NSToolbar alloc] initWithIdentifier:[container owner]] autorelease];
	[toolbar setDisplayMode:NSToolbarDisplayModeIconOnly];
	[toolbar setSizeMode:NSToolbarSizeModeSmall];
	[toolbar setAllowsUserCustomization:NO];
	[toolbar setDelegate:self];
	[[self window] setToolbar:toolbar];
	
	// check history
	if(m_historyDrawerOpened) {
		HistoryDrawerController* historyDrawer = [m_historyRegistry objectForKey:container];
		[[historyDrawer drawer] open];
	}
	
	// walk message queue
	[container walkMessageQueue:[m_mainWindowController messageQueue]];
	
	// make input box has focus
	[[self window] makeFirstResponder:[container inputBox]];
}

#pragma mark -
#pragma mark qq event handler

- (BOOL)handleQQEvent:(QQNotification*)event {
	BOOL ret = NO;
	switch([event eventId]) {
		case kQQEventClusterCommandFailed:
			ret = [self handleClusterCommandFailed:event];
			break;
	}
	return ret;
}

- (BOOL)handleClusterCommandFailed:(QQNotification*)event {
	ClusterCommandPacket* packet = (ClusterCommandPacket*)[event outPacket];
	Cluster* cluster = [[m_mainWindowController groupManager] cluster:[packet internalId]];
	if(cluster) {
		ClusterCommandReplyPacket* replyPacket = (ClusterCommandReplyPacket*)[event object];
		switch([replyPacket reply]) {
			case kQQReplyNoSuchCluster:
			case kQQReplyTempClusterRemoved:
			case kQQReplyNotClusterMember:
			case kQQReplyNotTempClusterMember:
				// find model container
				NSEnumerator* e = [m_containerArray objectEnumerator];
				while(id<IMContainer> container = [e nextObject]) {
					if([container model] == cluster) {
						// activate container
						[self activateContainer:container];
						
						// show warning
						[AlertTool showWarning:[self window]
										 title:L(@"LQFailed")
									   message:[[event object] errorMessage]
									  delegate:self
								didEndSelector:@selector(clusterCommandFailedAlertDidEnd:returnCode:contextInfo:)];
						break;
					}
				}
					
				// remove cluster from ui
				[[m_mainWindowController groupManager] removeCluster:cluster];
				[m_mainWindowController reloadClusters];
				
				break;
		}
	} else {
		// find container
		cluster = [[[Cluster alloc] initWithInternalId:[packet internalId] domain:m_mainWindowController] autorelease];
		id<IMContainer> container = [self findContainer:cluster];
		if(container) {
			// activate container
			[self activateContainer:container];
			
			// show warning
			[AlertTool showWarning:[self window]
							 title:L(@"LQFailed")
						   message:[[event object] errorMessage]
						  delegate:self
					didEndSelector:@selector(clusterCommandFailedAlertDidEnd:returnCode:contextInfo:)];
		}
	}
	return NO;
}

@end