def draw(self, visRgn=None):
if self._visible:
penstate = Qd.GetPenState()
Qd.PenPat(self._framepattern)
Qd.RGBForeColor(self._framecolor)
Qd.FrameRect(self._bounds)
Qd.RGBForeColor((0, 0, 0))
Qd.SetPenState(penstate)
def draw(self, visRgn = None):
if self._visible:
Qd.FrameRect(self._bounds)
Qd.EraseRect(Qd.InsetRect(self._bounds, 1, 1))
l, t, r, b = self._bounds
l = l + 2
t = t + 3
pictframe = (l, t, l + 10, t + 10)
Qd.DrawPicture(_arrowright, pictframe)
def _redraw(self, rgn=None):
## if rgn == None:
## rgn = self.wid.GetWindowPort().visRgn
Qd.SetPort(self.wid)
if not self.image_data:
Qd.EraseRect(self.rect)
else:
self._redrawimage(self.rect, self.image_data)
Qd.FrameRect(self.rect)
def redraw(self, ctl, part):
try:
Qd.SetPort(self.wid)
Qd.RGBBackColor((0xffff, 0xffff, 0xffff))
if self._background_image:
self._redrawimage(self.rect, self._background_image)
else:
Qd.EraseRect(self.rect)
Qd.RGBForeColor((0x7fff, 0x7fff, 0x7fff))
Qd.FrameRect(self.rect)
for r in self.otherrects:
Qd.RGBForeColor((0x0, 0x7fff, 0x7fff))
Qd.FrameRect(r)
self.drawourrect()
except:
import traceback, sys
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, None)
traceback.print_tb(exc_traceback)
def drawourrect(self):
if self.ourrect is None:
return
port = self.wid.GetWindowPort()
Qd.RGBForeColor((0x0, 0, 0))
oldmode = port.pnMode
Qd.PenMode(QuickDraw.srcXor)
Qd.FrameRect(self.ourrect)
for l in self.lurven:
Qd.PaintRect(l)
Qd.PenMode(oldmode)
def draw(self, visRgn=None):
if self._visible:
if not visRgn:
visRgn = self._parentwindow.wid.GetWindowPort().visRgn
Qd.PenPat(Qd.GetQDGlobalsGray())
rect = self._bounds
Qd.FrameRect(rect)
rect = Qd.InsetRect(rect, 3, 3)
Qd.PenNormal()
Qd.RGBForeColor(self._color)
Qd.PaintRect(rect)
Qd.RGBForeColor((0, 0, 0))
def adjust(self, oldbounds):
self.SetPort()
self.GetWindow().InvalWindowRect(oldbounds)
self._control.HideControl()
self._control.MoveControl(self._bounds[0], self._bounds[1])
self._control.SizeControl(self._bounds[2] - self._bounds[0],
self._bounds[3] - self._bounds[1])
if self._visible:
Qd.EraseRect(self._bounds)
if self._activated:
self._control.ShowControl()
else:
Qd.FrameRect(self._bounds)
self.GetWindow().ValidWindowRect(self._bounds)
def draw(self, visRgn=None):
if self._visible:
if not visRgn:
visRgn = self._parentwindow.wid.GetWindowPort().visRgn
self.ted.WEUpdate(visRgn)
# DISABLED! There are too many places where it is assumed that
# the frame of an EditText item is 1 pixel, inside the bounds.
#state = [kThemeStateActive, kThemeStateInactive][not self._activated]
#App.DrawThemeEditTextFrame(Qd.InsetRect(self._bounds, 1, 1), state)
Qd.FrameRect(self._bounds)
if self._selected and self._activated:
self.drawselframe(1)
def do_rawupdate(self, window, event):
tp, h, rect = self.dlg.GetDialogItem(MAIN_LIST)
Qd.SetPort(self.wid)
Qd.FrameRect(rect)
self.list.LUpdate(self.wid.GetWindowPort().visRgn)
import Printing
from Carbon import Qd
from Carbon import Fm
from Carbon import Res
# some constants
PostScriptBegin = 190 # Set driver state to PostScript
PostScriptEnd = 191 # Restore QuickDraw state
PostScriptHandle = 192 # PostScript data referenced in handle
CHUNK_SIZE = 0x8000 # max size of PicComment
def PostScript(text):
"""embed text as plain PostScript in print job."""
handle = Res.Resource('')
Qd.PicComment(PostScriptBegin, 0, handle)
while text:
chunk = text[:CHUNK_SIZE]
text = text[CHUNK_SIZE:]
handle.data = chunk
Qd.PicComment(PostScriptHandle, len(chunk), handle)
handle.data = ''
Qd.PicComment(PostScriptEnd, 0, handle)
# create a new print record
printrecord = Printing.NewTPrintRecord()
# open the printer
Printing.PrOpen()
try:
# initialize print record with default values
Printing.PrintDefault(printrecord)
# page setup, ok is 0 when user cancelled
ok = Printing.PrStlDialog(printrecord)
#
"""browsepict - Display all "PICT" resources found"""
def _render_one(self, entry):
cmd = entry[0]
if cmd == 'clear':
if self._bgcolor != None:
r = self._getredrawguarantee(skipclear=1)
if r:
r2 = Qd.NewRgn()
Qd.RectRgn(r2, self._window.qdrect())
Qd.DiffRgn(r2, r, r2)
Qd.EraseRgn(r2)
Qd.DisposeRgn(r)
Qd.DisposeRgn(r2)
else:
Qd.EraseRect(self._window.qdrect())
elif cmd == 'fg':
self._setfgcolor(entry[1])
elif cmd == 'font':
entry[1]._setfont(self._render_grafport)
elif cmd == 'text':
x, y, w, h = self._convert_coordinates(entry[1:5])
if not self._render_overlaprgn((x, y - h, x + w, y)):
return
Qd.MoveTo(x, y)
# XXXX Incorrect for long strings:
Qd.DrawText(entry[5], 0, len(entry[5]))
elif cmd == 'icon':
icon = entry[2]
if icon == None:
return
rect = self._convert_coordinates(entry[1])
if not self._render_overlaprgn(rect):
return
x0, y0, x1, y1 = rect
if x1 - x0 < ICONSIZE_PXL:
leftextra = (ICONSIZE_PXL - (x1 - x0)) / 2
x0 = x0 + leftextra
x1 = x0 + ICONSIZE_PXL
if y1 - y0 < ICONSIZE_PXL:
topextra = (ICONSIZE_PXL - (y1 - y0)) / 2
y0 = y0 + topextra
y1 = y0 + ICONSIZE_PXL
Icn.PlotCIcon((x0, y0, x1, y1), icon)
elif cmd == 'image':
mask, image, srcx, srcy, coordinates, w, h, units = entry[1:]
dstx, dsty = self._convert_coordinates(coordinates[:2],
units=units)
dstrect = dstx, dsty, dstx + w, dsty + h
if not self._render_overlaprgn(dstrect):
return
w = dstrect[2] - dstrect[0]
h = dstrect[3] - dstrect[1]
srcrect = srcx, srcy, srcx + w, srcy + h
self._setblackwhitecolors()
clip = self._window._mac_getclip()
if mask:
# XXXX We should also take note of the clip here.
Qd.CopyMask(image[0], mask[0],
self._render_grafport.GetPortBitMapForCopyBits(),
srcrect, srcrect, dstrect)
else:
Qd.CopyBits(image[0],
self._render_grafport.GetPortBitMapForCopyBits(),
srcrect, dstrect,
QuickDraw.srcCopy + QuickDraw.ditherCopy, clip)
self._restorecolors()
elif cmd == 'line':
color = entry[1]
points = entry[2]
self._setfgcolor(color)
x, y = self._convert_coordinates(points[0])
Qd.MoveTo(x, y)
for np in points[1:]:
x, y = self._convert_coordinates(np)
Qd.LineTo(x, y)
self._restorecolors()
elif cmd == '3dhline':
color1, color2, x0, x1, y = entry[1:]
fgcolor = self._render_grafport.rgbFgColor
self._setfgcolor(color1)
x0, y0 = self._convert_coordinates((x0, y))
x1, y1 = self._convert_coordinates((x1, y))
if not self._render_overlaprgn((x0, y0, x1, y1 + 1)):
return
Qd.MoveTo(x0, y0)
Qd.LineTo(x1, y1)
self._setfgcolor(color2)
Qd.MoveTo(x0, y0 + 1)
Qd.LineTo(x1, y1 + 1)
self._setfgcolor(fgcolor)
self._restorecolors()
elif cmd == 'box':
rect = self._convert_coordinates(entry[1])
if not self._render_overlaprgn(rect):
return
Qd.FrameRect(rect)
elif cmd == 'fbox':
color = entry[1]
units = entry[3]
rect = self._convert_coordinates(entry[2], units)
if not self._render_overlaprgn(rect):
return
self._setfgcolor(color)
Qd.PaintRect(rect)
self._restorecolors()
elif cmd == 'linewidth':
Qd.PenSize(entry[1], entry[1])
elif cmd == 'fpolygon':
polyhandle = self._polyhandle(entry[2],
cliprgn=self._render_cliprgn)
if not polyhandle:
return
self._setfgcolor(entry[1])
Qd.PaintPoly(polyhandle)
self._restorecolors()
elif cmd == '3dbox':
rect = self._convert_coordinates(entry[2])
if not self._render_overlaprgn(rect):
return
l, t, r, b = rect
cl, ct, cr, cb = entry[1]
clt = _colormix(cl, ct)
ctr = _colormix(ct, cr)
crb = _colormix(cr, cb)
cbl = _colormix(cb, cl)
## print '3Dbox', (l, t, r, b) # DBG
## print 'window', self._window.qdrect() # DBG
# l, r, t, b are the corners
l3 = l + SIZE_3DBORDER
t3 = t + SIZE_3DBORDER
r3 = r - SIZE_3DBORDER
b3 = b - SIZE_3DBORDER
# draw left side
self._setfgcolor(cl)
polyhandle = self._polyhandle([(l, t), (l3, t3), (l3, b3), (l, b)],
conv=0)
if polyhandle: Qd.PaintPoly(polyhandle)
# draw top side
self._setfgcolor(ct)
polyhandle = self._polyhandle([(l, t), (r, t), (r3, t3), (l3, t3)],
conv=0)
if polyhandle: Qd.PaintPoly(polyhandle)
# draw right side
self._setfgcolor(cr)
polyhandle = self._polyhandle([(r3, t3), (r, t), (r, b), (r3, b3)],
conv=0)
if polyhandle: Qd.PaintPoly(polyhandle)
# draw bottom side
self._setfgcolor(cb)
polyhandle = self._polyhandle([(l3, b3), (r3, b3), (r, b), (l, b)],
conv=0)
if polyhandle: Qd.PaintPoly(polyhandle)
# draw topleft
self._setfgcolor(clt)
Qd.PaintRect((l, t, l3, t3))
# draw topright
self._setfgcolor(ctr)
Qd.PaintRect((r3, t, r, t3))
# draw botright
self._setfgcolor(crb)
Qd.PaintRect((r3, b3, r, b))
# draw leftbot
self._setfgcolor(cbl)
Qd.PaintRect((l, b3, l3, b))
self._restorecolors()
elif cmd == 'diamond':
rect = self._convert_coordinates(entry[1])
if not self._render_overlaprgn(rect):
return
x, y, x1, y1 = rect
w = x1 - x
h = y1 - y
Qd.MoveTo(x, y + h / 2)
Qd.LineTo(x + w / 2, y)
Qd.LineTo(x + w, y + h / 2)
Qd.LineTo(x + w / 2, y + h)
Qd.LineTo(x, y + h / 2)
elif cmd == 'fdiamond':
rect = self._convert_coordinates(entry[2])
if not self._render_overlaprgn(rect):
return
x, y, x1, y1 = rect
w = x1 - x
h = y1 - y
self._setfgcolor(entry[1])
polyhandle = self._polyhandle([(x, y + h / 2), (x + w / 2, y),
(x + w, y + h / 2),
(x + w / 2, y + h), (x, y + h / 2)])
if polyhandle: Qd.PaintPoly(polyhandle)
self._restorecolors()
elif cmd == '3ddiamond':
rect = self._convert_coordinates(entry[2])
if not self._render_overlaprgn(rect):
return
l, t, r, b = rect
cl, ct, cr, cb = entry[1]
w = r - l
h = b - t
r = l + w
b = t + h
x = l + w / 2
y = t + h / 2
n = int(3.0 * w / h + 0.5)
ll = l + n
tt = t + 3
rr = r - n
bb = b - 3
self._setfgcolor(cl)
polyhandle = self._polyhandle([(l, y), (x, t), (x, tt), (ll, y)],
conv=0)
if polyhandle: Qd.PaintPoly(polyhandle)
self._setfgcolor(ct)
polyhandle = self._polyhandle([(x, t), (r, y), (rr, y), (x, tt)],
conv=0)
if polyhandle: Qd.PaintPoly(polyhandle)
self._setfgcolor(cr)
polyhandle = self._polyhandle([(r, y), (x, b), (x, bb), (rr, y)],
conv=0)
if polyhandle: Qd.PaintPoly(polyhandle)
self._setfgcolor(cb)
polyhandle = self._polyhandle([(l, y), (ll, y), (x, bb), (x, b)],
conv=0)
if polyhandle: Qd.PaintPoly(polyhandle)
self._restorecolors()
elif cmd == 'arrow':
color = entry[1]
src = entry[2]
dst = entry[3]
x0, y0, x1, y1, points = self._arrowdata(src, dst)
if not self._render_overlaprgn((x0, y0, x1, y1)):
return
self._setfgcolor(color)
Qd.MoveTo(x0, y0)
Qd.LineTo(x1, y1)
polyhandle = self._polyhandle(points)
if polyhandle: Qd.PaintPoly(polyhandle)
self._restorecolors()
else:
raise 'Unknown displaylist command', cmd
self._dbg_did = self._dbg_did + 1
def _drawbounds(self):
Qd.FrameRect(self._bounds)
def do_rawupdate(self, window, event):
Qd.SetPort(window)
Qd.FrameRect(self.listrect)
self.list.LUpdate(self.wid.GetWindowPort().visRgn)