Commits

Ronald Oussoren  committed 0d213f4

Update the website for the 1.0 release.

The website will be updated when the 'cvs commit' is finished.

  • Participants
  • Parent commits 8e2d80c

Comments (0)

Files changed (23)

File pyobjc-web/docroot/NEWS-1.0.txt

+===========
+PyObjC NEWS
+===========
+
+An overview of the relevant changes in new, and older, releases.
+
+Version 1.0 (2003-09-21)
+------------------------
+
+- This version includes a new version of libffi that properly deals with
+  complex types on MacOS X.
+
+Version 1.0rc3 (2003-09-14)
+---------------------------
+
+- 1.0rc2 didn't include the nibclassbuilder script
+
+- Fix bug in NSRectFillList
+
+Version 1.0rc2 (2003-09-10)
+---------------------------
+
+- Fix a number of bugs found in 1.0rc1.
+
+Version 1.0rc1 (2003-08-10)
+---------------------------
+
+- Better support for the NSKeyValueCoding protocol.  The module 
+  ``PyObjCTools.KeyValueCoding`` provides a python interface that makes it
+  possible to use key-value coding with python objects as well as 
+  Objective-C objects. Key-Value Coding also works as one would expect with
+  Python objects when accessing them from Objective-C (both for plain Python
+  objects and Python/Objective-C hybrid objects).
+
+- objc.pyobjc_unicode objects are now pickled as unicode objects, previously
+  the couldn't be pickled or were pickled as incomplete objects (protocol 
+  version 2). 
+
+- Pickling of ObjC objects never worked, we now explicitly throw an exception
+  if you try to pickle one: pickle protocol version 2 silently wrote the 
+  incomplete state of objects to the pickle.
+
+- The default repr() of ObjC objects is now the result of a call to the
+  ``description`` method. This method is not called for unitialized objects,
+  because that might crash the interpreter; we use a default implementation
+  in that case.
+
+- A minor change to the conversion rule for methods with output arguments
+  (pointers to values in ObjC, where the method will write through the pointer).
+  If the method has 'void' as its return type, we used to return a tuple where
+  the first value is always None. This first element is no longer included,
+  furthermore if the method has only 1 output argument we no longer return
+  a tuple but return the output value directly (again only if the method has
+  'void' as its return type).
+  
+  This is a backward incompatible change, but there are not many of such
+  methods.
+
+- Another backward incompatible change is a minor cleanup of the names in
+  the ``objc`` module. The most significant of these is the change from
+  ``recycle_autorelease_pool`` to ``recycleAutoreleasePool``. The other 
+  changed names are internal to the bridge and should not be used in other
+  code.
+
+- The interface of Foundation.NSFillRects changed, it now has an interface
+  that is consistent with the rest of the bridge.
+
+Version 1.0b1 (2003-07-05)
+--------------------------
+
+- More tutorials
+
+  Two new tutorials were added: 'Adding Python code to an existing ObjC 
+  application' and 'Understanding existing PyObjC examples'. The former
+  explains how you can use Python to add new functionality to an already
+  existing Objective-C application, the latter explains how to understand
+  PyObjC programs written by other people.
+
+- More examples
+
+  Three examples were added: DotView, ClassBrowser and PythonBrowser,
+  respectively showing the use of a custom NSView, NSBrowser and
+  NSOutlineView.  PythonBrowser is reusable, making it trivial to add an
+  object browser to your application.
+
+- Support for MacOS X 10.1
+
+  It is now possible to build PyObjC on MacOS X 10.1, with full access to 
+  the Cocoa API's on that platform.
+
+  Note: The port to MacOS X 10.1 is not as well supported as the 10.2 port.
+  The developers do not have full-time access to a MacOS X 10.1 system.
+
+- Support for the WebKit framework, included with Safari 1.0.
+
+  If you build PyObjC from source you will have to build on a system that has
+  the WebKit SDK installed to make use of this. Note that the additional 
+  functionality will only be usuable on systems that have Safari 1.0 installed,
+  however as long as you don't use the additional functionality it is safe
+  to run a 'WebKit-enabled' PyObjC on systems without Safari 1.0.
+
+- It is no longer necessary to specify which protocols are implemented by
+
+  a class, this information is automaticly deduced from the list of implemented
+  methods. You'll still a runtime error if you implement some methods of a 
+  protocol and one of the unimplemented methods is required.
+
+- Support for "toll-free bridging" of Carbon.CF types to Objective-C objects.
+
+  It is now possible to use instances of Carbon.CF types in places where 
+  Objective-C objects are expected. And to explicitly convert between the two.
+
+  Note: this requires Python 2.3.
+
+- Better integration with MacPython 2.3:
+
+  * ``NSMovie.initWithMovie_`` and ``NSMovie.QTMovie`` now use ``QT.Movie`` 
+    objects instead of generic pointer wrappers.
+
+  * ``NSWindow.initWithWindowRef_`` and ``Window.windowRef`` now use 
+    ``Carbon.Window`` objects instead of generic pointer wrappers.
+
+  * Methods returning CoreFoundation objects will return MacPython objects,
+    and likewise, methods with CoreFoundation arguments will accept MacPython
+    objects.
+
+- It is now possible to write plugin bundles, such as preference panes for 
+  use in System Preferences, in Python. See Examples/PrefPanes for an example
+  of this feature.
+ 
+- The methods ``pyobjcPopPool`` and ``pyobjcPushPool`` of ``NSAutoreleasePool``
+  are deprecated. These were introduced when PyObjC did not yet support the
+  usual method for creating autorelease pools and are no longer necessary.
+
+- Improved unittests, greatly increasing the confidence in the correctness
+  of the bridge.
+
+- All suppport for non-FFI builds has been removed.
+
+- Object state is completely stored in the Objective-C object.  This has no
+  user-visible effects, but makes the implementation a lot easier to 
+  comprehend and maintain.
+
+- As part of the previous item we also fixed a bug that allowed addition of 
+  attributes to Objective-C objects. This was never the intention and had 
+  very odd semantics. Pure Objective-C objects not longer have a __dict__.
+
+- Weakrefs are no longer used in the implementation of the bridge. Because
+  the weakrefs to proxy objects isn't very useful the entire feature has 
+  been removed: It is no longer possible to create weakrefs to Objective-C
+  objects. 
+
+  NOTE: You could create weakrefs in previous versions, but those would
+  expire as soon as the last reference from Python died, *not* when the 
+  Objective-C object died, therefore code that uses weakrefs to Objective-C
+  objects is almost certainly incorrect.
+
+- Added support for custom conversion for pointer types. The end result is that
+  we support more Cocoa APIs without special mappings.
+
+- The generator scripts are automaticly called when building PyObjC. This
+  should make it easier to support multiple versions of MacOS X.
+
+
+Version 0.9 (May-02-2003)
+-------------------------
+
+- This version includes numerous bugfixes and improvements.
+
+- The module AppKit.NibClassBuilder has been moved to the package
+  PyObjCTools.
+
+- Usage of libFFI (http://sources.redhat.com/libffi) is now mandatory. The
+  setup.py gives the impression that it isn't, but we do *not* support 
+  non-FFI builds.
+
+- We actually have some documentation, more will be added in future releases.
+
+- There are more Project Builder templates (see 'Project Templates').
+
+- The InterfaceBuilder, PreferencePanes and ScreenSaver frameworks have been
+  wrapped.
+
+- Management of reference counts is now completely automatic, it is no longer
+  necessary to manually compensate for the higher reference count of objects 
+  returned by the alloc, copy and copyWithZone: class methods.
+
+- Various function and keyword arguments have been renamed for a better 
+  integration with Cocoa. A partial list is of the changed names is::
+
+  	objc.lookup_class -> objc.lookUpClass
+	objc.selector arguments/attributes:
+		is_initializer -> isInitializer
+		is_allocator -> isAlloc
+		donates_ref -> doesDonateReference
+		is_required -> isRequired
+		class_method -> isClassMethod
+		defining_class -> definingClass
+		returns_self -> returnsSelf
+		argument_types -> argumentTypes
+		return_type -> returnType
+	objc.get_class_list -> objc.getClassList
+
+- On Python 2.2, objc.YES and objc.NO are instances of a private boolean type,
+  on Python 2.3 these are instances of the builtin type bool.
+
+- Because we now use libFFI a large amount of code could be disabled. The
+  binaries are therefore much smaller, while we can now forward messages with
+  arbitrary signatures (not limited to those we thought of while generating
+  the static proxies that were used in 0.8)
+
+- Better support for APIs that use byte arrays are arguments or return values. 
+  Specifically, the developer can now manipulate bitmaps directly via the 
+  NSBitmapImageRep class, work with binary data through the NSData class, and 
+  very quickly draw points and rects via NSRectFillList()
+
+- We added a subclass of unicode that is used to proxy NSString values. This
+  makes it easily possible to use NSString values with Python APIs, while at 
+  the same time allowing access to the full power of NSString.
+
+Version 0.8 (Dec-10-2002)
+-------------------------
+
+- GNUStep support has been removed for lack of support.  Volunteers
+  needed.
+
+- Subclassing Objective-C classes from Python, including the addition
+  of instance variables (like 'IBOutlet's)
+
+- Generic support for pass-by-reference arguments
+
+- More complete Cocoa package, including wrappers for a number of 
+  C functions, enumerated types, and globals.
+
+- More example code
+
+- Objective-C mappings and sequences can be accessed using the normal
+  python methods for accessing mappings and sequences (e.g. subscripting
+  works as expected)
+
+- Documentation: See the directory 'docs'
+
+- Can build standalone Cocoa applications based entirely on Python
+  without requiring that user installs anything extra (requires 10.2).
+
+- Better packaging and wrapper construction tools (borrowed from
+  MacPython).
+
+- An installer package.
+
+- Support for Project Builder based Cocoa-Python projects.
+
+- Unit tests.
+
+Version 2002-01-30 (January 30, 2002)
+-------------------------------------
+
+- Version bumped to 0.6.1 ( __version__ is now a PyString )
+
+- Will now build for Python 2.2
+
+- added Cocoa package with Foundation.py and AppKit.py wrappers.
+
+- HelloWorld.py in Examples
+
+- builds with -g flag for debugging. -v option will dump log
+  of message sends to /tmp file.
+
+- Fixed one major runtime bug: added ISCLASS test before isKindOfClass -
+  without check, it crashes on sends to abstract classes like NSProxy.
+
+- There are still problems with Delegates and Notifications. 
+
+Version 2001-03-17 (March 17, 2001)
+-----------------------------------
+
+- moved to using distutils setup.py (requires small patch to distutils
+  that has been submitted against python 2.1b1)
+
+Version 2000-11-14 (November 14, 2000)
+--------------------------------------
+
+- GNU_RUNTIME is likely completely broken
+
+- Compiles on Mac OS X Server (python 2.0)
+
+- Compiles on Mac OS X (python 2.0)
+
+- Works as either a dynamically loadable module or statically built
+  into a python executable
+
+- Requires a modified makesetup to work [patches have been sent to
+  SourceForge.net's Python project].
+
+- Supports NSAutoReleasepool.
+
+- Some pre-OSX stuff removed;  references to old APIs, etc... (but
+  nowhere near clean)
+
+Version 0.55, 18 August 1998
+----------------------------
+
+- Here again, supporting GNU_RUNTIME and GNUstep Base! On my new Linux
+  box I can finally test the module against them: I installed the
+  latest snapshot of gstep-core, that contains the base library
+  too. Given a sane GNUstep env (GNUSTEP_XXX env vars), you should be
+  able to build a static ObjC-ized interpreter by::
+
+    o Adjusting Setup, commenting out NeXT definition and enabling GNU
+      ones;
+    o make -f Makefile.pre.in boot
+    o make static
+
+Version 0.54, 24 March 1998
+---------------------------
+
+- OC_Pasteboard.[hm], OC_Stream.[mh] and ObjCStreams.m are definitively gone.
+
+- OC_PythonObject derives from NSProxy.
+
+Version 0.53, 4 January 1998
+----------------------------
+
+- Tons of changes, retargeting the core functionality around the
+  OpenSTEP API. This release basically matches the previous one
+  in terms of functionalities, but is should be closer to GNUstep.
+
+- OC_Streams and OC_Pasteboard aren't supported, I've not yet decided
+  if they are needed anymore.
+
+- Updated LittleButtonedWindow demo.
+
+Version 0.47, 29 October 1996
+-----------------------------
+
+- Misc/Makefile.pre.in automatically sets TARGET to ``pyobjc``.
+
+- ObjC.m splitted to ObjCObject.m ObjCMethod.m ObjCPointer.m
+  ObjCRuntime.m.
+
+- New (almost invisible) types: ObjCSequenceObject and
+  ObjCMappingObject; this to implement sequence and mapping syntax
+  (several mapping methods have stub implementation).
+
+- OC_Pasteboard class is gone. Its functionalities are now in a
+  category of Pasteboard/NSPasteboard.
+
+- Better methods doc.
+
+- PyArg_ParseTuple format strings contain arguments names.
+
+- OC_Streams are mapped to ObjCStreams by pythonify_c_value and its
+  counterpart.
+
+Version 0.46, 18 October 1996
+-----------------------------
+
+- OC_Stream is now a subclass of NSData under Foundation.
+
+- New Objective-C class: OC_Pasteboard. Use it instead of Pasteboard/
+  NSPasteboard. 
+
+- New Objective-C class: OC_PythonBundle. Use it instead of NXBundle/NSBundle.
+  The ShellText demo has been upgraded to use it, and now you can run it
+  directly from the WorkSpace.
+
+- OC_Python.[hm] aren't in the package anymore.
+
+- Setup.in directives changed again, due to OC_Python.m dropping.
+
+Version 0.45, 14 October 1996
+-----------------------------
+
+- Double syntax: to make it easier for us to test and choose the
+  better candidate, the only one that will be present in the final 1.0
+  release. Keeping both would result in a speed penality.
+- Revisited streams, in particular GNUstep support.
+
+Version 0.44, 9 October 1996
+----------------------------
+
+- Integers are now accepted too where floats or doubles are expected.
+
+- New method: ObjC.make_pointer (1) returns an ObjCPointer containing
+  ``((void *) 1)``.
+
+Version 0.43, 7 October 1996
+----------------------------
+
+- Completed ObjCStream implementation. There is now a new module, ObjCStreams
+  which is automatically loaded by ObjC. You can access it as ObjC.streams.
+
+- Manual splitted in three parts: libPyObjC.tex with the chapter intro,
+  libObjC.tex describing the main module, libObjCStreams.tex explains the
+  stream facilities.
+
+Version 0.42, 4 October 1996
+----------------------------
+
+- You can pass initialization arguments when using the ``Class()`` syntax. You
+  select the right initializer selector with the ``init`` keyword parameter.
+
+- First cut on ObjCStream objects. Thanx to Bill Bumgarner for motivations.
+
+- New demo ShellText, to test above points.
+
+Version 0.41, 2 October 1996
+----------------------------
+
+- Revised error messages: for arguments type mismatch they show the ObjC type
+  expected.
+
+- When a method returns a pointer to something, it gets translated as an
+  ObjCPointer object, not the pythonified pointed value. When a method
+  expects a pointer argument, it accepts such an object as well.
+
+- New demo: Fred. To halt it, suspend the Python process with ^Z then kill
+  it ;-).
+
+- Setup.in directives changed. See the new file Modules/Setup.PyObjC.in
+
+- Distribuited as a standalone package. Special thanks to Bill Bumgarner.
+
+Version 0.4, 27 September 1996
+------------------------------
+
+- Now handles methods returning doubles or floats.
+
+- ObjCRuntime responds to .sel_is_mapped().
+
+Version 0.31, 26 September 1996
+-------------------------------
+
+- It's now possible to use a different strategy to map ObjC method names to
+  Python ones. Sooner or later we should decide the one to go, and drop the
+  other. For details, see comments on PYTHONIFY_WITH_DOUBLE_UNDERSCORE in
+  objc_support.h.
+- Manual section.
+- ObjC.runtime.__dict__ added.
+- ObjC.runtime.kind added.
+
+Version 0.3, 20 September 1996
+------------------------------
+
+- No user visible changes, just a little effort towards GNU_RUNTIME support. 
+
+Version 0.2, 16 September 1996
+------------------------------
+
+- Accepts a struct.pack() string for pointer arguments, but...
+
+- ... New methods on ObjCMethod: .pack_argument and .unpack_argument:
+  these should be used whenever an ObjC method expects a passed-by-reference
+  argument; for example, on NeXTSTEP [View getFrame:] expects a pointer
+  to an NXRect structure, that it will fill with the current frame of the
+  view: in this case you should use something similar to::
+
+        framep = aView.getFrame__.pack_argument (0)
+        aView.getFrame__ (framep)
+        frame = aView.getFrame__.unpack_argument (0, framep)
+
+Version 0.1, 13 September 1996
+------------------------------
+
+- Correctly handle pointer arguments.
+
+- New syntax to get a class: ObjC.runtime.NameOfClass
+
+- New syntax aliasing .new(): SomeClass()
+
+- New Demo: LittleButtonedWindow, that tests points above.
+
+- What follow is the recipe to get PyObjC dynamically loadable on NeXTSTEP:
+
+  * apply the patch in Misc/INSTALL.PyObjC to Python/importdl.c
+
+  * modify Python/Makefile adding the switch ``-ObjC`` to the importdl.o
+    build rule::
+
+      importdl.o:   importdl.c
+        $(CC) -ObjC -c $(CFLAGS) -I$(DLINCLDIR) $(srcdir)/importdl.c
+
+  * modify Modules/Setup moving the PyObjC entry suggested above AFTER
+    ``*shared*``, and remove ``-u libNeXT_s -lNeXT_s`` from it.
+
+  * run ``make``: this will update various files, in particular
+    Modules/Makefile.
+
+  * modify Modules/Makefile adding ``-u libNeXT_s -lNeXT_s`` to SYSLIBS::
+
+       SYSLIBS=      $(LIBM) $(LIBC) -u libNeXT_s -lNeXT_s
+
+  * run ``make`` again

File pyobjc-web/docroot/doc/api-notes-macosx.php

 <?
     $title = "Notes on supported APIs and classes on MacOS X";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>
 </li>
 </ul>
 </div>
+<p>TODO: Add documentation about weak linking (see intro.txt).</p>
 <div class="section" id="introduction">
 <h1><a class="toc-backref" href="#id2" name="introduction">Introduction</a></h1>
 <p>This document describes the restrictions w.r.t. supported APIs and classes
 </div>
 <div class="section" id="class-nsopenglpixelformat">
 <h2><a class="toc-backref" href="#id16" name="class-nsopenglpixelformat">Class <tt class="literal"><span class="pre">NSOpenGLPixelFormat</span></tt></a></h2>
-<ul class="simple">
-<li><tt class="literal"><span class="pre">getValues:forAttribute:forVirtualScreen:</span></tt>
-This method is not yet supported</li>
-<li><tt class="literal"><span class="pre">initWithAttributes:</span></tt>
-This method is not yet supported</li>
+<ul>
+<li><p class="first"><tt class="literal"><span class="pre">getValues:forAttribute:forVirtualScreen:</span></tt></p>
+<p>This method is not yet supported</p>
+</li>
+<li><p class="first"><tt class="literal"><span class="pre">initWithAttributes:</span></tt></p>
+<p>This method is not yet supported</p>
+</li>
 </ul>
 </div>
 <div class="section" id="class-nsquickdrawview">
 <h2><a class="toc-backref" href="#id17" name="class-nsquickdrawview">Class <tt class="literal"><span class="pre">NSQuickDrawView</span></tt></a></h2>
-<ul class="simple">
-<li><tt class="literal"><span class="pre">qdPort</span></tt>
-This method is not yet supported and will return a MacPython wrapper for
-a QuickDraw port in the future.</li>
+<ul>
+<li><p class="first"><tt class="literal"><span class="pre">qdPort</span></tt></p>
+<p>This method returns an instance from a type Carbon.QuickDraw. This 
+requires MacPython.</p>
+</li>
 </ul>
 </div>
 <div class="section" id="class-nssimplehorizontaltypesetter">
 <h2><a class="toc-backref" href="#id24" name="class-nscoder">Class <tt class="literal"><span class="pre">NSCoder</span></tt></a></h2>
 <p>The following methods are not supported in the current version of PyObjC.
 This limitation will be lifted in a future version of the bridge.</p>
-<ul class="simple">
-<li><tt class="literal"><span class="pre">encodeBytes:length:</span></tt></li>
-<li><tt class="literal"><span class="pre">decodeBytesWithReturnedLength:</span></tt></li>
-<li><tt class="literal"><span class="pre">encodeValuesOfObjCType:</span></tt></li>
-<li><tt class="literal"><span class="pre">decodeValuesOfObjCType:</span></tt></li>
-<li><tt class="literal"><span class="pre">decodeBytesForKey:returnedLength:</span></tt></li>
-<li><tt class="literal"><span class="pre">decodeBytesWithoutReturnedLength:</span></tt></li>
+<ul>
+<li><p class="first"><tt class="literal"><span class="pre">decodeBytesWithReturnedLength:</span></tt></p>
+</li>
+<li><p class="first"><tt class="literal"><span class="pre">decodeBytesForKey:returnedLength:</span></tt></p>
+</li>
+<li><p class="first"><tt class="literal"><span class="pre">encodeValuesOfObjCType:</span></tt></p>
+<p>Use multiple calls to <tt class="literal"><span class="pre">encodeValueOfObjCType:at:</span></tt> instead.</p>
+</li>
+<li><p class="first"><tt class="literal"><span class="pre">decodeValuesOfObjCType:</span></tt></p>
+<p>Use multiple calls to <tt class="literal"><span class="pre">decodeValueOfObjCType:at:</span></tt> instead. Note that
+that won't work if your trying to read back data that was written using
+<tt class="literal"><span class="pre">encodeValuesOfObjCType:</span></tt>.</p>
+</li>
 </ul>
+<p>The method <tt class="literal"><span class="pre">decodeBytesWithoutReturnedLength:</span></tt> is not supported, use 
+<tt class="literal"><span class="pre">decodeBytesWithReturnedLength:</span></tt> instead. It is not possible to safely
+represent the return value of this method in Python.</p>
 </div>
 <div class="section" id="class-nsdata">
 <h2><a class="toc-backref" href="#id25" name="class-nsdata">Class <tt class="literal"><span class="pre">NSData</span></tt></a></h2>

File pyobjc-web/docroot/doc/architecture.php

 <?
     $title = "PyObjC Architecture";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>
 </table>
 <div class="section" id="introduction">
 <h1><a name="introduction">Introduction</a></h1>
+<p>XXX: This documented is outdated and incomplete.</p>
 <p>This document gives a (brief) description of how the PyObjc package is 
-structured. Too bad this document is outdated and incomplete...</p>
+structured.</p>
 </div>
 <div class="section" id="objective-c-classes-and-objects">
 <h1><a name="objective-c-classes-and-objects">Objective-C classes and objects</a></h1>

File pyobjc-web/docroot/doc/classes.php

 <?
     $title = "Python classes and Objective-C code";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>

File pyobjc-web/docroot/doc/coding-style.php

 <?
     $title = "Coding style for PyObjC";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>
 <pre class="literal-block">
 # Author: David Goodger
 # Contact: goodger&#64;users.sourceforge.net
-# Revision: $Revision: 1.4 $
-# Date: $Date: 2003/07/05 14:59:46 $
 # Copyright: This module has been placed in the public domain.
 </pre>
 </li>

File pyobjc-web/docroot/doc/developer.php

 <?
 $title = "Developer Documentation";
 $cvs_author = '$Author: ronaldoussoren $';
-$cvs_date = '$Date: 2003/07/05 14:59:46 $';
+$cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
 include "header.inc";
 ?>
 <ul>
 <!-- DEVDOC -->
 <LI><A HREF="coding-style.php">Coding style for PyObjC</A>
+<LI><A HREF="c-api.php">Documentation for the PyObjC C-API (Preliminary)</A>
 <LI><A HREF="structure.php">Structure of the PyObjC package</A>
 <LI><A HREF="architecture.php">PyObjC Architecture</A>
 <LI><A HREF="classes.php">Python classes and Objective-C code</A>

File pyobjc-web/docroot/doc/extending_objc_with_python.php

 <?
     $title = "Tutorial - Adding Python code to an existing ObjC application";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>

File pyobjc-web/docroot/doc/index.php

 <?
 $title = "Documentation";
 $cvs_author = '$Author: ronaldoussoren $';
-$cvs_date = '$Date: 2003/07/05 14:59:46 $';
+$cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
 include "header.inc";
 ?>
 
 <h1>PyObjC Documentation</h1>
 
-<p>
-The documentation for the PyObjC project is incomplete and one of our major
-items on the TODO list for PyObjC 1.0. The documents mentioned on this page
-should be enough to get you going.
-</p>
-
 <h2>User Documentation</h2>
 
 <p>
 <!-- USERDOC -->
 <LI><A HREF="install.php">Installation Instructions</A>
 <LI><A HREF="intro.php">An introduction to PyObjC</A>
-<LI><A HREF="users.php">Userguide for PyObjC</A>
 <LI><A HREF="tutorial.php">Creating your first PyObjC application.</A>
 <LI><A HREF="extending_objc_with_python.php">Tutorial - Adding Python code to an existing ObjC application</A>
 <LI><A HREF="tutorial_reading.php">Understanding existing PyObjC examples</A>
 <LI><A HREF="projectbuilder-syntaxhighlighting.php">Project Builder Python Support</A>
+<LI><A HREF="pyobjctools.php">PyObjCTools: The PyObjC Toolbox</A>
 <LI><A HREF="api-notes-macosx.php">Notes on supported APIs and classes on MacOS X</A>
-<LI><A HREF="warts.php">Odd features</A>
 <LI><A HREF="wrapping.php">How to wrap an Objective-C class library</A>
 <!-- /USERDOC -->
 </ul>
 <ul>
 <!-- DEVDOC -->
 <LI><A HREF="coding-style.php">Coding style for PyObjC</A>
+<LI><A HREF="c-api.php">Documentation for the PyObjC C-API (Preliminary)</A>
 <LI><A HREF="structure.php">Structure of the PyObjC package</A>
 <LI><A HREF="architecture.php">PyObjC Architecture</A>
 <LI><A HREF="classes.php">Python classes and Objective-C code</A>

File pyobjc-web/docroot/doc/install.php

 <?
     $title = "Installation Instructions";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>
 above will only install pyobjc for whatever version of python is the
 default on the command line.   Make sure you are installing python
 against the correct version of python.</p>
+<p>To be able to build the wrappers for the WebKit framework (included with
+Safari 1.0), you'll have to install the WebKit SDK. You can download 
+this from the <a class="reference" href="http://connect.apple.com">ADC website</a>.</p>
 </div>
 <div class="section" id="examples">
 <h1><a name="examples">Examples</a></h1>

File pyobjc-web/docroot/doc/intro.php

 <?
     $title = "An introduction to PyObjC";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>
 <div class="contents topic" id="contents">
 <p class="topic-title"><a name="contents">Contents</a></p>
 <ul class="simple">
-<li><a class="reference" href="#work-in-progress" id="id2" name="id2">WORK IN PROGRESS</a></li>
 <li><a class="reference" href="#preface" id="id3" name="id3">Preface</a></li>
 <li><a class="reference" href="#objective-c-for-pyobjc-users" id="id4" name="id4">Objective-C for PyObjC users</a></li>
-<li><a class="reference" href="#overview-of-the-bridge" id="id5" name="id5">Overview of the bridge</a></li>
-<li><a class="reference" href="#cocoa-for-python-programmers" id="id6" name="id6">Cocoa for Python programmers</a></li>
-<li><a class="reference" href="#building-applications" id="id7" name="id7">Building applications</a><ul>
-<li><a class="reference" href="#pure-python-buildapp-py" id="id8" name="id8">&quot;Pure Python&quot; :  buildapp.py</a></li>
-<li><a class="reference" href="#ide-approach-project-builder" id="id9" name="id9">&quot;IDE approach&quot; : Project builder</a></li>
+<li><a class="reference" href="#overview-of-the-bridge" id="id5" name="id5">Overview of the bridge</a><ul>
+<li><a class="reference" href="#classes" id="id6" name="id6">Classes</a></li>
+<li><a class="reference" href="#methods-and-functions" id="id7" name="id7">Methods and functions</a></li>
+<li><a class="reference" href="#reference-counting" id="id8" name="id8">Reference counting</a></li>
+<li><a class="reference" href="#informal-protocols" id="id9" name="id9">(Informal) protocols</a></li>
+</ul>
+</li>
+<li><a class="reference" href="#cocoa-for-python-programmers" id="id10" name="id10">Cocoa for Python programmers</a></li>
+<li><a class="reference" href="#notes-on-specific-tasks" id="id11" name="id11">Notes on specific tasks</a><ul>
+<li><a class="reference" href="#working-with-threads" id="id12" name="id12">Working with threads</a></li>
+</ul>
+</li>
+<li><a class="reference" href="#building-applications" id="id13" name="id13">Building applications</a><ul>
+<li><a class="reference" href="#pure-python-buildapp-py" id="id14" name="id14">&quot;Pure Python&quot; :  buildapp.py</a></li>
+<li><a class="reference" href="#ide-approach-project-builder" id="id15" name="id15">&quot;IDE approach&quot; : Project builder</a></li>
 </ul>
 </li>
 </ul>
 </div>
-<div class="section" id="work-in-progress">
-<h1><a class="toc-backref" href="#id2" name="work-in-progress">WORK IN PROGRESS</a></h1>
-<p>This document is work in progress and thin on details.</p>
-</div>
 <div class="section" id="preface">
 <h1><a class="toc-backref" href="#id3" name="preface">Preface</a></h1>
 <p>PyObjC is a bridge between Python and Objective-C. It allows you to write 
 </div>
 <div class="section" id="objective-c-for-pyobjc-users">
 <h1><a class="toc-backref" href="#id4" name="objective-c-for-pyobjc-users">Objective-C for PyObjC users</a></h1>
+<p>It is necessary to understand a little bit of Objective-C to use PyObjC,
+this helps you to better understand the class libraries and makes it easier
+to read (and translate) example code.</p>
 <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
 <p>Object allocation and initialization are explicit and seperate actions in 
 Objective-C. The former is done by the class-method <tt class="literal"><span class="pre">alloc</span></tt>, while the
 latter is done by instance-methods whose name customarily starts with <tt class="literal"><span class="pre">init</span></tt>.</p>
+<p>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
+declaration (usually found in <tt class="literal"><span class="pre">.h</span></tt> files) and implementation (usually found
+in <tt class="literal"><span class="pre">.m</span></tt> files) are listed below). Class declarations are easily recognized as 
+blocks of code between <tt class="literal"><span class="pre">&#64;interface</span></tt> and <tt class="literal"><span class="pre">&#64;end</span></tt>, and simularly the 
+implementation is between <tt class="literal"><span class="pre">&#64;implementation</span></tt> and <tt class="literal"><span class="pre">&#64;end</span></tt>. Calling methods
+is done using expressions enclosed with brackets (name?), e.g. 
+<tt class="literal"><span class="pre">[foo</span> <span class="pre">method]</span></tt>.  This is the same as <tt class="literal"><span class="pre">foo.method()</span></tt> in Python.</p>
+<p>A class declaration:</p>
+<pre class="literal-block">
+&#64;interface MYClass : MySuperClass
+{
+   id  anInstanceVariable;
+   int anotherInstanceVariable;
+}
+
++aClassMethod;
+
+-(int)anInstanceMethodWithArg1:arg1 andArg2:(BOOL)arg2;
+&#64;end
+</pre>
+<p>A class implemenation:</p>
+<pre class="literal-block">
+&#64;implementation MYClass
+
++aClassMethod
+{
+     id res = [[MYClass alloc] init];
+     return res;
+}
+
+-(int)anInstanceMethodWithArg1:arg1 andArg2:(BOOL)arg2
+{
+     int res;
+
+     if (arg2) {
+             res = [self fooWith:arg1];
+     } else {
+             res = [arg1 bar];
+     }
+}
+
+&#64;end
+</pre>
+<p>Objective-C also features exceptions, but as those are mostly used for disaster
+recovery and not for normal error handling you won't see them very often
+in example code. The <a class="reference" href="http://developer.apple.com/techpubs/macosx/Cocoa/ObjectiveC/index.html">The Objective-C Programming Language</a> if you want to
+know more about exceptions in Objective-C.</p>
+<p>One thing to keep in mind when translating Objective-C snippets to python is
+that it is valid to call methods on <tt class="literal"><span class="pre">nil</span></tt> (that is the NULL pointer). Those
+method calls are ignored by the runtime. The value <tt class="literal"><span class="pre">nil</span></tt> is represented in
+Python by the <tt class="literal"><span class="pre">None</span></tt>, this means that calls to non-existing methods are
+not ignored but will raise <tt class="literal"><span class="pre">AttributeError</span></tt>.</p>
 <p>For more information about Objective-C see:</p>
 <ul class="simple">
 <li><a class="reference" href="http://developer.apple.com/techpubs/macosx/Cocoa/ObjectiveC/index.html">The Objective-C Programming Language</a> at <a class="reference" href="http://www.apple.com/">Apple</a>.</li>
 </div>
 <div class="section" id="overview-of-the-bridge">
 <h1><a class="toc-backref" href="#id5" name="overview-of-the-bridge">Overview of the bridge</a></h1>
