Source

pyobjc / pyobjc-core / NEWS.txt

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
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
What's new in PyObjC
====================

An overview of the relevant changes in new, and older, releases.

Version 3.0
-----------

* ``inspect.signature`` works for all functions and methods implemented in C,
  when using Python 3.4 or later.

* The module ``PyObjCTools.NibClassBuilder`` is not longer available. It only worked
  with ancient versions of Interface Builder (pre-Xcode)

* The wrapper type for opaque pointers didn't have a "__module__" attribute,
  which breaks code that (correctly) assumes that all types have such an attribute.

* Archiving now supports nested definitions and method references, simular
  to the support of those added to pickle protocol 4 in Python 3.4.

  Encoding nested classes requires support for the ``__qualname__`` attribute,
  and hence requires Python 3.3. Decoding should work with earlier python
  versions as well.

* Addd ``objc.autorelease_pool``, a context manager for managing an
  autorelease pool. Usage::

       with objc.autorelease_pool():
          pass


  This is equivalent to::

       _pool = NSAutoreleasePool.alloc().init()
       try:
           pass

       finally:
           del _pool

* Added ``objc.registerABCForClass`` to make it possible to register
  a class with a number of ABC classes when the class becomes available.

* ``NSDecimalNumber`` can now be instantatiated as a normal Python object::

     value = NSDecimalNumber(4)

* ``NSData`` and ``NSMutableData`` can now be instantiated as a normal
  Python object::

      value = NSData(someBytes)

   or::

      value = NSData()

* ``NSDecimal`` now coerces the other value to ``NSDecimal`` in coercions.
  Because of you can now order instances of ``NSDecimal`` and ``int``.

* ``PyObjCTools.KeyValueCoding.ArrayOperators`` and
  ``PyObjCTools.KeyValueCoding.arrayOperators`` were accidently public
  names in previous releases, and are now removed. Use the array operators
  in the KVC protocol instead.

* Restructured the "convenience" method code. This shouldn't have user
  visible effects, but makes the code easier to maintain.

* ``objc.addConvienceForSelector`` no longer exists, it isn't possible
  to provide this functionality with the current implementation of the
  bridge.

* The build of pyobjc-core can now be configured by editing setup.cfg (or
  providing arguments to the build_ext command), instead of editing the
  setup.py file.

  Currently the following options are availabel for the build_ext command:

  * ``--use-system-libffi``: When this option is used the build will use
    /usr/lib/libffi.dylib instead of the embedded copy of libffi. The latter
    is the default is and is better tested.

  * ``--deployment-target=VAL``: The value of ``MACOSX_DEPLOYMENT_TARGET`` to use,
    defaults to the deployment target used for building Python itself

  * ``--sdk-root=VAL``: Path to the SDK root used to build PyObjC, or "python" to
    use the default SDK selected by distutils. The default is to use the
    most recent SDK available.

* The lazy importer has smarter calculation of the ``__all__`` attribute,
  which should speed up 'from Cocoa import \*'.

* BUGFIX: using a method definition with only ``*args`` and ``**kwds`` used
  to crash the interpreter, the now once again raise a TypeError exception.

* The metadata for pyobjc-framework-Accounts was incomplete, fixed that.

* :func:`objc.callbackFor` now also adds a *__metadata__* method to decorated
  functions. This is primarily to make it easier to test the metadata values.

* The *__typestr__* attribute of opaque pointer types is now a byte string,
  in previous versions this was an instance of :class:`str` (this only affects
  Python 3 support)

* The JavaScriptCore bindings (in pyobjc-framework-WebKit) are now more usable
  because types like "JSValueRef" are now exposed to Python (they were missing
  due to incomplete metadata).

* Exclude a number of keys from the metadata dictionary when they have the
  default value (in the result from the *__metadata__()* method on methods
  and functions)

* The "lazy" modules used by framework wrappers now always have a ``__loader__``
  attribute (as required by PEP 302). The value can be :data:`None` when there
  is no explicit loader (such as when importing from the filesystem in Python 3.2
  or earlier).

* Method (and function) metadata is stored in a more compact manner, reducing the
  memory use of PyObjC applications.

* Removed support for hiding "protected" methods, :func:`objc.setHideProtected` is gone,
  it complicated the code without real advantages.

  Reasons for this:

  * There were some conflicts because a class implemented two selectors that caused
    the same python method to be added to the class *__dict__*. Which one was added
    was basicly random.

  * The functionality required PyObjC to maintain a full *__dict__* for classes, even
    when most Cocoa methods were never called. Ensuring that the contents of *__dict__*
    is correct in the face of Objective-C categories and class patches required some
    *very* expensive code.

  As a side effect of this some classes may no longer have the convenience methods they
  had in earlier releases (in particular classes that are not mentioned in Apple's
  documentation).

* Issue #3: The bridge now lazily looks for Objective-C methods as they are used from Python, instead
  of trying to maintain a class *__dict__* that mirrors the method list of the Objective-C
  class.

  Maintaining the *__dict__* was *very* expensive, on every method call the bridge would
  check if the method list had changed and there is no cheap way to perform that check.

  .. note::
     I haven't done performance tests at this time, it is not yet clear if this work will
     make the bridge more efficient or that there are other more important bottlenecks.

* The default translation from a python name to a selector was slightly changed:

  * double underscores inside the name are no translated to colons, that is 'foo__bar_' is translated to 'foo__bar:', not 'foo::bar:'

  * if the Python name start with two uppercase letters and an underscore, that first underscore is not translated into
    an colon. Two leading capitals are often used as a way to add some kind of namespacing
    to selector names (and avoid conflicts when a method with the same name is added later by the library provider)

* Added *__new__* method to NSString, it is now possible to explictly convert a python string to a Cocoa
  string with ``NSString(someString)``

* Added *__eq__* and *__ne__* methods to native selector objects, which mean you can now
  check if two method objects are the same using 'sel1 == sel2'. This works both for bound
  and unbound selectors.

* NSData.bytes() could raise an exception on some version of Python 3 when the data object is empty.
  The function now returns an empty bytes object instead.

* NSMutableData.mutableBytes() raises an exception when the data object has a 0-sized buffer.
  (see also the previous bullet)

* Add attribute *__objclass__* to :class:`objc.selector` instances as an alias for *definingClass*. The name
  *__objclass__* is used by builtin method objects for the same purpose as *definingClass*.

  The new attribute is needed to ensure that ``help(NSObject)`` works (although all methods are shown as
  data descriptors, not methods)

* :class`objc.selector` no longer implements *__set__*, which means it is now classified as a method
  descriptor by the :mod:`inspec` module, which gives nicer output in :mod:`pydoc`.

  This doesn't change any functionality beyond that, it is still possible to overwrite methods and not
  possible to delete them.

* :class:`objc.native_selector` and :class:`objc.function` now have a (minimal) docstring with information
  object.  This makes :func:`help <pydoc.help>` for Cocoa classes and functions more useful.

  As a side-effect of this the docstring is no longer writeable.

  .. note::

     The docstring show the interface of a block with a function prototype instead of the proper
     C declaration, that makes the implementation slightly easier and the function prototype syntax
     is slightly easier to read for users that aren't C experts.

* :class:`objc.selector`, :class:`objc.function` and :class:`objc.IMP` now have an implementation for
  the "__signature__" property when using Python 3.3 or later. This makes it possible to use
  :func:`inspect.signature` with these objects.

* It should now be possible to write tuples with more than INT_MAX elements to an NSArchive. Those archives
  cannot be read back by older versions of PyObjC (or python running in 32-bit mode), but archives that
  contain only smaller tuples can be read back by earlier versions.

* Issue #38: Struct wrappers and opaque pointer types now implement support for :func:`sys.getsizeof`,
  as do :class:`objc.FSRef`, :class:`objc.FSSpec`, and Objective-C classes.

  The size of Objective-C instances is not entirely correct, and cannot be. The :func:`sizeof <sys.sizeof>` function
  only reports the size of the proxy object and the basic size of the Objective-C object. It does not
  report additional buffers used by the object, which for example means that a too low size is reported
  for Cocoa containers like NSArray.

* Opaque pointer objects now have a method "__c_void_p__" that returns a :class:`ctypes.void_p` for
  the same pointer.

* Added an API to "pyobjc-api.h" that makes it easier to explicitly load function references in
  manual function wrappers. This replaces the compiler support for weak linking, which was needed
  because weak linking did not work properly with clang (Xcode 4.5.1). This also makes it possible
  to compile in support for functions that aren't available on the build platform (in particular, when
  building on 10.8 the Quartz bindings now contain support for some functions that were dropped in 10.8
  and which will be available through pyobjc when deploying to 10.7)

* The framework wrappers no longer export a "protocols" submodule. Those submodules were deprecated in
  2.4 and did not contain information that is usefull for users of PyObjC.

* Dropped the "objc.runtime" attribute (which was deprecated in PyObjC 2.0)

* Dropped depcreated APIs *objc.pluginBundle*, *objc.registerPlugin*. Py2app has used a
  different mechanism for years now.

* Dropped deprecatd APIs: *objc.splitStruct*,  *objc._loadFunctionList*. Both have
  been replaced by newer APIs in PyObjC 2.4.

* Foundation's *NSDecimal* type is exposed in the objc module as well.

  This was done to remove a dependency from the pyobjc-core package to pyobjc-framework-Cocoa.

* The type :class:`objc.NSDecimal` is now an immutable type, just like
  :class:`decimal.Decimal` and other Python value types.

  Because of this the interface of ``Foundation.NSScanner.scanDecimal_`` has changed, in
  previous versions it is used as::

      dec = Foundation.NSDecimal()
      ok = scanner.scanDecimal_(dec)

  In the current version it is called just like any other method with an output argument::

      ok, dec = scanner.scanDecimal_(None)

* The C code is more careful about updating Python reference counts, in earlier versions
  it was possible to trigger access to a field in a datastructure that was being deallocated
  because the calls to :c:macro:`Py_DECREF` for the field happened before setting the
  field to :c:data:`NULL` or a new value.  This could then result in a hard crash due to
  accessing freed memory.

* Bugfix: objc.NSDecimal(2.5) works with python 3 (caused a confusing
  exception due to buggy code before).

* Bugfix: the support for :func:`round <__builtin__.round>` for :class:`objc.NSDecimal`
  always rounded down, instead of using the normal rounding rules used by other
  methods.

* PybjC no longer supports the CoreFoundation bindings in the "Carbon.CF" module
  in the standard library for Python 2.  The "Carbon.CF" module is not present
  in Python 3, and is unmaintained in Python 2.

* The 'struct sockaddr' conversion code now understands the AF_UNIX address family.

* The function "objc.setSignatureForSelector" has been removed (and was deprecated
  in 2.3), use the metadata system instead."

* The 'returnTypes' and 'argumentTypes' parameters for 'objc.selector' have
  been removed (they were deprecated in version 2.5). These were an attempt
  to use type encodings as used in :c:func:`Py_BuildValue` and AFAIK were never
  used in real code.

