[OpenSPARC-T2-DV] / tools / src / nas,5.n2.os.2 / lib / python / lib / python2.4 / lib-old / Para.py

# Text formatting abstractions
# Note -- this module is obsolete, it's too slow anyway


# Oft-used type object
Int = type(0)


# Represent a paragraph.  This is a list of words with associated
# font and size information, plus indents and justification for the
# entire paragraph.
# Once the words have been added to a paragraph, it can be laid out
# for different line widths.  Once laid out, it can be rendered at
# different screen locations.  Once rendered, it can be queried
# for mouse hits, and parts of the text can be highlighted
class Para:
    #
    def __init__(self):
        self.words = [] # The words
        self.just = 'l' # Justification: 'l', 'r', 'lr' or 'c'
        self.indent_left = self.indent_right = self.indent_hang = 0
        # Final lay-out parameters, may change
        self.left = self.top = self.right = self.bottom = \
                self.width = self.height = self.lines = None
    #
    # Add a word, computing size information for it.
    # Words may also be added manually by appending to self.words
    # Each word should be a 7-tuple:
    # (font, text, width, space, stretch, ascent, descent)
    def addword(self, d, font, text, space, stretch):
        if font is not None:
            d.setfont(font)
        width = d.textwidth(text)
        ascent = d.baseline()
        descent = d.lineheight() - ascent
        spw = d.textwidth(' ')
        space = space * spw
        stretch = stretch * spw
        tuple = (font, text, width, space, stretch, ascent, descent)
        self.words.append(tuple)
    #
    # Hooks to begin and end anchors -- insert numbers in the word list!
    def bgn_anchor(self, id):
        self.words.append(id)
    #
    def end_anchor(self, id):
        self.words.append(0)
    #
    # Return the total length (width) of the text added so far, in pixels
    def getlength(self):
        total = 0
        for word in self.words:
            if type(word) is not Int:
                total = total + word[2] + word[3]
        return total
    #
    # Tab to a given position (relative to the current left indent):
    # remove all stretch, add fixed space up to the new indent.
    # If the current position is already at the tab stop,
    # don't add any new space (but still remove the stretch)
    def tabto(self, tab):
        total = 0
        as, de = 1, 0
        for i in range(len(self.words)):
            word = self.words[i]
            if type(word) is Int: continue
            (fo, te, wi, sp, st, as, de) = word
            self.words[i] = (fo, te, wi, sp, 0, as, de)
            total = total + wi + sp
        if total < tab:
            self.words.append((None, '', 0, tab-total, 0, as, de))
    #
    # Make a hanging tag: tab to hang, increment indent_left by hang,
    # and reset indent_hang to -hang
    def makehangingtag(self, hang):
        self.tabto(hang)
        self.indent_left = self.indent_left + hang
        self.indent_hang = -hang
    #
    # Decide where the line breaks will be given some screen width
    def layout(self, linewidth):
        self.width = linewidth
        height = 0
        self.lines = lines = []
        avail1 = self.width - self.indent_left - self.indent_right
        avail = avail1 - self.indent_hang
        words = self.words
        i = 0
        n = len(words)
        lastfont = None
        while i < n:
            firstfont = lastfont
            charcount = 0
            width = 0
            stretch = 0
            ascent = 0
            descent = 0
            lsp = 0
            j = i
            while i < n:
                word = words[i]
                if type(word) is Int:
                    if word > 0 and width >= avail:
                        break
                    i = i+1
                    continue
                fo, te, wi, sp, st, as, de = word
                if width + wi > avail and width > 0 and wi > 0:
                    break
                if fo is not None:
                    lastfont = fo
                    if width == 0:
                        firstfont = fo
                charcount = charcount + len(te) + (sp > 0)
                width = width + wi + sp
                lsp = sp
                stretch = stretch + st
                lst = st
                ascent = max(ascent, as)
                descent = max(descent, de)
                i = i+1
            while i > j and type(words[i-1]) is Int and \
                    words[i-1] > 0: i = i-1
            width = width - lsp
            if i < n:
                stretch = stretch - lst
            else:
                stretch = 0
            tuple = i-j, firstfont, charcount, width, stretch, \
                    ascent, descent
            lines.append(tuple)
            height = height + ascent + descent
            avail = avail1
        self.height = height
    #
    # Call a function for all words in a line
    def visit(self, wordfunc, anchorfunc):
        avail1 = self.width - self.indent_left - self.indent_right
        avail = avail1 - self.indent_hang
        v = self.top
        i = 0
        for tuple in self.lines:
            wordcount, firstfont, charcount, width, stretch, \
                    ascent, descent = tuple
            h = self.left + self.indent_left
            if i == 0: h = h + self.indent_hang
            extra = 0
            if self.just == 'r': h = h + avail - width
            elif self.just == 'c': h = h + (avail - width) / 2
            elif self.just == 'lr' and stretch > 0:
                extra = avail - width
            v2 = v + ascent + descent
            for j in range(i, i+wordcount):
                word = self.words[j]
                if type(word) is Int:
                    ok = anchorfunc(self, tuple, word, \
                                    h, v)
                    if ok is not None: return ok
                    continue
                fo, te, wi, sp, st, as, de = word
                if extra > 0 and stretch > 0:
                    ex = extra * st / stretch
                    extra = extra - ex
                    stretch = stretch - st
                else:
                    ex = 0
                h2 = h + wi + sp + ex
                ok = wordfunc(self, tuple, word, h, v, \
                        h2, v2, (j==i), (j==i+wordcount-1))
                if ok is not None: return ok
                h = h2
            v = v2
            i = i + wordcount
            avail = avail1
    #
    # Render a paragraph in "drawing object" d, using the rectangle
    # given by (left, top, right) with an unspecified bottom.
    # Return the computed bottom of the text.
    def render(self, d, left, top, right):
        if self.width != right-left:
            self.layout(right-left)
        self.left = left
        self.top = top
        self.right = right
        self.bottom = self.top + self.height
        self.anchorid = 0
        try:
            self.d = d
            self.visit(self.__class__._renderword, \
                       self.__class__._renderanchor)
        finally:
            self.d = None
        return self.bottom
    #
    def _renderword(self, tuple, word, h, v, h2, v2, isfirst, islast):
        if word[0] is not None: self.d.setfont(word[0])
        baseline = v + tuple[5]
        self.d.text((h, baseline - word[5]), word[1])
        if self.anchorid > 0:
            self.d.line((h, baseline+2), (h2, baseline+2))
    #
    def _renderanchor(self, tuple, word, h, v):
        self.anchorid = word
    #
    # Return which anchor(s) was hit by the mouse
    def hitcheck(self, mouseh, mousev):
        self.mouseh = mouseh
        self.mousev = mousev
        self.anchorid = 0
        self.hits = []
        self.visit(self.__class__._hitcheckword, \
                   self.__class__._hitcheckanchor)
        return self.hits
    #
    def _hitcheckword(self, tuple, word, h, v, h2, v2, isfirst, islast):
        if self.anchorid > 0 and h <= self.mouseh <= h2 and \
                v <= self.mousev <= v2:
            self.hits.append(self.anchorid)
    #
    def _hitcheckanchor(self, tuple, word, h, v):
        self.anchorid = word
    #
    # Return whether the given anchor id is present
    def hasanchor(self, id):
        return id in self.words or -id in self.words
    #
    # Extract the raw text from the word list, substituting one space
    # for non-empty inter-word space, and terminating with '\n'
    def extract(self):
        text = ''
        for w in self.words:
            if type(w) is not Int:
                word = w[1]
                if w[3]: word = word + ' '
                text = text + word
        return text + '\n'
    #
    # Return which character position was hit by the mouse, as
    # an offset in the entire text as returned by extract().
    # Return None if the mouse was not in this paragraph
    def whereis(self, d, mouseh, mousev):
        if mousev < self.top or mousev > self.bottom:
            return None
        self.mouseh = mouseh
        self.mousev = mousev
        self.lastfont = None
        self.charcount = 0
        try:
            self.d = d
            return self.visit(self.__class__._whereisword, \
                              self.__class__._whereisanchor)
        finally:
            self.d = None
    #
    def _whereisword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
        fo, te, wi, sp, st, as, de = word
        if fo is not None: self.lastfont = fo
        h = h1
        if isfirst: h1 = 0
        if islast: h2 = 999999
        if not (v1 <= self.mousev <= v2 and h1 <= self.mouseh <= h2):
            self.charcount = self.charcount + len(te) + (sp > 0)
            return
        if self.lastfont is not None:
            self.d.setfont(self.lastfont)
        cc = 0
        for c in te:
            cw = self.d.textwidth(c)
            if self.mouseh <= h + cw/2:
                return self.charcount + cc
            cc = cc+1
            h = h+cw
        self.charcount = self.charcount + cc
        if self.mouseh <= (h+h2) / 2:
            return self.charcount
        else:
            return self.charcount + 1
    #
    def _whereisanchor(self, tuple, word, h, v):
        pass
    #
    # Return screen position corresponding to position in paragraph.
    # Return tuple (h, vtop, vbaseline, vbottom).
    # This is more or less the inverse of whereis()
    def screenpos(self, d, pos):
        if pos < 0:
            ascent, descent = self.lines[0][5:7]
            return self.left, self.top, self.top + ascent, \
                    self.top + ascent + descent
        self.pos = pos
        self.lastfont = None
        try:
            self.d = d
            ok = self.visit(self.__class__._screenposword, \
                            self.__class__._screenposanchor)
        finally:
            self.d = None
        if ok is None:
            ascent, descent = self.lines[-1][5:7]
            ok = self.right, self.bottom - ascent - descent, \
                    self.bottom - descent, self.bottom
        return ok
    #
    def _screenposword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
        fo, te, wi, sp, st, as, de = word
        if fo is not None: self.lastfont = fo
        cc = len(te) + (sp > 0)
        if self.pos > cc:
            self.pos = self.pos - cc
            return
        if self.pos < cc:
            self.d.setfont(self.lastfont)
            h = h1 + self.d.textwidth(te[:self.pos])
        else:
            h = h2
        ascent, descent = tuple[5:7]
        return h, v1, v1+ascent, v2
    #
    def _screenposanchor(self, tuple, word, h, v):
        pass
    #
    # Invert the stretch of text between pos1 and pos2.
    # If pos1 is None, the beginning is implied;
    # if pos2 is None, the end is implied.
    # Undoes its own effect when called again with the same arguments
    def invert(self, d, pos1, pos2):
        if pos1 is None:
            pos1 = self.left, self.top, self.top, self.top
        else:
            pos1 = self.screenpos(d, pos1)
        if pos2 is None:
            pos2 = self.right, self.bottom,self.bottom,self.bottom
        else:
            pos2 = self.screenpos(d, pos2)
        h1, top1, baseline1, bottom1 = pos1
        h2, top2, baseline2, bottom2 = pos2
        if bottom1 <= top2:
            d.invert((h1, top1), (self.right, bottom1))
            h1 = self.left
            if bottom1 < top2:
                d.invert((h1, bottom1), (self.right, top2))
            top1, bottom1 = top2, bottom2
        d.invert((h1, top1), (h2, bottom2))
