Commits

Ronald Oussoren  committed c9f920c

Recreate HTML docs

  • Participants
  • Parent commits 6800140
  • Branches pyobjc-ancient

Comments (0)

Files changed (12)

File Doc/C-API.html

 <p>The easiest way to wrap global functions and constants is by using the scripts
 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.</p>
-<h2><a name="limititations">Limititations</a></h2>
+<h2><a name="limitations">Limitations</a></h2>
 <p>An important limitation of the current C API is that you can only use the API
 from one C file in the implementation of an extension module. This limitation
 will probably not be removed in future versions of the API.</p>
 <h2><a name="initialization">Initialization</a></h2>
-<p>The initialiazation function (below) should be called before using the
+<p>The initialization function (below) should be called before using the
 rest of the API:</p>
 <pre>
 static int PyObjC_ImportAPI(PyObject* calling_module)
 <p>Convert an Objective-C exception to Python. Use 
 <code><span>PyObjCErr_FromObjC(localException)</span></code> to convert the exception in an 
 <code><span>NS_HANDLER</span></code> block.</p>
-<p>Note that PyObjC supports roundtripping for exceptions, if the current 
+<p>Note that PyObjC supports round-tripping for exceptions, if the current 
 Objective-C exception is an converted Python exception, the original Python
 exception will be rethrown.</p>
 <pre>
 void PyObjCErr_ToObjC(void);
 </pre>
 <p>Convert a Python exception to Objective-C. This function does not return.</p>
-<p>Note that PyObjC supports roundtripping for exceptions, if the current Python
+<p>Note that PyObjC supports round-tripping for exceptions, if the current Python
 exception is an converted Objective-C exception, the original Objective-C
 exception will be rethrown.</p>
 <pre>

File Doc/PyObjCTools.html

 </ul>
 <p>Utility functions for use with the <code><span>AppKit</span></code> module.</p>
 <ul>
-<li><code><span>PyObjCTools.Conversion.py</span></code></li>
+<li><code><span>PyObjCTools.Conversion</span></code></li>
 </ul>
 <p>Functions for converting between Cocoa and pure Python data structures.</p>
 <ul>
-<li><code><span>PyObjCTools.KeyValueCoding.py</span></code></li>
+<li><code><span>PyObjCTools.KeyValueCoding</span></code></li>
 </ul>
 <p>A python API for working with <a href="http://developer.apple.com/documentation/Cocoa/Conceptual/KeyValueCoding/index.html#//apple_ref/doc/uid/10000107i">Key-Value Coding</a>.</p>
 <ul>
-<li><code><span>PyObjCTools.NibClassBuilder.py</span></code></li>
+<li><code><span>PyObjCTools.NibClassBuilder</span></code></li>
 </ul>
 <p>Module containing a magic super-class that can read information about the
 actual super-class and implemented actions and outlets from a NIB file.</p>
 <ul>
-<li><code><span>PyObjCTools.pluginbuilder.py</span></code></li>
+<li><code><span>PyObjCTools.MachSignals</span></code></li>
+</ul>
+<p>Module to make it possible to integrate signal handling into the main
+runloop.</p>
+<ul>
+<li><code><span>PyObjCTools.pluginbuilder</span></code></li>
 </ul>
 <p>Extension of <code><span>bundlebuilder</span></code> (XXX: Link) that allows you to build python-based
 plugin bundles, such as panes for the System Preferences application and
 screen savers.</p>
 <ul>
-<li><code><span>PyObjCTools.Signals.py</span></code></li>
+<li><code><span>PyObjCTools.Signals</span></code></li>
 </ul>
 <p>Module that tries to print useful information when the program gets a fatal
 exception. This module should only be used during development.</p>
 <h2><a name="pyobjctools-apphelper"><code><span>PyObjCTools.AppHelper</span></code></a></h2>