* The header "pyobjc-api.h" has been cleaned up:

  .. note::

     "pyobjc-api.h" is used by extension modules in the PyObjC framework wrappers
     but is not intended to be a public API. Please let me (Ronald) know if you
     use this API, I'm trying to get the API as small as possible and that might
     lead to its complete removal in a future version of PyObjC.

  - Py_ARG_SIZE_T is no longer defined by pyobjc-api.h (use "n" instead)

  - Removed the following functions from the API (PYOBJC_API_VERSION is now 20)
    because they aren't used by PyObjC:

    - PyObjC_PerformWeaklinking (and struct PyObjC_WeakLink)

    - PyObjCRT_RemoveFieldNames

    - PyObjC_is_ascii_string

    - PyObjC_is_ascii_prefix

    - PyObjCObject_Check

    - PyObjCClass_Check

    - PyObjCSelector_Check

    - PyObjCObject_ClearObject

    - PyObjCClass_New

    - PyObjCErr_ToObjC

    - PyObjC_RegisterSignatureMapping

    - PyObjCRT_AlignOfType

    - PyObjCRT_SELName

    - PyObjCRT_SimplifySignature

    - PyObjC_RegisterStructType

    - PyObjCObject_IsUninitialized

    - PyObjCObject_New

    - PyObjCCreateOpaquePointerType

    .. note::

       There will be futher cleanup of this API before the 3.0 release.

    Added a *name* argument to PyObjCPointerWrapper_Register.

* The KVO implementation for Cocoa subclasses used to ignore exceptions
  in the implementation of ``[obj willChangeValueForKey:]`` and
  ``[obj didChangeValueForKey:]`` and no longer does so.

  One side effect of this is that ``willChangeForForKey_`` and
  ``didChangeValueForKey_`` can now cause user visible exceptions
  when "__useKVO__" is true (the default) and these methods are implemented
  in Python.

* PyObjC 3 requires a compiler that supports Objective-C with C99 as the base
  language.

* PyObjC raises an exception instead of creating instances of
  :class:`objc.PyObjCPointer` when you set :data:`objc.options.unknown_pointer_raises`
  to :data:`True`.

  The default is currently :data:`False`, that will be changed in a future version
  and the entire `objc.ObjCPointer` class will likely be removed some releases
  after that.

* Configuration options are now attributes of special object :data:`objc.options`.

  The following functions are therefore now deprecated and will be removed
  in PyObjC 3.1:

  * :func:`objc.getVerbose`

  * :func:`objc.setVerbose`

  * :func:`objc.setUseKVOForSetAttr`

  * :func:`objc.setStrBridgeEnabled`

  * :func:`objc.getStrBridgeEnabled`

* Removed objc._setClassSetUpHook, an internal method that is not used
  anymore.

* Removed +[OC_PythonObject setVersion:encoder:decoder:],
  +[OC_PythonObject pythonifyStructTable], +[OC_PythonObject depythonifyTable].

 All were private methods used by the core bridge and are no longer necessary.

* Added :func:`objc.registerSetType` and :func:`objc.registerDateType`, with
  simular semantics as the already existing functions :func:`objc.registerMappingType`
  and :func:`objc.registerListType`.

* Moved the logic for creating Objective-C proxies for Python objects from
  class methods on OC_PythonObject, OC_PythonArray, OC_PythonDictionary,
  OC_PythonSet and OC_PythonDate to a C function to simplify this logic and
  make it easier to further optimize.

  Because of this a number of (private) class methods are no longer
  available. This shouldn't affect normal code because these methods aren't
  part of the public API for PyObjC.

* Added bindings to the CoreWLAN framework (Mac OS X 10.6 or later) in
  package "pyobjc-framework-CoreWLAN"

* Added bindings to the AVFoundation framework (Mac OS X 10.7 or later) in
  package "pyobjc-framework-AVFoundation"

* The *__dict__* for ``anObject.pyobjc_instanceMethods`` and
  ``AClass.pyobjc_classMethods`` is now read-only instead of read-write.

  Updates of *__dict__* already did not affect anything (the value is
  calculated on access).

* Removed workarounds for KVO bugs in Mac OS X 10.3.9, which means KVO
  will likely not work properly anymore on that release of OS X.

* Earlier versions of PyObjC accidently exposed ``-[NSObject respondsToSelector:]``
  as ``NSObject.respondsToSelector()`` as well as the expected
  ``NSObject.respondsToSelector_()``. The first incorrect binding no
  longer works.

* Python 3 only: NSKeyedArchives with a bytes object can now be read
  back by a pure Objective-C program (that program will decode it
  as an NSData object).

  Because of this the encoding for method for OC_PythonData was changed,
  archives created by PyObjC 3.0 can therefore not be read back
  by earlier PyObjC versions (but PyObjC 3.0 can read archives created
  by those older versions)

* NSKeyedArchives with a python list or tuple (but not subclasses) can
  now be read back as NSArrays in Objective-C programs.

* NSKeyedArchives with a python set or frozenset (but not subclasses)
  can now be read back as NSSets in Objective-C programs.

  This required a change in the format used to create the archive,
  which means that archives with a set or frozenset (but not subclasses)
  cannot be read back by earlier versions of PyObjC.

* When writing instances of list, tuple, dict, set and frozenset to
  an NSArchive, but not an NSKeyedArchiver, the objects are stored
  with the same encoding as the corresponding Cocoa class.

  This has two side effects: the archive can be read back by pure
  Objective-C code and when you read back the archive using PyObjC you'll
  get instances of Cocoa classes instead of the native python classes.

* ``-[OC_PythonEnumerator nextObject]`` now returns ``[NSNull null]`` instead
  of ``nil``, to be compatible with the behavior of item getters/setters
  and to avoid ending iteration premature when a Python sequence contains
  :data:`None`.

* Fixed a number of issues with :data:`None` as a member of a set-like
  object proxied by ``OC_PythonSet``. The easiest way to trigger the
  issue in earlier versions::

     assert {None} == NSSet.setWithArray([None])

  These expose sets with the same members to ObjC code, but those objects
  didn't compare equal.

* Python 2 only: NSDictionary instances now have the same internal
  other as dict instances with the same value, that is
  ``cmp(anNSDict1, anNSDict2) == ``cmp(dict(anNSDict1), dict(anNSDict2))``.

* In previous versions of PyObjC instances of ``Foundation.NSDecimal`` behaved
  as if they had the same methods as ``Foundation.NSDecimalNumber``. In 3.0
  PyObjC no longer exposes these methods.

* Python blocks (that is, Python callables passed to a method/function that
  expects an Objective-C block argument) now include an Objective-C
  signature string (introduced in "ABI.2010.3.16").

* PyObjC now supports blocks that have a large struct as the return value
  (for example a block that returns an NSRect structure).

* Reduced the number of unnecessary methods implemented by the various
  OC_Python* classes, this might affect some Objective-C code that directly
  uses these classes instead of just using the interface of their
  superclasses.

* ``del NSObject.__version__`` crashed the interpreter because the setter
  didn't guard against deletion attempts.

* ``del aSelector.isHidden`` crashed the interpreter (see above)

* Class :class:`objc.ObjCPointer` was not exposed in the :mod:`objc` module.

* The implementation of :class:`objc.ObjCPointer` didn't have a proper
  implementation of *__getattribute__* and that made objects of this
  class even more useless than they should have been.

* Values of :class:`objc.ObjCPointer` no longer have an unpack method
  (the method has been inaccisible for several releases and its implementation
  as unsafe)

* The *type* attribute of :class:`objc.ObjCPointer` now starts with
  :data:`objc._C_PTR` (that is, the *type* attribute is the encoded type
  of the pointer, instead of the encoded type of the pointed-to value).

* Framework wrappers no longer have a 'protocols' submodule, use
  :func:`objc.protocolNamed` to access a protocol.

* ``-[OC_PythonObject valueForKeyPath:]`` and ``-[OC_PythonObject setValue:forKeyPath:]``
  now call helper functions in :mod:`PyObjCTools.KeyValueCoding`, just
  like ``-[OC_PythonObject valueForKey:]`` and ``-[OC_PythonObject setValue:forKey:]``.

  This should give better results in some edge cases when dealing with
  complicated keypaths.


Version 2.5.2
-------------

- "easy_install pyobjc" always tried to install the FSEvents binding,
  even when running on OSX 10.4 (where that API is not available).

- ``objc.ObjCPointer`` didn't implement *__getattribute__*.

  (reported by private mail)

- Implementing a python method that has a block as one of its arguments
  didn't work. It now works when there is metadata that describes the
  method signature.

  (reported by private mail)

- BUGFIX: a method definition like this now once again raises TypeError
  instead of crashing the interpreter::

      def myMethod(*args):
         pass

  (reported by private mail)

Version 2.5.1
-------------

- PyObjC could crash when calling a method that is dynamicly generated
  (that is, the selector is not present in the class according to the
  Objective-C runtime but the instance responds to it anyway).

  The cases that used to crash now raise :exc:`objc.error` instead.

  .. note::

     It is highly unlikely that real code would run into this, found
     while working on PyObjC 3.x.