Commit	Line	Data
86530b38 AT	1	# Text formatting abstractions
	2	# Note -- this module is obsolete, it's too slow anyway
	3
	4
	5	# Oft-used type object
	6	Int = type(0)
	7
	8
	9	# Represent a paragraph. This is a list of words with associated
	10	# font and size information, plus indents and justification for the
	11	# entire paragraph.
	12	# Once the words have been added to a paragraph, it can be laid out
	13	# for different line widths. Once laid out, it can be rendered at
	14	# different screen locations. Once rendered, it can be queried
	15	# for mouse hits, and parts of the text can be highlighted
	16	class Para:
	17	#
	18	def __init__(self):
	19	self.words = [] # The words
	20	self.just = 'l' # Justification: 'l', 'r', 'lr' or 'c'
	21	self.indent_left = self.indent_right = self.indent_hang = 0
	22	# Final lay-out parameters, may change
	23	self.left = self.top = self.right = self.bottom = \
	24	self.width = self.height = self.lines = None
	25	#
	26	# Add a word, computing size information for it.
	27	# Words may also be added manually by appending to self.words
	28	# Each word should be a 7-tuple:
	29	# (font, text, width, space, stretch, ascent, descent)
	30	def addword(self, d, font, text, space, stretch):
	31	if font is not None:
	32	d.setfont(font)
	33	width = d.textwidth(text)
	34	ascent = d.baseline()
	35	descent = d.lineheight() - ascent
	36	spw = d.textwidth(' ')
	37	space = space * spw
	38	stretch = stretch * spw
	39	tuple = (font, text, width, space, stretch, ascent, descent)
	40	self.words.append(tuple)
	41	#
	42	# Hooks to begin and end anchors -- insert numbers in the word list!
	43	def bgn_anchor(self, id):
	44	self.words.append(id)
	45	#
	46	def end_anchor(self, id):
	47	self.words.append(0)
	48	#
	49	# Return the total length (width) of the text added so far, in pixels
	50	def getlength(self):
	51	total = 0
	52	for word in self.words:
	53	if type(word) is not Int:
	54	total = total + word[2] + word[3]
	55	return total
	56	#
	57	# Tab to a given position (relative to the current left indent):
	58	# remove all stretch, add fixed space up to the new indent.
	59	# If the current position is already at the tab stop,
	60	# don't add any new space (but still remove the stretch)
	61	def tabto(self, tab):
	62	total = 0
	63	as, de = 1, 0
	64	for i in range(len(self.words)):
