Cutlery/calibre
1
0
Fork 0
mirror of https://github.com/kovidgoyal/calibre.git synced 2025-07-09 03:04:10 -04:00
Code Issues Packages Projects Releases Wiki Activity

Various improvements to lrs2lrf

Browse Source
This commit is contained in:
Kovid Goyal 2008-01-12 22:06:34 +00:00
parent 8f5aa3ede4
commit 50d07673f8
7 changed files with 287 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libprs500/ebooks/lrf/html/convert_from.py
View File

@ -807,7 +807,7 @@ class HTMLConverter(object):
dec = css['text-decoration'].lower() dec = css['text-decoration'].lower()
linepos = 'after' if dec == 'underline' else 'before' if dec == 'overline' else None linepos = 'after' if dec == 'underline' else 'before' if dec == 'overline' else None
if linepos is not None: if linepos is not None:
elem = EmpLine(elem, lineposition=linepos) elem = EmpLine(elem, emplineposition=linepos)
self.current_para.append(elem) self.current_para.append(elem)

319
src/libprs500/ebooks/lrf/lrs/convert_from.py
View File

@ -31,14 +31,14 @@ from libprs500.ebooks.lrf.pylrs.pylrs import \
Paragraph, CR, Italic, Bold, ImageStream, \ Paragraph, CR, Italic, Bold, ImageStream, \
CharButton, Button, PushButton, JumpTo, \ CharButton, Button, PushButton, JumpTo, \
Plot, Image, RuledLine, Canvas, DropCaps, \ Plot, Image, RuledLine, Canvas, DropCaps, \
Sup, Sub, Span, Text, \ Sup, Sub, Span, Text, EmpLine, Font, \
LrsError, Space, Box, ButtonBlock, NoBR LrsError, Space, Box, ButtonBlock, NoBR
from libprs500 import __appname__, __version__ from libprs500 import __appname__, __version__
class LrsParser(object): class LrsParser(object):
filterAttrib = ['objid', 'refobj', 'objlabel', 'pagestyle', 'blockstyle', 'textstyle', 'stylelabel', filterAttrib = ['objid', 'refobj', 'objlabel', 'pagestyle', 'blockstyle', 'textstyle', 'stylelabel',
'evenheaderid', 'oddheaderid', 'evenfooterid', 'oddfooterid'] 'evenheaderid', 'oddheaderid', 'evenfooterid', 'oddfooterid', 'page_tree_id', 'refstream']
def __init__(self, file): def __init__(self, file):
self.file = file self.file = file
self.book = Book() self.book = Book()
@ -53,6 +53,9 @@ class LrsParser(object):
self.footers = list() self.footers = list()
self.headers = list() self.headers = list()
self.putobjs = list() self.putobjs = list()
self.plots = list()
self.images = list()
self.imageblocks = list()
self.root = ElementTree(file=file) self.root = ElementTree(file=file)
# #
@ -65,22 +68,45 @@ class LrsParser(object):
id = element.attrib['objid'] id = element.attrib['objid']
if id not in self.objects: if id not in self.objects:
self.objects[id] = element self.objects[id] = element
elif self.equal_element(self.objects[id], element):
continue
elif self.objects[id] != element: elif self.objects[id] != element:
raise LrsError, "multiple objects with same objid=%d, %s and %s"%(id, element.tag, self.objects[id].tag) raise LrsError, "multiple objects with same objid=%s, %s and %s"%(id, element.tag, self.objects[id].tag)
if id == objid:
break
if objid in self.objects: if objid in self.objects:
return self.objects[objid] return self.objects[objid]
return None return None
# #
# compare two attrib dictionaries for equivalence # put the tag and attributes into one string
#
def element_dump(self, element):
str = ""
str += "<%s"%element.tag
keys = element.attrib.keys()
keys.sort()
for key in keys:
str += " %s=\"%s\""%(key,element.attrib[key])
# should do something about sub elements and sub text
str += "/>"
return str
#
# compare two elements for identical tags and attributes
#
def equal_element(self, e1, e2):
return e1.tag == e2.tag and self._equal_attrib(e1, e2, ignore=[])
#
# compare two element attrib dictionaries for equivalence
# ignoring some attributes
# #
def equal_attrib(self, e1, e2): def equal_attrib(self, e1, e2):
return self._equal_attrib(e1, e2, ignore=LrsParser.filterAttrib)
def _equal_attrib(self, e1, e2, ignore):
#print "comparing %s to %s in equal_attrib"%(e1.tag,e2.tag) #print "comparing %s to %s in equal_attrib"%(e1.tag,e2.tag)
a1 = e1.attrib a1 = e1.attrib
a2 = e2.attrib a2 = e2.attrib
ignore = LrsParser.filterAttrib
for name in a1.keys(): for name in a1.keys():
if name in ignore: if name in ignore:
continue continue
@ -112,11 +138,9 @@ class LrsParser(object):
if name == 'objid': if name == 'objid':
if id not in self.objects: if id not in self.objects:
self.objects[id] = element self.objects[id] = element
elif self.objects[id] != element: elif self.objects[id] != element and not self.equal_element(self.objects[id], element):
raise LrsError, "multiple objects with same objid=%s, %s and %s"%(id, element.tag, self.objects[id].tag) raise LrsError, "multiple objects with same objid=%s, %s and %s"%(id, element.tag, self.objects[id].tag)
del attrib[name] del attrib[name]
return attrib return attrib
# #
@ -257,12 +281,20 @@ class LrsParser(object):
obj.append(Text(text.text)) obj.append(Text(text.text))
for element in text: for element in text:
print "No text processor for ", element.tag print "No text processor for %s", self.element_dump(element)
if element.tail != None: if element.tail != None:
obj.append(Text(element.tail)) obj.append(Text(element.tail))
return obj return obj
#
# <Plot> occurs in draw_char, simple_char2, ...
#
def process_Plot(self, plot):
self.plots.append(plot)
plot.lrsplot = Plot(None, **self.process_attrib(plot))
return plot.lrsplot
def process_draw_char(self, draw_char, obj): def process_draw_char(self, draw_char, obj):
"""Process an element in the DrawChar set""" """Process an element in the DrawChar set"""
@ -271,49 +303,49 @@ class LrsParser(object):
for element in draw_char: for element in draw_char:
if element.tag == "Span": if element.tag == "Span":
obj.append(self.process_draw_char(element, Span(**element.attrib))) obj.append(self.process_draw_char(element, Span(**self.process_attrib(element))))
elif element.tag == "Plot": elif element.tag == "Plot":
obj.append(self.process_text(element, Plot(**element.attrib))) obj.append(self.process_text(element, self.process_Plot(element)))
elif element.tag == "CR": elif element.tag == "CR":
obj.append(CR()) obj.append(CR())
elif element.tag == "Space": elif element.tag == "Space":
obj.append(Space(**element.attrib)) obj.append(Space(**self.process_attrib(element)))
elif element.tag == "CharButton": elif element.tag == "CharButton":
self.charbuttons.append(element) self.charbuttons.append(element)
element.lrscharbutton = CharButton(None, **self.process_attrib(element)) element.lrscharbutton = CharButton(None, **self.process_attrib(element))
obj.append(self.process_simple_char1(element, element.lrscharbutton)) obj.append(self.process_simple_char1(element, element.lrscharbutton))
elif element.tag == "Sup": elif element.tag == "Sup":
obj.append(self.process_simple_char0(element, Sup(element.text))) obj.append(self.process_simple_char0(element, Sup()))
elif element.tag == "Sub": elif element.tag == "Sub":
obj.append(self.process_simple_char0(element, Sub(element.text))) obj.append(self.process_simple_char0(element, Sub()))
elif element.tag == "NoBR": elif element.tag == "NoBR":
obj.append(self.process_simple_char1(element, NoBR())) obj.append(self.process_simple_char1(element, NoBR()))
elif element.tag == "DrawChar": elif element.tag == "DrawChar":
obj.append(self.process_simple_char0(element, DropCaps(**element.attrib))) obj.append(self.process_simple_char0(element, DropCaps(**self.process_attrib(element))))
elif element.tag == "Box": elif element.tag == "Box":
obj.append(self.process_simple_char0(element, Box(**element.attrib))) obj.append(self.process_simple_char0(element, Box(**self.process_attrib(element))))
elif element.tag == "Italic": elif element.tag == "Italic":
obj.append(self.process_draw_char(element, Italic())) obj.append(self.process_draw_char(element, Italic()))
elif element.tag == "Bold": elif element.tag == "Bold":
obj.append(self.process_draw_char(element, Bold())) obj.append(self.process_draw_char(element, Bold()))
# elif element.tag == "Fill": # elif element.tag == "Fill":
# obj.append(Fill(**element.attrib)) # obj.append(Fill(**self.process_attrib(element)))
# elif element.tag == "Rubi": # elif element.tag == "Rubi":
# obj.append(process_Rubi(element)) # obj.append(self.process_Rubi(element))
# elif element.tag == "Yoko": # elif element.tag == "Yoko":
# obj.append(process_simple_char0(element, Yoko(**element.attrib))) # obj.append(self.process_simple_char0(element, Yoko(**self.process_attrib(element))))
# elif element.tag == "Tate": # elif element.tag == "Tate":
# obj.append(process_simple_char2(element, Tate(**element.attrib))) # obj.append(self.process_simple_char2(element, Tate(**self.process_attrib(element))))
# elif element.tag == "Nekase": # elif element.tag == "Nekase":
# obj.append(process_simple_char2(element, Nekase(**element.attrib))) # obj.append(self.process_simple_char2(element, Nekase(**self.process_attrib(element))))
# elif element.tag == "EmpLine": elif element.tag == "EmpLine":
# obj.append(process_simple_char0(element, EmpLine(**element.attrib))) obj.append(self.process_simple_char0(element, EmpLine(**self.process_attrib(element))))
# elif element.tag == "EmpDots": # elif element.tag == "EmpDots":
# obj.append(process_simple_char0(element, EmpDots(**element.attrib))) # obj.append(self.process_simple_char0(element, EmpDots(**self.process_attrib(element))))
# elif element.tag == "Gaiji": # elif element.tag == "Gaiji":
# obj.append(process_text(element, Gaiji(**element.attrib))) # obj.append(self.process_text(element, Gaiji(**self.process_attrib(element))))
# elif element.tag == "AltString": # elif element.tag == "AltString":
# obj.append(process_AltString(element)) # obj.append(self.process_AltString(element))
else: else:
print "No DrawChar set processor for ", element.tag print "No DrawChar set processor for ", element.tag
if element.tail != None: if element.tail != None:
@ -327,12 +359,14 @@ class LrsParser(object):
if simple_char0.text != None: if simple_char0.text != None:
obj.append(Text(simple_char0.text)) obj.append(Text(simple_char0.text))
for element in simple_char0: for element in simple_char0:
# if element.tag == "Gaiji": if element.tag == "Plot":
# obj.append(process_text(element, Gaiji(**element.attrib))) obj.append(self.process_text(element, self.process_Plot(element)))
# elif element.tag == "Gaiji":
# obj.append(process_text(element, Gaiji(**self.process_attrib(element))))
# elif element.tag == "AltString": # elif element.tag == "AltString":
# obj.append(process_AltString(element)) # obj.append(process_AltString(element))
# else: else:
print "No SimpleChar0 set processor for ", element.tag print "No SimpleChar0 set processor for ", element.tag
if element.tail != None: if element.tail != None:
obj.append(Text(element.tail)) obj.append(Text(element.tail))
@ -341,27 +375,26 @@ class LrsParser(object):
def process_simple_char1(self, simple_char1, obj): def process_simple_char1(self, simple_char1, obj):
"""Process an element in the SimpleChar1 set""" """Process an element in the SimpleChar1 set"""
if simple_char1.text != None: if simple_char1.text != None:
obj.append(Text(simple_char1.text)) obj.append(Text(simple_char1.text))
for element in simple_char1: for element in simple_char1:
if element.tag == "Box": if element.tag == "Box":
obj.append(self.process_simple_char0(element), Box(**element.attrib)) obj.append(self.process_simple_char0(element), Box(**self.process_attrib(element)))
elif element.tag == "Sub": elif element.tag == "Sub":
obj.append(self.process_simple_char0(element, Sub(**element.attrib))) obj.append(self.process_simple_char0(element, Sub(**self.process_attrib(element))))
elif element.tag == "Sup": elif element.tag == "Sup":
obj.append(self.process_simple_char0(element, Sup(**element.attrib))) obj.append(self.process_simple_char0(element, Sup(**self.process_attrib(element))))
elif element.tag == "Space": elif element.tag == "Space":
obj.append(Space(**element.attrib)) obj.append(Space(**self.process_attrib(element)))
# elif element.tag == "Rubi": # elif element.tag == "Rubi":
# obj.append(process_Rubi(element)) # obj.append(process_Rubi(element))
# elif element.tag == "Gaiji": # elif element.tag == "Gaiji":
# obj.append(process_text(element, Gaiji(**element.attrib))) # obj.append(process_text(element, Gaiji(**self.process_attrib(element))))
# elif element.tag == "EmpDots": # elif element.tag == "EmpDots":
# obj.append(process_simple_char0(element, EmpDots(**element.attrib))) # obj.append(process_simple_char0(element, EmpDots(**self.process_attrib(element))))
# elif element.tag == "EmpLine": # elif element.tag == "EmpLine":
# obj.append(process_simple_char0(element, EmpLine(**element.attrib))) # obj.append(process_simple_char0(element, EmpLine(**self.process_attrib(element))))
# elif element.tag == "AltString": # elif element.tag == "AltString":
# obj.append(process_AltString(element)) # obj.append(process_AltString(element))
else: else:
@ -379,9 +412,9 @@ class LrsParser(object):
for element in simple_char2: for element in simple_char2:
if element.tag == "Plot": if element.tag == "Plot":
obj.append(self.process_text(element, Plot(**element.attrib))) obj.append(self.process_text(element, self.process_Plot(element)))
# elif element.tag == "Gaiji": # elif element.tag == "Gaiji":
# obj.append(process_text(element, Gaiji(**element.attrib))) # obj.append(process_text(element, Gaiji(**self.process_attrib(element))))
# elif element.tag == "AltString": # elif element.tag == "AltString":
# obj.append(process_AltString(element)) # obj.append(process_AltString(element))
else: else:
@ -391,6 +424,13 @@ class LrsParser(object):
return obj return obj
#
# <PutObj> occurs in <Canvas>, <Header>, <Footer>
#
def process_PutObj(self, putobj):
self.putobjs.append(putobj)
putobj.lrsputobj = PutObj(None, **self.process_attrib(putobj))
return putobj.lrsputobj
# #
# <Canvas> occurs in <Page>, <Objects>, <Window> # <Canvas> occurs in <Page>, <Objects>, <Window>
@ -398,19 +438,24 @@ class LrsParser(object):
def process_Canvas(self, canvas): def process_Canvas(self, canvas):
"""Process the <Canvas> element""" """Process the <Canvas> element"""
dcanvas = Canvas(**canvas.attrib) width = canvas.attrib['canvaswidth']
height = canvas.attrib['canvasheight']
del canvas.attrib['canvaswidth']
del canvas.attrib['canvasheight']
dcanvas = Canvas(width=width, height=height, **self.process_attrib(canvas))
# text permitted? # text permitted?
for element in canvas: for element in canvas:
if element.tag == "PutObj": if element.tag == "PutObj":
dcanvas.append(PutObj(**element.attrib)) dcanvas.append(self.process_PutObj(element))
# elif element.tag == "MoveTo": # elif element.tag == "MoveTo":
# dcanvas.append(MoveTo(**element.attrib)) # dcanvas.append(MoveTo(**self.process_attrib(element)))
# elif element.tag == "LineTo": # elif element.tag == "LineTo":
# dcanvas.append(LineTo(**element.attrib)) # dcanvas.append(LineTo(**self.process_attrib(element)))
# elif element.tag == "DrawBox": # elif element.tag == "DrawBox":
# dcanvas.append(DrawBox(**element.attrib)) # dcanvas.append(DrawBox(**self.process_attrib(element)))
# elif element.tag == "DrawEllipse": # elif element.tag == "DrawEllipse":
# dcanvas.append(DrawEllipse(**element.attrib)) # dcanvas.append(DrawEllipse(**self.process_attrib(element)))
else: else:
print "No <Canvas> processor for ", element.tag print "No <Canvas> processor for ", element.tag
# tail text permitted? # tail text permitted?
@ -424,7 +469,7 @@ class LrsParser(object):
"""Process the <TextBlock> element""" """Process the <TextBlock> element"""
self.dobjects[textBlock.attrib['objid']] = \ self.dobjects[textBlock.attrib['objid']] = \
dtextblock = self.book.create_text_block(textStyle=self.fetch_style(textBlock, 'textstyle'), dtextblock = self.book.create_text_block(textStyle=self.fetch_style(textBlock, 'textstyle'),
blockStyle=self.fetch_style(textBlock, 'blockstyle'), blockStyle=self.fetch_style(textBlock, 'blockstyle'),
**self.process_attrib(textBlock)) **self.process_attrib(textBlock))
# text permitted? # text permitted?
@ -454,11 +499,11 @@ class LrsParser(object):
element.lrsjumpto = JumpTo(None) element.lrsjumpto = JumpTo(None)
dbutton.append(element.lrsjumpto) dbutton.append(element.lrsjumpto)
#elif element.tag == "Run": #elif element.tag == "Run":
# dbutton.append(Run(**element.attrib)) # dbutton.append(Run(**self.process_attrib(element)))
#elif element.tag == "SoundStop": #elif element.tag == "SoundStop":
# dbutton.append(SoundStop(**element.attrib)) # dbutton.append(SoundStop(**self.process_attrib(element)))
#elif element.tag == "CloseWindow": #elif element.tag == "CloseWindow":
# dbutton.append(CloseWindow(**element.attrib)) # dbutton.append(CloseWindow(**self.process_attrib(element)))
else: else:
print "No ", name, " processor for ", element.tag print "No ", name, " processor for ", element.tag
# tail text permitted? # tail text permitted?
@ -475,16 +520,16 @@ class LrsParser(object):
# #
# <FocusinButton> occurs in <ButtonBlock>, <Button> # <FocusinButton> occurs in <ButtonBlock>, <Button>
# #
#def process_FocusinButton(self, button): def process_FocusinButton(self, button):
# """Process the <FocusinButton> element""" """Process the <FocusinButton> element"""
# return self.process_some_Button(button, FocusinButton(**button.attrib), "<FocusinButton>") return self.process_some_Button(button, FocusinButton(**button.attrib), "<FocusinButton>")
# #
# <UpButton> occurs in <ButtonBlock>, <Button> # <UpButton> occurs in <ButtonBlock>, <Button>
# #
#def process_UpButton(self, button): def process_UpButton(self, button):
# """Process the <FocusinButton> element""" """Process the <FocusinButton> element"""
# return self.process_some_Button(button, UpButton(**button.attrib), "<UpButton>") return self.process_some_Button(button, UpButton(**button.attrib), "<UpButton>")
# #
# <ButtonBlock> occurs in <Page>, <Objects>, <Window> # <ButtonBlock> occurs in <Page>, <Objects>, <Window>
@ -495,19 +540,36 @@ class LrsParser(object):
dbuttonblock = ButtonBlock() dbuttonblock = ButtonBlock()
# text permitted? # text permitted?
for element in buttonBlock: for element in buttonBlock:
#if element.tag == "BaseButton": if element.tag == "BaseButton":
# dbuttonblock.append(BaseButton(**element.attrib)) dbuttonblock.append(BaseButton(**self.process_attrib(element)))
#elif element.tag == "FocusinButton": elif element.tag == "FocusinButton":
# dbuttonblock.append(process_FocusinButton(element)) dbuttonblock.append(self.process_FocusinButton(element))
#elif element.tag == "PushButton": elif element.tag == "PushButton":
# dbuttonblock.append(process_PushButton(element)) dbuttonblock.append(self.process_PushButton(element))
#elif element.tag == "UpButton": elif element.tag == "UpButton":
# dbuttonblock.append(process_UpButton(element)) dbuttonblock.append(self.process_UpButton(element))
#else: else:
print "No <ButtonBlock> processor for ", element.tag print "No <%s> processor for <%s>"%(buttonBlock.tag,element.tag)
# tail text permitted? # tail text permitted?
return dbuttonblock return dbuttonblock
#
# <ImageBlock> occurs in ...
#
def process_ImageBlock(self, imageblock):
self.imageblocks.append(imageblock)
imageblock.lrsimageblock = ImageBlock(None, **self.process_attrib(imageblock))
self.dobjects[imageblock.attrib['objid']] = imageblock.lrsimageblock
return self.process_text(imageblock, imageblock.lrsimageblock)
#
# <Image> occurs in ...
def process_Image(self, image):
self.images.append(image)
image.lrsimage = Image(None, **self.process_attrib(image))
self.dobjects[image.attrib['objid']] = image.lrsimage
return self.process_text(image, image.lrsimage)
# #
# <Button> occurs at toplevel, also <Page>, <Objects>, <Window> # <Button> occurs at toplevel, also <Page>, <Objects>, <Window>
# #
@ -515,19 +577,19 @@ class LrsParser(object):
"""Process the <Button> element""" """Process the <Button> element"""
self.dobjects[button.attrib['objid']] = \ self.dobjects[button.attrib['objid']] = \
dbutton = Button(**self.process_attrib(button)) dbutton = Button(**self.process_attrib(button))
# text permitted? # text permitted?
for element in button: for element in button:
#if element.tag == "BaseButton": if element.tag == "BaseButton":
# dbutton.append(BaseButton(**element.attrib)) dbutton.append(BaseButton(**self.process_attrib(element)))
#elif element.tag == "FocusinButton": elif element.tag == "FocusinButton":
# dbutton.append(self.process_FocusinButton(element)) dbutton.append(self.process_FocusinButton(element))
#elif element.tag == "PushButton": elif element.tag == "PushButton":
# dbutton.append(self.process_PushButton(element)) dbutton.append(self.process_PushButton(element))
#elif element.tag == "UpButton": elif element.tag == "UpButton":
# dbutton.append(self.process_UpButton(element)) dbutton.append(self.process_UpButton(element))
#else: else:
print "No <ButtonBlock> processor for ", element.tag print "No <Button> processor for <%s>"%element.tag
# tail text permitted? # tail text permitted?
return dbutton return dbutton
@ -542,25 +604,25 @@ class LrsParser(object):
if name+'id' in page.attrib: if name+'id' in page.attrib:
attrib[name] = self.fetch_header_footer(page, name+'id') attrib[name] = self.fetch_header_footer(page, name+'id')
self.dobjects[page.attrib['objid']] = \ self.dobjects[page.attrib['objid']] = \
dpage = self.book.create_page(pageStyle=self.fetch_style(page, 'pagestyle'), **attrib) dpage = self.book.create_page(pageStyle=self.fetch_style(page, 'pagestyle'), **attrib)
# text permitted? # text permitted?
for element in page: for element in page:
if element.tag == "TextBlock": if element.tag == "TextBlock":
dpage.append(self.process_TextBlock(element)) dpage.append(self.process_TextBlock(element))
elif element.tag == "ImageBlock": elif element.tag == "ImageBlock":
dpage.append(self.process_text(element, ImageBlock(**element.attrib))) dpage.append(self.process_ImageBlock(element))
elif element.tag == "ButtonBlock": elif element.tag == "ButtonBlock":
dpage.append(self.process_ButtonBlock(element)) dpage.append(self.process_ButtonBlock(element))
elif element.tag == "Button": elif element.tag == "Button":
dpage.append(self.process_Button(element)) dpage.append(self.process_Button(element))
elif element.tag == "BlockSpace": elif element.tag == "BlockSpace":
dpage.BlockSpace(**element.attrib) dpage.BlockSpace(**self.process_attrib(element))
elif element.tag == "Canvas": elif element.tag == "Canvas":
dpage.append(self.process_Canvas(element)) dpage.append(self.process_Canvas(element))
elif element.tag == "RuledLine": elif element.tag == "RuledLine":
dpage.append(RuledLine(**element.attrib)) dpage.append(RuledLine(**self.process_attrib(element)))
#elif element.tag == "Wait": #elif element.tag == "Wait":
# dpage.append(Wait(**element.attrib)) # dpage.append(Wait(**self.process_attrib(element)))
else: else:
print "No <Page> processor for ", element.tag print "No <Page> processor for ", element.tag
# tail text permitted? # tail text permitted?
@ -574,17 +636,15 @@ class LrsParser(object):
for element in header: for element in header:
if element.tag == "PutObj": if element.tag == "PutObj":
self.putobjs.append(element) dheader.append(self.process_PutObj(element))
element.lrsputobj = PutObj(None, **self.process_attrib(element))
dheader.append(element.lrsputobj)
# elif element.tag == "MoveTo": # elif element.tag == "MoveTo":
# dheader.append(MoveTo(**element.attrib)) # dheader.append(MoveTo(**self.process_attrib(element)))
# elif element.tag == "LineTo": # elif element.tag == "LineTo":
# dheader.append(LineTo(**element.attrib)) # dheader.append(LineTo(**self.process_attrib(element)))
# elif element.tag == "DrawBox": # elif element.tag == "DrawBox":
# dheader.append(DrawBox(**element.attrib)) # dheader.append(DrawBox(**self.process_attrib(element)))
# elif element.tag == "DrawEllipse": # elif element.tag == "DrawEllipse":
# dheader.append(DrawEllipse(**element.attrib)) # dheader.append(DrawEllipse(**self.process_attrib(element)))
else: else:
print "No <Header> processor for ", element.tag print "No <Header> processor for ", element.tag
@ -598,22 +658,28 @@ class LrsParser(object):
for element in footer: for element in footer:
if element.tag == "PutObj": if element.tag == "PutObj":
self.putobjs.append(element) dfooter.append(self.process_PutObj(element))
element.lrsputobj = PutObj(None, **self.process_attrib(element))
dfooter.append(element.lrsputobj)
# elif element.tag == "MoveTo": # elif element.tag == "MoveTo":
# dheader.append(MoveTo(**element.attrib)) # dheader.append(MoveTo(**self.process_attrib(element)))
# elif element.tag == "LineTo": # elif element.tag == "LineTo":
# dheader.append(LineTo(**element.attrib)) # dheader.append(LineTo(**self.process_attrib(element)))
# elif element.tag == "DrawBox": # elif element.tag == "DrawBox":
# dheader.append(DrawBox(**element.attrib)) # dheader.append(DrawBox(**self.process_attrib(element)))
# elif element.tag == "DrawEllipse": # elif element.tag == "DrawEllipse":
# dheader.append(DrawEllipse(**element.attrib)) # dheader.append(DrawEllipse(**self.process_attrib(element)))
else: else:
print "No <Footer> processor for ", element.tag print "No <Footer> processor for ", element.tag
return dfooter return dfooter
#
# <ImageStream> occurs in <Objects>
#
def process_ImageStream(self, imagestream):
self.dobjects[imagestream.attrib['objid']] = \
dimagestream = ImageStream(**self.process_attrib(imagestream))
return self.process_text(imagestream, dimagestream)
# #
# Toplevel elements. # Toplevel elements.
# #
@ -745,9 +811,11 @@ class LrsParser(object):
for element in bookStyle: for element in bookStyle:
if element.tag == "SetDefault": if element.tag == "SetDefault":
dbookstyle.styledefault = StyleDefault(**element.attrib) dbookstyle.styledefault = StyleDefault(**self.process_attrib(element))
elif element.tag == "BookSetting": elif element.tag == "BookSetting":
dbookstyle.booksetting = BookSetting(**element.attrib) dbookstyle.booksetting = BookSetting(**self.process_attrib(element))
elif element.tag == "RegistFont":
dbookstyle.append(Font(**self.process_attrib(element)))
else: else:
print "No <BookStyle> processor for ", element.tag print "No <BookStyle> processor for ", element.tag
@ -755,13 +823,13 @@ class LrsParser(object):
if element.tag == "BookStyle": if element.tag == "BookStyle":
process_BookStyle(element) process_BookStyle(element)
elif element.tag == "PageStyle": elif element.tag == "PageStyle":
# ignore - self.book.append(PageStyle(**element.attrib)) # ignore - self.book.append(PageStyle(**self.process_attrib(element)))
None None
elif element.tag == "TextStyle": elif element.tag == "TextStyle":
# ignore - self.book.append(TextStyle(**element.attrib)) # ignore - self.book.append(TextStyle(**self.process_attrib(element)))
None None
elif element.tag == "BlockStyle": elif element.tag == "BlockStyle":
# ignore - self.book.append(BlockStyle(**element.attrib)) # ignore - self.book.append(BlockStyle(**self.process_attrib(element)))
None None
else: else:
print "No <Style> processor for ", element.tag print "No <Style> processor for ", element.tag
@ -778,35 +846,35 @@ class LrsParser(object):
# def process_Window(window): # def process_Window(window):
# """Process the <Window> element""" # """Process the <Window> element"""
# #
# dwindow = Window(**window.attrib) # dwindow = Window(**self.process_attrib(window))
# #
# for element in window: # for element in window:
# if element.tag == "TextBlock": # if element.tag == "TextBlock":
# dwindow.append(process_TextBlock(element)) # dwindow.append(self.process_TextBlock(element))
# elif element.tag == "ImageBlock": # elif element.tag == "ImageBlock":
# dwindow.append(process_text(element, ImageBlock(**element.attrib))) # dwindow.append(self.process_ImageBlock(element)
# elif element.tag == "ButtonBlock": # elif element.tag == "ButtonBlock":
# dwindow.append(process_ButtonBlock(element)) # dwindow.append(self.process_ButtonBlock(element))
# elif element.tag == "Button": # elif element.tag == "Button":
# dwindow.append(process_Button(element)) # dwindow.append(self.process_Button(element))
# elif element.tag == "Canvas": # elif element.tag == "Canvas":
# dwindow.append(process_Canvas(element)) # dwindow.append(self.process_Canvas(element))
# elif element.tag == "RuledLine": # elif element.tag == "RuledLine":
# dwindow.append(RuledLine(**element.attrib)) # dwindow.append(RuledLine(**self.process_attrib(element)))
# elif element.tag == "Wait": # elif element.tag == "Wait":
# dwindow.append(Wait(**element.attrib)) # dwindow.append(Wait(**self.process_attrib(element)))
# else: # else:
# print "No <Window> processor for ", element.tag # print "No <Window> processor for ", element.tag
# <PopUpWin> occurs in <Objects> # <PopUpWin> occurs in <Objects>
# def process_PopUpWin(popUpWin): # def process_PopUpWin(popUpWin):
# """Process <PopUpWin> element""" # """Process <PopUpWin> element"""
# dpopupwin = PopUpWin(**popUpWin.attrib) # dpopupwin = PopUpWin(**self.process_attrib(popUpWin))
# for element in popUpWin: # for element in popUpWin:
# if element.tag == "TextBlock": # if element.tag == "TextBlock":
# dpopupwin.append(process_TextBlock(element)) # dpopupwin.append(process_TextBlock(element))
# elif element.tag == "ImageBlock": # elif element.tag == "ImageBlock":
# dpopup.append(process_text(element, ImageBlock(**element.attrib))) # dpopup.append(self.process_ImageBlock(element))
# else: # else:
# print "No <PopUpWin> processor for ", element.tag # print "No <PopUpWin> processor for ", element.tag
@ -825,7 +893,7 @@ class LrsParser(object):
if element.tag == "TextBlock": if element.tag == "TextBlock":
dobjects.append(self.process_TextBlock(element)) dobjects.append(self.process_TextBlock(element))
elif element.tag == "ImageBlock": elif element.tag == "ImageBlock":
dobjects.appendImageBlock(self.process_text(element, ImageBlock(**element.attrib))) dobjects.appendImageBlock(self.process_ImageBlock(element))
elif element.tag == "ButtonBlock": elif element.tag == "ButtonBlock":
dobjects.append(self.process_ButtonBlock(element)) dobjects.append(self.process_ButtonBlock(element))
elif element.tag == "Button": elif element.tag == "Button":
@ -841,7 +909,7 @@ class LrsParser(object):
# elif element.tag == "SoundStream": # elif element.tag == "SoundStream":
# dobjects.appendSoundStream(self.process_empty(element)) # dobjects.appendSoundStream(self.process_empty(element))
elif element.tag == "ImageStream": elif element.tag == "ImageStream":
dobjects.appendImageStream(self.process_text(element, ImageStream(**element.attrib))) dobjects.appendImageStream(self.process_ImageStream(element))
elif element.tag == "Header": elif element.tag == "Header":
# processed as part of Page or PageStyle, just skip here # processed as part of Page or PageStyle, just skip here
None # self.process_Header(element) None # self.process_Header(element)
@ -851,7 +919,7 @@ class LrsParser(object):
# elif element.tag == "eSound": # elif element.tag == "eSound":
# dobjects.appendeSound(process_empty(element)) # dobjects.appendeSound(process_empty(element))
elif element.tag == "Image": elif element.tag == "Image":
dobjects.appendImage(self.process_text(element, Image(**element.attrib))) dobjects.appendImage(self.process_Image(element))
# elif element.tag == "TOC": # elif element.tag == "TOC":
# dobjects.appendTOC(process_TOC(element)) # dobjects.appendTOC(process_TOC(element))
else: else:
@ -906,7 +974,24 @@ class LrsParser(object):
raise LrsError, "PutObj reference to %s did not resolve"%refobj raise LrsError, "PutObj reference to %s did not resolve"%refobj
else: else:
po.lrsputobj.setContent(self.dobjects[refobj]) po.lrsputobj.setContent(self.dobjects[refobj])
for pl in self.plots:
refobj = pl.attrib['refobj']
if refobj not in self.dobjects:
raise LrsError, "Plot reference to %s did not resolve"%refobj
else:
pl.lrsplot.setObj(self.dobjects[refobj])
for im in self.images:
refstream = im.attrib['refstream']
if refstream not in self.dobjects:
raise LrsError, "Image reference to %s did not resolve"%refstream
else:
im.lrsimage.setRefstream(self.dobjects[refstream])
for ib in self.imageblocks:
refstream = ib.attrib['refstream']
if refstream not in self.dobjects:
raise LrsError, "ImageBlock reference to %s did not resolve"%refstream
else:
ib.lrsimageblock.setRefstream(self.dobjects[refstream])
def renderLrf(self, file): def renderLrf(self, file):
self.book.renderLrf(file) self.book.renderLrf(file)

