/Lib/plat-mac/aetypes.py

http://unladen-swallow.googlecode.com/ · Python · 571 lines · 555 code · 11 blank · 5 comment · 13 complexity · f5a7cdef6aee4e981862830c1c4ce118 MD5 · raw file

  1. """aetypes - Python objects representing various AE types."""
  2. from warnings import warnpy3k
  3. warnpy3k("In 3.x, the aetypes module is removed.", stacklevel=2)
  4. from Carbon.AppleEvents import *
  5. import struct
  6. from types import *
  7. import string
  8. #
  9. # convoluted, since there are cyclic dependencies between this file and
  10. # aetools_convert.
  11. #
  12. def pack(*args, **kwargs):
  13. from aepack import pack
  14. return pack( *args, **kwargs)
  15. def nice(s):
  16. """'nice' representation of an object"""
  17. if type(s) is StringType: return repr(s)
  18. else: return str(s)
  19. class Unknown:
  20. """An uninterpreted AE object"""
  21. def __init__(self, type, data):
  22. self.type = type
  23. self.data = data
  24. def __repr__(self):
  25. return "Unknown(%r, %r)" % (self.type, self.data)
  26. def __aepack__(self):
  27. return pack(self.data, self.type)
  28. class Enum:
  29. """An AE enumeration value"""
  30. def __init__(self, enum):
  31. self.enum = "%-4.4s" % str(enum)
  32. def __repr__(self):
  33. return "Enum(%r)" % (self.enum,)
  34. def __str__(self):
  35. return string.strip(self.enum)
  36. def __aepack__(self):
  37. return pack(self.enum, typeEnumeration)
  38. def IsEnum(x):
  39. return isinstance(x, Enum)
  40. def mkenum(enum):
  41. if IsEnum(enum): return enum
  42. return Enum(enum)
  43. # Jack changed the way this is done
  44. class InsertionLoc:
  45. def __init__(self, of, pos):
  46. self.of = of
  47. self.pos = pos
  48. def __repr__(self):
  49. return "InsertionLoc(%r, %r)" % (self.of, self.pos)
  50. def __aepack__(self):
  51. rec = {'kobj': self.of, 'kpos': self.pos}
  52. return pack(rec, forcetype='insl')
  53. # Convenience functions for dsp:
  54. def beginning(of):
  55. return InsertionLoc(of, Enum('bgng'))
  56. def end(of):
  57. return InsertionLoc(of, Enum('end '))
  58. class Boolean:
  59. """An AE boolean value"""
  60. def __init__(self, bool):
  61. self.bool = (not not bool)
  62. def __repr__(self):
  63. return "Boolean(%r)" % (self.bool,)
  64. def __str__(self):
  65. if self.bool:
  66. return "True"
  67. else:
  68. return "False"
  69. def __aepack__(self):
  70. return pack(struct.pack('b', self.bool), 'bool')
  71. def IsBoolean(x):
  72. return isinstance(x, Boolean)
  73. def mkboolean(bool):
  74. if IsBoolean(bool): return bool
  75. return Boolean(bool)
  76. class Type:
  77. """An AE 4-char typename object"""
  78. def __init__(self, type):
  79. self.type = "%-4.4s" % str(type)
  80. def __repr__(self):
  81. return "Type(%r)" % (self.type,)
  82. def __str__(self):
  83. return string.strip(self.type)
  84. def __aepack__(self):
  85. return pack(self.type, typeType)
  86. def IsType(x):
  87. return isinstance(x, Type)
  88. def mktype(type):
  89. if IsType(type): return type
  90. return Type(type)
  91. class Keyword:
  92. """An AE 4-char keyword object"""
  93. def __init__(self, keyword):
  94. self.keyword = "%-4.4s" % str(keyword)
  95. def __repr__(self):
  96. return "Keyword(%r)" % `self.keyword`
  97. def __str__(self):
  98. return string.strip(self.keyword)
  99. def __aepack__(self):
  100. return pack(self.keyword, typeKeyword)
  101. def IsKeyword(x):
  102. return isinstance(x, Keyword)
  103. class Range:
  104. """An AE range object"""
  105. def __init__(self, start, stop):
  106. self.start = start
  107. self.stop = stop
  108. def __repr__(self):
  109. return "Range(%r, %r)" % (self.start, self.stop)
  110. def __str__(self):
  111. return "%s thru %s" % (nice(self.start), nice(self.stop))
  112. def __aepack__(self):
  113. return pack({'star': self.start, 'stop': self.stop}, 'rang')
  114. def IsRange(x):
  115. return isinstance(x, Range)
  116. class Comparison:
  117. """An AE Comparison"""
  118. def __init__(self, obj1, relo, obj2):
  119. self.obj1 = obj1
  120. self.relo = "%-4.4s" % str(relo)
  121. self.obj2 = obj2
  122. def __repr__(self):
  123. return "Comparison(%r, %r, %r)" % (self.obj1, self.relo, self.obj2)
  124. def __str__(self):
  125. return "%s %s %s" % (nice(self.obj1), string.strip(self.relo), nice(self.obj2))
  126. def __aepack__(self):
  127. return pack({'obj1': self.obj1,
  128. 'relo': mkenum(self.relo),
  129. 'obj2': self.obj2},
  130. 'cmpd')
  131. def IsComparison(x):
  132. return isinstance(x, Comparison)
  133. class NComparison(Comparison):
  134. # The class attribute 'relo' must be set in a subclass
  135. def __init__(self, obj1, obj2):
  136. Comparison.__init__(obj1, self.relo, obj2)
  137. class Ordinal:
  138. """An AE Ordinal"""
  139. def __init__(self, abso):
  140. # self.obj1 = obj1
  141. self.abso = "%-4.4s" % str(abso)
  142. def __repr__(self):
  143. return "Ordinal(%r)" % (self.abso,)
  144. def __str__(self):
  145. return "%s" % (string.strip(self.abso))
  146. def __aepack__(self):
  147. return pack(self.abso, 'abso')
  148. def IsOrdinal(x):
  149. return isinstance(x, Ordinal)
  150. class NOrdinal(Ordinal):
  151. # The class attribute 'abso' must be set in a subclass
  152. def __init__(self):
  153. Ordinal.__init__(self, self.abso)
  154. class Logical:
  155. """An AE logical expression object"""
  156. def __init__(self, logc, term):
  157. self.logc = "%-4.4s" % str(logc)
  158. self.term = term
  159. def __repr__(self):
  160. return "Logical(%r, %r)" % (self.logc, self.term)
  161. def __str__(self):
  162. if type(self.term) == ListType and len(self.term) == 2:
  163. return "%s %s %s" % (nice(self.term[0]),
  164. string.strip(self.logc),
  165. nice(self.term[1]))
  166. else:
  167. return "%s(%s)" % (string.strip(self.logc), nice(self.term))
  168. def __aepack__(self):
  169. return pack({'logc': mkenum(self.logc), 'term': self.term}, 'logi')
  170. def IsLogical(x):
  171. return isinstance(x, Logical)
  172. class StyledText:
  173. """An AE object respresenting text in a certain style"""
  174. def __init__(self, style, text):
  175. self.style = style
  176. self.text = text
  177. def __repr__(self):
  178. return "StyledText(%r, %r)" % (self.style, self.text)
  179. def __str__(self):
  180. return self.text
  181. def __aepack__(self):
  182. return pack({'ksty': self.style, 'ktxt': self.text}, 'STXT')
  183. def IsStyledText(x):
  184. return isinstance(x, StyledText)
  185. class AEText:
  186. """An AE text object with style, script and language specified"""
  187. def __init__(self, script, style, text):
  188. self.script = script
  189. self.style = style
  190. self.text = text
  191. def __repr__(self):
  192. return "AEText(%r, %r, %r)" % (self.script, self.style, self.text)
  193. def __str__(self):
  194. return self.text
  195. def __aepack__(self):
  196. return pack({keyAEScriptTag: self.script, keyAEStyles: self.style,
  197. keyAEText: self.text}, typeAEText)
  198. def IsAEText(x):
  199. return isinstance(x, AEText)
  200. class IntlText:
  201. """A text object with script and language specified"""
  202. def __init__(self, script, language, text):
  203. self.script = script
  204. self.language = language
  205. self.text = text
  206. def __repr__(self):
  207. return "IntlText(%r, %r, %r)" % (self.script, self.language, self.text)
  208. def __str__(self):
  209. return self.text
  210. def __aepack__(self):
  211. return pack(struct.pack('hh', self.script, self.language)+self.text,
  212. typeIntlText)
  213. def IsIntlText(x):
  214. return isinstance(x, IntlText)
  215. class IntlWritingCode:
  216. """An object representing script and language"""
  217. def __init__(self, script, language):
  218. self.script = script
  219. self.language = language
  220. def __repr__(self):
  221. return "IntlWritingCode(%r, %r)" % (self.script, self.language)
  222. def __str__(self):
  223. return "script system %d, language %d"%(self.script, self.language)
  224. def __aepack__(self):
  225. return pack(struct.pack('hh', self.script, self.language),
  226. typeIntlWritingCode)
  227. def IsIntlWritingCode(x):
  228. return isinstance(x, IntlWritingCode)
  229. class QDPoint:
  230. """A point"""
  231. def __init__(self, v, h):
  232. self.v = v
  233. self.h = h
  234. def __repr__(self):
  235. return "QDPoint(%r, %r)" % (self.v, self.h)
  236. def __str__(self):
  237. return "(%d, %d)"%(self.v, self.h)
  238. def __aepack__(self):
  239. return pack(struct.pack('hh', self.v, self.h),
  240. typeQDPoint)
  241. def IsQDPoint(x):
  242. return isinstance(x, QDPoint)
  243. class QDRectangle:
  244. """A rectangle"""
  245. def __init__(self, v0, h0, v1, h1):
  246. self.v0 = v0
  247. self.h0 = h0
  248. self.v1 = v1
  249. self.h1 = h1
  250. def __repr__(self):
  251. return "QDRectangle(%r, %r, %r, %r)" % (self.v0, self.h0, self.v1, self.h1)
  252. def __str__(self):
  253. return "(%d, %d)-(%d, %d)"%(self.v0, self.h0, self.v1, self.h1)
  254. def __aepack__(self):
  255. return pack(struct.pack('hhhh', self.v0, self.h0, self.v1, self.h1),
  256. typeQDRectangle)
  257. def IsQDRectangle(x):
  258. return isinstance(x, QDRectangle)
  259. class RGBColor:
  260. """An RGB color"""
  261. def __init__(self, r, g, b):
  262. self.r = r
  263. self.g = g
  264. self.b = b
  265. def __repr__(self):
  266. return "RGBColor(%r, %r, %r)" % (self.r, self.g, self.b)
  267. def __str__(self):
  268. return "0x%x red, 0x%x green, 0x%x blue"% (self.r, self.g, self.b)
  269. def __aepack__(self):
  270. return pack(struct.pack('hhh', self.r, self.g, self.b),
  271. typeRGBColor)
  272. def IsRGBColor(x):
  273. return isinstance(x, RGBColor)
  274. class ObjectSpecifier:
  275. """A class for constructing and manipulation AE object specifiers in python.
  276. An object specifier is actually a record with four fields:
  277. key type description
  278. --- ---- -----------
  279. 'want' type 4-char class code of thing we want,
  280. e.g. word, paragraph or property
  281. 'form' enum how we specify which 'want' thing(s) we want,
  282. e.g. by index, by range, by name, or by property specifier
  283. 'seld' any which thing(s) we want,
  284. e.g. its index, its name, or its property specifier
  285. 'from' object the object in which it is contained,
  286. or null, meaning look for it in the application
  287. Note that we don't call this class plain "Object", since that name
  288. is likely to be used by the application.
  289. """
  290. def __init__(self, want, form, seld, fr = None):
  291. self.want = want
  292. self.form = form
  293. self.seld = seld
  294. self.fr = fr
  295. def __repr__(self):
  296. s = "ObjectSpecifier(%r, %r, %r" % (self.want, self.form, self.seld)
  297. if self.fr:
  298. s = s + ", %r)" % (self.fr,)
  299. else:
  300. s = s + ")"
  301. return s
  302. def __aepack__(self):
  303. return pack({'want': mktype(self.want),
  304. 'form': mkenum(self.form),
  305. 'seld': self.seld,
  306. 'from': self.fr},
  307. 'obj ')
  308. def IsObjectSpecifier(x):
  309. return isinstance(x, ObjectSpecifier)
  310. # Backwards compatibility, sigh...
  311. class Property(ObjectSpecifier):
  312. def __init__(self, which, fr = None, want='prop'):
  313. ObjectSpecifier.__init__(self, want, 'prop', mktype(which), fr)
  314. def __repr__(self):
  315. if self.fr:
  316. return "Property(%r, %r)" % (self.seld.type, self.fr)
  317. else:
  318. return "Property(%r)" % (self.seld.type,)
  319. def __str__(self):
  320. if self.fr:
  321. return "Property %s of %s" % (str(self.seld), str(self.fr))
  322. else:
  323. return "Property %s" % str(self.seld)
  324. class NProperty(ObjectSpecifier):
  325. # Subclasses *must* self baseclass attributes:
  326. # want is the type of this property
  327. # which is the property name of this property
  328. def __init__(self, fr = None):
  329. #try:
  330. # dummy = self.want
  331. #except:
  332. # self.want = 'prop'
  333. self.want = 'prop'
  334. ObjectSpecifier.__init__(self, self.want, 'prop',
  335. mktype(self.which), fr)
  336. def __repr__(self):
  337. rv = "Property(%r" % (self.seld.type,)
  338. if self.fr:
  339. rv = rv + ", fr=%r" % (self.fr,)
  340. if self.want != 'prop':
  341. rv = rv + ", want=%r" % (self.want,)
  342. return rv + ")"
  343. def __str__(self):
  344. if self.fr:
  345. return "Property %s of %s" % (str(self.seld), str(self.fr))
  346. else:
  347. return "Property %s" % str(self.seld)
  348. class SelectableItem(ObjectSpecifier):
  349. def __init__(self, want, seld, fr = None):
  350. t = type(seld)
  351. if t == StringType:
  352. form = 'name'
  353. elif IsRange(seld):
  354. form = 'rang'
  355. elif IsComparison(seld) or IsLogical(seld):
  356. form = 'test'
  357. elif t == TupleType:
  358. # Breakout: specify both form and seld in a tuple
  359. # (if you want ID or rele or somesuch)
  360. form, seld = seld
  361. else:
  362. form = 'indx'
  363. ObjectSpecifier.__init__(self, want, form, seld, fr)
  364. class ComponentItem(SelectableItem):
  365. # Derived classes *must* set the *class attribute* 'want' to some constant
  366. # Also, dictionaries _propdict and _elemdict must be set to map property
  367. # and element names to the correct classes
  368. _propdict = {}
  369. _elemdict = {}
  370. def __init__(self, which, fr = None):
  371. SelectableItem.__init__(self, self.want, which, fr)
  372. def __repr__(self):
  373. if not self.fr:
  374. return "%s(%r)" % (self.__class__.__name__, self.seld)
  375. return "%s(%r, %r)" % (self.__class__.__name__, self.seld, self.fr)
  376. def __str__(self):
  377. seld = self.seld
  378. if type(seld) == StringType:
  379. ss = repr(seld)
  380. elif IsRange(seld):
  381. start, stop = seld.start, seld.stop
  382. if type(start) == InstanceType == type(stop) and \
  383. start.__class__ == self.__class__ == stop.__class__:
  384. ss = str(start.seld) + " thru " + str(stop.seld)
  385. else:
  386. ss = str(seld)
  387. else:
  388. ss = str(seld)
  389. s = "%s %s" % (self.__class__.__name__, ss)
  390. if self.fr: s = s + " of %s" % str(self.fr)
  391. return s
  392. def __getattr__(self, name):
  393. if self._elemdict.has_key(name):
  394. cls = self._elemdict[name]
  395. return DelayedComponentItem(cls, self)
  396. if self._propdict.has_key(name):
  397. cls = self._propdict[name]
  398. return cls(self)
  399. raise AttributeError, name
  400. class DelayedComponentItem:
  401. def __init__(self, compclass, fr):
  402. self.compclass = compclass
  403. self.fr = fr
  404. def __call__(self, which):
  405. return self.compclass(which, self.fr)
  406. def __repr__(self):
  407. return "%s(???, %r)" % (self.__class__.__name__, self.fr)
  408. def __str__(self):
  409. return "selector for element %s of %s"%(self.__class__.__name__, str(self.fr))
  410. template = """
  411. class %s(ComponentItem): want = '%s'
  412. """
  413. exec template % ("Text", 'text')
  414. exec template % ("Character", 'cha ')
  415. exec template % ("Word", 'cwor')
  416. exec template % ("Line", 'clin')
  417. exec template % ("paragraph", 'cpar')
  418. exec template % ("Window", 'cwin')
  419. exec template % ("Document", 'docu')
  420. exec template % ("File", 'file')
  421. exec template % ("InsertionPoint", 'cins')