-<p>This module exports two functions that are usefull when working with the
+<p>This module exports two functions that are useful when working with the
 <code><span>AppKit</span></code> framework.</p>
 <ul>
 <li><code><span>endSheetMethod(method)</span> <span>-&gt;</span> <span>selector</span></code><p>Convert a method to a form that is suitable to use as the delegate callback
 <p>This function doesn't return unless it throws an exception.</p>
 </li>
 </ul>
-<h2><a name="pyobjctools-conversion-py"><code><span>PyObjCTools.Conversion.py</span></code></a></h2>
+<h2><a name="pyobjctools-conversiony"><code><span>PyObjCTools.Conversiony</span></code></a></h2>
 <p>Functions for converting between Cocoa and pure Python data structures.</p>
 <ul>
 <li><code><span>propertyListFromPythonCollection(pyCol,</span> <span>conversionHelper=None)</span> <span>-&gt;</span> <span>ocCol</span></code><p>Convert a Python collection (dictionary, array, tuple, string) into an 
 </ul>
 </li>
 <li><code><span>getKeyPath(object,</span> <span>keypath)</span> <span>-&gt;</span> <span>value</span></code><p>Like <code><span>getKey</span></code> but using a key path. The <code><span>keypath</span></code> is a sequence of keys
-seperated by dots. It calls <code><span>getKey</span></code> to follow the path and returns the
+separated by dots. It calls <code><span>getKey</span></code> to follow the path and returns the
 final value.</p>
 </li>
 <li><code><span>setKey(object,</span> <span>key,</span> <span>value)</span> <span>-&gt;</span> <span>None</span></code><p>Set the value of <code><span>key</span></code> to <code><span>value</span></code>.</p>

File Doc/api-notes-macosx.html

 <h2><a href="#id2" name="introduction">Introduction</a></h2>
 <p>This document describes the restrictions w.r.t. supported APIs and classes
 on MacOS X. In general you can use classes and global functions just like
-in Objective-C (e.g. the Apple developer documentaton applies), but in some
+in Objective-C (e.g. the Apple developer documentation applies), but in some
 cases there are special considerations.</p>
 <p>We also do not provide access to global functions that are not useful for
 Python programs, those functions are listed below.</p>
 </li>
 </ul>
 <h3><a href="#id23" name="class-nsautoreleasepool">Class <code><span>NSAutoreleasePool</span></code></a></h3>
-<p>The bridge automaticly manages reference counts for you, but you're still 
+<p>The bridge automatically manages reference counts for you, but you're still 
 required to make an autorelease pool available.</p>
 <p>In simple, single-threaded GUI programs you don't have to do anything for this,
 because NSRunLoop does this for you and PyObjC creates an initial pool for the
 main thread.</p>
-<p>If you create lots of Cocoa objects in a loop it can be usefull to manually create
+<p>If you create lots of Cocoa objects in a loop it can be useful to manually create
 a pool to reclaim memory as soon as possible. The proper idiom for this is:</p>
 <pre>
 while &lt;test&gt;:
 <ul>
 <li><code><span>indicesOfObjectsByEvaluatingWithContainer:count:</span></code><p>Implementing this in Python is not supported yet. We're looking for a way
 to avoid leaking the returned buffer, as we cannot return a pointer to an
-internal datastructure.</p>
+internal data-structure.</p>
 </li>
 </ul>
 <h3><a href="#id36" name="class-nsset">Class <code><span>NSSet</span></code></a></h3>

File Doc/classes.html

 <li>Python numbers are translated into NSNumber instances</li>
 <li>Python strings and unicode objects are translated into NSString instances</li>
 <li>Python dictionaries are proxied using OC_PythonDictionary, a subclass of NSMutableDictionary. This allows you to use a Python dictionary everywhere where an NSDictionary is expected.</li>
