Commits

Anonymous committed 2221a23

Spelling fixes

Comments (0)

Files changed (9)

pyobjc/Doc/C-API.txt

 
 The C API is defined in ``pyobjc-api.h``. This file is currently not installed
 because the API is not entirely stable. This is the only file that can
-be included from outside of the 'Modules/objc' directory, future versions of
+be included from outside of the 'Modules/objc' directory; future versions of
 the bridge may use additional linker flags to make sure that the module doesn't
 export symbols other than the module init function.
 
 The easiest way to wrap global functions and constants is by using the scripts
-in Scripts/CodeGenerators. This script is unsupported and might not work on
-anything but the Apple headers, but if it works it will save you a lot of work.
+in Scripts/CodeGenerators. These scripts are unsupported and might not work on
+anything but the Apple headers, but if they work it will save you a lot of work.
 
 Limititations
 -------------
 
   static int PyObjC_ImportAPI(PyObject* calling_module)
 
-This module will return 0 if loading the module was successfull, and -1
+This module will return 0 if loading the module was successful, and -1
 otherwise. Reasons for failure include: not being able to locate the module
 and API version conflicts.
 

pyobjc/Doc/PyObjCTools.txt

 Introduction
 ------------
 
-The package ``PyObjCTools`` contains a number of (basicly unrelated) modules
-with usefull functionality. These have been placed inside a module to avoid
+The package ``PyObjCTools`` contains a number of (basically unrelated) modules
+with useful functionality. These have been placed inside a module to avoid
 cluttering the global namespace.
 
 The rest of this document provides documentation for these modules, but lets
 
 * ``PyObjCTools.Signals.py``
 
-Module that tries to print usefull information when the program gets a fatal
+Module that tries to print useful information when the program gets a fatal
 exception. This module should only be used during development.
 
 
 
   The same as ``setKey``, but now using a key path. A key path is a sequence
   of keys seperated by dots. The ``getKey`` function is used to traverse 
-  the path upto the last item, and then ``setKey`` is used to change the value.
+  the path up to the last item, and then ``setKey`` is used to change the value.
 
 PyObjCTools.NibClassBuilder
 ...........................
 
 When run from the command line, this module invokes a simple command
 line program, which you feed paths to nibs. This will print a Python
-template for all classes defined in the nib(s). For more doco, see
-the commandline_doc variable, or simply run the program wothout
+template for all classes defined in the nib(s). For more documentation,
+see the commandline_doc variable, or simply run the program without
 arguments. It also contains a simple test program.
 
 PyObjCTools.Signals
 ...................
 
-This module provides two functions that can be usefull while investigating
+This module provides two functions that can be useful while investigating
 random crashes of a PyObjC program. These crashes are often caused by 
 Objective-C style weak references or incorrectly implemented protocols.
 
   dumpStackOnFatalSignal.
 
 This module is not designed to provide fine grained control over signal 
-handling. Nor is it intended to be terribly robust. It may give usefull
+handling. Nor is it intended to be terribly robust. It may give useful
 information when your program gets unexpected signals, but it might just
 as easily cause a crash when such a signal gets in. 
 
 Examples of plugin bundles include PreferencePanes and InterfaceBuilder 
 palletes.
 
-The PluginBuilder class is instantated with a number of keyword arguments and
-have a ``build()`` method that will do all the work. 
+The PluginBuilder class is instantiated with a number of keyword arguments and
+has a ``build()`` method that will do all the work. 
 
 XXX: Add documentation about the constructor arguments
 

pyobjc/Doc/api-notes-macosx.txt

 in Objective-C (e.g. the Apple developer documentaton applies), but in some
 cases there are special considerations.
 
-We also do not provide access to global functions that are not usefull for
+We also do not provide access to global functions that are not useful for
 Python programs, those functions are listed below.
 
-This document list the examples to the basic rules. If a method uses pointers
+This document lists the exceptions to the basic rules. If a method uses pointers
 to return additional values, the Python wrapper for that method returns a tuple
 containing the original return value and the additional values. You don't have
 to pass values for those arguments, unless the method uses the values you
 pass in.
 
-This document is target at the latest supported version of MacOS X (currenlty
-MacOS X 10.2.x), unless specifically noted the same restrictions apply to 
+This document is targeted at the latest supported version of MacOS X (currently
+MacOS X 10.3.x); unless specifically noted the same restrictions apply to 
 earlier versions of MacOS X. Earlier versions of the OS have less extensive
 APIs, PyObjC does *not* provide a compatibility layer.
 
 
 * ``descriptionForClassMethod:``, ``descriptionForInstanceMethod``
 
-  These methods are not supported, protocols are hardly ever used explicitly
+  These methods are not supported. Protocols are hardly ever used explicitly
   in Cocoa therefore this should not be a problem.
 
 Addressbook framework
 ---------------------
 
