CPDocument.j

Go to the documentation of this file.

/*
 * CPDocument.j
 * AppKit
 *
 * Created by Francisco Tolmasky.
 * Copyright 2008, 280 North, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */




@global CPApp


/*
    @global
    @group CPSaveOperationType
*/
CPSaveOperation             = 0;
/*
    @global
    @group CPSaveOperationType
*/
CPSaveAsOperation           = 1;
/*
    @global
    @group CPSaveOperationType
*/
CPSaveToOperation           = 2;
/*
    @global
    @group CPSaveOperationType
*/
CPAutosaveOperation         = 3;

/*
    @global
    @group CPDocumentChangeType
*/
CPChangeDone                = 0;
/*
    @global
    @group CPDocumentChangeType
*/
CPChangeUndone              = 1;
/*
    @global
    @group CPDocumentChangeType
*/
CPChangeCleared             = 2;
/*
    @global
    @group CPDocumentChangeType
*/
CPChangeReadOtherContents   = 3;
/*
    @global
    @group CPDocumentChangeType
*/
CPChangeAutosaved           = 4;

CPDocumentWillSaveNotification      = @"CPDocumentWillSaveNotification";
CPDocumentDidSaveNotification       = @"CPDocumentDidSaveNotification";
CPDocumentDidFailToSaveNotification = @"CPDocumentDidFailToSaveNotification";

var CPDocumentUntitledCount = 0;

@implementation CPDocument : CPResponder
{
    CPWindow            _window; // For outlet purposes.
    CPView              _view; // For outlet purposes
    CPDictionary        _viewControllersForWindowControllers;

    CPURL               _fileURL;
    CPString            _fileType;
    CPArray             _windowControllers;
    unsigned            _untitledDocumentIndex;

    BOOL                _hasUndoManager;
    CPUndoManager       _undoManager;

    int                 _changeCount;

    CPURLConnection     _readConnection;
    CPURLRequest        _writeRequest;

    CPAlert             _canCloseAlert;
}

- (id)init
{
    self = [super init];

    if (self)
    {
        _windowControllers = [];
        _viewControllersForWindowControllers = @{};

        _hasUndoManager = YES;
        _changeCount = 0;

        [self setNextResponder:CPApp];
    }

    return self;
}

- (id)initWithType:(CPString)aType error:(/*{*/CPError/*}*/)anError
{
    self = [self init];

    if (self)
        [self setFileType:aType];

    return self;
}

- (id)initWithContentsOfURL:(CPURL)anAbsoluteURL ofType:(CPString)aType delegate:(id)aDelegate didReadSelector:(SEL)aDidReadSelector contextInfo:(id)aContextInfo
{
    self = [self init];

    if (self)
    {
        [self setFileURL:anAbsoluteURL];
        [self setFileType:aType];

        [self readFromURL:anAbsoluteURL ofType:aType delegate:aDelegate didReadSelector:aDidReadSelector contextInfo:aContextInfo];
    }

    return self;
}

- (id)initForURL:(CPURL)anAbsoluteURL withContentsOfURL:(CPURL)absoluteContentsURL ofType:(CPString)aType delegate:(id)aDelegate didReadSelector:(SEL)aDidReadSelector contextInfo:(id)aContextInfo
{
    self = [self init];

    if (self)
    {
        [self setFileURL:anAbsoluteURL];
        [self setFileType:aType];

        [self readFromURL:absoluteContentsURL ofType:aType delegate:aDelegate didReadSelector:aDidReadSelector contextInfo:aContextInfo];
    }

    return self;
}

- (CPData)dataOfType:(CPString)aType error:(/*{*/CPError/*}*/)anError
{
    [CPException raise:CPUnsupportedMethodException
                reason:"dataOfType:error: must be overridden by the document subclass."];
}

- (void)readFromData:(CPData)aData ofType:(CPString)aType error:(CPError)anError
{
    [CPException raise:CPUnsupportedMethodException
                reason:"readFromData:ofType: must be overridden by the document subclass."];
}

- (void)viewControllerWillLoadCib:(CPViewController)aViewController
{
}

- (void)viewControllerDidLoadCib:(CPViewController)aViewController
{
}

// Creating and managing window controllers
- (void)makeWindowControllers
{
    [self makeViewAndWindowControllers];
}

