root/livinglogic.python.xist/src/ll/xist/ns/htmlspecials.py @ 2590:7b6bba35f3a0

Revision 2590:7b6bba35f3a0, 8.9 KB (checked in by Walter Doerwald <walter@…>, 13 years ago)

htmlspecials.pixel() now no longer uses colored pixels, instead color is
done via CSS. The URL for the one remaining transparent pixel can now be
specified via src (either as an XML attribute or via the converter context).

Rename attrs methods with() and without() to withnames() and withoutnames()
(for Python 2.5 compatibility).

Use elinks instead of w3m for asText() and move/rename this method to a
function ll.xist.ns.html.astext().

Try to make XIST independent from PyXML (however PyXML is still required
for parsing via expat and for dtd2xsc.py (because this requires xmlproc)).

Remove the long dperecated method withSep().

Use Py_ssize_t in the C source where appropriate.

Line 
1#! /usr/bin/env python
2# -*- coding: iso-8859-1 -*-
3
4## Copyright 1999-2006 by LivingLogic AG, Bayreuth/Germany.
5## Copyright 1999-2006 by Walter Dörwald
6##
7## All Rights Reserved
8##
9## See xist/__init__.py for the license
10
11"""
12<par>An &xist; module that contains a collection of useful elements for
13generating &html;.</par>
14"""
15
16__version__ = "$Revision$".split()[1]
17# $Source$
18
19import sys, types, time as time_, string, warnings
20
21from ll.xist import xsc, parsers, sims
22from ll.xist.ns import ihtml, html, meta, specials
23
24
25class plaintable(html.table):
26    """
27    <par>a &html; table where the values of the attributes <lit>cellpadding</lit>,
28    <lit>cellspacing</lit> and <lit>border</lit> default to <lit>0</lit>.</par>
29    """
30    class Attrs(html.table.Attrs):
31        class cellpadding(html.table.Attrs.cellpadding):
32            default = 0
33        class cellspacing(html.table.Attrs.cellspacing):
34            default = 0
35        class border(html.table.Attrs.border):
36            default = 0
37
38    def convert(self, converter):
39        e = html.table(self.content, self.attrs)
40        return e.convert(converter)
41
42
43class plainbody(html.body):
44    """
45    <par>a &html; body where the attributes <lit>leftmargin</lit>, <lit>topmargin</lit>,
46    <lit>marginheight</lit> and <lit>marginwidth</lit> default to <lit>0</lit>.</par>
47    """
48    class Attrs(html.body.Attrs):
49        class leftmargin(html.body.Attrs.leftmargin):
50            default = 0
51        class topmargin(html.body.Attrs.topmargin):
52            default = 0
53        class marginheight(html.body.Attrs.marginheight):
54            default = 0
55        class marginwidth(html.body.Attrs.marginwidth):
56            default = 0
57
58    def convert(self, converter):
59        e = html.body(self.content, self.attrs)
60        return e.convert(converter)
61
62
63class _pixelbase(html.img):
64    class Context(html.img.Context):
65        def __init__(self):
66            self.src = "root:px/spc.gif"
67
68    class Attrs(html.img.Attrs):
69        class color(xsc.TextAttr):
70            """
71            The pixel color as a &css; value. Leave it blank to get a transparent
72            pixel.
73            """
74
75        class alt(html.img.Attrs.alt):
76            default = ""
77
78
79class pixel(_pixelbase):
80    """
81    <par>element for single transparent pixel image.</par>
82   
83    <par>You can specify the pixel color via the <lit>color</lit>
84    attribute (which will set the background-color in the style attribute.</par>
85
86    <par>In addition to that you can specify width and height attributes
87    (and every other allowed attribute for the <class>img</class> element)
88    as usual.</par>
89    """
90
91    class Attrs(_pixelbase.Attrs):
92        class width(_pixelbase.Attrs.width):
93            default = 1
94        class height(_pixelbase.Attrs.height):
95            default = 1
96
97    def convert(self, converter):
98        if self.attrs.src:
99            src = self.attrs.src
100        else:
101            src = converter[self].src
102        if self.attrs.color:
103            style = ["background-color: ", self.attrs.color, ";"]
104            if self.attrs.style:
105                style.append(" ")
106                style.append(self.attrs.style)
107        else:
108            style = self.attrs.style
109        e = converter.target.img(
110            self.attrs.withoutnames([u"color"]),
111            style=style,
112            src=src,
113        )
114        return e.convert(converter)
115
116
117class autoimg(html.img):
118    """
119    <par>An image were width and height attributes are automatically generated.</par>
120   
121    <par>If the attributes are already there, they won't be modified.</par>
122    """
123    def convert(self, converter):
124        target = converter.target
125        if issubclass(target, (ihtml, html)):
126            e = target.img(self.attrs.convert(converter))
127        else:
128            raise ValueError("unknown conversion target %r" % target)
129        src = self[u"src"].convert(converter).forInput(converter.root)
130        e._addimagesizeattributes(src, u"width", u"height")
131        return e
132
133
134class autopixel(_pixelbase):
135    """
136    <par>A pixel image were width and height attributes are automatically generated.</par>
137   
138    <par>This works like <pyref class="pixel"><class>pixel</class></pyref> but the
139    size is <z>inherited</z> from the image specified via the <lit>src</lit> attribute.</par>
140    """
141
142    def convert(self, converter):
143        target = converter.target
144        if not issubclass(target, (ihtml, html)):
145            raise ValueError("unknown conversion target %r" % target)
146        e = target.img(self.attrs.withoutnames([u"color"]))
147        src = self.attrs.src.convert(converter).forInput(converter.root)
148        e._addimagesizeattributes(src, u"width", u"height")
149        e.attrs.src = converter[self].src
150        return e
151
152
153class autoinput(html.input):
154    """
155    <par>Extends <pyref module="ll.xist.ns.html" class="input"><class>input</class></pyref>
156    with the ability to automatically set the size, if this element
157    has <lit>type=="image"</lit>.</par>
158    """
159    def convert(self, converter):
160        target = converter.target
161        e = target.input(self.content, self.attrs)
162        if u"type" in self.attrs and unicode(self[u"type"].convert(converter)) == u"image":
163            src = self[u"src"].convert(converter).forInput(converter.root)
164            e._addimagesizeattributes(src, u"size", None) # no height
165        return e.convert(converter)
166
167
168class redirectpage(xsc.Element):
169    model = sims.Empty()
170    class Attrs(xsc.Element.Attrs):
171        class href(xsc.URLAttr): required = True
172
173    langs = {
174        "en": (u"Redirection to ", u"Your browser doesn't understand redirects. This page has been redirected to "),
175        "de": (u"Weiterleitung auf ", u"Ihr Browser unterstützt keine Weiterleitung. Diese Seite wurde weitergeleitet auf ")
176    }
177
178    def convert(self, converter):
179        target = converter.target
180        (title, text) = self.langs.get(converter.lang, self.langs[u"en"])
181        url = self[u"href"]
182        e = target.html(
183            target.head(
184                meta.contenttype(),
185                target.title(title, url)
186            ),
187            target.body(
188                text, target.a(url, href=url)
189            )
190        )
191        return e.convert(converter)
192
193
194class javascript(html.script):
195    """
196    <par>can be used for javascript.</par>
197    """
198    class Attrs(html.script.Attrs):
199        language = None
200        type = None
201
202    def convert(self, converter):
203        target = converter.target
204        e = target.script(self.content, self.attrs, language=u"javascript", type=u"text/javascript")
205        return e.convert(converter)
206
207
208class flash(xsc.Element):
209    model = sims.Empty()
210    class Attrs(xsc.Element.Attrs):
211        class src(xsc.URLAttr): required = True
212        class width(xsc.IntAttr): required = True
213        class height(xsc.IntAttr): required = True
214        class quality(xsc.TextAttr): default = u"high"
215        class bgcolor(xsc.ColorAttr): pass
216
217    def convert(self, converter):
218        target = converter.target
219        e = target.object(
220            target.param(name=u"movie", value=self[u"src"]),
221            target.embed(
222                src=self[u"src"],
223                quality=self[u"quality"],
224                bgcolor=self[u"bgcolor"],
225                width=self[u"width"],
226                height=self[u"height"],
227                type=u"application/x-shockwave-flash",
228                pluginspage=u"http://www.macromedia.com/shockwave/download/index.cgi?P1_Prod_Version=ShockwaveFlash"
229            ),
230            classid=u"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
231            codebase=u"http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=5,0,0,0",
232            width=self[u"width"],
233            height=self[u"height"]
234        )
235
236        # copy optional attributes
237        for attrname in (u"quality", u"bgcolor"):
238            if attrname in self.attrs:
239                e.insert(0, target.param(name=attrname, value=self[attrname]))
240
241        return e.convert(converter)
242
243
244class quicktime(xsc.Element):
245    model = sims.Empty()
246    class Attrs(xsc.Element.Attrs):
247        class src(xsc.URLAttr): required = True
248        class href(xsc.URLAttr): pass
249        class target(xsc.TextAttr): pass
250        class width(xsc.IntAttr): required = True
251        class height(xsc.IntAttr): required = True
252        class bgcolor(xsc.ColorAttr): pass
253        class controller(xsc.ColorAttr): values = (u"true", u"false")
254        class autoplay(xsc.ColorAttr): values = (u"true", u"false")
255        class border(xsc.IntAttr): pass
256
257    def convert(self, converter):
258        target = converter.target
259        e = target.object(
260            target.param(name=u"src", value=self[u"src"]),
261            target.param(name=u"type", value=u"video/quicktime"),
262            target.param(name=u"pluginspage", value=u"http://www.apple.com/quicktime/download/indext.html"),
263            target.embed(
264                src=self[u"src"],
265                href=self[u"href"],
266                target=self[u"target"],
267                bgcolor=self[u"bgcolor"],
268                width=self[u"width"],
269                height=self[u"height"],
270                type=u"video/quicktime",
271                border=self[u"border"],
272                pluginspage=u"http://www.apple.com/quicktime/download/indext.html"
273            ),
274            classid=u"clsid:02BF25D5-8C17-4B23-BC80-D3488ABDDC6B",
275            codebase=u"http://www.apple.com/qtactivex/qtplugin.cab#version=6,0,2,0",
276            width=self[u"width"],
277            height=self[u"height"]
278        )
279
280        # copy optional attributes
281        for attrname in (u"href", u"target", u"bgcolor", u"controller", u"autoplay"):
282            if attrname in self.attrs:
283                e.insert(0, target.param(name=attrname, value=self[attrname]))
284
285        return e.convert(converter)
286
287
288class ImgAttrDecorator(specials.AttrDecorator):
289    class Attrs(html.img.Attrs):
290        pass
291    idecoratable = (html.img,)
292
293
294class InputAttrDecorator(specials.AttrDecorator):
295    class Attrs(html.input.Attrs):
296        pass
297    decoratable = (html.input,)
298
299
300class FormAttrDecorator(specials.AttrDecorator):
301    class Attrs(html.form.Attrs):
302        pass
303    decoratable = (html.form,)
304
305
306class TextAreaAttrDecorator(specials.AttrDecorator):
307    class Attrs(html.textarea.Attrs):
308        pass
309    decoratable = (html.textarea,)
310
311
312class __ns__(xsc.Namespace):
313    xmlname = "htmlspecials"
314    xmlurl = "http://xmlns.livinglogic.de/xist/ns/htmlspecials"
315__ns__.makemod(vars())
Note: See TracBrowser for help on using the browser.