1 

     2 /* ========================== Module _Mlte ========================== */

     3 

     4 #include "Python.h"

     5 

     6 #ifndef __LP64__

     7 

     8 

     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 #include <Carbon/Carbon.h>

    20 

    21 /* For now we declare them forward here. They'll go to mactoolbox later */

    22 static PyObject *TXNObj_New(TXNObject);

    23 static int TXNObj_Convert(PyObject *, TXNObject *);

    24 static PyObject *TXNFontMenuObj_New(TXNFontMenuObject);

    25 static int TXNFontMenuObj_Convert(PyObject *, TXNFontMenuObject *);

    26 

    27 // ADD declarations

    28 #ifdef NOTYET_USE_TOOLBOX_OBJECT_GLUE

    29 //extern PyObject *_CFTypeRefObj_New(CFTypeRef);

    30 //extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *);

    31 

    32 //#define CFTypeRefObj_New _CFTypeRefObj_New

    33 //#define CFTypeRefObj_Convert _CFTypeRefObj_Convert

    34 #endif

    35 

    36 /*

    37 ** Parse an optional fsspec

    38 */

    39 static int

    40 OptFSSpecPtr_Convert(PyObject *v, FSSpec **p_itself)

    41 {

    42         static FSSpec fss;

    43         if (v == Py_None)

    44         {

    45                 *p_itself = NULL;

    46                 return 1;

    47         }

    48         *p_itself = &fss;

    49         return PyMac_GetFSSpec(v, *p_itself);

    50 }

    51 

    52 /*

    53 ** Parse an optional GWorld

    54 */

    55 static int

    56 OptGWorldObj_Convert(PyObject *v, GWorldPtr *p_itself)

    57 {

    58         if (v == Py_None)

    59         {

    60                 *p_itself = NULL;

    61                 return 1;

    62         }

    63         return GWorldObj_Convert(v, p_itself);

    64 }

    65 

    66 

    67 static PyObject *Mlte_Error;

    68 

    69 /* --------------------- Object type TXNObject ---------------------- */

    70 

    71 PyTypeObject TXNObject_Type;

    72 

    73 #define TXNObj_Check(x) ((x)->ob_type == &TXNObject_Type || PyObject_TypeCheck((x), &TXNObject_Type))

    74 

    75 typedef struct TXNObjectObject {

    76 	PyObject_HEAD

    77 	TXNObject ob_itself;

    78 } TXNObjectObject;

    79 

    80 PyObject *TXNObj_New(TXNObject itself)

    81 {

    82 	TXNObjectObject *it;

    83 	if (itself == NULL) return PyMac_Error(resNotFound);

    84 	it = PyObject_NEW(TXNObjectObject, &TXNObject_Type);

    85 	if (it == NULL) return NULL;

    86 	it->ob_itself = itself;

    87 	return (PyObject *)it;

    88 }

    89 

    90 int TXNObj_Convert(PyObject *v, TXNObject *p_itself)

    91 {

    92 	if (!TXNObj_Check(v))

    93 	{

    94 		PyErr_SetString(PyExc_TypeError, "TXNObject required");

    95 		return 0;

    96 	}

    97 	*p_itself = ((TXNObjectObject *)v)->ob_itself;

    98 	return 1;

    99 }

   100 

   101 static void TXNObj_dealloc(TXNObjectObject *self)

   102 {

   103 	/* Cleanup of self->ob_itself goes here */

   104 	self->ob_type->tp_free((PyObject *)self);

   105 }

   106 

   107 static PyObject *TXNObj_TXNDeleteObject(TXNObjectObject *_self, PyObject *_args)

   108 {

   109 	PyObject *_res = NULL;

   110 #ifndef TXNDeleteObject

   111 	PyMac_PRECHECK(TXNDeleteObject);

   112 #endif

   113 	if (!PyArg_ParseTuple(_args, ""))

   114 		return NULL;

   115 	TXNDeleteObject(_self->ob_itself);

   116 	Py_INCREF(Py_None);

   117 	_res = Py_None;

   118 	return _res;

   119 }

   120 

   121 static PyObject *TXNObj_TXNResizeFrame(TXNObjectObject *_self, PyObject *_args)

   122 {

   123 	PyObject *_res = NULL;

   124 	UInt32 iWidth;

   125 	UInt32 iHeight;

   126 	TXNFrameID iTXNFrameID;

   127 #ifndef TXNResizeFrame

   128 	PyMac_PRECHECK(TXNResizeFrame);

   129 #endif

   130 	if (!PyArg_ParseTuple(_args, "lll",

   131 	                      &iWidth,

   132 	                      &iHeight,

   133 	                      &iTXNFrameID))

   134 		return NULL;

   135 	TXNResizeFrame(_self->ob_itself,

   136 	               iWidth,

   137 	               iHeight,

   138 	               iTXNFrameID);

   139 	Py_INCREF(Py_None);

   140 	_res = Py_None;

   141 	return _res;

   142 }

   143 

   144 static PyObject *TXNObj_TXNSetFrameBounds(TXNObjectObject *_self, PyObject *_args)

   145 {

   146 	PyObject *_res = NULL;

   147 	SInt32 iTop;

   148 	SInt32 iLeft;

   149 	SInt32 iBottom;

   150 	SInt32 iRight;

   151 	TXNFrameID iTXNFrameID;

   152 #ifndef TXNSetFrameBounds

   153 	PyMac_PRECHECK(TXNSetFrameBounds);

   154 #endif

   155 	if (!PyArg_ParseTuple(_args, "lllll",

   156 	                      &iTop,

   157 	                      &iLeft,

   158 	                      &iBottom,

   159 	                      &iRight,

   160 	                      &iTXNFrameID))

   161 		return NULL;

   162 	TXNSetFrameBounds(_self->ob_itself,

   163 	                  iTop,

   164 	                  iLeft,

   165 	                  iBottom,

   166 	                  iRight,

   167 	                  iTXNFrameID);

   168 	Py_INCREF(Py_None);

   169 	_res = Py_None;

   170 	return _res;

   171 }

   172 

   173 static PyObject *TXNObj_TXNKeyDown(TXNObjectObject *_self, PyObject *_args)

   174 {

   175 	PyObject *_res = NULL;

   176 	EventRecord iEvent;

   177 #ifndef TXNKeyDown

   178 	PyMac_PRECHECK(TXNKeyDown);

   179 #endif

   180 	if (!PyArg_ParseTuple(_args, "O&",

   181 	                      PyMac_GetEventRecord, &iEvent))

   182 		return NULL;

   183 	TXNKeyDown(_self->ob_itself,

   184 	           &iEvent);

   185 	Py_INCREF(Py_None);

   186 	_res = Py_None;

   187 	return _res;

   188 }

   189 

   190 static PyObject *TXNObj_TXNAdjustCursor(TXNObjectObject *_self, PyObject *_args)

   191 {

   192 	PyObject *_res = NULL;

   193 	RgnHandle ioCursorRgn;

   194 #ifndef TXNAdjustCursor

   195 	PyMac_PRECHECK(TXNAdjustCursor);

   196 #endif

   197 	if (!PyArg_ParseTuple(_args, "O&",

   198 	                      OptResObj_Convert, &ioCursorRgn))

   199 		return NULL;

   200 	TXNAdjustCursor(_self->ob_itself,

   201 	                ioCursorRgn);

   202 	Py_INCREF(Py_None);

   203 	_res = Py_None;

   204 	return _res;

   205 }

   206 

   207 static PyObject *TXNObj_TXNClick(TXNObjectObject *_self, PyObject *_args)

   208 {

   209 	PyObject *_res = NULL;

   210 	EventRecord iEvent;

   211 #ifndef TXNClick

   212 	PyMac_PRECHECK(TXNClick);

   213 #endif

   214 	if (!PyArg_ParseTuple(_args, "O&",

   215 	                      PyMac_GetEventRecord, &iEvent))

   216 		return NULL;

   217 	TXNClick(_self->ob_itself,

   218 	         &iEvent);

   219 	Py_INCREF(Py_None);

   220 	_res = Py_None;

   221 	return _res;

   222 }

   223 

   224 static PyObject *TXNObj_TXNSelectAll(TXNObjectObject *_self, PyObject *_args)

   225 {

   226 	PyObject *_res = NULL;

   227 #ifndef TXNSelectAll

   228 	PyMac_PRECHECK(TXNSelectAll);

   229 #endif

   230 	if (!PyArg_ParseTuple(_args, ""))

   231 		return NULL;

   232 	TXNSelectAll(_self->ob_itself);

   233 	Py_INCREF(Py_None);

   234 	_res = Py_None;

   235 	return _res;

   236 }

   237 

   238 static PyObject *TXNObj_TXNFocus(TXNObjectObject *_self, PyObject *_args)

   239 {

   240 	PyObject *_res = NULL;

   241 	Boolean iBecomingFocused;

   242 #ifndef TXNFocus

   243 	PyMac_PRECHECK(TXNFocus);

   244 #endif

   245 	if (!PyArg_ParseTuple(_args, "b",

   246 	                      &iBecomingFocused))

   247 		return NULL;

   248 	TXNFocus(_self->ob_itself,

   249 	         iBecomingFocused);

   250 	Py_INCREF(Py_None);

   251 	_res = Py_None;

   252 	return _res;

   253 }

   254 

   255 static PyObject *TXNObj_TXNUpdate(TXNObjectObject *_self, PyObject *_args)

   256 {

   257 	PyObject *_res = NULL;

   258 #ifndef TXNUpdate

   259 	PyMac_PRECHECK(TXNUpdate);

   260 #endif

   261 	if (!PyArg_ParseTuple(_args, ""))

   262 		return NULL;

   263 	TXNUpdate(_self->ob_itself);

   264 	Py_INCREF(Py_None);

   265 	_res = Py_None;

   266 	return _res;

   267 }

   268 

   269 static PyObject *TXNObj_TXNDraw(TXNObjectObject *_self, PyObject *_args)

   270 {

   271 	PyObject *_res = NULL;

   272 	GWorldPtr iDrawPort;

   273 #ifndef TXNDraw

   274 	PyMac_PRECHECK(TXNDraw);

   275 #endif

   276 	if (!PyArg_ParseTuple(_args, "O&",

   277 	                      OptGWorldObj_Convert, &iDrawPort))

   278 		return NULL;

   279 	TXNDraw(_self->ob_itself,

   280 	        iDrawPort);

   281 	Py_INCREF(Py_None);

   282 	_res = Py_None;

   283 	return _res;

   284 }

   285 

   286 static PyObject *TXNObj_TXNForceUpdate(TXNObjectObject *_self, PyObject *_args)

   287 {

   288 	PyObject *_res = NULL;

   289 #ifndef TXNForceUpdate

   290 	PyMac_PRECHECK(TXNForceUpdate);

   291 #endif

   292 	if (!PyArg_ParseTuple(_args, ""))

   293 		return NULL;

   294 	TXNForceUpdate(_self->ob_itself);

   295 	Py_INCREF(Py_None);

   296 	_res = Py_None;

   297 	return _res;

   298 }

   299 

   300 static PyObject *TXNObj_TXNGetSleepTicks(TXNObjectObject *_self, PyObject *_args)

   301 {

   302 	PyObject *_res = NULL;

   303 	UInt32 _rv;

   304 #ifndef TXNGetSleepTicks

   305 	PyMac_PRECHECK(TXNGetSleepTicks);

   306 #endif

   307 	if (!PyArg_ParseTuple(_args, ""))

   308 		return NULL;

   309 	_rv = TXNGetSleepTicks(_self->ob_itself);

   310 	_res = Py_BuildValue("l",

   311 	                     _rv);

   312 	return _res;

   313 }

   314 

   315 static PyObject *TXNObj_TXNIdle(TXNObjectObject *_self, PyObject *_args)

   316 {

   317 	PyObject *_res = NULL;

   318 #ifndef TXNIdle

   319 	PyMac_PRECHECK(TXNIdle);

   320 #endif

   321 	if (!PyArg_ParseTuple(_args, ""))

   322 		return NULL;

   323 	TXNIdle(_self->ob_itself);

   324 	Py_INCREF(Py_None);

   325 	_res = Py_None;

   326 	return _res;

   327 }

   328 

   329 static PyObject *TXNObj_TXNGrowWindow(TXNObjectObject *_self, PyObject *_args)

   330 {

   331 	PyObject *_res = NULL;

   332 	EventRecord iEvent;

   333 #ifndef TXNGrowWindow

   334 	PyMac_PRECHECK(TXNGrowWindow);

   335 #endif

   336 	if (!PyArg_ParseTuple(_args, "O&",

   337 	                      PyMac_GetEventRecord, &iEvent))

   338 		return NULL;

   339 	TXNGrowWindow(_self->ob_itself,

   340 	              &iEvent);

   341 	Py_INCREF(Py_None);

   342 	_res = Py_None;

   343 	return _res;

   344 }

   345 

   346 static PyObject *TXNObj_TXNZoomWindow(TXNObjectObject *_self, PyObject *_args)

   347 {

   348 	PyObject *_res = NULL;

   349 	SInt16 iPart;

   350 #ifndef TXNZoomWindow

   351 	PyMac_PRECHECK(TXNZoomWindow);

   352 #endif

   353 	if (!PyArg_ParseTuple(_args, "h",

   354 	                      &iPart))

   355 		return NULL;

   356 	TXNZoomWindow(_self->ob_itself,

   357 	              iPart);

   358 	Py_INCREF(Py_None);

   359 	_res = Py_None;

   360 	return _res;

   361 }

   362 

   363 static PyObject *TXNObj_TXNCanUndo(TXNObjectObject *_self, PyObject *_args)

   364 {

   365 	PyObject *_res = NULL;

   366 	Boolean _rv;

   367 	TXNActionKey oTXNActionKey;

   368 #ifndef TXNCanUndo

   369 	PyMac_PRECHECK(TXNCanUndo);

   370 #endif

   371 	if (!PyArg_ParseTuple(_args, ""))

   372 		return NULL;

   373 	_rv = TXNCanUndo(_self->ob_itself,

   374 	                 &oTXNActionKey);

   375 	_res = Py_BuildValue("bl",

   376 	                     _rv,

   377 	                     oTXNActionKey);

   378 	return _res;

   379 }

   380 

   381 static PyObject *TXNObj_TXNUndo(TXNObjectObject *_self, PyObject *_args)

   382 {

   383 	PyObject *_res = NULL;

   384 #ifndef TXNUndo

   385 	PyMac_PRECHECK(TXNUndo);

   386 #endif

   387 	if (!PyArg_ParseTuple(_args, ""))

   388 		return NULL;

   389 	TXNUndo(_self->ob_itself);

   390 	Py_INCREF(Py_None);

   391 	_res = Py_None;

   392 	return _res;

   393 }

   394 

   395 static PyObject *TXNObj_TXNCanRedo(TXNObjectObject *_self, PyObject *_args)

   396 {

   397 	PyObject *_res = NULL;

   398 	Boolean _rv;

   399 	TXNActionKey oTXNActionKey;

   400 #ifndef TXNCanRedo

   401 	PyMac_PRECHECK(TXNCanRedo);

   402 #endif

   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 #ifndef TXNRedo

   417 	PyMac_PRECHECK(TXNRedo);

   418 #endif

   419 	if (!PyArg_ParseTuple(_args, ""))

   420 		return NULL;

   421 	TXNRedo(_self->ob_itself);

   422 	Py_INCREF(Py_None);

   423 	_res = Py_None;

   424 	return _res;

   425 }

   426 

   427 static PyObject *TXNObj_TXNCut(TXNObjectObject *_self, PyObject *_args)

   428 {

   429 	PyObject *_res = NULL;

   430 	OSStatus _err;

   431 #ifndef TXNCut

   432 	PyMac_PRECHECK(TXNCut);

   433 #endif

   434 	if (!PyArg_ParseTuple(_args, ""))

   435 		return NULL;

   436 	_err = TXNCut(_self->ob_itself);

   437 	if (_err != noErr) return PyMac_Error(_err);

   438 	Py_INCREF(Py_None);

   439 	_res = Py_None;

   440 	return _res;

   441 }

   442 

   443 static PyObject *TXNObj_TXNCopy(TXNObjectObject *_self, PyObject *_args)

   444 {

   445 	PyObject *_res = NULL;

   446 	OSStatus _err;

   447 #ifndef TXNCopy

   448 	PyMac_PRECHECK(TXNCopy);

   449 #endif

   450 	if (!PyArg_ParseTuple(_args, ""))

   451 		return NULL;

   452 	_err = TXNCopy(_self->ob_itself);

   453 	if (_err != noErr) return PyMac_Error(_err);

   454 	Py_INCREF(Py_None);

   455 	_res = Py_None;

   456 	return _res;

   457 }

   458 

   459 static PyObject *TXNObj_TXNPaste(TXNObjectObject *_self, PyObject *_args)

   460 {

   461 	PyObject *_res = NULL;

   462 	OSStatus _err;

   463 #ifndef TXNPaste

   464 	PyMac_PRECHECK(TXNPaste);

   465 #endif

   466 	if (!PyArg_ParseTuple(_args, ""))

   467 		return NULL;

   468 	_err = TXNPaste(_self->ob_itself);

   469 	if (_err != noErr) return PyMac_Error(_err);

   470 	Py_INCREF(Py_None);

   471 	_res = Py_None;

   472 	return _res;

   473 }

   474 

   475 static PyObject *TXNObj_TXNClear(TXNObjectObject *_self, PyObject *_args)

   476 {

   477 	PyObject *_res = NULL;

   478 	OSStatus _err;

   479 #ifndef TXNClear

   480 	PyMac_PRECHECK(TXNClear);

   481 #endif

   482 	if (!PyArg_ParseTuple(_args, ""))

   483 		return NULL;

   484 	_err = TXNClear(_self->ob_itself);

   485 	if (_err != noErr) return PyMac_Error(_err);

   486 	Py_INCREF(Py_None);

   487 	_res = Py_None;

   488 	return _res;

   489 }

   490 

   491 static PyObject *TXNObj_TXNGetSelection(TXNObjectObject *_self, PyObject *_args)

   492 {

   493 	PyObject *_res = NULL;

   494 	TXNOffset oStartOffset;

   495 	TXNOffset oEndOffset;

   496 #ifndef TXNGetSelection

   497 	PyMac_PRECHECK(TXNGetSelection);

   498 #endif

   499 	if (!PyArg_ParseTuple(_args, ""))

   500 		return NULL;

   501 	TXNGetSelection(_self->ob_itself,

   502 	                &oStartOffset,

   503 	                &oEndOffset);

   504 	_res = Py_BuildValue("ll",

   505 	                     oStartOffset,

   506 	                     oEndOffset);

   507 	return _res;

   508 }

   509 

   510 static PyObject *TXNObj_TXNShowSelection(TXNObjectObject *_self, PyObject *_args)

   511 {

   512 	PyObject *_res = NULL;

   513 	Boolean iShowEnd;

   514 #ifndef TXNShowSelection

   515 	PyMac_PRECHECK(TXNShowSelection);

   516 #endif

   517 	if (!PyArg_ParseTuple(_args, "b",

   518 	                      &iShowEnd))

   519 		return NULL;

   520 	TXNShowSelection(_self->ob_itself,

   521 	                 iShowEnd);

   522 	Py_INCREF(Py_None);

   523 	_res = Py_None;

   524 	return _res;

   525 }

   526 

   527 static PyObject *TXNObj_TXNIsSelectionEmpty(TXNObjectObject *_self, PyObject *_args)

   528 {

   529 	PyObject *_res = NULL;

   530 	Boolean _rv;

   531 #ifndef TXNIsSelectionEmpty

   532 	PyMac_PRECHECK(TXNIsSelectionEmpty);

   533 #endif

   534 	if (!PyArg_ParseTuple(_args, ""))

   535 		return NULL;

   536 	_rv = TXNIsSelectionEmpty(_self->ob_itself);

   537 	_res = Py_BuildValue("b",

   538 	                     _rv);

   539 	return _res;

   540 }

   541 

   542 static PyObject *TXNObj_TXNSetSelection(TXNObjectObject *_self, PyObject *_args)

   543 {

   544 	PyObject *_res = NULL;

   545 	OSStatus _err;

   546 	TXNOffset iStartOffset;

   547 	TXNOffset iEndOffset;

   548 #ifndef TXNSetSelection

   549 	PyMac_PRECHECK(TXNSetSelection);

   550 #endif

   551 	if (!PyArg_ParseTuple(_args, "ll",

   552 	                      &iStartOffset,

   553 	                      &iEndOffset))

   554 		return NULL;

   555 	_err = TXNSetSelection(_self->ob_itself,

   556 	                       iStartOffset,

   557 	                       iEndOffset);

   558 	if (_err != noErr) return PyMac_Error(_err);

   559 	Py_INCREF(Py_None);

   560 	_res = Py_None;

   561 	return _res;

   562 }

   563 

   564 static PyObject *TXNObj_TXNCountRunsInRange(TXNObjectObject *_self, PyObject *_args)

   565 {

   566 	PyObject *_res = NULL;

   567 	OSStatus _err;

   568 	TXNOffset iStartOffset;

   569 	TXNOffset iEndOffset;

   570 	ItemCount oRunCount;

   571 #ifndef TXNCountRunsInRange

   572 	PyMac_PRECHECK(TXNCountRunsInRange);

   573 #endif

   574 	if (!PyArg_ParseTuple(_args, "ll",

   575 	                      &iStartOffset,

   576 	                      &iEndOffset))

   577 		return NULL;

   578 	_err = TXNCountRunsInRange(_self->ob_itself,

   579 	                           iStartOffset,

   580 	                           iEndOffset,

   581 	                           &oRunCount);

   582 	if (_err != noErr) return PyMac_Error(_err);

   583 	_res = Py_BuildValue("l",

   584 	                     oRunCount);

   585 	return _res;

   586 }

   587 

   588 static PyObject *TXNObj_TXNDataSize(TXNObjectObject *_self, PyObject *_args)

   589 {

   590 	PyObject *_res = NULL;

   591 	ByteCount _rv;

   592 #ifndef TXNDataSize

   593 	PyMac_PRECHECK(TXNDataSize);

   594 #endif

   595 	if (!PyArg_ParseTuple(_args, ""))

   596 		return NULL;

   597 	_rv = TXNDataSize(_self->ob_itself);

   598 	_res = Py_BuildValue("l",

   599 	                     _rv);

   600 	return _res;

   601 }

   602 

   603 static PyObject *TXNObj_TXNGetData(TXNObjectObject *_self, PyObject *_args)

   604 {

   605 	PyObject *_res = NULL;

   606 	OSStatus _err;

   607 	TXNOffset iStartOffset;

   608 	TXNOffset iEndOffset;

   609 	Handle oDataHandle;

   610 #ifndef TXNGetData

   611 	PyMac_PRECHECK(TXNGetData);

   612 #endif

   613 	if (!PyArg_ParseTuple(_args, "ll",

   614 	                      &iStartOffset,

   615 	                      &iEndOffset))

   616 		return NULL;

   617 	_err = TXNGetData(_self->ob_itself,

   618 	                  iStartOffset,

   619 	                  iEndOffset,

   620 	                  &oDataHandle);

   621 	if (_err != noErr) return PyMac_Error(_err);

   622 	_res = Py_BuildValue("O&",

   623 	                     ResObj_New, oDataHandle);

   624 	return _res;

   625 }

   626 

   627 static PyObject *TXNObj_TXNGetDataEncoded(TXNObjectObject *_self, PyObject *_args)

   628 {

   629 	PyObject *_res = NULL;

   630 	OSStatus _err;

   631 	TXNOffset iStartOffset;

   632 	TXNOffset iEndOffset;

   633 	Handle oDataHandle;

   634 	TXNDataType iEncoding;

   635 #ifndef TXNGetDataEncoded

   636 	PyMac_PRECHECK(TXNGetDataEncoded);

   637 #endif

   638 	if (!PyArg_ParseTuple(_args, "llO&",

   639 	                      &iStartOffset,

   640 	                      &iEndOffset,

   641 	                      PyMac_GetOSType, &iEncoding))

   642 		return NULL;

   643 	_err = TXNGetDataEncoded(_self->ob_itself,

   644 	                         iStartOffset,

   645 	                         iEndOffset,

   646 	                         &oDataHandle,

   647 	                         iEncoding);

   648 	if (_err != noErr) return PyMac_Error(_err);

   649 	_res = Py_BuildValue("O&",

   650 	                     ResObj_New, oDataHandle);

   651 	return _res;

   652 }

   653 

   654 static PyObject *TXNObj_TXNSetDataFromFile(TXNObjectObject *_self, PyObject *_args)

   655 {

   656 	PyObject *_res = NULL;

   657 	OSStatus _err;

   658 	SInt16 iFileRefNum;

   659 	OSType iFileType;

   660 	ByteCount iFileLength;

   661 	TXNOffset iStartOffset;

   662 	TXNOffset iEndOffset;

   663 #ifndef TXNSetDataFromFile

   664 	PyMac_PRECHECK(TXNSetDataFromFile);

   665 #endif

   666 	if (!PyArg_ParseTuple(_args, "hO&lll",

   667 	                      &iFileRefNum,

   668 	                      PyMac_GetOSType, &iFileType,

   669 	                      &iFileLength,

   670 	                      &iStartOffset,

   671 	                      &iEndOffset))

   672 		return NULL;

   673 	_err = TXNSetDataFromFile(_self->ob_itself,

   674 	                          iFileRefNum,

   675 	                          iFileType,

   676 	                          iFileLength,

   677 	                          iStartOffset,

   678 	                          iEndOffset);

   679 	if (_err != noErr) return PyMac_Error(_err);

   680 	Py_INCREF(Py_None);

   681 	_res = Py_None;

   682 	return _res;

   683 }

   684 

   685 static PyObject *TXNObj_TXNGetChangeCount(TXNObjectObject *_self, PyObject *_args)

   686 {

   687 	PyObject *_res = NULL;

   688 	ItemCount _rv;

   689 #ifndef TXNGetChangeCount

   690 	PyMac_PRECHECK(TXNGetChangeCount);

   691 #endif

   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 	TXNFileType iType;

   705 	OSType iResType;

   706 	TXNPermanentTextEncodingType iPermanentEncoding;

   707 	FSSpec iFileSpecification;

   708 	SInt16 iDataReference;

   709 	SInt16 iResourceReference;

   710 #ifndef TXNSave

   711 	PyMac_PRECHECK(TXNSave);

   712 #endif

   713 	if (!PyArg_ParseTuple(_args, "O&O&lO&hh",

   714 	                      PyMac_GetOSType, &iType,

   715 	                      PyMac_GetOSType, &iResType,

   716 	                      &iPermanentEncoding,

   717 	                      PyMac_GetFSSpec, &iFileSpecification,

   718 	                      &iDataReference,

   719 	                      &iResourceReference))

   720 		return NULL;

   721 	_err = TXNSave(_self->ob_itself,

   722 	               iType,

   723 	               iResType,

   724 	               iPermanentEncoding,

   725 	               &iFileSpecification,

   726 	               iDataReference,

   727 	               iResourceReference);

   728 	if (_err != noErr) return PyMac_Error(_err);

   729 	Py_INCREF(Py_None);

   730 	_res = Py_None;

   731 	return _res;

   732 }

   733 

   734 static PyObject *TXNObj_TXNRevert(TXNObjectObject *_self, PyObject *_args)

   735 {

   736 	PyObject *_res = NULL;

   737 	OSStatus _err;

   738 #ifndef TXNRevert

   739 	PyMac_PRECHECK(TXNRevert);

   740 #endif

   741 	if (!PyArg_ParseTuple(_args, ""))

   742 		return NULL;

   743 	_err = TXNRevert(_self->ob_itself);

   744 	if (_err != noErr) return PyMac_Error(_err);

   745 	Py_INCREF(Py_None);

   746 	_res = Py_None;

   747 	return _res;

   748 }

   749 

   750 static PyObject *TXNObj_TXNPageSetup(TXNObjectObject *_self, PyObject *_args)

   751 {

   752 	PyObject *_res = NULL;

   753 	OSStatus _err;

   754 #ifndef TXNPageSetup

   755 	PyMac_PRECHECK(TXNPageSetup);

   756 #endif

   757 	if (!PyArg_ParseTuple(_args, ""))

   758 		return NULL;

   759 	_err = TXNPageSetup(_self->ob_itself);

   760 	if (_err != noErr) return PyMac_Error(_err);

   761 	Py_INCREF(Py_None);

   762 	_res = Py_None;

   763 	return _res;

   764 }

   765 

   766 static PyObject *TXNObj_TXNPrint(TXNObjectObject *_self, PyObject *_args)

   767 {

   768 	PyObject *_res = NULL;

   769 	OSStatus _err;

   770 #ifndef TXNPrint

   771 	PyMac_PRECHECK(TXNPrint);

   772 #endif

   773 	if (!PyArg_ParseTuple(_args, ""))

   774 		return NULL;

   775 	_err = TXNPrint(_self->ob_itself);

   776 	if (_err != noErr) return PyMac_Error(_err);

   777 	Py_INCREF(Py_None);

   778 	_res = Py_None;

   779 	return _res;

   780 }

   781 

   782 static PyObject *TXNObj_TXNGetViewRect(TXNObjectObject *_self, PyObject *_args)

   783 {

   784 	PyObject *_res = NULL;

   785 	Rect oViewRect;

   786 #ifndef TXNGetViewRect

   787 	PyMac_PRECHECK(TXNGetViewRect);

   788 #endif

   789 	if (!PyArg_ParseTuple(_args, ""))

   790 		return NULL;

   791 	TXNGetViewRect(_self->ob_itself,

   792 	               &oViewRect);

   793 	_res = Py_BuildValue("O&",

   794 	                     PyMac_BuildRect, &oViewRect);

   795 	return _res;

   796 }

   797 

   798 static PyObject *TXNObj_TXNSetViewRect(TXNObjectObject *_self, PyObject *_args)

   799 {

   800 	PyObject *_res = NULL;

   801 	Rect iViewRect;

   802 #ifndef TXNSetViewRect

   803 	PyMac_PRECHECK(TXNSetViewRect);

   804 #endif

   805 	if (!PyArg_ParseTuple(_args, "O&",

   806 	                      PyMac_GetRect, &iViewRect))

   807 		return NULL;

   808 	TXNSetViewRect(_self->ob_itself,

   809 	               &iViewRect);

   810 	Py_INCREF(Py_None);

   811 	_res = Py_None;

   812 	return _res;

   813 }

   814 

   815 static PyObject *TXNObj_TXNAttachObjectToWindow(TXNObjectObject *_self, PyObject *_args)

   816 {

   817 	PyObject *_res = NULL;

   818 	OSStatus _err;

   819 	GWorldPtr iWindow;

   820 	Boolean iIsActualWindow;

   821 #ifndef TXNAttachObjectToWindow

   822 	PyMac_PRECHECK(TXNAttachObjectToWindow);

   823 #endif

   824 	if (!PyArg_ParseTuple(_args, "O&b",

   825 	                      GWorldObj_Convert, &iWindow,

   826 	                      &iIsActualWindow))

   827 		return NULL;

   828 	_err = TXNAttachObjectToWindow(_self->ob_itself,

   829 	                               iWindow,

   830 	                               iIsActualWindow);

   831 	if (_err != noErr) return PyMac_Error(_err);

   832 	Py_INCREF(Py_None);

   833 	_res = Py_None;

   834 	return _res;

   835 }

   836 

   837 static PyObject *TXNObj_TXNIsObjectAttachedToWindow(TXNObjectObject *_self, PyObject *_args)

   838 {

   839 	PyObject *_res = NULL;

   840 	Boolean _rv;

   841 #ifndef TXNIsObjectAttachedToWindow

   842 	PyMac_PRECHECK(TXNIsObjectAttachedToWindow);

   843 #endif

   844 	if (!PyArg_ParseTuple(_args, ""))

   845 		return NULL;

   846 	_rv = TXNIsObjectAttachedToWindow(_self->ob_itself);

   847 	_res = Py_BuildValue("b",

   848 	                     _rv);

   849 	return _res;

   850 }

   851 

   852 static PyObject *TXNObj_TXNDragTracker(TXNObjectObject *_self, PyObject *_args)

   853 {

   854 	PyObject *_res = NULL;

   855 	OSErr _err;

   856 	TXNFrameID iTXNFrameID;

   857 	DragTrackingMessage iMessage;

   858 	WindowPtr iWindow;

   859 	DragReference iDragReference;

   860 	Boolean iDifferentObjectSameWindow;

   861 #ifndef TXNDragTracker

   862 	PyMac_PRECHECK(TXNDragTracker);

   863 #endif

   864 	if (!PyArg_ParseTuple(_args, "lhO&O&b",

   865 	                      &iTXNFrameID,

   866 	                      &iMessage,

   867 	                      WinObj_Convert, &iWindow,

   868 	                      DragObj_Convert, &iDragReference,

   869 	                      &iDifferentObjectSameWindow))

   870 		return NULL;

   871 	_err = TXNDragTracker(_self->ob_itself,

   872 	                      iTXNFrameID,

   873 	                      iMessage,

   874 	                      iWindow,

   875 	                      iDragReference,

   876 	                      iDifferentObjectSameWindow);

   877 	if (_err != noErr) return PyMac_Error(_err);

   878 	Py_INCREF(Py_None);

   879 	_res = Py_None;

   880 	return _res;

   881 }

   882 

   883 static PyObject *TXNObj_TXNDragReceiver(TXNObjectObject *_self, PyObject *_args)

   884 {

   885 	PyObject *_res = NULL;

   886 	OSErr _err;

   887 	TXNFrameID iTXNFrameID;

   888 	WindowPtr iWindow;

   889 	DragReference iDragReference;

   890 	Boolean iDifferentObjectSameWindow;

   891 #ifndef TXNDragReceiver

   892 	PyMac_PRECHECK(TXNDragReceiver);

   893 #endif

   894 	if (!PyArg_ParseTuple(_args, "lO&O&b",

   895 	                      &iTXNFrameID,

   896 	                      WinObj_Convert, &iWindow,

   897 	                      DragObj_Convert, &iDragReference,

   898 	                      &iDifferentObjectSameWindow))

   899 		return NULL;

   900 	_err = TXNDragReceiver(_self->ob_itself,

   901 	                       iTXNFrameID,

   902 	                       iWindow,

   903 	                       iDragReference,

   904 	                       iDifferentObjectSameWindow);

   905 	if (_err != noErr) return PyMac_Error(_err);

   906 	Py_INCREF(Py_None);

   907 	_res = Py_None;

   908 	return _res;

   909 }

   910 

   911 static PyObject *TXNObj_TXNActivate(TXNObjectObject *_self, PyObject *_args)

   912 {

   913 	PyObject *_res = NULL;

   914 	OSStatus _err;

   915 	TXNFrameID iTXNFrameID;

   916 	TXNScrollBarState iActiveState;

   917 #ifndef TXNActivate

   918 	PyMac_PRECHECK(TXNActivate);

   919 #endif

   920 	if (!PyArg_ParseTuple(_args, "ll",

   921 	                      &iTXNFrameID,

   922 	                      &iActiveState))

   923 		return NULL;

   924 	_err = TXNActivate(_self->ob_itself,

   925 	                   iTXNFrameID,

   926 	                   iActiveState);

   927 	if (_err != noErr) return PyMac_Error(_err);

   928 	Py_INCREF(Py_None);

   929 	_res = Py_None;

   930 	return _res;

   931 }

   932 

   933 static PyObject *TXNObj_TXNEchoMode(TXNObjectObject *_self, PyObject *_args)

   934 {

   935 	PyObject *_res = NULL;

   936 	OSStatus _err;

   937 	UniChar iEchoCharacter;

   938 	TextEncoding iEncoding;

   939 	Boolean iOn;

   940 #ifndef TXNEchoMode

   941 	PyMac_PRECHECK(TXNEchoMode);

   942 #endif

   943 	if (!PyArg_ParseTuple(_args, "hlb",

   944 	                      &iEchoCharacter,

   945 	                      &iEncoding,

   946 	                      &iOn))

   947 		return NULL;

   948 	_err = TXNEchoMode(_self->ob_itself,

   949 	                   iEchoCharacter,

   950 	                   iEncoding,

   951 	                   iOn);

   952 	if (_err != noErr) return PyMac_Error(_err);

   953 	Py_INCREF(Py_None);

   954 	_res = Py_None;

   955 	return _res;

   956 }

   957 

   958 static PyObject *TXNObj_TXNDoFontMenuSelection(TXNObjectObject *_self, PyObject *_args)

   959 {

   960 	PyObject *_res = NULL;

   961 	OSStatus _err;

   962 	TXNFontMenuObject iTXNFontMenuObject;

   963 	SInt16 iMenuID;

   964 	SInt16 iMenuItem;

   965 #ifndef TXNDoFontMenuSelection

   966 	PyMac_PRECHECK(TXNDoFontMenuSelection);

   967 #endif

   968 	if (!PyArg_ParseTuple(_args, "O&hh",

   969 	                      TXNFontMenuObj_Convert, &iTXNFontMenuObject,

   970 	                      &iMenuID,

   971 	                      &iMenuItem))

   972 		return NULL;

   973 	_err = TXNDoFontMenuSelection(_self->ob_itself,

   974 	                              iTXNFontMenuObject,

   975 	                              iMenuID,

   976 	                              iMenuItem);

   977 	if (_err != noErr) return PyMac_Error(_err);

   978 	Py_INCREF(Py_None);

   979 	_res = Py_None;

   980 	return _res;

   981 }

   982 

   983 static PyObject *TXNObj_TXNPrepareFontMenu(TXNObjectObject *_self, PyObject *_args)

   984 {

   985 	PyObject *_res = NULL;

   986 	OSStatus _err;

   987 	TXNFontMenuObject iTXNFontMenuObject;

   988 #ifndef TXNPrepareFontMenu

   989 	PyMac_PRECHECK(TXNPrepareFontMenu);

   990 #endif

   991 	if (!PyArg_ParseTuple(_args, "O&",

   992 	                      TXNFontMenuObj_Convert, &iTXNFontMenuObject))

   993 		return NULL;

   994 	_err = TXNPrepareFontMenu(_self->ob_itself,

   995 	                          iTXNFontMenuObject);

   996 	if (_err != noErr) return PyMac_Error(_err);

   997 	Py_INCREF(Py_None);

   998 	_res = Py_None;

   999 	return _res;

  1000 }

  1001 

  1002 static PyObject *TXNObj_TXNPointToOffset(TXNObjectObject *_self, PyObject *_args)

  1003 {

  1004 	PyObject *_res = NULL;

  1005 	OSStatus _err;

  1006 	Point iPoint;

  1007 	TXNOffset oOffset;

  1008 #ifndef TXNPointToOffset

  1009 	PyMac_PRECHECK(TXNPointToOffset);

  1010 #endif

  1011 	if (!PyArg_ParseTuple(_args, "O&",

  1012 	                      PyMac_GetPoint, &iPoint))

  1013 		return NULL;

  1014 	_err = TXNPointToOffset(_self->ob_itself,

  1015 	                        iPoint,

  1016 	                        &oOffset);

  1017 	if (_err != noErr) return PyMac_Error(_err);

  1018 	_res = Py_BuildValue("l",

  1019 	                     oOffset);

  1020 	return _res;

  1021 }

  1022 

  1023 static PyObject *TXNObj_TXNOffsetToPoint(TXNObjectObject *_self, PyObject *_args)

  1024 {

  1025 	PyObject *_res = NULL;

  1026 	OSStatus _err;

  1027 	TXNOffset iOffset;

  1028 	Point oPoint;

  1029 #ifndef TXNOffsetToPoint

  1030 	PyMac_PRECHECK(TXNOffsetToPoint);

  1031 #endif

  1032 	if (!PyArg_ParseTuple(_args, "l",

  1033 	                      &iOffset))

  1034 		return NULL;

  1035 	_err = TXNOffsetToPoint(_self->ob_itself,

  1036 	                        iOffset,

  1037 	                        &oPoint);

  1038 	if (_err != noErr) return PyMac_Error(_err);

  1039 	_res = Py_BuildValue("O&",

  1040 	                     PyMac_BuildPoint, oPoint);

  1041 	return _res;

  1042 }

  1043 

  1044 static PyObject *TXNObj_TXNGetLineCount(TXNObjectObject *_self, PyObject *_args)

  1045 {

  1046 	PyObject *_res = NULL;

  1047 	OSStatus _err;

  1048 	ItemCount oLineTotal;

  1049 #ifndef TXNGetLineCount

  1050 	PyMac_PRECHECK(TXNGetLineCount);

  1051 #endif

  1052 	if (!PyArg_ParseTuple(_args, ""))

  1053 		return NULL;

  1054 	_err = TXNGetLineCount(_self->ob_itself,

  1055 	                       &oLineTotal);

  1056 	if (_err != noErr) return PyMac_Error(_err);

  1057 	_res = Py_BuildValue("l",

  1058 	                     oLineTotal);

  1059 	return _res;

  1060 }

  1061 

  1062 static PyObject *TXNObj_TXNGetLineMetrics(TXNObjectObject *_self, PyObject *_args)

  1063 {

  1064 	PyObject *_res = NULL;

  1065 	OSStatus _err;

  1066 	UInt32 iLineNumber;

  1067 	Fixed oLineWidth;

  1068 	Fixed oLineHeight;

  1069 #ifndef TXNGetLineMetrics

  1070 	PyMac_PRECHECK(TXNGetLineMetrics);

  1071 #endif

  1072 	if (!PyArg_ParseTuple(_args, "l",

  1073 	                      &iLineNumber))

  1074 		return NULL;

  1075 	_err = TXNGetLineMetrics(_self->ob_itself,

  1076 	                         iLineNumber,

  1077 	                         &oLineWidth,

  1078 	                         &oLineHeight);

  1079 	if (_err != noErr) return PyMac_Error(_err);

  1080 	_res = Py_BuildValue("O&O&",

  1081 	                     PyMac_BuildFixed, oLineWidth,

  1082 	                     PyMac_BuildFixed, oLineHeight);

  1083 	return _res;

  1084 }

  1085 

  1086 static PyObject *TXNObj_TXNIsObjectAttachedToSpecificWindow(TXNObjectObject *_self, PyObject *_args)

  1087 {

  1088 	PyObject *_res = NULL;

  1089 	OSStatus _err;

  1090 	WindowPtr iWindow;

  1091 	Boolean oAttached;

  1092 #ifndef TXNIsObjectAttachedToSpecificWindow

  1093 	PyMac_PRECHECK(TXNIsObjectAttachedToSpecificWindow);

  1094 #endif

  1095 	if (!PyArg_ParseTuple(_args, "O&",

  1096 	                      WinObj_Convert, &iWindow))

  1097 		return NULL;

  1098 	_err = TXNIsObjectAttachedToSpecificWindow(_self->ob_itself,

  1099 	                                           iWindow,

  1100 	                                           &oAttached);

  1101 	if (_err != noErr) return PyMac_Error(_err);

  1102 	_res = Py_BuildValue("b",

  1103 	                     oAttached);

  1104 	return _res;

  1105 }

  1106 

  1107 static PyObject *TXNObj_TXNRecalcTextLayout(TXNObjectObject *_self, PyObject *_args)

  1108 {

  1109 	PyObject *_res = NULL;

  1110 #ifndef TXNRecalcTextLayout

  1111 	PyMac_PRECHECK(TXNRecalcTextLayout);

  1112 #endif

  1113 	if (!PyArg_ParseTuple(_args, ""))

  1114 		return NULL;

  1115 	TXNRecalcTextLayout(_self->ob_itself);

  1116 	Py_INCREF(Py_None);

  1117 	_res = Py_None;

  1118 	return _res;

  1119 }

  1120 

  1121 static PyMethodDef TXNObj_methods[] = {

  1122 	{"TXNDeleteObject", (PyCFunction)TXNObj_TXNDeleteObject, 1,

  1123 	 PyDoc_STR("() -> None")},

  1124 	{"TXNResizeFrame", (PyCFunction)TXNObj_TXNResizeFrame, 1,

  1125 	 PyDoc_STR("(UInt32 iWidth, UInt32 iHeight, TXNFrameID iTXNFrameID) -> None")},

  1126 	{"TXNSetFrameBounds", (PyCFunction)TXNObj_TXNSetFrameBounds, 1,

  1127 	 PyDoc_STR("(SInt32 iTop, SInt32 iLeft, SInt32 iBottom, SInt32 iRight, TXNFrameID iTXNFrameID) -> None")},

  1128 	{"TXNKeyDown", (PyCFunction)TXNObj_TXNKeyDown, 1,

  1129 	 PyDoc_STR("(EventRecord iEvent) -> None")},

  1130 	{"TXNAdjustCursor", (PyCFunction)TXNObj_TXNAdjustCursor, 1,

  1131 	 PyDoc_STR("(RgnHandle ioCursorRgn) -> None")},

  1132 	{"TXNClick", (PyCFunction)TXNObj_TXNClick, 1,

  1133 	 PyDoc_STR("(EventRecord iEvent) -> None")},

  1134 	{"TXNSelectAll", (PyCFunction)TXNObj_TXNSelectAll, 1,

  1135 	 PyDoc_STR("() -> None")},