automanga.py

   1 #!/usr/bin/python
   2 #encoding: utf8
   3 #
   4 # automanga
   5 # by Kaka <kaka@dolda2000.com>
   6
   7 import os, sys, optparse
   8 from user import home
   9 try:
  10     import gtk
  11     import pygtk; pygtk.require("2.0")
  12 except AssertionError, e:
  13     error("You need to install the package 'python-gtk2'")
  14
  15 DIR_BASE      = os.path.join(home, ".automanga")
  16 DIR_PROFILES  = os.path.join(DIR_BASE, "profiles")
  17 FILE_SETTINGS = os.path.join(DIR_BASE, "settings")
  18
  19 def init():
  20     global settings, profile, opts, args, cwd
  21
  22     if not os.path.exists(DIR_PROFILES):
  23         os.makedirs(DIR_PROFILES)
  24     settings = Settings()
  25
  26     usage = "Usage: %prog [options]"
  27     parser = optparse.OptionParser(usage) # one delete option to use in combination with profile and directory?
  28     parser.add_option("-p", "--profile", help="load or create a profile", metavar="profile")
  29     parser.add_option("-r", "--remove-profile", help="remove profile",    metavar="profile")
  30     parser.add_option("-a", "--add",     help="add a directory",          metavar="dir")
  31     parser.add_option("-d", "--delete",  help="delete a directory",       metavar="dir")
  32     parser.add_option("-s", "--silent",  help="no output",                default=False, action="store_true")
  33     parser.add_option("-v", "--verbose", help="show output",              default=False, action="store_true")
  34     opts, args = parser.parse_args()
  35
  36     cwd = os.getcwd()
  37
  38 def load_profile(name):
  39     global profile
  40     profile = Profile(name)
  41     settings.last_profile(profile.name)
  42
  43 def output(msg):
  44     if not settings.silent():
  45         print msg
  46
  47 def error(msg):
  48     print >>sys.stderr, msg
  49     sys.exit(1)
  50
  51 def abs_path(path):
  52     """Returns the absolute path"""
  53     if not os.path.isabs(path): ret = os.path.join(cwd, path)
  54     else:                       ret = path
  55     return os.path.abspath(ret)
  56
  57 def manga_dir(path):
  58     """Checks if path is a manga directory"""
  59     for node in os.listdir(path):
  60         if node.rsplit(".", 1)[-1] in ("jpg", "png", "gif", "bmp"):
  61             return True
  62     return False
  63
  64 def natsorted(strings):
  65     """Sorts a list of strings naturally"""
  66 #    import re
  67 #    return sorted(strings, key=lambda s: [int(t) if t.isdigit() else t for t in re.split(r'(\d+)', s)])
  68     return sorted(strings, key=lambda s: [int(t) if t.isdigit() else t for t in s.rsplit(".")[0].split("-")])
  69
  70 class Reader(object):
  71     """GUI"""
  72     def __init__(self):
  73         self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
  74         self.window.connect("delete_event",    lambda widget, event, data = None: False)
  75         self.window.connect("destroy",         lambda widget, data = None: self.quit())
  76         self.window.connect("key_press_event", self.keypress)
  77 #        self.window.set_border_width(10)
  78         self.window.set_position(gtk.WIN_POS_CENTER) # save position in settings?
  79 #        self.window.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#222")) # seems to do nothing
  80
  81         self.set_title()
  82         self.fullscreen = False
  83         self.cursor     = None
  84
  85         self.container = gtk.VBox()
  86         self.menu_bar = self.build_menu()
  87         self.page_bar = gtk.HBox()
  88         self.key = gtk.Label()
  89 #        self.key.set_padding(10, 10)
  90         self.page_num = gtk.Label()
  91         self.page = gtk.Image()
  92         self.sep = gtk.HSeparator()
  93         self.sbar = gtk.Statusbar(); self.sbar.show(); self.sbar.set_has_resize_grip(False)
  94
  95         self.combo = gtk.combo_box_new_text()
  96         self.combo.set_wrap_width(2)
  97         for i in range(50):
  98             self.combo.append_text('item - %d' % i)
  99         self.combo.set_active(0)
 100
 101         self.page_bar.pack_start(self.key, expand=False)
 102         vsep = gtk.VSeparator(); vsep.show(); self.page_bar.pack_start(vsep, expand=False)
 103 #        self.page_bar.pack_start(self.combo, expand=False); self.combo.show()
 104         self.page_bar.pack_start(self.page_num, expand=False)
 105 #        self.container.pack_start(self.menu_bar, expand=False)
 106         self.container.pack_start(self.page_bar, expand=False)
 107         self.container.pack_start(self.sep, expand=False)
 108         self.container.pack_start(self.page)
 109         self.container.pack_start(self.sbar, expand=False)
 110         self.window.add(self.container)
 111
 112         self.key.show()
 113         self.page_num.show()
 114         self.sep.show()
 115         self.page.show()
 116         self.page_bar.show()
 117         self.container.show()
 118         self.window.show()
 119
 120     def build_menu(self):
 121         menus = (("_File", (
 122                     ("_New profile",    gtk.STOCK_NEW,         lambda widget, data: None),
 123                     ("_Load profile",   gtk.STOCK_OPEN,        lambda widget, data: None),
 124                     ("_Delete profile", gtk.STOCK_DELETE,      lambda widget, data: None),
 125                     (),
 126                     ("_Quit",           gtk.STOCK_QUIT,        lambda widget, data: self.quit()),
 127                     )),
 128                  ("_Edit", (
 129                     ("_Profile",        gtk.STOCK_EDIT,        lambda widget, data: None),
 130                     (),
 131                     ("_Settings",       gtk.STOCK_PREFERENCES, lambda widget, data: None),
 132                     )),
 133                  )
 134         menu_bar = gtk.MenuBar()
 135         menu_bar.show()
 136         for submenu in menus:
 137             lbl, items = submenu
 138             menu = gtk.Menu()
 139             menu.show()
 140             mi = gtk.MenuItem(lbl, True)
 141             mi.show()
 142             mi.set_submenu(menu)
 143             menu_bar.add(mi)
 144             for item in items:
 145                 if not item:
 146                     mi = gtk.SeparatorMenuItem()
 147                     mi.show()
 148                     menu.add(mi)
 149                 else:
 150                     lbl, icon, func = item
 151                     img = gtk.Image()
 152                     img.set_from_stock(icon, gtk.ICON_SIZE_MENU)
 153                     mi = gtk.ImageMenuItem(lbl, True)
 154                     mi.show()
 155                     mi.set_image(img)
 156                     mi.connect("activate", func, None)
 157                     menu.add(mi)
 158         return menu_bar
 159
 160     def start(self):
 161         gtk.main()
 162
 163     def quit(self):
 164         gtk.main_quit()
 165
 166     def set_title(self, title = None):
 167         self.window.set_title("Automanga" + (" - " + title if title else ""))
 168
 169     def set_manga(self, manga):
 170         self.manga = manga
 171         self.set_title(manga.title())
 172         self.cursor = manga.mark
 173         self.update_page()
 174
 175     def update_page(self):
 176         self.page.set_from_file(self.cursor.path)
 177         self.page_num.set_label("Mark's at %s (%s/%s)\t\tYou're at %s (%s/%s)" % (self.manga.mark.name, self.manga.index_of(self.manga.mark) + 1, self.manga.num_pages(), self.cursor.name, self.manga.index_of(self.cursor) + 1, self.manga.num_pages()))
 178         self.window.resize(*self.container.size_request())
 179
 180         self.sbar.pop(self.sbar.get_context_id("stat"))
 181         self.sbar.push(self.sbar.get_context_id("stat"), "Mark's at %s (%s/%s)\t\tYou're at %s (%s/%s)" % (self.manga.mark.name, self.manga.index_of(self.manga.mark) + 1, self.manga.num_pages(), self.cursor.name, self.manga.index_of(self.cursor) + 1, self.manga.num_pages()))
 182
 183     def keypress(self, widget, event, data = None):
 184         if   event.keyval in [32]:             self.read_page(1)        # space
 185         elif event.keyval in [65288]:          self.read_page(-1)       # backspace
 186         elif event.keyval in [65362, 65363]:   self.browse_page(1)      # up, right
 187         elif event.keyval in [65361, 65364]:   self.browse_page(-1)     # left, down
 188         elif event.keyval in [70, 102]:        self.toggle_fullscreen() # f, F
 189         elif event.keyval in [81, 113, 65307]: self.quit()              # q, Q, esc
 190         elif event.keyval in [65360]:          self.browse_start()      # home
 191         elif event.keyval in [65367]:          self.browse_end()        # end
 192         else: self.key.set_text(str(event.keyval))
 193
 194     def browse_page(self, step):
 195         self.cursor = self.cursor.previous() if step < 0 else self.cursor.next()
 196         self.update_page()
 197
 198     def read_page(self, step):
 199         if self.cursor == self.manga.mark:
 200             if step < 0: self.manga.set_mark(self.cursor.previous())
 201             else:        self.cursor = self.cursor.next()
 202         if step < 0: self.cursor = self.manga.mark
 203         else:        self.manga.set_mark(self.cursor)
 204         self.update_page()
 205
 206     def browse_start(self):
 207         self.cursor = self.manga.first_page()
 208         self.update_page()
 209
 210     def browse_end(self):
 211         self.cursor = self.manga.last_page()
 212         self.update_page()
 213
 214     def toggle_fullscreen(self):
 215         self.fullscreen = not self.fullscreen
 216 #         if self.fullscreen: self.window.fullscreen()
 217 #         else:               self.window.unfullscreen()
 218         if self.fullscreen:
 219             self.window.set_decorated(False)
 220             self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
 221             self.menu_bar.hide()
 222         else:
 223             self.window.set_decorated(True)
 224             self.window.set_position(gtk.WIN_POS_NONE)
 225             self.menu_bar.show()
 226
 227 class File(object):
 228     """A class for accessing the parsed content of a file as
 229     attributes on an object."""
 230
 231     def __init__(self, path, create = False): ## add autosync - save everytime an attribute is set - does not work well with list attributes
 232         self.path = path
 233         self.attributes = []    ## make this a dict which stores the attributes, instead of adding them as attributes to the File object
 234         if os.path.exists(path):
 235             file = open(path)
 236             self.parse(file)
 237             file.close()
 238         elif create:
 239             self.save()
 240
 241     def __setattr__(self, name, val):
 242         if name not in ("path", "attributes") and name not in self.attributes:
 243             self.attributes.append(name)
 244         object.__setattr__(self, name, val)
 245
 246     def __getattr__(self, name):
 247         try:    return object.__getattribute__(self, name)
 248         except: return None
 249
 250     def __delattr__(self, name):
 251         self.attributes.remove(name)
 252         object.__delattr__(self, name)
 253
 254     def parse(self, file):
 255         def add_attr(type, name, val):
 256             if type and name and val:
 257                 if   type == "str":  val = val[0]
 258                 elif type == "int":  val = int(val[0])
 259                 elif type == "bool": val = (val[0].lower() == "true")
 260                 setattr(self, name, val)
 261         type, attr, val = None, "", []
 262         for line in file.xreadlines():
 263             line = line.strip()
 264             if line.startswith("["):
 265                 add_attr(type, attr, val)
 266                 (type, attr), val = line[1:-1].split(":"), []
 267             elif line:
 268                 val.append(line)
 269         add_attr(type, attr, val)
 270
 271     def exists(self):
 272         return os.path.exists(self.path)
 273
 274     def delete(self):
 275         self.attributes = []
 276         os.remove(self.path)
 277
 278     def save(self):
 279         dir = self.path.rsplit("/", 1)[0]
 280         if not os.path.exists(dir):
 281             os.makedirs(dir)
 282         file = open(self.path, "w")
 283         for attr in self.attributes:
 284             val = getattr(self, attr)
 285             file.write("[%s:%s]\n" % (str(type(val))[7:-2], attr))
 286             if type(val) in (list, tuple):
 287                 for i in val:
 288                     file.write(i + "\n")
 289             else:
 290                 file.write(str(val) + "\n")
 291             file.write("\n")
 292         file.close()
 293
 294     def save_all(self):
 295         self.save()
 296
 297 class Directory(object):
 298     """A class for accessing files, or directories, in a directory as
 299     attributes on an object."""
 300
 301     def __init__(self, path):
 302         self._path = path
 303         self._nodes = [f for f in os.listdir(path) if "." not in f] if os.path.exists(path) else []
 304         self._opened_nodes = {}
 305
 306     def __iter__(self):
 307         return self._opened_nodes.itervalues()
 308
 309     def __contains__(self, name):
 310         return name in self._nodes
 311
 312     def __getitem__(self, name):
 313         if name in self._nodes:
 314             return getattr(self, name)
 315         raise KeyError(name)
 316
 317     def __getattr__(self, name):
 318         if name in self._nodes:
 319             if name not in self._opened_nodes:
 320                 if os.path.isdir(self.path(name)): self._opened_nodes[name] = Directory(self.path(name))
 321                 else:                              self._opened_nodes[name] = File(self.path(name))
 322             return self._opened_nodes[name]
 323         return object.__getattribute__(self, name)
 324
 325     def __delattr__(self, name):
 326         if name in self._nodes:
 327             self._nodes.remove(name)
 328             if name in self._opened_nodes:
 329                 self._opened_nodes.pop(name).delete()
 330         else:
 331             object.__delattr__(self, name)
 332
 333     def delete(self):
 334         for n in self._nodes:
 335             getattr(self, n).delete()
 336         self._opened_nodes = {}
 337         self._nodes = []
 338         os.rmdir(self.path())
 339
 340     def save(self):
 341         if not self.exists():
 342             os.makedirs(self.path())
 343
 344     def save_all(self):
 345         self.save()
 346         for name, node in self._opened_nodes.items():
 347             node.save_all()
 348
 349     def exists(self):
 350         return os.path.exists(self.path())
 351
 352     def move(self, new_path):
 353         if not self.exists() or os.path.exists(new_path):
 354             return False
 355         os.rename(self.path(), new_path)
 356         self._path = new_path
 357         return True
 358
 359     def path(self, *name):
 360         return os.path.join(self._path, *name)
 361
 362     def add_dir(self, name):
 363         if not os.path.exists(self.path(name)):
 364             self._nodes.append(name)
 365             self._opened_nodes[name] = Directory(self.path(name))
 366         return getattr(self, name)
 367
 368     def add_file(self, name):
 369         if not os.path.exists(self.path(name)):
 370             self._nodes.append(name)
 371             self._opened_nodes[name] = File(self.path(name))
 372         return getattr(self, name)
 373
 374 class Settings(object):
 375     def __init__(self):
 376         self.file = File(FILE_SETTINGS, True)
 377         if self.file.dirs is None:
 378             self.file.dirs = []
 379
 380     def save(self):
 381         self.file.save()
 382
 383     def add_dir(self, path):
 384         if not os.path.exists(path):
 385             output("Failed to add directory - '%s' does not exist!" % path)
 386             return
 387         if path not in self.file.dirs:
 388             self.file.dirs.append(path)
 389             self.save()
 390             output("Added '%s'!" % path)
 391
 392     def delete_dir(self, dir):
 393         if path not in self.file.dirs:
 394             output("Failed to remove directory - '%s' not in list!" % path)
 395             return
 396         self.file.dirs.remove(dir)
 397         self.save()
 398         output("Removed '%s'!" % path)
 399
 400     def silent(self, state = None):
 401         if state is None: return self.file.silent
 402         else:             self.file.silent = state
 403
 404     def last_profile(self, val = None):
 405         if val is None: return self.file.last_profile
 406         else:           self.file.last_profile = val
 407
 408     def load_last_profile(self):
 409         if not self.file.last_profile:
 410             return False
 411         load_profile(self.file.last_profile)
 412         if not profile.exists():
 413             del self.file.last_profile
 414             self.save()
 415             return False
 416         return True
 417
 418     def list_manga(self):
 419         ret = []
 420         for dir in self.file.dirs:
 421             if os.path.exists(dir):
 422                 ret += os.listdir(dir)
 423         return ret
 424
 425 class Profile(object):
 426     def __init__(self, name):
 427         self.name = name
 428         self.dir = Directory(os.path.join(DIR_PROFILES, name))
 429         self.mangas = self.dir.add_dir("manga")
 430         self.settings = self.dir.add_file("settings")
 431
 432     def exists(self):
 433         return self.dir.exists()
 434
 435     def delete(self):
 436         self.dir.delete()
 437
 438     def rename(self, new_name):
 439         if not self.dir.move(os.path.join(DIR_PROFILES, new_name)):
 440             return False
 441         self.name = new_name
 442         return True
 443
 444     def save(self):
 445         self.dir.save_all()
 446
 447     def save_page(self, manga):
 448         if manga.title() not in self.mangas:
 449             self.mangas.add_file(manga.title())
 450         file = self.mangas[manga.title()]
 451         file.page = manga.mark.name
 452         file.save()
 453
 454     def load_manga(self, path):
 455         self.settings.last_read = path
 456         manga = path.rsplit("/", 1)[-1]
 457         if manga in self.mangas:
 458             return Manga(self, path, self.mangas[manga].page)
 459         return Manga(self, path)
 460
 461 class Manga(object):
 462     def __init__(self, reader_profile, path, page = None):
 463         self.reader  = reader_profile
 464         self.path    = path
 465         self.pages   = self.load_pages()
 466         self.mark = Page(self, page) if page else self.first_page()
 467
 468     def load_pages(self):
 469         files = [f for f in os.listdir(self.path) if f.rsplit(".", 1)[-1] in ("jpg", "png", "gif", "bmp")]
 470         return natsorted(files) # check if there's an order file / only load image files
 471
 472     def first_page(self):
 473         return Page(self, self.pages[0])
 474
 475     def last_page(self):
 476         return Page(self, self.pages[-1])
 477
 478     def num_pages(self):
 479         return len(self.pages)
 480
 481     def index_of(self, page):
 482         return self.pages.index(page.name)
 483
 484     def set_mark(self, page):
 485         self.mark = page
 486         self.reader.save_page(self)
 487
 488     def previous(self, page, step = 1):
 489         return Page(self, self.pages[max(0, self.pages.index(page) - step)])
 490
 491     def next(self, page, step = 1):
 492         return Page(self, self.pages[min(len(self.pages) - 1, self.pages.index(page) + step)])
 493
 494     def title(self):
 495         return self.path.rsplit("/", 1)[-1]
 496
 497 class Page(object):
 498     def __init__(self, manga, name):
 499         self.manga = manga
 500         self.name = name
 501         self.path = os.path.join(manga.path, name)
 502
 503     def previous(self, step = 1):
 504         return self.manga.previous(self.name, step)
 505
 506     def next(self, step = 1):
 507         return self.manga.next(self.name, step)
 508
 509 if __name__ == "__main__":
 510     init()
 511
 512     if opts.add:
 513         path = abs_path(opts.add)
 514         settings.add_dir(path)
 515
 516     if opts.delete:
 517         path = abs_path(opts.delete)
 518         settings.delete_dir(path)
 519
 520     if opts.silent:
 521         settings.silent(True)
 522     if opts.verbose:
 523         settings.silent(False)
 524
 525     if opts.profile:
 526         load_profile(opts.profile)
 527         if profile.exists():
 528             output("Loaded profile '%s'" % profile.name)
 529         else:
 530             profile.save()
 531             output("Created profile '%s'" % profile.name)
 532     else:
 533         if settings.load_last_profile():
 534             output("No profile specified - loading '%s'" % profile.name)
 535         else:
 536             user = home.split("/")[-1]
 537             output("No profile exists - creating one for '%s'" % user)
 538             load_profile(user)
 539             profile.save()
 540
 541     reader = Reader()
 542     manga_path = abs_path(args[0]) if args else cwd
 543     if manga_dir(manga_path):
 544         reader.set_manga(profile.load_manga(manga_path))
 545     reader.start()
 546
 547     profile.save()
 548     settings.save()