summaryrefslogtreecommitdiffstats
path: root/Mac/Lib/PixMapWrapper.py
blob: b167cc2688309655a43da9221f7ff783f955f199 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
"""PixMapWrapper - defines the PixMapWrapper class, which wraps an opaque
QuickDraw PixMap data structure in a handy Python class.  Also provides 
methods to convert to/from pixel data (from, e.g., the img module) or a
Python Imaging Library Image object.

J. Strout <joe@strout.net>  February 1999"""

from Carbon import Qd
from Carbon import QuickDraw
import struct
import MacOS
import img
import imgformat

# PixMap data structure element format (as used with struct)
_pmElemFormat = {
	'baseAddr':'l',		# address of pixel data
	'rowBytes':'H',		# bytes per row, plus 0x8000
	'bounds':'hhhh',	# coordinates imposed over pixel data
		'top':'h',
		'left':'h',
		'bottom':'h',
		'right':'h',
	'pmVersion':'h',	# flags for Color QuickDraw
	'packType':'h',		# format of compression algorithm
	'packSize':'l',		# size after compression
	'hRes':'l',			# horizontal pixels per inch
	'vRes':'l',			# vertical pixels per inch
	'pixelType':'h',	# pixel format
	'pixelSize':'h',	# bits per pixel
	'cmpCount':'h',		# color components per pixel
	'cmpSize':'h',		# bits per component
	'planeBytes':'l',	# offset in bytes to next plane
	'pmTable':'l',		# handle to color table
	'pmReserved':'l'	# reserved for future use
}

# PixMap data structure element offset
_pmElemOffset = {
	'baseAddr':0,
	'rowBytes':4,
	'bounds':6,
		'top':6,
		'left':8,
		'bottom':10,
		'right':12,
	'pmVersion':14,
	'packType':16,
	'packSize':18,
	'hRes':22,
	'vRes':26,
	'pixelType':30,
	'pixelSize':32,
	'cmpCount':34,
	'cmpSize':36,
	'planeBytes':38,
	'pmTable':42,
	'pmReserved':46
}