- (void)makeViewAndWindowControllers
{
    var viewCibName = [self viewCibName],
        windowCibName = [self windowCibName],
        viewController = nil,
        windowController = nil;

    // Create our view controller if we have a cib for it.
    if ([viewCibName length])
        viewController = [[CPViewController alloc] initWithCibName:viewCibName bundle:nil owner:self];

    // From a cib if we have one.
    if ([windowCibName length])
        windowController = [[CPWindowController alloc] initWithWindowCibName:windowCibName owner:self];

    // If not you get a standard window capable of displaying multiple documents and view
    else if (viewController)
    {
        var view = [viewController view],
            viewFrame = [view frame];

        viewFrame.origin = CGPointMake(50, 50);

        var theWindow = [[CPWindow alloc] initWithContentRect:viewFrame styleMask:CPTitledWindowMask | CPClosableWindowMask | CPMiniaturizableWindowMask | CPResizableWindowMask];

        windowController = [[CPWindowController alloc] initWithWindow:theWindow];
    }

    if (windowController && viewController)
        [windowController setSupportsMultipleDocuments:YES];

    if (windowController)
        [self addWindowController:windowController];

    if (viewController)
        [self addViewController:viewController forWindowController:windowController];
}

- (CPArray)windowControllers
{
    return _windowControllers;
}

- (void)addWindowController:(CPWindowController)aWindowController
{
    [_windowControllers addObject:aWindowController];

    if ([aWindowController document] !== self)
        [aWindowController setDocument:self];
}

- (void)removeWindowController:(CPWindowController)aWindowController
{
    if (aWindowController)
        [_windowControllers removeObject:aWindowController];

    if ([aWindowController document] === self)
        [aWindowController setDocument:nil];
}

- (CPView)view
{
    return _view;
}

- (CPArray)viewControllers
{
    return [_viewControllersForWindowControllers allValues];
}

- (void)addViewController:(CPViewController)aViewController forWindowController:(CPWindowController)aWindowController
{
    // FIXME: exception if we don't own the window controller?
    [_viewControllersForWindowControllers setObject:aViewController forKey:[aWindowController UID]];

    if ([aWindowController document] === self)
        [aWindowController setViewController:aViewController];
}

- (void)removeViewController:(CPViewController)aViewController
{
    [_viewControllersForWindowControllers removeObject:aViewController];
}

- (CPViewController)viewControllerForWindowController:(CPWindowController)aWindowController
{
    return [_viewControllersForWindowControllers objectForKey:[aWindowController UID]];
}

// Managing Document Windows
- (void)showWindows
{
    [_windowControllers makeObjectsPerformSelector:@selector(setDocument:) withObject:self];
    [_windowControllers makeObjectsPerformSelector:@selector(showWindow:) withObject:self];
}

- (CPString)displayName
{
    if (_fileURL)
        return [_fileURL lastPathComponent];

    if (!_untitledDocumentIndex)
        _untitledDocumentIndex = ++CPDocumentUntitledCount;

    if (_untitledDocumentIndex == 1)
       return @"Untitled";

    return @"Untitled " + _untitledDocumentIndex;
}

- (CPString)viewCibName
{
    return nil;
}

- (CPString)windowCibName
{
    return nil;
}

- (void)windowControllerDidLoadCib:(CPWindowController)aWindowController
{
}

- (void)windowControllerWillLoadCib:(CPWindowController)aWindowController
{
}

// Reading from and Writing to URLs
- (void)readFromURL:(CPURL)anAbsoluteURL ofType:(CPString)aType delegate:(id)aDelegate didReadSelector:(SEL)aDidReadSelector contextInfo:(id)aContextInfo
{
    [_readConnection cancel];

    // FIXME: Oh man is this every looking for trouble, we need to handle login at the Cappuccino level, with HTTP Errors.
    _readConnection = [CPURLConnection connectionWithRequest:[CPURLRequest requestWithURL:anAbsoluteURL] delegate:self];

    _readConnection.session = _CPReadSessionMake(aType, aDelegate, aDidReadSelector, aContextInfo);
}

- (CPURL)fileURL
{
    return _fileURL;
}

- (void)setFileURL:(CPURL)aFileURL
{
    if (_fileURL === aFileURL)
        return;

    _fileURL = aFileURL;

    [_windowControllers makeObjectsPerformSelector:@selector(synchronizeWindowTitleWithDocumentName)];
}