-<p>Objective-C classes are visible as Python classes and can be subclassed just
-like normal Python classes. The major differences between normal Python classes
-and Objective-C classes are the way you create instances and the fact that 
-Objective-C classes have odd names.</p>
+<div class="section" id="classes">
+<h2><a class="toc-backref" href="#id6" name="classes">Classes</a></h2>
+<p>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 
+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 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
+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
+you won't get errors about this.</p>
+<p>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 <em>not</em> 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 
+(short) prefix and stick that in front of all class names, e.g. Apple <tt class="literal"><span class="pre">NS</span></tt> 
+as the prefix in the <a class="reference" href="http://developer.apple.com/techpubs/macosx/Cocoa/CocoaTopics.html">Cocoa libraries</a>.</p>
 <p>As described in <a class="reference" href="#objective-c-for-pyobjc-users">Objective-C for PyObjC users</a> the creation of Objective-C 
 objects is a two-stage process. You first call the class method <tt class="literal"><span class="pre">alloc</span></tt>, and
 then call some variation of <tt class="literal"><span class="pre">init</span></tt> to initialize the objects. The newly
 created object is the result of the call to <tt class="literal"><span class="pre">init</span></tt>. Most classes have 
 convienence class methods that combine the calls to <tt class="literal"><span class="pre">alloc</span></tt> and <tt class="literal"><span class="pre">init</span></tt>.</p>