- When writing a python unicode object to an NSArchiver or NSKeyedArchiver
  the object is now stored exactly the same as a normal NSString, and will
  be read back as such.

  This increases interoperability with code that expects to read back a
  non-keyed archive in a different proces. An example of this is the use
  of Growl (see issue #31)

  Instances of subclasses of unicode are not affected by this change, and
  can only be read back by other PyObjC programs.

- Issue #43: It was no longer possible to create instances of
  LaunchServices.LSLaunchURLSpec due to incomplete metadata.

- Issue #41: the 'install.py' script in the root of pyobjc repository
  failed to perform an install when running in a clean checkout of the tree.

- Issue #44: the various Cocoa frameworks only export @protocol defintions when
  they happen to be used by code in the framework. Added extensions to the
  various framework wrappers to ensure that all protocols are available to
  python code.

- Opaque pointer types now can be constructed with a "c_void_p" keyword
  argument that contains a :class:`ctypes.c_void_p` value for the pointer.

  This is the reverse of the *__c_void_p__()* method that was added
  earlier.

- Issue #46: It was not possible to use the Quartz.CoreGraphics module
  on OSX 10.5 when the binary was build on 10.8 (and using a 10.5 deployment
  target).

  Simular issues may be present in some of the other framework wrappers,
  there will be a more generic fix for this issue in a future release.

Version 2.5
-----------

- Add conversion to/from ctypes.c_void_p to proxies for Cocoa objects.

  To use::

     anObject = NSArray.array()
     void_p = anObject.__c_void_p__()
     # use void_p with ctypes

     otherObject = NSObject(c_void_p=voip_p)
     assert anObject is otherObject

  Note that it is save to contruct the python proxy from NSObject,
  the class will return an instance of the correct proxy type (in this
  example an instance of NSArray)

- Fixed problem where the result of ``anObject.__cobject__()`` could not be converted
  back to a PyObjC object again.

- A number of framework wrappers have a "protocols" submodule containing
  protocol objects (for example the module 'Foundation.protocol'). Use
  of these modules is deprecated, they will be removed in PyObjC 3.0.

  Use :func:`objc.protocolNamed` to access protocols instead.

- Instances of :class:`objc.ivar` now have slots for introspection:

  - *__typestr__*: The type encoding

  - *__name__*: The Objective-C name

  - *__isOutlet__*: :data:`True` if the instance variable is an IBOutlet

  - *__isSlot__*: :data:`True` if the instance variable is a Python slot

- Added implementation of '==' and '!=' for selectors defined in Python
  that is slightly smarter than the default (identity based) implementation
  in Python.

  This is mostly done for the PyObjC unittests and shouldn't affect user
  code.

- Issue #30: Explicitly check if the compiler works, and try to
  fall back to clang if it doesn't. This uses a simular algoritm as
  the fix for <http://bugs.python.org/issue13590> in Python's tracker.

- Issue #22: Reimplement support for bridgesupport files

  This reintroduces ``objc.parseBridgeSupport`` and
  ``objc.initFrameworkWrapper``, both are reimplemented in Python
  (previous version used C code)

  .. note::

     The implementation is currently barely tested and therefore likely
     contains bugs.

- Struct types created by the framework wrappers once again create class
  methods on :class:`objc.ivar` to generate instance variables of that type::

     myLocation = objc.ivar.NSPoint()

  This has the same result as::

    myLocation = objc.ivar(typer=NSPoint.__typestr__)

- :func:`objc.IBAction` now raises TypeError when the argument is :data:`None`.

- :func:`objc.instancemethod` is now actually exported by the :mod:`objc` package.

- :func:`objc.accessor` and :func:`objc.typedAccessor` were not 64-bit safe.

- :func:`objc.accessor` and :func:`objc.typedAccessor` didn't support the entire
  set of KVC accessors.

- Add methods "_asdict" and "_replace" and field "_fields" to the struct wrapper
  types. These new attributes mirror the :class:`collections.namedtuple` interface.

  .. note::

     In the long run I'd like to make struct wrappers immutable to allow using
     them as dictionary keys. This is a first step in that direction and makes
     it possible to verify that immutable struct wrappers are useable.

- Added :func:`objc.createStructAlias`, and deprecated
  :func:`objc.registerStructAlias`. The new function has a "name" argument
  and can register types with the :class:`objc.ivar` type (see previous item)

- Add explicit deprecation warnings to ``objc.CFToObject`` and
  ``objc.ObjectToCF``. Both functions barely function at all and will
  be removed with PyObjC 3.0.

- ``objc.CFToObject`` and ``objc.ObjectToCF`` are no longer available
  when using Python 3.x, the APIs are used for MacPython support and
  that part of the standard library is not available with Python 3.x.

- ``objc.splitStruct`` is renamed to ``objc.splitStructSignature``
  and now actually works. The old name is temporarily available as
  an alias.

- Fix refcounting leak in ``objc.splitSignature``.

- ``objc._loadFunctionList`` is renamed to ``objc.loadFunctionList``
  and is fully documented. The old name is temporarily available as
  an alias.

- Move (deprected) decorator "signature" from objc._functions to objc._descriptors,
  and remove the former module.

  .. note::
     The names op submodules of objc are implementation details, don't import
     them directly.

- The optional argument for the decorator :func:`objc.selectorFor` was broken

- The :class:`PyObjCTools.KeyValueCoding.kvc` wrapper `__setattr__` wrapper
  incorrectly set attributes on itself as well as on the wrapped object (the latter
  using Key-Value Coding)

- Renamed (private) function injectSuffixes to inject_suffixes to match the
  other code in objc._dyld.

- Slight restructuring of objc._pythonify to reduce code duplication between the
  python 2.x and python 3.x cases.

- Removed deprecated methods from PyObjCTools.TestSupport

- :class:`collections.Sequence` objects are now automaticly proxied as NSArray
  instances

- :class:`collections.Mapping` objects are now automaticly proxies as NSDictionary
  instances

- Removed some objects and functions from objc._bridges that weren't public
  and weren't used by PyObjC itself:

  - *BRIDGED_STRUCTURES*: mapping of python type to proxy class
  - *BRIDGED_STRUCTURES2*: mapping of python type to proxy class (not used at all)
  - *BRIDGED_TYPES*: mapping of python type to proxy class
  - *_bridgePythonTypes*: uses BRIDGED_STRUCTURES and BRIDGED_TYPES to update bridge data

  *_bridgePythonTypes* was called unconditionally, but never did anything because
  the data structures were empty and no code adds anything to them.

- Improved documentation

- For Objective-C blocks: try to extract the block signature from the (Objective-)C runtime
  when there is no metadata for the block. The block signature is available only when the
  code that creates the block is compiled using a recent enough compiler (although "recent
  enough" is fairly old by now)

- Fixes some issues with :class:`objc.object_property` which were found by
  improved unittests. In particular:

  - The selector names for boolean properties were wrong

  - Properties with a "depends_on" list didn't inherit properly

  - Properties that were used in subclasses didn't generate the correct KVO
    events when they were observed.

  - KVO issues with computed (read-only) properties

- Fixed some issues with :class:`objc.array_property` and :class:`objc.set_property`
  that were found by much improved unittests.

- Fixed issues with :mod:`PyObjCTools.KeyValueCoding` that were found by improved
  unittests:

  - ``getKey`` didn't work propertly on dictionaries (dictionaries were treated as sequences)

  - ``getKeyPath(list, "@avg.field")`` didn't work when field wasn't a valid key for all
     items in the list, and likewise for the '@sum', '@min', '@max' special keys.

  - ``getKeyPath`` didn't raise the correct exception for empty key paths

  - ``@unionOfObjects`` and ``@distinctUnionOfObjects`` operators for Python sequences
    didn't raise an exception when the selected keypath didn't exist on an item of the sequence.

  - ``@unionOfArrays`` and ``@distinctUnionOfArrays`` operators for Python sequences
    didn't raise an exception when the selected keypath didn't exist on an item of the sequence.

  - ``@distinctUnionOfArrays`` and ``@distinctUnionOfObjects`` didn't work properly when
     the keypath pointed to objects that weren't hashable.

  - ``@distinctUnionOfSets`` operator was not present at all.

- 'PyObjCTools.KeyValueCoding.setKey' now sets keys in dictionaries, that is::

     >>> a = {}
     >>> setKey(a, 'foo', 42)
     >>> a
     {'foo': 42 }

- 'PyObjCTools.KeyValueCoding.setKey(object, 'key', value)' now sets attribute 'key' when
  the object already has that attribute, before looking at '_key'. This avoids that ``setKey``
  changes the underlying storage for a common Python property pattern::

      class Record (object):
         @property
	 def prop(self):
	     return self._prop

	 @prop.setter
	 def prop(self, value):
	     self._prop = calculate_using(value)

  Until PyObjC 2.5 the property setter for 'prop' would not be called when using KeyValueCoding.

- Removed Mac OS X 10.2 (!) compatibility from :mod:`PyObjCTools.KeyValueCoding`.

- PyObjCTools.KeyValueCoding has undocumented attributes 'ArrayOperators' and 'arrayOperators',
  both will be removed in a future release.

- Using NSArchiver or NSKeyedArchiver to encode and then decode a python list or tuple could
  result in an unexpected value. In particular, if any element of the sequence was :data:`None`
  before archiving it would by ``NSNull.null()`` when read back.

- Using NSArchiver or NSKeyedArchiver to encode and decode (pure) python objects didn't always
  work correctly. Found by improved unittests.

- Using NSArchiver or NSKeyedArchiver to encode and decode bytes objects in Python 3 would
  result in an instance of NSData instead of bytes.

- The implementation of cmp() for NSSet instances now matches the behavior of regular python
  sets, that is calling ``cmp(anNSSet, aValue)`` will raise a TypeError exception unless
  both arguments are the same object (``anNSSet is aValue``).

- Issue #36: explictly document that PyObjC does not support the Objective-C Garbage Collection
  system (introduced in OSX 10.5, deprecated in OSX 10.8), and also mention this in the
  documentation for the screen saver framework because the screen saver engine uses GC on
  OSX 10.6 and 10.7.

- Issue #37: Fix runtime link error with EPD (Enthought Python Distribution),
  which doesn't include the pymactoolbox functionality.

- Various improvements to the documentation

Version 2.4.1
-------------

.. note:: 2.41 was never released, all bugfixes are in the 2.4 branch as well as the 2.5 release.

- Cocoa wrappers: fix metadata for ``copy``, ``mutableCopy``,
  ``copyWithZone:`` and ``mutableCopyWithZone:``

- Fix for issue 3585235 on SourceForge: the threading helper category on
  NSObject didn't work due to a typo (defined in the Cocoa bindings)

  Fix is based on a patch by "Kentzo" with further updates and tests by
  Ronald.

- Rename ReadMe.txt to README.txt to work around misfeature in the
  sdist command in distutils.

- Issue #28: Avoid crash when using CGEventTabProxy values.

- Issue #33: "easy_install pyobjc" no longer tries to install the
  InterfaceBuilderKit bindings on OSX 10.7 or later.

Version 2.4
-----------

.. note::

   Sadly enough this changelog is incomplete.

- Fix crash when unarchiving a Python object.

- Add missing calls to ``[super init]`` in the implementation of
  OC_PythonUnicode and OC_PythonString (the ObjC proxies for python's
  unicode and str types)

- ``objc.addConvenienceForSelector`` is deprecated, primarily to make
  it possible to restructure the pyobjc internals.

- Workaround for bug in pip that resulted in pyobjc-core not being pip
  installable.  Patch by Marc Abramowitz.

- Creating new formal protocols now uses the new runtime API that was
  introduced in OSX 10.7. Because of this it is now possible to create
  new formal protocols in 64-bit code (when running on OSX 10.7 or later)

- Codebase should work again when Python using ``--enable-unicode=ucs4``.

- BUG: Avoid crashes in calculating with NSDecimal values in Python 3

- Implement '//' operator for NSDecimal and NSDecimalNumber.

- Implement support for the ``round`` builtin in NSDecimal and
  NSDecimalNumber

- There is now limited support for packed struct definitions. This
  requires that the struct is wrapped using ``objc.createStructType``.

  Struct packing is not described in the encoding string for a
  structure, which is why special support is needed.

- objc.registerStructAlias now returns the alias type instead of ``None``

- In Python 3.x there is a new way to explicitly specify which (informal)
  protocols a class conforms to::

     class MyClass (NSObject, protocols=[Protocol1, Protocol2]):
        pass

  Python 2.x does not support this syntax, you can still use the
  following code there::

     class MyClass (NSObject, Protocol1, Protocol2):
        pass

  Note: The Python 2.x style works upto Python 3.2. In Python 3.3 and later
  the Python 2.x style declaration no longer works due to changes in the
  language.

- It is also possible to specify the protocols that a class conforms to using
  a "__pyobjc_protocols__" attribute in the class body.  This has the same
  interface as the "protocols" keyword argument in Python 3.x.

  This is primarily meant to be used by code that needs to work in Python 2
  as well as Python 3.

- Updated Python support. With this release PyObjC supports Python 2.6 and later,
  including Python 3.3 (which has a completely new representation for unicode strings)

  NOTE: Support for 3.3 is very much work in progress right now, there have
  been changes for the new unicode representation, but more changes are required.

  Known issues:

  * metadata conflict error when explictly implementing a prototype

  * one test failure w.r.t. unichar argument arrays

  Futhermore there are two refcounting test failures in both 3.2 and 3.3


- Add ``objc.setObjCPointerIsError`` and ``objc.getObjCPointerIsError``.

  By default PyObjC will create a ``PyObjCPointer`` object when it tries
  to convert a pointer it doesn't know about to Python. These values are
  fairly useless and obvious an indication that an API is wrapped improperly.

  With ``objc.setObjCPointerIsError(True)`` you can tell the bridge to
  raise an exception instead of creating these values.

- -[OC_PythonNumber compare:] calls super when the other value is
  an NSNumber and the Python value can be represented using a basic C
  type.

  This could slightly affect the results of comparing Python and
  Cocoa numbers, and avoids unbounded recursion when comparing
  Python numbers with NSDecimalNumbers on OSX 10.7 or later.

- Add implementations for methods from the NSComparisonMethods
  informal protocol to OC_PythonNumber

- Add '__cmp__' method when the Objective-C class implements the
  'compare:' selector.

- Introduced a way to compile bridgesupport data and lazily load wrappers.

  Avoid using "from Cocoa import \*" to get the most benefits from this,
  use either "import Cocoa" or "from Cocoa import NSObject".

- ``objc.initFrameworkWrapper`` is now deprecated, switch to the new
  compiled metadata code instead.

- ``objc.allocateBuffer`` now returns a bytearray on python >= 2.6,
  it used to return a buffer object in Python 2.

- ``objc.FSRef.from_pathname`` actually works instead of always raising
   a TypeError.

- ``objc.getAssociatedObject``, ``objc.setAssociatedObject`` and
  ``objc.removeAssociatedObjects`` are wrappers for the corresponding
  functions in the Objective-C runtime API.  These functions are only
  available when PyObjC was build on a system running OSX 10.6 or later,
  and the script is also running on such as system.

  The ``policy`` argument for ``objc.setAssociatedObject`` is optional and
  defaults to ``objc.OBJC_ASSOCIATION_RETAIN``.

Version 2.3
-----------

- Add some experimental code that slightly reduces the amount of
  memory used when loading bridgesupport files.

  Futher work is needed to investigate what causes the memory
  usage to increase as much as it does, sadly enough Instruments
  doesn't play nice with ``--with-pymalloc`` and for some reason
  'import Foundation' crashes with ``--without-pymalloc``.

- "<struct>" definitions in the bridgesupport files can now have
  an alias attribute containing the name of Python type that should
  be used to proxy values of this type.

  This is used in the Quartz bindings to ensure that ``CGRect``
  and ``NSRect`` (from the Foundation framework) map onto the
  same Python type.

- Added ``objc.registerStructAlias``, a helper function to add
  a type encoding that should map on an already existing struct
  type.

- Use this to ensure that ``NSRect`` and ``CGRect`` are the same
  (in the Foundation and Quartz bindings).

- This version requires Python 2.6 or later, and also supports
  Python 3.1 or later.

- BUGFIX: The generic proxy for Python objects now implements
  ``-(CFTypeID)_cfTypeID``, which should result in less hard to
  understand Objective-C exceptions.

- BUGFIX: The metadata file support now checks if the metadata is
  compatible with information gathered from the Objective-C runtime.

  This ensures that when a native method signature is incompatible
  with the signature in a metadata file the brige won't garble the
  correct information (and that in turn avoids hard crashes).

- PyObjC's support for ``NSCoding`` now also works with plain ``NSArchiver``
  instances, not just with ``NSKeyedArchiver``.

- (This item is currenlty only true for python3, need tests for python 2.x)

  NSDictionary now fully implements the dict API, except for the differences
  not below:

  * ``NSDictionary`` doesn't have the ``__missing__`` hook.

  * ``NSDictionary`` always copies keys, which gives slightly different
     semantics from Python.

  * ``NSDictionary.copy`` always returns an immutable dictionary, use
    ``NSDictionary.mutableCopy`` to get a mutable dictionary.

  * Instances of ``NSDictionary`` cannot be pickled

  ``NSDictionary`` implements one important feature that native Python
  dictionaries don't: full support for Key-Value Observations. Sadly enough
  it is not possible to support Key-Value Observation of native Python
  dictionaries without patching the interpreter.

- NSSet and NSMutableSet implement the same interface as ``frozenset`` and
  ``set``, except for the differences listed below:

  * ``NSSet.copy`` and ``NSMutableSet.copy`` always return an immutable
     object,  use the ``mutableCopy`` method to create a mutable copy.

  * Instances of ``NSSet`` cannot be pickled

  * In-place operators are not implemented, which means that ``aSet |= value``
    will assign a new object to ``aSet`` (as if you wrote ``aSet = aSet | value``.

    This is needed because the bridge cannot know if if ``aSet`` is mutable,
    let alone if ``aSet`` is a value that you are allowed to mutate by API
    contracts.

  * It is not possible to subclass ``NSSet`` and ``NSMutableSet`` in the same
    way as Python's ``set`` and ``frozenset`` classes because the Cocoa
    classes are class clusters (which means that all instances of ``NSSet``
    are actually instances of, non-necessarily public, subclasses.

  * Sadly enough ``set([1,2,3]) == NSSet([1, 2, 3])`` evaluates to False,
    even though the values are equavalent. Reversing the order of
    the test (``NSSet([1, 2, 3]) == set([1,2,3])``) results in the
    expected result.

    This is caused by the way equality tests for sets are implemented in
    CPython and is not something that can be fixed in PyObjC.

- BUGFIX: accessing methods through ``anObject.pyobjc_instancMethods`` is
  now safer, before this release this could cause unlimited recursion
  (although I'm not sure if it was possible to trigger this without
  other changes in this release).

- The PyObjC egg now includes the header files that should be used to
  compile to compile the extensions in the framework wrappers, which makes
  it a lot easier to access those headers.

- BUGFIX: The definition for Py_ARG_SIZE_T was incorrect, which causes
  problems in 64-bit code.

- Initial port to Python 3.x

  C-style 'char' characters and 'char*' strings are
  translated to/from byte strings ('str' in Python 2.x,
  'bytes' in Python 3.x). There is no automatic translation
  from Unicode strings.

  Objective-C selector names and encoded type strings are
  byte strings as well.

  NOTE: Python 3 support is pre-alpha at this time: the code compiles
  but does not pass tests yet. The code also needs to be reviewed to
  check for python3<->objc integration (dict.keys now returns a view,
  NSDictionary.keys still returns a basic iterator, ...)

  TODO:

  * Implement new style buffer support when depythonifying an array of
    C structures.

  * Documentation updates

- The Python 3.x port does not support transparent proxies for 'FILE*'
  "objects" because the ``file`` type in Python3 is not implemented on
  top of the C library stdio.

- The Python 2.x port has been enhanced to accept Unicode strings
  in more locations.

- Implement support for PEP-3118, for both Python 2.x and Python 3.x.

  This means that proxying arrays of basic C types to ObjC can now
  make use of the extended type information provided by the PEP-3118
  API.

  Furthermore it is possible to use ``memoryview`` objects with
  ``NSData`` instances, with the limitation that the memoryview *must*
  be cleaned up before the currently active autorelease pool is cleared,
  or the data instance is resized. That's a result of API restrictions
  in Apple's frameworks.

- The PyObjCTest testsuite now supports version-specific tests: for
  Python 2.x it will load modules whose name starts with 'test2\_' and for
  Python 3.x those starting with 'test3\_'. For both versions it will
  load test modules whose name starts with 'test\_' as well.

- Renamed the assertion functions in ``PyObjCTools.TestSupport``, added
  ``assertFoo`` methods and deprecated the ``failIfFoo`` and ``failUnlessFoo``
  methods (simularly to what's happening in the stdlib).

- Added ``objc.propertiesForClass``. This function returns information about
  properties for a class from the Objective-C runtime. The information does
  not include information about properties in superclasses.

- Added ``objc.object_property``. This is class behaves simularly to
  ``property``, but integrates better with Objective-C code and APIs like
  Key-Value Observation.

- Added ``objc.array_property``. This is simular to ``objc.object_property``,
  but models a list-like object and implements the right Objective-C interfaces
  for Key-Value Coding/Observations.

- Added ``objc.set_property``. This is simular to
  ``objc.object_property``, but models a set-like object and implements the
  right Objective-C interfaces for Key-Value Coding/Observations.

- Added ``objc.dict_property``. This is simular to
  ``objc.object_property``, but models a dict-like object and implements the
  right Objective-C interfaces for Key-Value Coding/Observations.

- NOTE: The interfaces of ``array_property``, ``set_property`` and ``dict_property``
  are minimal w.r.t. options for tweaking their behaviour. That will change in
  future versions of PyObjC.

  Please let us know which hooks would be usefull.

- The documentation is now written using Sphinx.

  NOTE: This is an operation in progress, the documentation needs work to be
  truly usefull.

- The (undocument) module ``PyObjCTools.DistUtilsSupport`` is no longer
  present.

- Converting a negative value to an unsigned integer now causes
  a deprecation warning, this will be a hard error once I update
  all framework wrapper metadata.


Version 2.2 (2009-11-24)
------------------------

- BUGFIX: Ensure PyObjC compiles cleanly with Python 2.6.4.

- BUGFIX: It is now possible to explicitly define ``__getitem__`` (and other
  special methods) if your class implements ``objectForKey:``::

      class MyObject (NSObject):
          def objectForKey_(self, k):
	     pass

	  def __getitem__(self, k):
	     pass

  In previous version of PyObjC the implementation of ``__getitem__`` would
  silently be replaced by a generic one.

- The default value for the ``__useKVO__`` attribute in class definitions
  can now be controlled by ``objc.setUseKVOForSetattr(b)``. The default
  is ``True``.

  Note: in previous versions the default was ``False``.

  Note2: the ``__useKVO__`` attribute is an implementation detail and should
  not be used in normal code.

  This change fixes an issue where KVO failed to detect some changes when
  those changes were done in Python using attribute access syntax.

- Wrappers for ``objc_sync_wait``, ``objc_sync_notify`` and
  ``objc_sync_notifyAll`` have been removed. These have never been part of
  the public API and this should therefore not affect existing code.

- BUGFIX: There was a refcount leak in the code that proxies native code to
  Python. This causes refcount leaks in user code when a Python class is
  instantiated from native code, when that class has an initializer written
  in Python.

  Thanks to Dirk Stoop of Made by Sofa for providing the bugreport that helped
  fix this issue.

- ``objc.recycleAutoreleasePool`` is now a no-op when a python bundle is loaded
  in an Objective-C program and the PyObjC's global release pool gets drained
  by an outer release pool. This should not affect user programs.

- BUGFIX: Storing pure python objects in a ``NSKeyedArchiver`` archive didn't
  full work for all tuples, especially self-recursive tuples.

  The current support for archiving Python objects passes all pickle unittests
  in Python 2.7.

- BUGFIX: ``+new`` is supposed to return an already retained object (that is,
  the caller owns a reference). Until now PyObjC has assumed that the return
  value of ``+new`` is an autoreleased value. The same is true for all class
  methods whose name starts with ``new``.

- There is initial support for Objective-C blocks, based on the implementation
  description in the `clang repository`__. Blocks are represented in Python
  as callable objects. This means you can pass an arbitrary callable when
  an Objective-C argument is a block, and that when your method accepts a block
  it will get passed a callable object.

  There are some limitations on the usage of blocks due to lack of introspection
  in the current implementation of blocks. This has two side-effects:

  * There must be metadata to describe the signature of blocks in PyObjC's
    metadata XML files.

  * Block metadata is not retained when a block is stored in an ObjC datastructure,
    such as an ``NSArray``, and there are no direct references to the block from
    Python.

.. __: https://llvm.org/viewvc/llvm-project/cfe/trunk/docs/Block-ABI-Apple.txt?revision=HEAD

- ``objc.inject`` is no longer support. This was code that had no real relation
  to the rest of PyObjC and was only working in 32-bit mode with little reason
  to expect that it would ever be ported to 64-bit mode.

- Move the testsuite from ``objc.test`` to ``PyObjCTest`` and no longer
  install the tests.

  The tests are no longer installed because they aren't needed for
  day-to-day usage of PyObjC. Furthermore this change will make it possible
  to copy all of the pyobjc-core "egg" into an application bundle without
  adding unnecessary files to that bundle.

- BUGFIX: Storing pure python objects in a ``NSKeydArchiver`` archive didn't
  work 100% reliably for Python floats. I've changed the implementation on
  for encoding floats a little and now floats do get rounddtripped properly.

  The side effect of this is that archives written by PyObjC 2.2b2 or later
  cannot always be read by earlier versions (but PyObjC 2.2b2 can read archives
  created with earlier versions).

- BUGFIX: Enable building from source with the Python.org binary distribution.

- BUGFIX: Fix crash when using the animotor proxy feature of CoreAnimation.
  That is, the following code now works:

  .. sourcecode:: python
     :linenos:

      app = NSApplication.sharedApplication()
      window = NSWindow.alloc().init()
      anim = window.animator()
      anim.setAlphaValue_(1.0)


- Improve handling of non-methods in objc.Category:

  * The docstring of a category is now ignored

  * You'll get an explict error exception when trying to add and ``ivar`` to
    a class

  * It's now possible to add class attributes in a category:

    .. sourcecode:: python
       :linenos:

          class NSObject (objc.Category(NSObject)):
              aClassDefault = [ 1, 2, 3 ]

              @classmethod
              def getDefault(cls):
                  return cls.aClassDefault



- Fixed support for ``FSRef`` and ``FSSpec`` structures.

  * Transparently convert ``Carbon.File.FSRef`` and ``Carbon.File.FSSpec``
    instances to C.

  * The types ``objc.FSRef`` and ``objc.FSSpec`` are the native
    PyObjC representation for ``FSRef`` and ``FSSpec`` structures.

- Added more magic signature heuristics: the delegate selector for
  sheets is now automaticly recognized, removing the need for
  the decorator ``AppHelper.didEndSelector`` (which will stay present
  for backward compatibility).

  FIXME: Do the same thing for ``objc.accessor``. Both are a frequent
  source for errors.

- Added ``PyObjC.TestSupport``. This is an unsupported module containing
  useful functionality for testing PyObjC itself.

- Added ``free_result`` attribute to the ``retval`` element in metadata
  files. When this attribute has value ``'true'`` the return value of the
  C function (or ObjC-method) will be free-ed using the function ``free()``,
  otherwise the bridge assumes other code is reponsible to free the result.

  This is to be used for low-level C API's that return a pointer to a
  dynamicly allocated array that is to be free-ed by the caller. One example
  is the function ``DHCPClientPreferencesCopyApplicationOptions`` in the
  SystemConfiguration framework.

- Added ``objc.context``, which is helpfull for dealing with "context"
  arguments as used by several Cocoa APIs. The context argument must be
  a number in Python, while you'd prefer to pass in an arbitrary object
  instead. The ``objc.context`` registry allows you to get a context
  integer for an arbitrary Python object, and retrieve that later on.

  To get the context integer for a Python object:

  .. sourcecode:: python

        ctx = objc.context.register(myValue)

  To unregister the object when you no longer need the context integer:

  .. sourcecode:: python

        objc.context.unregister(myValue)

  To retrieve the Python object given a context integer:

  .. sourcecode:: python

        myValue = objc.context.get(ctx)


  NOTE: This API is particularly handy when using Key-Value Observing, where
  the context number should be a unique value to make ensure that KVO usage
  by the superclass doesn't get confused with your own usage of KVO.

- PyObjC can now run in 64-bit mode.

  NOTE: 64-bit support is beta quality, that is: all unittests pass, but I
  haven't tried running real programs yet and hence there might be issues
  lurking below the surface.

  NOTE: 64-bit support does not yet work on PPC due to a bug in libffi which
  prefents catching Objective-C exceptions.

  This requires Leopard (OSX 10.5), earlier version of the OS don't have a
  64-bit Objective-C runtime at all.  This currently also requires a copy of
  python that was build with ``MACOSX_DEPLOYMENT_TARGET=10.5``.

  Note that class posing (the ``poseAsClass_`` class method) is not supported
  in 64-bit mode. It is also not possible to create new protocols in 64-bit
  code. Neither are supported by the 64-bit runtime APIs (that is, it is a
  restriction in Apple's Objective-C 2.0 runtime).

- There now is a custom proxy class for instances of ``datetime.date`` and
  ``datetime.datetime``, which takes away the need to manually convert these
  instances before using them from Objective-C (such as using an
  ``NSDateFormatter``)

- Objective-C classes that support the ``NSCopying`` protocol can now be
  copied using ``copy.copy`` as well.

..
   it would be nice to have the following, but that's not easy to achieve::
	- Objective-C classes that support the ``NSCoding`` protocol can now be
	  copied using ``copy.deepcopy``.

- ``OC_PythonArray`` and ``OC_PythonDictionary`` now explicitly implement
  ``copyWithZone:`` and ``mutableCopyWithZone:``, copies will now be
  Python objects instead of regular ``NSDictionary`` instances.

- Pure Python objects now support the ``NSCopying`` protocol.

- A new decorator: ``objc.namedselector`` for overriding the Objective-C
  selector. Usage:

  .. sourcecode:: python
     :linenos:

     class MyObject (NSObject):

         @objc.namedselector("foo:bar:")
         def foobar(self, foo, bar):
             pass

- A number of new type signature values were added. These are not present
  in the Objective-C runtime, but are used to more precisely describe the
  type of some arguments.

  The new values are:

  * ``_C_UNICHAR``:   A "UniChar" value in Objective-C

  * ``_C_NSBOOL``:    A "BOOL" value in Objective-C

  * ``_C_CHAR_AS_INT``: A "char" in Objective-C that is used as a number

  * ``_C_CHAR_AS_TEXT``: A "char" in Objective-C that is used as a character

  PyObjC will automaticly translate these values into the correct Objective-C
  type encoding when communicating with the Objective-C runtime, making this
  change transparent to anyone but Python users.

  NOTE: ``_C_CHR`` is of course still supported, with the same semi-schizofrenic
  behaviour as always.

  NOTE2: The non-standard metadata extensions we used before to indicate
  that a C short is used as a unicode string are no longer supported.

- Output arguments are no longer optional. They must be specified both in
  method implementations and method calls. In PyObjC 2.0 they were optional,
  but raised a deprecation warning, for backward compatiblity with PyObjC 1.x.

  The backward compatibility code was removed because it made code more
  complicated and actually caused some bugs.

- In PyObjC 1.x you could redefine an Objective-C class, as long as you
  redefined it in the same module (such as by reloading a module). That
  functionality didn't work in PyObjC 2.0 and is now completely removed
  because the functionality isn't supported by the Objective-C 2.0 runtime.

- Adds custom wrappers for some more Python types:

  * ``OC_PythonNumber``: wraps python numeric types

    This is used instead of ``NSNumber`` because we might loose information
    otherwise (such as when using custom subclasses of ``int``).

  * ``OC_PythonSet``: wraps a python set and is a subclass of ``NSMutableSet``

- BUGFIX: ``OC_PythonEnumerator`` now actually works.

- BUGFIX: using the ``@throw`` syntax one can raise arbitrary objects as
  exceptions (not just instances of NSException) in Objective-C. All
  instances of NSObject are now converted to Python exceptions, throwing
  some other object (such as a C++ exception) will still case a fatal
  error due to an uncaught exception.

  (SF Bug: 1741095)

- BUGFIX: ``repr(CoreFoundation.kCFAllocatorUseContext)`` now works

  (SF Bug: 1827746)

- BUGFIX: The wrappers for CoreFoundation types no longer create a new type
  in the Objective-C runtime, that type wasn't used anywhere and was an
  unwanted side-effect of how CoreFoundation types are wrapped.

- BUGFIX: The docstring for newly defined methods is no longer hidden
  by PyObjC. That is, given this code:

  .. sourcecode:: python
     :linenos:

  	class MyObject (NSObject):
	    def doit(self):
	        "do something"
		return 1 + 2

  ``MyObject.doit.__doc__`` now evaluates to ``"do something"``, in previous
  versions of PyObjC the docstring was ``None``.

- BUGFIX: Fixed calling and implementation methods where one or more
  of the arguments are defined as arrays, like this:

  .. sourcecode:: objective-c

  	-(void)fooCallback:(NSRect[4])rects;

  There were various issues that caused these to not work correctly in
  all earlier versions of PyObjC (which wasn't noticed earlier because
  Apple's frameworks don't use this construction).

- BUGFIX: correctly select the native implementation of the compatiblity
  routines for the ObjC 2.0 runtime API when running on 10.5 (when compiled
  for OSX 10.3 or later).

- BUGFIX: fix a number of compatibility routines (ObjC 2.0 runtime API
  on OSX 10.4 or earlier).

Version 2.0.1 (included with OSX 10.5.2)
----------------------------------------

- BUGFIX: ``objc.inject`` works on Leopard (at least on Intel Macs, haven't
  tested on PPC).

- BUGFIX: don't crash when printing CF objects that are magic cookies.

- BUGFIX: It is now possible to override ``respondsToSelector:`` in Python.

- Add support for interacting with '@synchronized' blocks in Objective-C.

  The function ``object_lock(object)`` is a contextmanager that acquires and
  releases the '@synchronized' mutex for an object, and can also be used
  manually.

  That is (as context manager):

  .. sourcecode:: python
     :linenos:

  	from __future__ import with_statement

	obj = NSObject.new()

	with objc.object_lock(obj):
	   # Perform work while owning the @synchronize lock
	   pass

  or (manually):

  .. sourcecode:: python
     :linenos:

   	obj = NSObject.new()
	mutex = objc.object_lock(obj)
	mutex.lock()
	try:
	    # Perform work while owning the @synchronized lock
	    pass
	finally:
	    mutex.unlock()

  Note that the first version is slightly saver (see the documentation
  for with-statements for the details).

Version 2.0 (MacOS X 10.5.0)
----------------------------

- The basic infrastructure for playing nice in a GC host was added.

  This doesn't mean that PyObjC now actually plays nice with the ObjC
  garbage collector, some more development and much more testing is
  needed for that.

  Even so, the end result is about as good as we have without GC,
  programs won't make optimal use of GC because that would require
  surgery on the Python interpreter itself.

- The metadata returned by the ``__metadata__`` method is slightly changed
  to make it more compatible with the XML files.

- Some of the older metadata attributes, such as ``isAlloc`` and
  ``doesDonateRef`` were dropped. ``isAlloc`` isn't needed for anything but
  a number of now hardcoded methods (``+alloc`` and ``+allocWithZone:``),
  ``doesDonateRef`` is available through the new metadata mechanism.

- Fix a memory leak in the code that creates the python representation for
  method lists.

- Speed up framework loading due to three changes:

  1. Don't rescan the list of classes unless the framework actually defines
     new classes.

  2. The metadata loader now implemented in C.

  3. CF wrapper types (e.g. CGContextRef) no longer have methods
     corresponding to global functions, the speed-hit for calculating
     these is too large.

- It is now conveniently possible to create instance variables with
  a specific type (e.g. without manually making up a encoded type
  string):

  .. sourcecode:: python
     :linenos:

      class MyObject (NSObject):
          bounds = objc.ivar.NSRect()
          done = objc.ivar.bool()

- Objective-C metaclasses are modelled as Python metaclasses.  This brings
  a major improvement: class methods "just work"(TM):

  .. sourcecode:: python
     :linenos:

     o = NSObject.alloc().init()
     o.description()

     NSObject.description()

  In earlier versions of PyObjC the second call would fail because
  ``NSObject.description`` referred to an unbound instance-method instead of
  to the class method.

  This change should require little or change to existing code. There's only
  two types of code where the new behaviour is incompatible:

  1) Code that introspects the class dictionary to see what methods are
     available. These will no longer see class methods, but will have to look
     at the metaclass as well. This affects ``pydoc(1)`` as well.

  2) Code that uses unbound instance methods will no pick up class methods
     in some occasions. Use ``MyClass.instanceMethodForSelector_`` instead of
     unbound methods, or alternatively access instance methods through
     ``MyClass.pyobjc_instanceMethods``.

  3) Due to a limitation in the implementation of python's ``super`` class[1]
     it is not possible to use the super machinery to resolve class methods.

     However, ``from Foundation import *`` will replace the builtin ``super``
     by a subclass that does work correctly for PyObjC programs, therefore
     this doesn't affect most PyObjC-using programs.


.. [1] It is not possible to override the way ``super`` looks for the "next"
   method to call. The class ``objc.super`` is a subclass of the builtin
   superclass with a ``__getattr__`` implementation that does the right thing
   for supercalls for Objective-C class methods.

- It is now easily possible to tell PyObjC that a Python type should be
  treated like a builtin sequence type:

  .. sourcecode:: python
     :linenos:

  	import UserList, objc

	class MyClass (UserList.UserList):
	    pass

	objc.registerListType(MyClass)

- And likewise for mapping types using ``objc.registerMappingType``.

- ``objc.enableThreading()`` is gone. It was introduced in ancient times to
  enable threading in the Python runtime but has been a no-op for ages because
  the PyObjC enables threading by default now.

- The unittests can now use the leaks(1) command to check for memory leaks. This
  slows testing down significantly and is therefore off by default. Enable by
  setting ``PYOBJC_WITH_LEAKS`` to a value in the shell environment before running
  the tests:

  .. sourcecode:: sh

       $ PYOBJC_WITH_LEAKS=1 python setup.py test

   NOTE: the actual value is ignored, as long as there is a value.

- (BUGFIX): PyObjC was leaking memory when doing scans of the Objective-C method tables

- (BUGFIX): The code below now raises an error, as it should have done in previous versions but never
  did:

  .. sourcecode:: python
     :linenos:

       class MyObject (object):
           def updateDescription(self):
               self.description = 42


- PyObjC has been split into several smaller packages: ``pyobjc-core`` contains
  the core bridge and frameworks are wrapped as seperate setuptools packages.

- Objective-C objects now have an implicit attribute named ``_`` which can
  be used a shortcut for Key-Value-Coding.

  The code fragment below:

  .. sourcecode:: python
     :linenos:

  	o = <Some Objective-C Object>
	print o._.myKey
	o._.myKey = 44

  is equivalent to:

  .. sourcecode:: python
     :linenos:

	print o.valueForKey_('myKey')
	o.setValue_forKey_(44, 'myKey')

  The former is much nicer to use.

- Struct wrappers now have a ``copy`` method. This method tries to do the right
  thing when subfields are other struct wrappers (that is, deep-copy them).

- The metadata system has been revamped and mostly removes the need to write
  C-code when wrapping frameworks (that includes most of the AppKit and
  Foundation wrappers as well). The metadata is loaded at runtime from
  an XML file, whose format is shared between PyObjC and RubyCocoa.

  ``objc.initFrameworkWrapper`` can be used to load a framework using
  these XML metadata files.

  Note: because we now use an XML metadata file the scripts in
  ``Scripts/CodeGenerators`` have been removed: they are no longer needed. Have
  a look at the project ``pyobjc-metadata`` if you want to generate your own
  metadata.

  Note2: the metadata format is shared with RubyCocoa, although there are
  currently some slight differences (that is, the PyObjC metadata is slightly
  richer).

- PyObjC now has builtin support for CoreFoundation-based types, which is
  used by the new metadata file support.  Note that doesn't mean we support
  all of CoreFoundation and other CF-based frameworks, just that the machinery
  that's needed for that is present and working.

  This is a backward incompatible change: CF-based types will now be proxied
  using PyObjC-owned types instead of the ones in MacPython.  However, PyObjC
  will still convert MacPython CF-wrappers to the right native type.

  Another backward compatible change: ``registerCFSignature`` has a different
  signature:

  .. sourcecode:: python

      registerCFSignature(name, encoding, typeId [, tollfreeName]) -> type

  This is needed to capture all information about CF types.

- This version introduces generic support for callback functions. The metadata
  metioned before contains information about the signature for callback
  functions, the decorator ``callbackFor`` converts a plain function to
  one that can be used as a callback:

  .. sourcecode:: python
     :linenos:

  	@objc.callbackFor(NSArray.sortedArrayUsingFunction_andContext_)
	def compare(left, right, context):
	    if left.key < right.key:
	        return NSOrderedAscending
	    elif left.key > right.key:
	        return NSOrderedDescending
   	    else:
	        return NSOrderedSame

  The ``makeCallbackFor`` callback should be used for callbacks where the
  callable is stored by the called function and is optional otherwise (such
  as the example above).

- The decorator ``selectorFor`` can be used to ensure that a method has the
  right signature to be used as the callback method for a specific method.

  Usage:

  .. sourcecode:: python

 	@objc.selectorFor(NSApplication.beginSheet_modalForWindow_modalDelegate_didEndSelector_contextInfo_)
	def sheetDidEnd_returnCode_contextInfo_(self, sheet, returnCode, info):
	    pass

- PyObjC compiled on Leopard uses the Objective-C 2.0 runtime.

  The compiler on 10.5 still gives warning about usage of deprecated APIs unless
  compiling for 10.5 or later because of a compatibility layer.

- GNUstep support has been removed because this has never worked properly,
  nobody seems interested in fixing that and the internal APIs of PyObjC have
  changed greatly.

- Output arguments are treated slightly different. In previous versions you
  were not allowed to pass values for output arguments.

  This is now deprecated behaviour, you should choose to suply values for all
  arguments including output arguments (mixing these two styles is not
  allowed, if you have two output argument you must either supply a value for
  both of them or neither).

  There are only two acceptable values for output argument:

  * ``None``: pass a non-NULL pointer to the objc function/method

  * ``objc.NULL``: pass a NULL pointer to the objc method.

  The already existing behaviour is the same as passing in ``None`` for all
  output arguments.

  This is most useful for supressing an ``NSError`` value for methods that
  have an ``NSError**`` argument (when you don't want to look at that value),
  because generating that object might be expensive.

- ``objc.setSignature`` is deprecated, use the new metadata machinery instead.

- Opaque types (such as NSZonePointer) are now mutable, which is mostly present
  to allow framework wrappers to provide a nice OO interface to those types
  instead of forcing users to use the procedural API.

  None of the current framework wrappers use this feature.

- Several new methods were added to improve integration with a future version
  of MacPython: opaque pointer types and ``NSObject`` now have a method
  named ``__cobject__`` that returns a ``PyCObject`` which represents the
  proxied value. Furthermore both opaque pointer types and subclasses of
  ``NSObject`` are now callable and will create the proper proxy object when
  passed a ``PyCObject``. Note however than the caller is responsible to ensure
  that the ``PyCObject`` value represents a value of the right type.

- Archiving pure python objects using ``NSArchiver`` was already unsupported,
  we now explicitly raise an exception when users try to do this anyway. It
  is supported to archive and retrieve simple values: instances of ``int``,
  ``long``, ``float``, ``str`` and ``unicode``.

- A ``__del__`` or ``dealloc`` method can revive objects, which isn't really
  supported by Objective-C. We'll now warn about this, hopefully before the
  program crashes. The warning is ``objc.RevivedObjectiveCObjectWarning``.

- Some functions and methods return an instance of ``objc.varlist``. These
  objects behave a little like tuples, but don't have a defined lenght, you
  are responsible to not peak beyond the end of the actual array.

  The best way to deal with these objects is to convert them to real tuples
  as soon as possbible (using the ``as_tuple`` method). The number of elements
  in that tuple should be known to you and depends on the API.

  These objects are used in places where objects return an array but the
  size of that array cannot be described using the bridge metadata. These
  are mostly arrays whose size depends on the state of an object, or whose
  size is a function of one or more arguments of the method.

- There now is a public API for adding new "convenience methods", that is
  methods that emulate standard Python methods using Objective-C methods.

  There are two functions for adding new convenience methods:

  * ``addConvenienceForSelector`` adds a list of methods to a class when that
    class has the specified selector:

  .. sourcecode:: python

       addConvenienceForSelector('hash', [
       		('__hash__', lambda self: self.hash()),
	])

  * ``addConvenienceForClass`` adds a list of methods to the class with the
     specified name:

  .. sourcecode:: python

       addConvenienceForSelector('NSObject', [
       		('dummy', lambda self: 42 ),
	])

  In both cases the addition is done lazily, the class that will be changed
  need not be loaded at the time of the call.

- Fix a long-standing race condition where one could end up with a reference
  to an already deallocated Objective-C object when the last ObjC reference
  goes away on one thread and is just "recreated" on a second thread.

- The 'name' and 'reason' of an Objective-C exception are now represented as
  Unicode objects in the Python representation of the exception, instead of
  as a UTF-8 encoded string.

  The standard Python exception message is still a UTF-8 encoded string,
  that's needed to ensure that we can always print the value of the exception
  message (such as in tracebacks).

Version 1.4.1 (2006)
--------------------

- PyObjC now uses setuptools. Setuptools support is fairly minimal at the
  moment, we expect to move more of the build infrastructure to setuptools and
  to split PyObjC into smaller eggs.

- Fix an issue that made is possible to create weakref's to subclasses of
  subclasses of Objective-C classes. This was unintentional behaviour, the
  weakref is to the proxy (see the news for 1.0b1 for more details).

- Add RoundTransparentWindow and DragItemAround examples in ``Examples/AppKit``.

  Both are ports of Objective-C examples at ADC and were provided by
  ytrewq1.

- Fix issue where programs would crash with an badly aligned C-stack on
  some problems. This issue only affected Intel systems.

- Remove ``OC_PythonObject.pythonifyStructTable``. This method of wrapping
  structs was untested and not used in the core distribution. Use
  ``objc.createStructType`` instead.

- Binaries build on 10.4 also work on 10.3. This means it is no longer
  necessary to build PyObjC on the lowest version of the OS that you want
  to run your binaries on.  Doing this with python is somewhat of a black
  art, please test your applications on the lowest version of the OS that
  you want to support to make sure that this actually works.

Version 1.4 (2006-06-14)
--------------------------

- Classes whose name starts with and underscore are no longer imported when
  using ``objc.loadBundle``. They are still available using
  ``objc.lookUpClass``.

  Methods whose name starts with an underscore are no longer visible when
  introspecting using ``dir()``, but can still be called.

  These changes were done to make introspection slightly more user-friendly:
  anything that is now hidden from introspection is most likely not part of
  a public API.

- Most of the libffi testsuite is now run using a module that emulates
  dejagnu.

- Introduction of a GUI tool to manage custom method signatures
  (``Tools/Signatures``). This replaces the ``find-raw-pointers.py`` script.

- Fixed memory leak in ``OC_PythonObject``, this was due to bad reference
  counting.

- ``NSMutableArray.sort`` now has the same API as ``list.sort``. Due to
  implementation constraints the ``key`` argument results in slower sorting
  than you'd see with ``list.sort``.

- Selectors now have a read-only property 'native_signature' that contains
  the untampered signature for the method. This is for use by tools.

- 'void*' arguments are treated like unsigned integers, they are almost always
  opaque cookies.

- ``FILE*`` arguments are recognized and mostly work correctly. We can't
  reliably detect if the file was opened in append mode though.

- Make it possible to override the KVO methods, like ``setValue:forKey:`` and
  ``valueForKey:`` in Python for all levels in the inheritance hierarchie.

- Fix issues with reference counts for ``__slots__``.

- Experimental: use ``-autorelease`` instead of ``-release`` to release
  values in destructors. This seems to solve at least one memory managment
  issue.

- A slight complication in the naming rule:

  1) Don't translate leading underscores in Python to colons in Objective-C,
     ``_doFoo_andBar_`` in Python will be ``_doFoo:andBar:`` in Objective-C.

  2) If a name starts and ends with double underscores don't modify the
     name at all when moving from Python to Objective-C,
     ``__foobar__`` in Python will stay that way in Objective-C.

  These changes fix some minor annoyances with the older scheme. Note that
  the translation from Objective-C to Python is unmodified and is entirely
  consistent with the modified rules for translating from Python to Objective-C.

- Fix for a memory leak in ``__pyobjc_object__`` handling.

Version 1.3.7 (2005-07-06)
--------------------------

- Added wrappers for embedded DiscRecording frameworks
  ([ 1224188 ] Fix for DiscRecording framework)

- Probably working Xcode 2.1 support (for converted Xcode 2.0 projects)

- Hide List, Object, and Protocol classes from objc.loadBundle
  to prevent confusion with Python code.  They can still be looked
  up with objc.lookUpClass.

- Fixed a regression where type signatures for pointers weren't
  normalized (fixes uses of NSModalSession, etc.)

- Fixed a bug with -[NSObject hash] to __hash__, there was a mismatch
  between integer types.

- Removed traces of the old Project Builder and Xcode templates in the
  examples and Foundation initialization code (PYOBJCFRAMEWORKS).

- Fixed a problem with reference counting in initializers.

- New TinyURLService example in AppKit that demonstrates how to write
  a service that transforms URLs into their tinyurl.com equivalents.

- 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.

- Support a number of new frameworks:

  * SenTestingKit

    TODO: this framework uses lots of macros (such as STAssertEquals), these
    have not yet been wrapped/converted.

  * SecurityFoundation


Version 1.3.6 (2005-05-19)
--------------------------

- Fixed bugs in the ProgressViewPalette example

- Fixed a bug in the class builder that caused most plugins to break

- Removed all references to Project Builder

- Mac OS X 10.2 (Jaguar) no longer supported

Version 1.3.5 (2005-05-18)
--------------------------

- Importing objc now ensures that Foundation is multi-threaded, previously
  it only ensured that Python was.

- New ``objc.RegisterCFSignature`` used to register ``CFTypeRef``-like
  signatures with the runtime.

- ``PyObjCTools.Conversion`` functions now support all property list
  types with the following conversions:

  - NSData <-> buffer
  - NSDecimalNumber <-> decimal.Decimal (if present)
  - NSDate <-> datetime.datetime

  New ``toPythonDecimal``, ``fromPythonDecimal`` functions which convert
  between NSDecimalNumber and decimal.Decimal using an intermediate string.

  New ``serializePropertyList`` and ``deserializePropertyList`` functions
  which serialize (Objective-C) property lists to and from NSData.

- ``OC_PythonObject``, 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
  ``-isEqual:``, ``-hash``, and ``-compare:``).  This allows them
  to work with Key-Value Coding if they are contained by an Objective-C
  object, among other things.

- New objc.signature decorator that allows easier specification of
  objc.selector wrappers for functions when using Python 2.4:

  .. sourcecode:: python

     @objc.signature('i@:if')
     def methodWithX_andY_(self, x, y):
         return 0

- ``PyObjCTools.KeyValueCoding.getKeyPath`` now supports all of the
  Array Operators supported by Mac OS X 10.4.

- 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.

- The formal protocol list is now complete.  A new internal function,
  ``objc.protocolsForProcess()`` 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.

- A special value, ``objc.NULL``, 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.

- Some of the new Tiger frameworks now have wrappers:

  - ``AppleScriptKit``
  - ``Automator``
  - ``CoreData``
  - ``DiscRecording``
  - ``DiscRecordingUI``
  - ``OSAKit``
  - ``Quartz``
  - ``QTKit``
  - ``SyncServices``
  - ``XgridFoundation``

  Documentation and tests not yet written.

- New ``OutlineEditor`` example in ``Examples/CoreData``,
  it is a Python version of the identically named Apple example.

- The last argument of selectors that end with ':error:' is now
  assumed to be 'out' if its type is an object pointer.

- More conveniences for ``list``-like and ``dict``-like
  objects: ``__reversed__``, ``reverse``, ``pop``,
  ``remove``, ``fromkeys``.

- ``OC_PythonDictionary`` and ``OC_PythonArray`` now return
  ``NSNull`` to Objective-C callers as appropriate.

- New ``WebKitInterpreter`` example in ``Examples/Plugins``.
  Uses the new WebKit Cocoa plugin API available in Safari 1.3
  and later to embed a PyInterpreter in the browser.

- Fixed a ``CFBundleRef`` reference counting bug in
  ``Foundation._Foundation``.  The symptom of this is usually
  a crashing application after having loaded a PyObjC-based
  plugin into an otherwise Objective-C app.

- New ``PyObjCTools.AppHelper`` functions: ``callAfter`` and
  ``callLater``, conveniences for calling Python functions on
  the main thread as soon as possible, or after a delay.

- Twisted examples changed to use ``threadedselectreactor``
  instead of ``cfreactor``.  ``cfreactor`` is deprecated.
  Needs Twisted newer than 2.0 (svn r13575 or later).

- ``objc.inject`` now injects on main thread by default,
  and takes an optional third ``useMainThread`` argument
  to change this behavior.  This is a complete rewrite
  which should be correct, stable, Tiger compatible,
  and synchronized with mach_* 1.1.

- Removed an ``NSAutoreleasePool`` category hack that has
  been deprecated for quite some time.

- New ``objc.removeAutoreleasePool`` function that will remove
  PyObjC's global ``NSAutoreleasePool``, which may be useful
  for plugins.

- Fixed bug in the ``NSBundle`` hack that caused a ``NULL``
  pointer dereference if looking up a non-existent class using
  ``NSBundle`` API.

- Added ``OC_PythonUnicode`` and ``OC_PythonString`` classes that
  preserve the identity of ``str`` and ``unicode`` objects across
  the bridge.  The bridge for ``str`` now uses the default
  encoding of ``NSString``, rather than ``sys.getdefaultencoding()``
  from Python.  For Mac OS X, this is typically MacRoman.  The reason
  for this is that not all Python ``str`` instances could cross the
  bridge at all previously.  ``objc.setStrBridgeEnabled(False)`` 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.

- New Xcode project template "PyObjC Mixed Application" that is
  a py2app based Python application that loads an Objective-C
  plug-in built as a separate target.

- New py2app based Xcode templates "PyObjC Application" and
  "PyObjC Document-based Application", these replace the
  older "Cocoa-Python Application" and
  "Cocoa-Python Document-based Application" respectively.

- New ``InjectBrowser`` example in ``Examples/Inject`` that demonstrates
  injection of the ``ClassBrowser`` example into another application using
  ``objc.inject``.

- ``NSData`` and ``NSMutableData`` instances now support the Python buffer
  protocol.

- ``NSData`` instances now support a convenience API that allow them to
  act like a ``buffer`` instance for ``str()`` and slicing.

- Objects that support the Python buffer protocol, such as ``buffer`` and
  ``array.array`` (but not ``str`` or ``unicode``) are now bridged as
  ``NSData`` subclasses.

Version 1.3 (2005-03-31)
------------------------

- New ``objc.pyobjc_id`` function that returns a the id of the underlying
  NSObject as an integer.  (Python wrapper objects are often made on the
  fly, meaning ``id(obj)`` is not constant during the lifetime of the
  object.)

- 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.

  Exceptions: ``NSString`` and ``NSNumber`` 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
  "value proxies" for a single Objective-C object.

  Any Python object that is proxied using the ``__pyobjc_object__``
  interface will only get a unique proxy if the ``__pyobjc_object__``
  method implements that feature.

- New ``objc.protocolsForClass`` function that returns a list of protocols
  that the class directly claims to conform to.

- PyObjC classes can now declare that they implement formal protocols,
  for example:

  .. sourcecode:: python

     class MyLockingClass(NSObject, objc.protocolNamed('NSLocking')):
         # implementation
         pass

  It is also possible to define new protocols:

  .. sourcecode:: python

       MyProtocol = objc.formal_protocol("MyProtocol", None, [
       	selector(None, selector='mymethod', signature='v@:'),
       ])

  All formal protocols are instances of ``objc.formal_protocol``.

- PyObjCTools.KeyValueCoding has a new ``kvc`` class that allows
  Pythonic Key-Value Coding.

  - ``__getitem__`` is mapped to ``valueForKeyPath:``
  - ``__setitem__`` is mapped to ``setValue:forKeyPath:``
  - ``__getattr__`` is mapped to ``valueForKey:``
  - ``__setattr__`` is mapped to ``setValue:forKey:``

  The ``kvc`` class uses ``__pyobjc_object__``, so it may cross the bridge
  as the wrapped object.

- ``NSNumber`` instances are bridged to a ``float``, ``long``, or ``int``
  subclass that uses ``__pyobjc_object__``.
  ``NSDecimal`` is converted to ``NSDecimalNumber`` when used as an object,
  ``NSDecimalNumber`` is not bridged to ``NSDecimal`` because the latter is
  a mutable type.

- The Python to Objective-C bridge now looks for a ``__pyobjc_object__``
  attribute to get a PyObjC object from a Python object.

- New IDNSnitch example in Inject that demonstrates how to write an
  monitor for the launch of another application,
  use ``objc.inject`` 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).

