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.0"
  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                                 splt = string.split(s, 'Previous</a> | <a href="/comics/', 1)
 379                                 if len(splt) < 2:
 380                                         print "last comic?"
 381                                         next = False
 382                                 else:
 383                                         splt = string.split(splt[1], '/">Next ></a>', 1)
 384                                         if len(splt[0]) > 10:
 385                                                 next = False
 386                                         else:
 387                                                 next = splt[0]
 388
 389                                 splt = string.split(s, '</tr><tr><td colspan=2>', 1)
 390                                 if len(splt) < 2:
 391                                         print "no comic?"
 392                                         return False
 393                                 splt = string.split(splt[1], ' <b>by <a href="', 1)
 394                                 title = splt[0];
 395                                 splt = string.split(splt[1], 'a daily webcomic" src="http://www.explosm', 1)
 396                                 if len(splt) < 2:
 397                                         print "a video? Try skipping"
 398                                         return ['skip',next,prev]
 399
 400                                 splt = string.split(splt[1], '"></div><br />', 1)
 401                                 url = "http://www.explosm" + splt[0]
 402                                 splt2 = string.rsplit(url, "/", 1)
 403                                 filename = splt2[1]
 404                                 irow = [comic,number,link,url,filename,title,next,prev]
 405                                 return irow
 406
 407                         splt2 = string.rsplit(url, "/", 1)
 408                         filename = splt2[1]
 409                         irow = [comic,number,link,url,filename,title]
 410                         return irow
 411
 412
 413 # ------------UI
 414
 415 class ComicHomePlugin(hildondesktop.HomePluginItem):
 416         __gtype_name__ = 'ComicHomePlugin'
 417         def __init__(self):
 418                 hildondesktop.HomePluginItem.__init__(self)
 419                 global supports_alpha
 420                 self.set_settings(True)
 421                 self.active_comics = self.get_active_comics()
 422                 self.connect("show-settings", self.show_options)
 423                 self.osso_c = osso.Context("comic-widget", "0.3.0", False)
 424                 self.osso_rpc = osso.Rpc(self.osso_c)
 425                 self.keypointer = 0
 426                 if len(self.active_comics) < 1:
 427                         self.active_comics = ['xkcd']
 428                 self.db = ComicDb(self.active_comics[self.keypointer])
 429                 self.comicname = comics[self.active_comics[self.keypointer]]['name']
 430                 self.set_name = "comicwidget"
 431                 screen = self.get_screen()
 432                 colormap = screen.get_rgba_colormap()
 433                 if colormap == None:
 434                         colormap = screen.get_rgb_colormap()
 435                         supports_alpha = False
 436                 else:
 437                         supports_alpha = True
 438                 self.set_colormap(colormap)
 439                 self.set_app_paintable(True)
 440                 #setup internal area
 441                 self.set_size_request(480, 230)
 442                 self.imgvpos = 0;
 443                 self.vbox = gtk.VBox()
 444                 self.hbox = gtk.HBox()
 445                 self.label = gtk.Label()
 446                 self.label.set_alignment(xalign = 0, yalign = 0.5)
 447                 self.label.set_use_markup(True)
 448                 titl = str(self.db.db[self.db.currentcomic]['title'])
 449                 if len(titl) > 22:
 450                         titl = titl[:19] + "..."
 451                 self.label.set_markup('<span size="12000" face="monospace"> <b>' + self.comicname + '</b> ' + str(self.db.db[self.db.currentcomic]['id']) + '\n ' + titl + '</span>')
 452
 453
 454                 self.e_goweb = gtk.EventBox()
 455                 self.e_goweb.set_name('goweb')
 456                 self.e_goweb.set_size_request(220, 48)
 457                 # e_open is the eventbox for the image. Does nothing, but it's convenient to have it.
 458                 # it will change to be a cairo thing when I have the time.
 459                 self.e_open = gtk.EventBox()
 460                 self.e_open.set_name('open')
 461                 self.e_switch = gtk.EventBox()
 462                 self.e_switch.set_name('switch')
 463                 self.e_switch.set_size_request(48, 48)
 464                 self.e_next = gtk.EventBox()
 465                 self.e_next.set_name('next')
 466                 self.e_next.set_size_request(48, 48)
 467                 self.e_prev = gtk.EventBox()
 468                 self.e_prev.set_name('prev')
 469                 self.e_prev.set_size_request(48, 48)
 470                 self.e_up = gtk.EventBox()
 471                 self.e_up.set_name('up')
 472                 self.e_up.set_size_request(48, 48)
 473                 self.e_down = gtk.EventBox()
 474                 self.e_down.set_name('down')
 475                 self.e_down.set_size_request(48, 48)
 476                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 477                 self.comic_image.show()
 478
 479
 480                 # Preload images into a dictionary, so that we can access them by the names of the eventboxes:
 481
 482                 self.images = {'up0':cairo.ImageSurface.create_from_png(imagedir + "up0-48x48.png"),
 483                                         'up1':cairo.ImageSurface.create_from_png(imagedir + "up1-48x48.png"),
 484                                         'down0':cairo.ImageSurface.create_from_png(imagedir + "down0-48x48.png"),
 485                                         'down1':cairo.ImageSurface.create_from_png(imagedir + "down1-48x48.png"),
 486                                         'next0':cairo.ImageSurface.create_from_png(imagedir + "next0-48x48.png"),
 487                                         'next1':cairo.ImageSurface.create_from_png(imagedir + "next1-48x48.png"),
 488                                         'prev0':cairo.ImageSurface.create_from_png(imagedir + "prev0-48x48.png"),
 489                                         'prev1':cairo.ImageSurface.create_from_png(imagedir + "prev1-48x48.png"),
 490                                         'switch0':cairo.ImageSurface.create_from_png(imagedir + "switch0-48x48.png"),
 491                                         'switch1':cairo.ImageSurface.create_from_png(imagedir + "switch1-48x48.png"),
 492                                         }
 493
 494
 495
 496                 self.e_goweb.add(self.label)
 497                 self.e_goweb.set_events(gtk.gdk.BUTTON_RELEASE_MASK)
 498                 self.e_goweb.connect("button-release-event", self.view_comic)
 499
 500                 self.e_open.add(self.comic_image)
 501
 502                 # self.e_switch.add(self.switch)
 503                 self.e_switch.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 504                 self.e_switch.connect("button-press-event", self.button_press)
 505                 self.e_switch.connect("button-release-event", self.button_release)
 506                 self.e_switch.connect("leave-notify-event", self.button_release)
 507
 508
 509                 # self.e_next.add(self.next)
 510                 self.e_next.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 511                 self.e_next.connect("button-press-event", self.button_press)
 512                 self.e_next.connect("button-release-event", self.button_release)
 513                 self.e_next.connect("leave-notify-event", self.button_release)
 514
 515                 #self.e_prev.add(self.prev)
 516                 self.e_prev.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 517                 self.e_prev.connect("button-press-event", self.button_press)
 518                 self.e_prev.connect("button-release-event", self.button_release)
 519                 self.e_prev.connect("leave-notify-event", self.button_release)
 520
 521                 #self.e_up.add(self.up)
 522                 self.e_up.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 523                 self.e_up.connect("button-press-event", self.button_press)
 524                 self.e_up.connect("button-release-event", self.button_release)
 525                 self.e_up.connect("leave-notify-event", self.button_release)
 526
 527
 528                 #self.e_down.add(self.down)
 529                 self.e_down.set_events(gtk.gdk.BUTTON_PRESS_MASK|gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.LEAVE_NOTIFY)
 530                 self.e_down.connect("button-press-event", self.button_press)
 531                 self.e_down.connect("button-release-event", self.button_release)
 532                 self.e_down.connect("leave-notify-event", self.button_release)
 533
 534                 self.vbox.pack_start(self.e_open,False,False,0)
 535                 self.vbox.pack_end(self.hbox,False,False,0)
 536
 537                 self.hbox.pack_start(self.e_switch,False,False,0)
 538                 self.hbox.pack_start(self.e_goweb,False,False,10)
 539                 self.hbox.pack_end(self.e_next,False,False,0)
 540                 self.hbox.pack_end(self.e_prev,False,False,0)
 541                 self.hbox.pack_end(self.e_down,False,False,0)
 542                 self.hbox.pack_end(self.e_up,False,False,0)
 543                 self.vbox.show_all()
 544                 self.add(self.vbox)
 545
 546         # **************** Cairo draw functions ***************
 547
 548         def realize(self, widget):
 549                 global supports_alpha
 550
 551                 # To check if the display supports alpha channels, get the colormap
 552                 screen = self.get_screen()
 553                 colormap = screen.get_rgba_colormap()
 554                 if colormap == None:
 555                         print 'Your screen does not support alpha channels!'
 556                         colormap = screen.get_rgb_colormap()
 557                         supports_alpha = False
 558                 else:
 559                 #      print 'Your screen supports alpha channels!'
 560                         supports_alpha = True
 561
 562                 # Now we have a colormap appropriate for the screen, use it
 563                 self.set_colormap(colormap)
 564
 565                 return False
 566
 567         def do_expose_event(widget, event):
 568                 cr = widget.window.cairo_create()
 569                 widget.draw(widget.e_up, 0)
 570                 widget.draw(widget.e_down, 0)
 571                 widget.draw(widget.e_prev,0)
 572                 widget.draw(widget.e_next, 0)
 573                 widget.draw(widget.e_switch, 0)
 574 #               widget.writeit(widget.e_goweb, "asdf")
 575                 cr.set_operator(cairo.OPERATOR_OVER)
 576                 region = gtk.gdk.region_rectangle(event.area)
 577                 cr.region(region)
 578                 bg_color=gtk.gdk.color_parse('#000000')
 579                 if supports_alpha:
 580                         cr.set_source_rgba (0.0, 0.0, 0.0, 0.5)
 581                 else:
 582                         cr.set_source_rgb (0.0, 0.0, 0.0)
 583
 584                 cr.fill_preserve()
 585                 return False
 586
 587         # Function that draws a button preloaded in the images dictionary.
 588         def draw(self, target, postfix):
 589                 cr_e = target.window.cairo_create()
 590                 cr_e.set_source_rgba(0.0, 0.0, 0.0, 0.5) # Transparent
 591                 cr_e.set_operator(cairo.OPERATOR_SOURCE)
 592                 cr_e.paint()
 593                 cr_e.set_operator(cairo.OPERATOR_OVER)
 594                 cr_e.set_source_surface(self.images[target.get_name() + str(postfix)], 0, 0)
 595                 cr_e.paint()
 596
 597         # ********** Event handlers *************
 598
 599
 600         # Most events happen on release, so I moved all of them into the same event handler.
 601         def button_release(self, widget, event):
 602                 if event.type == gtk.gdk.BUTTON_RELEASE:
 603                         func = widget.get_name()
 604                         print "pressed: " + func
 605                         if func == 'up':
 606                                 self.e_open.remove(self.comic_image)
 607                                 self.imgvpos = self.imgvpos - 80
 608                                 if self.imgvpos < 0:
 609                                         self.imgvpos = 0
 610                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 611                                 self.e_open.add(self.comic_image)
 612                                 self.e_open.show_all()
 613
 614                         elif func == 'down':
 615                                 self.e_open.remove(self.comic_image)
 616                                 self.imgvpos = self.imgvpos + 80
 617                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 618                                 self.e_open.add(self.comic_image)
 619                                 self.e_open.show_all()
 620
 621                         elif func == 'next':
 622                                 self.db.currentcomic -= 1
 623                                 self.imgvpos = 0
 624                                 self.e_open.remove(self.comic_image)
 625                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 626                                 self.e_open.add(self.comic_image)
 627                                 self.e_open.show_all()
 628                                 self.e_goweb.remove(self.label)
 629                                 titl = str(self.db.db[self.db.currentcomic]['title'])
 630                                 if len(titl) > 22:
 631                                         titl = titl[:19] + "..."
 632                                 self.label.set_markup('<span size="12000" face="monospace"> <b>' + self.comicname + '</b> ' + str(self.db.db[self.db.currentcomic]['id']) + '\n ' + titl + '</span>')
 633                                 self.e_goweb.add(self.label)
 634                                 self.e_goweb.show_all()
 635
 636                         elif func == 'prev':
 637                                 self.db.currentcomic += 1
 638                                 self.imgvpos = 0
 639                                 self.e_open.remove(self.comic_image)
 640                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 641                                 self.e_open.add(self.comic_image)
 642                                 self.e_open.show_all()
 643                                 self.e_goweb.remove(self.label)
 644                                 titl = str(self.db.db[self.db.currentcomic]['title'])
 645                                 if len(titl) > 22:
 646                                         titl = titl[:19] + "..."
 647                                 self.label.set_markup('<span size="12000" face="monospace"> <b>' + self.comicname + '</b> ' + str(self.db.db[self.db.currentcomic]['id']) + '\n ' + titl + '</span>')
 648                                 self.e_goweb.add(self.label)
 649                                 self.e_goweb.show_all()
 650
 651                         elif func == 'switch':
 652                                 self.active_comics = self.get_active_comics()
 653                                 print "active comics: " + str(self.active_comics)
 654                                 self.keypointer = (self.keypointer + 1) % len(self.active_comics)
 655                                 self.imgvpos = 0
 656                                 self.db = []
 657                                 print "switching to " + self.active_comics[self.keypointer]
 658                                 self.comicname = comics[self.active_comics[self.keypointer]]['name']
 659                                 self.db = ComicDb(self.active_comics[self.keypointer])
 660                                 self.e_open.remove(self.comic_image)
 661                                 self.comic_image = self.get_resized_pixmap(self.db.get_comic(), self.imgvpos)
 662                                 self.e_goweb.remove(self.label)
 663                                 titl = str(self.db.db[self.db.currentcomic]['title'])
 664                                 if len(titl) > 22:
 665                                         titl = titl[:19] + "..."
 666                                 self.label.set_markup('<span size="12000" face="monospace"> <b>' + self.comicname + '</b> ' + str(self.db.db[self.db.currentcomic]['id']) + '\n ' + titl + '</span>')
 667                                 self.e_goweb.add(self.label)
 668                                 self.e_goweb.show_all()
 669                                 self.e_open.add(self.comic_image)
 670                                 self.e_open.show_all()
 671
 672                         else:
 673                                 return False
 674                 self.draw(widget, "0")
 675
 676         # this one only switches to pressed button image
 677         def button_press(self, widget, event):
 678                 if not event.type == gtk.gdk.BUTTON_PRESS:
 679                         return False
 680                 self.draw(widget, "1")
 681
 682         # this one cancels a button press when pointer is moved out from it after press.
 683         def button_out(self, widget, event):
 684                 if not event.type == gtk.gdk.BUTTON_PRESS:
 685                         return False
 686                 self.draw(widget, "0")
 687
 688         # no fancy cairo stuff here. simply launches url in browser.
 689         def view_comic(self, widget, event):
 690                 if not event.type == gtk.gdk.BUTTON_RELEASE:
 691                         return False
 692                 link = self.db.get_link()
 693                 self.osso_rpc.rpc_run_with_defaults("osso_browser", "open_new_window", (link,))
 694
 695
 696
 697         # this function modifies the image to fit the widget and then returns it.
 698
 699         def get_resized_pixmap(self, filename, vpos):
 700                 print "vpos: " + str(vpos)
 701
 702                 maxheight = 182
 703
 704                 pixbuf = gtk.gdk.pixbuf_new_from_file(filename)
 705                 parent_buf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, pixbuf.get_has_alpha(), 8, 480, maxheight)
 706                 parent_buf.fill(0xffffffff)
 707                 retimg = gtk.Image()
 708                 # get correct width/height
 709                 new_height = 1
 710                 new_width = 478
 711                 new_height = int((478.0 / pixbuf.get_width()) * pixbuf.get_height())
 712                 scaled_buf = pixbuf.scale_simple(new_width,new_height,gtk.gdk.INTERP_BILINEAR)
 713                 print "scaled height: " + str(scaled_buf.get_height())
 714                 if scaled_buf.get_height() > maxheight:
 715                         if scaled_buf.get_height() - (vpos + maxheight) < 0:
 716                                 vpos = scaled_buf.get_height() - maxheight
 717                         scaled_buf.copy_area(0,vpos,478,maxheight,parent_buf,1,0)
 718                         self.imgvpos = vpos
 719                 else:
 720                         tmpy = maxheight - scaled_buf.get_height()
 721                         if tmpy > 0:
 722                                 tmpy = tmpy / 2
 723
 724                         scaled_buf.copy_area(0,0,478,scaled_buf.get_height(),parent_buf,1,tmpy)
 725                         self.imgvpos = 0
 726                 retimg.set_from_pixbuf(parent_buf)
 727                 print "vpos after fixing image: " + str(self.imgvpos)
 728                 return retimg
 729
 730         def screen_changed(self, widget, old_screen=None):
 731                 global supports_alpha
 732
 733                 # To check if the display supports alpha channels, get the colormap
 734                 screen = self.get_screen()
 735                 colormap = screen.get_rgba_colormap()
 736                 if colormap == None:
 737                         print 'Your screen does not support alpha channels!'
 738                         colormap = screen.get_rgb_colormap()
 739                         supports_alpha = False
 740                 else:
 741                 #      print 'Your screen supports alpha channels!'
 742                         supports_alpha = True
 743
 744                 # Now we have a colormap appropriate for the screen, use it
 745                 self.set_colormap(colormap)
 746
 747                 return False
 748
 749
 750         def get_active_comics(self):
 751                 print "get list"
 752
 753                 if os.path.isfile(activecomics) == True:
 754                         print "found " + activecomics
 755                         dbf = open(activecomics, 'r')
 756                         dbr = csv.reader(dbf)
 757                         try:
 758                                 active = dbr.next()
 759                         except:
 760                                 active = []
 761                         dbf.close()
 762                         return active
 763                 # if not, copy it.
 764                 else:
 765                         print "file " + activecomics + " not found"
 766                         if not os.path.exists(dbdir):
 767                                 print "path not found: " + dbdir
 768                                 try:
 769                                         os.makedirs(dbdir)
 770                                 except:
 771                                         print "settings dir creation failed. Exiting."
 772                                         exit()
 773                         try:
 774 #                               dbf = file(activecomics, 'w')
 775 #                               dbf.close()
 776                                 dbf = open(activecomics, 'w')
 777                         except:
 778                                 print "error storing settings"
 779                                 exit()
 780                         dbw = csv.writer(dbf)
 781                         dbw.writerow(comics.keys())
 782                         print comics.keys()
 783                         dbf.close()
 784                         ret = comics.keys()
 785                         return ret
 786
 787
 788
 789
 790                 #check if settings file exists
 791
 792                 #if not, write defaults
 793
 794 # ************************* OPTION DIALOGS ********************************
 795
 796         def show_options(self, widget):
 797                 dialog = gtk.Dialog("Comic Widget", None, gtk.DIALOG_DESTROY_WITH_PARENT)
 798
 799                 about_button = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
 800                 about_button.set_text("About", "See Author, Copyright and License information")
 801                 about_button.set_alignment(0,0,0,0)
 802                 about_button.connect("clicked", self.show_about)
 803
 804                 comics_button = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
 805                 comics_button.set_text("Comics", "Choose which comics to view")
 806                 comics_button.set_alignment(0,0,0,0)
 807                 comics_button.connect("clicked", self.show_comics)
 808
 809                 dialog.vbox.pack_start(about_button, True, True, 0)
 810                 dialog.vbox.pack_start(comics_button, True, True, 0)
 811
 812                 dialog.show_all()
 813                 dialog.run()
 814                 dialog.destroy()
 815
 816         def show_about(self, widget):
 817                 dialog = gtk.AboutDialog()
 818                 dialog.set_title("About")
 819                 dialog.set_name("Comic widget")
 820                 dialog.set_version(APP_VERSION)
 821                 dialog.set_copyright("Copyright 2010 Marcus Wikstrom")
 822                 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."])
 823                 dialog.set_logo(gtk.gdk.pixbuf_new_from_file("/opt/comic-widget/images/icon2-64x64.png"))
 824                 dialog.set_comments("Silly rabbit, tricks are for kids.")
 825                 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/>.""")
 826                 dialog.set_wrap_license(True)
 827                 dialog.show_all()
 828                 dialog.run()
 829                 dialog.destroy()
 830
 831         def show_comics(self, widget):
 832                 dialog = gtk.Dialog("Configure Search Engines", None, gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_NO_SEPARATOR)
 833                 comiclist = comics.keys()
 834                 comiclist.sort()
 835                 buttonlist = {}
 836                 for comicid in comiclist:
 837                         buttonlist[comicid] = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
 838                         print buttonlist[comicid].get_name()
 839
 840                         print buttonlist[comicid].set_alignment(0, 0.5, 0, 0.5)
 841                         active = False
 842                         for acomic in self.active_comics:
 843                                 if acomic == comicid:
 844                                         active = True
 845                                         break
 846                         if active:
 847                                 buttonlist[comicid].set_text(comics[comicid]['name'] + " *", comicid + ": click to remove")
 848                                 buttonlist[comicid].connect("clicked", self.remove_comic)
 849                         else:
 850                                 buttonlist[comicid].set_text(comics[comicid]['name'], comicid + ": click to add")
 851                                 buttonlist[comicid].connect("clicked", self.add_comic)
 852                         dialog.vbox.pack_start(buttonlist[comicid], True, True, 0)
 853
 854
 855                 dialog.show_all()
 856                 dialog.run()
 857                 dialog.destroy()
 858
 859         def add_comic(self, widget):
 860                 print "add " + widget.get_title()
 861                 splt = string.split(widget.get_value(), ':', 1)
 862                 comicid = splt[0]
 863                 if os.path.isfile(activecomics) == True:
 864                         print "added " + comicid + " to " + str(self.active_comics)
 865                         try:
 866                                 found = self.active_comics.index(comicid)
 867                         except:
 868                                 self.active_comics.append(comicid)
 869                         dbf = open(activecomics, 'w')
 870                         dbw = csv.writer(dbf)
 871                         dbw.writerow(self.active_comics)
 872                         dbf.close()
 873                 widget.set_text(comics[comicid]['name'] + " *", comicid + ": click to remove")
 874
 875         def remove_comic(self, widget):
 876                 print "remove " + widget.get_title()
 877                 if len(self.active_comics) == 1:
 878                         return
 879                 splt = string.split(widget.get_value(), ':', 1)
 880                 comicid = splt[0]
 881                 if os.path.isfile(activecomics) == True:
 882                         print "removing " + comicid + " from " + str(self.active_comics)
 883                         del self.active_comics[self.active_comics.index(comicid)]
 884                         dbf = open(activecomics, 'w')
 885                         dbw = csv.writer(dbf)
 886                         dbw.writerow(self.active_comics)
 887                         dbf.close()
 888                 widget.set_text(comics[comicid]['name'], comicid + ": click to add")
 889
 890 hd_plugin_type = ComicHomePlugin
 891
 892
 893 if __name__ == "__main__":
 894         import gobject
 895         gobject.type_register(hd_plugin_type)
 896         obj = gobject.new(hd_plugin_type, plugin_id="plugin_id")
 897         obj.show_all()
 898         gtk.main()