+</div>
+<div class="section" id="methods-and-functions">
+<h2><a class="toc-backref" href="#id7" name="methods-and-functions">Methods and functions</a></h2>
 <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
 for translation are:</p>
 <li>Concatenate all elements of the method name: <tt class="literal"><span class="pre">someMethod:withFoo:andBar:</span></tt></li>
 <li>Then convert all colons to underscores: <tt class="literal"><span class="pre">someMethod_withFoo_andBar_</span></tt></li>
 </ul>
-<p>The bridged method usually has the same number of arguments as the orginal 
-method and also returns the same as the original method. In special 
-circumstances the method interface may be different from the Objective-C 
-interface, those methods are document in 'some other document'. Furthermore,
-some methods have pass-by-reference arguments (that is a pointer to a single
-value that is used to transfer data to (in), from (out) or to-and-from (inout)
-the method. The arguments that are passed to methods is present as normal 
-arguments in the bridged method (e.g. if the method has an <tt class="literal"><span class="pre">int*</span></tt> argument
-the bridged method has has an integer argument).  Data that is passed from the
-function results in additional return values from the function.</p>
-<p>When the bridge cannot automaticly deduce the right signature for a method, or
-if you want to add a method whose name cannot be transformed into Python (
-for example a methodname containing <tt class="literal"><span class="pre">$</span></tt>), you'll have to add explicit hints
-to your code. You do this by calling the function <tt class="literal"><span class="pre">objc.selector</span></tt> and using
-the result instead of your method definition:</p>
+<p>Wrapped/bridged methods (and functions) have the same number of arguments
+as the corresponding Objective-C method or function, unless otherwise noted
+in the documentation (<a class="reference" href="api-notes-macosx.html">Notes on supported APIs and classes on MacOS X</a> for
+Cocoa on MacOS X).</p>
+<p>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 <em>pass by reference</em> arguments, and can be subdived into
+three types of arguments: <tt class="literal"><span class="pre">in</span></tt> arguments are used to pass data to the 
+function, <tt class="literal"><span class="pre">out</span></tt> arguments are used to pass data from the function (e.g. and
+additional return value) and <tt class="literal"><span class="pre">inout</span></tt> arguments are a combination of the two.</p>
+<p>The <tt class="literal"><span class="pre">in</span></tt> and <tt class="literal"><span class="pre">inout</span></tt> arguments for a method are also present in the Python
+interface for that method (or function). In python the value passed to the
+function is a &quot;normal&quot; argument. <tt class="literal"><span class="pre">Out</span></tt> arguments are not present in the 
+argument list of the Python function.</p>
+<p>If a function (or method) has one or more output arguments (<tt class="literal"><span class="pre">out</span></tt> or 
+<tt class="literal"><span class="pre">inout</span></tt>) the output values are returned as part of the return value of the
+method. That is, the return value of the function is a tuple containing
+the return value of the C function (or method), followed by the values of
+the <tt class="literal"><span class="pre">out</span></tt> in <tt class="literal"><span class="pre">inout</span></tt> arguments in the order the are present in the argument
+list. If the C function (or method) has return type <tt class="literal"><span class="pre">void</span></tt>, the tuple contains
+only the output arguments. As a final complication, methods with a single output
+argument and return type <tt class="literal"><span class="pre">void</span></tt>, have the value of the output argument as
+the return value (e.g. not a tuple containing the return value).</p>
+<p>The rules for pass by reference arguments may look quite complicated, but
+it turns out this is very straightforward when working with them.</p>
+<p>As an example of a method with two output arguments, NSMatrix has a method
+named <tt class="literal"><span class="pre">getNumberOfRows_columns_</span></tt> with the following signature:</p>
+<pre class="literal-block">
+(void)getNumberOfRows:(int *)rowCount columns:(int *)columnCount
+</pre>
+<p>You use this method in python like this:</p>
+<pre class="literal-block">
+rowCount, columnCount = matrix.getNumberOfRows_columns_()
+</pre>
+<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 
+signature when it has more information available. Specifically, if you 
+overide 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>
+<p>The end result is that you almost never have to add information about the
+signature of methods. The only known case where you have to tell the bridge
+about the signature of a method is the call-back method for sheets. You can
+use the function <tt class="literal"><span class="pre">PyObjCTools.AppHelper.endSheetMethod</span></tt> to create an object
+that contains the right information. This function is used like 
+<tt class="literal"><span class="pre">staticmethod</span></tt> and <tt class="literal"><span class="pre">classmethod</span></tt> (as introduced in Python 2.2).</p>
+<p>For complete control of the mapping to Objective-C you can use the function
+<tt class="literal"><span class="pre">objc.selector</span></tt>. See the documentation of the <tt class="literal"><span class="pre">objc</span></tt> module for the
+arguments you can use with this function. It is normally used like this:</p>
 <pre class="literal-block">
 class MyObject (NSObject):
         def someMethod_(self, arg):
 
         someMethod_ = objc.selector(someMethod_, ...)
 </pre>
-<p>The other arguments of <tt class="literal"><span class="pre">objc.selector</span></tt> (not shown in the example) provide
-additional information about the method to the bridge, see the online 
-documentation for more information about this function. It is almost never
-necessary to use this technique.</p>
-<p>If you write a method for an Objecitve-C class in Python, PyObjC will try to
-deduce the method's signature. If it's overriding a method, the signature of
-the method that is overridden is taken. If it's a method that appears
-<em>anywhere</em> in an informal protocol definition in a framework that's currently
-loaded, PyObjC takes the signature from there. (Most wrapped frameworks have a
-submodule named <tt class="literal"><span class="pre">protocols.py</span></tt> that contains informal protocol definitions.)</p>
+</div>
+<div class="section" id="reference-counting">
+<h2><a class="toc-backref" href="#id8" name="reference-counting">Reference counting</a></h2>
+<p>The <a class="reference" href="http://developer.apple.com/techpubs/macosx/Cocoa/CocoaTopics.html">Cocoa libraries</a>, and most (if not all) other class libraries for 
+Objective-C use explicit reference counting to manage memory. The methods
+<tt class="literal"><span class="pre">retain</span></tt>, <tt class="literal"><span class="pre">release</span></tt> and <tt class="literal"><span class="pre">autorelease</span></tt> are used to manage these 
+reference counts. You won't have to manage reference counts in Python, the
+bridge does all that work for you.</p>
+<p>The only reasons reference counts are mentioned at all are to tell you about
+ignoring them, and more importantly to introduce you to some issues w.r.t. 
+reference counting.</p>
+<p>It turns out that Cocoa uses a primitive form of <a class="reference" href="http://www.python.org/doc/current/lib/module-weakref.html">weak references</a>. Those 
+are not true <a class="reference" 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
+dealing with those <a class="reference" 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
+the bridge works, this means that you must make sure that you don't create
+weak references from Objective-C to a plain Python object. The Python
+object stays alive, but the proxy object as seen by the Objective-C code is
+actually an autoreleased object that will be cleaned up unless the Objective-C
+code increases its reference count.</p>
+<p>The document <a class="reference" href="api-notes-macosx.html">Notes on supported APIs and classes on MacOS X</a> contains 
+information about classes that work with weak references. The most important
+are notification centers and <tt class="literal"><span class="pre">NSOutlineView</span></tt>, to be exact: the outline view
+stores weak references to the objects return by the method 
+<tt class="literal"><span class="pre">outlineView:child:ofItem:</span></tt> of its data source. The easiest way to avoid
+crashes with outline views is to make sure that you model for the view uses
+subclasses of <tt class="literal"><span class="pre">NSObject</span></tt> to represent the nodes in the outline view.</p>
+<p>Another gotcha is when you're manually allocating and assigning delegate(-like)
+objects: most of the time <tt class="literal"><span class="pre">obj.setDelegate_()</span></tt> will <em>not</em> retain the 
+delegate, so you must keep a reference manually.</p>
+</div>
+<div class="section" id="informal-protocols">
+<h2><a class="toc-backref" href="#id9" name="informal-protocols">(Informal) protocols</a></h2>
+<p>Cocoa defines a number of formal and informal protocols that specify methods
+that should be implemented by a class if it is to be used in a specific role,
+such as the data source for an NSTableView.</p>
+<p>Those protocols are represented by instances of <tt class="literal"><span class="pre">objc.informal_protocol</span></tt>. The
+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 <tt class="literal"><span class="pre">informal_protocol</span></tt> 
+objects to add the right method signatures to methods, and to warn about
+classes that partially implement a protocol.</p>
+</div>
 </div>
 <div class="section" id="cocoa-for-python-programmers">
-<h1><a class="toc-backref" href="#id6" name="cocoa-for-python-programmers">Cocoa for Python programmers</a></h1>
+<h1><a class="toc-backref" href="#id10" name="cocoa-for-python-programmers">Cocoa for Python programmers</a></h1>
 <p>Cocoa frameworks are mapped onto Python packages with the same name, that is
 the classes, constants and functioins from the AppKit framework are available
 after you import <tt class="literal"><span class="pre">AppKit</span></tt> in your Python script.</p>
+<p>These helper modules contain <em>only</em> functions, constants and classes that 
+wrap items in the corresponding framework. All utility functions and classes 
+are located in the <tt class="literal"><span class="pre">PyObjCTools</span></tt> package and <tt class="literal"><span class="pre">objc</span></tt> module. Note that it
+is possible to use <tt class="literal"><span class="pre">pydoc</span></tt> (or the <tt class="literal"><span class="pre">help()</span></tt>) function with the framework
+wrappers, but that this is not very usefull for the entire module due to the
+size of these modules.</p>
+<p>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
+item is documented in the PyObjC documentation.</p>
 <p>The module <tt class="literal"><span class="pre">PyObjCTools.NibClassBuilder</span></tt> can be used to make working with 
 NIB files more convenient. This module can be used to extract information 
 about classes from NIB files, both as a standalone tool generating source code 
 and during runtime. See the online documentation for this module for more
 information.</p>
-<p><strong>TODO</strong>:</p>
-<ul class="simple">
-<li>Links to example PyObjC scripts.</li>
-</ul>
+<p>PyObjC includes a number of examples that show how to use Cocoa from
+Python. The <a class="reference" href="../Examples/00ReadMe.html">PyObjC Example index</a> contains an overview of those examples.</p>
 <p>More information on Cocoa programming can be found at:</p>
 <ul class="simple">
 <li><a class="reference" href="http://developer.apple.com/techpubs/macosx/Cocoa/CocoaTopics.html">Cocoa documentation at the Apple developer website</a></li>
 <li>Your local bookstore or library</li>
 </ul>
 </div>
+<div class="section" id="notes-on-specific-tasks">
+<h1><a class="toc-backref" href="#id11" name="notes-on-specific-tasks">Notes on specific tasks</a></h1>
+<div class="section" id="working-with-threads">
+<h2><a class="toc-backref" href="#id12" name="working-with-threads">Working with threads</a></h2>
+<p>When you create a thread and want to use PyObjC from that thread you will
+have to create an <tt class="literal"><span class="pre">NSAutoreleasePool</span></tt> in that thread and clean it up when
+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 <tt class="literal"><span class="pre">NSThread</span></tt> 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 
+to use <tt class="literal"><span class="pre">NSThread</span></tt> to create new threads).  This restriction will be lifted
+in a future version of PyObjC (at least when using Python 2.3).</p>
+</div>
+</div>
 <div class="section" id="building-applications">