- ``objc.IMP`` should do the right thing now.  This type is returned
  by ``+[NSObject methodForSelector:]`` and
  ``+[NSObject instanceMethodForSelector:]``

- 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
  "Cocoa Bindings Examples and Hints", converted to PyObjC by u.fiedler.

- New Bookmarks example in CocoaBindings that demonstrates how to
  subclass ``NSArrayController`` to implement the ``NSTableView``
  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
  "Cocoa Bindings Examples and Hints", converted to PyObjC by u.fiedler.

- New FilteringController example in CocoaBindings that demonstrates
  how to subclass ``NSArrayController`` to implement filtering
  of a ``NSTableView``.  Also demonstrates the use of indexed accessors.
  Originally from "Cocoa Bindings Examples and Hints", converted to PyObjC
  by u.fiedler.

- New ControlledPreferences example in CocoaBindings that demonstrates
  how to use Cocoa Bindings to simplify storing and retrieving user
  preferences.  Originally from "Cocoa Bindings Examples and Hints",
  converted to PyObjC by u.fiedler.

- New TemperatureTransformer example in CocoaBindings that demonstrates
  how to use NSValueTransfomers with PyObjC.  Based on Apple's
  "Cocoa: Value Transformers" documentation, converted to PyObjC
  by u.fiedler.

