Creating document based applications - Revision history

Newacct at 21:17, 3 February 2011

2011-02-03T21:17:58Z

Befree: /* NSDocument subclass */

2008-05-08T07:20:49Z

NSDocument subclass

Comrade: Small language changes and punctuation update

2005-11-29T10:26:06Z

Small language changes and punctuation update

Quineska: /* Application Interface File */

2005-11-28T00:39:16Z

Application Interface File

Mguesdon: /* Introduction */

2005-08-29T14:38:40Z

Introduction

Quineska: /* Document Interface File(s) */ - Added better subclassing information/Fixed typo

2005-07-29T02:53:39Z

Document Interface File(s): - Added better subclassing information/Fixed typo

Quineska: /* Code */

2005-07-29T02:50:12Z

Code

Quineska: Spelling errors, grammatical fixes

2005-07-09T02:18:37Z

Spelling errors, grammatical fixes

Quineska: Spelling errors, grammatical fixes

2005-07-09T02:08:00Z

Spelling errors, grammatical fixes

Quineska: Spelling errors, grammatical fixes

2005-07-09T02:03:41Z

Spelling errors, grammatical fixes

@@ Line 4: / Line 4: @@
 == Introduction ==
-[[OpenStep]] supports document-based applications, simplifing the process of creating applications whose behaviour is familiar to many users. [[GNUstep]] also provides this functionality to the developer. This guide aims to provide an overview of what is required in the creation and design of such an application.
+[[OpenStep]] supports document-based applications, simplifying the process of creating applications whose behaviour is familiar to many users. [[GNUstep]] also provides this functionality to the developer. This guide aims to provide an overview of what is required in the creation and design of such an application.
 It is assumed you are familiar with GNUstep, and have some understanding as how to create [[Gorm]]'s interface files (often referred to as nibs), as well as some understanding of how they work.
@@ Line 22: / Line 22: @@
 ==== NSWindowController ====
-As mentioned above, NSWindowController instances are individually associated with one NSWindow instance, in such a way that a document maintains a list of window controllers that are reponsible for rendering the views associated with a document.
+As mentioned above, NSWindowController instances are individually associated with one NSWindow instance, in such a way that a document maintains a list of window controllers that are responsible for rendering the views associated with a document.
 You will most likely not have to subclass NSWindowController. Instead, you associate a nib file (the Gorm output) with the subclass of NSDocument, and NSDocumentController will load this nib file for each document that is created or loaded.
@@ Line 65: / Line 65: @@
 * '''NSHumanReadableName:''' The human readable name of your document type (string)? TODO: explain where this is used.
 * '''NSUnixExtensions:''' An array of strings, each containing a file extension connected to this document type on "unix" platforms. TODO: explain how "unix" is interpreted by GNUstep.
-* '''NSDOSExtensions:''' An array of strings, each containing a file extenstion connected to this document type on "DOS" platforms (could be loosely interpreted as any MS platforms GNUstep runs on, i.e. Windows 2000/XP).
+* '''NSDOSExtensions:''' An array of strings, each containing a file extension connected to this document type on "DOS" platforms (could be loosely interpreted as any MS platforms GNUstep runs on, i.e. Windows 2000/XP).
 * '''NSRole:''' A string, either "Viewer" or "Editor", depending on how your document operates on this file type.
 * '''NSIcon:''' A icon name associated with this document type. TODO: Investigate how this works.
@@ Line 156: / Line 156: @@
 ==== loadDataRepresentation:ofType: and dataRepresentationOfType: ====
