manga/reader.py

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