- 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
  "Introduction to Developing Cocoa Applications Using Bindings".

- New ManualBindings example in CocoaBindings that demonstrates how
  to develop programmatic bindings from a PyObjC application.
  Converted to PyObjC by u.fiedler from the "Cocoa Bindings and Hints"
  example of the same name.

- 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.

- Key-Value Observing support is now automatic in Python classes that
  descend from ``NSObject``, unless they implement a custom
  ``willChangeValueForKey:``, ``didChangeValueForKey:``, or
  ``__useKVO__`` is not True.  This allows ``self.foo = 1`` to
  automatically trigger notifications.  This works in all cases,
  whether ``foo`` is a ``property``, ``ivar``, or just in the
  ``__dict__``.

- New Inject folder in Examples, with an InjectInterpreter
  example that will inject a GUI Python interpreter into any process.

- New ``objc.inject()`` function for Mac OS X 10.3 and later,
  allows an arbitrary bundle to be loaded into another process
  using mach_inject.

- ``objc.classAddMethods`` now recognizes and supports
  classmethods.

- GC is now correctly implemented for struct wrappers.

- The ``NSNumber`` bridge has been removed, now you will get
  ``NSNumber`` instances across the bridge instead of a
  Python representation.

- ``PyObjCTools.AppHelper.runEventLoop()`` will now bring your
  application to the front at startup when using pdb
  mode for convenience.

