manga/reader.py

   1 import threading, gtk, gobject
   2 import lib, profile
   3
   4 class notdone(Exception): pass
   5
   6 class future(threading.Thread):
   7     prog = None
   8
   9     def __init__(self):
  10         super(future, self).__init__()
  11         self._val = None
  12         self._exc = None
  13         self._notlist = []
  14         self._started = False
  15         self.setDaemon(True)
  16
  17     def start(self):
  18         if not self._started:
  19             super(future, self).start()
  20             self._started = True
  21
  22     def run(self):
  23         try:
  24             val = self.value()
  25         except Exception as e:
  26             self._exc = e
  27             gobject.idle_add(self._callcbs, True)
  28         else:
  29             self._val = [val]
  30             gobject.idle_add(self._callcbs, True)
  31
  32     def _callcbs(self, final):
  33         nls = []
  34         for cb in self._notlist:
  35             if cb():
  36                 nls.append(cb)
  37         self._notlist = [] if final else nls
  38
  39     # Caller must hold GDK lock
  40     def notify(self, cb):
  41         self.start()
  42         if not self.done:
  43             self._notlist.append(cb)
  44         else:
  45             cb()
  46
  47     def progcb(self):
  48         gobject.idle_add(self._callcbs, False)
  49
  50     @property
  51     def val(self):
  52         self.start()
  53         if self._exc is not None:
  54             raise self._exc
  55         if self._val is None:
  56             raise notdone()
  57         return self._val[0]
  58
  59     @property
  60     def done(self):
  61         self.start()
  62         return self._exc != None or self._val != None
  63
  64     def wait(self):
  65         self.start()
  66         while self.is_alive():
  67             self.join()
  68         return self.val
  69
  70 class imgload(future):
  71     def __init__(self, page):
  72         super(imgload, self).__init__()
  73         self.page = page
  74         self.st = None
  75         self.start()
  76
  77     def value(self):
  78         buf = gtk.gdk.PixbufLoader()
  79         try:
  80             with self.page.open() as st:
  81                 self.p = 0
  82                 self.st = st
  83                 while True:
  84                     read = st.read(1024)
  85                     if read == "":
  86                         break
  87                     self.p += len(read)
  88                     buf.write(read)
  89                     self.progcb()
  90             self.st = None
  91         finally:
  92             buf.close()
  93         return buf.get_pixbuf()
  94
  95     @property
  96     def prog(self):
  97         if self.st is None or self.st.clen is None:
  98             return None
  99         return float(self.p) / float(self.st.clen)
 100
 101 class pagecache(object):
 102     def __init__(self, sz=50):
 103         self.sz = sz
 104         self.bk = []
 105
 106     def __getitem__(self, page):
 107         idl = page.idlist()
 108         for ol, f in self.bk:
 109             if ol == idl:
 110                 return f
 111         f = imgload(page)
 112         self.bk.append((idl, f))
 113         if len(self.bk) > self.sz:
 114             self.bk = self.bk[-self.sz:]
 115         return f
 116
 117     def __delitem__(self, page):
 118         idl = page.idlist()
 119         for i, (ol, f) in enumerate(self.bk):
 120             if ol == idl:
 121                 del self.bk[i]
 122                 return
 123         raise KeyError(idl)
 124
 125 class relpageget(future):
 126     def __init__(self, cur, prev, cache=None):
 127         super(relpageget, self).__init__()
 128         self.cur = lib.cursor(cur)
 129         self.prev = prev
 130         self.cache = cache
 131         self.start()
 132
 133     def value(self):
 134         try:
 135             if self.prev:
 136                 page = self.cur.prev()
 137             else:
 138                 page = self.cur.next()
 139         except StopIteration:
 140             page = None
 141         else:
 142             if self.cache:
 143                 self.cache[page]
 144         return page
 145
 146 class idpageget(future):
 147     def __init__(self, base, idlist):
 148         super(idpageget, self).__init__()
 149         self.bnode = base
 150         self.idlist = idlist
 151
 152     def value(self):
 153         return lib.cursor(self.bnode.byidlist(self.idlist)).cur
 154
 155 class pageget(future):
 156     def __init__(self, fnode):
 157         super(pageget, self).__init__()
 158         self.fnode = fnode
 159         self.start()
 160
 161     def value(self):
 162         return lib.cursor(self.fnode).cur
 163
 164 class ccursor(object):
 165     def __init__(self, ob, cache=None):
 166         self.cur = lib.cursor(ob)
 167         self.prev = relpageget(self.cur, True, cache)
 168         self.next = relpageget(self.cur, False, cache)
 169
 170 class pageview(gtk.Widget):
 171     def __init__(self, pixbuf):
 172         super(pageview, self).__init__()
 173         self.pixbuf = pixbuf
 174         self.zoomed = None, None
 175         self.fit = True
 176         self.zoom = 1.0
 177         self.interp = gtk.gdk.INTERP_HYPER
 178         self.off = 0, 0
 179
 180     def get_osize(self):
 181         return self.pixbuf.get_width(), self.pixbuf.get_height()
 182
 183     def get_asize(self):
 184         return self.allocation.width, self.allocation.height
 185
 186     def do_realize(self):
 187         self.set_flags(self.flags() | gtk.REALIZED)
 188         alloc = self.allocation
 189         self.window = gtk.gdk.Window(self.get_parent_window(),
 190                                      width=alloc.width, height=alloc.height,
 191                                      window_type = gtk.gdk.WINDOW_CHILD,
 192                                      wclass = gtk.gdk.INPUT_OUTPUT,
 193                                      event_mask = self.get_events() | gtk.gdk.EXPOSURE_MASK
 194                                      )
 195         self.window.set_user_data(self)
 196         self.style.attach(self.window)
 197         self.style.set_background(self.window, gtk.STATE_NORMAL)
 198         self.window.move_resize(*alloc)
 199
 200     def do_unrealize(self):
 201         self.window.set_user_data(None)
 202
 203     def do_size_request(self, req):
 204         w, h = self.get_osize()
 205         req.width, req.height = max(min(w, 4096), 0), max(min(h, 4096), 0)
 206
 207     def fitzoom(self):
 208         w, h = self.get_osize()
 209         alloc = self.allocation
 210         return min(float(alloc.width) / float(w), float(alloc.height) / float(h))
 211
 212     def do_size_allocate(self, alloc):
 213         self.allocation = alloc
 214         if self.fit:
 215             self.zoom = self.fitzoom()
 216         else:
 217             aw, ah = self.get_asize()
 218             zw, zh = self.get_zsize()
 219             ox, oy = self.off
 220             if zw >= aw and ox + aw > zw:
 221                 ox = zw - aw
 222             if zh >= ah and oy + ah > zh:
 223                 oy = zh - ah
 224             self.off = ox, oy
 225         if self.flags() & gtk.REALIZED:
 226             self.window.move_resize(*alloc)
 227
 228     def get_zoomed(self):
 229         zoom = self.zoom
 230         pz, zbuf = self.zoomed
 231         if pz != zoom:
 232             w, h = self.get_osize()
 233             zbuf = self.pixbuf.scale_simple(int(w * zoom), int(h * zoom), self.interp)
 234             self.zoomed = zoom, zbuf
 235         return zbuf
 236
 237     def get_zsize(self):
 238         zbuf = self.get_zoomed()
 239         return zbuf.get_width(), zbuf.get_height()
 240
 241     def do_expose_event(self, event):
 242         aw, ah = self.get_asize()
 243         dw, dh = aw, ah
 244         zbuf = self.get_zoomed()
 245         zw, zh = self.get_zsize()
 246         ox, oy = self.off
 247         dx, dy = 0, 0
 248         if zw < aw:
 249             dx = (aw - zw) / 2
 250             dw = zw
 251         if zh < ah:
 252             dy = (ah - zh) / 2
 253             dh = zh
 254         gc = self.style.fg_gc[gtk.STATE_NORMAL]
 255         self.window.draw_pixbuf(gc, zbuf, ox, oy, dx, dy, dw, dh)
 256
 257     def set_off(self, off):
 258         aw, ah = self.get_asize()
 259         zw, zh = self.get_zsize()
 260         ox, oy = off
 261         ox, oy = int(ox), int(oy)
 262         if ox > zw - aw: ox = zw - aw
 263         if oy > zh - ah: oy = zh - ah
 264         if ox < 0: ox = 0
 265         if oy < 0: oy = 0
 266         self.off = ox, oy
 267         self.queue_draw()
 268
 269     def set_zoom(self, zoom):
 270         if zoom is not None: zoom = float(zoom)
 271         aw, ah = self.get_asize()
 272         zw, zh = self.get_zsize()
 273         dw, dh = zw - aw, zh - ah
 274         ox, oy = self.off
 275         xa = float(ox) / float(dw) if dw > 0 else 0.5
 276         ya = float(oy) / float(dh) if dh > 0 else 0.5
 277
 278         if zoom is None:
 279             self.fit = True
 280             self.zoom = self.fitzoom()
 281         else:
 282             self.fit = False
 283             self.zoom = zoom
 284
 285         zw, zh = self.get_zsize()
 286         dw, dh = zw - aw, zh - ah
 287         ox = int(xa * dw) if dw > 0 else 0
 288         oy = int(ya * dh) if dh > 0 else 0
 289         self.set_off((ox, oy))
 290 gobject.type_register(pageview)
 291
 292 class msgproc(object):
 293     def attach(self, reader):
 294         self.rd = reader
 295         self.msg = gtk.Alignment(0, 0.5, 0, 0)
 296         self.hlay = gtk.HBox()
 297         self.lbl = gtk.Label("")
 298         self.hlay.pack_start(self.lbl)
 299         self.lbl.show()
 300         self.msg.add(self.hlay)
 301         self.hlay.show()
 302         self.rd.sbar.pack_start(self.msg)
 303         self.msg.show()
 304         self._prog = None
 305
 306     def prog(self, p):
 307         if p is not None:
 308             if self._prog is None:
 309                 self._prog = gtk.ProgressBar()
 310                 self.hlay.pack_start(self._prog, padding=5)
 311                 self._prog.show()
 312             self._prog.set_fraction(p)
 313         elif p is None and self._prog is not None:
 314             self.hlay.remove(self._prog)
 315             self._prog = None
 316
 317     def abort(self):
 318         self.rd.sbar.remove(self.msg)
 319
 320 class pagefetch(msgproc):
 321     def __init__(self, fpage, setcb=None):
 322         self.pg = fpage
 323         self.setcb = setcb
 324
 325     def attach(self, reader):
 326         super(pagefetch, self).attach(reader)
 327         self.lbl.set_text("Fetching page...")
 328         self.pg.notify(self.haspage)
 329
 330     def haspage(self):
 331         if self.rd.pagefetch.cur != self: return False
 332         if not self.pg.done:
 333             return True
 334         if self.pg.val is not None:
 335             self.rd.setpage(self.pg.val)
 336             if self.setcb is not None:
 337                 self.setcb(self.pg.val)
 338         self.rd.pagefetch.set(None)
 339
 340 class imgfetch(msgproc):
 341     def __init__(self, fimage):
 342         self.img = fimage
 343         self.upd = False
 344         self.error = None
 345
 346     def attach(self, reader):
 347         super(imgfetch, self).attach(reader)
 348         self.lbl.set_text("Fetching image...")
 349         self.img.notify(self.imgprog)
 350
 351     def imgprog(self):
 352         if self.rd.imgfetch.cur != self: return False
 353         if self.img.done:
 354             try:
 355                 img = self.img.val
 356             except Exception as e:
 357                 self.error = str(e)
 358             else:
 359                 self.rd.setimg(img)
 360                 self.upd = True
 361             self.rd.imgfetch.set(None)
 362         else:
 363             self.prog(self.img.prog)
 364             return True
 365
 366     def abort(self):
 367         self.rd.sbar.remove(self.msg)
 368         if not self.upd:
 369             self.rd.setimg(None)
 370             if self.error is not None:
 371                 self.rd.pagelbl.set_text("Error fetching image: " + self.error)
 372
 373 class preload(msgproc):
 374     def __init__(self, fpage):
 375         self.pg = fpage
 376
 377     def attach(self, reader):
 378         super(preload, self).attach(reader)
 379         self.lbl.set_text("Fetching next page...")
 380         self.pg.notify(self.haspage)
 381
 382     def haspage(self):
 383         if self.rd.preload.cur != self: return False
 384         if not self.pg.done: return True
 385         if self.pg.val is not None:
 386             self.img = self.rd.cache[self.pg.val]
 387             self.lbl.set_text("Loading next page...")
 388             self.img.notify(self.imgprog)
 389         else:
 390             self.rd.preload.set(None)
 391
 392     def imgprog(self):
 393         if self.rd.preload.cur != self: return False
 394         if self.img.done:
 395             self.rd.preload.set(None)
 396         else:
 397             self.prog(self.img.prog)
 398             return True
 399
 400     def abort(self):
 401         self.rd.sbar.remove(self.msg)
 402
 403 class procslot(object):
 404     __slots__ = ["cur", "p"]
 405     def __init__(self, p):
 406         self.cur = None
 407         self.p = p
 408
 409     def set(self, proc):
 410         if self.cur is not None:
 411             self.cur.abort()
 412             self.cur = None
 413         if proc is not None:
 414             self.cur = proc
 415             try:
 416                 proc.attach(self.p)
 417             except:
 418                 self.cur = None
 419                 raise
 420
 421 class plistget(future):
 422     def __init__(self, node):
 423         super(plistget, self).__init__()
 424         self.node = node
 425
 426     def value(self):
 427         return list(self.node)
 428
 429 class loadplist(object):
 430     def __init__(self, pnode):
 431         self.pnode = pnode
 432         self.flist = plistget(self.pnode)
 433
 434     def attach(self, sbox):
 435         self.sbox = sbox
 436         self.flist.notify(self.haslist)
 437
 438     def haslist(self):
 439         if self.sbox.loadlist.cur != self: return False
 440         if not self.flist.done: return True
 441         self.sbox.setlist(self.flist.val)
 442
 443 class sbox(gtk.ComboBox):
 444     def __init__(self, reader, ptnode):
 445         super(sbox, self).__init__()
 446         self.rd = reader
 447         self.node = ptnode
 448         self.pnode, self.pidx = self.node.stack[-1]
 449
 450         self.bk = gtk.ListStore(str)
 451         self.set_model(self.bk)
 452         cell = gtk.CellRendererText()
 453         self.pack_start(cell, True)
 454         self.add_attribute(cell, "text", 0)
 455         self.set_active(0)
 456
 457         self.set_sensitive(False)
 458         self.set_focus_on_click(False)
 459         self.bk.append([ptnode.name])
 460         self.loadlist = procslot(self)
 461         self.loadlist.set(loadplist(self.pnode))
 462
 463     def setlist(self, ls):
 464         self.bk.clear()
 465         for i, ch in enumerate(ls):
 466             self.bk.append(["%i/%i: %s" % (i + 1, len(ls), ch.name)])
 467         self.set_active(self.pidx)
 468         self.set_sensitive(True)
 469         self.connect("changed", self.changed_cb)
 470
 471     def changed_cb(self, wdg, data=None):
 472         self.rd.fetchpage(pageget(self.pnode[self.get_active()]))
 473
 474 class profprop(object):
 475     def __init__(self, key, default=None):
 476         self.key = key
 477         self.default = default
 478
 479     def __get__(self, ins, cls):
 480         return ins.profile.props.get(self.key, self.default)
 481
 482     def __set__(self, ins, val):
 483         ins.profile.props[self.key] = val
 484         ins.profile.save()
 485
 486     def __delete__(self, ins):
 487         del ins.profile.props[self.key]
 488         ins.profile.save()
 489
 490 class reader(gtk.Window):
 491     def __init__(self, manga, prof=None):
 492         super(reader, self).__init__(gtk.WINDOW_TOPLEVEL)
 493         self.connect("delete_event",    lambda wdg, ev, data=None: False)
 494         self.connect("destroy",         lambda wdg, data=None:     self.quit())
 495         self.connect("key_press_event", self.key)
 496         self.cache = pagecache()
 497         self.pagefetch = procslot(self)
 498         self.imgfetch = procslot(self)
 499         self.preload = procslot(self)
 500         self.profile = prof if prof else profile.memmanga(None, None, manga.id)
 501
 502         self.manga = manga
 503         self.page = None
 504         self.sboxes = []
 505         self.point = None
 506
 507         vlay = gtk.VBox()
 508         self.pfr = gtk.Frame(None)
 509         self.pfr.set_shadow_type(gtk.SHADOW_NONE)
 510         vlay.pack_start(self.pfr)
 511         self.pfr.show()
 512         self.sboxbar = gtk.HBox()
 513         algn = gtk.Alignment(0, 0.5, 0, 0)
 514         sboxlbl = gtk.Label(self.manga.name + u": ")
 515         algn.add(sboxlbl)
 516         sboxlbl.show()
 517         self.sboxbar.pack_start(algn, False)
 518         algn.show()
 519         vlay.pack_start(self.sboxbar, False)
 520         self.sboxbar.show()
 521         self.sbar = gtk.HBox()
 522         self.pagelbl = gtk.Label("")
 523         algn = gtk.Alignment(0, 0.5, 0, 0)
 524         algn.add(self.pagelbl)
 525         self.pagelbl.show()
 526         self.sbar.pack_start(algn)
 527         algn.show()
 528         vlay.pack_end(self.sbar, False)
 529         self.sbar.show()
 530         self.add(vlay)
 531         vlay.show()
 532
 533         if self.curpage is not None:
 534             self.fetchpage(idpageget(self.manga, self.curpage))
 535         else:
 536             self.fetchpage(pageget(self.manga))
 537         self.updtitle()
 538
 539     zmode = profprop("zmode", "fit")
 540     curpage = profprop("curpage")
 541
 542     def updpagelbl(self):
 543         if self.page is None:
 544             self.pagelbl.set_text("")
 545         else:
 546             w, h = self.page.get_osize()
 547             self.pagelbl.set_text(u"%s\u00d7%s (%d%%)" % (w, h, int(self.page.zoom * 100)))
 548
 549     def updsboxes(self, page):
 550         nodes = [node for node, idx in page.stack[1:]] + [page]
 551         l = min(len(self.sboxes), len(nodes))
 552         for i, (pbox, node) in enumerate(zip(self.sboxes, nodes)):
 553             if pbox.node != node:
 554                 l = i
 555                 break
 556         for i in xrange(l, len(self.sboxes)):
 557             self.sboxbar.remove(self.sboxes[i])
 558         self.sboxes = self.sboxes[:l]
 559         for i in xrange(l, len(nodes)):
 560             new = sbox(self, nodes[i])
 561             self.sboxbar.pack_start(new, False, padding=5)
 562             self.sboxes.append(new)
 563             new.show()
 564
 565     def setimg(self, img):
 566         if self.page is not None:
 567             self.pfr.remove(self.page)
 568             self.page = None
 569         if img is not None:
 570             self.page = pageview(img)
 571             if self.zmode == "1":
 572                 self.page.set_zoom(1)
 573                 self.page.set_off((0, 0))
 574             self.pfr.add(self.page)
 575             self.page.show()
 576         self.updpagelbl()
 577
 578     def setpage(self, page):
 579         if self.point is not None:
 580             self.point = None
 581         if page is not None:
 582             self.curpage = page.idlist()
 583             self.point = ccursor(page, self.cache)
 584             self.imgfetch.set(imgfetch(self.cache[page]))
 585         else:
 586             self.setimg(None)
 587         self.updsboxes(page)
 588
 589     def fetchpage(self, fpage, setcb=None):
 590         self.imgfetch.set(None)
 591         proc = pagefetch(fpage, setcb)
 592         self.pagefetch.set(proc)
 593         return proc
 594
 595     def updtitle(self):
 596         self.set_title(u"Automanga \u2013 " + self.manga.name)
 597
 598     @property
 599     def zoom(self):
 600         return self.page.zoom
 601     @zoom.setter
 602     def zoom(self, zoom):
 603         self.page.set_zoom(zoom)
 604         self.updpagelbl()
 605
 606     def pan(self, off):
 607         ox, oy = self.page.off
 608         px, py = off
 609         self.page.set_off((ox + px, oy + py))
 610
 611     def key(self, wdg, ev, data=None):
 612         if ev.keyval in [ord('Q'), ord('q')]:
 613             self.quit()
 614         elif ev.keyval in [65307]:
 615             if self.page is not None:
 616                 self.pagefetch.set(None)
 617             self.imgfetch.set(None)
 618         if self.page is not None:
 619             if ev.keyval in [ord('O'), ord('o')]:
 620                 self.zoom = 1.0
 621                 self.zmode = "1"
 622             elif ev.keyval in [ord('P'), ord('p')]:
 623                 self.zoom = None
 624                 self.zmode = "fit"
 625             elif ev.keyval in [ord('[')]:
 626                 self.zoom = min(self.zoom * 1.25, 3)
 627             elif ev.keyval in [ord(']')]:
 628                 self.zoom /= 1.25
 629             elif ev.keyval in [ord('h')]:
 630                 self.pan((-100, 0))
 631             elif ev.keyval in [ord('j')]:
 632                 self.pan((0, 100))
 633             elif ev.keyval in [ord('k')]:
 634                 self.pan((0, -100))
 635             elif ev.keyval in [ord('l')]:
 636                 self.pan((100, 0))
 637             elif ev.keyval in [ord('H')]:
 638                 self.page.set_off((0, self.page.off[1]))
 639             elif ev.keyval in [ord('J')]:
 640                 self.page.set_off((self.page.off[0], self.page.get_asize()[1]))
 641             elif ev.keyval in [ord('K')]:
 642                 self.page.set_off((self.page.off[1], 0))
 643             elif ev.keyval in [ord('L')]:
 644                 self.page.set_off((self.page.get_asize()[0], self.page.off[1]))
 645         if self.point is not None:
 646             if ev.keyval in [ord(' ')]:
 647                 if self.page and self.page.off[1] + self.page.get_asize()[1] < self.page.get_zsize()[1]:
 648                     self.pan((0, self.page.get_asize()[1] - 50))
 649                 else:
 650                     self.fetchpage(self.point.next, lambda page: self.preload.set(preload(relpageget(page, False, self.cache))))
 651             elif ev.keyval in [65288]:
 652                 if self.page and self.page.off[1] > 0:
 653                     self.pan((0, -(self.page.get_asize()[1] - 50)))
 654                 else:
 655                     self.fetchpage(self.point.prev, lambda page: self.preload.set(preload(relpageget(page, True, self.cache))))
 656             elif ev.keyval in [ord('R'), ord('r')]:
 657                 page = self.point.cur.cur
 658                 del self.cache[page]
 659                 self.imgfetch.set(imgfetch(self.cache[page]))
 660
 661     def quit(self):
 662         self.hide()
 663         gtk.main_quit()
 664 gobject.type_register(reader)