Source

pyobjc / NEWS.html

The branch 'pyobjc-ancient' does not exist.
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>
PyObjC NEWS</title>
</head>
<body>
<h2>PyObjC NEWS</h2>
<p>An overview of the relevant changes in new, and older, releases.</p>
<h2><a>Version 1.3.7 (2005-07-06)</a></h2>
<ul>
<li>Added wrappers for embedded DiscRecording frameworks
([ 1224188 ] Fix for DiscRecording framework)</li>
<li>Probably working Xcode 2.1 support (for converted Xcode 2.0 projects)</li>
<li>Hide List, Object, and Protocol classes from objc.loadBundle
to prevent confusion with Python code.  They can still be looked
up with objc.lookUpClass.</li>
<li>Fixed a regression where type signatures for pointers weren't
normalized (fixes uses of NSModalSession, etc.)</li>
<li>Fixed a bug with -[NSObject hash] to __hash__, there was a mismatch
between integer types.</li>
<li>Removed traces of the old Project Builder and Xcode templates in the
examples and Foundation initialization code (PYOBJCFRAMEWORKS).</li>
<li>Fixed a problem with reference counting in initializers.</li>
<li>New TinyURLService example in AppKit that demonstrates how to write
a service that transforms URLs into their tinyurl.com equivalents.</li>
<li>Ported to Mac OS X on Intel. This is an initial, experimental port. The
Intel ABI has not been finalised yet. It is also possible to build fat
binaries, that option should not be used in production builds.</li>
<li>Support a number of new frameworks:<ul>
<li>SenTestingKit<p>TODO: this framework uses lots of macros (such as STAssertEquals), these
have not yet been wrapped/converted.</p>
</li>
<li>SecurityFoundation</li>
</ul>
</li>
</ul>
<h2><a>Version 1.3.6 (2005-05-19)</a></h2>
<ul>
<li>Fixed bugs in the ProgressViewPalette example</li>
<li>Fixed a bug in the class builder that caused most plugins to break</li>
<li>Removed all references to Project Builder</li>
<li>Mac OS X 10.2 (Jaguar) no longer supported</li>
</ul>
<h2><a>Version 1.3.5 (2005-05-18)</a></h2>
<ul>
<li>Importing objc now ensures that Foundation is multi-threaded, previously
it only ensured that Python was.</li>
<li>New <code><span>objc.RegisterCFSignature</span></code> used to register <code><span>CFTypeRef</span></code>-like
signatures with the runtime.</li>
<li><code><span>PyObjCTools.Conversion</span></code> functions now support all property list
types with the following conversions:<ul>
<li>NSData &lt;-&gt; buffer</li>
<li>NSDecimalNumber &lt;-&gt; decimal.Decimal (if present)</li>
<li>NSDate &lt;-&gt; datetime.datetime</li>
</ul>
<p>New <code><span>toPythonDecimal</span></code>, <code><span>fromPythonDecimal</span></code> functions which convert
between NSDecimalNumber and decimal.Decimal using an intermediate string.</p>
<p>New <code><span>serializePropertyList</span></code> and <code><span>deserializePropertyList</span></code> functions
which serialize (Objective-C) property lists to and from NSData.</p>
</li>
<li><code><span>OC_PythonObject</span></code>, the proxy for Python objects that do not have
an Objective-C superclass and are not otherwise special-cased, now
act slightly more like typical Objective-C objects (supporting
<code><span>-isEqual:</span></code>, <code><span>-hash</span></code>, and <code><span>-compare:</span></code>).  This allows them
to work with Key-Value Coding if they are contained by an Objective-C
object, among other things.</li>
<li>New objc.signature decorator that allows easier specification of
objc.selector wrappers for functions when using Python 2.4:<pre>
@objc.signature('i@:if')
def methodWithX_andY_(self, x, y):
    return 0