-We do not provide access to the global functions in that framework, because
+We do not provide access to the global functions in this framework, because
 the same functionality can be accessed by using the object-oriented interface.
 
 AppKit framework
 
 * ``appendBezierPathWithGlyphs:count:inFont:``
 
-  The first argument is a list of integers, count should be at most the lenght
+  The first argument is a list of integers, count should be at most the length
   of the first argument.
 
 * ``appendBezierPathWithPoints:count:``
 
-  The first argument is a list of points, count should be at most the lenght
+  The first argument is a list of points, count should be at most the length
   of the first argument. 
 
 * ``setAssociatedPoints:atIndex:``
 
   This method is not supported (yet)
 
-* ``initWithBitmapDataPlanes:pixesWide:pixelsHigh:bitPerSample:samplesPerPixel:hasAlpha:isPlanar:colorSpaceName:bytesPerRow:bitsPerPixel:``
+* ``initWithBitmapDataPlanes:pixesWide:pixelsHigh:bitsPerSample:samplesPerPixel:hasAlpha:isPlanar:colorSpaceName:bytesPerRow:bitsPerPixel:``
 
   This method is not supported (yet)
 
 Class ``NSMatrix``
 ..................
 
-* ``sortUsingFunction:context``
+* ``sortUsingFunction:context:``
 
   Calling this method from Python is supported, overriding it in Python
   is not. The ``context`` can be an arbitrary python object.
 
 * ``qdPort``
 
-  This method returns an instance from a type Carbon.QuickDraw. This 
+  This method returns an instance of type Carbon.QuickDraw. This 
   requires MacPython.
 
 Class ``NSSimpleHorizontalTypesetter``
 --------------------
 
 NOTE: The list below is mostly based on scripts that find methods that can
-not be automaticly handled by the bridge. We have not yet performed a manual
+not be automatically handled by the bridge. We have not yet performed a manual
 search for such methods in the Cocoa documentation.
 
 The ``-forward::`` method is not supported. It's functionality can be accessed
 using the python function ``apply``. The ``performv::`` method is also not
-supported, with a simular work-around.
+supported, with a similar work-around.
 
 Structs are wrapped using a struct-like type. They can be accessed using the
 field-names from Objective-C, or you can access them as sequences. Accessing
-them as sequences is necessary for backward compatibility and is depericated.
+them as sequences is necessary for backward compatibility and is deprecated.
 
 Class ``NSArray``
 .................
 
 * ``deserializeAlignedBytesLengthAtCursor:``
 
-  This is a depricated method, see Apple documentation.
+  This is a deprecated method, see Apple documentation.
 
 * ``deserializeBytes:length:atCursor:``
 
-  This is a depricated method, see Apple documentation.
+  This is a deprecated method, see Apple documentation.
 
 * ``deserializeDataAt:ofObjCType:atCursor:context:``
 
-  This is a depricated method, see Apple documentation.
+  This is a deprecated method, see Apple documentation.
 
 * ``deserializeIntAtCursor:``
 
-  This is a depricated method, see Apple documentation.
+  This is a deprecated method, see Apple documentation.
 
 * ``deserializeInts:count:atCursor:``
 
-  This is a depricated method, see Apple documentation.
+  This is a deprecated method, see Apple documentation.
 
 * ``deserializeInts:count:atIndex:``
 
-  This is a depricated method, see Apple documentation.
+  This is a deprecated method, see Apple documentation.
 
 * ``getBytes:``, ``getBytes:length:``, ``getBytes:range:``
   Use ``bytes`` instead, and then use subscripting to get the
 
 * ``addresses``
 
-  When calling this from Python this methods returns a tuple of adress-info
+  When calling this from Python this methods returns a tuple of address info
   tuples, like the values returned by ``socket.getpeeraddr()``. 
 
 Class ``NSObject``
 
   These methods can be used from Python, but the ``observationInfo`` is 
   represented by an integer instead of ``void*``. This probably makes it
-  impossible to do anything usefull with these methods.
+  impossible to do anything useful with these methods.
 
 * ``addObserver:forKeyPath:options:context:``
 
 
 * ``initWithCharactersNoCopy:length:freeWhenDone:`` 
 
-  This method is unsupported because we cannot guarantee that the buffer wil
+  This method is unsupported because we cannot guarantee that the buffer will
   be available as long as the string is. Use ``initWithCharacters:`` instead.
 
 * ``getCharacters:`` and ``getCharacters:range:``
 
-  These methods are not supported at the moment. This limitation will be liften
+  These methods are not supported at the moment. This limitation will be lifted
   in a future version of the bridge.
 
 * ``getCString:maxLength:range:remainingRange:`` and ``getCString:maxLength:``
 
   Calling these methods from Python is supported, overriding them from 
