Mac/Modules/mlte/_Mltemodule.c

   1
   2 /* ========================== Module _Mlte ========================== */
   3
   4 #include "Python.h"
   5
   6
   7
   8 #ifdef _WIN32
   9 #include "pywintoolbox.h"
  10 #else
  11 #include "macglue.h"
  12 #include "pymactoolbox.h"
  13 #endif
  14
  15 /* Macro to test whether a weak-loaded CFM function exists */
  16 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
  17         PyErr_SetString(PyExc_NotImplementedError, \
  18         "Not available in this shared library/OS version"); \
  19         return NULL; \
  20     }} while(0)
  21
  22
  23 #ifdef WITHOUT_FRAMEWORKS
  24 #include <MacTextEditor.h>
  25 #else
  26 #include <Carbon/Carbon.h>
  27 #endif
  28
  29 /* For now we declare them forward here. They'll go to mactoolbox later */
  30 static PyObject *TXNObj_New(TXNObject);
  31 static int TXNObj_Convert(PyObject *, TXNObject *);
  32 static PyObject *TXNFontMenuObj_New(TXNFontMenuObject);
  33 static int TXNFontMenuObj_Convert(PyObject *, TXNFontMenuObject *);
  34
  35 // ADD declarations
  36 #ifdef NOTYET_USE_TOOLBOX_OBJECT_GLUE
  37 //extern PyObject *_CFTypeRefObj_New(CFTypeRef);
  38 //extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *);
  39
  40 //#define CFTypeRefObj_New _CFTypeRefObj_New
  41 //#define CFTypeRefObj_Convert _CFTypeRefObj_Convert
  42 #endif
  43
  44 /*
  45 ** Parse an optional fsspec
  46 */
  47 static int
  48 OptFSSpecPtr_Convert(PyObject *v, FSSpec **p_itself)
  49 {
  50         static FSSpec fss;
  51         if (v == Py_None)
  52         {
  53                 *p_itself = NULL;
  54                 return 1;
  55         }
  56         *p_itself = &fss;
  57         return PyMac_GetFSSpec(v, *p_itself);
  58 }
  59
  60 /*
  61 ** Parse an optional rect
  62 */
  63 static int
  64 OptRectPtr_Convert(PyObject *v, Rect **p_itself)
  65 {
  66         static Rect r;
  67
  68         if (v == Py_None)
  69         {
  70                 *p_itself = NULL;
  71                 return 1;
  72         }
  73         *p_itself = &r;
  74         return PyMac_GetRect(v, *p_itself);
  75 }
  76
  77 /*
  78 ** Parse an optional GWorld
  79 */
  80 static int
  81 OptGWorldObj_Convert(PyObject *v, GWorldPtr *p_itself)
  82 {
  83         if (v == Py_None)
  84         {
  85                 *p_itself = NULL;
  86                 return 1;
  87         }
  88         return GWorldObj_Convert(v, p_itself);
  89 }
  90
  91
  92 static PyObject *Mlte_Error;
  93
  94 /* --------------------- Object type TXNObject ---------------------- */
  95
  96 PyTypeObject TXNObject_Type;
  97
  98 #define TXNObj_Check(x) ((x)->ob_type == &TXNObject_Type)
  99
 100 typedef struct TXNObjectObject {
 101         PyObject_HEAD
 102         TXNObject ob_itself;
 103 } TXNObjectObject;
 104
 105 PyObject *TXNObj_New(TXNObject itself)
 106 {
 107         TXNObjectObject *it;
 108         if (itself == NULL) return PyMac_Error(resNotFound);
 109         it = PyObject_NEW(TXNObjectObject, &TXNObject_Type);
 110         if (it == NULL) return NULL;
 111         it->ob_itself = itself;
 112         return (PyObject *)it;
 113 }
 114 int TXNObj_Convert(PyObject *v, TXNObject *p_itself)
 115 {
 116         if (!TXNObj_Check(v))
 117         {
 118                 PyErr_SetString(PyExc_TypeError, "TXNObject required");
 119                 return 0;
 120         }
 121         *p_itself = ((TXNObjectObject *)v)->ob_itself;
 122         return 1;
 123 }
 124
 125 static void TXNObj_dealloc(TXNObjectObject *self)
 126 {
 127         /* Cleanup of self->ob_itself goes here */
 128         PyObject_Del(self);
 129 }
 130
 131 static PyObject *TXNObj_TXNDeleteObject(TXNObjectObject *_self, PyObject *_args)
 132 {
 133         PyObject *_res = NULL;
 134 #ifndef TXNDeleteObject
 135         PyMac_PRECHECK(TXNDeleteObject);
 136 #endif
 137         if (!PyArg_ParseTuple(_args, ""))
 138                 return NULL;
 139         TXNDeleteObject(_self->ob_itself);
 140         Py_INCREF(Py_None);
 141         _res = Py_None;
 142         return _res;
 143 }
 144
 145 static PyObject *TXNObj_TXNResizeFrame(TXNObjectObject *_self, PyObject *_args)
 146 {
 147         PyObject *_res = NULL;
 148         UInt32 iWidth;
 149         UInt32 iHeight;
 150         TXNFrameID iTXNFrameID;
 151 #ifndef TXNResizeFrame
 152         PyMac_PRECHECK(TXNResizeFrame);
 153 #endif
 154         if (!PyArg_ParseTuple(_args, "lll",
 155                               &iWidth,
 156                               &iHeight,
 157                               &iTXNFrameID))
 158                 return NULL;
 159         TXNResizeFrame(_self->ob_itself,
 160                        iWidth,
 161                        iHeight,
 162                        iTXNFrameID);
 163         Py_INCREF(Py_None);
 164         _res = Py_None;
 165         return _res;
 166 }
 167
 168 static PyObject *TXNObj_TXNSetFrameBounds(TXNObjectObject *_self, PyObject *_args)
 169 {
 170         PyObject *_res = NULL;
 171         SInt32 iTop;
 172         SInt32 iLeft;
 173         SInt32 iBottom;
 174         SInt32 iRight;
 175         TXNFrameID iTXNFrameID;
 176 #ifndef TXNSetFrameBounds
 177         PyMac_PRECHECK(TXNSetFrameBounds);
 178 #endif
 179         if (!PyArg_ParseTuple(_args, "lllll",
 180                               &iTop,
 181                               &iLeft,
 182                               &iBottom,
 183                               &iRight,
 184                               &iTXNFrameID))
 185                 return NULL;
 186         TXNSetFrameBounds(_self->ob_itself,
 187                           iTop,
 188                           iLeft,
 189                           iBottom,
 190                           iRight,
 191                           iTXNFrameID);
 192         Py_INCREF(Py_None);
 193         _res = Py_None;
 194         return _res;
 195 }
 196
 197 static PyObject *TXNObj_TXNKeyDown(TXNObjectObject *_self, PyObject *_args)
 198 {
 199         PyObject *_res = NULL;
 200         EventRecord iEvent;
 201 #ifndef TXNKeyDown
 202         PyMac_PRECHECK(TXNKeyDown);
 203 #endif
 204         if (!PyArg_ParseTuple(_args, "O&",
 205                               PyMac_GetEventRecord, &iEvent))
 206                 return NULL;
 207         TXNKeyDown(_self->ob_itself,
 208                    &iEvent);
 209         Py_INCREF(Py_None);
 210         _res = Py_None;
 211         return _res;
 212 }
 213
 214 static PyObject *TXNObj_TXNAdjustCursor(TXNObjectObject *_self, PyObject *_args)
 215 {
 216         PyObject *_res = NULL;
 217         RgnHandle ioCursorRgn;
 218 #ifndef TXNAdjustCursor
 219         PyMac_PRECHECK(TXNAdjustCursor);
 220 #endif
 221         if (!PyArg_ParseTuple(_args, "O&",
 222                               OptResObj_Convert, &ioCursorRgn))
 223                 return NULL;
 224         TXNAdjustCursor(_self->ob_itself,
 225                         ioCursorRgn);
 226         Py_INCREF(Py_None);
 227         _res = Py_None;
 228         return _res;
 229 }
 230
 231 static PyObject *TXNObj_TXNClick(TXNObjectObject *_self, PyObject *_args)
 232 {
 233         PyObject *_res = NULL;
 234         EventRecord iEvent;
 235 #ifndef TXNClick
 236         PyMac_PRECHECK(TXNClick);
 237 #endif
 238         if (!PyArg_ParseTuple(_args, "O&",
 239                               PyMac_GetEventRecord, &iEvent))
 240                 return NULL;
 241         TXNClick(_self->ob_itself,
 242                  &iEvent);
 243         Py_INCREF(Py_None);
 244         _res = Py_None;
 245         return _res;
 246 }
 247
 248 #if TARGET_API_MAC_OS8
 249
 250 static PyObject *TXNObj_TXNTSMCheck(TXNObjectObject *_self, PyObject *_args)
 251 {
 252         PyObject *_res = NULL;
 253         Boolean _rv;
 254         EventRecord ioEvent;
 255 #ifndef TXNTSMCheck
 256         PyMac_PRECHECK(TXNTSMCheck);
 257 #endif
 258         if (!PyArg_ParseTuple(_args, ""))
 259                 return NULL;
 260         _rv = TXNTSMCheck(_self->ob_itself,
 261                           &ioEvent);
 262         _res = Py_BuildValue("bO&",
 263                              _rv,
 264                              PyMac_BuildEventRecord, &ioEvent);
 265         return _res;
 266 }
 267 #endif
 268
 269 static PyObject *TXNObj_TXNSelectAll(TXNObjectObject *_self, PyObject *_args)
 270 {
 271         PyObject *_res = NULL;
 272 #ifndef TXNSelectAll
 273         PyMac_PRECHECK(TXNSelectAll);
 274 #endif
 275         if (!PyArg_ParseTuple(_args, ""))
 276                 return NULL;
 277         TXNSelectAll(_self->ob_itself);
 278         Py_INCREF(Py_None);
 279         _res = Py_None;
 280         return _res;
 281 }
 282
 283 static PyObject *TXNObj_TXNFocus(TXNObjectObject *_self, PyObject *_args)
 284 {
 285         PyObject *_res = NULL;
 286         Boolean iBecomingFocused;
 287 #ifndef TXNFocus
 288         PyMac_PRECHECK(TXNFocus);
 289 #endif
 290         if (!PyArg_ParseTuple(_args, "b",
 291                               &iBecomingFocused))
 292                 return NULL;
 293         TXNFocus(_self->ob_itself,
 294                  iBecomingFocused);
 295         Py_INCREF(Py_None);
 296         _res = Py_None;
 297         return _res;
 298 }
 299
 300 static PyObject *TXNObj_TXNUpdate(TXNObjectObject *_self, PyObject *_args)
 301 {
 302         PyObject *_res = NULL;
 303 #ifndef TXNUpdate
 304         PyMac_PRECHECK(TXNUpdate);
 305 #endif
 306         if (!PyArg_ParseTuple(_args, ""))
 307                 return NULL;
 308         TXNUpdate(_self->ob_itself);
 309         Py_INCREF(Py_None);
 310         _res = Py_None;
 311         return _res;
 312 }
 313
 314 static PyObject *TXNObj_TXNDraw(TXNObjectObject *_self, PyObject *_args)
 315 {
 316         PyObject *_res = NULL;
 317         GWorldPtr iDrawPort;
 318 #ifndef TXNDraw
 319         PyMac_PRECHECK(TXNDraw);
 320 #endif
 321         if (!PyArg_ParseTuple(_args, "O&",
 322                               OptGWorldObj_Convert, &iDrawPort))
 323                 return NULL;
 324         TXNDraw(_self->ob_itself,
 325                 iDrawPort);
 326         Py_INCREF(Py_None);
 327         _res = Py_None;
 328         return _res;
 329 }
 330
 331 static PyObject *TXNObj_TXNForceUpdate(TXNObjectObject *_self, PyObject *_args)
 332 {
 333         PyObject *_res = NULL;
 334 #ifndef TXNForceUpdate
 335         PyMac_PRECHECK(TXNForceUpdate);
 336 #endif
 337         if (!PyArg_ParseTuple(_args, ""))
 338                 return NULL;
 339         TXNForceUpdate(_self->ob_itself);
 340         Py_INCREF(Py_None);
 341         _res = Py_None;
 342         return _res;
 343 }
 344
 345 static PyObject *TXNObj_TXNGetSleepTicks(TXNObjectObject *_self, PyObject *_args)
 346 {
 347         PyObject *_res = NULL;
 348         UInt32 _rv;
 349 #ifndef TXNGetSleepTicks
 350         PyMac_PRECHECK(TXNGetSleepTicks);
 351 #endif
 352         if (!PyArg_ParseTuple(_args, ""))
 353                 return NULL;
 354         _rv = TXNGetSleepTicks(_self->ob_itself);
 355         _res = Py_BuildValue("l",
 356                              _rv);
 357         return _res;
 358 }
 359
 360 static PyObject *TXNObj_TXNIdle(TXNObjectObject *_self, PyObject *_args)
 361 {
 362         PyObject *_res = NULL;
 363 #ifndef TXNIdle
 364         PyMac_PRECHECK(TXNIdle);
 365 #endif
 366         if (!PyArg_ParseTuple(_args, ""))
 367                 return NULL;
 368         TXNIdle(_self->ob_itself);
 369         Py_INCREF(Py_None);
 370         _res = Py_None;
 371         return _res;
 372 }
 373
 374 static PyObject *TXNObj_TXNGrowWindow(TXNObjectObject *_self, PyObject *_args)
 375 {
 376         PyObject *_res = NULL;
 377         EventRecord iEvent;
 378 #ifndef TXNGrowWindow
 379         PyMac_PRECHECK(TXNGrowWindow);
 380 #endif
 381         if (!PyArg_ParseTuple(_args, "O&",
 382                               PyMac_GetEventRecord, &iEvent))
 383                 return NULL;
 384         TXNGrowWindow(_self->ob_itself,
 385                       &iEvent);
 386         Py_INCREF(Py_None);
 387         _res = Py_None;
 388         return _res;
 389 }
 390
 391 static PyObject *TXNObj_TXNZoomWindow(TXNObjectObject *_self, PyObject *_args)
 392 {
 393         PyObject *_res = NULL;
 394         short iPart;
 395 #ifndef TXNZoomWindow
 396         PyMac_PRECHECK(TXNZoomWindow);
 397 #endif
 398         if (!PyArg_ParseTuple(_args, "h",
 399                               &iPart))
 400                 return NULL;
 401         TXNZoomWindow(_self->ob_itself,
 402                       iPart);
 403         Py_INCREF(Py_None);
 404         _res = Py_None;
 405         return _res;
 406 }
 407
 408 static PyObject *TXNObj_TXNCanUndo(TXNObjectObject *_self, PyObject *_args)
 409 {
 410         PyObject *_res = NULL;
 411         Boolean _rv;
 412         TXNActionKey oTXNActionKey;
 413 #ifndef TXNCanUndo
 414         PyMac_PRECHECK(TXNCanUndo);
 415 #endif
 416         if (!PyArg_ParseTuple(_args, ""))
 417                 return NULL;
 418         _rv = TXNCanUndo(_self->ob_itself,
 419                          &oTXNActionKey);
 420         _res = Py_BuildValue("bl",
 421                              _rv,
 422                              oTXNActionKey);
 423         return _res;
 424 }
 425
 426 static PyObject *TXNObj_TXNUndo(TXNObjectObject *_self, PyObject *_args)
 427 {
 428         PyObject *_res = NULL;
 429 #ifndef TXNUndo
 430         PyMac_PRECHECK(TXNUndo);
 431 #endif
 432         if (!PyArg_ParseTuple(_args, ""))
 433                 return NULL;
 434         TXNUndo(_self->ob_itself);
 435         Py_INCREF(Py_None);
 436         _res = Py_None;
 437         return _res;
 438 }
 439
 440 static PyObject *TXNObj_TXNCanRedo(TXNObjectObject *_self, PyObject *_args)
 441 {
 442         PyObject *_res = NULL;
 443         Boolean _rv;
 444         TXNActionKey oTXNActionKey;
 445 #ifndef TXNCanRedo
 446         PyMac_PRECHECK(TXNCanRedo);
 447 #endif
 448         if (!PyArg_ParseTuple(_args, ""))
 449                 return NULL;
 450         _rv = TXNCanRedo(_self->ob_itself,
 451                          &oTXNActionKey);
 452         _res = Py_BuildValue("bl",
 453                              _rv,
 454                              oTXNActionKey);
 455         return _res;
 456 }
 457
 458 static PyObject *TXNObj_TXNRedo(TXNObjectObject *_self, PyObject *_args)
 459 {
 460         PyObject *_res = NULL;
 461 #ifndef TXNRedo
 462         PyMac_PRECHECK(TXNRedo);
 463 #endif
 464         if (!PyArg_ParseTuple(_args, ""))
 465                 return NULL;
 466         TXNRedo(_self->ob_itself);
 467         Py_INCREF(Py_None);
 468         _res = Py_None;
 469         return _res;
 470 }
 471
 472 static PyObject *TXNObj_TXNCut(TXNObjectObject *_self, PyObject *_args)
 473 {
 474         PyObject *_res = NULL;
 475         OSStatus _err;
 476 #ifndef TXNCut
 477         PyMac_PRECHECK(TXNCut);
 478 #endif
 479         if (!PyArg_ParseTuple(_args, ""))
 480                 return NULL;
 481         _err = TXNCut(_self->ob_itself);
 482         if (_err != noErr) return PyMac_Error(_err);
 483         Py_INCREF(Py_None);
 484         _res = Py_None;
 485         return _res;
 486 }
 487
 488 static PyObject *TXNObj_TXNCopy(TXNObjectObject *_self, PyObject *_args)
 489 {
 490         PyObject *_res = NULL;
 491         OSStatus _err;
 492 #ifndef TXNCopy
 493         PyMac_PRECHECK(TXNCopy);
 494 #endif
 495         if (!PyArg_ParseTuple(_args, ""))
 496                 return NULL;
 497         _err = TXNCopy(_self->ob_itself);
 498         if (_err != noErr) return PyMac_Error(_err);
 499         Py_INCREF(Py_None);
 500         _res = Py_None;
 501         return _res;
 502 }
 503
 504 static PyObject *TXNObj_TXNPaste(TXNObjectObject *_self, PyObject *_args)
 505 {
 506         PyObject *_res = NULL;
 507         OSStatus _err;
 508 #ifndef TXNPaste
 509         PyMac_PRECHECK(TXNPaste);
 510 #endif
 511         if (!PyArg_ParseTuple(_args, ""))
 512                 return NULL;
 513         _err = TXNPaste(_self->ob_itself);
 514         if (_err != noErr) return PyMac_Error(_err);
 515         Py_INCREF(Py_None);
 516         _res = Py_None;
 517         return _res;
 518 }
 519
 520 static PyObject *TXNObj_TXNClear(TXNObjectObject *_self, PyObject *_args)
 521 {
 522         PyObject *_res = NULL;
 523         OSStatus _err;
 524 #ifndef TXNClear
 525         PyMac_PRECHECK(TXNClear);
 526 #endif
 527         if (!PyArg_ParseTuple(_args, ""))
 528                 return NULL;
 529         _err = TXNClear(_self->ob_itself);
 530         if (_err != noErr) return PyMac_Error(_err);
 531         Py_INCREF(Py_None);
 532         _res = Py_None;
 533         return _res;
 534 }
 535
 536 static PyObject *TXNObj_TXNGetSelection(TXNObjectObject *_self, PyObject *_args)
 537 {
 538         PyObject *_res = NULL;
 539         TXNOffset oStartOffset;
 540         TXNOffset oEndOffset;
 541 #ifndef TXNGetSelection
 542         PyMac_PRECHECK(TXNGetSelection);
 543 #endif
 544         if (!PyArg_ParseTuple(_args, ""))
 545                 return NULL;
 546         TXNGetSelection(_self->ob_itself,
 547                         &oStartOffset,
 548                         &oEndOffset);
 549         _res = Py_BuildValue("ll",
 550                              oStartOffset,
 551                              oEndOffset);
 552         return _res;
 553 }
 554
 555 static PyObject *TXNObj_TXNShowSelection(TXNObjectObject *_self, PyObject *_args)
 556 {
 557         PyObject *_res = NULL;
 558         Boolean iShowEnd;
 559 #ifndef TXNShowSelection
 560         PyMac_PRECHECK(TXNShowSelection);
 561 #endif
 562         if (!PyArg_ParseTuple(_args, "b",
 563                               &iShowEnd))
 564                 return NULL;
 565         TXNShowSelection(_self->ob_itself,
 566                          iShowEnd);
 567         Py_INCREF(Py_None);
 568         _res = Py_None;
 569         return _res;
 570 }
 571
 572 static PyObject *TXNObj_TXNIsSelectionEmpty(TXNObjectObject *_self, PyObject *_args)
 573 {
 574         PyObject *_res = NULL;
 575         Boolean _rv;
 576 #ifndef TXNIsSelectionEmpty
 577         PyMac_PRECHECK(TXNIsSelectionEmpty);
 578 #endif
 579         if (!PyArg_ParseTuple(_args, ""))
 580                 return NULL;
 581         _rv = TXNIsSelectionEmpty(_self->ob_itself);
 582         _res = Py_BuildValue("b",
 583                              _rv);
 584         return _res;
 585 }
 586
 587 static PyObject *TXNObj_TXNSetSelection(TXNObjectObject *_self, PyObject *_args)
 588 {
 589         PyObject *_res = NULL;
 590         OSStatus _err;
 591         TXNOffset iStartOffset;
 592         TXNOffset iEndOffset;
 593 #ifndef TXNSetSelection
 594         PyMac_PRECHECK(TXNSetSelection);
 595 #endif
 596         if (!PyArg_ParseTuple(_args, "ll",
 597                               &iStartOffset,
 598                               &iEndOffset))
 599                 return NULL;
 600         _err = TXNSetSelection(_self->ob_itself,
 601                                iStartOffset,
 602                                iEndOffset);
 603         if (_err != noErr) return PyMac_Error(_err);
 604         Py_INCREF(Py_None);
 605         _res = Py_None;
 606         return _res;
 607 }
 608
 609 static PyObject *TXNObj_TXNCountRunsInRange(TXNObjectObject *_self, PyObject *_args)
 610 {
 611         PyObject *_res = NULL;
 612         OSStatus _err;
 613         TXNOffset iStartOffset;
 614         TXNOffset iEndOffset;
 615         ItemCount oRunCount;
 616 #ifndef TXNCountRunsInRange
 617         PyMac_PRECHECK(TXNCountRunsInRange);
 618 #endif
 619         if (!PyArg_ParseTuple(_args, "ll",
 620                               &iStartOffset,
 621                               &iEndOffset))
 622                 return NULL;
 623         _err = TXNCountRunsInRange(_self->ob_itself,
 624                                    iStartOffset,
 625                                    iEndOffset,
 626                                    &oRunCount);
 627         if (_err != noErr) return PyMac_Error(_err);
 628         _res = Py_BuildValue("l",
 629                              oRunCount);
 630         return _res;
 631 }
 632
 633 static PyObject *TXNObj_TXNDataSize(TXNObjectObject *_self, PyObject *_args)
 634 {
 635         PyObject *_res = NULL;
 636         ByteCount _rv;
 637 #ifndef TXNDataSize
 638         PyMac_PRECHECK(TXNDataSize);
 639 #endif
 640         if (!PyArg_ParseTuple(_args, ""))
 641                 return NULL;
 642         _rv = TXNDataSize(_self->ob_itself);
 643         _res = Py_BuildValue("l",
 644                              _rv);
 645         return _res;
 646 }
 647
 648 static PyObject *TXNObj_TXNGetData(TXNObjectObject *_self, PyObject *_args)
 649 {
 650         PyObject *_res = NULL;
 651         OSStatus _err;
 652         TXNOffset iStartOffset;
 653         TXNOffset iEndOffset;
 654         Handle oDataHandle;
 655 #ifndef TXNGetData
 656         PyMac_PRECHECK(TXNGetData);
 657 #endif
 658         if (!PyArg_ParseTuple(_args, "ll",
 659                               &iStartOffset,
 660                               &iEndOffset))
 661                 return NULL;
 662         _err = TXNGetData(_self->ob_itself,
 663                           iStartOffset,
 664                           iEndOffset,
 665                           &oDataHandle);
 666         if (_err != noErr) return PyMac_Error(_err);
 667         _res = Py_BuildValue("O&",
 668                              ResObj_New, oDataHandle);
 669         return _res;
 670 }
 671
 672 static PyObject *TXNObj_TXNGetDataEncoded(TXNObjectObject *_self, PyObject *_args)
 673 {
 674         PyObject *_res = NULL;
 675         OSStatus _err;
 676         TXNOffset iStartOffset;
 677         TXNOffset iEndOffset;
 678         Handle oDataHandle;
 679         TXNDataType iEncoding;
 680 #ifndef TXNGetDataEncoded
 681         PyMac_PRECHECK(TXNGetDataEncoded);
 682 #endif
 683         if (!PyArg_ParseTuple(_args, "llO&",
 684                               &iStartOffset,
 685                               &iEndOffset,
 686                               PyMac_GetOSType, &iEncoding))
 687                 return NULL;
 688         _err = TXNGetDataEncoded(_self->ob_itself,
 689                                  iStartOffset,
 690                                  iEndOffset,
 691                                  &oDataHandle,
 692                                  iEncoding);
 693         if (_err != noErr) return PyMac_Error(_err);
 694         _res = Py_BuildValue("O&",
 695                              ResObj_New, oDataHandle);
 696         return _res;
 697 }
 698
 699 static PyObject *TXNObj_TXNSetDataFromFile(TXNObjectObject *_self, PyObject *_args)
 700 {
 701         PyObject *_res = NULL;
 702         OSStatus _err;
 703         SInt16 iFileRefNum;
 704         OSType iFileType;
 705         ByteCount iFileLength;
 706         TXNOffset iStartOffset;
 707         TXNOffset iEndOffset;
 708 #ifndef TXNSetDataFromFile
 709         PyMac_PRECHECK(TXNSetDataFromFile);
 710 #endif
 711         if (!PyArg_ParseTuple(_args, "hO&lll",
 712                               &iFileRefNum,
 713                               PyMac_GetOSType, &iFileType,
 714                               &iFileLength,
 715                               &iStartOffset,
 716                               &iEndOffset))
 717                 return NULL;
 718         _err = TXNSetDataFromFile(_self->ob_itself,
 719                                   iFileRefNum,
 720                                   iFileType,
 721                                   iFileLength,
 722                                   iStartOffset,
 723                                   iEndOffset);
 724         if (_err != noErr) return PyMac_Error(_err);
 725         Py_INCREF(Py_None);
 726         _res = Py_None;
 727         return _res;
 728 }
 729
 730 static PyObject *TXNObj_TXNSetData(TXNObjectObject *_self, PyObject *_args)
 731 {
 732         PyObject *_res = NULL;
 733         OSStatus _err;
 734         TXNDataType iDataType;
 735         void * *iDataPtr__in__;
 736         ByteCount iDataPtr__len__;
 737         int iDataPtr__in_len__;
 738         TXNOffset iStartOffset;
 739         TXNOffset iEndOffset;
 740 #ifndef TXNSetData
 741         PyMac_PRECHECK(TXNSetData);
 742 #endif
 743         if (!PyArg_ParseTuple(_args, "O&s#ll",
 744                               PyMac_GetOSType, &iDataType,
 745                               &iDataPtr__in__, &iDataPtr__in_len__,
 746                               &iStartOffset,
 747                               &iEndOffset))
 748                 return NULL;
 749         iDataPtr__len__ = iDataPtr__in_len__;
 750         _err = TXNSetData(_self->ob_itself,
 751                           iDataType,
 752                           iDataPtr__in__, iDataPtr__len__,
 753                           iStartOffset,
 754                           iEndOffset);
 755         if (_err != noErr) return PyMac_Error(_err);
 756         Py_INCREF(Py_None);
 757         _res = Py_None;
 758         return _res;
 759 }
 760
 761 static PyObject *TXNObj_TXNGetChangeCount(TXNObjectObject *_self, PyObject *_args)
 762 {
 763         PyObject *_res = NULL;
 764         ItemCount _rv;
 765 #ifndef TXNGetChangeCount
 766         PyMac_PRECHECK(TXNGetChangeCount);
 767 #endif
 768         if (!PyArg_ParseTuple(_args, ""))
 769                 return NULL;
 770         _rv = TXNGetChangeCount(_self->ob_itself);
 771         _res = Py_BuildValue("l",
 772                              _rv);
 773         return _res;
 774 }
 775
 776 static PyObject *TXNObj_TXNSave(TXNObjectObject *_self, PyObject *_args)
 777 {
 778         PyObject *_res = NULL;
 779         OSStatus _err;
 780         TXNFileType iType;
 781         OSType iResType;
 782         TXNPermanentTextEncodingType iPermanentEncoding;
 783         FSSpec iFileSpecification;
 784         SInt16 iDataReference;
 785         SInt16 iResourceReference;
 786 #ifndef TXNSave
 787         PyMac_PRECHECK(TXNSave);
 788 #endif
 789         if (!PyArg_ParseTuple(_args, "O&O&lO&hh",
 790                               PyMac_GetOSType, &iType,
 791                               PyMac_GetOSType, &iResType,
 792                               &iPermanentEncoding,
 793                               PyMac_GetFSSpec, &iFileSpecification,
 794                               &iDataReference,
 795                               &iResourceReference))
 796                 return NULL;
 797         _err = TXNSave(_self->ob_itself,
 798                        iType,
 799                        iResType,
 800                        iPermanentEncoding,
 801                        &iFileSpecification,
 802                        iDataReference,
 803                        iResourceReference);
 804         if (_err != noErr) return PyMac_Error(_err);
 805         Py_INCREF(Py_None);
 806         _res = Py_None;
 807         return _res;
 808 }
 809
 810 static PyObject *TXNObj_TXNRevert(TXNObjectObject *_self, PyObject *_args)
 811 {
 812         PyObject *_res = NULL;
 813         OSStatus _err;
 814 #ifndef TXNRevert
 815         PyMac_PRECHECK(TXNRevert);
 816 #endif
 817         if (!PyArg_ParseTuple(_args, ""))
 818                 return NULL;
 819         _err = TXNRevert(_self->ob_itself);
 820         if (_err != noErr) return PyMac_Error(_err);
 821         Py_INCREF(Py_None);
 822         _res = Py_None;
 823         return _res;
 824 }
 825
 826 static PyObject *TXNObj_TXNPageSetup(TXNObjectObject *_self, PyObject *_args)
 827 {
 828         PyObject *_res = NULL;
 829         OSStatus _err;
 830 #ifndef TXNPageSetup
 831         PyMac_PRECHECK(TXNPageSetup);
 832 #endif
 833         if (!PyArg_ParseTuple(_args, ""))
 834                 return NULL;
 835         _err = TXNPageSetup(_self->ob_itself);
 836         if (_err != noErr) return PyMac_Error(_err);
 837         Py_INCREF(Py_None);
 838         _res = Py_None;
 839         return _res;
 840 }
 841
 842 static PyObject *TXNObj_TXNPrint(TXNObjectObject *_self, PyObject *_args)
 843 {
 844         PyObject *_res = NULL;
 845         OSStatus _err;
 846 #ifndef TXNPrint
 847         PyMac_PRECHECK(TXNPrint);
 848 #endif
 849         if (!PyArg_ParseTuple(_args, ""))
 850                 return NULL;
 851         _err = TXNPrint(_self->ob_itself);
 852         if (_err != noErr) return PyMac_Error(_err);
 853         Py_INCREF(Py_None);
 854         _res = Py_None;
 855         return _res;
 856 }
 857
 858 static PyObject *TXNObj_TXNGetViewRect(TXNObjectObject *_self, PyObject *_args)
 859 {
 860         PyObject *_res = NULL;
 861         Rect oViewRect;
 862 #ifndef TXNGetViewRect
 863         PyMac_PRECHECK(TXNGetViewRect);
 864 #endif
 865         if (!PyArg_ParseTuple(_args, ""))
 866                 return NULL;
 867         TXNGetViewRect(_self->ob_itself,
 868                        &oViewRect);
 869         _res = Py_BuildValue("O&",
 870                              PyMac_BuildRect, &oViewRect);
 871         return _res;
 872 }
 873
 874 static PyObject *TXNObj_TXNSetViewRect(TXNObjectObject *_self, PyObject *_args)
 875 {
 876         PyObject *_res = NULL;
 877         Rect iViewRect;
 878 #ifndef TXNSetViewRect
 879         PyMac_PRECHECK(TXNSetViewRect);
 880 #endif
 881         if (!PyArg_ParseTuple(_args, "O&",
 882                               PyMac_GetRect, &iViewRect))
 883                 return NULL;
 884         TXNSetViewRect(_self->ob_itself,
 885                        &iViewRect);
 886         Py_INCREF(Py_None);
 887         _res = Py_None;
 888         return _res;
 889 }
 890
 891 static PyObject *TXNObj_TXNAttachObjectToWindow(TXNObjectObject *_self, PyObject *_args)
 892 {
 893         PyObject *_res = NULL;
 894         OSStatus _err;
 895         GWorldPtr iWindow;
 896         Boolean iIsActualWindow;
 897 #ifndef TXNAttachObjectToWindow
 898         PyMac_PRECHECK(TXNAttachObjectToWindow);
 899 #endif
 900         if (!PyArg_ParseTuple(_args, "O&b",
 901                               GWorldObj_Convert, &iWindow,
 902                               &iIsActualWindow))
 903                 return NULL;
 904         _err = TXNAttachObjectToWindow(_self->ob_itself,
 905                                        iWindow,
 906                                        iIsActualWindow);
 907         if (_err != noErr) return PyMac_Error(_err);
 908         Py_INCREF(Py_None);
 909         _res = Py_None;
 910         return _res;
 911 }
 912
 913 static PyObject *TXNObj_TXNIsObjectAttachedToWindow(TXNObjectObject *_self, PyObject *_args)
 914 {
 915         PyObject *_res = NULL;
 916         Boolean _rv;
 917 #ifndef TXNIsObjectAttachedToWindow
 918         PyMac_PRECHECK(TXNIsObjectAttachedToWindow);
 919 #endif
 920         if (!PyArg_ParseTuple(_args, ""))
 921                 return NULL;
 922         _rv = TXNIsObjectAttachedToWindow(_self->ob_itself);
 923         _res = Py_BuildValue("b",
 924                              _rv);
 925         return _res;
 926 }
 927
 928 static PyObject *TXNObj_TXNDragTracker(TXNObjectObject *_self, PyObject *_args)
 929 {
 930         PyObject *_res = NULL;
 931         OSErr _err;
 932         TXNFrameID iTXNFrameID;
 933         DragTrackingMessage iMessage;
 934         WindowPtr iWindow;
 935         DragReference iDragReference;
 936         Boolean iDifferentObjectSameWindow;
 937 #ifndef TXNDragTracker
 938         PyMac_PRECHECK(TXNDragTracker);
 939 #endif
 940         if (!PyArg_ParseTuple(_args, "lhO&O&b",
 941                               &iTXNFrameID,
 942                               &iMessage,
 943                               WinObj_Convert, &iWindow,
 944                               DragObj_Convert, &iDragReference,
 945                               &iDifferentObjectSameWindow))
 946                 return NULL;
 947         _err = TXNDragTracker(_self->ob_itself,
 948                               iTXNFrameID,
 949                               iMessage,
 950                               iWindow,
 951                               iDragReference,
 952                               iDifferentObjectSameWindow);
 953         if (_err != noErr) return PyMac_Error(_err);
 954         Py_INCREF(Py_None);
 955         _res = Py_None;
 956         return _res;
 957 }
 958
 959 static PyObject *TXNObj_TXNDragReceiver(TXNObjectObject *_self, PyObject *_args)
 960 {
 961         PyObject *_res = NULL;
 962         OSErr _err;
 963         TXNFrameID iTXNFrameID;
 964         WindowPtr iWindow;
 965         DragReference iDragReference;
 966         Boolean iDifferentObjectSameWindow;
 967 #ifndef TXNDragReceiver
 968         PyMac_PRECHECK(TXNDragReceiver);
 969 #endif
 970         if (!PyArg_ParseTuple(_args, "lO&O&b",
 971                               &iTXNFrameID,
 972                               WinObj_Convert, &iWindow,
 973                               DragObj_Convert, &iDragReference,
 974                               &iDifferentObjectSameWindow))
 975                 return NULL;
 976         _err = TXNDragReceiver(_self->ob_itself,
 977                                iTXNFrameID,
 978                                iWindow,
 979                                iDragReference,
 980                                iDifferentObjectSameWindow);
 981         if (_err != noErr) return PyMac_Error(_err);
 982         Py_INCREF(Py_None);
 983         _res = Py_None;
 984         return _res;
 985 }
 986
 987 static PyObject *TXNObj_TXNActivate(TXNObjectObject *_self, PyObject *_args)
 988 {
 989         PyObject *_res = NULL;
 990         OSStatus _err;
 991         TXNFrameID iTXNFrameID;
 992         TXNScrollBarState iActiveState;
 993 #ifndef TXNActivate
 994         PyMac_PRECHECK(TXNActivate);
 995 #endif
 996         if (!PyArg_ParseTuple(_args, "ll",
 997                               &iTXNFrameID,
 998                               &iActiveState))
 999                 return NULL;
1000         _err = TXNActivate(_self->ob_itself,
1001                            iTXNFrameID,
1002                            iActiveState);
1003         if (_err != noErr) return PyMac_Error(_err);
1004         Py_INCREF(Py_None);
1005         _res = Py_None;
1006         return _res;
1007 }
1008
1009 static PyObject *TXNObj_TXNEchoMode(TXNObjectObject *_self, PyObject *_args)
1010 {
1011         PyObject *_res = NULL;
1012         OSStatus _err;
1013         UniChar iEchoCharacter;
1014         TextEncoding iEncoding;
1015         Boolean iOn;
1016 #ifndef TXNEchoMode
1017         PyMac_PRECHECK(TXNEchoMode);
1018 #endif
1019         if (!PyArg_ParseTuple(_args, "hlb",
1020                               &iEchoCharacter,
1021                               &iEncoding,
1022                               &iOn))
1023                 return NULL;
1024         _err = TXNEchoMode(_self->ob_itself,
1025                            iEchoCharacter,
1026                            iEncoding,
1027                            iOn);
1028         if (_err != noErr) return PyMac_Error(_err);
1029         Py_INCREF(Py_None);
1030         _res = Py_None;
1031         return _res;
1032 }
1033
1034 static PyObject *TXNObj_TXNDoFontMenuSelection(TXNObjectObject *_self, PyObject *_args)
1035 {
1036         PyObject *_res = NULL;
1037         OSStatus _err;
1038         TXNFontMenuObject iTXNFontMenuObject;
1039         SInt16 iMenuID;
1040         SInt16 iMenuItem;
1041 #ifndef TXNDoFontMenuSelection
1042         PyMac_PRECHECK(TXNDoFontMenuSelection);
1043 #endif
1044         if (!PyArg_ParseTuple(_args, "O&hh",
1045                               TXNFontMenuObj_Convert, &iTXNFontMenuObject,
1046                               &iMenuID,
1047                               &iMenuItem))
1048                 return NULL;
1049         _err = TXNDoFontMenuSelection(_self->ob_itself,
1050                                       iTXNFontMenuObject,
1051                                       iMenuID,
1052                                       iMenuItem);
1053         if (_err != noErr) return PyMac_Error(_err);
1054         Py_INCREF(Py_None);
1055         _res = Py_None;
1056         return _res;
1057 }
1058
1059 static PyObject *TXNObj_TXNPrepareFontMenu(TXNObjectObject *_self, PyObject *_args)
1060 {
1061         PyObject *_res = NULL;
1062         OSStatus _err;
1063         TXNFontMenuObject iTXNFontMenuObject;
1064 #ifndef TXNPrepareFontMenu
1065         PyMac_PRECHECK(TXNPrepareFontMenu);
1066 #endif
1067         if (!PyArg_ParseTuple(_args, "O&",
1068                               TXNFontMenuObj_Convert, &iTXNFontMenuObject))
1069                 return NULL;
1070         _err = TXNPrepareFontMenu(_self->ob_itself,
1071                                   iTXNFontMenuObject);
1072         if (_err != noErr) return PyMac_Error(_err);
1073         Py_INCREF(Py_None);
1074         _res = Py_None;
1075         return _res;
1076 }
1077
1078 static PyObject *TXNObj_TXNPointToOffset(TXNObjectObject *_self, PyObject *_args)
1079 {
1080         PyObject *_res = NULL;
1081         OSStatus _err;
1082         Point iPoint;
1083         TXNOffset oOffset;
1084 #ifndef TXNPointToOffset
1085         PyMac_PRECHECK(TXNPointToOffset);
1086 #endif
1087         if (!PyArg_ParseTuple(_args, "O&",
1088                               PyMac_GetPoint, &iPoint))
1089                 return NULL;
1090         _err = TXNPointToOffset(_self->ob_itself,
1091                                 iPoint,
1092                                 &oOffset);
1093         if (_err != noErr) return PyMac_Error(_err);
1094         _res = Py_BuildValue("l",
1095                              oOffset);
1096         return _res;
1097 }
1098
1099 static PyObject *TXNObj_TXNOffsetToPoint(TXNObjectObject *_self, PyObject *_args)
1100 {
1101         PyObject *_res = NULL;
1102         OSStatus _err;
1103         TXNOffset iOffset;
1104         Point oPoint;
1105 #ifndef TXNOffsetToPoint
1106         PyMac_PRECHECK(TXNOffsetToPoint);
1107 #endif
1108         if (!PyArg_ParseTuple(_args, "l",
1109                               &iOffset))
1110                 return NULL;
1111         _err = TXNOffsetToPoint(_self->ob_itself,
1112                                 iOffset,
1113                                 &oPoint);
1114         if (_err != noErr) return PyMac_Error(_err);
1115         _res = Py_BuildValue("O&",
1116                              PyMac_BuildPoint, oPoint);
1117         return _res;
1118 }
1119
1120 static PyObject *TXNObj_TXNGetLineCount(TXNObjectObject *_self, PyObject *_args)
1121 {
1122         PyObject *_res = NULL;
1123         OSStatus _err;
1124         ItemCount oLineTotal;
1125 #ifndef TXNGetLineCount
1126         PyMac_PRECHECK(TXNGetLineCount);
1127 #endif
1128         if (!PyArg_ParseTuple(_args, ""))
1129                 return NULL;
1130         _err = TXNGetLineCount(_self->ob_itself,
1131                                &oLineTotal);
1132         if (_err != noErr) return PyMac_Error(_err);
1133         _res = Py_BuildValue("l",
1134                              oLineTotal);
1135         return _res;
1136 }
1137
1138 static PyObject *TXNObj_TXNGetLineMetrics(TXNObjectObject *_self, PyObject *_args)
1139 {
1140         PyObject *_res = NULL;
1141         OSStatus _err;
1142         UInt32 iLineNumber;
1143         Fixed oLineWidth;
1144         Fixed oLineHeight;
1145 #ifndef TXNGetLineMetrics
1146         PyMac_PRECHECK(TXNGetLineMetrics);
1147 #endif
1148         if (!PyArg_ParseTuple(_args, "l",
1149                               &iLineNumber))
1150                 return NULL;
1151         _err = TXNGetLineMetrics(_self->ob_itself,
1152                                  iLineNumber,
1153                                  &oLineWidth,
1154                                  &oLineHeight);
1155         if (_err != noErr) return PyMac_Error(_err);
1156         _res = Py_BuildValue("O&O&",
1157                              PyMac_BuildFixed, oLineWidth,
1158                              PyMac_BuildFixed, oLineHeight);
1159         return _res;
1160 }
1161
1162 static PyObject *TXNObj_TXNIsObjectAttachedToSpecificWindow(TXNObjectObject *_self, PyObject *_args)
1163 {
1164         PyObject *_res = NULL;
1165         OSStatus _err;
1166         WindowPtr iWindow;
1167         Boolean oAttached;
1168 #ifndef TXNIsObjectAttachedToSpecificWindow
1169         PyMac_PRECHECK(TXNIsObjectAttachedToSpecificWindow);
1170 #endif
1171         if (!PyArg_ParseTuple(_args, "O&",
1172                               WinObj_Convert, &iWindow))
1173                 return NULL;
1174         _err = TXNIsObjectAttachedToSpecificWindow(_self->ob_itself,
1175                                                    iWindow,
1176                                                    &oAttached);
1177         if (_err != noErr) return PyMac_Error(_err);
1178         _res = Py_BuildValue("b",
1179                              oAttached);
1180         return _res;
1181 }
1182
1183 static PyMethodDef TXNObj_methods[] = {
1184         {"TXNDeleteObject", (PyCFunction)TXNObj_TXNDeleteObject, 1,
1185          PyDoc_STR("() -> None")},
1186         {"TXNResizeFrame", (PyCFunction)TXNObj_TXNResizeFrame, 1,
1187          PyDoc_STR("(UInt32 iWidth, UInt32 iHeight, TXNFrameID iTXNFrameID) -> None")},
1188         {"TXNSetFrameBounds", (PyCFunction)TXNObj_TXNSetFrameBounds, 1,
1189          PyDoc_STR("(SInt32 iTop, SInt32 iLeft, SInt32 iBottom, SInt32 iRight, TXNFrameID iTXNFrameID) -> None")},
1190         {"TXNKeyDown", (PyCFunction)TXNObj_TXNKeyDown, 1,
1191          PyDoc_STR("(EventRecord iEvent) -> None")},
1192         {"TXNAdjustCursor", (PyCFunction)TXNObj_TXNAdjustCursor, 1,
1193          PyDoc_STR("(RgnHandle ioCursorRgn) -> None")},
1194         {"TXNClick", (PyCFunction)TXNObj_TXNClick, 1,
1195          PyDoc_STR("(EventRecord iEvent) -> None")},
1196
1197 #if TARGET_API_MAC_OS8
1198         {"TXNTSMCheck", (PyCFunction)TXNObj_TXNTSMCheck, 1,
1199          PyDoc_STR("() -> (Boolean _rv, EventRecord ioEvent)")},
1200 #endif
1201         {"TXNSelectAll", (PyCFunction)TXNObj_TXNSelectAll, 1,
1202          PyDoc_STR("() -> None")},
1203         {"TXNFocus", (PyCFunction)TXNObj_TXNFocus, 1,
1204          PyDoc_STR("(Boolean iBecomingFocused) -> None")},
1205         {"TXNUpdate", (PyCFunction)TXNObj_TXNUpdate, 1,
1206          PyDoc_STR("() -> None")},
1207         {"TXNDraw", (PyCFunction)TXNObj_TXNDraw, 1,
1208          PyDoc_STR("(GWorldPtr iDrawPort) -> None")},
1209         {"TXNForceUpdate", (PyCFunction)TXNObj_TXNForceUpdate, 1,
1210          PyDoc_STR("() -> None")},
1211         {"TXNGetSleepTicks", (PyCFunction)TXNObj_TXNGetSleepTicks, 1,
1212          PyDoc_STR("() -> (UInt32 _rv)")},
1213         {"TXNIdle", (PyCFunction)TXNObj_TXNIdle, 1,
1214          PyDoc_STR("() -> None")},
1215         {"TXNGrowWindow", (PyCFunction)TXNObj_TXNGrowWindow, 1,
1216          PyDoc_STR("(EventRecord iEvent) -> None")},
1217         {"TXNZoomWindow", (PyCFunction)TXNObj_TXNZoomWindow, 1,
1218          PyDoc_STR("(short iPart) -> None")},
1219         {"TXNCanUndo", (PyCFunction)TXNObj_TXNCanUndo, 1,
1220          PyDoc_STR("() -> (Boolean _rv, TXNActionKey oTXNActionKey)")},
1221         {"TXNUndo", (PyCFunction)TXNObj_TXNUndo, 1,
1222          PyDoc_STR("() -> None")},
1223         {"TXNCanRedo", (PyCFunction)TXNObj_TXNCanRedo, 1,
1224          PyDoc_STR("() -> (Boolean _rv, TXNActionKey oTXNActionKey)")},
1225         {"TXNRedo", (PyCFunction)TXNObj_TXNRedo, 1,
1226          PyDoc_STR("() -> None")},
1227         {"TXNCut", (PyCFunction)TXNObj_TXNCut, 1,
1228          PyDoc_STR("() -> None")},
1229         {"TXNCopy", (PyCFunction)TXNObj_TXNCopy, 1,
1230          PyDoc_STR("() -> None")},
1231         {"TXNPaste", (PyCFunction)TXNObj_TXNPaste, 1,
1232          PyDoc_STR("() -> None")},
1233         {"TXNClear", (PyCFunction)TXNObj_TXNClear, 1,
1234          PyDoc_STR("() -> None")},
1235         {"TXNGetSelection", (PyCFunction)TXNObj_TXNGetSelection, 1,
1236          PyDoc_STR("() -> (TXNOffset oStartOffset, TXNOffset oEndOffset)")},
1237         {"TXNShowSelection", (PyCFunction)TXNObj_TXNShowSelection, 1,
1238          PyDoc_STR("(Boolean iShowEnd) -> None")},
1239         {"TXNIsSelectionEmpty", (PyCFunction)TXNObj_TXNIsSelectionEmpty, 1,
1240          PyDoc_STR("() -> (Boolean _rv)")},
1241         {"TXNSetSelection", (PyCFunction)TXNObj_TXNSetSelection, 1,
1242          PyDoc_STR("(TXNOffset iStartOffset, TXNOffset iEndOffset) -> None")},
1243         {"TXNCountRunsInRange", (PyCFunction)TXNObj_TXNCountRunsInRange, 1,
1244          PyDoc_STR("(TXNOffset iStartOffset, TXNOffset iEndOffset) -> (ItemCount oRunCount)")},
1245         {"TXNDataSize", (PyCFunction)TXNObj_TXNDataSize, 1,
1246          PyDoc_STR("() -> (ByteCount _rv)")},
1247         {"TXNGetData", (PyCFunction)TXNObj_TXNGetData, 1,
1248          PyDoc_STR("(TXNOffset iStartOffset, TXNOffset iEndOffset) -> (Handle oDataHandle)")},
1249         {"TXNGetDataEncoded", (PyCFunction)TXNObj_TXNGetDataEncoded, 1,
1250          PyDoc_STR("(TXNOffset iStartOffset, TXNOffset iEndOffset, TXNDataType iEncoding) -> (Handle oDataHandle)")},
1251         {"TXNSetDataFromFile", (PyCFunction)TXNObj_TXNSetDataFromFile, 1,
1252          PyDoc_STR("(SInt16 iFileRefNum, OSType iFileType, ByteCount iFileLength, TXNOffset iStartOffset, TXNOffset iEndOffset) -> None")},
1253         {"TXNSetData", (PyCFunction)TXNObj_TXNSetData, 1,
1254          PyDoc_STR("(TXNDataType iDataType, Buffer iDataPtr, TXNOffset iStartOffset, TXNOffset iEndOffset) -> None")},
1255         {"TXNGetChangeCount", (PyCFunction)TXNObj_TXNGetChangeCount, 1,
1256          PyDoc_STR("() -> (ItemCount _rv)")},
1257         {"TXNSave", (PyCFunction)TXNObj_TXNSave, 1,
1258          PyDoc_STR("(TXNFileType iType, OSType iResType, TXNPermanentTextEncodingType iPermanentEncoding, FSSpec iFileSpecification, SInt16 iDataReference, SInt16 iResourceReference) -> None")},
1259         {"TXNRevert", (PyCFunction)TXNObj_TXNRevert, 1,
1260          PyDoc_STR("() -> None")},
1261         {"TXNPageSetup", (PyCFunction)TXNObj_TXNPageSetup, 1,
1262          PyDoc_STR("() -> None")},
1263         {"TXNPrint", (PyCFunction)TXNObj_TXNPrint, 1,
1264          PyDoc_STR("() -> None")},
1265         {"TXNGetViewRect", (PyCFunction)TXNObj_TXNGetViewRect, 1,
1266          PyDoc_STR("() -> (Rect oViewRect)")},
1267         {"TXNSetViewRect", (PyCFunction)TXNObj_TXNSetViewRect, 1,
1268          PyDoc_STR("(Rect iViewRect) -> None")},
1269         {"TXNAttachObjectToWindow", (PyCFunction)TXNObj_TXNAttachObjectToWindow, 1,
1270          PyDoc_STR("(GWorldPtr iWindow, Boolean iIsActualWindow) -> None")},
1271         {"TXNIsObjectAttachedToWindow", (PyCFunction)TXNObj_TXNIsObjectAttachedToWindow, 1,
1272          PyDoc_STR("() -> (Boolean _rv)")},
1273         {"TXNDragTracker", (PyCFunction)TXNObj_TXNDragTracker, 1,
1274          PyDoc_STR("(TXNFrameID iTXNFrameID, DragTrackingMessage iMessage, WindowPtr iWindow, DragReference iDragReference, Boolean iDifferentObjectSameWindow) -> None")},
1275         {"TXNDragReceiver", (PyCFunction)TXNObj_TXNDragReceiver, 1,
1276          PyDoc_STR("(TXNFrameID iTXNFrameID, WindowPtr iWindow, DragReference iDragReference, Boolean iDifferentObjectSameWindow) -> None")},
1277         {"TXNActivate", (PyCFunction)TXNObj_TXNActivate, 1,
1278          PyDoc_STR("(TXNFrameID iTXNFrameID, TXNScrollBarState iActiveState) -> None")},
1279         {"TXNEchoMode", (PyCFunction)TXNObj_TXNEchoMode, 1,
1280          PyDoc_STR("(UniChar iEchoCharacter, TextEncoding iEncoding, Boolean iOn) -> None")},
1281         {"TXNDoFontMenuSelection", (PyCFunction)TXNObj_TXNDoFontMenuSelection, 1,
1282          PyDoc_STR("(TXNFontMenuObject iTXNFontMenuObject, SInt16 iMenuID, SInt16 iMenuItem) -> None")},
1283         {"TXNPrepareFontMenu", (PyCFunction)TXNObj_TXNPrepareFontMenu, 1,
1284          PyDoc_STR("(TXNFontMenuObject iTXNFontMenuObject) -> None")},
1285         {"TXNPointToOffset", (PyCFunction)TXNObj_TXNPointToOffset, 1,
1286          PyDoc_STR("(Point iPoint) -> (TXNOffset oOffset)")},
1287         {"TXNOffsetToPoint", (PyCFunction)TXNObj_TXNOffsetToPoint, 1,
1288          PyDoc_STR("(TXNOffset iOffset) -> (Point oPoint)")},
1289         {"TXNGetLineCount", (PyCFunction)TXNObj_TXNGetLineCount, 1,
1290          PyDoc_STR("() -> (ItemCount oLineTotal)")},
1291         {"TXNGetLineMetrics", (PyCFunction)TXNObj_TXNGetLineMetrics, 1,
1292          PyDoc_STR("(UInt32 iLineNumber) -> (Fixed oLineWidth, Fixed oLineHeight)")},
1293         {"TXNIsObjectAttachedToSpecificWindow", (PyCFunction)TXNObj_TXNIsObjectAttachedToSpecificWindow, 1,
1294          PyDoc_STR("(WindowPtr iWindow) -> (Boolean oAttached)")},
1295         {NULL, NULL, 0}
1296 };
1297
1298 PyMethodChain TXNObj_chain = { TXNObj_methods, NULL };
1299
1300 static PyObject *TXNObj_getattr(TXNObjectObject *self, char *name)
1301 {
1302         return Py_FindMethodInChain(&TXNObj_chain, (PyObject *)self, name);
1303 }
1304
1305 #define TXNObj_setattr NULL
1306
1307 #define TXNObj_compare NULL
1308
1309 #define TXNObj_repr NULL
1310
1311 #define TXNObj_hash NULL
1312
1313 PyTypeObject TXNObject_Type = {
1314         PyObject_HEAD_INIT(NULL)
1315         0, /*ob_size*/
1316         "_Mlte.TXNObject", /*tp_name*/
1317         sizeof(TXNObjectObject), /*tp_basicsize*/
1318         0, /*tp_itemsize*/
1319         /* methods */
1320         (destructor) TXNObj_dealloc, /*tp_dealloc*/
1321         0, /*tp_print*/
1322         (getattrfunc) TXNObj_getattr, /*tp_getattr*/
1323         (setattrfunc) TXNObj_setattr, /*tp_setattr*/
1324         (cmpfunc) TXNObj_compare, /*tp_compare*/
1325         (reprfunc) TXNObj_repr, /*tp_repr*/
1326         (PyNumberMethods *)0, /* tp_as_number */
1327         (PySequenceMethods *)0, /* tp_as_sequence */
1328         (PyMappingMethods *)0, /* tp_as_mapping */
1329         (hashfunc) TXNObj_hash, /*tp_hash*/
1330 };
1331
1332 /* ------------------- End object type TXNObject -------------------- */
1333
1334
1335 /* ----------------- Object type TXNFontMenuObject ------------------ */
1336
1337 PyTypeObject TXNFontMenuObject_Type;
1338
1339 #define TXNFontMenuObj_Check(x) ((x)->ob_type == &TXNFontMenuObject_Type)
1340
1341 typedef struct TXNFontMenuObjectObject {
1342         PyObject_HEAD
1343         TXNFontMenuObject ob_itself;
1344 } TXNFontMenuObjectObject;
1345
1346 PyObject *TXNFontMenuObj_New(TXNFontMenuObject itself)
1347 {
1348         TXNFontMenuObjectObject *it;
1349         if (itself == NULL) return PyMac_Error(resNotFound);
1350         it = PyObject_NEW(TXNFontMenuObjectObject, &TXNFontMenuObject_Type);
1351         if (it == NULL) return NULL;
1352         it->ob_itself = itself;
1353         return (PyObject *)it;
1354 }
1355 int TXNFontMenuObj_Convert(PyObject *v, TXNFontMenuObject *p_itself)
1356 {
1357         if (!TXNFontMenuObj_Check(v))
1358         {
1359                 PyErr_SetString(PyExc_TypeError, "TXNFontMenuObject required");
1360                 return 0;
1361         }
1362         *p_itself = ((TXNFontMenuObjectObject *)v)->ob_itself;
1363         return 1;
1364 }
1365
1366 static void TXNFontMenuObj_dealloc(TXNFontMenuObjectObject *self)
1367 {
1368         /* Cleanup of self->ob_itself goes here */
1369         PyObject_Del(self);
1370 }
1371
1372 static PyObject *TXNFontMenuObj_TXNGetFontMenuHandle(TXNFontMenuObjectObject *_self, PyObject *_args)
1373 {
1374         PyObject *_res = NULL;
1375         OSStatus _err;
1376         MenuHandle oFontMenuHandle;
1377 #ifndef TXNGetFontMenuHandle
1378         PyMac_PRECHECK(TXNGetFontMenuHandle);
1379 #endif
1380         if (!PyArg_ParseTuple(_args, ""))
1381                 return NULL;
1382         _err = TXNGetFontMenuHandle(_self->ob_itself,
1383                                     &oFontMenuHandle);
1384         if (_err != noErr) return PyMac_Error(_err);
1385         _res = Py_BuildValue("O&",
1386                              MenuObj_New, oFontMenuHandle);
1387         return _res;
1388 }
1389
1390 static PyObject *TXNFontMenuObj_TXNDisposeFontMenuObject(TXNFontMenuObjectObject *_self, PyObject *_args)
1391 {
1392         PyObject *_res = NULL;
1393         OSStatus _err;
1394 #ifndef TXNDisposeFontMenuObject
1395         PyMac_PRECHECK(TXNDisposeFontMenuObject);
1396 #endif
1397         if (!PyArg_ParseTuple(_args, ""))
1398                 return NULL;
1399         _err = TXNDisposeFontMenuObject(_self->ob_itself);
1400         if (_err != noErr) return PyMac_Error(_err);
1401         Py_INCREF(Py_None);
1402         _res = Py_None;
1403         return _res;
1404 }
1405
1406 static PyMethodDef TXNFontMenuObj_methods[] = {
1407         {"TXNGetFontMenuHandle", (PyCFunction)TXNFontMenuObj_TXNGetFontMenuHandle, 1,
1408          PyDoc_STR("() -> (MenuHandle oFontMenuHandle)")},
1409         {"TXNDisposeFontMenuObject", (PyCFunction)TXNFontMenuObj_TXNDisposeFontMenuObject, 1,
1410          PyDoc_STR("() -> None")},
1411         {NULL, NULL, 0}
1412 };
1413
1414 PyMethodChain TXNFontMenuObj_chain = { TXNFontMenuObj_methods, NULL };
1415
1416 static PyObject *TXNFontMenuObj_getattr(TXNFontMenuObjectObject *self, char *name)
1417 {
1418         return Py_FindMethodInChain(&TXNFontMenuObj_chain, (PyObject *)self, name);
1419 }
1420
1421 #define TXNFontMenuObj_setattr NULL
1422
1423 #define TXNFontMenuObj_compare NULL
1424
1425 #define TXNFontMenuObj_repr NULL
1426
1427 #define TXNFontMenuObj_hash NULL
1428
1429 PyTypeObject TXNFontMenuObject_Type = {
1430         PyObject_HEAD_INIT(NULL)
1431         0, /*ob_size*/
1432         "_Mlte.TXNFontMenuObject", /*tp_name*/
1433         sizeof(TXNFontMenuObjectObject), /*tp_basicsize*/
1434         0, /*tp_itemsize*/
1435         /* methods */
1436         (destructor) TXNFontMenuObj_dealloc, /*tp_dealloc*/
1437         0, /*tp_print*/
1438         (getattrfunc) TXNFontMenuObj_getattr, /*tp_getattr*/
1439         (setattrfunc) TXNFontMenuObj_setattr, /*tp_setattr*/
1440         (cmpfunc) TXNFontMenuObj_compare, /*tp_compare*/
1441         (reprfunc) TXNFontMenuObj_repr, /*tp_repr*/
1442         (PyNumberMethods *)0, /* tp_as_number */
1443         (PySequenceMethods *)0, /* tp_as_sequence */
1444         (PyMappingMethods *)0, /* tp_as_mapping */
1445         (hashfunc) TXNFontMenuObj_hash, /*tp_hash*/
1446 };
1447
1448 /* --------------- End object type TXNFontMenuObject ---------------- */
1449
1450
1451 static PyObject *Mlte_TXNNewObject(PyObject *_self, PyObject *_args)
1452 {
1453         PyObject *_res = NULL;
1454         OSStatus _err;
1455         FSSpec * iFileSpec;
1456         WindowPtr iWindow;
1457         Rect * iFrame;
1458         TXNFrameOptions iFrameOptions;
1459         TXNFrameType iFrameType;
1460         TXNFileType iFileType;
1461         TXNPermanentTextEncodingType iPermanentEncoding;
1462         TXNObject oTXNObject;
1463         TXNFrameID oTXNFrameID;
1464 #ifndef TXNNewObject
1465         PyMac_PRECHECK(TXNNewObject);
1466 #endif
1467         if (!PyArg_ParseTuple(_args, "O&O&O&llO&l",
1468                               OptFSSpecPtr_Convert, &iFileSpec,
1469                               WinObj_Convert, &iWindow,
1470                               OptRectPtr_Convert, &iFrame,
1471                               &iFrameOptions,
1472                               &iFrameType,
1473                               PyMac_GetOSType, &iFileType,
1474                               &iPermanentEncoding))
1475                 return NULL;
1476         _err = TXNNewObject(iFileSpec,
1477                             iWindow,
1478                             iFrame,
1479                             iFrameOptions,
1480                             iFrameType,
1481                             iFileType,
1482                             iPermanentEncoding,
1483                             &oTXNObject,
1484                             &oTXNFrameID,
1485                             (TXNObjectRefcon)0);
1486         if (_err != noErr) return PyMac_Error(_err);
1487         _res = Py_BuildValue("O&l",
1488                              TXNObj_New, oTXNObject,
1489                              oTXNFrameID);
1490         return _res;
1491 }
1492
1493 static PyObject *Mlte_TXNTerminateTextension(PyObject *_self, PyObject *_args)
1494 {
1495         PyObject *_res = NULL;
1496 #ifndef TXNTerminateTextension
1497         PyMac_PRECHECK(TXNTerminateTextension);
1498 #endif
1499         if (!PyArg_ParseTuple(_args, ""))
1500                 return NULL;
1501         TXNTerminateTextension();
1502         Py_INCREF(Py_None);
1503         _res = Py_None;
1504         return _res;
1505 }
1506
1507 static PyObject *Mlte_TXNIsScrapPastable(PyObject *_self, PyObject *_args)
1508 {
1509         PyObject *_res = NULL;
1510         Boolean _rv;
1511 #ifndef TXNIsScrapPastable
1512         PyMac_PRECHECK(TXNIsScrapPastable);
1513 #endif
1514         if (!PyArg_ParseTuple(_args, ""))
1515                 return NULL;
1516         _rv = TXNIsScrapPastable();
1517         _res = Py_BuildValue("b",
1518                              _rv);
1519         return _res;
1520 }
1521
1522 static PyObject *Mlte_TXNConvertToPublicScrap(PyObject *_self, PyObject *_args)
1523 {
1524         PyObject *_res = NULL;
1525         OSStatus _err;
1526 #ifndef TXNConvertToPublicScrap
1527         PyMac_PRECHECK(TXNConvertToPublicScrap);
1528 #endif
1529         if (!PyArg_ParseTuple(_args, ""))
1530                 return NULL;
1531         _err = TXNConvertToPublicScrap();
1532         if (_err != noErr) return PyMac_Error(_err);
1533         Py_INCREF(Py_None);
1534         _res = Py_None;
1535         return _res;
1536 }
1537
1538 static PyObject *Mlte_TXNConvertFromPublicScrap(PyObject *_self, PyObject *_args)
1539 {
1540         PyObject *_res = NULL;
1541         OSStatus _err;
1542 #ifndef TXNConvertFromPublicScrap
1543         PyMac_PRECHECK(TXNConvertFromPublicScrap);
1544 #endif
1545         if (!PyArg_ParseTuple(_args, ""))
1546                 return NULL;
1547         _err = TXNConvertFromPublicScrap();
1548         if (_err != noErr) return PyMac_Error(_err);
1549         Py_INCREF(Py_None);
1550         _res = Py_None;
1551         return _res;
1552 }
1553
1554 static PyObject *Mlte_TXNNewFontMenuObject(PyObject *_self, PyObject *_args)
1555 {
1556         PyObject *_res = NULL;
1557         OSStatus _err;
1558         MenuHandle iFontMenuHandle;
1559         SInt16 iMenuID;
1560         SInt16 iStartHierMenuID;
1561         TXNFontMenuObject oTXNFontMenuObject;
1562 #ifndef TXNNewFontMenuObject
1563         PyMac_PRECHECK(TXNNewFontMenuObject);
1564 #endif
1565         if (!PyArg_ParseTuple(_args, "O&hh",
1566                               MenuObj_Convert, &iFontMenuHandle,
1567                               &iMenuID,
1568                               &iStartHierMenuID))
1569                 return NULL;
1570         _err = TXNNewFontMenuObject(iFontMenuHandle,
1571                                     iMenuID,
1572                                     iStartHierMenuID,
1573                                     &oTXNFontMenuObject);
1574         if (_err != noErr) return PyMac_Error(_err);
1575         _res = Py_BuildValue("O&",
1576                              TXNFontMenuObj_New, oTXNFontMenuObject);
1577         return _res;
1578 }
1579
1580 static PyObject *Mlte_TXNVersionInformation(PyObject *_self, PyObject *_args)
1581 {
1582         PyObject *_res = NULL;
1583         TXNVersionValue _rv;
1584         TXNFeatureBits oFeatureFlags;
1585 #ifndef TXNVersionInformation
1586         PyMac_PRECHECK(TXNVersionInformation);
1587 #endif
1588         if (!PyArg_ParseTuple(_args, ""))
1589                 return NULL;
1590         _rv = TXNVersionInformation(&oFeatureFlags);
1591         _res = Py_BuildValue("ll",
1592                              _rv,
1593                              oFeatureFlags);
1594         return _res;
1595 }
1596
1597 static PyObject *Mlte_TXNInitTextension(PyObject *_self, PyObject *_args)
1598 {
1599         PyObject *_res = NULL;
1600
1601         OSStatus _err;
1602         TXNMacOSPreferredFontDescription * iDefaultFonts = NULL;
1603         ItemCount iCountDefaultFonts = 0;
1604         TXNInitOptions iUsageFlags;
1605         PyMac_PRECHECK(TXNInitTextension);
1606         if (!PyArg_ParseTuple(_args, "l", &iUsageFlags))
1607                 return NULL;
1608         _err = TXNInitTextension(iDefaultFonts,
1609                                  iCountDefaultFonts,
1610                                  iUsageFlags);
1611         if (_err != noErr) return PyMac_Error(_err);
1612         Py_INCREF(Py_None);
1613         _res = Py_None;
1614         return _res;
1615
1616 }
1617
1618 static PyMethodDef Mlte_methods[] = {
1619         {"TXNNewObject", (PyCFunction)Mlte_TXNNewObject, 1,
1620          PyDoc_STR("(FSSpec * iFileSpec, WindowPtr iWindow, Rect * iFrame, TXNFrameOptions iFrameOptions, TXNFrameType iFrameType, TXNFileType iFileType, TXNPermanentTextEncodingType iPermanentEncoding) -> (TXNObject oTXNObject, TXNFrameID oTXNFrameID)")},
1621         {"TXNTerminateTextension", (PyCFunction)Mlte_TXNTerminateTextension, 1,
1622          PyDoc_STR("() -> None")},
1623         {"TXNIsScrapPastable", (PyCFunction)Mlte_TXNIsScrapPastable, 1,
1624          PyDoc_STR("() -> (Boolean _rv)")},
1625         {"TXNConvertToPublicScrap", (PyCFunction)Mlte_TXNConvertToPublicScrap, 1,
1626          PyDoc_STR("() -> None")},
1627         {"TXNConvertFromPublicScrap", (PyCFunction)Mlte_TXNConvertFromPublicScrap, 1,
1628          PyDoc_STR("() -> None")},
1629         {"TXNNewFontMenuObject", (PyCFunction)Mlte_TXNNewFontMenuObject, 1,
1630          PyDoc_STR("(MenuHandle iFontMenuHandle, SInt16 iMenuID, SInt16 iStartHierMenuID) -> (TXNFontMenuObject oTXNFontMenuObject)")},
1631         {"TXNVersionInformation", (PyCFunction)Mlte_TXNVersionInformation, 1,
1632          PyDoc_STR("() -> (TXNVersionValue _rv, TXNFeatureBits oFeatureFlags)")},
1633         {"TXNInitTextension", (PyCFunction)Mlte_TXNInitTextension, 1,
1634          PyDoc_STR("(TXNInitOptions) -> None")},
1635         {NULL, NULL, 0}
1636 };
1637
1638
1639
1640
1641 void init_Mlte(void)
1642 {
1643         PyObject *m;
1644         PyObject *d;
1645
1646
1647
1648         //      PyMac_INIT_TOOLBOX_OBJECT_NEW(xxxx);
1649
1650
1651         m = Py_InitModule("_Mlte", Mlte_methods);
1652         d = PyModule_GetDict(m);
1653         Mlte_Error = PyMac_GetOSErrException();
1654         if (Mlte_Error == NULL ||
1655             PyDict_SetItemString(d, "Error", Mlte_Error) != 0)
1656                 return;
1657         TXNObject_Type.ob_type = &PyType_Type;
1658         Py_INCREF(&TXNObject_Type);
1659         if (PyDict_SetItemString(d, "TXNObjectType", (PyObject *)&TXNObject_Type) != 0)
1660                 Py_FatalError("can't initialize TXNObjectType");
1661         TXNFontMenuObject_Type.ob_type = &PyType_Type;
1662         Py_INCREF(&TXNFontMenuObject_Type);
1663         if (PyDict_SetItemString(d, "TXNFontMenuObjectType", (PyObject *)&TXNFontMenuObject_Type) != 0)
1664                 Py_FatalError("can't initialize TXNFontMenuObjectType");
1665 }
1666
1667 /* ======================== End module _Mlte ======================== */
1668