← Back to branch summary

~ubuntu-branches/debian/sid/calibre/sid

« back to all changes in this revision

Viewing changes to src/calibre/gui2/lrf_renderer/document.py

  • Committer: Package Import Robot
  • Author(s): Martin Pitt
  • Date: 2014-05-14 18:17:50 UTC
  • mto: This revision was merged to the branch mainline in revision 75.
  • Revision ID: package-import@ubuntu.com-20140514181750-efj1wymey2vb4cao
Tags: upstream-1.36.0+dfsg
Import upstream version 1.36.0+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/calibre/gui2/lrf_renderer/document.py
2
2
__copyright__ = '2008, Kovid Goyal <kovid at kovidgoyal.net>'
3
3
import collections, itertools, glob
4
4
 
5
 
from PyQt4.QtCore import Qt, QByteArray, SIGNAL
 
5
from PyQt4.QtCore import Qt, QByteArray, pyqtSignal
6
6
from PyQt4.QtGui import QGraphicsRectItem, QGraphicsScene, QPen, \
7
7
                        QBrush, QColor, QFontDatabase, \
8
8
                        QGraphicsItem, QGraphicsLineItem
15
15
 
16
16
 
17
17
class Color(QColor):
 
18
 
18
19
    def __init__(self, color):
19
20
        QColor.__init__(self, color.r, color.g, color.b, 0xff-color.a)
20
21
 
21
22
class Pen(QPen):
 
23
 
22
24
    def __init__(self, color, width):
23
25
        QPen.__init__(self, QBrush(Color(color)), width,
24
26
                      (Qt.SolidLine if width > 0 else Qt.NoPen))
104
106
 
105
107
    def layout_text_block(self, block, x, y):
106
108
        textwidth = block.bs.blockwidth - block.bs.sidemargin
107
 
        if block.max_y == 0 or not block.lines: # Empty block skipping
 
109
        if block.max_y == 0 or not block.lines:  # Empty block skipping
108
110
            self.is_full = False
109
111
            return
110
112
        line = block.peek()
111
113
        y += block.bs.topskip
112
114
        block_consumed = False
113
 
        line.height = min(line.height, self.max_y-block.bs.topskip) # LRF files from TOR have Plot elements with their height set to 800
 
115
        line.height = min(line.height, self.max_y-block.bs.topskip)  # LRF files from TOR have Plot elements with their height set to 800
114
116
        while y + line.height <= self.max_y:
115
117
            block.commit()
116
118
            if isinstance(line, QGraphicsItem):
122
124
            if not block.has_content:
123
125
                try:
124
126
                    y += block.bs.footskip
125
 
                except AttributeError: # makelrf generates BlockStyles without footskip
 
127
                except AttributeError:  # makelrf generates BlockStyles without footskip
126
128
                    pass
127
129
                block_consumed = True
128
130
                break
178
180
        return matches
179
181
 
180
182
 
181
 
 
182
183
class Canvas(_Canvas, ContentObject):
183
184
 
184
185
    def __init__(self, font_loader, canvas, logger, opts, ruby_tags, link_activated, width=0, height=0):
210
211
        _Canvas.layout_block(self, block, x, y)
211
212
 
212
213
class Header(Canvas):
 
214
 
213
215
    def __init__(self, font_loader, header, page_style, logger, opts, ruby_tags, link_activated):
214
216
        Canvas.__init__(self, font_loader, header, logger, opts, ruby_tags, link_activated,
215
217
                        page_style.textwidth,  page_style.headheight)
217
219
            self.setPen(QPen(Qt.blue, 1, Qt.DashLine))
218
220
 
219
221
class Footer(Canvas):
 
222
 
220
223
    def __init__(self, font_loader, footer, page_style, logger, opts, ruby_tags, link_activated):
221
224
        Canvas.__init__(self, font_loader, footer, logger, opts, ruby_tags, link_activated,
222
225
                        page_style.textwidth, page_style.footheight)
291
294
        self.layout_block(block, 0, self.current_y)