-<h1><a class="toc-backref" href="#id7" name="building-applications">Building applications</a></h1>
+<h1><a class="toc-backref" href="#id13" name="building-applications">Building applications</a></h1>
 <p>There are two different ways to build applications with PyObjC. There are no
 major advantages to using either one of them, use the one that is most 
 convenient to you.</p>
 <div class="section" id="pure-python-buildapp-py">
-<h2><a class="toc-backref" href="#id8" name="pure-python-buildapp-py">&quot;Pure Python&quot; :  buildapp.py</a></h2>
+<h2><a class="toc-backref" href="#id14" name="pure-python-buildapp-py">&quot;Pure Python&quot; :  buildapp.py</a></h2>
 <p>PyObjC includes a copy of the <tt class="literal"><span class="pre">bundlebuilder</span></tt> module. This module will be
 part of the Python 2.3 MacPython release and offers a way to build
 distutils-style scripts  for building (standalone) applications.</p>
 incompatible Python version.</p>
 <p>The online documentation for <tt class="literal"><span class="pre">bundlebuilder</span></tt> contains more information on 
 building <tt class="literal"><span class="pre">buildapp.py</span></tt> scripts and how to invoke them. There are plenty of
-example <tt class="literal"><span class="pre">buildapp.py</span></tt> scripts in the various <a class="reference" href="../Examples">Examples</a> subfolders.</p>
+example <tt class="literal"><span class="pre">buildapp.py</span></tt> scripts in the various <a class="reference" href="../Examples/00ReadMe.txt">Examples</a> subfolders.</p>
 </div>
 <div class="section" id="ide-approach-project-builder">