- ``objc.loadBundle()`` no longer filters the class list.  This
  solves a few potential issues and shaves off about 1/3rd of
  the overhead of ``python -c "import AppKit"``.

- ``PyObjCTools.AppHelper.runEventLoop()`` 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.

- ``PyObjCTools.AppHelper.runEventLoop()`` now installs the
  interrupt handler and verbose exception logging when using pdb,
  either explicitly or by the USE_PDB environment variable.

- There is now a fast path for the ``NSString``/``unicode``
  bridge when ``Py_UNICODE_SIZE`` is 2.  This is the default
  setting for Python.

- The default selector signature will have a void return value
  unless a "return" statement with an argument is used in the
  bytecode.  In that case, it will default to an object return
  value.

- ``__bundle_hack__`` is no longer necessary, py2app now sets
  a different environment variable to the current plugin during
  execution, and a hack is installed to ``NSBundle`` so that classes
  may respond to requests for their bundle with the ``+bundleForClass``
  method.  The class builder adds a default implementation of this to
  Python classes if this environment variable is set.

- Added ``objc.currentBundle()``, which is equivalent to
  ``NSBundle.mainBundle()`` except after loading a plug-in.
  Makes it easier to load nib files.

- ``PyObjCTools.NibClassBuilder.extractClasses()`` now uses
  ``objc.currentBundle()`` instead of ``NSBundle.mainBundle()``.  This
  makes plugins less of a hassle to develop and allows identical code
  to be used for application or plugin development.

