Mac/Modules/mlte/Mltemodule.c

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