-<h2><a class="toc-backref" href="#id9" name="ide-approach-project-builder">&quot;IDE approach&quot; : Project builder</a></h2>
+<h2><a class="toc-backref" href="#id15" name="ide-approach-project-builder">&quot;IDE approach&quot; : Project builder</a></h2>
 <p>PyObjC includes a number of Project Builder templates that can be used to 
-build (standalone) applications.</p>
-<p><strong>TODO</strong>:</p>
-<ul class="simple">
-<li>Expand this section, input needed as I don't use Project Builder</li>
-<li>Add link to documentation about our templates</li>
-<li>Add link to documentation for Project Builder</li>
-</ul>
+build (standalone) applications. Those templates are used like any other
+Project Builder 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.</p>
+<p>The templates will build an application that makes use of the installed copy
+<tt class="literal"><span class="pre">/usr/bin/python</span></tt> (e.g. the one shipped by Apple in MacOS X 10.2) and will 
+copy the PyObjC modules into the application bundle. This means that this 
+application bundle should be useable on any MacOS X 10.2 system.</p>
+<p>See <a class="reference" href="ProjectBuilder-Templates.html">the documentation for the templates</a> for more details.</p>
+<p>MacOS X 10.3 seems to ship with Python 2.3 as /usr/bin/python. This means that
+standalone applications build using the Project Builder templates will start
+to complain about Python ABI versions in the <tt class="literal"><span class="pre">Console</span></tt> when you run them
+on MacOS X 10.3. These are harmless messages caused by the extension modules
+in PyObjC.</p>
 </div>
 </div>
 </div>