- ``objc.registerPlugin()`` and ``objc.pluginBundle()`` are now deprecated
  as they are no longer useful.

- It is now possible to subclass a class that implements ``copyWithZone:``
  without setting ``__slots__`` to ``()``.

- It is now possible to override ``dealloc``. It is still possible to
  define ``__del__``.

- As an experimental feature it is also possible to override ``retain`` and
  ``release``. Note it almost never a good idea to do this (even when you're
  programming in Objective-C and much more so in Python).

- ``poseAsClass:`` can be used, although it is not very useful in python, use
  categories instead.

  A major issue with ``poseAsClass:`` is that existing references to the old
  version of the class won't be changed to point to the new class.

- It is now possible to access all instance variables of a class using
  the functions ``objc.listInstanceVariables(aClassOrInstance)``,
  ``objc.getInstanceVariable(obj, name)`` and
  ``objc.setInstanceVariable(obj, name, value [, updateRefCount])``.

  The last argument of ``setInstanceVariable`` is required when the instance
  variable is an object. If it is true the bridge will update reference counts,
  otherwise it won't.

- All wrappers for opaque pointers (such as ``NSZone*``) 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 ``__typestr__``
  attribute on the type object, this contains the encoded Objective-C type
  of the pointer.

  A function for creating new wrappers is exposed to python, as
  ``objc.createOpaquePointerType(name, typestr, doc)``.  The same function is
  also exposed in the C-API.