- (void)saveToURL:(CPURL)anAbsoluteURL ofType:(CPString)aTypeName forSaveOperation:(CPSaveOperationType)aSaveOperation delegate:(id)aDelegate didSaveSelector:(SEL)aDidSaveSelector contextInfo:(id)aContextInfo
{
    var data = [self dataOfType:[self fileType] error:nil],
        oldChangeCount = _changeCount;

    _writeRequest = [CPURLRequest requestWithURL:anAbsoluteURL];

    // FIXME: THIS IS WRONG! We need a way to decide
    if ([CPPlatform isBrowser])
        [_writeRequest setHTTPMethod:@"POST"];
    else
        [_writeRequest setHTTPMethod:@"PUT"];

    [_writeRequest setHTTPBody:[data rawString]];

    [_writeRequest setValue:@"close" forHTTPHeaderField:@"Connection"];

    if (aSaveOperation === CPSaveOperation)
        [_writeRequest setValue:@"true" forHTTPHeaderField:@"x-cappuccino-overwrite"];

    if (aSaveOperation !== CPSaveToOperation)
        [self updateChangeCount:CPChangeCleared];

    // FIXME: Oh man is this every looking for trouble, we need to handle login at the Cappuccino level, with HTTP Errors.
    var connection = [CPURLConnection connectionWithRequest:_writeRequest delegate:self];

    connection.session = _CPSaveSessionMake(anAbsoluteURL, aSaveOperation, oldChangeCount, aDelegate, aDidSaveSelector, aContextInfo, connection);
}

/*
    Implemented as a delegate method for CPURLConnection
    @ignore
*/
- (void)connection:(CPURLConnection)aConnection didReceiveResponse:(CPURLResponse)aResponse
{
    // If we got this far and it wasn't an HTTP request, then everything is fine.
    if (![aResponse isKindOfClass:[CPHTTPURLResponse class]])
        return;

    var statusCode = [aResponse statusCode];

    // Nothing to do if everything is hunky dory.
    if (statusCode === 200)
        return;

    var session = aConnection.session;

    if (aConnection == _readConnection)
    {
        [aConnection cancel];

        alert("There was an error retrieving the document.");

        var theDelegate = session.delegate;

        theDelegate.isa.objj_msgSend3(theDelegate, session.didReadSelector, self, NO, session.contextInfo);
    }
    else
    {
        // 409: Conflict, in Cappuccino, overwrite protection for documents.
        if (statusCode == 409)
        {
            [aConnection cancel];

            if (confirm("There already exists a file with that name, would you like to overwrite it?"))
            {
                [_writeRequest setValue:@"true" forHTTPHeaderField:@"x-cappuccino-overwrite"];

                [aConnection start];
            }
            else
            {
                if (session.saveOperation != CPSaveToOperation)
                {
                    _changeCount += session.changeCount;
                    [_windowControllers makeObjectsPerformSelector:@selector(setDocumentEdited:) withObject:[self isDocumentEdited]];
                }

                _writeRequest = nil;

                var theDelegate = session.delegate;

                theDelegate.isa.objj_msgSend3(theDelegate, session.didSaveSelector, self, NO, session.contextInfo);
                [self _sendDocumentSavedNotification:NO];
            }
        }
    }
}

/*
    Implemented as a delegate method for CPURLConnection
    @ignore
*/
- (void)connection:(CPURLConnection)aConnection didReceiveData:(CPString)aData
{
    var session = aConnection.session,
        theDelegate = session.delegate;

    // READ
    if (aConnection == _readConnection)
    {
        [self readFromData:[CPData dataWithRawString:aData] ofType:session.fileType error:nil];

        theDelegate.isa.objj_msgSend3(theDelegate, session.didReadSelector, self, YES, session.contextInfo);
    }
    else
    {
        if (session.saveOperation != CPSaveToOperation)
            [self setFileURL:session.absoluteURL];

        _writeRequest = nil;

        theDelegate.isa.objj_msgSend3(theDelegate, session.didSaveSelector, self, YES, session.contextInfo);
        [self _sendDocumentSavedNotification:YES];
    }
}

/*
    Implemented as a delegate method for CPURLConnection
    @ignore
*/
- (void)connection:(CPURLConnection)aConnection didFailWithError:(CPError)anError
{
    var session = aConnection.session,
        theDelegate = session.delegate;

    if (_readConnection == aConnection)
        theDelegate.isa.objj_msgSend3(theDelegate, session.didReadSelector, self, NO, session.contextInfo);

    else
    {
        if (session.saveOperation != CPSaveToOperation)
        {
            _changeCount += session.changeCount;
            [_windowControllers makeObjectsPerformSelector:@selector(setDocumentEdited:) withObject:[self isDocumentEdited]];
        }

        _writeRequest = nil;

        alert("There was an error saving the document.");

        theDelegate.isa.objj_msgSend3(theDelegate, session.didSaveSelector, self, NO, session.contextInfo);
        [self _sendDocumentSavedNotification:NO];
    }
}

/*
    Implemented as a delegate method for CPURLConnection
    @ignore
*/
- (void)connectionDidFinishLoading:(CPURLConnection)aConnection
{
    if (_readConnection == aConnection)
        _readConnection = nil;
}

