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                 self._exc = e
  28                 for cb in self._notlist:
  29                     cb()
  30                 self._notlist = []
  31         else:
  32             with gtk.gdk.lock:
  33                 self._val = [val]
  34                 for cb in self._notlist:
  35                     cb()
  36                 self._notlist = []
  37
  38     # Caller must hold GDK lock
  39     def notify(self, cb):
  40         self.start()
  41         if not self.done:
  42             self._notlist.append(cb)
  43         else:
  44             cb()
  45
  46     def progcb(self):
  47         with gtk.gdk.lock:
  48             nls = []
  49             for cb in self._notlist:
  50                 if cb():
  51                     nls.append(cb)
  52             self._notlist = nls
  53
  54     @property
  55     def val(self):
  56         self.start()
  57         if self._exc is not None:
  58             raise self._exc
  59         if self._val is None:
  60             raise notdone()
  61         return self._val[0]
  62
  63     @property
  64     def done(self):
  65         self.start()
  66         return self._exc != None or self._val != None
  67
  68     def wait(self):
  69         self.start()
  70         while self.is_alive():
  71             self.join()
  72         return self.val
  73
  74 class imgload(future):
  75     def __init__(self, page):
  76         super(imgload, self).__init__()
  77         self.page = page
  78         self.st = None
  79         self.start()
  80
  81     def value(self):
  82         buf = bytearray()
  83         with self.page.open() as st:
  84             self.p = 0
  85             self.st = st
  86             while True:
  87                 read = st.read(1024)
  88                 if read == "":
  89                     break
  90                 self.p += len(read)
  91                 buf.extend(read)
  92                 self.progcb()
  93         self.st = None
  94         return gtk.gdk.pixbuf_new_from_stream(gio.memory_input_stream_new_from_data(str(buf)))
  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[-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         req.width, req.height = self.get_osize()
 189
 190     def fitzoom(self):
 191         w, h = self.get_osize()
 192         alloc = self.allocation
 193         return min(float(alloc.width) / float(w), float(alloc.height) / float(h))
 194
 195     def do_size_allocate(self, alloc):
 196         self.allocation = alloc
 197         if self.fit:
 198             self.zoom = self.fitzoom()
 199         if self.flags() & gtk.REALIZED:
 200             self.window.move_resize(*alloc)
 201
 202     def get_zoomed(self):
 203         zoom = self.zoom
 204         pz, zbuf = self.zoomed
 205         if pz != zoom:
 206             w, h = self.get_osize()
 207             zbuf = self.pixbuf.scale_simple(int(w * zoom), int(h * zoom), self.interp)
 208             self.zoomed = zoom, zbuf
 209         return zbuf
 210
 211     def get_zsize(self):
 212         zbuf = self.get_zoomed()
 213         return zbuf.get_width(), zbuf.get_height()
 214
 215     def do_expose_event(self, event):
 216         aw, ah = self.get_asize()
 217         dw, dh = aw, ah
 218         zbuf = self.get_zoomed()
 219         zw, zh = self.get_zsize()
 220         ox, oy = self.off
 221         dx, dy = 0, 0
 222         if zw < aw:
 223             dx = (aw - zw) / 2
 224             dw = zw
 225         if zh < ah:
 226             dy = (ah - zh) / 2
 227             dh = zh
 228         gc = self.style.fg_gc[gtk.STATE_NORMAL]
 229         self.window.draw_pixbuf(gc, zbuf, ox, oy, dx, dy, dw, dh)
 230
 231     def set_off(self, off):
 232         aw, ah = self.get_asize()
 233         zw, zh = self.get_zsize()
 234         ox, oy = off
 235         ox, oy = int(ox), int(oy)
 236         if ox > zw - aw: ox = zw - aw
 237         if oy > zh - ah: oy = zh - ah
 238         if ox < 0: ox = 0
 239         if oy < 0: oy = 0
 240         self.off = ox, oy
 241         self.queue_draw()
 242
 243     def set_zoom(self, zoom):
 244         if zoom is not None: zoom = float(zoom)
 245         aw, ah = self.get_asize()
 246         zw, zh = self.get_zsize()
 247         dw, dh = zw - aw, zh - ah
 248         ox, oy = self.off
 249         xa = float(ox) / float(dw) if dw > 0 else 0.5
 250         ya = float(oy) / float(dh) if dh > 0 else 0.5
 251
 252         if zoom is None:
 253             self.fit = True
 254             self.zoom = self.fitzoom()
 255         else:
 256             self.fit = False
 257             self.zoom = zoom
 258
 259         zw, zh = self.get_zsize()
 260         dw, dh = zw - aw, zh - ah
 261         ox = int(xa * dw) if dw > 0 else 0
 262         oy = int(ya * dh) if dh > 0 else 0
 263         self.set_off((ox, oy))
 264 gobject.type_register(pageview)
 265
 266 class pagefetch(object):
 267     def __init__(self, fpage, setcb=None):
 268         self.pg = fpage
 269         self.setcb = setcb
 270
 271     def attach(self, reader):
 272         self.rd = reader
 273         self.msg = gtk.Alignment(0, 0.5, 0, 0)
 274         self.hlay = gtk.HBox()
 275         self.lbl = gtk.Label("Fetching page...")
 276         self.hlay.pack_start(self.lbl)
 277         self.lbl.show()
 278         self.msg.add(self.hlay)
 279         self.hlay.show()
 280         self.rd.sbar.pack_start(self.msg)
 281         self.msg.show()
 282
 283         self.pg.notify(self.haspage)
 284
 285     def haspage(self):
 286         if self.rd.pagefetch.cur != self: return False
 287         if not self.pg.done:
 288             return True
 289         if self.pg.val is not None:
 290             self.rd.setpage(self.pg.val)
 291             if self.setcb is not None:
 292                 self.setcb(self.pg.val)
 293         self.rd.pagefetch.set(None)
 294
 295     def abort(self):
 296         self.rd.sbar.remove(self.msg)
 297
 298 class imgfetch(object):
 299     def __init__(self, fimage):
 300         self.img = fimage
 301         self.upd = False
 302         self.error = None
 303
 304     def attach(self, reader):
 305         self.rd = reader
 306         self.msg = gtk.Alignment(0, 0.5, 0, 0)
 307         self.hlay = gtk.HBox()
 308         self.lbl = gtk.Label("Fetching image...")
 309         self.hlay.pack_start(self.lbl)
 310         self.lbl.show()
 311         self.prog = gtk.ProgressBar()
 312         self.prog.set_fraction(0.0)
 313         self.hlay.pack_start(self.prog, padding=5)
 314         self.prog.show()
 315         self.msg.add(self.hlay)
 316         self.hlay.show()
 317         self.rd.sbar.pack_start(self.msg)
 318         self.msg.show()
 319
 320         self.img.notify(self.imgprog)
 321
 322     def imgprog(self):
 323         if self.rd.imgfetch.cur != self: return False
 324         if self.img.done:
 325             try:
 326                 img = self.img.val
 327             except Exception as e:
 328                 self.error = str(e)
 329             else:
 330                 self.rd.setimg(img)
 331                 self.upd = True
 332             self.rd.imgfetch.set(None)
 333         else:
 334             p = self.img.prog
 335             if p: self.prog.set_fraction(p)
 336             return True
 337
 338     def abort(self):
 339         self.rd.sbar.remove(self.msg)
 340         if not self.upd:
 341             self.rd.setimg(None)
 342             if self.error is not None:
 343                 self.rd.pagelbl.set_text("Error fetching image: " + self.error)
 344
 345 class preload(object):
 346     def __init__(self, fpage):
 347         self.pg = fpage
 348
 349     def attach(self, reader):
 350         self.rd = reader
 351         self.msg = gtk.Alignment(0, 0.5, 0, 0)
 352         self.hlay = gtk.HBox()
 353         self.lbl = gtk.Label("Fetching next page...")
 354         self.hlay.pack_start(self.lbl)
 355         self.lbl.show()
 356         self.msg.add(self.hlay)
 357         self.hlay.show()
 358         self.rd.sbar.pack_start(self.msg)
 359         self.msg.show()
 360
 361         self.pg.notify(self.haspage)
 362
 363     def haspage(self):
 364         if self.rd.preload.cur != self: return False
 365         if not self.pg.done: return True
 366         if self.pg.val is not None:
 367             self.img = self.rd.cache[self.pg.val]
 368             self.prog = gtk.ProgressBar()
 369             self.prog.set_fraction(0.0)
 370             self.hlay.pack_start(self.prog, padding=5)
 371             self.prog.show()
 372             self.lbl.set_text("Loading next page...")
 373             self.img.notify(self.imgprog)
 374         else:
 375             self.rd.preload.set(None)
 376
 377     def imgprog(self):
 378         if self.rd.preload.cur != self: return False
 379         if self.img.done:
 380             self.rd.preload.set(None)
 381         else:
 382             p = self.img.prog
 383             if p: self.prog.set_fraction(p)
 384             return True
 385
 386     def abort(self):
 387         self.rd.sbar.remove(self.msg)
 388
 389 class procslot(object):
 390     __slots__ = ["cur", "p"]
 391     def __init__(self, p):
 392         self.cur = None
 393         self.p = p
 394
 395     def set(self, proc):
 396         if self.cur is not None:
 397             self.cur.abort()
 398             self.cur = None
 399         if proc is not None:
 400             self.cur = proc
 401             try:
 402                 proc.attach(self.p)
 403             except:
 404                 self.cur = None
 405                 raise
 406
 407 class reader(gtk.Window):
 408     def __init__(self, manga):
 409         super(reader, self).__init__(gtk.WINDOW_TOPLEVEL)
 410         self.connect("delete_event",    lambda wdg, ev, data=None: False)
 411         self.connect("destroy",         lambda wdg, data=None:     self.quit())
 412         self.connect("key_press_event", self.key)
 413         self.cache = pagecache()
 414         self.pagefetch = procslot(self)
 415         self.imgfetch = procslot(self)
 416         self.preload = procslot(self)
 417
 418         vlay = gtk.VBox()
 419         self.pfr = gtk.Frame(None)
 420         self.pfr.set_shadow_type(gtk.SHADOW_NONE)
 421         vlay.pack_start(self.pfr)
 422         self.pfr.show()
 423         self.sbar = gtk.HBox()
 424         self.pagelbl = gtk.Label("")
 425         algn = gtk.Alignment(0, 0.5, 0, 0)
 426         algn.add(self.pagelbl)
 427         self.pagelbl.show()
 428         self.sbar.pack_start(algn)
 429         algn.show()
 430         vlay.pack_end(self.sbar, False)
 431         self.sbar.show()
 432         self.add(vlay)
 433         vlay.show()
 434
 435         self.manga = manga
 436         self.page = None
 437         self.fetchpage(pageget(self.manga))
 438         self.updtitle()
 439         self.point = None
 440
 441     def updpagelbl(self):
 442         if self.page is None:
 443             self.pagelbl.set_text("")
 444         else:
 445             w, h = self.page.get_osize()
 446             self.pagelbl.set_text(u"%s\u00d7%s (%d%%)" % (w, h, int(self.page.zoom * 100)))
 447
 448     def setimg(self, img):
 449         if self.page is not None:
 450             self.pfr.remove(self.page)
 451             self.page = None
 452         if img is not None:
 453             self.page = pageview(img)
 454             self.pfr.add(self.page)
 455             self.page.show()
 456         self.updpagelbl()
 457
 458     def setpage(self, page):
 459         if self.point is not None:
 460             self.point = None
 461         if page is not None:
 462             self.point = ccursor(page, self.cache)
 463             self.imgfetch.set(imgfetch(self.cache[page]))
 464         else:
 465             self.setimg(None)
 466
 467     def fetchpage(self, fpage, setcb=None):
 468         self.imgfetch.set(None)
 469         proc = pagefetch(fpage, setcb)
 470         self.pagefetch.set(proc)
 471         return proc
 472
 473     def updtitle(self):
 474         self.set_title(u"Automanga \u2013 " + self.manga.name)
 475
 476     @property
 477     def zoom(self):
 478         return self.page.zoom
 479     @zoom.setter
 480     def zoom(self, zoom):
 481         self.page.set_zoom(zoom)
 482         self.updpagelbl()
 483
 484     def pan(self, off):
 485         ox, oy = self.page.off
 486         px, py = off
 487         self.page.set_off((ox + px, oy + py))
 488
 489     def key(self, wdg, ev, data=None):
 490         if ev.keyval in [ord('Q'), ord('q')]:
 491             self.quit()
 492         elif ev.keyval in [65307]:
 493             if self.page is not None:
 494                 self.pagefetch.set(None)
 495             self.imgfetch.set(None)
 496         if self.page is not None:
 497             if ev.keyval in [ord('O'), ord('o')]:
 498                 self.zoom = 1.0
 499             elif ev.keyval in [ord('P'), ord('p')]:
 500                 self.zoom = None
 501             elif ev.keyval in [ord('[')]:
 502                 self.zoom = min(self.zoom * 1.25, 3)
 503             elif ev.keyval in [ord(']')]:
 504                 self.zoom /= 1.25
 505             elif ev.keyval in [ord('h')]:
 506                 self.pan((-100, 0))
 507             elif ev.keyval in [ord('j')]:
 508                 self.pan((0, 100))
 509             elif ev.keyval in [ord('k')]:
 510                 self.pan((0, -100))
 511             elif ev.keyval in [ord('l')]:
 512                 self.pan((100, 0))
 513             elif ev.keyval in [ord('H')]:
 514                 self.page.set_off((0, self.page.off[1]))
 515             elif ev.keyval in [ord('J')]:
 516                 self.page.set_off((self.page.off[0], self.page.get_asize()[1]))
 517             elif ev.keyval in [ord('K')]:
 518                 self.page.set_off((self.page.off[1], 0))
 519             elif ev.keyval in [ord('L')]:
 520                 self.page.set_off((self.page.get_asize()[0], self.page.off[1]))
 521         if self.point is not None:
 522             if ev.keyval in [ord(' ')]:
 523                 self.fetchpage(self.point.next, lambda page: self.preload.set(preload(relpageget(page, False, self.cache))))
 524             elif ev.keyval in [65288]:
 525                 self.fetchpage(self.point.prev, lambda page: self.preload.set(preload(relpageget(page, True, self.cache))))
 526
 527     def quit(self):
 528         self.hide()
 529         gtk.main_quit()
 530 gobject.type_register(reader)