</pre>
</li>
<li><code><span>PyObjCTools.KeyValueCoding.getKeyPath</span></code> now supports all of the
Array Operators supported by Mac OS X 10.4.</li>
<li>Key-Value Coding of Python objects (whether or not using an Objective-C
base class) should act like Objective-C now.  In previous versions
there were inconsistencies with the use of capitalization, the
underscore postfix in setters, and Key-Value Observing.</li>
<li>The formal protocol list is now complete.  A new internal function, 
<code><span>objc.protocolsForProcess()</span></code> enumerates over all mach
headers and returns all of the protocols defined in the expected
place.  This fixes the scenario where an application uses a
protocol but does not define any classes that
conform to that protocol (i.e. to check plugin conformity).
Previously it was not possible to reach these protocols simply by
walking over all of the classes.</li>
<li>A special value, <code><span>objc.NULL</span></code>, may now be passed in the place
of 'in' and 'inout' arguments.  This tells the bridge to pass
a NULL pointer to the Objective-C method, instead of a pointer
to the value.  The return value will still be a tuple of the
expected size.</li>
<li>Some of the new Tiger frameworks now have wrappers:<ul>
<li><code><span>AppleScriptKit</span></code></li>
<li><code><span>Automator</span></code></li>
<li><code><span>CoreData</span></code></li>
<li><code><span>DiscRecording</span></code></li>
<li><code><span>DiscRecordingUI</span></code></li>
<li><code><span>OSAKit</span></code></li>
<li><code><span>Quartz</span></code></li>
<li><code><span>QTKit</span></code></li>
<li><code><span>SyncServices</span></code></li>
<li><code><span>XgridFoundation</span></code></li>
</ul>
<p>Documentation and tests not yet written.</p>
</li>
<li>New <code><span>OutlineEditor</span></code> example in <code><span>Examples/CoreData</span></code>,
it is a Python version of the identically named Apple example.</li>
<li>The last argument of selectors that end with ':error:' is now
assumed to be 'out' if its type is an object pointer.</li>
<li>More conveniences for <code><span>list</span></code>-like and <code><span>dict</span></code>-like
objects: <code><span>__reversed__</span></code>, <code><span>reverse</span></code>, <code><span>pop</span></code>,
<code><span>remove</span></code>, <code><span>fromkeys</span></code>.</li>
<li><code><span>OC_PythonDictionary</span></code> and <code><span>OC_PythonArray</span></code> now return
<code><span>NSNull</span></code> to Objective-C callers as appropriate.</li>
<li>New <code><span>WebKitInterpreter</span></code> example in <code><span>Examples/Plugins</span></code>.
Uses the new WebKit Cocoa plugin API available in Safari 1.3
and later to embed a PyInterpreter in the browser.</li>
<li>Fixed a <code><span>CFBundleRef</span></code> reference counting bug in
<code><span>Foundation._Foundation</span></code>.  The symptom of this is usually
a crashing application after having loaded a PyObjC-based
plugin into an otherwise Objective-C app.</li>
<li>New <code><span>PyObjCTools.AppHelper</span></code> functions: <code><span>callAfter</span></code> and
<code><span>callLater</span></code>, conveniences for calling Python functions on
the main thread as soon as possible, or after a delay.</li>
<li>Twisted examples changed to use <code><span>threadedselectreactor</span></code>
instead of <code><span>cfreactor</span></code>.  <code><span>cfreactor</span></code> is deprecated.
Needs Twisted newer than 2.0 (svn r13575 or later).</li>
<li><code><span>objc.inject</span></code> now injects on main thread by default,
and takes an optional third <code><span>useMainThread</span></code> argument
to change this behavior.  This is a complete rewrite
which should be correct, stable, Tiger compatible,
and synchronized with mach_* 1.1.</li>
<li>Removed an <code><span>NSAutoreleasePool</span></code> category hack that has
been deprecated for quite some time.</li>
<li>New <code><span>objc.removeAutoreleasePool</span></code> function that will remove
PyObjC's global <code><span>NSAutoreleasePool</span></code>, which may be useful
for plugins.</li>
<li>Fixed bug in the <code><span>NSBundle</span></code> hack that caused a <code><span>NULL</span></code>
pointer dereference if looking up a non-existent class using
<code><span>NSBundle</span></code> API.</li>
<li>Added <code><span>OC_PythonUnicode</span></code> and <code><span>OC_PythonString</span></code> classes that
preserve the identity of <code><span>str</span></code> and <code><span>unicode</span></code> objects across
the bridge.  The bridge for <code><span>str</span></code> now uses the default
encoding of <code><span>NSString</span></code>, rather than <code><span>sys.getdefaultencoding()</span></code>
from Python.  For Mac OS X, this is typically MacRoman.  The reason
for this is that not all Python <code><span>str</span></code> instances could cross the
bridge at all previously.  <code><span>objc.setStrBridgeEnabled(False)</span></code> will
still trigger warnings, if you are attempting to track down an
encoding bug.  However, the symptoms of the bug will be incorrectly
encoded text, not an exception.</li>
<li>New Xcode project template &quot;PyObjC Mixed Application&quot; that is
a py2app based Python application that loads an Objective-C
plug-in built as a separate target.</li>
<li>New py2app based Xcode templates &quot;PyObjC Application&quot; and
&quot;PyObjC Document-based Application&quot;, these replace the
older &quot;Cocoa-Python Application&quot; and 
&quot;Cocoa-Python Document-based Application&quot; respectively.</li>
<li>New <code><span>InjectBrowser</span></code> example in <code><span>Examples/Inject</span></code> that demonstrates
injection of the <code><span>ClassBrowser</span></code> example into another application using
<code><span>objc.inject</span></code>.</li>
<li><code><span>NSData</span></code> and <code><span>NSMutableData</span></code> instances now support the Python buffer
protocol.</li>
<li><code><span>NSData</span></code> instances now support a convenience API that allow them to
act like a <code><span>buffer</span></code> instance for <code><span>str()</span></code> and slicing.</li>
<li>Objects that support the Python buffer protocol, such as <code><span>buffer</span></code> and
<code><span>array.array</span></code> (but not <code><span>str</span></code> or <code><span>unicode</span></code>) are now bridged as
<code><span>NSData</span></code> subclasses.</li>
</ul>
<h2><a>Version 1.3 (2005-03-31)</a></h2>
<ul>
<li>New <code><span>objc.pyobjc_id</span></code> function that returns a the id of the underlying
NSObject as an integer.  (Python wrapper objects are often made on the
fly, meaning <code><span>id(obj)</span></code> is not constant during the lifetime of the
object.)</li>
<li>The bridge now maintains object identity across the bridge
in both directions. Previous versions of the bridge only did this when
bridging from Objective-C to Python.<p>Exceptions: <code><span>NSString</span></code> and <code><span>NSNumber</span></code> do not have unique proxies.  These
types are converted to subclasses of Python types as appropriate, so they
can not have unique proxies.  The identity of the original Objective-C
object is maintained by these subclasses, but there may be many Python
&quot;value proxies&quot; for a single Objective-C object.</p>
<p>Any Python object that is proxied using the <code><span>__pyobjc_object__</span></code>
interface will only get a unique proxy if the <code><span>__pyobjc_object__</span></code>
method implements that feature.</p>
</li>
<li>New <code><span>objc.protocolsForClass</span></code> function that returns a list of protocols
that the class directly claims to conform to.</li>
<li>PyObjC classes can now declare that they implement formal protocols,
for example:<pre>
class MyLockingClass(NSObject, objc.protocolNamed('NSLocking')):
    # implementation
    pass
