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