manga/reader.py

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