</pre>
<p>It is also possible to define new protocols:</p>
<pre>
MyProtocol = objc.formal_protocol(&quot;MyProtocol&quot;, None, [
   selector(None, selector='mymethod', signature='v@:'),
])
</pre>
<p>All formal protocols are instances of <code><span>objc.formal_protocol</span></code>.</p>
</li>
<li>PyObjCTools.KeyValueCoding has a new <code><span>kvc</span></code> class that allows
Pythonic Key-Value Coding.<ul>
<li><code><span>__getitem__</span></code> is mapped to <code><span>valueForKeyPath:</span></code></li>
<li><code><span>__setitem__</span></code> is mapped to <code><span>setValue:forKeyPath:</span></code></li>
<li><code><span>__getattr__</span></code> is mapped to <code><span>valueForKey:</span></code></li>
<li><code><span>__setattr__</span></code> is mapped to <code><span>setValue:forKey:</span></code></li>
</ul>
<p>The <code><span>kvc</span></code> class uses <code><span>__pyobjc_object__</span></code>, so it may cross the bridge
as the wrapped object.</p>
</li>
<li><code><span>NSNumber</span></code> instances are bridged to a <code><span>float</span></code>, <code><span>long</span></code>, or <code><span>int</span></code>
subclass that uses <code><span>__pyobjc_object__</span></code>.  
<code><span>NSDecimal</span></code> is converted to <code><span>NSDecimalNumber</span></code> when used as an object,
<code><span>NSDecimalNumber</span></code> is not bridged to <code><span>NSDecimal</span></code> because the latter is
a mutable type.</li>
<li>The Python to Objective-C bridge now looks for a <code><span>__pyobjc_object__</span></code> 
attribute to get a PyObjC object from a Python object.</li>
<li>New IDNSnitch example in Inject that demonstrates how to write an
monitor for the launch of another application,
use <code><span>objc.inject</span></code> to load code into a target process,
and override the implementation of an existing method but still
call back into the original implementation (method swizzling).</li>
<li><code><span>objc.IMP</span></code> should do the right thing now.  This type is returned
by <code><span>+[NSObject</span> <span>methodForSelector:]</span></code> and
<code><span>+[NSObject</span> <span>instanceMethodForSelector:]</span></code></li>
<li>New ToDos example in CocoaBindings that demonstrates how to use
two array controllers for the same data, and how to use value
transformers to alter the color of text.  Originally from
&quot;Cocoa Bindings Examples and Hints&quot;, converted to PyObjC by u.fiedler.</li>
<li>New Bookmarks example in CocoaBindings that demonstrates how to
subclass <code><span>NSArrayController</span></code> to implement the <code><span>NSTableView</span></code>
delegate drag and drop protocol, including copying of objects between
documents and accepting URL drops from other applications.  Also
demonstrates re-ordering of the content array.  Originally from
&quot;Cocoa Bindings Examples and Hints&quot;, converted to PyObjC by u.fiedler.</li>
<li>New FilteringController example in CocoaBindings that demonstrates
how to subclass <code><span>NSArrayController</span></code> to implement filtering
of a <code><span>NSTableView</span></code>.  Also demonstrates the use of indexed accessors.
Originally from &quot;Cocoa Bindings Examples and Hints&quot;, converted to PyObjC
by u.fiedler.</li>
<li>New ControlledPreferences example in CocoaBindings that demonstrates
how to use Cocoa Bindings to simplify storing and retrieving user
preferences.  Originally from &quot;Cocoa Bindings Examples and Hints&quot;,
converted to PyObjC by u.fiedler.</li>
<li>New TemperatureTransformer example in CocoaBindings that demonstrates
how to use NSValueTransfomers with PyObjC.  Based on Apple's
&quot;Cocoa: Value Transformers&quot; documentation, converted to PyObjC
by u.fiedler.</li>
<li>New CurrencyConvBindings example in CocoaBindings that demonstrates
a Cocoa Bindings enabled version of the CurrencyConverter example.
Converted to PyObjC by u.fiedler from the example in Apple's
&quot;Introduction to Developing Cocoa Applications Using Bindings&quot;.</li>
<li>New ManualBindings example in CocoaBindings that demonstrates how
to develop programmatic bindings from a PyObjC application.
Converted to PyObjC by u.fiedler from the &quot;Cocoa Bindings and Hints&quot;
example of the same name.</li>
<li>New HotKeyPython example in AppKit that demonstrates how to use
Carbon global hot keys from a PyObjC application.  Also demonstrates
how to use a NSApplication subclass.</li>
<li>Key-Value Observing support is now automatic in Python classes that
descend from <code><span>NSObject</span></code>, unless they implement a custom
<code><span>willChangeValueForKey:</span></code>, <code><span>didChangeValueForKey:</span></code>, or
<code><span>__useKVO__</span></code> is not True.  This allows <code><span>self.foo</span> <span>=</span> <span>1</span></code> to
automatically trigger notifications.  This works in all cases,
whether <code><span>foo</span></code> is a <code><span>property</span></code>, <code><span>ivar</span></code>, or just in the
<code><span>__dict__</span></code>.</li>
<li>New Inject folder in Examples, with an InjectInterpreter
example that will inject a GUI Python interpreter into any process.</li>
<li>New <code><span>objc.inject()</span></code> function for Mac OS X 10.3 and later,
allows an arbitrary bundle to be loaded into another process
using mach_inject.</li>
<li><code><span>objc.classAddMethods</span></code> now recognizes and supports
classmethods.</li>
<li>GC is now correctly implemented for struct wrappers.</li>
<li>The <code><span>NSNumber</span></code> bridge has been removed, now you will get
<code><span>NSNumber</span></code> instances across the bridge instead of a
Python representation.</li>
<li><code><span>PyObjCTools.AppHelper.runEventLoop()</span></code> will now bring your
application to the front at startup when using pdb
mode for convenience.</li>
<li><code><span>objc.loadBundle()</span></code> no longer filters the class list.  This
solves a few potential issues and shaves off about 1/3rd of
the overhead of <code><span>python</span> <span>-c</span> <span>&quot;import</span> <span>AppKit&quot;</span></code>.</li>
<li><code><span>PyObjCTools.AppHelper.runEventLoop()</span></code> no longer breaks on
pure Objective-C exceptions.  Most exceptions of this variety
are more like warnings, and there is nothing that can be done
them anyway.</li>
<li><code><span>PyObjCTools.AppHelper.runEventLoop()</span></code> now installs the
interrupt handler and verbose exception logging when using pdb,
either explicitly or by the USE_PDB environment variable.</li>
<li>There is now a fast path for the <code><span>NSString</span></code>/<code><span>unicode</span></code>
bridge when <code><span>Py_UNICODE_SIZE</span></code> is 2.  This is the default
setting for Python.</li>
<li>The default selector signature will have a void return value
unless a &quot;return&quot; statement with an argument is used in the
bytecode.  In that case, it will default to an object return
value.</li>
<li><code><span>__bundle_hack__</span></code> is no longer necessary, py2app now sets
a different environment variable to the current plugin during
execution, and a hack is installed to <code><span>NSBundle</span></code> so that classes
may respond to requests for their bundle with the <code><span>+bundleForClass</span></code>
method.  The class builder adds a default implementation of this to
Python classes if this environment variable is set.</li>
<li>Added <code><span>objc.currentBundle()</span></code>, which is equivalent to
<code><span>NSBundle.mainBundle()</span></code> except after loading a plug-in.
Makes it easier to load nib files.</li>
<li><code><span>PyObjCTools.NibClassBuilder.extractClasses()</span></code> now uses
<code><span>objc.currentBundle()</span></code> instead of <code><span>NSBundle.mainBundle()</span></code>.  This
makes plugins less of a hassle to develop and allows identical code
to be used for application or plugin development.</li>
<li><code><span>objc.registerPlugin()</span></code> and <code><span>objc.pluginBundle()</span></code> are now deprecated
as they are no longer useful.</li>
<li>It is now possible to subclass a class that implements <code><span>copyWithZone:</span></code>
without setting <code><span>__slots__</span></code> to <code><span>()</span></code>.</li>
<li>It is now possible to override <code><span>dealloc</span></code>. It is still possible to
define <code><span>__del__</span></code>.</li>
<li>As an experimental feature it is also possible to override <code><span>retain</span></code> and
<code><span>release</span></code>. Note it almost never a good idea to do this (even when you're
programming in Objective-C and much more so in Python).</li>
<li><code><span>poseAsClass:</span></code> can be used, although it is not very useful in python, use
categories instead.<p>A major issue with <code><span>poseAsClass:</span></code> is that existing references to the old
version of the class won't be changed to point to the new class.</p>
</li>
<li>It is now possible to access all instance variables of a class using
the functions <code><span>objc.listInstanceVariables(aClassOrInstance)</span></code>,
<code><span>objc.getInstanceVariable(obj,</span> <span>name)</span></code> and 
<code><span>objc.setInstanceVariable(obj,</span> <span>name,</span> <span>value</span> <span>[,</span> <span>updateRefCount])</span></code>.<p>The last argument of <code><span>setInstanceVariable</span></code> is required when the instance
variable is an object. If it is true the bridge will update reference counts,
otherwise it won't.</p>
</li>
<li>All wrappers for opaque pointers (such as <code><span>NSZone*</span></code>) now have the same
interface and share a single implementation. This decreases code-size and
makes it easier to add new wrappers.  A new feature is a <code><span>__typestr__</span></code>
attribute on the type object, this contains the encoded Objective-C type
of the pointer.<p>A function for creating new wrappers is exposed to python, as 
<code><span>objc.createOpaquePointerType(name,</span> <span>typestr,</span> <span>doc)</span></code>.  The same function is 
also exposed in the C-API.</p>
</li>
<li>Wrappers for C-structs how have a <code><span>__typestr__</span></code> attribute on their type.
This attribute contains the encoded Objective-C type of the struct.<p>The default <code><span>__init__</span></code> for struct-wrappers now initializes fields with an 
appropriate default value, instead of <code><span>None</span></code>.</p>
<p>New wrappers can now be created from Python using the function
<code><span>objc.createStructType(name,</span> <span>typestr,</span> <span>fieldnames,</span> <span>doc)</span></code>. The same
function is also exposed in the C API (and has been for a while).</p>
</li>
</ul>
<h2><a>Version 1.2 (2004-12-29)</a></h2>
<ul>
<li><code><span>PyObjCTools.AppHelper.stopEventLoop</span></code> will attempt to stop the current
<code><span>NSRunLoop</span></code> (if started by <code><span>runConsoleEventLoop</span></code>) or terminate the
current <code><span>NSApplication</span></code> (which may or may not have been started by
<code><span>runEventLoop</span></code>).</li>
<li>This version no longer support Python 2.2. Python 2.3 or later is
required.</li>
<li>It is now possible to use <code><span>reload</span></code> on modules containing Objective-C
classes.</li>
<li><code><span>objc.loadBundle</span></code> now returns bundle we just loaded.</li>
<li>Added <code><span>objc.loadBundleVariables</span></code> and <code><span>objc.loadBundleFunctions</span></code>,
two functions for reading global variables and functions from a bundle.</li>
<li>objc.runtime will now raise AttributeError instead of objc.nosuchclass_error
when a class is not found.</li>
<li>objc.Category can be used to define categories on existing classes:<pre>
class NSObject (objc.Category(NSObject)):
    def myMethod(self):
        pass