File pyobjc-web/docroot/doc/projectbuilder-syntaxhighlighting.php

 <?
     $title = "Project Builder Python Support";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>
 <li><a class="reference" href="#misc" id="id5" name="id5">Misc.</a></li>
 </ul>
 </div>
+<p>Triple-quoted strings are not always treated correctly by Project Builder. This
+seems to be a Project Builder bug.</p>
 <div class="section" id="installation">
 <h1><a class="toc-backref" href="#id2" name="installation">Installation</a></h1>
 <p>Create the directory 'Specifications' within
 <pre class="literal-block">
 cp Python.pb*spec ~/Developer/ProjectBuilder\ Extras/Specifications/
 </pre>
+<p>The binary installer will install the specifications for you.</p>
 </div>
 <div class="section" id="documentation">
 <h1><a class="toc-backref" href="#id3" name="documentation">Documentation</a></h1>

File pyobjc-web/docroot/doc/step3-MainMenu.nib.zip

Binary file modified.

File pyobjc-web/docroot/doc/structure.php

 <?
     $title = "Structure of the PyObjC package";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>
 HTML. -->
 <div class="section" id="introduction">
 <h1><a name="introduction">Introduction</a></h1>
+<p>XXX:  This documet 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>

File pyobjc-web/docroot/doc/tutorial.php

 <?
     $title = "Creating your first PyObjC application.";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>

File pyobjc-web/docroot/doc/tutorial_reading.php

 <?
     $title = "Understanding existing PyObjC examples";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>
 make your code harder to read (because the Controller will contain a mix
 of algorithms and glue code), but there is no architectural reason that
 stops you. If you combine the two classes it is customary to use the name
-you would use for your document class, so without &quot;Controller&quot;.</p>
+you would use for your document class, so without &quot;Controller&quot;. Note that
+MVC is not specific to Cocoa, you can use the paradigm with any GUI toolkit,
+but Cocoa really steers you towards it.</p>
 <p>You should have an MVC trio for every distinct unit of information in your
 program. In case of a simple dialog-style application such as Currency Converter
 you will have one such trio. Most applications, however, will have at least
 the objects get a running start. Again, this is conceptually similar
 to how unpickling works.</p>
 <blockquote>
-The section above explains a lot of the strangeness in PyObjC
+<p>The section above explains a lot of the strangeness in PyObjC
 programs: why you don't create windows and other dialogs (they
 already exist); why you shouldn't do initialization in <tt class="literal"><span class="pre">__init__</span></tt>
 (because it will be called at some undefined point in time, while
-reading the NIB) but in <tt class="literal"><span class="pre">awakeFromNIB</span></tt> in stead; why you don't
+reading the NIB) but in <tt class="literal"><span class="pre">awakeFromNib:</span></tt> in stead; why you don't
 have to create and initialize the attributes that tie your
-objects together (they are already tied together).</blockquote>
+objects together (they are already tied together).</p>
+<p><tt class="literal"><span class="pre">awakeFromNib:</span></tt> is very similar in nature to <tt class="literal"><span class="pre">__setstate__</span></tt> for
+a pickled Python object, but it happens after all objects have been
+unserialized.</p>
+</blockquote>
 <p>This also explains why you want separate NIB files for each MVC trio:
 the objects and classes in a NIB file are all unpickled together. In other
 words: if you had created your document window in your application NIB
 But in addition the NIB also contains a large proportion of your Model
 functionality: creating the View and Controller objects and tieing the
 lot together.</p>
-<p>XXXX Explain about delegates instead of subclassing.</p>
+</div>
+<div class="section" id="delegates">
+<h1><a name="delegates">Delegates</a></h1>
+<p>If you are familiar with other object-oriented GUI toolkits such as MFC
+another thing to notice is that Cocoa applications often use a <em>delegate</em>
+object where other toolkits would use a subclass. For example: it is not
+common to use your own subclass in stead of <tt class="literal"><span class="pre">NSApplication</span></tt> for the
+main application object. In stead, <tt class="literal"><span class="pre">NSApplication</span></tt> objects have a helper
+called its <tt class="literal"><span class="pre">delegate</span></tt>. The application object will attempt to inform
+its delegate of all sorts of things happening, and the delegate implements
+only the methods for the events in which it is interested.</p>
+<p>For example, the method <tt class="literal"><span class="pre">applicationShouldTerminate:</span></tt> on the delegate
+is called just before the application quits, and it has a chance to return
+<tt class="literal"><span class="pre">NO</span></tt> if you don't want to quit just yet.</p>
 </div>
 <div class="section" id="examining-a-nib-file">
 <h1><a name="examining-a-nib-file">Examining a NIB file</a></h1>
