FreeRDP/client/iOS/Controllers/BookmarkListController.m

/*
 bookmarks and active session view controller
 
 Copyright 2013 Thincast Technologies GmbH, Author: Martin Fleisz
 
 This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. 
 If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#import "BookmarkListController.h"
#import "Utils.h"
#import "BookmarkEditorController.h"
#import "RDPSessionViewController.h"
#import "Toast+UIView.h"
#import "Reachability.h"
#import "GlobalDefaults.h"
#import "BlockAlertView.h"

#define SECTION_SESSIONS    0
#define SECTION_BOOKMARKS   1
#define NUM_SECTIONS        2

@interface BookmarkListController (Private)
#pragma mark misc functions
- (UIButton*)disclosureButtonWithImage:(UIImage*)image;
- (void)performSearch:(NSString*)searchText;
#pragma mark Persisting bookmarks
- (void)scheduleWriteBookmarksToDataStore;
- (void)writeBookmarksToDataStore;
- (void)scheduleWriteManualBookmarksToDataStore;
- (void)writeManualBookmarksToDataStore;
- (void)readManualBookmarksFromDataStore;
- (void)writeArray:(NSArray*)bookmarks toDataStoreURL:(NSURL*)url;
- (NSMutableArray*)arrayFromDataStoreURL:(NSURL*)url;
- (NSURL*)manualBookmarksDataStoreURL;
- (NSURL*)connectionHistoryDataStoreURL;
@end


@implementation BookmarkListController

@synthesize searchBar = _searchBar, tableView = _tableView, bmTableCell = _bmTableCell, sessTableCell = _sessTableCell;

 // The designated initializer.  Override if you create the controller programmatically and want to perform customization that is not appropriate for viewDidLoad.
- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil {
    if ((self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil])) 
	{   
        // load bookmarks
        [self readManualBookmarksFromDataStore];

        // load connection history
        [self readConnectionHistoryFromDataStore];
        
		// init search result array
		_manual_search_result = nil;		
        
        // register for session notifications
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(sessionDisconnected:) name:TSXSessionDidDisconnectNotification object:nil];
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(sessionFailedToConnect:) name:TSXSessionDidFailToConnectNotification object:nil];
                
        // set title and tabbar controller image
        [self setTitle:NSLocalizedString(@"Connections", @"'Connections': bookmark controller title")];
        [self setTabBarItem:[[[UITabBarItem alloc] initWithTabBarSystemItem:UITabBarSystemItemBookmarks tag:0] autorelease]];

        // load images
        _star_on_img = [[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"icon_accessory_star_on" ofType:@"png"]] retain];
        _star_off_img = [[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"icon_accessory_star_off" ofType:@"png"]] retain];

        // init reachability detection
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(reachabilityChanged:) name:kReachabilityChangedNotification object:nil];
        
        // init other properties
        _active_sessions = [[NSMutableArray alloc] init];
        _temporary_bookmark = nil;
    }
    return self;
}

- (void)loadView
{
    [super loadView];    
}

// Implement viewDidLoad to do additional setup after loading the view, typically from a nib.
- (void)viewDidLoad {
    [super viewDidLoad];        
    
    // set edit button to allow bookmark list editing
    [[self navigationItem] setRightBarButtonItem:[self editButtonItem]];
}


- (void)viewWillAppear:(BOOL)animated 
{
	[super viewWillAppear:animated];
    
    // in case we had a search - search again cause the bookmark searchable items could have changed
    if ([[_searchBar text] length] > 0)
        [self performSearch:[_searchBar text]];

    // to reflect any bookmark changes - reload table
    [_tableView reloadData];
}

- (void)viewWillDisappear:(BOOL)animated
{
    [super viewWillDisappear:animated];
    
    // clear any search
    [_searchBar setText:@""];
    [_searchBar resignFirstResponder];
    [self performSearch:@""];
}

// Override to allow orientations other than the default portrait orientation.
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
    // Return YES for supported orientations
    return YES;
}


- (void)didReceiveMemoryWarning {
    // Releases the view if it doesn't have a superview.
    [super didReceiveMemoryWarning];
    
    // Release any cached data, images, etc that aren't in use.
}

- (void)viewDidUnload {
    [super viewDidUnload];
    // Release any retained subviews of the main view.
    // e.g. self.myOutlet = nil;
}


- (void)dealloc 
{
    [[NSNotificationCenter defaultCenter] removeObserver:self];

    [_temporary_bookmark release];
    [_connection_history release];
    [_active_sessions release];
	[_manual_search_result release];
    [_manual_bookmarks release];
    
    [_star_on_img release];
    [_star_off_img release];

    [super dealloc];
}


#pragma mark -
#pragma mark Table view data source

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    // Return the number of sections.
	return NUM_SECTIONS;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
	
	switch(section)
	{
        case SECTION_SESSIONS:
            return 0;
            break;
            
		case SECTION_BOOKMARKS:
			{
				// (+1 for Add Bookmark entry)
				if(_manual_search_result != nil)
					return ([_manual_search_result count] + [_history_search_result count] + 1);
				return ([_manual_bookmarks count] + 1);
			}
			break;	
			
		default:
			break;
	}
	return 0;
}

- (UITableViewCell*)cellForGenericListEntry
{
    static NSString *CellIdentifier = @"BookmarkListCell";
    UITableViewCell *cell = [[self tableView] dequeueReusableCellWithIdentifier:CellIdentifier];
    if(cell == nil)
    {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier];
        [cell setSelectionStyle:UITableViewCellSelectionStyleNone];
        [cell setAccessoryView:[self disclosureButtonWithImage:_star_off_img]];                        
    }

    return cell;
}

- (BookmarkTableCell*)cellForBookmark
{
    static NSString *BookmarkCellIdentifier = @"BookmarkCell";   
    BookmarkTableCell *cell = (BookmarkTableCell*)[[self tableView] dequeueReusableCellWithIdentifier:BookmarkCellIdentifier];
    if(cell == nil) 
    {
        [[NSBundle mainBundle] loadNibNamed:@"BookmarkTableViewCell" owner:self options:nil];
        [_bmTableCell setAccessoryView:[self disclosureButtonWithImage:_star_on_img]];                        
        cell = _bmTableCell;
        _bmTableCell = nil;
    }
    
    return cell;
}

// Customize the appearance of table view cells.
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {


    switch ([indexPath section])
    {
        case SECTION_SESSIONS:
        {
            // get custom session cell
            static NSString *SessionCellIdentifier = @"SessionCell";
            SessionTableCell *cell = (SessionTableCell*)[tableView dequeueReusableCellWithIdentifier:SessionCellIdentifier];
            if(cell == nil) 
            {
                [[NSBundle mainBundle] loadNibNamed:@"SessionTableViewCell" owner:self options:nil];
                cell = _sessTableCell;
                _sessTableCell = nil;
            }
            
            // set cell data
            RDPSession* session = [_active_sessions objectAtIndex:[indexPath row]];        
            [[cell title] setText:[session sessionName]];
            [[cell server] setText:[[session params] StringForKey:@"hostname"]];
            [[cell username] setText:[[session params] StringForKey:@"username"]];
            [[cell screenshot] setImage:[session getScreenshotWithSize:[[cell screenshot] bounds].size]];
            [[cell disconnectButton] setTag:[indexPath row]];        
            return cell;
        }
            
        case SECTION_BOOKMARKS:
        {
            // special handling for first cell - quick connect/quick create Bookmark cell
            if([indexPath row] == 0)
            {                
                // if a search text is entered the cell becomes a quick connect/quick create bookmark cell - otherwise it's just an add bookmark cell
                UITableViewCell* cell = [self cellForGenericListEntry];
                if ([[_searchBar text] length] == 0)
                {
                    [[cell textLabel] setText:[@"  " stringByAppendingString:NSLocalizedString(@"Add Connection", @"'Add Connection': button label")]];
                    [((UIButton*)[cell accessoryView]) setHidden:YES];
                }
                else
                {
                    [[cell textLabel] setText:[@"  " stringByAppendingString:[_searchBar text]]];            
                    [((UIButton*)[cell accessoryView]) setHidden:NO];
                }
                
                return cell;
            }
            else            
            {
                // do we have a history cell or bookmark cell?
                if ([self isIndexPathToHistoryItem:indexPath])
                {
                    UITableViewCell* cell = [self cellForGenericListEntry];
                    [[cell textLabel] setText:[@"  " stringByAppendingString:[_history_search_result objectAtIndex:[self historyIndexFromIndexPath:indexPath]]]];
                    [((UIButton*)[cell accessoryView]) setHidden:NO];                    
                    return cell;
                }
                else
                {
                    // set cell properties
                    ComputerBookmark* entry;
                    BookmarkTableCell* cell = [self cellForBookmark];
                    if(_manual_search_result == nil)
                        entry = [_manual_bookmarks objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]];
                    else
                        entry = [[_manual_search_result objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]] valueForKey:@"bookmark"];
                    
                    [[cell title] setText:[entry label]];
                    [[cell subTitle] setText:[[entry params] StringForKey:@"hostname"]];
                    return cell;                
                }                
            }            
        }
            
        default:
            break;
    }
    
    NSAssert(0, @"Failed to create cell");
    return nil;    	
}



// Override to support conditional editing of the table view.
- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath {
	// dont allow to edit Add Bookmark item
    if([indexPath section] == SECTION_SESSIONS)
        return NO;
    if([indexPath section] == SECTION_BOOKMARKS && [indexPath row] == 0)
		return NO;
    return YES;
}



 // Override to support editing the table view.
 - (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath 
{
	if(editingStyle == UITableViewCellEditingStyleDelete) 
	{
		// Delete the row from the data source
		switch([indexPath section])
		{
            case SECTION_BOOKMARKS:
            {
                if (_manual_search_result == nil)
                    [_manual_bookmarks removeObjectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]];
                else
                {
                    // history item or bookmark?
                    if ([self isIndexPathToHistoryItem:indexPath])
                    {
                        [_connection_history removeObject:[_history_search_result objectAtIndex:[self historyIndexFromIndexPath:indexPath]]];
                        [_history_search_result removeObjectAtIndex:[self historyIndexFromIndexPath:indexPath]];
                    }                    
                    else
                    {
                        [_manual_bookmarks removeObject:[[_manual_search_result objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]] valueForKey:@"bookmark"]];
                        [_manual_search_result removeObjectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]];
                    }                    
                }
                [self scheduleWriteManualBookmarksToDataStore];
                break;
            }                
		}

		[tableView reloadSections:[NSIndexSet indexSetWithIndex:[indexPath section]] withRowAnimation:UITableViewRowAnimationNone];
	}   
}


// Override to support rearranging the table view.
- (void)tableView:(UITableView *)tableView moveRowAtIndexPath:(NSIndexPath *)fromIndexPath toIndexPath:(NSIndexPath *)toIndexPath 
{
	if([fromIndexPath compare:toIndexPath] != NSOrderedSame)
	{
		switch([fromIndexPath section])
		{
            case SECTION_BOOKMARKS:
            {
                int fromIdx = [self bookmarkIndexFromIndexPath:fromIndexPath];
                int toIdx = [self bookmarkIndexFromIndexPath:toIndexPath];
                ComputerBookmark* temp_bookmark = [[_manual_bookmarks objectAtIndex:fromIdx] retain];
                [_manual_bookmarks removeObjectAtIndex:fromIdx];
                if (toIdx >= [_manual_bookmarks count])
                    [_manual_bookmarks addObject:temp_bookmark];
                else
                    [_manual_bookmarks insertObject:temp_bookmark atIndex:toIdx];
                [temp_bookmark release];
                
                [self scheduleWriteManualBookmarksToDataStore];
                break;
            }
		}
	}
}


// prevent that an item is moved befoer the Add Bookmark item
-(NSIndexPath*)tableView:(UITableView *)tableView targetIndexPathForMoveFromRowAtIndexPath:(NSIndexPath *)sourceIndexPath toProposedIndexPath:(NSIndexPath *)proposedDestinationIndexPath
{
    // don't allow to move:
    //  - items between sections
    //  - the quick connect/quick create bookmark cell
    //  - any item while a search is applied
    if([proposedDestinationIndexPath row] == 0 || ([sourceIndexPath section] != [proposedDestinationIndexPath section]) || 
       _manual_search_result != nil)
    {
        return sourceIndexPath;
    }
    else
    {
        return proposedDestinationIndexPath;
    }
}


// Override to support conditional rearranging of the table view.
- (BOOL)tableView:(UITableView *)tableView canMoveRowAtIndexPath:(NSIndexPath *)indexPath {
	// dont allow to reorder Add Bookmark item
    if([indexPath section] == SECTION_BOOKMARKS && [indexPath row] == 0)
		return NO;
    return YES;
}

- (NSString*)tableView:(UITableView*)tableView titleForHeaderInSection:(NSInteger)section
{
	if(section == SECTION_SESSIONS && [_active_sessions count] > 0)
		return NSLocalizedString(@"My Sessions", @"'My Session': section sessions header");
	if(section == SECTION_BOOKMARKS)
		return NSLocalizedString(@"Manual Connections", @"'Manual Connections': section manual bookmarks header");
	return nil;
}

- (NSString*)tableView:(UITableView*)tableView titleForFooterInSection:(NSInteger)section
{
	return nil;
}

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    if([indexPath section] == SECTION_SESSIONS)
        return 72;
    return [tableView rowHeight];
}

#pragma mark -
#pragma mark Table view delegate

- (void)setEditing:(BOOL)editing animated:(BOOL)animated
{
    [super setEditing:editing animated:animated];
    [[self tableView] setEditing:editing animated:animated];
}

- (void)accessoryButtonTapped:(UIControl*)button withEvent:(UIEvent*)event
{
    // forward a tap on our custom accessory button to the real accessory button handler
    NSIndexPath* indexPath = [[self tableView] indexPathForRowAtPoint:[[[event touchesForView:button] anyObject] locationInView:[self tableView]]];
    if (indexPath == nil)
        return;
    
    [[[self tableView] delegate] tableView:[self tableView] accessoryButtonTappedForRowWithIndexPath:indexPath];
}

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath 
{    
    if([indexPath section] == SECTION_SESSIONS)
    {
        // resume session
        RDPSession* session = [_active_sessions objectAtIndex:[indexPath row]];
        UIViewController* ctrl = [[[RDPSessionViewController alloc] initWithNibName:@"RDPSessionView" bundle:nil session:session] autorelease];
        [ctrl setHidesBottomBarWhenPushed:YES];
        [[self navigationController] pushViewController:ctrl animated:YES];
    }
	else
	{
		ComputerBookmark* bookmark = nil;
		if([indexPath section] == SECTION_BOOKMARKS)
		{
            // first row has either quick connect or add bookmark item
            if([indexPath row] == 0)
            {
                if ([[_searchBar text] length] == 0)
                {                    
                    // show add bookmark controller
                    ComputerBookmark *bookmark = [[[ComputerBookmark alloc] initWithBaseDefaultParameters] autorelease];
                    BookmarkEditorController* bookmarkEditorController = [[[BookmarkEditorController alloc] initWithBookmark:bookmark] autorelease];
                    [bookmarkEditorController setTitle:NSLocalizedString(@"Add Connection", @"Add Connection title")];
                    [bookmarkEditorController setDelegate:self];
                    [bookmarkEditorController setHidesBottomBarWhenPushed:YES];
                    [[self navigationController] pushViewController:bookmarkEditorController animated:YES];
                }
                else
                {
                    // create a quick connect bookmark and add an entry to the quick connect history (if not already in the history)
                    bookmark = [self bookmarkForQuickConnectTo:[_searchBar text]];     
                    if (![_connection_history containsObject:[_searchBar text]])
                    {
                        [_connection_history addObject:[_searchBar text]];
                        [self scheduleWriteConnectionHistoryToDataStore];                        
                    }
                }
            }
            else
            {
                if(_manual_search_result != nil)
                {
                    if ([self isIndexPathToHistoryItem:indexPath])
                    {
                        // create a quick connect bookmark for a history item
                        NSString* item = [_history_search_result objectAtIndex:[self historyIndexFromIndexPath:indexPath]];
                        bookmark = [self bookmarkForQuickConnectTo:item];
                    }
                    else
                        bookmark = [[_manual_search_result objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]] valueForKey:@"bookmark"];                    
                }
                else
                    bookmark = [_manual_bookmarks objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]]; // -1 because of ADD BOOKMARK entry
            }
            
            // set reachability status
            WakeUpWWAN();
            [bookmark setConntectedViaWLAN:[[Reachability reachabilityWithHostName:[[bookmark params] StringForKey:@"hostname"]] currentReachabilityStatus] == ReachableViaWiFi];            
		}
		
		if(bookmark != nil)
		{	            
			// create rdp session
            RDPSession* session = [[[RDPSession alloc] initWithBookmark:bookmark] autorelease];
            UIViewController* ctrl = [[[RDPSessionViewController alloc] initWithNibName:@"RDPSessionView" bundle:nil session:session] autorelease];
            [ctrl setHidesBottomBarWhenPushed:YES];
            [[self navigationController] pushViewController:ctrl animated:YES];
            [_active_sessions addObject:session];
        }
	}
}


- (void)tableView:(UITableView*)tableView accessoryButtonTappedForRowWithIndexPath:(NSIndexPath*)indexPath
{    
	// get the bookmark
    NSString* bookmark_editor_title = NSLocalizedString(@"Edit Connection", @"Edit Connection title");
	ComputerBookmark* bookmark = nil;
	if ([indexPath section] == SECTION_BOOKMARKS)
	{
        if ([indexPath row] == 0)
        {
            // create a new bookmark and init hostname and label
            bookmark = [self bookmarkForQuickConnectTo:[_searchBar text]];     
            bookmark_editor_title = NSLocalizedString(@"Add Connection", @"Add Connection title");
        }
        else
        {
            if (_manual_search_result != nil)
            {
                if ([self isIndexPathToHistoryItem:indexPath])
                {
                    // create a new bookmark and init hostname and label
                    NSString* item = [_history_search_result objectAtIndex:[self historyIndexFromIndexPath:indexPath]];
                    bookmark = [self bookmarkForQuickConnectTo:item];     
                    bookmark_editor_title = NSLocalizedString(@"Add Connection", @"Add Connection title");
                }
                else
                    bookmark = [[_manual_search_result objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]] valueForKey:@"bookmark"];
            }
            else
                bookmark = [_manual_bookmarks objectAtIndex:[self bookmarkIndexFromIndexPath:indexPath]];	// -1 because of ADD BOOKMARK entry
        }
	}

    // bookmark found? - start the editor
	if (bookmark != nil)
	{
		BookmarkEditorController* editBookmarkController = [[[BookmarkEditorController alloc] initWithBookmark:bookmark] autorelease];
        [editBookmarkController setHidesBottomBarWhenPushed:YES];
        [editBookmarkController setTitle:bookmark_editor_title];
        [editBookmarkController setDelegate:self];
		[[self navigationController] pushViewController:editBookmarkController animated:YES];	
	}
}

#pragma mark -
#pragma mark Search Bar Delegates

- (BOOL)searchBarShouldBeginEditing:(UISearchBar*)searchBar
{
	// show cancel button
	[searchBar setShowsCancelButton:YES animated:YES];
	return YES;
}

- (void)searchBarCancelButtonClicked:(UISearchBar *)searchBar
{
	// clear search result
	[_manual_search_result release];
	_manual_search_result = nil;
	
	// clear text and remove cancel button
	[searchBar setText:@""];
	[searchBar resignFirstResponder];
}

- (BOOL)searchBarShouldEndEditing:(UISearchBar*)searchBar
{	
	[searchBar setShowsCancelButton:NO animated:YES];
	
	// re-enable table selection
	[_tableView setAllowsSelection:YES];
	
	return YES;
}

- (void)searchBarSearchButtonClicked:(UISearchBar *)searchBar
{
	[_searchBar resignFirstResponder];
}

- (void)searchBar:(UISearchBar*)searchBar textDidChange:(NSString*)searchText
{
    [self performSearch:searchText];
	[_tableView reloadData];
}

#pragma mark - Session handling

// session was added
- (void)sessionDisconnected:(NSNotification*)notification
{
    // remove session from active sessions
    RDPSession* session = (RDPSession*)[notification object];
    [_active_sessions removeObject:session];

    // if this view is currently active refresh entries
    if([[self navigationController] visibleViewController] == self)
        [_tableView reloadSections:[NSIndexSet indexSetWithIndex:SECTION_SESSIONS] withRowAnimation:UITableViewRowAnimationNone];	
    
    // if session's bookmark is not in the bookmark list ask the user if he wants to add it
    // (this happens if the session is created using the quick connect feature)
    if (![_manual_bookmarks containsObject:[session bookmark]])
    {
        // retain the bookmark in case we want to save it later
        _temporary_bookmark = [[session bookmark] retain];
        
        // ask the user if he wants to save the bookmark
        NSString* title = NSLocalizedString(@"Save Connection Settings?", @"Save connection settings title");
        NSString* message = NSLocalizedString(@"Your Connection Settings have not been saved. Do you want to save them?", @"Save connection settings message");
        BlockAlertView* alert = [BlockAlertView alertWithTitle:title message:message];
        [alert setCancelButtonWithTitle:NSLocalizedString(@"No", @"No Button") block:nil];
        [alert addButtonWithTitle:NSLocalizedString(@"Yes", @"Yes Button") block:^{
            if (_temporary_bookmark)
            {
                [_manual_bookmarks addObject:_temporary_bookmark];
                [_tableView reloadSections:[NSIndexSet indexSetWithIndex:SECTION_BOOKMARKS] withRowAnimation:UITableViewRowAnimationNone];
                [_temporary_bookmark autorelease];
                _temporary_bookmark = nil;
            }
        }];
        [alert show];
    }
}

- (void)sessionFailedToConnect:(NSNotification*)notification
{
    // remove session from active sessions
    RDPSession* session = (RDPSession*)[notification object];
    [_active_sessions removeObject:session];    
    
    // display error toast
    [[self view] makeToast:NSLocalizedString(@"Failed to connect to session!", @"Failed to connect error message") duration:ToastDurationNormal position:@"center"];
}

#pragma mark - Reachability notification
- (void)reachabilityChanged:(NSNotification*)notification
{
    // no matter how the network changed - we will disconnect
    // disconnect session (if there is any)
    if ([_active_sessions count] > 0)
    {
        RDPSession* session = [_active_sessions objectAtIndex:0];
        [session disconnect];
    }
}

#pragma mark - BookmarkEditorController delegate

- (void)commitBookmark:(ComputerBookmark *)bookmark
{
    // if we got a manual bookmark that is not in the list yet - add it otherwise replace it
    BOOL found = NO;
    for (int idx = 0; idx < [_manual_bookmarks count]; ++idx)
    {
        if ([[bookmark uuid] isEqualToString:[[_manual_bookmarks objectAtIndex:idx] uuid]])
        {
            [_manual_bookmarks replaceObjectAtIndex:idx withObject:bookmark];
            found = YES;
            break;
        }
    }
    if (!found)
        [_manual_bookmarks addObject:bookmark];
    
    // remove any quick connect history entry with the same hostname
    NSString* hostname = [[bookmark params] StringForKey:@"hostname"];
    if ([_connection_history containsObject:hostname])
    {
        [_connection_history removeObject:hostname];
        [self scheduleWriteConnectionHistoryToDataStore];
    }
        
    [self scheduleWriteManualBookmarksToDataStore];
}

- (IBAction)disconnectButtonPressed:(id)sender
{
    // disconnect session and refresh table view
    RDPSession* session = [_active_sessions objectAtIndex:[sender tag]];
    [session disconnect];
}

#pragma mark - Misc functions

- (BOOL)hasNoBookmarks
{
    return ([_manual_bookmarks count] == 0);
}

- (UIButton*)disclosureButtonWithImage:(UIImage*)image
{
    // we make the button a little bit bigger (image widht * 2, height + 10) so that the user doesn't accidentally connect to the bookmark ...
    UIButton* button = [UIButton buttonWithType:UIButtonTypeCustom];  
    [button setFrame:CGRectMake(0, 0, [image size].width * 2, [image size].height + 10)];
    [button setImage:image forState:UIControlStateNormal];
    [button addTarget:self action:@selector(accessoryButtonTapped:withEvent:) forControlEvents:UIControlEventTouchUpInside];    
    [button setUserInteractionEnabled:YES];
    return button;
}

- (void)performSearch:(NSString*)searchText
{
    [_manual_search_result autorelease];
    
	if([searchText length] > 0)
	{
		_manual_search_result = [FilterBookmarks(_manual_bookmarks, [searchText componentsSeparatedByCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]) retain];
        _history_search_result = [FilterHistory(_connection_history, searchText) retain];
    }
	else
	{
        _history_search_result = nil;
		_manual_search_result = nil;
	}    
}

- (int)bookmarkIndexFromIndexPath:(NSIndexPath*)indexPath
{
    return [indexPath row] - ((_history_search_result != nil) ? [_history_search_result count] : 0) - 1;
}

- (int)historyIndexFromIndexPath:(NSIndexPath*)indexPath
{
    return [indexPath row] - 1;
}

- (BOOL)isIndexPathToHistoryItem:(NSIndexPath*)indexPath
{
    return (([indexPath row] - 1) < [_history_search_result count]);
}

- (ComputerBookmark*)bookmarkForQuickConnectTo:(NSString*)host
{
    ComputerBookmark* bookmark = [[[ComputerBookmark alloc] initWithBaseDefaultParameters] autorelease];
    [bookmark setLabel:host]; 
    [[bookmark params] setValue:host forKey:@"hostname"];                
    return bookmark;
}

#pragma mark - Persisting bookmarks

- (void)scheduleWriteBookmarksToDataStore
{
	[[NSOperationQueue mainQueue] addOperationWithBlock:^{
		[self writeBookmarksToDataStore];
	}];
}

- (void)writeBookmarksToDataStore
{    
    [self writeManualBookmarksToDataStore];
}

- (void)scheduleWriteManualBookmarksToDataStore
{
	[[NSOperationQueue mainQueue] addOperation:[[[NSInvocationOperation alloc] initWithTarget:self selector:@selector(writeManualBookmarksToDataStore) object:nil] autorelease]];
}

- (void)writeManualBookmarksToDataStore
{    
    [self writeArray:_manual_bookmarks toDataStoreURL:[self manualBookmarksDataStoreURL]];
}

- (void)scheduleWriteConnectionHistoryToDataStore
{
	[[NSOperationQueue mainQueue] addOperation:[[[NSInvocationOperation alloc] initWithTarget:self selector:@selector(writeConnectionHistoryToDataStore) object:nil] autorelease]];
}

- (void)writeConnectionHistoryToDataStore
{    
    [self writeArray:_connection_history toDataStoreURL:[self connectionHistoryDataStoreURL]];
}

- (void)writeArray:(NSArray*)bookmarks toDataStoreURL:(NSURL*)url
{
	NSData* archived_data = [NSKeyedArchiver archivedDataWithRootObject:bookmarks];
	[archived_data writeToURL:url atomically:YES];    
}

- (void)readManualBookmarksFromDataStore
{
    [_manual_bookmarks autorelease];
    _manual_bookmarks = [self arrayFromDataStoreURL:[self manualBookmarksDataStoreURL]];

    if(_manual_bookmarks == nil)
    {
        _manual_bookmarks = [[NSMutableArray alloc] init];
        [_manual_bookmarks addObject:[[[GlobalDefaults sharedGlobalDefaults] newTestServerBookmark] autorelease]];
    }
}

- (void)readConnectionHistoryFromDataStore
{
    [_connection_history autorelease];
    _connection_history = [self arrayFromDataStoreURL:[self connectionHistoryDataStoreURL]];
    
    if(_connection_history == nil)
        _connection_history = [[NSMutableArray alloc] init];
}

- (NSMutableArray*)arrayFromDataStoreURL:(NSURL*)url
{
	NSData* archived_data = [NSData dataWithContentsOfURL:url];
	
	if (!archived_data)
		return nil;
    
	return [[NSKeyedUnarchiver unarchiveObjectWithData:archived_data] retain];
}

- (NSURL*)manualBookmarksDataStoreURL
{
	return [NSURL fileURLWithPath:[NSString stringWithFormat:@"%@/%@", [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject], @"com.freerdp.ifreerdp.bookmarks.plist"]];
}

- (NSURL*)connectionHistoryDataStoreURL
{
	return [NSURL fileURLWithPath:[NSString stringWithFormat:@"%@/%@", [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject], @"com.freerdp.ifreerdp.connection_history.plist"]];
}

@end