git.maemo.org Git - comic-widget/blob - src/usr/lib/hildon-desktop/comicwidget.py

   1 import gobject
   2 import hildon
   3 import hildondesktop
   4 import gtk
   5 import csv
   6 import urllib2
   7 import urllib
   8 import string
   9 import os
  10 import osso
  11 import cairo
  12 import datetime
  13 import shutil
  14
  15 supports_alpha = False
  16
  17 # constants. dbfile is the location of the csv
  18 # comiccache is the location of the images
  19 APP_VERSION = "0.3.1"
  20
  21 basedbdir = "/opt/comic-widget/db/"
  22 imagedir = "/opt/comic-widget/images/"
  23 dbdir = "/home/user/.comic-widget/"
  24 activecomics = dbdir + "activecomics.cfg"
  25 comiccache = "/home/user/MyDocs/.comics/"
  26 comics = {"xkcd":{"name":"xkcd","link":"http://xkcd.org/","start":666,"dbfile":dbdir + "comicdb.xkcd.csv"},
  27                 "sinfest":{"name":"Sinfest","link":"http://sinfest.com/","start":3400,"dbfile":dbdir + "comicdb.sinfest.csv"},
  28                 "phd":{"name":"PHD Comics","link":"http://www.phdcomics.com/","start":1240,"dbfile":dbdir + "comicdb.phd.csv"},
  29                 "dilbert":{"name":"Dilbert","link":"http://dilbert.com/","start":"2009-01-01","dbfile":dbdir + "comicdb.dilbert.csv"},
  30                 "cyanide":{"name":"Cyanide&amp;Happiness","link":"http://explosm.com/","start":"1920","dbfile":dbdir + "comicdb.cyanide.csv"},
  31                 }
  32
  33 previous = False
  34 next = False
  35
  36 # handling of the comics
  37 class ComicDb():
  38         def __init__(self, comic):
  39                 self.comic = comic
  40                 self.start = comics[self.comic]["start"]
  41                 self.dbfile = comics[self.comic]["dbfile"]
  42
  43                 #if db file exist, read it
  44                 # if os.path.isfile(self.dbfile) == True:
  45                 #       dbf = open(self.dbfile, 'r')
  46                 # if not, create it.
  47                 dbf = self.get_dbfile()
  48                 dbr = csv.DictReader(dbf)
  49                 self.db = []
  50                 for row in dbr:
  51                         self.db.insert(0,row)
  52                 dbf.close()
  53                 if len(self.db) == 0:
  54                         self.refresh()
  55                 self.currentcomic = 0
  56
  57
  58
  59         def get_dbfile(self):
  60                 #if db file exist, read it
  61                 print "fetching " + self.dbfile
  62                 if os.path.isfile(self.dbfile) == True:
  63                         print "found " + self.dbfile
  64                         dbf = open(self.dbfile, 'r')
  65                         return dbf
  66                 # if not, copy it.
  67                 else:
  68                         print "file " + self.dbfile + " not found"
  69                         if not os.path.exists(dbdir):
  70                                 print "path not found: " + dbdir
  71                                 try:
  72                                         os.makedirs(dbdir)
  73                                 except:
  74                                         print "comic db creation failed on mkdir"
  75                                         exit()
  76                         try:
  77                                 shutil.copyfile(basedbdir + "comicdb." + self.comic + ".csv", dbdir + "comicdb." + self.comic + ".csv")
  78                         except:
  79                                 print "comic db creation failed on copy"
  80                                 print "creating new..."
  81                                 dbf = open(self.dbfile, 'w')
  82                                 dbf.write('comic,id,link,url,filename,title\n')
  83                                 dbf.close()
  84
  85                         if os.path.isfile(self.dbfile) == True:
  86                                 dbf = open(self.dbfile, 'r')
  87                                 return dbf
  88                         else:
  89                                 print "comic db creation failed after copy"
  90
  91
  92         def get_comic(self):
  93                 print str(self.currentcomic)
  94                 if self.currentcomic < 0:
  95                         self.refresh()
  96                         self.currentcomic = 0
  97                 if  len(self.db) < (self.currentcomic + 1):
  98                         self.currentcomic -= 1
  99                         self.refresh()
 100                         self.currentcomic = len(self.db) - 1
 101
 102                 dbrow = self.db[self.currentcomic]
 103                 filename = comiccache + self.comic + "/" + dbrow['filename']
 104                 print filename + "\n"
 105
 106                 if os.path.isfile(filename):
 107                         print "found, returning " + filename + "\n"
 108                         return filename
 109                 else:
 110                         #fetch file
 111                         print filename + " not found\nretrieving " + dbrow['url'] + "\n"
 112                         if not os.path.exists(comiccache + self.comic + "/"):
 113                                 print "create dir " + comiccache + self.comic + "/"
 114                                 try:
 115                                         os.makedirs(comiccache + self.comic + "/")
 116                                         print "created dir"
 117                                 except:
 118                                         print "comic db creation failed on mkdir"
 119                         urllib.urlretrieve(dbrow['url'], filename)
 120                         print "success\n"
 121                         return filename
 122
 123         def get_current_row(self):
 124                 return self.db[self.currentcomic]
 125
 126         def get_link(self):
 127                 print str(self.currentcomic)
 128                 if self.currentcomic < 0:
 129                         self.refresh()
 130                         self.currentcomic = 0
 131                 if  len(self.db) < (self.currentcomic + 1):
 132                         self.currentcomic -= 1
 133                 return self.db[self.currentcomic]['link']
 134
 135
 136
 137         def insert_row(self, irow):
 138                 dbf = open(self.dbfile, 'a')
 139                 dbw = csv.writer(dbf)
 140                 dbw.writerow(irow)
 141                 dbf.close()
 142
 143         def insert_row_first(self, irow):
 144                 dbf = open(self.dbfile, 'w')
 145                 dbf.write('comic,id,link,url,filename,title\n')
 146                 dbw = csv.writer(dbf)
 147                 dbw.writerow(irow)
 148                 dbf.close()
 149                 dbf = open(self.dbfile, 'a')
 150                 dbw = csv.DictWriter(dbf, ['comic','id','link','url','filename','title'])
 151                 tmpdb = self.db
 152                 tmpdb.reverse()
 153                 for row in tmpdb:
 154                         dbw.writerow(row)
 155                 dbf.close()
 156
 157         def refresh(self):
 158                 if len(self.db) < 1:
 159                         self.currentcomic = -1
 160                         self.fetch_latest_std(self.comic, self.start)
 161                 elif self.currentcomic == 0 or self.currentcomic < 0:
 162                         self.fetch_latest_std(self.comic, self.db[0]['id'])
 163                 elif self.currentcomic == (len(self.db) - 1):
 164                         self.fetch_earlier(self.comic, self.db[self.currentcomic]['id'])
 165                 dbf = open(self.dbfile, 'r')
 166                 dbr = csv.DictReader(dbf)
 167                 self.db = []
 168                 for row in dbr:
 169                         self.db.insert(0,row)
 170                 dbf.close()
 171
 172         def fetch_earlier(self, comic, earliest):
 173                 if len(earliest) == 10:
 174                         # date id.
 175                         dt = string.split(earliest, "-")
 176                         d = datetime.date(int(dt[0]),int(dt[1]),int(dt[2]))
 177                         earlier = d - datetime.timedelta( 1 )
 178                         comicid = earlier.isoformat()
 179                 else:
 180                         comicid = int(earliest) - 1
 181
 182                 irow = self.get_irow(comic, comicid)
 183                 if irow:
 184                         print "got irow: "
 185                         print irow
 186                         print "\ninserting first...\n"
 187                         self.insert_row_first(irow)
 188                 else:
 189                         print "No comic found at " + comicid
 190
 191         def fetch_latest_std(self, comic, latest):
 192                 print "fetching new after " + str(comic) + " " + str(latest)
 193                 next = False
 194                 dateid = False
 195                 if comic == 'cyanide':
 196                         next = self.get_next_id(comic, latest)
 197                         if not next:
 198                                 return
 199                         else:
 200                                 comicid = next
 201                 else:
 202                         if len(str(latest)) == 10:
 203                                 # date id.
 204                                 dateid = True
 205                                 dt = string.split(latest, "-")
 206                                 d = datetime.date(int(dt[0]),int(dt[1]),int(dt[2]))
 207                                 newer = d + datetime.timedelta( 1 )
 208                                 comicid = newer.isoformat()
 209                         else:
 210                                 comicid = int(latest) + 1
 211
 212                 if len(self.db) > 0:
 213                         lasturl = self.db[0]['url']
 214                 else:
 215                         lasturl = "http"
 216                 while True:
 217                         irow = self.get_irow(comic, comicid)
 218                         if irow:
 219                                 print "got irow: " + str(irow)
 220                                 if str(irow[0]) == 'skip':
 221                                         print "skipping this one..."
 222                                         next = int(irow[1])
 223                                 else:
 224                                         if irow[3] == lasturl:
 225                                                 print "Looping the same, break break break!"
 226                                                 break
 227                                         lasturl = irow[3]
 228                                         print "inserting..."
 229                                         self.insert_row([irow[0],irow[1],irow[2],irow[3],irow[4],irow[5]])
 230                                         if len(irow) > 6:
 231                                                 next = irow[6]
 232                                                 if not next:
 233                                                         break
 234                                 if dateid:
 235                                         dt = string.split(comicid, "-")
 236                                         d = datetime.date(int(dt[0]),int(dt[1]),int(dt[2]))
 237                                         newer = d + datetime.timedelta( 1 )
 238                                         comicid = newer.isoformat()
 239                                 elif next:
 240                                         comicid = next
 241                                 else:
 242                                         comicid += 1
 243                         else:
 244                                 break
 245
 246
 247
 248
 249         def get_next_id(self, comic, number):
 250                 if comic == 'cyanide':
 251                         link = "http://www.explosm.net/comics/" + str(number) + "/"
 252                         print "link: " + link
 253                         try:
 254                                 f = urllib2.urlopen(link)
 255                                 hcode = f.code
 256                         except:
 257                                 hcode = 404
 258                         print "got hcode = " + str(hcode) + "\n"
 259                         if (hcode != 200):
 260                                 return False
 261                         else:
 262                                 print "Cyanide & Happiness is unreliable, so we need to track next and prev"
 263                                 s = f.read()
 264                                 f.close()
 265                                 # title:
 266                                 splt = string.split(s, 'Previous</a> | <a href="/comics/', 1)
 267                                 if len(splt) < 2:
 268                                         print "no 'next' found"
 269                                         return False
 270                                 splt = string.split(splt[1], '/">Next >', 1)
 271                                 if len(splt) < 2:
 272                                         print "no 'next' found"
 273                                         return False
 274                                 else:
 275                                         return splt[0]
 276
 277
 278
 279
 280
 281
 282         def get_irow(self, comic, number):
 283                 dateid = False
 284                 if len(str(number)) == 10:
 285                         dateid = True
 286                 else:
 287                         if number < 0:
 288                                 return False
 289                         print "number is now: " + str(number) + "\n"
 290                 if comic == 'xkcd':
 291                         link = "http://xkcd.org/" + str(number) + "/"
 292                 elif comic == 'sinfest':
 293                         link = "http://www.sinfest.net/archive_page.php?comicID=" + str(number)
 294                 elif comic == 'dilbert':
 295                         link = "http://dilbert.com/" + str(number) + "/"
 296                 elif comic == 'phd':
 297                         link = "http://www.phdcomics.com/comics/archive.php?comicid=" + str(number)
 298                 elif comic == 'cyanide':
 299                         link = "http://www.explosm.net/comics/" + str(number) + "/"
 300                 else:
 301                         return False
 302
 303                 print "link: " + link
 304                 try:
 305                         f = urllib2.urlopen(link)
 306                         hcode = f.code
 307                 except:
 308                         hcode = 404
 309                 print "got hcode = " + str(hcode) + "\n"
 310                 if (hcode != 200):
 311                         return False
 312                 else:
 313                         # Build db entry.
 314                         # they look like: comic,id,link,url,filename,title
 315                         # We already have comic, number/id and link
 316
 317                         if comic == 'xkcd':
 318                                 s = f.read()
 319                                 f.close()
 320                                 # This should be done with regex but...
 321                                 splt = string.split(s, "<h3>Image URL (for hotlinking/embedding): ", 1)
 322                                 splt2 = string.split(splt[1], "</h3>", 1)
 323                                 url = splt2[0]
 324                                 splt = string.split(splt[0], "<h1>", 1)
 325                                 splt = string.split(splt[1], "</h1>", 1)
 326
 327                                 title = splt[0]
 328
 329                         elif comic == 'sinfest':
 330                                 s = f.read()
 331                                 f.close()
 332                                 splt = string.split(s, 'height="107"', 1)
 333                                 splt = string.split(splt[1], '<img src="', 1)
 334                                 splt = string.split(splt[1], '" alt="', 1)
 335                                 url = splt[0]
 336                                 if len(url) < 49:
 337                                         print "Fake 404! Break break break!"
 338                                         return False
 339                                 splt = string.split(splt[1], '" border="0" />', 1)
 340                                 title = splt[0]
 341
 342                         elif comic == 'dilbert':
 343                                 s = f.read()
 344                                 f.close()
 345                                 splt = string.split(s, 'input type="hidden" name="PrintPath" value="', 1)
 346                                 splt = string.split(splt[1], '" />', 1)
 347                                 url = "http://dilbert.com" + splt[0]
 348                                 if len(url) < 50:
 349                                         print "Fake 404! Break break break!"
 350                                         return False
 351                                 title = ""
 352
 353                         elif comic == 'phd':
 354                                 s = f.read()
 355                                 f.close()
 356                                 # title:
 357                                 splt = string.split(s, '<title>PHD Comics: ', 1)
 358                                 splt = string.split(splt[1], '</title>', 1)
 359                                 title = splt[0];
 360                                 splt = string.split(splt[1], '<td bgcolor=#FFFFFF align=center><img src=', 1)
 361                                 splt = string.split(splt[1], ' align=top>', 1)
 362                                 url = splt[0]
 363                                 if len(url) < 49:
 364                                         print "Fake 404! Break break break!"
 365                                         return False
 366
 367                         elif comic == 'cyanide':
 368                                 s = f.read()
 369                                 f.close()
 370                                 # title:
 371                                 splt = string.split(s, ' First</a> | <a href="/comics/', 1)
 372                                 if len(splt) < 2:
 373                                         print "first comic?"
 374                                         prev = False
 375                                 else:
 376                                         splt = string.split(splt[1], '/">< ', 1)
 377                                         prev = splt[0];
 378                                         print "got prev: " + prev
 379                                 splt = string.split(s, 'Previous</a> | <a href="/comics/', 1)
 380                                 if len(splt) < 2:
 381                                         print "last comic?"
 382                                         next = False
 383                                 else:
 384                                         splt = string.split(splt[1], '/">Next ></a>', 1)
 385                                         if len(splt[0]) > 10:
 386                                                 next = False
 387                                         else:
 388                                                 next = splt[0]
 389                                                 print "got next: " + next
 390
 391                                 splt = string.split(s, '</tr><tr><td colspan=2>', 1)
 392                                 if len(splt) < 2:
 393                                         print "no comic?"
 394                                         return False
 395                                 splt = string.split(splt[1], ' <b>by <a href="', 1)
 396                                 title = splt[0];
 397                                 if len(title) > 10:
 398                                         print "title wrong..."
 399                                         return False
 400                                 splt = string.split(splt[1], 'a daily webcomic" src="http://www.explosm', 1)
 401                                 if len(splt) < 2:
 402                                         print "a video? Try skipping"
 403                                         return ['skip',next,prev]
 404
 405                                 splt = string.split(splt[1], '">', 1)
 406                                 url = "http://www.explosm" + splt[0]
 407                                 splt2 = string.rsplit(url, "/", 1)
 408                                 filename = splt2[1]
 409                                 irow = [comic,number,link,url,filename,title,next,prev]
 410                                 return irow
 411
 412                         splt2 = string.rsplit(url, "/", 1)
 413                         filename = splt2[1]
 414                         irow = [comic,number,link,url,filename,title]
 415                         return irow
 416
 417
 418 # ------------UI
 419
 420 class ComicHomePlugin(hildondesktop.HomePluginItem):
 421         __gtype_name__ = 'ComicHomePlugin'
 422         def __init__(self):
 423                 hildondesktop.HomePluginItem.__init__(self)
 424                 global supports_alpha
 425                 self.set_settings(True)
 426                 self.active_comics = self.get_active_comics()
 427                 self.connect("show-settings", self.show_options)
 428                 self.osso_c = osso.Context("comic-widget", "0.3.0", False)
 429                 self.osso_rpc = osso.Rpc(self.osso_c)
 430                 self.keypointer = 0
 431                 if len(self.active_comics) < 1:
 432                         self.active_comics = ['xkcd']
 433                 self.db = ComicDb(self.active_comics[self.keypointer])
 434                 self.comicname = comics[self.active_comics[self.keypointer]]['name']
 435                 self.set_name = "comicwidget"
 436                 screen = self.get_screen()
 437                 colormap = screen.get_rgba_colormap()
 438                 if colormap == None:
 439                         colormap = screen.get_rgb_colormap()
 440                         supports_alpha = False
 441                 else:
 442                         supports_alpha = True
 443                 self.set_colormap(colormap)
 444                 self.set_app_paintable(True)
 445                 #setup internal area
 446                 self.set_size_request(480, 230)
 447                 self.imgvpos = 0;
 448                 self.vbox = gtk.VBox()
 449                 self.hbox = gtk.HBox()
 450                 self.label = gtk.Label()
 451                 self.label.set_alignment(xalign = 0, yalign = 0.5)
 452                 self.label.set_use_markup(True)
 453                 titl = str(self.db.db[self.db.currentcomic]['title'])
 454                 if len(titl) > 22:
 455                         titl = titl[:19] + "..."
 456                 self.label.set_markup('<span size="12000" face="monospace"> <b>' + self.comicname + '</b> ' + str(self.db.db[self.db.currentcomic]['id']) + '\n ' + titl + '</span>')
 457
 458
 459                 self.e_goweb = gtk.EventBox()
 460                 self.e_goweb.set_name('goweb')
 461                 self.e_goweb.set_size_request(220, 48)
 462                 # e_open is the eventbox for the image. Does nothing, but it's convenient to have it.
 463                 # it will change to be a cairo thing when I have the time.
 464                 self.e_open = gtk.EventBox()
 465                 self.e_open.set_name('open')
 466                 self.e_switch = gtk.EventBox()
 467                 self.e_switch.set_name('switch')
 468                 self.e_switch.set_size_request(48, 48)
 469                 self.e_next = gtk.EventBox()
 470                 self.e_next.set_name('next')
 471                 self.e_next.set_size_request(48, 48)
 472                 self.e_prev = gtk.EventBox()
 473                 self.e_prev.set_name('prev')
 474                 self.e_prev.set_size_request(48, 48)
 475                 self.e_up = gtk.EventBox()
 476                 self.e_up.set_name('up')
 477                 self.e_up.set_size_request(48, 48)
 478                 self.e_down = gtk.EventBox()
 479                 self.e_down.set_name('down')
 480                 self.e_down.set_size_request(48, 48)
 481                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 482                 self.comic_image.show()
 483
 484
 485                 # Preload images into a dictionary, so that we can access them by the names of the eventboxes:
 486
 487                 self.images = {'up0':cairo.ImageSurface.create_from_png(imagedir + "up0-48x48.png"),
 488                                         'up1':cairo.ImageSurface.create_from_png(imagedir + "up1-48x48.png"),
 489                                         'down0':cairo.ImageSurface.create_from_png(imagedir + "down0-48x48.png"),
 490                                         'down1':cairo.ImageSurface.create_from_png(imagedir + "down1-48x48.png"),
 491                                         'next0':cairo.ImageSurface.create_from_png(imagedir + "next0-48x48.png"),
 492                                         'next1':cairo.ImageSurface.create_from_png(imagedir + "next1-48x48.png"),
 493                                         'prev0':cairo.ImageSurface.create_from_png(imagedir + "prev0-48x48.png"),
 494                                         'prev1':cairo.ImageSurface.create_from_png(imagedir + "prev1-48x48.png"),
 495                                         'switch0':cairo.ImageSurface.create_from_png(imagedir + "switch0-48x48.png"),
 496                                         'switch1':cairo.ImageSurface.create_from_png(imagedir + "switch1-48x48.png"),
 497                                         }
 498
 499
 500
 501                 self.e_goweb.add(self.label)
 502                 self.e_goweb.set_events(gtk.gdk.BUTTON_RELEASE_MASK)
 503                 self.e_goweb.connect("button-release-event", self.view_comic)
 504
 505                 self.e_open.add(self.comic_image)
 506
 507                 # self.e_switch.add(self.switch)
 508                 self.e_switch.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 509                 self.e_switch.connect("button-press-event", self.button_press)
 510                 self.e_switch.connect("button-release-event", self.button_release)
 511                 self.e_switch.connect("leave-notify-event", self.button_release)
 512
 513
 514                 # self.e_next.add(self.next)
 515                 self.e_next.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 516                 self.e_next.connect("button-press-event", self.button_press)
 517                 self.e_next.connect("button-release-event", self.button_release)
 518                 self.e_next.connect("leave-notify-event", self.button_release)
 519
 520                 #self.e_prev.add(self.prev)
 521                 self.e_prev.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 522                 self.e_prev.connect("button-press-event", self.button_press)
 523                 self.e_prev.connect("button-release-event", self.button_release)
 524                 self.e_prev.connect("leave-notify-event", self.button_release)
 525
 526                 #self.e_up.add(self.up)
 527                 self.e_up.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 528                 self.e_up.connect("button-press-event", self.button_press)
 529                 self.e_up.connect("button-release-event", self.button_release)
 530                 self.e_up.connect("leave-notify-event", self.button_release)
 531
 532
 533                 #self.e_down.add(self.down)
 534                 self.e_down.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 535                 self.e_down.connect("button-press-event", self.button_press)
 536                 self.e_down.connect("button-release-event", self.button_release)
 537                 self.e_down.connect("leave-notify-event", self.button_release)
 538
 539                 self.vbox.pack_start(self.e_open,False,False,0)
 540                 self.vbox.pack_end(self.hbox,False,False,0)
 541
 542                 self.hbox.pack_start(self.e_switch,False,False,0)
 543                 self.hbox.pack_start(self.e_goweb,False,False,10)
 544                 self.hbox.pack_end(self.e_next,False,False,0)
 545                 self.hbox.pack_end(self.e_prev,False,False,0)
 546                 self.hbox.pack_end(self.e_down,False,False,0)
 547                 self.hbox.pack_end(self.e_up,False,False,0)
 548                 self.vbox.show_all()
 549                 self.add(self.vbox)
 550
 551         # **************** Cairo draw functions ***************
 552
 553         def realize(self, widget):
 554                 global supports_alpha
 555
 556                 # To check if the display supports alpha channels, get the colormap
 557                 screen = self.get_screen()
 558                 colormap = screen.get_rgba_colormap()
 559                 if colormap == None:
 560                         print 'Your screen does not support alpha channels!'
 561                         colormap = screen.get_rgb_colormap()
 562                         supports_alpha = False
 563                 else:
 564                 #      print 'Your screen supports alpha channels!'
 565                         supports_alpha = True
 566
 567                 # Now we have a colormap appropriate for the screen, use it
 568                 self.set_colormap(colormap)
 569
 570                 return False
 571
 572         def do_expose_event(widget, event):
 573                 cr = widget.window.cairo_create()
 574                 widget.draw(widget.e_up, 0)
 575                 widget.draw(widget.e_down, 0)
 576                 widget.draw(widget.e_prev,0)
 577                 widget.draw(widget.e_next, 0)
 578                 widget.draw(widget.e_switch, 0)
 579 #               widget.writeit(widget.e_goweb, "asdf")
 580                 cr.set_operator(cairo.OPERATOR_OVER)
 581                 region = gtk.gdk.region_rectangle(event.area)
 582                 cr.region(region)
 583                 bg_color=gtk.gdk.color_parse('#000000')
 584                 if supports_alpha:
 585                         cr.set_source_rgba (0.0, 0.0, 0.0, 0.5)
 586                 else:
 587                         cr.set_source_rgb (0.0, 0.0, 0.0)
 588
 589                 cr.fill_preserve()
 590                 return False
 591
 592         # Function that draws a button preloaded in the images dictionary.
 593         def draw(self, target, postfix):
 594                 cr_e = target.window.cairo_create()
 595                 cr_e.set_source_rgba(0.0, 0.0, 0.0, 0.5) # Transparent
 596                 cr_e.set_operator(cairo.OPERATOR_SOURCE)
 597                 cr_e.paint()
 598                 cr_e.set_operator(cairo.OPERATOR_OVER)
 599                 cr_e.set_source_surface(self.images[target.get_name() + str(postfix)], 0, 0)
 600                 cr_e.paint()
 601
 602         # ********** Event handlers *************
 603
 604
 605         # Most events happen on release, so I moved all of them into the same event handler.
 606         def button_release(self, widget, event):
 607                 if event.type == gtk.gdk.BUTTON_RELEASE:
 608                         func = widget.get_name()
 609                         print "pressed: " + func
 610                         if func == 'up':
 611                                 self.e_open.remove(self.comic_image)
 612                                 self.imgvpos = self.imgvpos - 80
 613                                 if self.imgvpos < 0:
 614                                         self.imgvpos = 0
 615                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 616                                 self.e_open.add(self.comic_image)
 617                                 self.e_open.show_all()
 618
 619                         elif func == 'down':
 620                                 self.e_open.remove(self.comic_image)
 621                                 self.imgvpos = self.imgvpos + 80
 622                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 623                                 self.e_open.add(self.comic_image)
 624                                 self.e_open.show_all()
 625
 626                         elif func == 'next':
 627                                 self.db.currentcomic -= 1
 628                                 self.imgvpos = 0
 629                                 self.e_open.remove(self.comic_image)
 630                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 631                                 self.e_open.add(self.comic_image)
 632                                 self.e_open.show_all()
 633                                 self.e_goweb.remove(self.label)
 634                                 titl = str(self.db.db[self.db.currentcomic]['title'])
 635                                 if len(titl) > 22:
 636                                         titl = titl[:19] + "..."
 637                                 self.label.set_markup('<span size="12000" face="monospace"> <b>' + self.comicname + '</b> ' + str(self.db.db[self.db.currentcomic]['id']) + '\n ' + titl + '</span>')
 638                                 self.e_goweb.add(self.label)
 639                                 self.e_goweb.show_all()
 640
 641                         elif func == 'prev':
 642                                 self.db.currentcomic += 1
 643                                 self.imgvpos = 0
 644                                 self.e_open.remove(self.comic_image)
 645                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 646                                 self.e_open.add(self.comic_image)
 647                                 self.e_open.show_all()
 648                                 self.e_goweb.remove(self.label)
 649                                 titl = str(self.db.db[self.db.currentcomic]['title'])
 650                                 if len(titl) > 22:
 651                                         titl = titl[:19] + "..."
 652                                 self.label.set_markup('<span size="12000" face="monospace"> <b>' + self.comicname + '</b> ' + str(self.db.db[self.db.currentcomic]['id']) + '\n ' + titl + '</span>')
 653                                 self.e_goweb.add(self.label)
 654                                 self.e_goweb.show_all()
 655
 656                         elif func == 'switch':
 657                                 self.active_comics = self.get_active_comics()
 658                                 print "active comics: " + str(self.active_comics)
 659                                 self.keypointer = (self.keypointer + 1) % len(self.active_comics)
 660                                 self.imgvpos = 0
 661                                 self.db = []
 662                                 print "switching to " + self.active_comics[self.keypointer]
 663                                 self.comicname = comics[self.active_comics[self.keypointer]]['name']
 664                                 self.db = ComicDb(self.active_comics[self.keypointer])
 665                                 self.e_open.remove(self.comic_image)
 666                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 667                                 self.e_goweb.remove(self.label)
 668                                 titl = str(self.db.db[self.db.currentcomic]['title'])
 669                                 if len(titl) > 22:
 670                                         titl = titl[:19] + "..."
 671                                 self.label.set_markup('<span size="12000" face="monospace"> <b>' + self.comicname + '</b> ' + str(self.db.db[self.db.currentcomic]['id']) + '\n ' + titl + '</span>')
 672                                 self.e_goweb.add(self.label)
 673                                 self.e_goweb.show_all()
 674                                 self.e_open.add(self.comic_image)
 675                                 self.e_open.show_all()
 676
 677                         else:
 678                                 return False
 679                 self.draw(widget, "0")
 680
 681         # this one only switches to pressed button image
 682         def button_press(self, widget, event):
 683                 if not event.type == gtk.gdk.BUTTON_PRESS:
 684                         return False
 685                 self.draw(widget, "1")
 686
 687         # this one cancels a button press when pointer is moved out from it after press.
 688         def button_out(self, widget, event):
 689                 if not event.type == gtk.gdk.BUTTON_PRESS:
 690                         return False
 691                 self.draw(widget, "0")
 692
 693         # no fancy cairo stuff here. simply launches url in browser.
 694         def view_comic(self, widget, event):
 695                 if not event.type == gtk.gdk.BUTTON_RELEASE:
 696                         return False
 697                 link = self.db.get_link()
 698                 self.osso_rpc.rpc_run_with_defaults("osso_browser", "open_new_window", (link,))
 699
 700
 701
 702         # this function modifies the image to fit the widget and then returns it.
 703
 704         def get_resized_pixmap(self, filename, vpos):
 705                 print "vpos: " + str(vpos)
 706
 707                 maxheight = 182
 708
 709                 pixbuf = gtk.gdk.pixbuf_new_from_file(filename)
 710                 parent_buf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, pixbuf.get_has_alpha(), 8, 480, maxheight)
 711                 parent_buf.fill(0xffffffff)
 712                 retimg = gtk.Image()
 713                 # get correct width/height
 714                 new_height = 1
 715                 new_width = 478
 716                 new_height = int((478.0 / pixbuf.get_width()) * pixbuf.get_height())
 717                 scaled_buf = pixbuf.scale_simple(new_width,new_height,gtk.gdk.INTERP_BILINEAR)
 718                 print "scaled height: " + str(scaled_buf.get_height())
 719                 if scaled_buf.get_height() > maxheight:
 720                         if scaled_buf.get_height() - (vpos + maxheight) < 0:
 721                                 vpos = scaled_buf.get_height() - maxheight
 722                         scaled_buf.copy_area(0,vpos,478,maxheight,parent_buf,1,0)
 723                         # parent_buf.composite(scaled_buf, 0, 0, 478, maxheight, 0, 0, 478, maxheight, gtk.gdk.INTERP_BILINEAR, 0)
 724                         self.imgvpos = vpos
 725                 else:
 726                         tmpy = maxheight - scaled_buf.get_height()
 727                         if tmpy > 0:
 728                                 tmpy = tmpy / 2
 729
 730                         scaled_buf.copy_area(0,0,478,scaled_buf.get_height(),parent_buf,1,tmpy)
 731                         self.imgvpos = 0
 732 #               test = parent_buf.render_pixmap_and_mask(0)
 733                 parent_buf.add_alpha(True,chr(255),chr(255),chr(255))
 734                 retimg.set_from_pixbuf(parent_buf)
 735                 print retimg.get_pixel_size()
 736                 print "vpos after fixing image: " + str(self.imgvpos)
 737                 return retimg
 738
 739         def screen_changed(self, widget, old_screen=None):
 740                 global supports_alpha
 741
 742                 # To check if the display supports alpha channels, get the colormap
 743                 screen = self.get_screen()
 744                 colormap = screen.get_rgba_colormap()
 745                 if colormap == None:
 746                         print 'Your screen does not support alpha channels!'
 747                         colormap = screen.get_rgb_colormap()
 748                         supports_alpha = False
 749                 else:
 750                 #      print 'Your screen supports alpha channels!'
 751                         supports_alpha = True
 752
 753                 # Now we have a colormap appropriate for the screen, use it
 754                 self.set_colormap(colormap)
 755
 756                 return False
 757
 758
 759         def get_active_comics(self):
 760                 print "get list"
 761
 762                 if os.path.isfile(activecomics) == True:
 763                         print "found " + activecomics
 764                         dbf = open(activecomics, 'r')
 765                         dbr = csv.reader(dbf)
 766                         try:
 767                                 active = dbr.next()
 768                         except:
 769                                 active = []
 770                         dbf.close()
 771                         return active
 772                 # if not, copy it.
 773                 else:
 774                         print "file " + activecomics + " not found"
 775                         if not os.path.exists(dbdir):
 776                                 print "path not found: " + dbdir
 777                                 try:
 778                                         os.makedirs(dbdir)
 779                                 except:
 780                                         print "settings dir creation failed. Exiting."
 781                                         exit()
 782                         try:
 783 #                               dbf = file(activecomics, 'w')
 784 #                               dbf.close()
 785                                 dbf = open(activecomics, 'w')
 786                         except:
 787                                 print "error storing settings"
 788                                 exit()
 789                         dbw = csv.writer(dbf)
 790                         dbw.writerow(comics.keys())
 791                         print comics.keys()
 792                         dbf.close()
 793                         ret = comics.keys()
 794                         return ret
 795
 796
 797
 798
 799                 #check if settings file exists
 800
 801                 #if not, write defaults
 802
 803 # ************************* OPTION DIALOGS ********************************
 804
 805         def show_options(self, widget):
 806                 dialog = gtk.Dialog("Comic Widget", None, gtk.DIALOG_DESTROY_WITH_PARENT)
 807
 808                 about_button = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
 809                 about_button.set_text("About", "See Author, Copyright and License information")
 810                 about_button.set_alignment(0,0,0,0)
 811                 about_button.connect("clicked", self.show_about)
 812
 813                 comics_button = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
 814                 comics_button.set_text("Comics", "Choose which comics to view")
 815                 comics_button.set_alignment(0,0,0,0)
 816                 comics_button.connect("clicked", self.show_comics)
 817
 818                 dialog.vbox.pack_start(about_button, True, True, 0)
 819                 dialog.vbox.pack_start(comics_button, True, True, 0)
 820
 821                 dialog.show_all()
 822                 dialog.run()
 823                 dialog.destroy()
 824
 825         def show_about(self, widget):
 826                 dialog = gtk.AboutDialog()
 827                 dialog.set_title("About")
 828                 dialog.set_name("Comic widget")
 829                 dialog.set_version(APP_VERSION)
 830                 dialog.set_copyright("Copyright 2010 Marcus Wikstrom")
 831                 dialog.set_authors(["Marcus Wikstrom <mece@ovi.com>\nLogo by Martin Wikstrom\n\nSpecial thanks to all the great python developers on t.m.o who share their code, and the helpful wizards on #maemo."])
 832                 dialog.set_logo(gtk.gdk.pixbuf_new_from_file("/opt/comic-widget/images/icon2-64x64.png"))
 833                 dialog.set_comments("Silly rabbit, tricks are for kids.")
 834                 dialog.set_license("""This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. <http://www.gnu.org/licenses/>.""")
 835                 dialog.set_wrap_license(True)
 836                 dialog.show_all()
 837                 dialog.run()
 838                 dialog.destroy()
 839
 840         def show_comics(self, widget):
 841                 dialog = gtk.Dialog("Configure Search Engines", None, gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_NO_SEPARATOR)
 842                 comiclist = comics.keys()
 843                 comiclist.sort()
 844                 buttonlist = {}
 845                 for comicid in comiclist:
 846                         buttonlist[comicid] = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
 847                         print buttonlist[comicid].get_name()
 848
 849                         print buttonlist[comicid].set_alignment(0, 0.5, 0, 0.5)
 850                         active = False
 851                         for acomic in self.active_comics:
 852                                 if acomic == comicid:
 853                                         active = True
 854                                         break
 855                         if active:
 856                                 buttonlist[comicid].set_text(comics[comicid]['name'] + " *", comicid + ": click to remove")
 857                                 buttonlist[comicid].connect("clicked", self.remove_comic)
 858                         else:
 859                                 buttonlist[comicid].set_text(comics[comicid]['name'], comicid + ": click to add")
 860                                 buttonlist[comicid].connect("clicked", self.add_comic)
 861                         dialog.vbox.pack_start(buttonlist[comicid], True, True, 0)
 862
 863
 864                 dialog.show_all()
 865                 dialog.run()
 866                 dialog.destroy()
 867
 868         def add_comic(self, widget):
 869                 print "add " + widget.get_title()
 870                 splt = string.split(widget.get_value(), ':', 1)
 871                 comicid = splt[0]
 872                 if os.path.isfile(activecomics) == True:
 873                         print "added " + comicid + " to " + str(self.active_comics)
 874                         try:
 875                                 found = self.active_comics.index(comicid)
 876                         except:
 877                                 self.active_comics.append(comicid)
 878                         dbf = open(activecomics, 'w')
 879                         dbw = csv.writer(dbf)
 880                         dbw.writerow(self.active_comics)
 881                         dbf.close()
 882                 widget.set_text(comics[comicid]['name'] + " *", comicid + ": click to remove")
 883
 884         def remove_comic(self, widget):
 885                 print "remove " + widget.get_title()
 886                 if len(self.active_comics) == 1:
 887                         return
 888                 splt = string.split(widget.get_value(), ':', 1)
 889                 comicid = splt[0]
 890                 if os.path.isfile(activecomics) == True:
 891                         print "removing " + comicid + " from " + str(self.active_comics)
 892                         del self.active_comics[self.active_comics.index(comicid)]
 893                         dbf = open(activecomics, 'w')
 894                         dbw = csv.writer(dbf)
 895                         dbw.writerow(self.active_comics)
 896                         dbf.close()
 897                 widget.set_text(comics[comicid]['name'], comicid + ": click to add")
 898
 899 hd_plugin_type = ComicHomePlugin
 900
 901
 902 if __name__ == "__main__":
 903         import gobject
 904         gobject.type_register(hd_plugin_type)
 905         obj = gobject.new(hd_plugin_type, plugin_id="plugin_id")
 906         obj.show_all()
 907         gtk.main()