-<p>Let us examine the NIB of the Currency Converter tutorial with this in mind.
+<p>Let us examine the final NIB of the Currency Converter tutorial with this in mind.
 If you open it and look at the main window (the one with &quot;MainMenu.nib&quot; as
 its title) and select the &quot;Instances&quot; pane you see six objects. Two of these
 have a greyed-out name (&quot;File's Owner&quot; and &quot;First Responder&quot;): these have
 Because this application is not a document-based application the MVC trio
 for the actual conversion window are in here too: <tt class="literal"><span class="pre">Converter</span></tt>, <tt class="literal"><span class="pre">Window</span></tt> and
 <tt class="literal"><span class="pre">ConverterController</span></tt> respectively.</p>
-<p>XXXX Examine ConverterController, show how to see class and methods</p>
-<p>XXXX Show how to see connections</p>
-<p>XXXX Show how to use outline view</p>
+<p>Let us have a look at the <tt class="literal"><span class="pre">ConverterController</span></tt> object by double clicking it.
+The &quot;MainMenu.nib&quot; window goes to the &quot;Classes&quot; tab, and an info window shows up.
+In the &quot;MainMenu.nib&quot; window the <tt class="literal"><span class="pre">ConverterController</span></tt> class is selected, and
+you can see it is a subclass of <tt class="literal"><span class="pre">NSobject</span></tt>. Having the same name for the class
+and the instance is common in Cocoa programs, the main exception being the File
+Owner object.</p>
+<p>The info window shows more information on the <tt class="literal"><span class="pre">ConverterController</span></tt> class. It
+should pop open to the &quot;attributes&quot; page. In the &quot;Outlets&quot; tab you see that instances
+of this class have four attributes, <tt class="literal"><span class="pre">converter</span></tt>, <tt class="literal"><span class="pre">rateField</span></tt>, <tt class="literal"><span class="pre">dollarField</span></tt>
+and <tt class="literal"><span class="pre">totalField</span></tt>. In any instance of <tt class="literal"><span class="pre">ConverterController</span></tt> you can connect these
+to other objects, as we shall see below. The &quot;Actions&quot; tab shows that there are two
+methods <tt class="literal"><span class="pre">convert:</span></tt> and <tt class="literal"><span class="pre">invertRate:</span></tt>, and again you can arrange for these to
+be called on instances of your <tt class="literal"><span class="pre">ConverterController</span></tt> on certain events by
+making connections.</p>
+<p>So let us now look at the connections for our <tt class="literal"><span class="pre">ConverterController</span></tt> <em>instance</em>. Select
+the &quot;Instances&quot; tab in the main window, select <tt class="literal"><span class="pre">ConverterController</span></tt> and set the info
+window to show &quot;Connections&quot;. You now see all the outlets defined in the class.
+Select one, and in the lower half of the info window you will see which object it connects
+to. Moreover, a blue line will also link the object representations in the main window and
+in the dialog preview window.</p>
+<p>Finding out who calls your <tt class="literal"><span class="pre">convert:</span></tt> method is more difficult, though, with this view.
+But, if you select the &quot;Convert&quot; button in the dialog you will see that its <tt class="literal"><span class="pre">target</span></tt>
+action will go to the <tt class="literal"><span class="pre">ConverterController.convert:</span></tt> method.</p>
+<p>Luckily there is a way to find such incoming connections without reverting to guessing.
+For instance, you will be hard put to find who, if anyone, calls 
+<tt class="literal"><span class="pre">ConverterController.invertRate:</span></tt>. 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
+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
+on the incoming connections icon. The view will change again and ConverterController
+will probably scroll out of sight. Locate it, and see that there are two lines
+going out of the ConverterController object. One goes to <tt class="literal"><span class="pre">NSButton(Convert)</span></tt>
+and is labeled <tt class="literal"><span class="pre">convert:</span></tt>, we knew about that already. The other one goes to an
+object <tt class="literal"><span class="pre">NSMenuItem(Invert</span> <span class="pre">Exchange</span> <span class="pre">Rate)</span></tt> and is labeled <tt class="literal"><span class="pre">invertRate:</span></tt>, so that
+is where calls to <tt class="literal"><span class="pre">invertRate:</span></tt> come from. And if you look at where this
+<tt class="literal"><span class="pre">NSMenuItem</span></tt> sits in the object hierarchy you find that it is an entry in the
+&quot;Edit&quot; menu in the menubar.</p>
 </div>
-<div class="section" id="examining-an-example">
-<h1><a name="examining-an-example">Examining an example</a></h1>
-<p>XXXX Pick one of the interesting examples and walk through it, looking at the
-NIB file and the code.</p>
+<div class="section" id="examining-an-apple-example">
+<h1><a name="examining-an-apple-example">Examining an Apple example</a></h1>
+<p>This section remains to be written. Contributions will be gratefully accepted:-)</p>
 </div>
 </div>
 <?

File pyobjc-web/docroot/doc/usage.php

 <?
 $title = "User documentation";
 $cvs_author = '$Author: ronaldoussoren $';
-$cvs_date = '$Date: 2003/07/05 14:59:46 $';
+$cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
 include "header.inc";
 ?>
 <!-- USERDOC -->
 <LI><A HREF="install.php">Installation Instructions</A>
 <LI><A HREF="intro.php">An introduction to PyObjC</A>
-<LI><A HREF="users.php">Userguide for PyObjC</A>
 <LI><A HREF="tutorial.php">Creating your first PyObjC application.</A>
 <LI><A HREF="extending_objc_with_python.php">Tutorial - Adding Python code to an existing ObjC application</A>
 <LI><A HREF="tutorial_reading.php">Understanding existing PyObjC examples</A>
 <LI><A HREF="projectbuilder-syntaxhighlighting.php">Project Builder Python Support</A>
+<LI><A HREF="pyobjctools.php">PyObjCTools: The PyObjC Toolbox</A>
 <LI><A HREF="api-notes-macosx.php">Notes on supported APIs and classes on MacOS X</A>
-<LI><A HREF="warts.php">Odd features</A>
 <LI><A HREF="wrapping.php">How to wrap an Objective-C class library</A>
 <!-- /USERDOC -->
 </ul>

File pyobjc-web/docroot/doc/wrapping.php

 <?
     $title = "How to wrap an Objective-C class library";
     $cvs_author = '$Author: ronaldoussoren $';
-    $cvs_date = '$Date: 2003/07/05 14:59:46 $';
+    $cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
     include "header.inc";
 ?>
 is all that is needed.</p>
 <p>Don't forget to import the frameworks that are used by your framework before
 calling <tt class="literal"><span class="pre">objc.loadBundle</span></tt>. This is necessary to arrange for the helper code
-for these modules (if there is any) to be loaded.</p>
+for these modules (if there is any) to be loaded. Not importing the those
+wrappers can lead to subtle bugs in unrelated code!</p>
 </div>
 <div class="section" id="wrapping-global-functions-and-constants">
 <h1><a name="wrapping-global-functions-and-constants">Wrapping global functions and constants</a></h1>
 this module for you. These scripts are both very rough and tuned for the Apple
 headers, so YMMV.</p>
 <p>Note that we currently do not install the <tt class="literal"><span class="pre">pyobjc-api.h</span></tt> header, you'll have
-to copy it from the source-tree until we do.</p>
+to copy it from the source-tree until we do. This header is not installed 
+because the interface is not yet stable, please let us know if you want to
+use the API.</p>
 </div>
 <div class="section" id="pointer-arguments">
 <h1><a name="pointer-arguments">Pointer arguments</a></h1>
 The following code tells the brigde about this better method signature:</p>
 <pre class="literal-block">
 import objc