-<li>Python lists or tuples are proxied using OC_PythonArray, a subclas of NSMutableArray. This allows you to use a Python list or tuple everywhere where an NSArray is expected.</li>
+<li>Python lists or tuples are proxied using OC_PythonArray, a subclass of NSMutableArray. This allows you to use a Python list or tuple everywhere where an NSArray is expected.</li>
 </ul>
 <p>The special cases allow for more transparent bridging between Python and
 Objective-C.</p>
 <li>There can be only 1 Objective-C base class.
 It is not possible to multiple-inherit from two Objective-C classes, this
 limitation is inherited from Objective-C.</li>
-<li>It is not possible to overide or extend an Objective-C method using a mixin.
+<li>It is not possible to override or extend an Objective-C method using a mixin.
 This is limitation will be lifted in future versions of PyObjC.</li>
-<li>It is not possible to overide or extend an Objective-C method by adding a new method to the class after creating it.</li>
+<li>It is not possible to override or extend an Objective-C method by adding a new method to the class after creating it.</li>
 </ol>
 <p>PyObjC provides limited support for Objective-C protocols. The type 
 obc.informal_protocol can be used to shadow protocol definitions in Objective-C.
 <p>As can be seen in the examples above, Objective-C allows you to specify
 the types of arguments and the return value, while this is not possible in
 Python. This is not a problem when calling existing Objective-C methods, 
-because PyObjC will automaticly read the needed information from the 
+because PyObjC will automatically read the needed information from the 
 Objective-C runtime, but it can be a problem when defining new Objective-C
 methods in Python.</p>
 <p>PyObjC therefore provides a function to define the signature of a python method

File Doc/coding-style.html

 <h2><a href="#id1" name="introduction">Introduction</a></h2>
 <p>This document describes the coding style for PyObjC. Please use this style for
 new code and try apply this style to existing code while working on it.</p>
-<p>The managment summary: 4-space indents in Python code, 1-TAB indents in C
+<p>The management summary: 4-space indents in Python code, 1-TAB indents in C
 code.</p>
 <h2><a href="#id2" name="python-code">Python code</a></h2>
 <p>The coding style for core Python is used (see <a href="http://www.python.org/peps/pep-0008.txt">PEP 8</a>). For consistency with

File Doc/gnustep.html

 <p>This text is not printed by PyObjC and I haven't been able to find who
 does print that text...</p>
 </li>
-<li>Fix bugs found using the unittests<p>runPyObjCTests finds some problems that disapear when those tests are run
-seperately...</p>
+<li>Fix bugs found using the unittests<p>runPyObjCTests finds some problems that disappear when those tests 
+are run separately...</p>
 </li>
 <li>Port the AppKit wrappers</li>
 <li>Extract more CFLAGS and LDFLAGS information from the GNUstep build system,

File Doc/index.html

 most importantly the <a href="http://developer.apple.com/techpubs/macosx/Cocoa/CocoaTopics.html">Cocoa libraries</a> by <a href="http://www.apple.com/">Apple</a>.</p>
 <p>More information can be found on <a href="http://pyobjc.sf.net">our website</a></p>
 <h2><a name="general-user-documentation">General user documentation</a></h2>
-<p>The following documents are usefull when you're interested in developing
+<p>The following documents are useful when you're interested in developing
 Cocoa applications in Python.</p>
 <ul>
 <li><a href="intro.html">An introduction to PyObjC</a><p>An overview of the PyObjC package and how to use it. Read this before

File Doc/intro.html

 <p>Objective-C is an object-oriented programming language that is an extension 
 of C and borrows heavily from Smalltalk. It features single inheritance with
 (in theory) multiple root classes and dynamic dispatch of methods. This is
-basicly the same as Python with single inheritance.</p>
+basically the same as Python with single inheritance.</p>
 <p>An important difference between Python and Objective-C is that the latter is
 not a pure object-oriented language. Some values are not objects, but values
 of plain C types, such as <code><span>int</span></code> and <code><span>double</span></code>. These basic C types can also
 be used as the types of arguments and the return value of methods.</p>