class PixMapWrapper:
	"""PixMapWrapper -- wraps the QD PixMap object in a Python class,
	with methods to easily get/set various pixmap fields.  Note: Use the
	PixMap() method when passing to QD calls."""

	def __init__(self):
		self.__dict__['data'] = ''
		self._header = struct.pack("lhhhhhhhlllhhhhlll",
			id(self.data)+MacOS.string_id_to_buffer,
			0,						# rowBytes
			0, 0, 0, 0,				# bounds
			0,						# pmVersion
			0, 0,					# packType, packSize
			72<<16, 72<<16,			# hRes, vRes
			QuickDraw.RGBDirect,	# pixelType
			16,						# pixelSize
			2, 5,					# cmpCount, cmpSize,
			0, 0, 0)				# planeBytes, pmTable, pmReserved
		self.__dict__['_pm'] = Qd.RawBitMap(self._header)
	
	def _stuff(self, element, bytes):
		offset = _pmElemOffset[element]
		fmt = _pmElemFormat[element]
		self._header = self._header[:offset] \
			+ struct.pack(fmt, bytes) \
			+ self._header[offset + struct.calcsize(fmt):]
		self.__dict__['_pm'] = None
	
	def _unstuff(self, element):
		offset = _pmElemOffset[element]
		fmt = _pmElemFormat[element]
		return struct.unpack(fmt, self._header[offset:offset+struct.calcsize(fmt)])[0]

	def __setattr__(self, attr, val):
		if attr == 'baseAddr':
			raise 'UseErr', "don't assign to .baseAddr -- assign to .data instead"
		elif attr == 'data':
			self.__dict__['data'] = val
			self._stuff('baseAddr', id(self.data) + MacOS.string_id_to_buffer)
		elif attr == 'rowBytes':
			# high bit is always set for some odd reason
			self._stuff('rowBytes', val | 0x8000)
		elif attr == 'bounds':
			# assume val is in official Left, Top, Right, Bottom order!
			self._stuff('left',val[0])
			self._stuff('top',val[1])
			self._stuff('right',val[2])
			self._stuff('bottom',val[3])
		elif attr == 'hRes' or attr == 'vRes':
			# 16.16 fixed format, so just shift 16 bits
			self._stuff(attr, int(val) << 16)
		elif attr in _pmElemFormat.keys():
			# any other pm attribute -- just stuff
			self._stuff(attr, val)
		else:
			self.__dict__[attr] = val	

	def __getattr__(self, attr):
		if attr == 'rowBytes':
			# high bit is always set for some odd reason
			return self._unstuff('rowBytes') & 0x7FFF
		elif attr == 'bounds':
			# return bounds in official Left, Top, Right, Bottom order!
			return ( \
				self._unstuff('left'),
				self._unstuff('top'),
				self._unstuff('right'),
				self._unstuff('bottom') )
		elif attr == 'hRes' or attr == 'vRes':
			# 16.16 fixed format, so just shift 16 bits
			return self._unstuff(attr) >> 16
		elif attr in _pmElemFormat.keys():
			# any other pm attribute -- just unstuff
			return self._unstuff(attr)
		else:
			return self.__dict__[attr]	

		
	def PixMap(self):
		"Return a QuickDraw PixMap corresponding to this data."
		if not self.__dict__['_pm']:
			self.__dict__['_pm'] = Qd.RawBitMap(self._header)
		return self.__dict__['_pm']

	def blit(self, x1=0,y1=0,x2=None,y2=None, port=None):
		"""Draw this pixmap into the given (default current) grafport.""" 
		src = self.bounds
		dest = [x1,y1,x2,y2]
		if x2 == None:
			dest[2] = x1 + src[2]-src[0]
		if y2 == None:
			dest[3] = y1 + src[3]-src[1]
		if not port: port = Qd.GetPort()
		Qd.CopyBits(self.PixMap(), port.portBits, src, tuple(dest),
				QuickDraw.srcCopy, None)
	
	def fromstring(self,s,width,height,format=imgformat.macrgb):
		"""Stuff this pixmap with raw pixel data from a string.
		Supply width, height, and one of the imgformat specifiers."""
		# we only support 16- and 32-bit mac rgb...
		# so convert if necessary
		if format != imgformat.macrgb and format != imgformat.macrgb16:
			# (LATER!)
			raise "NotImplementedError", "conversion to macrgb or macrgb16"
		self.data = s
		self.bounds = (0,0,width,height)
		self.cmpCount = 3
		self.pixelType = QuickDraw.RGBDirect
		if format == imgformat.macrgb:
			self.pixelSize = 32
			self.cmpSize = 8
		else:
			self.pixelSize = 16
			self.cmpSize = 5
		self.rowBytes = width*self.pixelSize/8

	def tostring(self, format=imgformat.macrgb):
		"""Return raw data as a string in the specified format."""
		# is the native format requested?  if so, just return data
		if (format == imgformat.macrgb and self.pixelSize == 32) or \
		   (format == imgformat.macrgb16 and self.pixelsize == 16):
			return self.data
		# otherwise, convert to the requested format
		# (LATER!)
			raise "NotImplementedError", "data format conversion"

	def fromImage(self,im):
		"""Initialize this PixMap from a PIL Image object."""
		# We need data in ARGB format; PIL can't currently do that,
		# but it can do RGBA, which we can use by inserting one null
		# up frontpm = 
		if im.mode != 'RGBA': im = im.convert('RGBA')
		data = chr(0) + im.tostring()
		self.fromstring(data, im.size[0], im.size[1])

	def toImage(self):
		"""Return the contents of this PixMap as a PIL Image object."""
		import Image
		# our tostring() method returns data in ARGB format,
		# whereas Image uses RGBA; a bit of slicing fixes this...
		data = self.tostring()[1:] + chr(0)
		bounds = self.bounds
		return Image.fromstring('RGBA',(bounds[2]-bounds[0],bounds[3]-bounds[1]),data)

def test():
	import MacOS
	import macfs
	import Image
	fsspec, ok = macfs.PromptGetFile("Image File:")
	if not ok: return
	path = fsspec.as_pathname()
	pm = PixMapWrapper()
	pm.fromImage( Image.open(path) )
	pm.blit(20,20)
	return pm