-The methods, loadDataRepresent:ofType: and dataRepresentationOfType: are used by NSDocumentController to load and save our files. The first method is called when the user trys to open a document (NSDocumentController gets the file name and copies it's data using an open panel). The method is passed the raw data in this file, as well as a string representing its type. It is important to note that this type string is the same one used in your property list. It is used by NSDocumentController to tell you what type it thinks you should open the data with. If this is not possible, or if there is an error trying to parse the data, your method returns FALSE/NO. Otherwise, you should store a local, meaningful representation of the data, which you can insert into your document window a little later (and return TRUE/YES).
+The methods, loadDataRepresent:ofType: and dataRepresentationOfType: are used by NSDocumentController to load and save our files. The first method is called when the user tries to open a document (NSDocumentController gets the file name and copies it's data using an open panel). The method is passed the raw data in this file, as well as a string representing its type. It is important to note that this type string is the same one used in your property list. It is used by NSDocumentController to tell you what type it thinks you should open the data with. If this is not possible, or if there is an error trying to parse the data, your method returns FALSE/NO. Otherwise, you should store a local, meaningful representation of the data, which you can insert into your document window a little later (and return TRUE/YES).
 For example, in terms of the TextEdit example:
@@ Line 162: / Line 162: @@
+  {
      /*Check type information */
-     if ([type equalTo:GSTextDocumentType]==NO)
+     if (![type isEqual:GSTextDocumentType])
          return NO;
      /* Clean out our old representation if it still exists */
@@ Line 187: / Line 187: @@
   - (NSData*) dataRepresentationOfType:(NSString*)type
+  {
-      if ([type equalTo:GSTextDocumentType]==NO)
+      if (![type isEqual:GSTextDocumentType])
           return nil; <br>
       NSData stringData =  [[textView string] dataUsingEncoding:NSASCIIStringEncoding];
@@ Line 197: / Line 197: @@
 ==== windowNibName ====
-This method must be overriden to return the a string of the name of your nib file (without the file extension). More complex implementations will use other methods to load the interface files. TODO: information on what methods need to be overriden.
+This method must be overridden to return the a string of the name of your nib file (without the file extension). More complex implementations will use other methods to load the interface files. TODO: information on what methods need to be overridden.
 ==== windowControllerDidLoadNib: ====
@@ Line 232: / Line 232: @@
 This class can also be optionally subclassed, to implement functionality specific to a window controller for a document type. You may need to override makeWindowControllers: in the NSDocument subclass in order to make sure your specific window controller is instantiated.
-You should use separate implemenation files and add the .m file to GNUmakefile.
+You should use separate implementation files and add the .m file to GNUmakefile.
 == Optional Additions ==

@@ Line 142: / Line 142: @@
       /* Outlets we added in our Gorm nib file */
       id * textView;
+  }
   /* Basic methods used for loading and saving document data (respectively). */
@@ Line 161: / Line 162: @@
+  {
      /*Check type information */
-     if ([representation equalTo:GSTextDocumentType]==NO)
+     if ([type equalTo:GSTextDocumentType]==NO)
          return NO;
      /* Clean out our old representation if it still exists */
-     if (fileContents) RELEASE(fileContents); <br>
+     if (self->fileContents) RELEASE(self->fileContents); <br>
      /* Allocate room for the new data, and try to initialise a string with it. */
      self->fileContents = [NSString alloc];
-     fileContents = [fileContents initWithBytes: [representation bytes]
+     self->fileContents = [self->fileContents initWithBytes: [representation bytes]
-                         length: [representation length]
+                                                    length: [representation length]
-                       encoding: NSASCIIStringEncoding]; <br>
+                                                  encoding: NSASCIIStringEncoding]; <br>
      /* If this can't be done, return NO */
-     if (!fileContents)
+     if (!self->fileContents)
          return NO; <br>
      /* Otherwise, set our TextView to the string data. */

@@ Line 4: / Line 4: @@
 == Introduction ==
-[[OpenStep]] can provide your application a document-based model. It helps to simplify the process of creating such applications. [[GNUstep]] implements this as well; this document aims to provide an overview of what is required in the creation and design of such an application.
+[[OpenStep]] supports document-based applications, simplifing the process of creating applications whose behaviour is familiar to many users. [[GNUstep]] also provides this functionality to the developer. This guide aims to provide an overview of what is required in the creation and design of such an application.
-It is assumed you are familiar with GNUstep, and have some understanding as how to create [[Gorm]]'s interface files (often referred to as nib's), as well as some understanding of how they work.
+It is assumed you are familiar with GNUstep, and have some understanding as how to create [[Gorm]]'s interface files (often referred to as nibs), as well as some understanding of how they work.
 Importantly, such applications have certain components that are required, and should be considered as part of their design. When programming, classes that will be used as part of the [[AppKit]] are:

@@ Line 106: / Line 106: @@
 The application one should just be a menu (though it could be more if necessary). When constructing it, take the following into account:
-* Use a standard Gorm template for an Application.
+* '''Use an "Application" template''': Use a standard Gorm template for an Application.
-* Delete the window instance in the "Objects" pane (unless you need a main window, which is beyond the scope of this document).
+* '''Delete the NSWindow instance''': In the "Objects" pane, remove the NSWindow instance by going File->Delete (unless you need a main window, which is beyond the scope of this document).
-* Set NSOwner's class to "NSDocumentController". This is the custom class option of NSOwner in the property inspector. This ensures that the openDocument:, newDocument: messages, as sent to NSFirst, get picked up by NSDocumentController. Do not instantiate it (I believe you can't anyway).
+* '''Set NSOwner's class to "NSDocumentController"''': This is the custom class option of NSOwner in the property inspector. This ensures that the openDocument:, newDocument: messages, as sent to NSFirst, get picked up by NSDocumentController. Do not instantiate it (I believe you can't anyway).
-* If you intend to subclass NSDocumentController, subclass it in the Classes pane. To make sure that this class is instantiated and used, make sure you instantiate it in Gorm or in your main.m file, and set NSOwner to be your subclass.
+* '''[Optional] Subclass NSDocumentController''':If you intend to subclass NSDocumentController, subclass it in the Classes pane. To make sure that this class is instantiated and used, make sure you instantiate it in Gorm or in your main.m file, and then set NSOwner to be of your custom subclass type.
-* Drag a Document menu from the palette onto your main menu. This already has the proper outlet and action linkage for each relevant message to be directed to NSFirst. Generic messages (such as openDocument:, not associated with any document instance) are forwarded to the shared instance of NSDocumentController (see it's reference documentation). When a document is active, more specific messages (such as close: or saveDocument:) are forwarded to the relevant document instance of your NSDocument subclass.
+* '''Add a "Document" menu''': Drag a Document menu from the palette onto your main menu. This already has the proper outlet and action linkage for each relevant message to be directed to NSFirst. Generic messages (such as openDocument:, not associated with any document instance) are forwarded to the shared instance of NSDocumentController (see it's reference documentation). When a document is active, more specific messages (such as close: or saveDocument:) are forwarded to the relevant document instance of your NSDocument subclass.
-* Add any appropriate menus such as "Info" and "Format" which may be relevant to your application.
+* '''[Optional] Add other menus''': Add any appropriate menus such as "Info" and "Format" which may be relevant to your application.
 ==== Document Interface File(s) ====

@@ Line 4: / Line 4: @@
 == Introduction ==
-OpenStep can provide your application a document-based model. It helps to simplify the process of creating such applications. GNUstep implements this as well; this document aims to provide an overview of what is required in the creation and design of such an application.
+[[OpenStep]] can provide your application a document-based model. It helps to simplify the process of creating such applications. [[GNUstep]] implements this as well; this document aims to provide an overview of what is required in the creation and design of such an application.
-It is assumed you are familiar with GNUstep, and have some understanding as how to create Gorm's interface files (often referred to as nib's), as well as some understanding of how they work.
+It is assumed you are familiar with GNUstep, and have some understanding as how to create [[Gorm]]'s interface files (often referred to as nib's), as well as some understanding of how they work.
-Importantly, such applications have certain components that are required, and should be considered as part of their design. When programming, classes that will be used as part of the AppKit are:
+Importantly, such applications have certain components that are required, and should be considered as part of their design. When programming, classes that will be used as part of the [[AppKit]] are:
 ==== NSDocument ====

@@ Line 115: / Line 115: @@
 ==== Document Interface File(s) ====
-The document interface file is a window containing the view(s) required for the implementation of one instance of your document type. For example, in the case of a TextDocument type, a window instance with a NSTextView drawn on it is used for each document window. This interface file is instantiated every time a person creates a new document (the newDocument: message goes to NSDocumentController) or opens an existing document (openDocument:).
+The document interface file is a window containing the view(s) required for the implementation of one instance of your document type. For example, in the case of a TextDocument type, a window instance with a NSTextView drawn on it is used for each document window. This interface file is instantiated every time a person creates a new document (the newDocument: message is sent to NSDocumentController) or opens an existing document (openDocument:).
 You will need to:
-* '''Subclass NSDocument''' with your document type in Gorm. This is done in a couple of ways, see [[Gorm_Manual#Custom_classes|custom classes]].
+* '''Subclass NSDocument''' with your document type in Gorm. This is done in a couple of ways, see [[Gorm_Manual#Custom_classes|custom classes]]. It is up to you whether or not you let Gorm generate the class files, but make sure you add the appropriate outlets to your class in the source files (otherwise, I think your your program may segfault).
-* '''Set NSOwner:''' Set your subclass as NSOwner's Custom class using the Property Inspector). DO NOT INSTANTIATE IT.
+* '''Set NSOwner:''' Set your subclass as NSOwner's Custom class using the Property Inspector. ''DO NOT INSTANTIATE IT.''
 Another thing that you may want to consider is custom outlets. If you place certain views or controls on your window (including the window itself), you may want to refer to them directly in your code, e.g. the NSTextView in our TextEdit example is accessed directly, so that we can save it's contents to a file. To enable this, we add outlets to our class (see [[Gorm_Manual#Custom_classes|custom classes]]). We then connect NSOwner to the appropriate controls/views, and select the outlets in the Connections Property Inspector (see [[Gorm_Manual#Editing_the_interface|editing the interface]]).

@@ Line 208: / Line 208: @@
 ==== makeWindowControllers ====
-This is an optional method override, which must be used if you have multiple window controllers per document. It is responsible for creating each window controller from it's interface file and then adding it to the document. Use the addWindowController: method.
+This is an optional method to override, which must be used if you have multiple window controllers per document. It is responsible for creating each window controller from it's interface file and then adding it to the document. Use the addWindowController: method.
 ==== Other considerations ====

@@ Line 107: / Line 107: @@
 * Use a standard Gorm template for an Application.
-* Delete the window instance in the "Objects" pane (unless you need a main window, in which case I don't know how to operate).
+* Delete the window instance in the "Objects" pane (unless you need a main window, which is beyond the scope of this document).
-* Set NSOwner's class to "NSDocumentController" (this is the custom class option of NSOwner in the property inspector). This ensures openDocument, newDocument, etc. messages, as sent to NSFirst, get picked up by NSDocumentController. Do not instantiate it (I believe you can't anyway).
+* Set NSOwner's class to "NSDocumentController". This is the custom class option of NSOwner in the property inspector. This ensures that the openDocument:, newDocument: messages, as sent to NSFirst, get picked up by NSDocumentController. Do not instantiate it (I believe you can't anyway).
 * If you intend to subclass NSDocumentController, subclass it in the Classes pane. To make sure that this class is instantiated and used, make sure you instantiate it in Gorm or in your main.m file, and set NSOwner to be your subclass.
-* Drag a Document menu from the palette onto your main menu. This already has the proper linkage for each relevant message for a document setup to be directed to NSFirst. In the case of generic messages (such as openDocument:, not associated with any document instance), these are forwarded to the shared instance of NSDocumentController (see it's reference documentation). When a document is active, more specific messages (such as close: or saveDocument:) are forwarded to the relevant document instance of your NSDocument subclass.
+* Drag a Document menu from the palette onto your main menu. This already has the proper outlet and action linkage for each relevant message to be directed to NSFirst. Generic messages (such as openDocument:, not associated with any document instance) are forwarded to the shared instance of NSDocumentController (see it's reference documentation). When a document is active, more specific messages (such as close: or saveDocument:) are forwarded to the relevant document instance of your NSDocument subclass.
 * Add any appropriate menus such as "Info" and "Format" which may be relevant to your application.
 ==== Document Interface File(s) ====
-The document interface file is (generically) a window containing the view(s) required for the implementation of one instance of your document type. For example, in the case of a TextDocument type, a window instance with a NSTextView drawn on it is used for each open window. This nib file is instantiated every time a person creates a new document (the newDocument: message goes to NSDocumentController) or opens an existing document (openDocument:).
+The document interface file is a window containing the view(s) required for the implementation of one instance of your document type. For example, in the case of a TextDocument type, a window instance with a NSTextView drawn on it is used for each document window. This interface file is instantiated every time a person creates a new document (the newDocument: message goes to NSDocumentController) or opens an existing document (openDocument:).
 You will need to:
-* '''Subclass NSDocument''' with your document type in Gorm (this is done in a couple of ways, see [[Gorm_Manual#Custom_classes|custom classes]]).
+* '''Subclass NSDocument''' with your document type in Gorm. This is done in a couple of ways, see [[Gorm_Manual#Custom_classes|custom classes]].
-* '''Set NSOwner:''' Set your subclass as NSOwner's Custom class (done using the Property inspector). DO NOT INSTANTIATE IT.
+* '''Set NSOwner:''' Set your subclass as NSOwner's Custom class using the Property Inspector). DO NOT INSTANTIATE IT.
-Another thing that you may want to consider is custom outlets. If you place certain views or controls on your window (including the window itself), you may want to refer to them directly in yout code, e.g. the NSTextView in our TextEdit example is accessed directly, so that we can save it's contents to a file. To enable this, we add outlets to our class (see [[Gorm_Manual#Custom_classes|custom classes]]). We then connected NSOwner to the appropriate controls/views, and selected the outlets in the Connections property inspector (see [[Gorm_Manual#Editing_the_interface|editing the interface]]).
+Another thing that you may want to consider is custom outlets. If you place certain views or controls on your window (including the window itself), you may want to refer to them directly in your code, e.g. the NSTextView in our TextEdit example is accessed directly, so that we can save it's contents to a file. To enable this, we add outlets to our class (see [[Gorm_Manual#Custom_classes|custom classes]]). We then connect NSOwner to the appropriate controls/views, and select the outlets in the Connections Property Inspector (see [[Gorm_Manual#Editing_the_interface|editing the interface]]).
 == Code ==
@@ Line 155: / Line 155: @@
 ==== loadDataRepresentation:ofType: and dataRepresentationOfType: ====
-The methods, loadDataRepresent:ofType: and dataRepresentationOfType: are used by NSDocumentController to load and save our files. The first method is called when the user trys to open a document (NSDocumentController gets the file name and copies it's data using an open panel). The method is passed the raw data in this file, as well as a string representing its type. It is important to note that this type string is the same one used in your property list. It is used by NSDocumentController to tell you what type it thinks you should open the data with. If this is not possible, or if there is an error trying to parse the data, your method returns FALSE/NO. Otherwise, you should store a local, meaningful representation of the data, which you can insert into your document window a little later (and return YES).
+The methods, loadDataRepresent:ofType: and dataRepresentationOfType: are used by NSDocumentController to load and save our files. The first method is called when the user trys to open a document (NSDocumentController gets the file name and copies it's data using an open panel). The method is passed the raw data in this file, as well as a string representing its type. It is important to note that this type string is the same one used in your property list. It is used by NSDocumentController to tell you what type it thinks you should open the data with. If this is not possible, or if there is an error trying to parse the data, your method returns FALSE/NO. Otherwise, you should store a local, meaningful representation of the data, which you can insert into your document window a little later (and return TRUE/YES).
 For example, in terms of the TextEdit example:
@@ Line 178: / Line 178: @@
+  }
-If this is not suffice, or if your program can open the data in a more efficient manner, it may be worth looking into overriding -initWithContentsOfFile:ofType: and -initWithContentsOfURL:ofType: (see the GUI manual for more details).
+If this is not sufficient, or if your program can open the data in a more efficient manner, it may be worth looking into overriding -initWithContentsOfFile:ofType: and -initWithContentsOfURL:ofType:. Again, see the GUI manual for more details.
 dataRepresentationOfType: is used to save the data. Your method is expected to return an instance of NSData that contains what should be saved to a file, for the type specified. Again, the ''type'' variable should be checked to ensure that you can write data of that type. Return nil if the file cannot be saved as that type.
@@ Line 192: / Line 192: @@
+  }
-If a more sophisticated save implementation is needed, consult the documentation for information on the writeTo methods.
+If a more sophisticated save implementation is needed, consult the documentation for information on the writeTo* methods.
 ==== windowNibName ====
-This method must be overriden to return the a string of the name of your nib file (without the file extention). More complex implementations will use other methods to load the interface files. TODO: information on what methods need to be overriden.
+This method must be overriden to return the a string of the name of your nib file (without the file extension). More complex implementations will use other methods to load the interface files. TODO: information on what methods need to be overriden.
 ==== windowControllerDidLoadNib: ====
@@ Line 202: / Line 202: @@
 Use this method to add code that should be run as soon as ''windowController'' has been initialised. Your document may have many window controllers; each window controller taking possession of one window.
-In the TextEdit example, this method is used to copy the fileContents object ivar to the text view. It otherwise initialises the document window.
+In the TextEdit example, this method is used to copy the ''fileContents'' variable to the text view. It otherwise initialises the document window.
-Also note that you can override windowControllerWillLoadNib: to perform pre-nib loading initialisation.
+Also note that you can override windowControllerWillLoadNib: to perform pre-interface loading initialisation.
 ==== makeWindowControllers ====
-This is an optional method override, which must be used if you have multiple window controllers per document. It is responsible for creating each window controller from it's nib and then adding it to the document. Use the addWindowController: method.
+This is an optional method override, which must be used if you have multiple window controllers per document. It is responsible for creating each window controller from it's interface file and then adding it to the document. Use the addWindowController: method.
 ==== Other considerations ====
@@ Line 214: / Line 214: @@
 * You need a way to notify NSDocument that your document has changed, so that NSDocumentController can enable the menu item to allow saving. This is done by a call to the updateChangeCount: method. For example, the TextDocument class adds itself as a delegate to the textView, for any notification of changes. It then calls updateChangeCount: in the delegate's method.
-* You may also wish to add a close: method (not the close method already in NSDocument, see below) to respond to the menu item permitting your document to close. This could perform cleanup operations before a call to [super close] is called e.g.
+* You may also wish to add a close: method (not the close method already in NSDocument, see below) to respond to the menu item permitting your document to close. This could perform cleanup operations before a call to [self close] is made e.g.
   - (void) close:(id)sender /* Note this is not the method found in NSDocument (they differ by a parameter) */
@@ Line 220: / Line 220: @@
       [self close];
+  }
 === NSDocumentController ===
@@ Line 233: / Line 231: @@
 This class can also be optionally subclassed, to implement functionality specific to a window controller for a document type. You may need to override makeWindowControllers: in the NSDocument subclass in order to make sure your specific window controller is instantiated.
-You should use separate implemenatino files and add the .m file to GNUmakefile.
+You should use separate implemenation files and add the .m file to GNUmakefile.
 == Optional Additions ==

@@ Line 58: / Line 58: @@
 For those that have edited this file in their project before, it is a dictionary with various values entered. For our purposes, we need an array within the main dictionary, called "NSTypes". This is a array of unnamed dictionaries, with one dictionary for each type.
-An entire example of this file, for a "theoretical" TextEdit application (please note that such an application does exist as an example application from Next I think, and again on MacOS X but I have constructed a much simpler version, used only for plain text files).
+I have provided an example for this file below. ProjectBuilder creates one as well. Please note that "TextEdit" does exist as an example application from NEXT I think, and again on MacOS X but I have constructed a much simpler version, used only for plain text files.
 Taking a look at the single dictionary entry in the NSTypes array, the following key-value pairs are needed:

@@ Line 4: / Line 4: @@
 == Introduction ==
-OpenStep can provide your application a document-based model. It helps to simplify the process of creating such applications. GNUstep is compatible with this paridgm as well; this document aims to provide an overview of what is required in the creation and design of such an application.
+OpenStep can provide your application a document-based model. It helps to simplify the process of creating such applications. GNUstep implements this as well; this document aims to provide an overview of what is required in the creation and design of such an application.
-It is assumed you are familiar with GNUstep, and have some understanding as how to create Gorm's nib files, as well as some understanding of how they work.
+It is assumed you are familiar with GNUstep, and have some understanding as how to create Gorm's interface files (often referred to as nib's), as well as some understanding of how they work.
-Importantly, such applications have certain components that are required, and should be considered as part of their design. At a programmatic level, classes that will be used as part of the AppKit are:
+Importantly, such applications have certain components that are required, and should be considered as part of their design. When programming, classes that will be used as part of the AppKit are:
 ==== NSDocument ====
-This class is central to the OpenStep document based model. Such an application declares a new instance of a subclass of NSDocument for each “document” that is opened. It will be necessary to subclass NSDocument to implement this.
+This class is central to the OpenStep document based model. These application's declare a new instance of a subclass of NSDocument for each “document” that is opened. You will subclass NSDocument to implement this.
 Each instance of your NSDocument subclass may have one or more windows associated with it. These are used as an interface for loading and saving a representation of your document type. Each window will have an “NSWindowController” instance associated with it, where NSDocument maintains a list of these.
@@ Line 18: / Line 18: @@
 ==== NSDocumentController ====
-This class acts a controller. It maintains a list of documents (instances of your NSDocument subclass) and is responsible for loading and instantiating new documents. It is usually not necessary to implement a subclass of this, but often it may be useful to implement special functionality (especially related to open documents as a whole).
+This class acts a controller. It maintains a list of documents (instances of your NSDocument subclass) and is responsible for loading and instantiating new documents. It is usually not necessary to implement a subclass of this, but often it may be useful to implement special functionality (especially related to opening and creating documents at an application level).
 ==== NSWindowController ====
@@ Line 26: / Line 26: @@
 You will most likely not have to subclass NSWindowController. Instead, you associate a nib file (the Gorm output) with the subclass of NSDocument, and NSDocumentController will load this nib file for each document that is created or loaded.
-For example, a text based application that is used for the editing of plain text files, may subclass NSDocument with a TextDocument class. Each instance of this class would have an NSWindowController instance associated with it, which in turn manages a window instance that is instantiated from a nib file. The NSDocumentController instance, as managed and instatiated by GNUstep, would be responsible for loading and saving documents in your application. It even prompts the user to save their documents when they try to quit the application.
+For example, a text based application that is used for the editing of plain text files, may subclass NSDocument with a TextDocument class. Each instance of this class would have an NSWindowController instance associated with it, which in turn manages a window instance that is instantiated from a nib file. The NSDocumentController instance, as managed and instantiated by GNUstep, would be responsible for loading and saving documents in your application. It even prompts the user to save their documents when they try to quit the application.
 == File Components ==