-objc.set_signature_for_selector(&quot;ClassName&quot;, &quot;selector:withArguments:&quot;,
+objc.setSignatureForSelector(&quot;ClassName&quot;, &quot;selector:withArguments:&quot;,
      &quot;v&#64;:o^&#64;:&#64;&quot;)
 </pre>
 <p>To anotate method signatures you'll have to add a single character before all
 three functions: 1 to call the method from Python, 1 to call the superclass
 implementation of the method from Python and 1 to call a Python implementation
 of the method from Objective-C.</p>
+<p>You also must write a custom wrapper when the method has a variable number
+of arguments. It is often adviseable to documented varargs method as 
+unsupported, or to support them only using a fixed number of arguments.</p>
 <p>For now it is best to check the source code for the wrappers for the Cocoa 
 class library for more information. We'll add documentation for this in the
 future.</p>

File pyobjc-web/docroot/header.inc

 <?
-/* $Id: header.inc,v 1.5 2003/05/29 15:42:57 ronaldoussoren Exp $ */
+/* $Id: header.inc,v 1.6 2003/10/08 17:30:40 ronaldoussoren Exp $ */
 
 // section navigation (always visible)
 $sections = array(
   "faq/index.php", "FAQ", "faq",
   "software/", "Download", "download",
   "examples/index.php", "Examples", "examples",
+  "showcase/index.php", "PyObjC Users", "pyobjc-users",
   "http://sourceforge.net/mail/?group_id=14534", "Mailing Lists", "mailing-lists"
 );
 if (!$section)

File pyobjc-web/docroot/index.php

 <?
 $title = "Home";
 $cvs_author = '$Author: ronaldoussoren $';
-$cvs_date = '$Date: 2003/07/05 14:59:46 $';
+$cvs_date = '$Date: 2003/10/08 17:30:40 $';
 $is_home = 1;
 
 $metatags = '<meta name="description" content="PyObjC, a universal bridge between the Objective-C and Python languages.">
 <a href="http://www.apple.com/macosx/">Mac OS X</a> in pure Python. See 
 <a href="<? print $root; ?>doc/tutorial.php">our tutorial</a> for an example
 of this.
+<p>
 
 
 <table border="0" cellpadding="0" cellspacing="0" width="100%">
 <h1>Status</h1>
 
 <p>
-<a href="software/index.php">PyObjC 1.0b1</a> was released on 5 July 2003.  See the <a href="NEWS-1.0b1.txt">NEWS</a> for details.
+<a href="software/index.php">PyObjC 1.0</a> was released on 21 September 2003.  See the <a href="NEWS-1.0.txt">NEWS</a> for details.
 </p>
 
 <h1>Platform support</h1>
 <ul>
 <li><a href="http://sourceforge.net/projects/pyobjc/">Project page</a></li>
 <li><a
-href="http://sourceforge.net/tracker/?group_id=14534&amp;atid=114534">Bug tracker</a></li>
+href="http://sourceforge.net/tracker/?group_id=14534&atid=114534">Bug tracker</a></li>
 <li><a href="http://sourceforge.net/project/showfiles.php?group_id=14534">Files</a></li>
 <li>CVS (<a href="http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/pyobjc">browse online</a>, <a href="http://sourceforge.net/cvs/?group_id=14534">access instructions</a>)</li>
 

File pyobjc-web/docroot/links.php

 <?
 $title = "Links";
-$cvs_author = '$Author: bbum $';
-$cvs_date = '$Date: 2002/11/12 07:41:06 $';
+$cvs_author = '$Author: ronaldoussoren $';
+$cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
 include "header.inc";
 ?>
 
 <p>All links will open in a new browser window.</p>
 
-<p>The building blocks</p>
+<h2>The building blocks</h2>
 <ul>
 <li><a href="http://www.python.org/" target="_blank">Python</a> - the Python interpreter</li>
 <li><a href="http://developer.apple.com/techpubs/macosx/Cocoa/ObjectiveC/" target="_blank">Objective-C</a> - the Objective-C programming language</li>
 <li><a href="http://www.gnustep.org/" target="_blank">GnuStep</a> - open source implementation of ObjC, Foundation, and AppKit</li>
 </ul>
 
-<p>Similar Projects</p>
+<h2>Similar Projects</h2>
 <ul>
 <li><a href="http://camelbones.sourceforge.net/" target="_blank">CamelBones</a> - a Perl&lt;-&gt;ObjC bridge</li>
 <li><a href="http://archive.develooper.com/macosx@perl.org/msg00896.html" target="_blank">PerlObjCBridge</a> - another Perl&lt;-&gt;ObjC bridge. Ships with OS X (see <i>PerlObjCBridge</i> man page)</li>

File pyobjc-web/docroot/news/news.inc

+<span class="news_date">2003-10-08: </span><span class="news_headline">PyObjC 1.0 released</span><?php gray_line(); ?>
+  <p>
+We're happy to announce the release of PyObjC 1.0. This version fixes the bugs 
+found in the last beta and adds support for Key-Value Coding, see the 
+<a href="<? print $root; ?>NEWS-1.0.txt">NEWS file</a> for details.
+  <p>
+A disk image and the sources are <a href="http://sourceforget.net/project/showfiles.php?group_id=14534">available</a>.  Users of MacPython 2.3 can install 
+PyObjC using the Package Manager.
+  <p>
 <span class="news_date">2003-07-05: </span><span class="news_headline">PyObjC 1.0b1 released</span><?php gray_line(); ?>
   <p>
  PyObjC 1.0b1 has shipped. A disk image with an installer package and the 
 are automaticly generated snapshots of our CVS tree. They might not work, and
 need not even compile. 
 
-<p><span class="news_date">2003-05-07: </span><span class="news_headline">Updated tutorial</span><?php gray_line(); ?>
-  <p>
-The tutorial included in the 0.9 release was not entirely up-to-date, please use <a href="<? print $root; ?> doc/tutorial.php">the tutorial on this website</a>.
-<p>
-<span class="news_date">2003-05-02: </span><span class="news_headline">PyObjC 0.9 released</span><?php gray_line(); ?>
- <p>
- PyObjC 0.9 has shipped. A disk image with an installer package and the sources are <a href="http://sourceforge.net/project/showfiles.php?group_id=14534">available</a>. There are many new features and bugfixes, see the <a href="<? print $root; ?>NEWS-0.9.txt">NEWS file</a> for details.
- <p>
- The PyObjC installer package installs a number of examples and project builder
- templates as wel as documentation into /Developer. Users of 
- <a href="http://homepages.cwi.nl/~jack/macpython.html#beta">MacPython 2.3b1</a> can install this release using the 
- PackageManager application.
- <p>
-

File pyobjc-web/docroot/news/older-news.inc

-
+<p><span class="news_date">2003-05-07: </span><span class="news_headline">Updated tutorial</span><?php gray_line(); ?>
+  <p>
+The tutorial included in the 0.9 release was not entirely up-to-date, please use <a href="<? print $root; ?> doc/tutorial.php">the tutorial on this website</a>.
+<p>
+<span class="news_date">2003-05-02: </span><span class="news_headline">PyObjC 0.9 released</span><?php gray_line(); ?>
+ <p>
+ PyObjC 0.9 has shipped. A disk image with an installer package and the sources are <a href="http://sourceforge.net/project/showfiles.php?group_id=14534">available</a>. There are many new features and bugfixes, see the <a href="<? print $root; ?>NEWS-1.0.txt">NEWS file</a> for details.
+ <p>
+ The PyObjC installer package installs a number of examples and project builder
+ templates as wel as documentation into /Developer. Users of 
+ <a href="http://homepages.cwi.nl/~jack/macpython.html#beta">MacPython 2.3b1</a> can install this release using the 
+ PackageManager application.
+ <p>
 <p><span class="news_date">2003-01-23: </span><span class="news_headline">Dev News; GNUstep support, FFI, performance, etc...</span><?php gray_line(); ?>
 <p>
 <span class="news_date">2002-12-19: </span><span class="news_headline">PyObjC 0.8 released</span><?php gray_line(); ?>

File pyobjc-web/docroot/software/index.php

 <?
 $title = "Documentation";
 $cvs_author = '$Author: ronaldoussoren $';
-$cvs_date = '$Date: 2003/09/24 11:13:37 $';
+$cvs_date = '$Date: 2003/10/08 17:30:40 $';
 
 include "header.inc";
 ?>
 <h1>Downloads</h1>
 
 <ul>
-<li><a href="http://prdownloads.sourceforge.net/pyobjc/PyObjC-1.0b1.dmg?download">PyObjC 1.0b1 installer package for Apple's Python</a>
-<li><a href="http://prdownloads.sourceforge.net/pyobjc/pyobjc-1.0b1.tar.gz?download">PyObjC 1.0b1 source release (a compressed tar archive)</a>
+<li><a href="http://prdownloads.sourceforge.net/pyobjc/PyObjC-1.0.dmg?download">PyObjC 1.0 installer package for Apple's Python</a>
+<li><a href="http://prdownloads.sourceforge.net/pyobjc/pyobjc-1.0.tar.gz?download">PyObjC 1.0 source release (a compressed tar archive)</a>
 </ul>
 
+<p>Users of MacPython can use the PyObjC PackageManager database to install 
+   PyObjC: select ``File/open URL...`` in Package Manager and select 
+   "<CODE>http://pyobjc.sf.net/packman/pyobjc-stable-6.6-Power_Macintosh.plist</CODE>" as the URL. 
+
+ <p>Users of MacPython on MacOS X 10.3 can use "<CODE>"http://pyobjc.sf.net/packman/pyobjc-stable-7.0-Power_Macintosh.plist</CODE>" as the database location. 
+ There is no MacOS X 10.3 installer at the moment.
+
 <p>Older releases are available in the <a href="http://sourceforge.net/project/showfiles.php?group_id=14534">Files section of our SourceForge project</a>.
 
 <p>If you want to install PyObjC from CVS you'll have to download the latest