292
295
 
293
296
 
294
 
 
295
297
class Chapter(object):
296
298
 
297
299
    num_of_pages = property(fget=lambda self: len(self.pages))
325
327
        self.pos = 0
326
328
 
327
329
    def back(self):
328
 
        if self.pos - 1 < 0: return None
 
330
        if self.pos - 1 < 0:
 
331
            return None
329
332
        self.pos -= 1
330
333
        return self[self.pos]
331
334
 
332
335
    def forward(self):
333
 
        if self.pos + 1 >= len(self): return None
 
336
        if self.pos + 1 >= len(self):
 
337
            return None
334
338
        self.pos += 1
335
339
        return self[self.pos]
336
340
 
341
345
        self.pos += 1
342
346
 
343
347
 
344
 
 
345
348
class Document(QGraphicsScene):
346
349
 
347
350
    num_of_pages = property(fget=lambda self: sum(self.chapter_layout))
 
351
    chapter_rendered = pyqtSignal(object)
 
352
    page_changed = pyqtSignal(object)
348
353
 
349
354
    def __init__(self, logger, opts):
350
355
        QGraphicsScene.__init__(self)
364
369
    def page_of(self, oid):
365
370
        for chapter in self.chapters:
366
371
            if oid in chapter.object_to_page_map:
367
 
                return  chapter.object_to_page_map[oid]
 
372
                return chapter.object_to_page_map[oid]
368
373
 
369
374
    def get_page_num(self, chapterid, objid):
370
375
        cnum = self.chapter_map[chapterid]
388
393
            jb = self.objects[objid]
389
394
            self.link_map[objid] = (jb.refpage, jb.refobj)
390
395
 
391
 
 
392
396
    def back(self):
393
397
        oid = self.history.back()
394
398
        if oid is not None:
401
405
            page = self.page_of(oid)
402
406
            self.show_page(page)
403
407
 
404
 
 
405
408
    def load_fonts(self, lrf, load_substitutions=True):
406
409
        font_map = {}
407
410
 
418
421
 
419
422
        self.font_loader = FontLoader(font_map, self.dpi)
420
423
 
421
 
 
422
424
    def render_chapter(self, chapter, lrf):
423
425
        oddscreen, evenscreen = Screen(self.font_loader, chapter, True, self.logger, self.opts, self.ruby_tags, self.link_activated), \
424
426
                                Screen(self.font_loader, chapter, False, self.logger, self.opts, self.ruby_tags, self.link_activated)
442
444
        self.chapters.append(Chapter(oddscreen, evenscreen, pages, object_to_page_map))
443
445
        self.chapter_map[chapter.id] = len(self.chapters)-1
444
446
 
445
 
 
446
447
    def render(self, lrf, load_substitutions=True):
447
448
        self.dpi = lrf.device_info.dpi/10.
448
449
        self.ruby_tags = dict(**lrf.ruby_tags)
453
454
        for pt in lrf.page_trees:
454
455
            for chapter in pt:
455
456
                num_chaps += 1
456
 
        self.emit(SIGNAL('chapter_rendered(int)'), num_chaps)
 
457
        self.chapter_rendered.emit(num_chaps)
457
458
 
458
459
        for pt in lrf.page_trees:
459
460
            for chapter in pt:
460
461
                self.render_chapter(chapter, lrf)
461
 
 
462
 
                self.emit(SIGNAL('chapter_rendered(int)'), -1)
 
462
                self.chapter_rendered.emit(-1)
463
463
        self.chapter_layout = [i.num_of_pages for i in self.chapters]
464
464
        self.objects = None
465
465
 
485
485
            self.addItem(self.current_screen)
486
486
 
487
487
        self.current_screen.set_page(page)
488
 
        self.emit(SIGNAL('page_changed(PyQt_PyObject)'), self.current_page)
489
 
 
 
488
        self.page_changed.emit(self.current_page)
490
489
 
491
490
    def next(self):
492
491
        self.next_by(1)