</pre>
<p>This adds method <code><span>myMethod</span></code> to class NSObject.</p>
</li>
<li><code><span>py2app</span></code> is now used for all Example scripts and is the recommended method
for creating PyObjC applications.</li>
<li>Proxies of dict, list, and tuple now respect the invariant that you should
get an identical instance if you ask for the same thing twice and the
collection has not been mutated.  This fixes some problems with binary
plist serialization, and potentially some edge cases elsewhere.</li>
<li>There is now a <code><span>__bundle_hack__</span></code> class attribute that will cause the PyObjC
class builder to use a statically allocated class wrapper if one is
available via certain environment variables.  This functionality is used
to enable +[NSBundle bundleForClass:] to work for exactly one class from
a py2app-created plugin bundle.</li>
<li>We now have a working Interface Builder palette example due to
<code><span>__bundle__hack__</span></code>.</li>
<li><code><span>bool(NSNull.null())</span></code> is now false.</li>
<li><code><span>setup.py</span></code> supports several new commands:<blockquote>
<p>build_libffi:</p>
<blockquote>
<p>builds libffi (used by build_ext)</p>
</blockquote>
<dl>
<dt>build_html:</dt>
<dd><p>builds html documentation from ReST source</p>
</dd>
<dt>bdist_dmg:</dt>
<dd><p>creates a disk image with the binary installer</p>
</dd>
<dt>bdist_mpkg:</dt>
<dd><p>creates a binary installer</p>
</dd>
<dt>test:</dt>
<dd><p>runs unit test suite (replaces Scripts/runPyObjCTests
and Scripts/runalltests)</p>
</dd>
</dl>
</blockquote>
</li>
<li><code><span>PyObjCStrBridgeWarning</span></code> can now be generated when Python <code><span>str</span></code> objects
cross the bridge by calling <code><span>objc.setStrBridgeEnabled(False)</span></code>.  It is
HIGHLY recommended that your application never send <code><span>str</span></code> objects over
the bridge, as it is likely to cause problems due to the required
coercion to unicode.</li>
<li>The coercion bridge from Python to Objective-C instances can now be
augmented from Python as it is exposed by <code><span>OC_PythonObject</span></code>.  See
<code><span>objc._bridges</span></code>.  This is how the <code><span>str</span></code> -&gt; <code><span>unicode</span></code> -&gt; <code><span>NSString</span></code>
bridge with optional warnings is implemented.</li>
<li>The coercion bridge between Python objects and Objective-C structures
can now be augmented from Python as it is exposed by <code><span>OC_PythonObject</span></code>.
See <code><span>objc._bridges</span></code>.  This is how the <code><span>Carbon.File.FSRef</span></code> 
&lt;-&gt; <code><span>'{FSRef=[80c]}'</span></code> structure bridge is implemented.</li>
<li>Extension modules such as <code><span>_objc</span></code>, <code><span>_AppKit</span></code>, etc. are now inside
packages as <code><span>objc._objc</span></code>, <code><span>AppKit._AppKit</span></code>, etc.  They should never be
used directly, so this should not break user code.</li>
</ul>
<h2><a>Version 1.1 (2004-05-30)</a></h2>
<ul>
<li>KVO now actually works from Python without using nasty hacks.</li>
<li>Added Xcode template for document-based applications</li>
</ul>
<h2><a>Version 1.1b2 (2004-04-11)</a></h2>
<ul>
<li>More fine-grained multi-threading support</li>
<li>Xcode templates use a smarter embedded main program</li>
<li>Add support for WebObjects 4.5 (a one-line patch!)</li>
<li>Add a PackageManager clone to the Examples directory</li>
<li>Add better support for NSProxy<p>This makes it possible to use at Distributed Objects, although this
feature has not received much testing</p>
</li>
<li>Function 'objc.protocolNamed' is the Python equivalent of the @protocol
expression in Objective-C.</li>
<li>Add several new examples</li>
</ul>
<h2><a>Version 1.1b1 (2004-02-20)</a></h2>
<ul>
<li>Fixes some regressions in 1.1 w.r.t. 1.0</li>
<li>Add Xcode templates for python files<p>You can now select a new python file in the 'add file...' dialog in Xcode</p>
</li>
<li>Fix installer for Panther: the 1.1a0 version didn't behave correctly</li>
<li>There is now an easier way to define methods that conform to the expectations
of Cocoa bindings:<pre>
class MyClass (NSObject):

    def setSomething_(self, value):
        pass

    setSomething_ = objc.accessor(setSomething_)

    def something(self):
        return &quot;something!&quot;

    something = objc.accessor(something)