65	word = self.words[i]
66	if type(word) is Int: continue
67	(fo, te, wi, sp, st, as, de) = word
68	self.words[i] = (fo, te, wi, sp, 0, as, de)
69	total = total + wi + sp
70	if total < tab:
71	self.words.append((None, '', 0, tab-total, 0, as, de))
72	#
73	# Make a hanging tag: tab to hang, increment indent_left by hang,
74	# and reset indent_hang to -hang
75	def makehangingtag(self, hang):
76	self.tabto(hang)
77	self.indent_left = self.indent_left + hang
78	self.indent_hang = -hang
79	#
80	# Decide where the line breaks will be given some screen width
81	def layout(self, linewidth):
82	self.width = linewidth
83	height = 0
84	self.lines = lines = []
85	avail1 = self.width - self.indent_left - self.indent_right
86	avail = avail1 - self.indent_hang
87	words = self.words
88	i = 0
89	n = len(words)
90	lastfont = None
91	while i < n:
92	firstfont = lastfont
93	charcount = 0
94	width = 0
95	stretch = 0
96	ascent = 0
97	descent = 0
98	lsp = 0
99	j = i
100	while i < n:
101	word = words[i]
102	if type(word) is Int:
103	if word > 0 and width >= avail:
104	break
105	i = i+1
106	continue
107	fo, te, wi, sp, st, as, de = word
108	if width + wi > avail and width > 0 and wi > 0:
109	break
110	if fo is not None:
111	lastfont = fo
112	if width == 0:
113	firstfont = fo
114	charcount = charcount + len(te) + (sp > 0)
115	width = width + wi + sp
116	lsp = sp
117	stretch = stretch + st
118	lst = st
119	ascent = max(ascent, as)
120	descent = max(descent, de)
121	i = i+1
122	while i > j and type(words[i-1]) is Int and \
123	words[i-1] > 0: i = i-1
124	width = width - lsp
125	if i < n:
126	stretch = stretch - lst
127	else:
128	stretch = 0
129	tuple = i-j, firstfont, charcount, width, stretch, \
130	ascent, descent
131	lines.append(tuple)
132	height = height + ascent + descent
133	avail = avail1
134	self.height = height
135	#
136	# Call a function for all words in a line
137	def visit(self, wordfunc, anchorfunc):
138	avail1 = self.width - self.indent_left - self.indent_right
139	avail = avail1 - self.indent_hang
140	v = self.top
141	i = 0
142	for tuple in self.lines:
143	wordcount, firstfont, charcount, width, stretch, \
144	ascent, descent = tuple
145	h = self.left + self.indent_left
146	if i == 0: h = h + self.indent_hang
147	extra = 0
148	if self.just == 'r': h = h + avail - width
149	elif self.just == 'c': h = h + (avail - width) / 2
150	elif self.just == 'lr' and stretch > 0:
151	extra = avail - width
152	v2 = v + ascent + descent
153	for j in range(i, i+wordcount):
154	word = self.words[j]
155	if type(word) is Int:
156	ok = anchorfunc(self, tuple, word, \
157	h, v)
158	if ok is not None: return ok
159	continue
160	fo, te, wi, sp, st, as, de = word
161	if extra > 0 and stretch > 0:
162	ex = extra * st / stretch
163	extra = extra - ex
164	stretch = stretch - st
165	else:
166	ex = 0
167	h2 = h + wi + sp + ex
168	ok = wordfunc(self, tuple, word, h, v, \
169	h2, v2, (j==i), (j==i+wordcount-1))
170	if ok is not None: return ok
171	h = h2
172	v = v2
173	i = i + wordcount
174	avail = avail1
175	#
176	# Render a paragraph in "drawing object" d, using the rectangle
177	# given by (left, top, right) with an unspecified bottom.
178	# Return the computed bottom of the text.
179	def render(self, d, left, top, right):
180	if self.width != right-left:
181	self.layout(right-left)
182	self.left = left
183	self.top = top
184	self.right = right
185	self.bottom = self.top + self.height
186	self.anchorid = 0
187	try:
188	self.d = d
189	self.visit(self.__class__._renderword, \
190	self.__class__._renderanchor)
191	finally:
192	self.d = None
193	return self.bottom
194	#
195	def _renderword(self, tuple, word, h, v, h2, v2, isfirst, islast):
196	if word[0] is not None: self.d.setfont(word[0])
197	baseline = v + tuple[5]
198	self.d.text((h, baseline - word[5]), word[1])
199	if self.anchorid > 0:
200	self.d.line((h, baseline+2), (h2, baseline+2))
201	#
202	def _renderanchor(self, tuple, word, h, v):
203	self.anchorid = word
204	#
205	# Return which anchor(s) was hit by the mouse
206	def hitcheck(self, mouseh, mousev):
207	self.mouseh = mouseh
208	self.mousev = mousev
209	self.anchorid = 0
210	self.hits = []
211	self.visit(self.__class__._hitcheckword, \
212	self.__class__._hitcheckanchor)
213	return self.hits
214	#
215	def _hitcheckword(self, tuple, word, h, v, h2, v2, isfirst, islast):
216	if self.anchorid > 0 and h <= self.mouseh <= h2 and \
217	v <= self.mousev <= v2:
218	self.hits.append(self.anchorid)
219	#
220	def _hitcheckanchor(self, tuple, word, h, v):
221	self.anchorid = word
222	#
223	# Return whether the given anchor id is present
224	def hasanchor(self, id):
225	return id in self.words or -id in self.words
226	#
227	# Extract the raw text from the word list, substituting one space
228	# for non-empty inter-word space, and terminating with '\n'
229	def extract(self):
230	text = ''
231	for w in self.words:
232	if type(w) is not Int:
233	word = w[1]
234	if w[3]: word = word + ' '
235	text = text + word
236	return text + '\n'
237	#
238	# Return which character position was hit by the mouse, as
239	# an offset in the entire text as returned by extract().
240	# Return None if the mouse was not in this paragraph
241	def whereis(self, d, mouseh, mousev):
242	if mousev < self.top or mousev > self.bottom:
243	return None
244	self.mouseh = mouseh
245	self.mousev = mousev
246	self.lastfont = None
247	self.charcount = 0
248	try:
249	self.d = d
250	return self.visit(self.__class__._whereisword, \
251	self.__class__._whereisanchor)
252	finally:
253	self.d = None
254	#
255	def _whereisword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
256	fo, te, wi, sp, st, as, de = word
257	if fo is not None: self.lastfont = fo
258	h = h1
259	if isfirst: h1 = 0
260	if islast: h2 = 999999
261	if not (v1 <= self.mousev <= v2 and h1 <= self.mouseh <= h2):
262	self.charcount = self.charcount + len(te) + (sp > 0)
263	return
264	if self.lastfont is not None:
265	self.d.setfont(self.lastfont)
266	cc = 0
267	for c in te:
268	cw = self.d.textwidth(c)
269	if self.mouseh <= h + cw/2:
270	return self.charcount + cc
271	cc = cc+1
272	h = h+cw
273	self.charcount = self.charcount + cc
274	if self.mouseh <= (h+h2) / 2:
275	return self.charcount
276	else:
277	return self.charcount + 1
278	#
279	def _whereisanchor(self, tuple, word, h, v):
280	pass
281	#
282	# Return screen position corresponding to position in paragraph.
283	# Return tuple (h, vtop, vbaseline, vbottom).
284	# This is more or less the inverse of whereis()
285	def screenpos(self, d, pos):
286	if pos < 0:
287	ascent, descent = self.lines[0][5:7]
288	return self.left, self.top, self.top + ascent, \
289	self.top + ascent + descent
290	self.pos = pos
291	self.lastfont = None
292	try:
293	self.d = d
294	ok = self.visit(self.__class__._screenposword, \
295	self.__class__._screenposanchor)
296	finally:
297	self.d = None
298	if ok is None:
299	ascent, descent = self.lines[-1][5:7]
300	ok = self.right, self.bottom - ascent - descent, \
301	self.bottom - descent, self.bottom
302	return ok
303	#
304	def _screenposword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
305	fo, te, wi, sp, st, as, de = word
306	if fo is not None: self.lastfont = fo
307	cc = len(te) + (sp > 0)
308	if self.pos > cc:
309	self.pos = self.pos - cc
310	return
311	if self.pos < cc:
312	self.d.setfont(self.lastfont)
313	h = h1 + self.d.textwidth(te[:self.pos])
314	else:
315	h = h2
316	ascent, descent = tuple[5:7]
317	return h, v1, v1+ascent, v2
318	#
319	def _screenposanchor(self, tuple, word, h, v):
320	pass
321	#
322	# Invert the stretch of text between pos1 and pos2.
323	# If pos1 is None, the beginning is implied;
324	# if pos2 is None, the end is implied.
325	# Undoes its own effect when called again with the same arguments
326	def invert(self, d, pos1, pos2):
327	if pos1 is None:
328	pos1 = self.left, self.top, self.top, self.top
329	else:
330	pos1 = self.screenpos(d, pos1)
331	if pos2 is None:
332	pos2 = self.right, self.bottom,self.bottom,self.bottom
333	else:
334	pos2 = self.screenpos(d, pos2)
335	h1, top1, baseline1, bottom1 = pos1
336	h2, top2, baseline2, bottom2 = pos2
337	if bottom1 <= top2:
338	d.invert((h1, top1), (self.right, bottom1))
339	h1 = self.left
340	if bottom1 < top2:
341	d.invert((h1, bottom1), (self.right, top2))
342	top1, bottom1 = top2, bottom2
343	d.invert((h1, top1), (h2, bottom2))