-  Python is not. This limitation will be liften in a future version of the
+  Python is not. This limitation will be lifted in a future version of the
   bridge.
 
 * ``getCString:``
 
   This method is not supported. Use ``getCString:maxLength:`` instead (using
   the length of the string as the maximum length). This limitation will be
-  liften in a future version of the bridge.
+  lifted in a future version of the bridge.
  
 
 class ``NSThread``
 ..................
 
-When you're using Python 2.3 or later it is save to call from Objective-C to
+When you're using Python 2.3 or later it is safe to call from Objective-C to
 Python on any thread. Otherwise you must be sure that the current thread has
 acquired the GIL. This means you shouldn't use API's that will call back on
 an arbitrary thread unless you're using Python 2.3 or later. It is safe to 
 PreferencePanes framework
 -------------------------
 
-This framework seems to define usefull classes like ``NSAuthorization`` and
-``NSKeychain``, but these are not documented and some usefull methods have
+This framework seems to define useful classes like ``NSAuthorization`` and
+``NSKeychain``, but these are not documented and some useful methods have
 a hard signature.
 
-The only documented class, ``NSPreferencePane`` is fully supported.
+The only documented class, ``NSPreferencePane``, is fully supported.
 
 ScreenSaver framework
 ---------------------
 .........................
 
 This class is fully supported.
+

pyobjc/Doc/architecture.txt

 Introduction
 ------------
 
-XXX: This documented is outdated and incomplete.
+XXX: This documentent is outdated and incomplete.
 
-This document gives a (brief) description of how the PyObjc package is 
+This document gives a (brief) description of how the PyObjC package is 
 structured. 
 
 Objective-C classes and objects
 that represent Objective-C classes.
 
 Objective-C objects are represented by proxy objects that are instances of
-the classes descriped above.
+the classes described above.
 
 TODO: work out how we'll implement subclasses objects and describe here.
 

pyobjc/Doc/intro.txt

 latter is done by instance-methods whose name customarily starts with ``init``.
 
 Objective-C code looks just like plain C code, with some easily recognizable
-extensions for the Object-Oriented parts of the language. And example class
+extensions for the Object-Oriented parts of the language. An example class
 declaration (usually found in ``.h`` files) and implementation (usually found
-in ``.m`` files) are listed below). Class declarations are easily recognized as 
-blocks of code between ``@interface`` and ``@end``, and simularly the 
+in ``.m`` files) are listed below. Class declarations are easily recognized as 
+blocks of code between ``@interface`` and ``@end``, and similarly the 
 implementation is between ``@implementation`` and ``@end``. Calling methods
 is done using expressions enclosed with brackets (name?), e.g. 
 ``[foo method]``.  This is the same as ``foo.method()`` in Python.
 
    @end
 
-Objective-C also features exceptions, but as those are mostly used for disaster
+Objective-C also features exceptions, but as they are mostly used for disaster
 recovery and not for normal error handling you won't see them very often
-in example code. The `The Objective-C Programming Language`_ if you want to
+in example code. Read `The Objective-C Programming Language`_ if you want to
 know more about exceptions in Objective-C. 
 
 One thing to keep in mind when translating Objective-C snippets to python is
 that it is valid to call methods on ``nil`` (that is the NULL pointer). Those
 method calls are ignored by the runtime. The value ``nil`` is represented in
-Python by the ``None``, this means that calls to non-existing methods are
-not ignored but will raise ``AttributeError``.
+Python by the ``None``; this means to access a non-existing method will raise
+``AttributeError``.
 
 For more information about Objective-C see:
 
 
 Objective-C classes are visible as (new-style) Python classes and can be 
 subclassed just like normal Python classes. All the usual introspection
-mechanism work as well, as do __slots__ and descriptors. The major 
+mechanisms work as well, as do __slots__ and descriptors. The major 
 differences between normal Python classes and Objective-C classes are the way 
 you create instances and the fact that Objective-C methods have odd names.
 
 You can use multiple inheritance with Objective-C classes, as long as the
-Objetive-C is the first base-class and there is only one Objective-C 
-base-class. E.g. it is not possible to subclass from the Objective-C classes
+Objetive-C class is the first base-class and there is only one Objective-C 
+base-class. E.g. it is not possible to subclass from multiple Objective-C classes
 at the same time. Multiple inheritance should also not be used to mix-in
-different implementations for Objective-C methods, that will not work and
+different implementations for Objective-C methods. It will not work and
 you won't get errors about this.
 
 Another thing to keep in mind is that the names of Objective-C classes must