18
src/libprs500/ebooks/lrf/objects.py
View File

@ -522,10 +522,12 @@ class Block(LRFStream):
s += 'textstyle="%d" '%(self.textstyle_id,) s += 'textstyle="%d" '%(self.textstyle_id,)
for attr in self.attrs: for attr in self.attrs:
s += '%s="%s" '%(attr, self.attrs[attr]) s += '%s="%s" '%(attr, self.attrs[attr])
s = s.rstrip()+'>\n' if self.name != 'ImageBlock':
s += unicode(self.content) s = s.rstrip()+'>\n'
s += '</%s>\n'%(self.name,) s += unicode(self.content)
return s s += '</%s>\n'%(self.name,)
return s
return s.rstrip() + ' />\n'
class MiniPage(LRFStream): class MiniPage(LRFStream):
@ -794,12 +796,12 @@ class Image(LRFObject):
class PutObj(EmptyPageElement): class PutObj(EmptyPageElement):
def __init__(self, objects, x, y, refobj): def __init__(self, objects, x1, y1, refobj):
self.x, self.y, self.refobj = x, y, refobj self.x1, self.y1, self.refobj = x1, y1, refobj
self.object = objects[refobj] self.object = objects[refobj]
def __unicode__(self): def __unicode__(self):
return u'<PutObj x="%d" y="%d" refobj="%d" />'%(self.x, self.y, self.refobj) return u'<PutObj x1="%d" y1="%d" refobj="%d" />'%(self.x1, self.y1, self.refobj)
class Canvas(LRFStream): class Canvas(LRFStream):
tag_map = { tag_map = {
@ -992,7 +994,7 @@ class Font(LRFStream):
self.file = self.fontfacename + '.ttf' self.file = self.fontfacename + '.ttf'
def __unicode__(self): def __unicode__(self):
s = '<RegistFont objid="%s" fontfilename="%s" fontfacename="%s" encoding="TTF" file="%s" />\n'%\ s = '<RegistFont objid="%s" fontfilename="%s" fontname="%s" encoding="TTF" file="%s" />\n'%\
(self.id, self.fontfilename, self.fontfacename, self.file) (self.id, self.fontfilename, self.fontfacename, self.file)
return s return s

13
src/libprs500/ebooks/lrf/parser.py
View File

@ -36,7 +36,6 @@ class LRFDocument(LRFMetaFile):
def parse(self): def parse(self):
self._parse_objects() self._parse_objects()
self.toc = None
self.metadata = LRFDocument.temp() self.metadata = LRFDocument.temp()
for a in ('title', 'title_reading', 'author', 'author_reading', 'book_id', for a in ('title', 'title_reading', 'author', 'author_reading', 'book_id',
'classification', 'free_text', 'publisher', 'label', 'category'): 'classification', 'free_text', 'publisher', 'label', 'category'):
@ -65,7 +64,7 @@ class LRFDocument(LRFMetaFile):
break break
if hasattr(obj, 'initialize'): if hasattr(obj, 'initialize'):
obj.initialize() obj.initialize()
def _parse_object(self, objid, objoff, objsize): def _parse_object(self, objid, objoff, objsize):
obj = get_object(self, self._file, objid, objoff, objsize, self.scramble_key) obj = get_object(self, self._file, objid, objoff, objsize, self.scramble_key)
self.objects[objid] = obj self.objects[objid] = obj
@ -105,7 +104,7 @@ class LRFDocument(LRFMetaFile):
bookinfo += u'<Language reading="">%s</Language>\n'%(self.doc_info.language,) bookinfo += u'<Language reading="">%s</Language>\n'%(self.doc_info.language,)
bookinfo += u'<Creator reading="">%s</Creator>\n'%(self.doc_info.creator,) bookinfo += u'<Creator reading="">%s</Creator>\n'%(self.doc_info.creator,)
bookinfo += u'<Producer reading="">%s</Producer>\n'%(self.doc_info.producer,) bookinfo += u'<Producer reading="">%s</Producer>\n'%(self.doc_info.producer,)
bookinfo += u'<SumPage>%s</SumPage>\n</DocInfo>\n</Info>\n</BookInformation>\n'%(self.doc_info.page,) bookinfo += u'<SumPage>%s</SumPage>\n</DocInfo>\n</Info>\n%s</BookInformation>\n'%(self.doc_info.page,self.toc)
pages = u'' pages = u''
done_main = False done_main = False
pt_id = -1 pt_id = -1
@ -127,8 +126,10 @@ class LRFDocument(LRFMetaFile):
styles = u'\n<Style>\n' styles = u'\n<Style>\n'
for obj in self.objects: for obj in self.objects:
obj = self.objects[obj] obj = self.objects[obj]
if obj.id in traversed_objects or isinstance(obj, (Font, Text)): if obj.id in traversed_objects:
continue continue
if isinstance(obj, (Font, Text, TOCObject)):
continue
if isinstance(obj, StyleObject): if isinstance(obj, StyleObject):
styles += unicode(obj) styles += unicode(obj)
else: else:
@ -169,4 +170,4 @@ def main(args=sys.argv, logger=None):
return 0 return 0
if __name__ == '__main__': if __name__ == '__main__':
sys.exit(main()) sys.exit(main())

7
src/libprs500/ebooks/lrf/pylrs/pylrf.py
View File

@ -513,9 +513,12 @@ class LrfObject(object):
# #
composites = {} composites = {}
for name, value in tagDict.items(): for name, value in tagDict.items():
if name == 'rubyAlignAndAdjust':
continue
if name not in ["bgimagemode", "bgimageid", if name not in ["bgimagemode", "bgimageid",
"rubyalign", "rubyadjust", "rubyalign", "rubyadjust",
"empdotscode", "empdotsfontname", "refempdotsfont"]: "empdotscode", "empdotsfontname",
"refempdotsfont"]:
self.append(LrfTag(name, value)) self.append(LrfTag(name, value))
else: else:
composites[name] = value composites[name] = value

100
src/libprs500/ebooks/lrf/pylrs/pylrs.py
View File

@ -1131,7 +1131,7 @@ class StyleDefault(LrsAttributes):
empdotscode="0x002e", emplineposition="after", empdotscode="0x002e", emplineposition="after",
emplinetype = "solid", setwaitprop="noreplay") emplinetype = "solid", setwaitprop="noreplay")
alsoAllow = ["refempdotsfont"] alsoAllow = ["refempdotsfont", "rubyAlignAndAdjust"]
def __init__(self, **settings): def __init__(self, **settings):
LrsAttributes.__init__(self, self.defaults, LrsAttributes.__init__(self, self.defaults,
@ -1665,19 +1665,19 @@ class LrsSimpleChar1(object):
class DropCaps(LrsTextTag): class DropCaps(LrsTextTag):
def __init__(self, lines=1): def __init__(self, line=1):
LrsTextTag.__init__(self, None, [LrsSimpleChar1]) LrsTextTag.__init__(self, None, [LrsSimpleChar1])
if int(lines) <= 0: if int(line) <= 0:
raise LrsError('A DrawChar must span at least one line.') raise LrsError('A DrawChar must span at least one line.')
self.lines = int(lines) self.line = int(line)
def toElement(self, se): def toElement(self, se):
elem = Element('DrawChar', line=str(self.lines)) elem = Element('DrawChar', line=str(self.line))
appendTextElements(elem, self.contents, se) appendTextElements(elem, self.contents, se)
return elem return elem
def toLrfContainer(self, lrfWriter, parent): def toLrfContainer(self, lrfWriter, parent):
parent.appendLrfTag(LrfTag('DrawChar', (int(self.lines),))) parent.appendLrfTag(LrfTag('DrawChar', (int(self.line),)))
for content in self.contents: for content in self.contents:
content.toLrfContainer(lrfWriter, parent) content.toLrfContainer(lrfWriter, parent)
@ -1697,7 +1697,7 @@ class Button(LrsObject, LrsContainer):
for sub2 in sub1.contents: for sub2 in sub1.contents:
if isinstance(sub2, JumpTo): if isinstance(sub2, JumpTo):
return (sub2.textBlock.objId, sub2.textBlock.parent.objId) return (sub2.textBlock.objId, sub2.textBlock.parent.objId)
raise LrsException, "%s has no PushButton or JumpTo subs"%self.__class__.__name__ raise LrsError, "%s has no PushButton or JumpTo subs"%self.__class__.__name__
def toLrf(self, lrfWriter): def toLrf(self, lrfWriter):
(refobj, refpage) = self.findJumpToRefs() (refobj, refpage) = self.findJumpToRefs()
@ -1757,9 +1757,8 @@ class Plot(LrsSimpleChar1, LrsContainer):
def __init__(self, obj, xsize=0, ysize=0, adjustment=None): def __init__(self, obj, xsize=0, ysize=0, adjustment=None):
LrsContainer.__init__(self, []) LrsContainer.__init__(self, [])
if not isinstance(obj, (Image, Button)): if obj != None:
raise LrsError('Plot elements can only refer to Image or Button elements') self.setObj(obj)
self.obj = obj
if xsize < 0 or ysize < 0: if xsize < 0 or ysize < 0:
raise LrsError('Sizes must be positive semi-definite') raise LrsError('Sizes must be positive semi-definite')
self.xsize = int(xsize) self.xsize = int(xsize)
@ -1768,6 +1767,11 @@ class Plot(LrsSimpleChar1, LrsContainer):
raise LrsError('adjustment must be one of' + Plot.ADJUSTMENT_VALUES.keys()) raise LrsError('adjustment must be one of' + Plot.ADJUSTMENT_VALUES.keys())
self.adjustment = adjustment self.adjustment = adjustment
def setObj(self, obj):
if not isinstance(obj, (Image, Button)):
raise LrsError('Plot elements can only refer to Image or Button elements')
self.obj = obj
def getReferencedObjIds(self): def getReferencedObjIds(self):
return [self.obj.objId] return [self.obj.objId]
@ -1942,18 +1946,20 @@ class Span(LrsSimpleChar1, LrsContainer):
return element return element
class EmpLine(LrsTextTag, LrsSimpleChar1): class EmpLine(LrsTextTag, LrsSimpleChar1):
linetypes = ['none', 'solid', 'dotted', 'dashed', 'double'] emplinetypes = ['none', 'solid', 'dotted', 'dashed', 'double']
linepositions = ['before', 'after'] emplinepositions = ['before', 'after']
def __init__(self, text=None, lineposition='before', linetype='solid'): def __init__(self, text=None, emplineposition='before', emplinetype='solid'):
LrsTextTag.__init__(self, text, [LrsSimpleChar1]) LrsTextTag.__init__(self, text, [LrsSimpleChar1])
if lineposition not in self.__class__.linepositions: if emplineposition not in self.__class__.emplinepositions:
raise LrsError('lineposition for an EmpLine must be one of: '+str(self.__class__.linepositions)) raise LrsError('emplineposition for an EmpLine must be one of: '+str(self.__class__.emplinepositions))
if linetype not in self.__class__.linetypes: if emplinetype not in self.__class__.emplinetypes:
raise LrsError('linetype for an EmpLine must be one of: '+str(self.__class__.linetypes)) raise LrsError('emplinetype for an EmpLine must be one of: '+str(self.__class__.emplinetypes))
self.emplinetype=linetype self.emplinetype = emplinetype
self.emplineposition=lineposition self.emplineposition = emplineposition
def toLrfContainer(self, lrfWriter, parent): def toLrfContainer(self, lrfWriter, parent):
parent.appendLrfTag(LrfTag(self.__class__.__name__, (self.emplineposition, self.emplinetype))) parent.appendLrfTag(LrfTag(self.__class__.__name__, (self.emplineposition, self.emplinetype)))
@ -2269,8 +2275,8 @@ class Canvas(LrsObject, LrsContainer, LrsAttributes):
self.settings['canvasheight'] = int(height) self.settings['canvasheight'] = int(height)
self.settings['canvaswidth'] = int(width) self.settings['canvaswidth'] = int(width)
def put_object(self, obj, x, y): def put_object(self, obj, x1, y1):
self.append(PutObj(obj, x1=x, y1=y)) self.append(PutObj(obj, x1, y1))
def toElement(self, source_encoding): def toElement(self, source_encoding):
el = self.lrsObjectElement("Canvas", **self.settings) el = self.lrsObjectElement("Canvas", **self.settings)
@ -2336,15 +2342,15 @@ class ImageStream(LrsObject, LrsContainer):
VALID_ENCODINGS = [ "JPEG", "GIF", "BMP", "PNG" ] VALID_ENCODINGS = [ "JPEG", "GIF", "BMP", "PNG" ]
def __init__(self, filename, encoding=None, comment=None): def __init__(self, file=None, encoding=None, comment=None):
LrsObject.__init__(self) LrsObject.__init__(self)
LrsContainer.__init__(self, []) LrsContainer.__init__(self, [])
_checkExists(filename) _checkExists(file)
self.filename = filename self.filename = file
self.comment = comment self.comment = comment
# TODO: move encoding from extension to lrf module # TODO: move encoding from extension to lrf module
if encoding is None: if encoding is None:
extension = os.path.splitext(filename)[1] extension = os.path.splitext(file)[1]
if not extension: if not extension:
raise LrsError, \ raise LrsError, \
"file must have extension if encoding is not specified" "file must have extension if encoding is not specified"
@ -2397,6 +2403,9 @@ class Image(LrsObject, LrsContainer, LrsAttributes):
LrsAttributes.__init__(self, self.defaults, settings) LrsAttributes.__init__(self, self.defaults, settings)
self.x0, self.y0, self.x1, self.y1 = int(x0), int(y0), int(x1), int(y1) self.x0, self.y0, self.x1, self.y1 = int(x0), int(y0), int(x1), int(y1)
self.xsize, self.ysize = int(xsize), int(ysize) self.xsize, self.ysize = int(xsize), int(ysize)
self.setRefstream(refstream)
def setRefstream(self, refstream):
self.refstream = refstream self.refstream = refstream
def appendReferencedObjects(self, parent): def appendReferencedObjects(self, parent):
@ -2436,14 +2445,16 @@ class ImageBlock(LrsObject, LrsContainer, LrsAttributes):
blockStyle=BlockStyle(blockrule='block-fixed'), blockStyle=BlockStyle(blockrule='block-fixed'),
alttext=None, **settings): alttext=None, **settings):
LrsObject.__init__(self) LrsObject.__init__(self)
LrsContainer.__init__(self, []) LrsContainer.__init__(self, [Text, Image])
LrsAttributes.__init__(self, self.defaults, **settings) LrsAttributes.__init__(self, self.defaults, **settings)
self.x0, self.y0, self.x1, self.y1 = int(x0), int(y0), int(x1), int(y1) self.x0, self.y0, self.x1, self.y1 = int(x0), int(y0), int(x1), int(y1)
self.xsize, self.ysize = int(xsize), int(ysize) self.xsize, self.ysize = int(xsize), int(ysize)
self.refstream = refstream self.setRefstream(refstream)
self.blockStyle = blockStyle self.blockStyle = blockStyle
self.alttext = alttext self.alttext = alttext
def setRefstream(self, refstream):
self.refstream = refstream
def appendReferencedObjects(self, parent): def appendReferencedObjects(self, parent):
if self.refstream.parent is None: if self.refstream.parent is None:
@ -2507,28 +2518,39 @@ class ImageBlock(LrsObject, LrsContainer, LrsAttributes):
class Font(LrsContainer): class Font(LrsContainer):
""" Allows a TrueType file to be embedded in an Lrf. """ """ Allows a TrueType file to be embedded in an Lrf. """
def __init__(self, filename, facename): def __init__(self, file=None, fontname=None, fontfilename=None, encoding=None):
LrsContainer.__init__(self, []) LrsContainer.__init__(self, [])
_checkExists(filename) try:
self.filename = filename _checkExists(fontfilename)
self.facename = facename self.truefile = fontfilename
except:
try:
_checkExists(file)
self.truefile = file
except:
raise LrsError, "neither '%s' nor '%s' exists"%(fontfilename, file)
self.file = file
self.fontname = fontname
self.fontfilename = fontfilename
self.encoding = encoding
def toLrf(self, lrfWriter): def toLrf(self, lrfWriter):
font = LrfObject("Font", LrsObject.getNextObjId()) font = LrfObject("Font", LrsObject.getNextObjId())
lrfWriter.registerFontId(font.objId) lrfWriter.registerFontId(font.objId)
font.appendLrfTag(LrfTag("FontFilename", font.appendLrfTag(LrfTag("FontFilename",
lrfWriter.toUnicode(self.filename))) lrfWriter.toUnicode(self.truefile)))
font.appendLrfTag(LrfTag("FontFacename", font.appendLrfTag(LrfTag("FontFacename",
lrfWriter.toUnicode(self.facename))) lrfWriter.toUnicode(self.fontname)))
stream = LrfFileStream(STREAM_FORCE_COMPRESSED, self.filename) stream = LrfFileStream(STREAM_FORCE_COMPRESSED, self.truefile)
font.appendLrfTags(stream.getStreamTags()) font.appendLrfTags(stream.getStreamTags())
lrfWriter.append(font) lrfWriter.append(font)
def toElement(self, se): def toElement(self, se):
element = Element("RegistFont", encoding="TTF", fontname=self.facename, element = Element("RegistFont", encoding="TTF", fontname=self.fontname,
file=self.filename, fontfilename=self.filename) file=self.file, fontfilename=self.file)
return element return element

2
src/libprs500/gui2/lrf_renderer/document.py
View File

@ -208,7 +208,7 @@ class Canvas(_Canvas, ContentObject):
obj = po.object obj = po.object
item = object_factory(self, obj, respect_max_y=True) item = object_factory(self, obj, respect_max_y=True)
if item: if item:
self.items.append((item, po.x, po.y)) self.items.append((item, po.x1, po.y1))
def put_objects(self): def put_objects(self):
for block, x, y in self.items: for block, x, y in self.items: