← Back to branch summary

~ubuntu-branches/ubuntu/natty/moin/natty-updates

« back to all changes in this revision

Viewing changes to MoinMoin/formatter/text_plain.py

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard
  • Date: 2008-06-22 21:17:13 UTC
  • mto: This revision was merged to the branch mainline in revision 18.
  • Revision ID: james.westby@ubuntu.com-20080622211713-inlv5k4eifxckelr
Import upstream version 1.7.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
MoinMoin/formatter/text_plain.py
3
3
    MoinMoin - "text/plain" Formatter
4
4
 
5
5
    @copyright: 2000-2002 Juergen Hermann <jh@web.de>
6
 
                2007 by Timo Sirainen <tss@iki.fi>
7
6
    @license: GNU GPL, see COPYING for details.
8
7
"""
9
8
 
10
9
from MoinMoin.formatter import FormatterBase
11
10
 
12
 
 
13
11
class Formatter(FormatterBase):
14
12
    """
15
13
        Send plain text data.
22
20
        self._in_code_area = 0
23
21
        self._in_code_line = 0
24
22
        self._code_area_state = [0, -1, -1, 0]
25
 
        self._lists = []
 
23
        self._in_list = 0
 
24
        self._did_para = 0
26
25
        self._url = None
27
 
        self._text = None  # XXX does not work with links in headings!!!!!
28
 
        self._text_stack = []
29
 
        self._skip_text = False
30
 
        self._wrap_skip_text = False
31
 
        self._textbuf = ''
32
 
        self._indent = 0
33
 
        self._listitem_on = []
34
 
        self._empty_line_count = 2
35
 
        self._paragraph_ended = False
36
 
        self._paragraph_skip_begin = True
 
26
        self._text = None # XXX does not work with links in headings!!!!!
37
27
 
38
28
    def startDocument(self, pagename):
39
 
        line = u'\n'.rjust(len(pagename) + 2, u'*')
40
 
        return self.wrap(u"%s %s \n%s" % (line, pagename, line))
 
29
        line = u"*" * (len(pagename) + 2) + u'\n'
 
30
        return u"%s %s \n%s" % (line, pagename, line)
41
31
 
42
 
    def endContent(self):
43
 
        return self.flush(True)
 
32
    def endDocument(self):
 
33
        return u'\n'
44
34
 
45
35
    def sysmsg(self, on, **kw):
46
 
        return self.wrap((u'\n\n*** ', u' ***\n\n')[not on])
 
36
        return (u'\n\n*** ', u' ***\n\n')[not on]
47
37
 
48
38
    def pagelink(self, on, pagename='', page=None, **kw):
49
39
        FormatterBase.pagelink(self, on, pagename, page, **kw)
50
 
        if on:
51
 
            if not self._textbuf or self._textbuf[-1] in ('\n', ' '):
52
 
                result = self.wrap(u'<')
53
 
            else:
54
 
                result = self.wrap(u' <')
55
 
            self.text_on(True)
56
 
            self.add_missing_space()
57
 
            return result
58
 
        else:
59
 
            linktext = self._text
60
 
            self.text_off()
61
 
            orig_pagename = pagename
62
 
            if pagename.find('/'):
63
 
                pagename = pagename.replace('/', '.')
64
 
            pagename += '.txt'
65
 
            if linktext == orig_pagename:
66
 
                return self.wrap(u'%s>' % pagename)
67
 
            else:
68
 
                return self.wrap(u'%s> [%s]' % (linktext, pagename))
 
40
        return (u">>", u"<<") [not on]
69
41
 
70
42
    def interwikilink(self, on, interwiki='', pagename='', **kw):
71
43
        if on:
72
 
            self.add_missing_space()
73
44
            self._url = u"%s:%s" % (interwiki, pagename)
74
 
            self.text_on()
 
45
            self._text = []
75
46
            return u''
76
47
        else:
77
 
            text = self._text
78
 
            self.text_off()
79
 
            if text == self._url:
80
 
                result = ''
 
48
            if "".join(self._text) == self._url:
 
49
                self._url = None
 
50
                self._text = None
 
51
                return ''
81
52
            else:
82
 
                result = self.wrap(u' [%s]' % (self._url))
83
 
            self._url = None
84
 
            return result
 
53
                self._url = None
 
54
                self._text = None
 
55
                return u' [%s]' % (self._url)
85
56
 
86
57
    def url(self, on, url='', css=None, **kw):
87
58
        if on:
88
 
            self.add_missing_space()
89
59
            self._url = url
90
 
            self.text_on()
 
60
            self._text = []
91
61
            return u''
92
62
        else:
93
 
            text = self._text
94
 
            self.text_off()
95
 
            if text == self._url or 'mailto:' + text == self._url:
96
 
                result = ''
 
63
            if "".join(self._text) == self._url:
 
64
                self._url = None
 
65
                self._text = None
 
66
                return ''
97
67
            else:
98
 
                result = self.wrap(u' [%s]' % (self._url))
99
 
            self._url = None
100
 
            return result
 
68
                self._url = None
 
69
                self._text = None
 
70
                return u' [%s]' % (self._url)
101
71
 
102
72
    def attachment_link(self, on, url=None, **kw):
103
73
        if on:
104
 
            if 'title' in kw and kw['title']:
105
 
                if kw['title'] != url:
106
 
                    return self.wrap(u'[attachment:%s ' % url)
107
 
            return self.wrap(u'[attachment:')
108
 
        return self.wrap(']')
 
74
            return "["
 
75
        else:
 
76
            return "]"
109
77
 
110
78
    def attachment_image(self, url, **kw):
111
79
        title = ''
112
80
        for a in (u'title', u'html__title', u'alt', u'html_alt'):
113
81
            if a in kw:
114
82
                title = ':' + kw[a]
115
 
        return self.wrap("[image:%s%s]" % (url, title))
 
83
        return "[image:%s%s]" % (url, title)
116
84
 
117
85
    def attachment_drawing(self, url, text, **kw):
118
 
        return self.wrap("[drawing:%s]" % text)
 
86
        return "[drawing:%s]" % text
119
87
 
120
88
    def text(self, text, **kw):
 
89
        self._did_para = 0
121
90
        if self._text is not None:
122
 
            self._text += text
123
 
        if self._wrap_skip_text:
124
 
            return ''
125
 
        return self.wrap(text)
 
91
            self._text.append(text)
 
92
        return text
126
93
 
127
94
    def rule(self, size=0, **kw):
128
95
        size = min(size, 10)
129
96
        ch = u"---~=*+#####"[size]
130
 
        self.paragraph_begin()
131
 
        result = self.wrap((ch * (79 - self._indent)))
132
 
        self.paragraph_end()
133
 
        return result
 
97
        return (ch * 79) + u'\n'
134
98
 
135
99
    def strong(self, on, **kw):
136
 
        if on:
137
 
            self.add_missing_space()
138
 
        return self.wrap(u'*')
 
100
        return u'*'
139
101
 
140
102
    def emphasis(self, on, **kw):
141
 
        if on:
142
 
            self.add_missing_space()
143
 
        return self.wrap(u'/')
 
103
        return u'/'
144
104
 
145
105
    def highlight(self, on, **kw):
146
106
        return u''
147
107
 
148
108
    def number_list(self, on, type=None, start=None, **kw):
149
109
        if on:
150
 
            if self._lists:
151
 
                # No empty lines between sublists
152
 
                self._paragraph_ended = False
153
 
            self.paragraph_begin()
154
 
            self._lists.append(0)
155
 
            self._listitem_on.append(False)
156
 
        elif self._lists:
157
 
            self.paragraph_end()
158
 
            num = self._lists.pop()
159
 
            listitem_on = self._listitem_on.pop()
160
 
            if listitem_on:
161
 
                prefix = ' %d. ' % (num)
162
 
                self._indent -= len(prefix)
163
 
        return ''
 
110
            self._in_list = 1
 
111
            return [u'\n', u'\n\n'][not self._did_para]
 
112
        else:
 
113
            self._in_list = 0
 
114
            if not self._did_para:
 
115
                self._did_para = 1
 
116
                return u'\n'
 
117
        return u''
164
118
 
165
119
    def bullet_list(self, on, **kw):
166
120
        if on:
167
 
            if self._lists:
168
 
                # No empty lines between sublists
169
 
                self._paragraph_ended = False
170
 
            self.paragraph_begin()
171
 
            self._lists.append(-1)
172
 
            self._listitem_on.append(False)
 
121
            self._in_list = -1
 
122
            return [u'\n', u'\n\n'][not self._did_para]
173
123
        else:
174
 
            self.paragraph_end()
175
 
            self._lists.pop()
176
 
            listitem_on = self._listitem_on.pop()
177
 
            if listitem_on:
178
 
                self._indent -= 3
179
 
        return ''
 
124
            self._in_list = 0
 
125
            if not self._did_para:
 
126
                self._did_para = 1
 
127
                return u'\n'
 
128
        return u''
180
129
 
181
130
    def listitem(self, on, **kw):
182
 
        self._paragraph_ended = False
183
 
        if not on:
184
 
            # we can't rely on this
185
 
            self.paragraph_end()
186
 
            return ''
187
 
 
188
 
        result = ''
189
 
        num = self._lists.pop()
190
 
        listitem_on = self._listitem_on.pop()
191
 
        if listitem_on and on:
192
 
            # we didn't receive on=False for previous listitem
193
 
            self.paragraph_end()
194
 
            if num >= 0:
195
 
                prefix = ' %d. ' % (num)
196
 
                self._indent -= len(prefix)
 
131
        if on:
 
132
            if self._in_list > 0:
 
133
                self._in_list += 1
 
134
                self._did_para = 1
 
135
                return ' %d. ' % (self._in_list-1, )
 
136
            elif self._in_list < 0:
 
137
                self._did_para = 1
 
138
                return u' * '
197
139
            else:
198
 
                self._indent -= 3
199
 
 
200
 
        if num >= 0:
201
 
            num += 1
202
 
            prefix = ' %d. ' % (num)
 
140
                return u' * '
203
141
        else:
204
 
            # FIXME: also before tables, at leat in LDA.Sieve.txt
205
 
            prefix = ' * '
206
 
        self._lists.append(num)
207
 
        self._listitem_on.append(on)
208
 
 
209
 
        result += self.wrap(prefix)
210
 
        self._indent += len(prefix)
211
 
        self._paragraph_skip_begin = True
212
 
        return result
 
142
            self._did_para = 1
 
143
            return u'\n'
213
144
 
214
145
    def sup(self, on, **kw):
215
 
        if on:
216
 
            return self.wrap(u'^')
217
 
        else:
218
 
            return ''
 
146
        return u'^'
219
147
 
220
148
    def sub(self, on, **kw):
221
 
        return self.wrap(u'_')
 
149
        return u'_'
222
150
 
223
151
    def strike(self, on, **kw):
224
 
        if on:
225
 
            self.add_missing_space()
226
 
        return self.wrap(u'__')
 
152
        return u'__'
227
153
 
228
154
    def code(self, on, **kw):
229
 
        if on:
230
 
            self.add_missing_space()
231
 
        return self.wrap(u"'")
 
155
        #return [unichr(0x60), unichr(0xb4)][not on]
 
156
        return u"'" # avoid high-ascii
232
157
 
233
158
    def preformatted(self, on, **kw):
234
159
        FormatterBase.preformatted(self, on)
235
 
        snip = u'%s\n' % u'---%<'.ljust(78 - self._indent, u'-')
 
160
        snip = u'---%<'
 
161
        snip = snip + (u'-' * (78 - len(snip)))
236
162
        if on:
237
 
            self.paragraph_begin()
238
 
            return self.wrap(snip)
 
163
            return u'\n' + snip + u'\n'
239
164
        else:
240
 
            if self._textbuf and not self._textbuf.endswith('\n'):
241
 
                self._textbuf += '\n'
242
 
            result = self.wrap(snip)
243
 
            self.paragraph_end()
244
 
            return result
 
165
            return snip + u'\n'
245
166
 
246
167
    def small(self, on, **kw):
247
 
        if on:
248
 
            self.add_missing_space()
249
168
        return u''
250
169
 
251
170
    def big(self, on, **kw):
252
 
        if on:
253
 
            self.add_missing_space()
254
171
        return u''
255
172
 
256
 
    def code_area(self, on, code_id, code_type='code', show=0, start=-1,
257
 
                  step=-1, msg=None):
258
 
        snip = u'%s\n' % u'---CodeArea'.ljust(78 - self._indent, u'-')
 
173
    def code_area(self, on, code_id, code_type='code', show=0, start=-1, step=-1):
 
174
        snip = u'---CodeArea'
 
175
        snip = snip + (u'-' * (78 - len(snip)))
259
176
        if on:
260
 
            self.paragraph_begin()
261
177
            self._in_code_area = 1
262
178
            self._in_code_line = 0
263
179
            self._code_area_state = [show, start, step, start]
264
 
            return self.wrap(snip)
 
180
            return u'\n' + snip + u'\n'
265
181
        else:
266
182
            if self._in_code_line:
267
 
                return self.wrap(self.code_line(0) + snip)
268
 
            result = self.wrap(snip)
269
 
            self.paragraph_end()
270
 
            return result
 
183
                return self.code_line(0) + snip + u'\n'
 
184
            return snip + u'\n'
271
185
 
272
186
    def code_line(self, on):
273
187
        res = u''
278
192
                res += u' %4d  ' % self._code_area_state[3]
279
193
                self._code_area_state[3] += self._code_area_state[2]
280
194
        self._in_code_line = on != 0
281
 
        return self.wrap(res)
 
195
        return res
282
196
 
283
197
    def code_token(self, on, tok_type):
284
198
        return ""
285
199
 
286
 
    def add_missing_space(self):
287
 
        if self._textbuf and self._textbuf[-1].isalnum():
288
 
            self._textbuf += ' '
289
 
 
290
200
    def paragraph(self, on, **kw):
291
201
        FormatterBase.paragraph(self, on)
292
 
        if on:
293
 
            self.paragraph_begin()
294
 
        else:
295
 
            self.paragraph_end()
296
 
        return ''
 
202
        if self._did_para:
 
203
            on = 0
 
204
        return [u'\n', u''][not on]
297
205
 
298
206
    def linebreak(self, preformatted=1):
299
 
        return self.wrap(u'\n')
 
207
        return u'\n'
300
208
 
301
209
    def smiley(self, text):
302
 
        return self.wrap(text)
 
210
        return text
303
211
 
304
212
    def heading(self, on, depth, **kw):
305
213
        if on:
306
 
            self.paragraph_begin()
307
 
            self.text_on()
308
 
            result = ''
 
214
            self._text = []
 
215
            return '\n\n'
309
216
        else:
310
 
            if depth == 1:
311
 
                ch = u'='
312
 
            else:
313
 
                ch = u'-'
314
 
 
315
 
            result = u'\n%s\n' % (ch * len(self._text))
316
 
            self.text_off()
317
 
            result = self.wrap(result)
318
 
            self.paragraph_end()
319
 
        return result
320
 
 
321
 
    def get_table_sep(self, col_widths):
322
 
        result = ''
323
 
        for width in col_widths:
324
 
            result += '+' + ('-' * width)
325
 
        return result + '+\n'
326
 
 
327
 
    def fix_col_widths(self):
328
 
        min_widths = self._table_column_min_len
329
 
        max_widths = self._table_column_max_len
330
 
        max_len = sum(max_widths)
331
 
        # take the needed space equally from all columns
332
 
        count = len(max_widths)
333
 
        idx, skip = 0, 0
334
 
        available_len = 79 - count - 1
335
 
        while max_len > available_len:
336
 
            if max_widths[idx] > min_widths[idx]:
337
 
                max_widths[idx] -= 1
338
 
                max_len -= 1
339
 
                skip = 0
340
 
            else:
341
 
                skip += 1
342
 
                if skip == count:
343
 
                    # there are only too wide columns
344
 
                    break
345
 
            if idx == count - 1:
346
 
                idx = 0
347
 
            else:
348
 
                idx += 1
349
 
        return max_widths
 
217
            result = u'\n%s\n\n' % (u'=' * len("".join(self._text)))
 
218
            self._text = None
 
219
            return result
350
220
 
351
221
    def table(self, on, attrs={}, **kw):
352
 
        if on:
353
 
            self._table = []
354
 
            self._table_column_min_len = []
355
 
            self._table_column_max_len = []
356
 
            result = self.flush(True)
357
 
        else:
358
 
            result = u''
359
 
            col_widths = self.fix_col_widths()
360
 
            for row in self._table:
361
 
                result += self.get_table_sep(col_widths)
362
 
                more = True
363
 
                while more:
364
 
                    more = False
365
 
                    num = 0
366
 
                    result += '|'
367
 
                    for col in row:
368
 
                        # break at next LF
369
 
                        lf_idx = col.find('\n')
370
 
                        if lf_idx != -1:
371
 
                            more = True
372
 
                            col_len = lf_idx