-be unique, without taking modules into account. That is, it is *not* possible
-to have two modules that define a class with the same name. If you write classes
-that will be used outside of a single project it is customary to pick a 
+be unique, including across Python modules. That is, it is *not* possible
+to have two Python modules that define a class with the same name. If you write 
+classes that will be used outside of a single project it is customary to pick a 
 (short) prefix and stick that in front of all class names, e.g. Apple ``NS`` 
 as the prefix in the `Cocoa libraries`_.
 
 One group of exceptions to this rule can be described in a global way. Some
 methods and functions have pointers as arguments, specifically pointers to
 a single value that is passed in and/or out of the function. These arguments
-are sometimes called *pass by reference* arguments, and can be subdived into
+are sometimes called *pass by reference* arguments, and can be subdivided into
 three types of arguments: ``in`` arguments are used to pass data to the 
 function, ``out`` arguments are used to pass data from the function (e.g. and
 additional return value) and ``inout`` arguments are a combination of the two.
 Cocoa for Python programmers
 ----------------------------
 
-Cocoa frameworks are mapped onto Python packages with the same name, that is
-the classes, constants and functioins from the AppKit framework are available
+Cocoa frameworks are mapped onto Python packages with the same name; that is
+the classes, constants and functions from the AppKit framework are available
 after you import ``AppKit`` in your Python script. 
 
 These helper modules contain *only* functions, constants and classes that 
 wrap items in the corresponding framework. All utility functions and classes 
 are located in the ``PyObjCTools`` package and ``objc`` module. Note that it
 is possible to use ``pydoc`` (or the ``help()``) function with the framework
-wrappers, but that this is not very usefull for the entire module due to the
+wrappers, but that this is not very useful for the entire module due to the
 size of these modules.
 
 This makes it easier to find documentation for an item: if you import it 
 from the wrapper module for an Objective-C framework the documentation for
-that item can be found in the documentation for the framework, otherwise the
+that item can be found in the documentation for the framework; otherwise the
 item is documented in the PyObjC documentation.
 
 The module ``PyObjCTools.NibClassBuilder`` can be used to make working with 
 "Pure Python" :  buildapp.py
 ............................
 
-PyObjC includes a copy of the ``bundlebuilder`` module. This module will be
+PyObjC includes a copy of the ``bundlebuilder`` module. This module is
 part of the Python 2.3 MacPython release and offers a way to build
-distutils-style scripts  for building (standalone) applications.
+distutils-style scripts for building (standalone) applications.
 
 An example ``buildapp.py`` script::
 
 .. __: ../Examples/00ReadMe.txt
 
 
-"IDE approach" : Project builder
+"IDE approach" : Xcode
 ................................
 
-PyObjC includes a number of Project Builder templates that can be used to 
+PyObjC includes a number of Xcode templates that can be used to 
 build (standalone) applications. Those templates are used like any other
-Project Builder template. The only non-obvious detail is that you have to
+Xcode template. The only non-obvious detail is that you have to
 add your sources as resources, but Project Builder usually does the right
 thing when you add a new file.
 
Add a comment to this file

pyobjc/Examples/Twisted/PackMan/MainMenu.nib/keyedobjects.nib

Binary file modified.

pyobjc/Lib/PyObjCTools/NibClassBuilder.py

 
 The module contains a "magic" base (super) class called AutoBaseClass.
 Subclassing AutoBaseClass will invoke some magic that will look up the
-proper base class in the class definitions extraced from the nib(s).
+proper base class in the class definitions extracted from the nib(s).
 If you use multiple inheritance to use Cocoa's "informal protocols",
 you _must_ list AutoBaseClass as the first base class. For example:
 
 
 When run from the command line, this module invokes a simple command
 line program, which you feed paths to nibs. This will print a Python
-template for all classes defined in the nib(s). For more doco, see
-the commandline_doc variable, or simply run the program wothout
+template for all classes defined in the nib(s). For more documentation, see
+the commandline_doc variable, or simply run the program without
 arguments. It also contains a simple test program.
 """
 

pyobjc/Lib/PyObjCTools/Signals.py

   dumpStackOnFatalSignal.
 
 This module is not designed to provide fine grained control over signal 
-handling. Nor is it intended to be terribly robust. It may give usefull
+handling. Nor is it intended to be terribly robust. It may give useful
 information when your program gets unexpected signals, but it might just
 as easily cause a crash when such a signal gets in. 
 
 
 def dumpStackOnFatalSignal():
     """
-    Install signal handlers that might print a usefull stack trace when
+    Install signal handlers that might print a useful stack trace when
     this process receives a fatal signal. 
 
     NOTE: See module docstring

pyobjc/Lib/PyObjCTools/pluginbuilder.py

 
 You *must* use a framework build of Python to be able to use this module.
 
-The PluginBuilder class is instantated with a number of keyword arguments and
-have a build() method that will do all the work. See the class docstrings for
+The PluginBuilder class is instantiated with a number of keyword arguments and
+has a build() method that will do all the work. See the class docstrings for
 a description of the constructor arguments.
 
 The module contains a main program that can be used in two ways:
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.