- Wrappers for C-structs how have a ``__typestr__`` attribute on their type.
  This attribute contains the encoded Objective-C type of the struct.

  The default ``__init__`` for struct-wrappers now initializes fields with an
  appropriate default value, instead of ``None``.

  New wrappers can now be created from Python using the function
  ``objc.createStructType(name, typestr, fieldnames, doc)``. The same
  function is also exposed in the C API (and has been for a while).

Version 1.2 (2004-12-29)
------------------------

- ``PyObjCTools.AppHelper.stopEventLoop`` will attempt to stop the current
  ``NSRunLoop`` (if started by ``runConsoleEventLoop``) or terminate the
  current ``NSApplication`` (which may or may not have been started by
  ``runEventLoop``).

- This version no longer support Python 2.2. Python 2.3 or later is
  required.

- It is now possible to use ``reload`` on modules containing Objective-C
  classes.

- ``objc.loadBundle`` now returns bundle we just loaded.

- Added ``objc.loadBundleVariables`` and ``objc.loadBundleFunctions``,
  two functions for reading global variables and functions from a bundle.

- objc.runtime will now raise AttributeError instead of objc.nosuchclass_error
  when a class is not found.

- objc.Category can be used to define categories on existing classes:

  .. sourcecode:: python

    class NSObject (objc.Category(NSObject)):
        def myMethod(self):
            pass

  This adds method ``myMethod`` to class NSObject.

- ``py2app`` is now used for all Example scripts and is the recommended method
  for creating PyObjC applications.

- 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.

- There is now a ``__bundle_hack__`` 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.

- We now have a working Interface Builder palette example due to
  ``__bundle__hack__``.

- ``bool(NSNull.null())`` is now false.

- ``setup.py`` supports several new commands:

    build_libffi:

      builds libffi (used by build_ext)

    build_html:
      builds html documentation from ReST source

    bdist_dmg:
      creates a disk image with the binary installer

    bdist_mpkg:
      creates a binary installer

    test:
      runs unit test suite (replaces Scripts/runPyObjCTests
      and Scripts/runalltests)

- ``PyObjCStrBridgeWarning`` can now be generated when Python ``str`` objects
  cross the bridge by calling ``objc.setStrBridgeEnabled(False)``.  It is
  HIGHLY recommended that your application never send ``str`` objects over
  the bridge, as it is likely to cause problems due to the required
  coercion to unicode.

- The coercion bridge from Python to Objective-C instances can now be
  augmented from Python as it is exposed by ``OC_PythonObject``.  See
  ``objc._bridges``.  This is how the ``str`` -> ``unicode`` -> ``NSString``
  bridge with optional warnings is implemented.

- The coercion bridge between Python objects and Objective-C structures
  can now be augmented from Python as it is exposed by ``OC_PythonObject``.
  See ``objc._bridges``.  This is how the ``Carbon.File.FSRef``
  <-> ``'{FSRef=[80c]}'`` structure bridge is implemented.

- Extension modules such as ``_objc``, ``_AppKit``, etc. are now inside
  packages as ``objc._objc``, ``AppKit._AppKit``, etc.  They should never be
  used directly, so this should not break user code.

Version 1.1 (2004-05-30)
------------------------

- KVO now actually works from Python without using nasty hacks.

- Added Xcode template for document-based applications

Version 1.1b2 (2004-04-11)
--------------------------

- More fine-grained multi-threading support

- Xcode templates use a smarter embedded main program

- Add support for WebObjects 4.5 (a one-line patch!)

- Add a PackageManager clone to the Examples directory

- Add better support for NSProxy

  This makes it possible to use at Distributed Objects, although this
  feature has not received much testing

- Function 'objc.protocolNamed' is the Python equivalent of the @protocol
  expression in Objective-C.

- Add several new examples


Version 1.1b1 (2004-02-20)
---------------------------

- Fixes some regressions in 1.1 w.r.t. 1.0

- Add Xcode templates for python files

  You can now select a new python file in the 'add file...' dialog in Xcode

- Fix installer for Panther: the 1.1a0 version didn't behave correctly

- There is now an easier way to define methods that conform to the expectations
  of Cocoa bindings:

  .. sourcecode:: python

     class MyClass (NSObject):

	@objc.accessor
        def setSomething_(self, value):
            pass

	@objc.accessor
        def something(self):
            return "something!"


  It is not necessary to use ``objc.accessor`` when overriding an existing
  accessor method.

Version 1.1a0 (2004-02-02)
--------------------------

- 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.

  This means you can now access the x-coordinate of a point as ``aPoint.x``,
  accessing ``aPoint[0]`` is still supported for compatibility with older
  versions of PyObjC.

  It is still allowed to use tuples, or other sequences, to represent
  Objective-C structs.

  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.

- This version adds support for NSDecimal. This is a fixed-point type defined
  in Cocoa.

- NSDecimalNumbers are no longer converted to floats, that would loose
  information.

- 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__().

  The same is true for defining methods, if you define a method ``raise__`` in
  a subclass of NSObject it will registered with the runtime as ``raise``.

  NOTE: Currently only ``class`` and ``raise`` are treated like this, because
  those are the only Python keywords that are actually used as Objective-C
  method names.

- Experimental support for ``instanceMethodForSelector:`` and
  ``methodForSelector:``.
  This support is not 100% stable, and might change in the future.

- Backward incompatible change: class methods are no longer callable through
  the instances.

- Integrates full support for MacOS X 10.3 (aka Panther)

- Adds a convenience/wrapper module for SecurityInterface

- It is now safe to call from Objective-C to Python in arbitrary threads, but
  only when using Python 2.3 or later.

- Fixes some issues with passing structs between Python and Objective-C.

- Uses the Panther version of ``NSKeyValueCoding``, the Jaguar version is still
  supported.

- method ``updateNSString`` of ``objc.pyobjc_unicode`` is deprecated, use
  create a new unicode object using ``unicode(mutableStringInstance)`` instead.

- NSAppleEventDescriptor bridged to Carbon.AE

- LibFFI is used more aggressivly, this should have no user-visible effects
  other than fixing a bug related to key-value observing.


- Adds a number of new Examples:

  * OpenGLDemo

    Shows how to use OpenGL with PyObjC

  * SillyBallsSaver

    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).

  * Twisted/WebServicesTool

    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.

  * Twisted/WebServicesTool-ControllerLayer

    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.

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://sourceware.org/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