373
 
                            next_idx = lf_idx + 1
374
 
                        else:
375
 
                            col_len = len(col)
376
 
                            next_idx = col_len
377
 
                        # possibly break earlier if we need to wrap
378
 
                        if col_len > col_widths[num]:
379
 
                            idx = col.rfind(' ', 0, col_widths[num])
380
 
                            if idx == -1:
381
 
                                idx = col.find(' ', col_widths[num])
382
 
                            if idx != -1:
383
 
                                col_len = idx
384
 
                                next_idx = idx + 1
385
 
                            more = True
386
 
                        result += ' ' + col[:col_len]
387
 
                        result += (' ' * (col_widths[num] - col_len - 1)) + '|'
388
 
                        row[num] = col[next_idx:]
389
 
                        num += 1
390
 
                    result += '\n'
391
 
            result += self.get_table_sep(col_widths)
392
 
            self._table = None
393
 
            self._table_column_min_len = None
394
 
            self._table_column_max_len = None
395
 
            self._empty_line_count = 0
396
 
            self.paragraph_end()
397
 
        return result
 
222
        return u''
398
223
 
399
224
    def table_row(self, on, attrs={}, **kw):
400
 
        if on:
401
 
            self._table.append([])
402
225
        return u''
403
226
 
404
227
    def table_cell(self, on, attrs={}, **kw):
405
 
        if on:
406
 
            self.text_on()
407
 
            self._wrap_skip_text = True
408
 
        else:
409
 
            # keep track of the longest word and the longest line in the cell
410
 
            self._text = self._text.strip()
411
 
            max_line_len = 0
412
 
            max_word_len = 0
413
 
            for line in self._text.split('\n'):
414
 
                if len(line) > max_line_len:
415
 
                    max_line_len = len(line)
416
 
            for word in self._text.split(' '):
417
 
                if len(word) > max_word_len:
418
 
                    max_word_len = len(word)
419
 
            # one preceding and trailing cell whitespace
420
 
            max_word_len += 2
421
 
            max_line_len += 2
422
 
 
423
 
            rownum = len(self._table) - 1
424
 
            colnum = len(self._table[rownum])
425
 
            if len(self._table_column_max_len) <= colnum:
426
 
                self._table_column_min_len.append(max_word_len)
427
 
                self._table_column_max_len.append(max_line_len)
428
 
            else:
429
 
                if max_word_len > self._table_column_min_len[colnum]:
430
 
                    self._table_column_min_len[colnum] = max_word_len
431
 
                if self._table_column_max_len[colnum] < max_line_len:
432
 
                    self._table_column_max_len[colnum] = max_line_len
433
 
            self._table[rownum].append(self._text)
434
 
            self.text_off()
435
228
        return u''
436
229
 
437
230
    def underline(self, on, **kw):
438
 
        return self.wrap(u'_')
 
231
        return u'_'
439
232
 
440
233
    def definition_list(self, on, **kw):
441
 
        if on:
442
 
            self.paragraph_begin()
443
 
        else:
444
 
            self.paragraph_end()
445
234
        return u''
446
235
 
447
236
    def definition_term(self, on, compact=0, **kw):
448
237
        result = u''
449
 
        #if not compact:
450
 
        #    result = result + u'\n'
 
238
        if not compact:
 
239
            result = result + u'\n'
451
240
        if not on:
452
 
            result = result + u':'
453
 
        return self.wrap(result)
 
241
            result = result + u':\n'
 
242
        return result
454
243
 
455
244
    def definition_desc(self, on, **kw):
456
 
        if on:
457
 
            self._indent += 2
458
 
            self.paragraph_begin()
459
 
        else:
460
 
            self.paragraph_end()
461
 
            self._textbuf += '\n'
462
 
            self._indent -= 2
463
 
        return ''
 
245
        return [u'    ', u'\n'][not on]
464
246
 
465
247
    def image(self, src=None, **kw):
466
248
        for a in (u'title', u'html__title', u'alt', u'html_alt'):
467
249
            if a in kw:
468
 
                return self.wrap(kw[a] + ' [' + src + ']')
469
 
        return self.wrap('[' + src + ']')
 
250
                return kw[a]
 
251
        return u''
 
252
 
 
253
    def transclusion(self, on, **kw):
 
254
        return u''
 
255
 
 
256
    def transclusion_param(self, **kw):
 
257
        return u''
