/Mac/Modules/mlte/_Mltemodule.c

http://unladen-swallow.googlecode.com/ · C · 1690 lines · 1529 code · 135 blank · 26 comment · 159 complexity · dc62f16ca304ea0d7b0443d80ba513d3 MD5 · raw file

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