marvin/view.py

   1 ##
   2 ## view.py
   3 ## Login : <freyes@yoda>
   4 ## Started on  Tue Jul  1 20:51:33 2008 Felipe Reyes
   5 ## $Id$
   6 ##
   7 ## Copyright (C) 2008 Felipe Reyes
   8 ##
   9 ## This file is part of Marvin.
  10 ##
  11 ## Marvin is free software: you can redistribute it and/or modify
  12 ## it under the terms of the GNU General Public License as published by
  13 ## the Free Software Foundation, either version 3 of the License, or
  14 ## (at your option) any later version.
  15 ##
  16 ## Marvin is distributed in the hope that it will be useful,
  17 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ## GNU General Public License for more details.
  20 ##
  21 ## You should have received a copy of the GNU General Public License
  22 ## along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 from marvin.model import Photo, PhotoListStore, connect_to_db, ConfigurationManager
  25
  26 import locale
  27 import gettext
  28 import gobject
  29 import gtk
  30 import gtk.glade
  31 import gtk.gdk
  32 import gnomevfs
  33 import gconf
  34 import threading
  35 import sqlite3
  36 import os
  37 import sys
  38 import shutil
  39 import time
  40 import datetime
  41 try:
  42     import EXIF
  43 except:
  44     curr_dir = os.path.abspath(".")
  45     sys.path.append(curr_dir)
  46     import EXIF
  47
  48 ##logging system
  49 import logging
  50 log = None
  51
  52 ### l18n
  53 APP_NAME = "marvin"
  54 #Get the local directory since we are not installing anything
  55 local_path = os.path.realpath(os.path.dirname(sys.argv[0]))
  56 # Init the list of languages to support
  57 langs = []
  58 #Check the default locale
  59 lc, encoding = locale.getdefaultlocale()
  60 if (lc):
  61     #If we have a default, it's the first in the list
  62     langs = [lc]
  63 # Now lets get all of the supported languages on the system
  64 language = os.environ.get('LANGUAGE', None)
  65 if (language):
  66     langs += language.split(":")
  67
  68 langs += ["es_CL"]
  69
  70 gettext.bindtextdomain(APP_NAME, local_path)
  71 gettext.textdomain(APP_NAME)
  72 # Get the language to use
  73 lang = gettext.translation(APP_NAME, local_path, languages=langs, fallback = True)
  74
  75 _ = lang.gettext
  76 ###
  77
  78 gtk.gdk.threads_init()
  79 wTree = None
  80
  81 from pkg_resources import resource_filename
  82
  83
  84 class MainWindow (object):
  85
  86     def __init__ (self, **kwargs):
  87
  88         self._gladefile = resource_filename("marvin.ui", "marvin.glade")
  89         global wTree
  90         wTree = gtk.glade.XML(self._gladefile, "wnd_main")
  91
  92         signals = {
  93             "on_entry_sql_filter_activate" : self._on_sql_filter_activate,
  94             "on_btn_search_with_filter_clicked" : self._on_search_clicked,
  95             "on_iconview1_selection_changed" : self._on_selection_changed,
  96             "on_wnd_main_delete_event" : self._on_delete_event,
  97             "on_iconview1_item_activated" : self._item_activated,
  98             "on_iconview1_button_press_event" : self._show_popup,
  99             }
 100
 101         wTree.signal_autoconnect(signals)
 102
 103         list_photos = gtk.ListStore(Photo, gtk.gdk.Pixbuf, str)
 104         list_photos.clear()
 105
 106         #setup the iconview and set the model
 107         iconview = wTree.get_widget("iconview1")
 108         iconview.set_model(list_photos)
 109         iconview.set_pixbuf_column(1)
 110         iconview.set_text_column(2)
 111
 112         self._win = wTree.get_widget("wnd_main")
 113         uidef = resource_filename("marvin.ui", "bar.xml")
 114         self._uimanager = gtk.UIManager()
 115         accel_group = self._uimanager.get_accel_group()
 116         self._win.add_accel_group(accel_group)
 117         action_group = gtk.ActionGroup('my_actions')
 118         action_group.add_actions([#TODO:finish actions
 119             ('File', None, _("_File"), None, None, None),
 120             ('ImportPhoto', gtk.STOCK_ADD, _("Import Photos"), "<Control>i", None,
 121              self._on_import_clicked),
 122             ("Quit", gtk.STOCK_QUIT, None, "<Control>q", None,
 123              self._on_quit_clicked),
 124             ("Image", None, _("_Image"), None, None, None),
 125             ('SetAsWallpaper', None, _("Set as wallpaper"), None, None,
 126              self._on_set_wallpaper_clicked),
 127             ])
 128
 129         self._uimanager.insert_action_group(action_group, 0)
 130         self._uimanager.add_ui_from_file(uidef)
 131         box = wTree.get_widget("vbox1")
 132         menubar = self._uimanager.get_widget("/menubar")
 133         box.pack_start(menubar, False)
 134         box.reorder_child(menubar, 0)
 135         toolbar = self._uimanager.get_widget("/toolbar")
 136         box.pack_start(toolbar, False)
 137         box.reorder_child(toolbar, 1)
 138
 139         config = ConfigurationManager()
 140         self._win.set_default_size(config.window_default_size[0],
 141                                    config.window_default_size[1])
 142         self._win.show_all()
 143
 144
 145         # prepare and launch the thread that fills the iconview model
 146         self._thread = PhotoListThread(list_photos)
 147         self._thread.start()
 148
 149     def _show_popup(self, widget, event):
 150         if event.button != 3:
 151             return
 152
 153         iconview = wTree.get_widget("iconview1")
 154         selected_items = iconview.get_selected_items()
 155         item_under_mouse = iconview.get_item_at_pos (int(event.x), int(event.y))[0]
 156
 157         if item_under_mouse not in selected_items:
 158             iconview.unselect_all()
 159             iconview.select_path(item_under_mouse)
 160             selected_items = iconview.get_selected_items()
 161
 162         item = self._uimanager.get_widget("/popup/SetAsWallpaper")
 163         if len(selected_items) != 1:
 164             item.set_sensitive(False)
 165         else:
 166             item.set_sensitive(True)
 167
 168         menu_widget = self._uimanager.get_widget("/popup");
 169
 170         menu_widget.popup(None, None, None, event.button, event.time);
 171         menu_widget.show_all()
 172
 173     def _on_quit_clicked (self, menuitem):
 174         self.quit()
 175
 176     def _on_set_wallpaper_clicked(self, menuitem):
 177
 178         iconview = wTree.get_widget("iconview1")
 179
 180         selected_items = iconview.get_selected_items()
 181
 182         if len(selected_items) != 1:
 183             return
 184
 185         model = iconview.get_model()
 186         iter = model.get_iter(selected_items[0])
 187         photo = model.get(iter, 0)[0]
 188
 189         ConfigurationManager.set_wallpaper(photo.path)
 190
 191     def _on_import_clicked(self, menuitem):
 192         ImportWindow()
 193
 194     def _on_sql_filter_activate(self, entry):
 195         button = wTree.get_widget("btn_search_with_filter")
 196         button.clicked()
 197
 198     def _on_search_clicked(self, button):
 199         """
 200
 201         Arguments:
 202         - `self`:
 203         - `button`:
 204         """
 205         model = wTree.get_widget("iconview1").get_model()
 206
 207         entry = wTree.get_widget("entry_sql_filter")
 208         sql_filter = entry.get_text()
 209
 210         query = "select id, uri from photos " + sql_filter
 211
 212         if not self._thread.stop.isSet():
 213             self._thread.stop.set()
 214         thread = PhotoListThread(model, query)
 215         thread.start()
 216
 217     def _on_selection_changed(self, iconview):
 218         """
 219
 220         Arguments:
 221         - `self`:
 222         - `iconview`:
 223         """
 224         num_selec_items = len(iconview.get_selected_items())
 225         if num_selec_items == 1:
 226
 227             lbl = wTree.get_widget("lbl_original_date")
 228
 229             model = iconview.get_model()
 230             iter = model.get_iter(iconview.get_selected_items()[0])
 231             photo = model.get(iter, 0)[0]
 232             str_date = photo.original_date.strftime("%x")
 233             lbl.set_text(_("Original Date %s" % str_date))
 234
 235             lbl = wTree.get_widget("lbl_tags")
 236
 237             lbl.set_text(str(photo.tags))
 238         elif num_selec_items == 0:
 239             wTree.get_widget("lbl_original_date").set_text("")
 240             wTree.get_widget("lbl_tags").set_text("")
 241
 242     def _item_activated(self, iconview, path):
 243
 244         store = iconview.get_model()
 245         iter = store.get_iter(path)
 246         photo = store.get_value (iter, 0)
 247
 248         ImageWindow(photo, iconview)
 249
 250     def _on_delete_event (self, widget, event):
 251         self.quit()
 252
 253     def quit(self):
 254         config = ConfigurationManager()
 255         win = wTree.get_widget("wnd_main")
 256         config.window_default_size = win.get_size()
 257         gtk.main_quit()
 258
 259 class ImageWindow:
 260
 261     def __init__(self, photo, iconview):
 262
 263         self.fullscreen = False
 264
 265         self._wTree = gtk.glade.XML(resource_filename("marvin.ui", "marvin.glade"), "wnd_display_img")
 266
 267         signals = {
 268             "on_wnd_display_img_window_state_event": self._on_window_state_event,
 269             "on_wnd_display_img_delete_event" : self._on_delete_event,
 270             "on_wnd_display_img_key_press_event" : self._on_key_press,
 271             }
 272         self._wTree.signal_autoconnect (signals)
 273
 274         self.img_widget = self._wTree.get_widget("img")
 275
 276         self.iconview = iconview
 277         self.photo = photo
 278         self.path = gnomevfs.get_local_path_from_uri (self.photo.uri)
 279
 280         win = self._wTree.get_widget("wnd_display_img")
 281         win.set_size_request (800, 600)
 282         win.show_all()
 283
 284         self.update_image()
 285
 286     def _on_delete_event(self, widget, event):
 287         """
 288
 289         Arguments:
 290         - `self`:
 291         - `widget`:
 292         - `event`:
 293         """
 294         pass
 295
 296     def _on_window_state_event (self, widget, event):
 297         "This method should be used for the fullscreen functinality"
 298         pass
 299
 300
 301     def _on_key_press(self, widget, event):
 302         """Handle the key press event of the image window
 303
 304         Arguments:
 305         - `self`:
 306         - `widget`:
 307         - `event`:
 308         """
 309         model = self.iconview.get_model()
 310
 311         iter = model.get_iter(self.iconview.get_selected_items()[0])
 312
 313         str_key = gtk.gdk.keyval_name(event.keyval)
 314
 315         if str_key == 'Right' or str_key == 'Down':
 316             iter_next = model.iter_next(iter)
 317
 318             if iter_next == None:
 319                 iter_next = model.get_iter_first()
 320
 321             self.update_iconview(iter_next)
 322
 323         elif str_key == 'Left' or str_key == 'Up':
 324             int_path = int(model.get_string_from_iter(iter)) - 1
 325             if int_path < 0:
 326                 int_path = 0
 327             str_path = str("%d" % (int_path))
 328
 329             iter_next = model.get_iter_from_string(str_path)
 330
 331             self.update_iconview(iter_next)
 332
 333         elif str_key == 'plus':
 334             self.zoom(1.1)
 335
 336         elif str_key == 'minus':
 337             self.zoom(0.9)
 338
 339         elif str_key == '1':
 340             self.update_image(False)
 341
 342         elif str_key == 'F11':
 343             win = self._wTree.get_widget("wnd_display_img")
 344             if self.fullscreen:
 345                 win.unfullscreen()
 346                 self.fullscreen =False
 347             else:
 348                 win.fullscreen()
 349                 self.fullscreen = True
 350
 351         elif str_key.lower() == 's':
 352             self.update_image()
 353
 354         elif str_key == 'Escape':
 355             win = self._wTree.get_widget("wnd_display_img")
 356             win.destroy()
 357             return
 358         else:
 359             print str_key
 360             return
 361
 362
 363     def zoom(self, factor):
 364
 365         curr_width = self.pixbuf.get_width()
 366         curr_height = self.pixbuf.get_height()
 367         scaled_pixbuf = self.pixbuf.scale_simple(int(curr_width*factor), int(curr_height*factor), gtk.gdk.INTERP_BILINEAR)
 368
 369         self.pixbuf = scaled_pixbuf
 370         self.img_widget.set_from_pixbuf(self.pixbuf)
 371
 372
 373     def update_iconview(self, iter_next):
 374
 375         self.photo = model.get(iter_next, 0)[0]
 376         self.path = gnomevfs.get_local_path_from_uri (self.photo.uri)
 377
 378         self.update_image()
 379         str_path = model.get_string_from_iter(iter_next)
 380         self.iconview.select_path(str_path)
 381
 382     def update_image(self, to_wnd_size=True):
 383
 384         if (to_wnd_size):
 385             win = self._wTree.get_widget("wnd_display_img")
 386             size = win.get_size()
 387             self.pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(self.path, size[0], size[1])
 388         else:
 389             self.pixbuf = gtk.gdk.pixbuf_new_from_file(self.path)
 390
 391         self.img_widget.set_from_pixbuf(self.pixbuf)
 392
 393 class PhotoListThread (threading.Thread):
 394
 395     def __init__ (self, model, query=None, use_progressbar=False):
 396         super(PhotoListThread, self).__init__()
 397
 398         if query is not None:
 399             self._query = query
 400         else:
 401             self._query = "select id, uri from photos order by time desc limit 10"
 402
 403         self._model = model
 404
 405     def run (self):
 406
 407         inicio = datetime.datetime.now()
 408
 409         global wTree
 410
 411         gtk.gdk.threads_enter()
 412         progressbar = wTree.get_widget("progressbar1")
 413         progressbar.show()
 414         self._model.clear()
 415         gtk.gdk.threads_leave()
 416
 417         conn = connect_to_db()
 418         c = conn.cursor()
 419         c.execute (self._query)
 420         i=0
 421         for row in c:
 422
 423             gtk.gdk.threads_enter()
 424             i += 1
 425             try:
 426                 p = Photo(row[0], row[1])
 427                 self._model.append([p,
 428                                     p.pixbuf,
 429                                     p.original_date.date().strftime("%x")])
 430             except:
 431                 pass
 432
 433             progressbar.pulse()
 434             gtk.gdk.threads_leave()
 435
 436         gtk.gdk.threads_enter()
 437         Progressbar.push_message(_("%d pictures found.") % (i))
 438         conn.close()
 439         progressbar.hide()
 440         gtk.gdk.threads_leave()
 441
 442         fin = datetime.datetime.now()
 443         print "Took %s load the pictures" % (fin-inicio)
 444
 445 class Progressbar(object):
 446
 447     @classmethod
 448     def push_message(cls, msg, context="marvin"):
 449         statusbar = wTree.get_widget("statusbar1")
 450         context_id = statusbar.get_context_id(context)
 451         msg_id = statusbar.push(context_id, msg)
 452         gobject.timeout_add(10000,Progressbar.remove_from_statusbar,context_id, msg_id)
 453
 454     @classmethod
 455     def remove_from_statusbar(cls, context_id, msg_id):
 456         statusbar = wTree.get_widget("statusbar1")
 457         statusbar.remove(context_id, msg_id)
 458
 459         return False #stop being called by gobject.timeout_add
 460
 461
 462 class ImportWindow(object):
 463     """
 464     """
 465
 466     def __init__(self):
 467         """
 468         """
 469         self._thread = None
 470         glade_file = resource_filename("marvin.ui", "marvin.glade")
 471         self._wTree = gtk.glade.XML(glade_file, "wnd_photo_import")
 472
 473         signals = {
 474             "on_checkbtn_include_subdirs_toggled" : self._on_include_subdir_toggled,
 475             "on_chooserbtn_dir_to_import_current_folder_changed" : self._on_folder_changed,
 476             "on_btn_accept_clicked" : self._on_accept_clicked,
 477             }
 478
 479         self._wTree.signal_autoconnect(signals)
 480
 481         list_photos = gtk.ListStore(Photo, gtk.gdk.Pixbuf, str)
 482         list_photos.clear()
 483         iconview = self._wTree.get_widget("iconview_preview")
 484         iconview.set_model(list_photos)
 485         iconview.set_pixbuf_column(1)
 486         iconview.set_text_column(2)
 487
 488         win = self._wTree.get_widget("wnd_photo_import")
 489         win.show_all()
 490
 491     def _on_folder_changed(self, widget):
 492         self.refresh_iconview()
 493
 494     def _on_include_subdir_toggled(self, togglebutton):
 495         self.refresh_iconview()
 496
 497     def refresh_iconview(self):
 498
 499         uris_list = list()
 500
 501         uri = self._wTree.get_widget("chooserbtn_dir_to_import").get_current_folder_uri()
 502         selected_path= gnomevfs.get_local_path_from_uri(uri)
 503         model = self._wTree.get_widget("iconview_preview").get_model()
 504
 505         recursive = self._wTree.get_widget("checkbtn_include_subdirs").get_active()
 506
 507         if recursive:
 508             for root, dirs, files in os.walk(selected_path):
 509                 for name in files:
 510                     uri = "file://" + str(root) + "/" + str(name)
 511                     if gnomevfs.get_mime_type(uri) == "image/jpeg":
 512                         uris_list.append(uri)
 513         else:
 514             for name in os.listdir(selected_path):
 515                 uri = "file://" + str(selected_path) + "/" + str(name)
 516                 if gnomevfs.get_mime_type(uri) == "image/jpeg":
 517                     uris_list.append(uri)
 518
 519         if (self._thread is not None) and (not self._thread.is_stopped()):
 520             self._thread.stop()
 521
 522         self._thread = PhotoPreviewThread(model, uris_list)
 523         self._thread.start()
 524
 525     def _on_accept_clicked(self, button):
 526
 527         self._wTree.get_widget("wnd_photo_import").set_sensitive(False)
 528
 529         iconview = self._wTree.get_widget("iconview_preview")
 530         model = iconview.get_model()
 531
 532         list_of_photos = list()
 533
 534         if len(iconview.get_selected_items()) == 0:
 535             iter = model.get_iter_first()
 536
 537             while (iter is not None):
 538                 list_of_photos.append(model.get(iter, 0)[0])
 539                 iter = model.iter_next(iter)
 540
 541         else:
 542             selected_items = iconview.get_selected_items()
 543             for path in selected_items:
 544                 iter = model.get_iter(path)
 545                 list_of_photos.append(model.get(iter, 0)[0])
 546
 547         copy_to_photodir = self._wTree.get_widget("checkbtn_copy").get_active()
 548         progressbar = self._wTree.get_widget("progressbar_import")
 549         thread = ImportPhotoThread(list_of_photos, copy_to_photodir, progressbar)
 550         thread.start()
 551
 552 class ImportPhotoThread(threading.Thread):
 553
 554     def __init__(self, list_of_photos, copy_to_photodir, progressbar):
 555         super(ImportPhotoThread, self).__init__()
 556
 557         self._photos = list_of_photos
 558         self._copy_to_photodir = copy_to_photodir
 559         self._progressbar = progressbar
 560
 561     def run(self):
 562         self._conn = connect_to_db()
 563         self._c = self._conn.cursor()
 564
 565         self._progressbar.show()
 566         i = 0
 567         total = float(len(self._photos))
 568         for photo in self._photos:
 569             i += 1
 570             self._import (photo, self._copy_to_photodir)
 571             self._progressbar.set_fraction(i/total)
 572             self._progressbar.set_text(_("Imported %d of %d") % (i, int(total)))
 573
 574         self._conn.commit()
 575         self._conn.close()
 576
 577         win = self._progressbar.get_toplevel()
 578         win.destroy()
 579
 580     def _import (self, photo, copy_to_photodir):
 581
 582         if copy_to_photodir:
 583             new_uri = self._copy_photo(photo.uri)
 584         else:
 585             new_uri = photo.uri
 586
 587         self._c.execute("""insert into photos(uri, time, description, roll_id, default_version_id, rating)
 588         values (?, ?, '', 0, 1, 0)""", (new_uri, time.mktime(photo.original_date.timetuple()),))
 589
 590     def _copy_photo(self, uri):
 591
 592         base = "/apps/f-spot/import"
 593         client = gconf.client_get_default()
 594         client.add_dir(base, gconf.CLIENT_PRELOAD_NONE)
 595         root_photo_dir = client.get_string(base + "/storage_path")
 596
 597         src_path = gnomevfs.get_local_path_from_uri(uri)
 598         f = open(src_path, 'rb')
 599         tags = EXIF.process_file(f, stop_tag='DateTimeOriginal')
 600
 601         if tags.has_key('EXIF DateTimeOriginal'):
 602             (aux_date, aux_time) = str(tags['EXIF DateTimeOriginal']).split(' ')
 603             (year, month, day) = aux_date.split(':')
 604
 605         else:
 606             mtime = time.localtime(os.path.getmtime(src_path))
 607             year = str(mtime[0])
 608             moth = str(mtime[1])
 609             day = str(mtime[2])
 610
 611
 612         destdir = os.path.join(root_photo_dir, year, month, day)
 613         list_dir = (os.path.join(root_photo_dir, year),
 614                     os.path.join(root_photo_dir, year, month),
 615                     os.path.join(root_photo_dir, year, month, day))
 616         for aux_path in list_dir:
 617             if not os.path.exists(aux_path):
 618                 os.mkdir(aux_path)
 619
 620         if os.path.exists(os.path.join(destdir, os.path.basename(src_path))):
 621             aux = os.path.basename(src_path).rsplit('.', 1)
 622             suff = str(time.localtime()[3]) + str(time.localtime()[4])
 623             destdir = os.path.join(destdir, aux[0] + suff + aux[1])
 624         else:
 625             destdir = os.path.join(destdir, os.path.basename(src_path))
 626
 627         shutil.copyfile(src_path, destdir)
 628
 629         return "file://" + destdir #returns the destination uri
 630
 631 class PhotoPreviewThread(threading.Thread):
 632
 633     def __init__(self, model, uris):
 634         super(PhotoPreviewThread, self).__init__()
 635
 636         self._model = model
 637         self._uris = uris
 638         self._stop = False
 639         self._stopped = True
 640
 641     def run(self):
 642         self._stopped = False
 643         self._model.clear()
 644
 645         for uri in self._uris:
 646             if self._stop:
 647                 self._stopped = True
 648                 self._stop = False
 649                 return
 650
 651             photo = Photo(-1, uri, 150)
 652             self._model.append([photo,
 653                                 photo.pixbuf,
 654                                 photo.original_date.date().strftime("%x")])
 655
 656     def stop(self):
 657         self._stop = True
 658
 659     def is_stopped(self):
 660         return self._stopped
 661
 662 def setup_log():
 663     # code adapted from
 664     # http://docs.python.org/lib/multiple-destinations.html example
 665     # set up logging to file - see previous section for more details
 666     logging.basicConfig(level=logging.DEBUG,
 667                         #format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
 668                         format='%(levelname)-8s %(message)s',
 669                         datefmt='%m-%d %H:%M')
 670     # define a Handler which writes INFO messages or higher to the sys.stderr
 671     console = logging.StreamHandler()
 672     console.setLevel(logging.INFO)
 673     # set a format which is simpler for console use
 674     formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
 675     # tell the handler to use this format
 676     console.setFormatter(formatter)
 677     # add the handler to the root logger
 678     logging.getLogger('').addHandler(console)
 679
 680
 681 def start_import(run_main_loop=True):
 682
 683     ImportWindow()
 684
 685     if run_main_loop:
 686         setup_log()
 687
 688         gobject.set_application_name(_("Photo collection manager"))
 689         gobject.set_prgname("marvin")
 690
 691         gtk.main()
 692
 693 def start():
 694     """
 695     """
 696     setup_log()
 697     log = logging.getLogger('view')
 698
 699     gobject.set_application_name(_("Photo collection manager"))
 700     gobject.set_prgname("marvin")
 701
 702     wnd = MainWindow()
 703
 704     gtk.gdk.threads_enter()
 705     gtk.main()
 706     gtk.gdk.threads_leave()
 707
 708
 709 if __name__ == '__main__':
 710     start()