-<p>Object allocation and initialization are explicit and seperate actions in 
+<p>Object allocation and initialization are explicit and separate actions in 
 Objective-C. The former is done by the class-method <code><span>alloc</span></code>, while the
 latter is done by instance-methods whose name customarily starts with <code><span>init</span></code>.</p>
 <p>Objective-C code looks just like plain C code, with some easily recognizable
 -(int)anInstanceMethodWithArg1:arg1 andArg2:(BOOL)arg2;
 @end
 </pre>
-<p>A class implemenation:</p>
+<p>A class implementation:</p>
 <pre>
 @implementation MYClass
 
 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.</p>
 <p>You can use multiple inheritance with Objective-C classes, as long as the
-Objetive-C class is the first base-class and there is only one Objective-C 
+Objective-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. It will not work and
 objects is a two-stage process. You first call the class method <code><span>alloc</span></code>, and
 then call some variation of <code><span>init</span></code> to initialize the objects. The newly
 created object is the result of the call to <code><span>init</span></code>. Most classes have 
-convienence class methods that combine the calls to <code><span>alloc</span></code> and <code><span>init</span></code>.</p>
+convenience class methods that combine the calls to <code><span>alloc</span></code> and <code><span>init</span></code>.</p>
 <h3><a href="#id8" name="methods-and-functions">Methods and functions</a></h3>
 <p>Objective-C methods are bridged to Python callables. Because Objective-C method 
 names can contain colons it is necessary to translate methods names. The rules
 <p>When you define methods in a subclass of an Objective-C class, the bridge has
 to tell the Objective-C runtime what the signature of those methods is. The
 basic rule is that all arguments as well as the return value are objects (just
-like with normal Python methods). The bridge will automaticly pick a better 
+like with normal Python methods). The bridge will automatically pick a better 
 signature when it has more information available. Specifically, if you 
-overide an existing method the bridge will assume you want to use the same
+override an existing method the bridge will assume you want to use the same
 method signature. And furthermore, if you implement a method in an (informal)
 protocol known to the bridge it will use the signature from the corresponding
 method in that signature.</p>
 are not true <a href="http://www.python.org/doc/current/lib/module-weakref.html">weak references</a> as in Python, but use-cases where an object 
 stores a reference to another object without increasing the reference count
 for that other object. The bridge cannot solve the issues this introduces
-for you, which means that you get hard crashes when you're not carefull when
+for you, which means that you get hard crashes when you're not careful when
 dealing with those <a href="http://www.python.org/doc/current/lib/module-weakref.html">weak references</a>.</p>
 <p>The basic rule to deal with weak references is: make sure objects stays
 alive as long as someone might have a weak reference to them. Due to the way
 only ones that have to care about these objects are the maintainers of 
 wrappers around Objective-C frameworks: they have to keep these protocol
 wrappers up-to-date.</p>
-<p>PyObjC will automaticly use the information in the <code><span>informal_protocol</span></code> 
+<p>PyObjC will automatically use the information in the <code><span>informal_protocol</span></code> 
 objects to add the right method signatures to methods, and to warn about
 classes that partially implement a protocol.</p>
 <h3><a href="#id11" name="cocoa-bindings">Cocoa Bindings</a></h3>
 you're done. The easiest way to that is to create an instance of that class
 bound to a local variable. If the thread is long-lived you may want to arrange
 for recycling the pool once in a while.</p>