</pre>
<p>It is not necessary to use <code><span>objc.accessor</span></code> when overriding an existing 
accessor method.</p>
</li>
</ul>
<h2><a>Version 1.1a0 (2004-02-02)</a></h2>
<ul>
<li>Objective-C structs can now be wrapped using struct-like types. This has
been used to implement wrapper types for NSPoint, NSSize, NSRange and NSRect
in Foundation and NSAffineTransformStruct in AppKit.<p>This means you can now access the x-coordinate of a point as <code><span>aPoint.x</span></code>,
accessing <code><span>aPoint[0]</span></code> is still supported for compatibility with older 
versions of PyObjC.</p>
<p>It is still allowed to use tuples, or other sequences, to represent 
Objective-C structs.</p>
<p>NOTE: This has two side-effects that may require changes in your programs:
the values of the types mentioned above are no longer immutable and cannot
be used as keys in dicts or elements in sets. Another side-effect is that
a pickle containing these values created using this version of PyObjC cannot
be unpickled on older versions of PyObjC.</p>
</li>
<li>This version adds support for NSDecimal. This is a fixed-point type defined
in Cocoa.</li>
<li>NSDecimalNumbers are no longer converted to floats, that would loose 
information.</li>
<li>If an Objective-C method name is a Python keyword you can now access it
by appending two underscores to its name, e.g. someObject.class__().<p>The same is true for defining methods, if you define a method <code><span>raise__</span></code> in
a subclass of NSObject it will registered with the runtime as <code><span>raise</span></code>.</p>
<p>NOTE: Currently only <code><span>class</span></code> and <code><span>raise</span></code> are treated like this, because
those are the only Python keywords that are actually used as Objective-C
method names.</p>
</li>
<li>Experimental support for <code><span>instanceMethodForSelector:</span></code> and 
<code><span>methodForSelector:</span></code>. 
This support is not 100% stable, and might change in the future.</li>
<li>Backward incompatible change: class methods are no longer callable through
the instances.</li>
<li>Integrates full support for MacOS X 10.3 (aka Panther)</li>
<li>Adds a convenience/wrapper module for SecurityInterface</li>
<li>It is now safe to call from Objective-C to Python in arbitrary threads, but
only when using Python 2.3 or later.</li>
<li>Fixes some issues with passing structs between Python and Objective-C.</li>
<li>Uses the Panther version of <code><span>NSKeyValueCoding</span></code>, the Jaguar version is still
supported.</li>
<li>method <code><span>updateNSString</span></code> of <code><span>objc.pyobjc_unicode</span></code> is deprecated, use 
create a new unicode object using <code><span>unicode(mutableStringInstance)</span></code> instead.</li>
<li>NSAppleEventDescriptor bridged to Carbon.AE</li>
<li>LibFFI is used more aggressivly, this should have no user-visible effects
other than fixing a bug related to key-value observing.</li>
<li>Adds a number of new Examples:<ul>
<li>OpenGLDemo<p>Shows how to use OpenGL with PyObjC</p>
</li>
<li>SillyBallsSaver<p>Shows how to write a screensaver in Python. Requires a framework install
of Python (that is, MacOS X 10.3 or MacPython 2.3 on MacOS X 10.2).</p>
</li>
<li>Twisted/WebServicesTool<p>Shows how to integrate Twisted (1.1 or later) with Cocoa, it is a
refactor of the WebServicesTool example that is made much simpler
by using Twisted.</p>
</li>
<li>Twisted/WebServicesTool-ControllerLayer<p>Shows how to integrate Twisted (1.1 or later) with Cocoa, it is a
refactor of the WebServicesTool example that is made much simpler
by using Twisted as it does not need threads. This one also uses
NSController and therefore requires MacOS X 10.3.</p>
</li>
</ul>
</li>
</ul>
<h2><a>Version 1.0 (2003-09-21)</a></h2>
<ul>
<li>This version includes a new version of libffi that properly deals with
complex types on MacOS X.</li>
</ul>
<h2><a>Version 1.0rc3 (2003-09-14)</a></h2>
<ul>
<li>1.0rc2 didn't include the nibclassbuilder script</li>
<li>Fix bug in NSRectFillList</li>
</ul>
<h2><a>Version 1.0rc2 (2003-09-10)</a></h2>
<ul>
<li>Fix a number of bugs found in 1.0rc1.</li>
</ul>
<h2><a>Version 1.0rc1 (2003-08-10)</a></h2>
<ul>
<li>Better support for the NSKeyValueCoding protocol.  The module 
<code><span>PyObjCTools.KeyValueCoding</span></code> 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).</li>
<li>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).</li>
<li>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.</li>
<li>The default repr() of ObjC objects is now the result of a call to the
<code><span>description</span></code> method. This method is not called for unitialized objects,
because that might crash the interpreter; we use a default implementation
in that case.</li>
<li>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).<p>This is a backward incompatible change, but there are not many of such
methods.</p>
</li>
<li>Another backward incompatible change is a minor cleanup of the names in
the <code><span>objc</span></code> module. The most significant of these is the change from
<code><span>recycle_autorelease_pool</span></code> to <code><span>recycleAutoreleasePool</span></code>. The other 
changed names are internal to the bridge and should not be used in other
code.</li>
<li>The interface of Foundation.NSFillRects changed, it now has an interface
that is consistent with the rest of the bridge.</li>
</ul>
<h2><a>Version 1.0b1 (2003-07-05)</a></h2>
<ul>
<li>More tutorials<p>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.</p>
</li>
<li>More examples<p>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.</p>
</li>
<li>Support for MacOS X 10.1<p>It is now possible to build PyObjC on MacOS X 10.1, with full access to 
the Cocoa API's on that platform.</p>
<p>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.</p>
</li>
<li>Support for the WebKit framework, included with Safari 1.0.<p>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.</p>
</li>
<li>It is no longer necessary to specify which protocols are implemented by<p>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.</p>
</li>
<li>Support for &quot;toll-free bridging&quot; of Carbon.CF types to Objective-C objects.<p>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.</p>
<p>Note: this requires Python 2.3.</p>
</li>
<li>Better integration with MacPython 2.3:<ul>
<li><code><span>NSMovie.initWithMovie_</span></code> and <code><span>NSMovie.QTMovie</span></code> now use <code><span>QT.Movie</span></code> 
objects instead of generic pointer wrappers.</li>
<li><code><span>NSWindow.initWithWindowRef_</span></code> and <code><span>Window.windowRef</span></code> now use 
<code><span>Carbon.Window</span></code> objects instead of generic pointer wrappers.</li>
<li>Methods returning CoreFoundation objects will return MacPython objects,
and likewise, methods with CoreFoundation arguments will accept MacPython
objects.</li>
</ul>
</li>
<li>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.</li>
<li>The methods <code><span>pyobjcPopPool</span></code> and <code><span>pyobjcPushPool</span></code> of <code><span>NSAutoreleasePool</span></code>
are deprecated. These were introduced when PyObjC did not yet support the
usual method for creating autorelease pools and are no longer necessary.</li>
<li>Improved unittests, greatly increasing the confidence in the correctness
of the bridge.</li>
<li>All suppport for non-FFI builds has been removed.</li>
<li>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.</li>
<li>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__.</li>
<li>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.<p>NOTE: You could create weakrefs in previous versions, but those would
expire as soon as the last reference from Python died, <i>not</i> when the 
Objective-C object died, therefore code that uses weakrefs to Objective-C
objects is almost certainly incorrect.</p>
</li>
<li>Added support for custom conversion for pointer types. The end result is that
we support more Cocoa APIs without special mappings.</li>
<li>The generator scripts are automaticly called when building PyObjC. This
should make it easier to support multiple versions of MacOS X.</li>
</ul>
<h2><a>Version 0.9 (May-02-2003)</a></h2>
<ul>
<li>This version includes numerous bugfixes and improvements.</li>
<li>The module AppKit.NibClassBuilder has been moved to the package
PyObjCTools.</li>
<li>Usage of libFFI (<a href="http://sources.redhat.com/libffi">http://sources.redhat.com/libffi</a>) is now mandatory. The
setup.py gives the impression that it isn't, but we do <i>not</i> support 
non-FFI builds.</li>
<li>We actually have some documentation, more will be added in future releases.</li>
<li>There are more Project Builder templates (see 'Project Templates').</li>
<li>The InterfaceBuilder, PreferencePanes and ScreenSaver frameworks have been
wrapped.</li>
<li>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.</li>
<li>Various function and keyword arguments have been renamed for a better 
integration with Cocoa. A partial list is of the changed names is:<pre>
objc.lookup_class -&gt; objc.lookUpClass
objc.selector arguments/attributes:
    is_initializer -&gt; isInitializer
    is_allocator -&gt; isAlloc
    donates_ref -&gt; doesDonateReference
    is_required -&gt; isRequired
    class_method -&gt; isClassMethod
    defining_class -&gt; definingClass
    returns_self -&gt; returnsSelf
    argument_types -&gt; argumentTypes
    return_type -&gt; returnType
objc.get_class_list -&gt; objc.getClassList
</pre>
</li>
<li>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.</li>
<li>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)</li>
<li>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()</li>
<li>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.</li>
</ul>
<h2><a>Version 0.8 (Dec-10-2002)</a></h2>
<ul>
<li>GNUStep support has been removed for lack of support.  Volunteers
needed.</li>
<li>Subclassing Objective-C classes from Python, including the addition
of instance variables (like 'IBOutlet's)</li>
<li>Generic support for pass-by-reference arguments</li>
<li>More complete Cocoa package, including wrappers for a number of 
C functions, enumerated types, and globals.</li>
<li>More example code</li>
<li>Objective-C mappings and sequences can be accessed using the normal
python methods for accessing mappings and sequences (e.g. subscripting
works as expected)</li>
<li>Documentation: See the directory 'docs'</li>
<li>Can build standalone Cocoa applications based entirely on Python
without requiring that user installs anything extra (requires 10.2).</li>
<li>Better packaging and wrapper construction tools (borrowed from
MacPython).</li>
<li>An installer package.</li>
<li>Support for Project Builder based Cocoa-Python projects.</li>
<li>Unit tests.</li>
</ul>
<h2><a>Version 2002-01-30 (January 30, 2002)</a></h2>
<ul>
<li>Version bumped to 0.6.1 ( __version__ is now a PyString )</li>
<li>Will now build for Python 2.2</li>
<li>added Cocoa package with Foundation.py and AppKit.py wrappers.</li>
<li>HelloWorld.py in Examples</li>
<li>builds with -g flag for debugging. -v option will dump log
of message sends to /tmp file.</li>
<li>Fixed one major runtime bug: added ISCLASS test before isKindOfClass -
without check, it crashes on sends to abstract classes like NSProxy.</li>
<li>There are still problems with Delegates and Notifications.</li>
</ul>
<h2><a>Version 2001-03-17 (March 17, 2001)</a></h2>
<ul>
<li>moved to using distutils setup.py (requires small patch to distutils
that has been submitted against python 2.1b1)</li>
</ul>
<h2><a>Version 2000-11-14 (November 14, 2000)</a></h2>
<ul>
<li>GNU_RUNTIME is likely completely broken</li>
<li>Compiles on Mac OS X Server (python 2.0)</li>
<li>Compiles on Mac OS X (python 2.0)</li>
<li>Works as either a dynamically loadable module or statically built
into a python executable</li>
<li>Requires a modified makesetup to work [patches have been sent to
SourceForge.net's Python project].</li>
<li>Supports NSAutoReleasepool.</li>
<li>Some pre-OSX stuff removed;  references to old APIs, etc... (but
nowhere near clean)</li>
</ul>
<h2><a>Version 0.55, 18 August 1998</a></h2>
<ul>
<li>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:<pre>
o Adjusting Setup, commenting out NeXT definition and enabling GNU
  ones;
o make -f Makefile.pre.in boot
o make static
</pre>
</li>
</ul>
<h2><a>Version 0.54, 24 March 1998</a></h2>
<ul>
<li>OC_Pasteboard.[hm], OC_Stream.[mh] and ObjCStreams.m are definitively gone.</li>
<li>OC_PythonObject derives from NSProxy.</li>
</ul>
<h2><a>Version 0.53, 4 January 1998</a></h2>
<ul>
<li>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.</li>
<li>OC_Streams and OC_Pasteboard aren't supported, I've not yet decided
if they are needed anymore.</li>
<li>Updated LittleButtonedWindow demo.</li>
</ul>
<h2><a>Version 0.47, 29 October 1996</a></h2>
<ul>
<li>Misc/Makefile.pre.in automatically sets TARGET to <code><span>pyobjc</span></code>.</li>
<li>ObjC.m splitted to ObjCObject.m ObjCMethod.m ObjCPointer.m
ObjCRuntime.m.</li>
<li>New (almost invisible) types: ObjCSequenceObject and
ObjCMappingObject; this to implement sequence and mapping syntax
(several mapping methods have stub implementation).</li>
<li>OC_Pasteboard class is gone. Its functionalities are now in a
category of Pasteboard/NSPasteboard.</li>
<li>Better methods doc.</li>
<li>PyArg_ParseTuple format strings contain arguments names.</li>
<li>OC_Streams are mapped to ObjCStreams by pythonify_c_value and its
counterpart.</li>
</ul>
<h2><a>Version 0.46, 18 October 1996</a></h2>
<ul>
<li>OC_Stream is now a subclass of NSData under Foundation.</li>
<li>New Objective-C class: OC_Pasteboard. Use it instead of Pasteboard/
NSPasteboard.</li>
<li>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.</li>
<li>OC_Python.[hm] aren't in the package anymore.</li>
<li>Setup.in directives changed again, due to OC_Python.m dropping.</li>
</ul>
<h2><a>Version 0.45, 14 October 1996</a></h2>
<ul>
<li>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.</li>
<li>Revisited streams, in particular GNUstep support.</li>
</ul>
<h2><a>Version 0.44, 9 October 1996</a></h2>
<ul>
<li>Integers are now accepted too where floats or doubles are expected.</li>
<li>New method: ObjC.make_pointer (1) returns an ObjCPointer containing
<code><span>((void</span> <span>*)</span> <span>1)</span></code>.</li>
</ul>
<h2><a>Version 0.43, 7 October 1996</a></h2>
<ul>
<li>Completed ObjCStream implementation. There is now a new module, ObjCStreams
which is automatically loaded by ObjC. You can access it as ObjC.streams.</li>
<li>Manual splitted in three parts: libPyObjC.tex with the chapter intro,
libObjC.tex describing the main module, libObjCStreams.tex explains the
stream facilities.</li>
</ul>
<h2><a>Version 0.42, 4 October 1996</a></h2>
<ul>
<li>You can pass initialization arguments when using the <code><span>Class()</span></code> syntax. You
select the right initializer selector with the <code><span>init</span></code> keyword parameter.</li>
<li>First cut on ObjCStream objects. Thanx to Bill Bumgarner for motivations.</li>
<li>New demo ShellText, to test above points.</li>
</ul>
<h2><a>Version 0.41, 2 October 1996</a></h2>
<ul>
<li>Revised error messages: for arguments type mismatch they show the ObjC type
expected.</li>
<li>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.</li>
<li>New demo: Fred. To halt it, suspend the Python process with ^Z then kill
it ;-).</li>
<li>Setup.in directives changed. See the new file Modules/Setup.PyObjC.in</li>
<li>Distribuited as a standalone package. Special thanks to Bill Bumgarner.</li>
</ul>
<h2><a>Version 0.4, 27 September 1996</a></h2>
<ul>
<li>Now handles methods returning doubles or floats.</li>
<li>ObjCRuntime responds to .sel_is_mapped().</li>
</ul>
<h2><a>Version 0.31, 26 September 1996</a></h2>
<ul>
<li>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.</li>
<li>Manual section.</li>
<li>ObjC.runtime.__dict__ added.</li>
<li>ObjC.runtime.kind added.</li>
</ul>
<h2><a>Version 0.3, 20 September 1996</a></h2>
<ul>
<li>No user visible changes, just a little effort towards GNU_RUNTIME support.</li>
</ul>
<h2><a>Version 0.2, 16 September 1996</a></h2>
<ul>
<li>Accepts a struct.pack() string for pointer arguments, but...</li>
<li>... 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:<pre>
framep = aView.getFrame__.pack_argument (0)
aView.getFrame__ (framep)
frame = aView.getFrame__.unpack_argument (0, framep)
</pre>
</li>
</ul>
<h2><a>Version 0.1, 13 September 1996</a></h2>
<ul>
<li>Correctly handle pointer arguments.</li>
<li>New syntax to get a class: ObjC.runtime.NameOfClass</li>
<li>New syntax aliasing .new(): SomeClass()</li>
<li>New Demo: LittleButtonedWindow, that tests points above.</li>
<li>What follow is the recipe to get PyObjC dynamically loadable on NeXTSTEP:<ul>
<li>apply the patch in Misc/INSTALL.PyObjC to Python/importdl.c</li>
<li>modify Python/Makefile adding the switch <code><span>-ObjC</span></code> to the importdl.o
build rule:<pre>
importdl.o:   importdl.c
  $(CC) -ObjC -c $(CFLAGS) -I$(DLINCLDIR) $(srcdir)/importdl.c
</pre>
</li>
<li>modify Modules/Setup moving the PyObjC entry suggested above AFTER
<code><span>*shared*</span></code>, and remove <code><span>-u</span> <span>libNeXT_s</span> <span>-lNeXT_s</span></code> from it.</li>
<li>run <code><span>make</span></code>: this will update various files, in particular
Modules/Makefile.</li>
<li>modify Modules/Makefile adding <code><span>-u</span> <span>libNeXT_s</span> <span>-lNeXT_s</span></code> to SYSLIBS:<pre>
SYSLIBS=      $(LIBM) $(LIBC) -u libNeXT_s -lNeXT_s
</pre>
</li>
<li>run <code><span>make</span></code> again</li>
</ul>
</li>
</ul>
</body>
</html>
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.