// Managing Document Status
- (BOOL)isDocumentEdited
{
    return _changeCount != 0;
}

- (void)updateChangeCount:(CPDocumentChangeType)aChangeType
{
    if (aChangeType == CPChangeDone)
        ++_changeCount;
    else if (aChangeType == CPChangeUndone)
        --_changeCount;
    else if (aChangeType == CPChangeCleared)
        _changeCount = 0;
    /*else if (aChangeType == CPCHangeReadOtherContents)

    else if (aChangeType == CPChangeAutosaved)*/

    [_windowControllers makeObjectsPerformSelector:@selector(setDocumentEdited:) withObject:[self isDocumentEdited]];
}

// Managing File Types
- (void)setFileType:(CPString)aType
{
    _fileType = aType;
}

- (CPString)fileType
{
    return _fileType;
}

// Working with Undo Manager
- (BOOL)hasUndoManager
{
    return _hasUndoManager;
}

- (void)setHasUndoManager:(BOOL)aFlag
{
    if (_hasUndoManager == aFlag)
        return;

    _hasUndoManager = aFlag;

    if (!_hasUndoManager)
        [self setUndoManager:nil];
}

/* @ignore */
- (void)_undoManagerWillCloseGroup:(CPNotification)aNotification
{
    var undoManager = [aNotification object];

    if ([undoManager isUndoing] || [undoManager isRedoing])
        return;

    [self updateChangeCount:CPChangeDone];
}

/* @ignore */
- (void)_undoManagerDidUndoChange:(CPNotification)aNotification
{
    [self updateChangeCount:CPChangeUndone];
}

/* @ignore */
- (void)_undoManagerDidRedoChange:(CPNotification)aNotification
{
    [self updateChangeCount:CPChangeDone];
}

/*
    Sets the document's undo manager. This method will add the
    undo manager as an observer to the notification center.
    @param anUndoManager the new undo manager for the document
*/
- (void)setUndoManager:(CPUndoManager)anUndoManager
{
    var defaultCenter = [CPNotificationCenter defaultCenter];

    if (_undoManager)
    {
        [defaultCenter removeObserver:self
                                 name:CPUndoManagerDidUndoChangeNotification
                               object:_undoManager];

        [defaultCenter removeObserver:self
                                 name:CPUndoManagerDidRedoChangeNotification
                               object:_undoManager];

        [defaultCenter removeObserver:self
                                 name:CPUndoManagerWillCloseUndoGroupNotification
                               object:_undoManager];
    }

    _undoManager = anUndoManager;

    if (_undoManager)
    {

        [defaultCenter addObserver:self
                          selector:@selector(_undoManagerDidUndoChange:)
                              name:CPUndoManagerDidUndoChangeNotification
                            object:_undoManager];

        [defaultCenter addObserver:self
                          selector:@selector(_undoManagerDidRedoChange:)
                              name:CPUndoManagerDidRedoChangeNotification
                            object:_undoManager];

        [defaultCenter addObserver:self
                          selector:@selector(_undoManagerWillCloseGroup:)
                              name:CPUndoManagerWillCloseUndoGroupNotification
                            object:_undoManager];
    }
}

- (CPUndoManager)undoManager
{
    if (_hasUndoManager && !_undoManager)
        [self setUndoManager:[[CPUndoManager alloc] init]];

    return _undoManager;
}

/*
    Implemented as a delegate of a CPWindow
    @ignore
*/
- (CPUndoManager)windowWillReturnUndoManager:(CPWindow)aWindow
{
    return [self undoManager];
}

// Handling User Actions
- (void)saveDocument:(id)aSender
{
    [self saveDocumentWithDelegate:nil didSaveSelector:nil contextInfo:nil];
}

- (void)saveDocumentWithDelegate:(id)delegate didSaveSelector:(SEL)didSaveSelector contextInfo:(Object)contextInfo
{
    if (_fileURL)
    {
        [[CPNotificationCenter defaultCenter]
            postNotificationName:CPDocumentWillSaveNotification
                          object:self];

        [self saveToURL:_fileURL ofType:[self fileType] forSaveOperation:CPSaveOperation delegate:delegate didSaveSelector:didSaveSelector contextInfo:contextInfo];
    }
    else
        [self _saveDocumentAsWithDelegate:delegate didSaveSelector:didSaveSelector contextInfo:contextInfo];
}

- (void)saveDocumentAs:(id)aSender
{
    [self _saveDocumentAsWithDelegate:nil didSaveSelector:nil contextInfo:nil];
}

