# Sketch - A Python-based interactive drawing program
# Copyright (C) 1997, 1998, 1999, 2000 by Bernhard Herzog
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# SimpleText: A graphics object representing a single line of text
#
#
# Model:
#
# An instance of SimpleText is a single line of text in one particular
# font. The position and orientation of the text is described by an
# anchor point and an arbitrary linear transformation (a 2x2-matrix).
# The transformation allows rotated, sheared, reflected and nonuniformly
# scaled text.
#
# In addition, there are two flags that control which of several special
# points of the text is located at the anchor point: horizontal and
# vertical alignment. The special point chosen is the reference point.
#
# Horizontal alignment can be one of `left', `right' and `center',
# meaning the left, right and horizontal center of the text. Vertical
# alignment can be `top', `bottom', `center' and `baseline', referring
# to the top, bottom, vertical center and the baseline of the text.
#
# The default alignment is left and baseline.
#
# The anchor point is also the layout point. If some form of snapping is
# active, this point will be `magnetic'.
#
#
# Representation:
#
# The position and orientation of a SimpleText-instance is stored in a
# single affine transformation in the instance variable `trafo' (An
# instance of the Trafo type (see the developer's guide)). The
# translation part of the transformation (trafo.v1 and trafo.v2) is the
# position of the anchor point. The matrix part (trafo.m11, ...,
# trafo.m22) is the linear transformation.
#
# The alignment is stored in the instance variables `halign' and
# `valign' and in a special internal transformation `atrafo'.
#
# atrafo is set up in such a way, that trafo(atrafo) (the concatenation
# of both transformations) maps text coordinates to document
# coordinates. Text coordinates are the natural coordinates for the text
# and the given font and size. The origin is the leftmost point of the
# first character projected on the baseline. X extends to the right, y
# upwards. The unit is the point.
#
# While halign and valign are independent of font, size and the text
# itself, atrafo needs to be recomputed every time some of these change.
#
# The definition of trafo and atrafo leads to these rules:
#
# 1. trafo(0, 0) is the anchor point.
#
# 2. If (rx, ry) is the reference point in text coordinates, then
# atrafo(rx, ry) == (0, 0)
#
# 3. For the default alignment, atrafo is the identity transformation.
#
#
from string import split
from math import sin,cos,atan2,hypot,pi,fmod,floor
from Sketch import _,Rect,UnionRects,EmptyRect,NullPoint,Polar,\
IdentityMatrix, SingularMatrix, Identity, Trafo, Scale, Translation, \
Rotation, NullUndo, CreateMultiUndo, RegisterCommands
from Sketch.UI.command import AddCmd
from Sketch import const,config
import handle
import selinfo
from base import Primitive,RectangularPrimitive,Creator,Editor
from compound import Compound
from group import Group
from bezier import PolyBezier,CombineBeziers
from blend import Blend,MismatchError,BlendTrafo
from properties import PropertyStack,FactoryTextStyle,DefaultTextProperties
import color, pattern
import graphics, font
font_module = font
from Sketch.Lib import encoding;iso_latin_1=encoding.iso_latin_1
printable = ''
for n in range(len(iso_latin_1)):
if iso_latin_1[n] != encoding.notdef:
printable = printable + chr(n)
# Alignment. Defaults are 0
ALIGN_BASE = 0
ALIGN_CENTER = 1
ALIGN_TOP = 2
ALIGN_BOTTOM = 3
ALIGN_LEFT = 0
ALIGN_CENTER = 1
ALIGN_RIGHT = 2
class CommonText:
commands = []
def __init__(self, text = '', duplicate = None):
if duplicate is not None:
self.text = duplicate.text
else:
self.text = text
def SetText(self, text, caret = None):
if self.editor is not None:
oldcaret = self.editor.Caret()
else:
oldcaret = 0
undo = (self.SetText, self.text, oldcaret)
self.text = text
if caret is not None and self.editor is not None:
self.editor.SetCaret(caret)
self._changed()
return undo
def Text(self):
return self.text
editor = None
def set_editor(self, editor):
self.editor = editor
def unset_editor(self, editor):
if self.editor is editor:
self.editor = None
def SetFont(self, font, size = None):
if size is not None:
undo = self.properties.SetProperty(font = font, font_size = size)
else:
undo = self.properties.SetProperty(font = font)
return self.properties_changed(undo)
def SetFontSize(self, size):
undo = self.properties.SetProperty(font_size = size)
return self.properties_changed(undo)
def Font(self):
return self.properties.font
def FontSize(self):
return self.properties.font_size
class CommonTextEditor(Editor):
EditedClass = CommonText
commands = []
def __init__(self, object):
Editor.__init__(self, object)
self.caret = 0
object.set_editor(self)
def Destroy(self):
self.object.unset_editor(self)
def ButtonDown(self, p, button, state):
Editor.DragStart(self, p)
def ButtonUp(self, p, button, state):
Editor.DragStop(self, p)
def update_selection(self):
# a bit ugly...
if self.document is not None:
self.document.queue_selection()
def SetCaret(self, caret):
if caret > len(self.text):
caret = len(self.text)
self.caret = caret
def Caret(self):
return self.caret
def InsertCharacter(self, char):
if len(char) == 1 and self.properties.font.IsPrintable(char):
text = self.text; caret = self.caret
text = text[:caret] + char + text[caret:]
return self.SetText(text, caret + 1)
return NullUndo
AddCmd(commands, InsertCharacter, '', key_stroke = tuple(printable),
invoke_with_keystroke = 1)
def DeleteCharBackward(self):
if self.text and self.caret > 0:
text = self.text; caret = self.caret
text = text[:caret - 1] + text[caret:]
return self.SetText(text, caret - 1)
return NullUndo
AddCmd(commands, DeleteCharBackward, '', key_stroke = 'BackSpace')
def DeleteCharForward(self):
if self.text and self.caret < len(self.text):
text = self.text; caret = self.caret
text = text[:caret] + text[caret + 1:]
return self.SetText(text, caret)
return NullUndo
AddCmd(commands, DeleteCharForward, '', key_stroke = ('Delete', 'C-d'))
def MoveForwardChar(self):
if self.caret < len(self.text):
self.SetCaret(self.caret + 1)
self.update_selection()
return NullUndo
AddCmd(commands, MoveForwardChar, '', key_stroke = ('Right', 'C-f'))
def MoveBackwardChar(self):
if self.caret > 0:
self.SetCaret(self.caret - 1)
self.update_selection()
return NullUndo
AddCmd(commands, MoveBackwardChar, '', key_stroke = ('Left', 'C-b'))
def MoveToBeginningOfLine(self):
self.SetCaret(0)
self.update_selection()
return NullUndo
AddCmd(commands, MoveToBeginningOfLine, '', key_stroke = ('Home', 'C-a'))
def MoveToEndOfLine(self):
self.SetCaret(len(self.text))
self.update_selection()
return NullUndo
AddCmd(commands, MoveToEndOfLine, '', key_stroke = ('End', 'C-e'))
RegisterCommands(CommonTextEditor)
class SimpleText(CommonText, RectangularPrimitive):
has_edit_mode = 1
is_Text = 1
is_SimpleText = 1
is_curve = 1
is_clip = 1
has_font = 1
has_fill = 1
has_line = 0
commands = CommonText.commands + RectangularPrimitive.commands
_lazy_attrs = RectangularPrimitive._lazy_attrs.copy()
_lazy_attrs['atrafo'] = 'update_atrafo'
def __init__(self, trafo = None, text = '', halign = ALIGN_LEFT,
valign = ALIGN_BASE, properties = None, duplicate = None):
CommonText.__init__(self, text, duplicate)
RectangularPrimitive.__init__(self, trafo, properties = properties,
duplicate = duplicate)
if duplicate != None:
self.halign = duplicate.halign
self.valign = duplicate.valign
self.atrafo = duplicate.atrafo
else:
self.halign = halign
self.valign = valign
if properties is None:
self.properties = PropertyStack(base=FactoryTextStyle())
self.cache = {}
def Disconnect(self):
self.cache = {}
RectangularPrimitive.Disconnect(self)
def Hit(self, p, rect, device, clip = 0):
a = self.properties
llx, lly, urx, ury = a.font.TextBoundingBox(self.text, a.font_size)
trafo = self.trafo(self.atrafo)
trafo = trafo(Trafo(urx - llx, 0, 0, ury - lly, llx, lly))
return device.ParallelogramHit(p, trafo, 1, 1, 1,
ignore_outline_mode = 1)
def GetObjectHandle(self, multiple):
trafo = self.trafo(self.atrafo(Scale(self.properties.font_size)))
if multiple:
return trafo(NullPoint)
else:
pts = self.properties.font.TypesetText(self.text)
return map(trafo, pts)
def SetAlignment(self, horizontal, vertical):
undo = (self.SetAlignment, self.halign, self.valign)
if horizontal is not None:
self.halign = horizontal
if vertical is not None:
self.valign = vertical
self._changed()
return undo
AddCmd(commands, 'AlignLeft', _("Align Left"), SetAlignment,
args = (ALIGN_LEFT, None))
AddCmd(commands, 'AlignRight', _("Align Right"), SetAlignment,
args =(ALIGN_RIGHT,None))
AddCmd(commands, 'AlignHCenter', _("Align H. Center"), SetAlignment,
args = (ALIGN_CENTER, None))
AddCmd(commands, 'AlignTop', _("Align Top"), SetAlignment,
args = (None, ALIGN_TOP))
AddCmd(commands, 'AlignVCenter', _("Align V. Center"), SetAlignment,
args =(None, ALIGN_CENTER))
AddCmd(commands, 'AlignBase', _("Align Baseline"), SetAlignment,
args = (None, ALIGN_BASE))
AddCmd(commands, 'AlignBottom', _("Align Bottom"), SetAlignment,
args = (None, ALIGN_BOTTOM))
def Alignment(self):
return self.halign, self.valign
def RemoveTransformation(self):
if self.trafo.matrix() != IdentityMatrix:
a = self.properties
trafo = self.trafo
llx, lly, urx, ury = a.font.TextCoordBox(self.text, a.font_size)
try:
undostyle = Primitive.Transform(self, trafo.inverse())
except SingularMatrix:
undostyle = None
undotrafo = self.set_transformation(Translation(trafo.offset()))
return CreateMultiUndo(undostyle, undotrafo)
return NullUndo
def DrawShape(self, device, rect = None, clip = 0):
RectangularPrimitive.DrawShape(self, device)
# Workaround for a bug in my Xserver.
text = split(self.text, '\n')[0]
device.DrawText(self.text, self.trafo(self.atrafo), clip,
cache = self.cache)
def update_atrafo(self):
a = self.properties
llx, lly, urx, ury = a.font.TextCoordBox(self.text, a.font_size)
hj = self.halign
if hj == ALIGN_RIGHT:
xoff = llx - urx
elif hj == ALIGN_CENTER:
xoff = (llx - urx) / 2
else:
xoff = 0
vj = self.valign
if vj == ALIGN_TOP:
yoff = -ury
elif vj == ALIGN_CENTER:
yoff = (lly - ury) / 2 - lly
elif vj == ALIGN_BOTTOM:
yoff = -lly
else:
yoff = 0
self.atrafo = Translation(xoff, yoff)
def update_rects(self):
trafo = self.trafo(self.atrafo)
a = self.properties
rect = apply(Rect, a.font.TextBoundingBox(self.text, a.font_size))
self.bounding_rect = trafo(rect).grown(2)
rect = apply(Rect, a.font.TextCoordBox(self.text, a.font_size))
self.coord_rect = trafo(rect)
def Info(self):
return (_("Text `%(text)s' at %(position)[position]"),
{'text':self.text[:10], 'position':self.trafo.offset()} )
def FullTrafo(self):
# XXX perhaps the Trafo method should return
# self.trafo(self.atrafo) for a SimpleText object as well.
return self.trafo(self.atrafo)
def SaveToFile(self, file):
RectangularPrimitive.SaveToFile(self, file)
file.SimpleText(self.text, self.trafo, self.halign, self.valign)
def Blend(self, other, p, q):
if self.__class__ != other.__class__ \
or self.properties.font != other.properties.font \
or self.text != other.text:
raise MismatchError
blended = self.__class__(BlendTrafo(self.trafo, other.trafo, p, q),
self.text)
self.set_blended_properties(blended, other, p, q)
return blended
def AsBezier(self):
if self.text:
objects = []
base_trafo = self.trafo(self.atrafo)
base_trafo = base_trafo(Scale(self.properties.font_size))
pos = self.properties.font.TypesetText(self.text)
for i in range(len(self.text)):
paths = self.properties.font.GetOutline(self.text[i])
if paths:
obj = PolyBezier(paths = paths,
properties = self.properties.Duplicate())
trafo = base_trafo(Translation(pos[i]))
obj.Transform(trafo)
objects.append(obj)
return Group(objects)
def Paths(self):
paths = []
if self.text:
base_trafo = self.trafo(self.atrafo)
base_trafo = base_trafo(Scale(self.properties.font_size))
pos = self.properties.font.TypesetText(self.text)
for i in range(len(self.text)):
outline = self.properties.font.GetOutline(self.text[i])
trafo = base_trafo(Translation(pos[i]))
for path in outline:
path.Transform(trafo)
paths.append(path)
return tuple(paths)
def Editor(self):
return SimpleTextEditor(self)
context_commands = ('AlignLeft', 'AlignRight', 'AlignHCenter', None,
'AlignTop', 'AlignVCenter', 'AlignBase', 'AlignBottom')
RegisterCommands(SimpleText)
class SimpleTextCreator(Creator):
is_Text = 1 # XXX: ugly
creation_text = _("Create Text")
def __init__(self, start):
Creator.__init__(self, start)
def ButtonDown(self, p, button, state):
Creator.DragStart(self, p)
def MouseMove(self, p, state):
p = self.apply_constraint(p, state)
Creator.MouseMove(self, p, state)
def ButtonUp(self, p, button, state):
p = self.apply_constraint(p, state)
Creator.DragStop(self, p)
def DrawDragged(self, device, partially):
device.DrawLine(self.start, self.drag_cur)
def apply_constraint(self, p, state):
if state & const.ConstraintMask:
r, phi = (p - self.start).polar()
pi12 = pi / 12
phi = pi12 * floor(phi / pi12 + 0.5)
p = self.start + Polar(r, phi)
return p
def CreatedObject(self):
trafo = Translation(self.start)
r, phi = (self.drag_cur - self.start).polar()
if r:
trafo = trafo(Rotation(phi))
return SimpleText(trafo = trafo, properties = DefaultTextProperties())
class SimpleTextEditor(CommonTextEditor):
EditedClass = SimpleText
commands = CommonTextEditor.commands[:]
def GetHandles(self):
a = self.properties
pos, up = a.font.TextCaretData(self.text, self.caret, a.font_size)
pos = self.trafo(self.atrafo(pos))
up = self.trafo.DTransform(up)
return [handle.MakeCaretHandle(pos, up)]
def SelectPoint(self, p, rect, device, mode):
trafo = self.trafo(self.atrafo(Scale(self.properties.font_size)))
trafo = trafo.inverse()
p2 = trafo(p)
pts = self.properties.font.TypesetText(self.text + ' ')
dists = []
for i in range(len(pts)):
dists.append((abs(pts[i].x - p2.x), i))
caret = min(dists)[-1]
self.SetCaret(caret)
return 1
def Destroy(self):
CommonTextEditor.Destroy(self)
self.document.AddAfterHandler(maybe_remove_text, (self.object,))
RegisterCommands(SimpleTextEditor)
def maybe_remove_text(text):
if text.parent is not None and not text.text:
doc = text.document
doc.DeselectObject(text)
doc.AddUndo(text.parent.Remove(text))
doc.selection.update_selinfo()
#
#
#
PATHTEXT_ROTATE = 1
PATHTEXT_SKEW = 2
def coord_sys_at(lengths, pos, type):
if len(lengths) < 2:
return None
for idx in range(len(lengths)):
if lengths[idx][0] > pos:
d2, p2 = lengths[idx]
d1, p1 = lengths[idx - 1]
if d2 != d1 and p1 != p2:
break
else:
return None
t = (pos - d1) / (d2 - d1)
p = (1 - t) * p1 + t * p2
diff = (p2 - p1).normalized()
del lengths[:idx - 1]
if type == PATHTEXT_SKEW:
return Trafo(diff.x, diff.y, 0, 1, p.x, p.y)
else:
return Trafo(diff.x, diff.y, -diff.y, diff.x, p.x, p.y)
def pathtext(path, start_pos, text, font, size, type):
metric = font.metric
lengths = path.arc_lengths(start_pos)
scale = Scale(size); factor = size / 2000.0
pos = font.TypesetText(text)
pos = map(scale, pos)
trafos = []
for idx in range(len(text)):
char = text[idx]
width2 = metric.char_width(ord(char)) * factor
x = pos[idx].x + width2
trafo = coord_sys_at(lengths, x, type)
if trafo is not None:
trafos.append(trafo(Translation(-width2, 0)))
else:
# we've reached the end of the path. Ignore all following
# characters
break
return trafos
class InternalPathText(CommonText, Primitive):
has_edit_mode = 1
is_Text = 1
is_PathTextText = 1
is_curve = 0
is_clip = 1
has_font = 1
has_fill = 1
has_line = 0
_lazy_attrs = Primitive._lazy_attrs.copy()
_lazy_attrs['trafos'] = 'update_trafos'
_lazy_attrs['paths'] = 'update_paths'
commands = CommonText.commands + Primitive.commands
def __init__(self, text = '', trafo = None, model = PATHTEXT_ROTATE,
start_pos = 0.0, properties = None, duplicate = None):
CommonText.__init__(self, text, duplicate = duplicate)
Primitive.__init__(self, properties = properties,
duplicate = duplicate)
if duplicate is not None and isinstance(duplicate, self.__class__):
# dont copy paths, update it from parent
self.trafo = duplicate.trafo
self.model = duplicate.model
self.start_pos = duplicate.start_pos
else:
if trafo is None:
self.trafo = Identity
else:
self.trafo = trafo
self.model = model
self.start_pos = start_pos
self.cache = {}
def update_rects(self):
a = self.properties
length = len(self.trafos)
sizes = [a.font_size] * length
boxes = map(a.font.TextBoundingBox, self.text[:length], sizes)
rects = map(lambda *a:a, map(apply, [Rect] * length, boxes))
self.bounding_rect = reduce(UnionRects, map(apply, self.trafos, rects),
EmptyRect)
boxes = map(a.font.TextCoordBox, self.text[:length], sizes)
rects = map(lambda *a:a, map(apply, [Rect] * length, boxes))
self.coord_rect = reduce(UnionRects, map(apply, self.trafos, rects),
EmptyRect)
def update_trafos(self):
self.trafos = map(self.trafo, pathtext(self.paths[0], self.start_pos,
self.text, self.properties.font,
self.properties.font_size,
self.model))
def update_paths(self):
paths = self.parent.get_paths()
try:
itrafo = self.trafo.inverse()
transformed = []
for path in paths:
path = path.Duplicate()
path.Transform(itrafo)
transformed.append(path)
paths = tuple(transformed)
except SingularMatrix:
# XXX what do we do?
pass
self.paths = paths
def SetText(self, text, caret = None):
self.cache = {}
return CommonText.SetText(self, text, caret)
def PathChanged(self):
self.del_lazy_attrs()
def SetModel(self, model):
undo = (self.SetModel, self.model)
self.model = model
self._changed()
return undo
def Model(self):
return self.model
def SetStartPos(self, start_pos):
undo = (self.SetStartPos, self.start_pos)
self.start_pos = start_pos
self._changed()
return undo
def StartPos(self):
return self.start_pos
def CharacterTransformations(self):
return self.trafos
def DrawShape(self, device, rect = None, clip = 0):
text = self.text; trafos = self.trafos
font = self.properties.font; font_size = self.properties.font_size
Primitive.DrawShape(self, device)
device.BeginComplexText(clip, self.cache)
for idx in range(len(trafos)):
char = text[idx]
if char not in '\r\n': # avoid control chars
device.DrawComplexText(text[idx], trafos[idx], font, font_size)
device.EndComplexText()
def Disconnect(self):
self.cache = {}
Primitive.Disconnect(self)
def Hit(self, p, rect, device, clip = 0):
bbox = self.properties.font.TextBoundingBox
font_size = self.properties.font_size
text = self.text; trafos = self.trafos
for idx in range(len(trafos)):
llx, lly, urx, ury = bbox(text[idx], font_size)
trafo = trafos[idx](Trafo(urx - llx, 0, 0, ury - lly, llx, lly))
if device.ParallelogramHit(p, trafo, 1, 1, 1,
ignore_outline_mode = 1):
return 1
return 0
def Translate(self, offset):
return NullUndo
def Transform(self, trafo):
return self.set_transformation(trafo(self.trafo))
def set_transformation(self, trafo):
undo = (self.set_transformation, self.trafo)
self.trafo = trafo
self._changed()
return undo
def RemoveTransformation(self):
return self.set_transformation(Identity)
def Blend(self, other, p, q):
if self.__class__ != other.__class__ \
or self.properties.font != other.properties.font \
or self.text != other.text:
raise MismatchError
trafo = BlendTrafo(self.trafo, other.trafo, p, q)
start_pos = p * self.start_pos + q * other.start_pos
blended = self.__class__(self.text, trafo = trafo,
start_pos = start_pos, model = self.model)
self.set_blended_properties(blended, other, p, q)
return blended
def SaveToFile(self, file):
Primitive.SaveToFile(self, file)
file.InternalPathText(self.text, self.trafo, self.model,
self.start_pos)
def Info(self):
return _("Text on Path: `%(text)s'") % {'text':self.text[:10]}
def Editor(self):
return InternalPathTextEditor(self)
class InternalPathTextEditor(CommonTextEditor):
EditedClass = InternalPathText
commands = CommonTextEditor.commands
def GetHandles(self):
a = self.properties
if self.caret > 0 and self.trafos:
# special case to deal with here: the characters that fall
# off the end of the path are not visible. If the caret is
# in this invisible area, display the caret after the last
# visible character
caret = 1
index = min(self.caret, len(self.text), len(self.trafos)) - 1
text = self.text[index]
trafo = self.trafos[index]
else:
caret = 0
if self.text and self.trafos:
text = self.text[0]
trafo = self.trafos[0]
else:
# XXX fix this
self.start_point = self.paths[0].point_at(self.start_pos)
return [handle.MakeNodeHandle(self.start_point, 1)]
pos, up = a.font.TextCaretData(text, caret, a.font_size)
pos = trafo(pos)
up = trafo.DTransform(up)
self.start_point = self.trafos[0].offset()
return [handle.MakeCaretHandle(pos, up),
handle.MakeNodeHandle(self.start_point, 1)]
selection = None
def SelectHandle(self, handle, mode = const.SelectSet):
self.selection = handle
def SelectPoint(self, p, rect, device, mode):
if self.trafos:
dists = []
for i in range(len(self.trafos)):
dists.append((abs(p - self.trafos[i].offset()), i))
char = self.text[len(self.trafos) - 1]
width = self.properties.font.metric.char_width(ord(char)) / 1000.0
pos = self.trafos[-1](width * self.properties.font_size, 0)
dists.append((abs(p - pos), len(self.trafos)))
caret = min(dists)[-1]
self.SetCaret(caret)
def ButtonDown(self, p, button, state):
self.cache = {}
return p - self.start_point
def nearest_start_pos(self, p):
try:
x, y = self.trafo.inverse()(p)
t = self.paths[0].nearest_point(x, y)
except SingularMatrix:
# XXX
t = 0.0
return t
def DrawDragged(self, device, partially):
text = self.text; trafos = self.trafos
font = self.properties.font; font_size = self.properties.font_size
t = self.nearest_start_pos(self.drag_cur)
trafos = map(self.trafo, pathtext(self.paths[0], t, text, font,
font_size, self.model))
device.BeginComplexText(0, self.cache)
for idx in range(len(trafos)):
char = text[idx]
if char not in '\n\r':
device.DrawComplexText(char, trafos[idx], font, font_size)
device.EndComplexText()
device.ResetFontCache()
def ButtonUp(self, p, button, state):
CommonTextEditor.ButtonUp(self, p, button, state)
return self.SetStartPos(self.nearest_start_pos(self.drag_cur))
RegisterCommands(InternalPathTextEditor)
class PathText(Compound):
is_PathTextGroup = 1
allow_traversal = 1
commands = Compound.commands[:]
def __init__(self, text = None, path = None, model = PATHTEXT_ROTATE,
start_pos = 0.0, duplicate = None, _blended_text = None):
if duplicate is not None:
Compound.__init__(self, duplicate = duplicate)
self.text = self.objects[0]
self.path = self.objects[1]
else:
if _blended_text is not None:
self.text = _blended_text
self.path = path
Compound.__init__(self, [self.text, self.path])
elif text is not None:
self.text = InternalPathText(text.Text(),
start_pos = start_pos,
model = model,
duplicate = text)
self.path = path
Compound.__init__(self, [self.text, self.path])
else:
# we're being loaded
self.text = self.path = None
Compound.__init__(self)
def ChildChanged(self, child):
if self.document is not None:
self.document.AddClearRect(self.bounding_rect)
Compound.ChildChanged(self, child)
if child is self.path:
self.text.PathChanged()
if self.document is not None:
self.document.AddClearRect(self.bounding_rect)
def load_AppendObject(self, object):
Compound.load_AppendObject(self, object)
if len(self.objects) == 2:
self.text, self.path = self.objects
def SelectSubobject(self, p, rect, device, path = None, *rest):
idx = self.Hit(p, rect, device) - 1
obj = self.objects[idx]
if path:
path_idx = path[0]
path = path[1:]
if path_idx == idx:
obj = obj.SelectSubobject(p, rect, device, path)
elif path == ():
obj = obj.SelectSubobject(p, rect, device)
else:
return self
return selinfo.prepend_idx(idx, obj)
def ReplaceChild(self, child, object):
if child is self.path and object.is_curve:
undo = self.ReplaceChild, object, child
self.path = self.objects[1] = object
object.SetParent(self)
object.SetDocument(self.document)
child.SetParent(None)
self.ChildChanged(object)
#self._changed()
return undo
else:
raise SketchError('Cannot replace child')
def Info(self):
return _("Path Text: `%(text)s'") % {'text':self.text.Text()[:10]}
def SaveToFile(self, file):
file.BeginPathText()
self.text.SaveToFile(file)
self.path.SaveToFile(file)
file.EndPathText()
def SelectTextObject(self):
self.document.SelectObject(self.text)
AddCmd(commands, SelectTextObject, _("Select Text"), key_stroke = 't')
def SelectPathObject(self):
self.document.SelectObject(self.path)
AddCmd(commands, SelectPathObject, _("Select Path"), key_stroke = 'p')
def get_paths(self):
return self.path.Paths()
def SetModel(self, model):
return self.text.SetModel(model)
AddCmd(commands, 'SetModelRotate', _("Rotate Letters"), SetModel,
args = PATHTEXT_ROTATE)
AddCmd(commands, 'SetModelSkew', _("Skew Letters"), SetModel,
args = PATHTEXT_SKEW)
def Model(self):
return self.text.Model()
def Blend(self, other, p, q):
if self.__class__ != other.__class__:
raise MismatchError
return self.__class__(_blended_text = Blend(self.text,other.text, p,q),
path = Blend(self.path, other.path, p, q))
context_commands = ('SelectTextObject', 'SelectPathObject', None,
'SetModelRotate', 'SetModelSkew')
RegisterCommands(PathText)
def CanCreatePathText(objects):
if len(objects) == 2:
if objects[0].is_Text:
return objects[1].is_curve
elif objects[0].is_curve:
return objects[1].is_Text
def CreatePathText(objects):
if len(objects) == 2:
if objects[0].is_Text:
text, curve = objects
elif objects[1].is_Text:
curve, text = objects
if not curve.is_curve:
# XXX what do we do here?
return text
return PathText(text, curve)
|