470
258
 
471
259
    def lang(self, on, lang_name):
472
260
        return ''
473
261
 
474
 
    def paragraph_begin(self):
475
 
        if self._paragraph_ended:
476
 
            self._textbuf += '\n'
477
 
        elif not self._paragraph_skip_begin:
478
 
            if self._textbuf and not self._textbuf.endswith('\n'):
479
 
                self._textbuf += '\n'
480
 
        self._paragraph_ended = False
481
 
        self._paragraph_skip_begin = False
482
 
 
483
 
    def paragraph_end(self):
484
 
        if self._textbuf and not self._textbuf.endswith('\n'):
485
 
            self._textbuf += '\n'
486
 
        self._paragraph_ended = True
487
 
 
488
 
    def wrap(self, text):
489
 
        if not text:
490
 
            return ''
491
 
        if self._wrap_skip_text:
492
 
            # we're inside table
493
 
            #self._text += 'w{' + text + '}'
494
 
            self._text += text
495
 
            return ''
496
 
 
497
 
        self._paragraph_ended = False
498
 
        self._paragraph_skip_begin = False
499
 
 
500
 
        # add indents after all LFs. kind of dirty to split twice though..
501
 
        lines = text.split('\n')
502
 
        text = lines.pop(0)
503
 
        while lines:
504
 
            text += '\n%s%s' % (' ' * self._indent, lines.pop(0))
505
 
 
506
 
        if not self._textbuf or self._textbuf.endswith('\n'):
507
 
            self._textbuf += ' ' * self._indent
508
 
        self._textbuf += text
509
 
 
510
 
        lines = self._textbuf.split('\n')
511
 
        self._textbuf = ''
512
 
        text = ''
513
 
        while lines:
514
 
            self._textbuf += lines.pop(0)
515
 
            if lines:
516
 
                # LFs found
517
 
                text += self.flush(True)
518
 
            if len(self._textbuf) > 80 and \
519
 
                    self._textbuf.find(' ', self._indent) != -1:
520
 
                # wrap time
521
 
                text += self.flush(False)
522
 
        return text
523
 
 
524
 
    def flush(self, addlf):
525
 
        result = ''
526
 
 
527
 
        while len(self._textbuf) >= 80:
528
 
            # need to wrap
529
 
            last_space = self._textbuf.rfind(' ', self._indent, 80)
530
 
            if last_space == -1:
531
 
                # a long line. split at the next possible space
532
 
                last_space = self._textbuf.find(' ', self._indent)
533
 
                if last_space == -1:
534
 
                    break
535
 
            result += self._textbuf[:last_space] + '\n'
536
 
            self._empty_line_count = 0
537
 
            self._textbuf = ' ' * self._indent + self._textbuf[last_space + 1:]
538
 
        self._textbuf = self._textbuf.rstrip()
539
 
 
540
 
        if not self._textbuf:
541
 
            if not addlf:
542
 
                return result
543
 
            self._empty_line_count += 1
544
 
            if self._empty_line_count >= 2:
545
 
                return result
546
 
        else:
547
 
            self._empty_line_count = 0
548
 
 
549
 
        if addlf:
550
 
            result += self._textbuf + '\n'
551
 
            self._textbuf = ''
552
 
        return result
553
 
 
554
 
    def text_on(self, skip_text=False):
555
 
        if self._text is None:
556
 
            self._text_stack.append(None)
557
 
        else:
558
 
            self._text_stack.append(self._text)
559
 
            #self._text_stack.append('[' + self._text + ']')
560
 
        self._text_stack.append(self._skip_text)
561
 
        self._text_stack.append(self._wrap_skip_text)
562
 
        self._text = ""
563
 
        self._skip_text = skip_text
564
 
        if skip_text:
565
 
            self._wrap_skip_text = True
566
 
 
567
 
    def text_off(self):
568
 
        prev_skip_text = self._skip_text
569
 
        self._wrap_skip_text = self._text_stack.pop()
570
 
        self._skip_text = self._text_stack.pop()
571
 
        old_text = self._text_stack.pop()
572
 
        if old_text is None:
573
 
            self._text = None
574
 
        else:
575
 
            if not prev_skip_text:
576
 
                #self._text = 'o#' + old_text + '#|#' + self._text + '#'
577
 
                self._text = old_text + self._text
578
 
            else:
579
 
                self._text = old_text