- (void)_saveDocumentAsWithDelegate:(id)delegate didSaveSelector:(SEL)didSaveSelector contextInfo:(Object)contextInfo
{
    var savePanel = [CPSavePanel savePanel],
        response = [savePanel runModal];

    if (!response)
        return;

    var saveURL = [savePanel URL];

    [[CPNotificationCenter defaultCenter]
        postNotificationName:CPDocumentWillSaveNotification
                      object:self];

    [self saveToURL:saveURL ofType:[self fileType] forSaveOperation:CPSaveAsOperation delegate:delegate didSaveSelector:didSaveSelector contextInfo:contextInfo];
}

/*
    @ignore
*/
- (void)_sendDocumentSavedNotification:(BOOL)didSave
{
    if (didSave)
        [[CPNotificationCenter defaultCenter]
            postNotificationName:CPDocumentDidSaveNotification
                          object:self];
    else
        [[CPNotificationCenter defaultCenter]
            postNotificationName:CPDocumentDidFailToSaveNotification
                          object:self];
}

@end

@implementation CPDocument (ClosingDocuments)

- (void)close
{
    [_windowControllers makeObjectsPerformSelector:@selector(removeDocumentAndCloseIfNecessary:) withObject:self];
    [[CPDocumentController sharedDocumentController] removeDocument:self];
}

- (void)shouldCloseWindowController:(CPWindowController)controller delegate:(id)delegate shouldCloseSelector:(SEL)selector contextInfo:(Object)info
{
    if ([controller shouldCloseDocument] || ([_windowControllers count] < 2 && [_windowControllers indexOfObject:controller] !== CPNotFound))
        [self canCloseDocumentWithDelegate:self shouldCloseSelector:@selector(_document:shouldClose:context:) contextInfo:{delegate:delegate, selector:selector, context:info}];

    else if ([delegate respondsToSelector:selector])
        delegate.isa.objj_msgSend3(delegate, selector, self, YES, info);
}

- (void)_document:(CPDocument)aDocument shouldClose:(BOOL)shouldClose context:(Object)context
{
    var theDelegate = context.delegate;

    if (aDocument === self && shouldClose)
        [self close];

    if (theDelegate != null)
        theDelegate.isa.objj_msgSend3(theDelegate, context.selector, aDocument, shouldClose, context.context);
}

- (void)canCloseDocumentWithDelegate:(id)aDelegate shouldCloseSelector:(SEL)aSelector contextInfo:(Object)context
{
    if (![self isDocumentEdited])
        return [aDelegate respondsToSelector:aSelector] && aDelegate.isa.objj_msgSend3(aDelegate, aSelector, self, YES, context);

    _canCloseAlert = [[CPAlert alloc] init];

    [_canCloseAlert setDelegate:self];
    [_canCloseAlert setAlertStyle:CPWarningAlertStyle];
    [_canCloseAlert setTitle:@"Unsaved Document"];
    [_canCloseAlert setMessageText:@"Do you want to save the changes you've made to the document \"" + ([self displayName] || [self fileName]) + "\"?"];

    [_canCloseAlert addButtonWithTitle:@"Save"];
    [_canCloseAlert addButtonWithTitle:@"Cancel"];
    [_canCloseAlert addButtonWithTitle:@"Don't Save"];

    _canCloseAlert._context = {delegate:aDelegate, selector:aSelector, context:context};

    [_canCloseAlert runModal];
}

- (void)alertDidEnd:(CPAlert)alert returnCode:(int)returnCode
{
    if (alert !== _canCloseAlert)
        return;

    var delegate = alert._context.delegate,
        selector = alert._context.selector,
        context = alert._context.context;

    if (returnCode === 0)
        [self saveDocumentWithDelegate:delegate didSaveSelector:selector contextInfo:context];
    else if (delegate != null)
        delegate.isa.objj_msgSend3(delegate, selector, self, returnCode === 2, context);

    _canCloseAlert = nil;
}

@end

var _CPReadSessionMake = function(aType, aDelegate, aDidReadSelector, aContextInfo)
{
    return { fileType:aType, delegate:aDelegate, didReadSelector:aDidReadSelector, contextInfo:aContextInfo };
};

var _CPSaveSessionMake = function(anAbsoluteURL, aSaveOperation, aChangeCount, aDelegate, aDidSaveSelector, aContextInfo, aConnection)
{
    return { absoluteURL:anAbsoluteURL, saveOperation:aSaveOperation, changeCount:aChangeCount, delegate:aDelegate, didSaveSelector:aDidSaveSelector, contextInfo:aContextInfo, connection:aConnection };
};