-<p>There are some limitiation w.r.t. threading. You cannot use <code><span>NSThread</span></code> to 
+<p>There are some limitation w.r.t. threading. You cannot use <code><span>NSThread</span></code> to 
 create new threads, but must use the python primitives instead.</p>
 <p>You must also make sure that Objective-C only makes calls to Python from a 
 thread that owns the Python GIL (that's also the reason for not being able 

File Doc/release-process.html

 administrators, and not of much use for users of PyObjC.</p>
 <p>The timeframe is a guideline only and should be taken with a grain of salt.</p>
 <h2><a name="release-date-2-weeks">Release date -2 weeks</a></h2>
-<p>Full feature freeze, documenation updates and critical bugfixes only. At this
+<p>Full feature freeze, documentation updates and critical bug-fixes only. At this
 time:</p>
 <ul>
 <li>Check if the NEWS file is up-to-date</li>
 <li>Tests the tutorial(s)
 Read the tutorial(s) and follow the instructions exactly, the tutorials should
-be completely bugfree.</li>
+be completely bug-free.</li>
 <li>Proofread the documentation</li>
 <li>Update the announcement messages.</li>
 </ul>
 </dl>
 <ul>
 <li>Organization: PyObjC Team</li>
-<li>Name of Produt... : PyObjC</li>
+<li>Name of Product... : PyObjC</li>
 <li>URL: <a href="http://pyobjc.sourceforge.net">http://pyobjc.sourceforge.net</a></li>
 <li>Describe your product... :<p>PyObjC is a bridge between Python and Objective-C and allows development
 of full-fledged Cocoa programs in pure Python.</p>

File Doc/structure.html

 <!-- This document is in structured text markup to enable easy translation to 
 HTML. -->
 <h2><a name="introduction">Introduction</a></h2>
-<p>XXX:  This documet is outdated and incomplete.</p>
+<p>XXX:  This document is outdated and incomplete.</p>
 <p>This document gives an overview of the PyObjC for developers (of the package).</p>
 <p>One of the sections describes how all of it works, and some of the limitation.</p>
 <p>This document is a little dated, it should be updated.</p>
 <p>When translating from NSString to a Python unicode object (and back) we first 
 translate to a UTF8 encoding. This way we don't have to worry about any
 differences in the representation of Unicode strings in Python and Objective-C
-(Python has two different represenations, selection is at compile-time).</p>
+(Python has two different representations, selection is at compile-time).</p>
 </body>
 </html>

File Doc/tutorial_embed/extending_objc_with_python.html

 you would disable the &quot;Ask iTunes&quot; button unless iTunes was active. All that
 is left as an exercise to the reader.</li>
 </ol>
+<h2><a name="a-minor-variation">A minor variation</a></h2>
+<p>There a several projects that improve upon the built-in AppleScript support (or to be more precise &quot;application scripting support&quot;). One of those is AppScript (<a href="http://freespace.virgin.net/hamish.sanderson/appscript.html">http://freespace.virgin.net/hamish.sanderson/appscript.html</a>).</p>
+<p>When you have this module installed you can replace the contents of
+<code><span>ITunesCommuncation.py</span></code> with <code><span>src/ITunesCommunication_AppScript.py</span></code>, and
+you can skip step 15 entirely.</p>
 </body>
 </html>

File Doc/tutorial_reading.html

 you don't need it. The NIB file usually contains all of the things that need to
 be done for the Views objects, as is often the case with other gui-builders.
 But in addition the NIB also contains a large proportion of your Model
-functionality: creating the View and Controller objects and tieing the
+functionality: creating the View and Controller objects and tying the
 lot together.</p>
 <h2><a name="delegates">Delegates</a></h2>
 <p>If you are familiar with other object-oriented GUI toolkits such as MFC
 For instance, you will be hard put to find who, if anyone, calls 
 <code><span>ConverterController.invertRate:</span></code>. The solution: go to the &quot;MainMenu.nib&quot; window and
 look at the top of the vertical scrollbar. There are two little icons there, one with
-lines and one with squares, with the squares being higlighted. Press it. The view will change
+lines and one with squares, with the squares being highlighted. Press it. The view will change
 to a scrollable list with objects in the left column and an indication of connections
 in the right column. You can now see our ConverterController object has four
 outgoing connections (the ones we found earlier) and two incoming connections. Click