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