def update_bytag_combo_ids(self):
self.bytag_combo_ids = {}
self.bytag_combo_ids[0] = 0
i = 1
tags = Select(self.db.Tag.c, order_by='name')
for tag in tags.execute().fetchall():
self.bytag_combo_ids[i] = tag.tag_id
i += 1
def update_loanedto_combo_ids(self):
self.loanedto_combo_ids = {}
self.loanedto_combo_ids[0] = 0
i = 1
persons = Select(self.db.Person.c, order_by='name')
for person in persons.execute().fetchall():
self.loanedto_combo_ids[i] = person.person_id
i += 1
def update_collection_combo_ids(self):
self.collection_combo_ids = {}
self.collection_combo_ids[0] = 0
i = 1
collections = Select(self.db.Collection.c, order_by='name')
for collection in collections.execute().fetchall():
self.collection_combo_ids[i] = collection.collection_id
i += 1
def update_volume_combo_ids(self):
self.volume_combo_ids = {}
self.volume_combo_ids[0] = 0
i = 1
volumes = Select(self.db.Volume.c, order_by='name')
for volume in volumes.execute().fetchall():
self.volume_combo_ids[i] = volume.volume_id
i += 1
def run(self, name):
"""Import movies, function called in a loop over source files"""
from add import validate_details, edit_movie
from gutils import find_next_available
from sqlalchemy import Select, func
import gtk
if not self.set_source(name):
self.debug.show("Can't read data from file %s" % name)
return False
self.widgets['pwindow'].show()
while gtk.events_pending(): # give GTK some time for updates
gtk.main_iteration()
# progressbar
update_on = []
count = self.count_movies()
if count > 0:
for i in range(0,100):
update_on.append(int(float(i)/100*count))
statement = Select( [ func.max(self.db.Movie.c.number) ] )
number = statement.execute().fetchone()[0]
if number is None:
number = 1
else:
number += 1
statement = Select([self.db.Movie.c.number])
processed = 0
while self._abort is False:
details = self.get_movie_details()
if details is None:
break
processed += 1
if processed in update_on:
self.widgets['progressbar'].set_fraction(float(processed)/float(count))
gtk.main_iteration()
self.widgets['progressbar'].set_text("%s (%s/%s)" % (str(self.imported), str(processed), str(count)))
gtk.main_iteration()
gtk.main_iteration() # extra iteration for abort button
if (details.has_key('o_title') and details['o_title']) or (details.has_key('title') and details['title']):
if details.has_key('o_title') and details['o_title']:
statement.whereclause = func.lower(self.db.Movie.c.o_title)==details['o_title'].lower()
if details.has_key('title') and details['title']:
statement.append_whereclause( func.lower(self.db.Movie.c.title)==details['title'].lower() )
tmp = statement.execute().fetchone()
if tmp is not None:
self.debug.show("movie already exists (number=%s, o_title=%s)" % (tmp.number, details['o_title']))
continue
elif details.has_key('title') and details['title']:
statement.whereclause = func.lower(self.db.Movie.c.title)==details['title'].lower()
tmp = statement.execute().fetchone()
if tmp is not None:
self.debug.show("movie already exists (number=%s, title=%s)" % (tmp.number, details['title']))
continue
validate_details(details, self.fields_to_import)
if self.edit is True:
response = edit_movie(self.parent, details) # FIXME: wait until save or cancel button pressed
if response == 1:
self.imported += 1
else:
if not details.has_key('number') or (details.has_key('number') and details['number'] is None):
#details['number'] = find_next_available(self.db)
details['number'] = number
number += 1
#movie = self.db.Movie()
#movie.add_to_db(details)
try:
self.db.Movie.mapper.mapped_table.insert().execute(details)
self.imported += 1
except Exception, e:
self.debug.show("movie details are not unique, skipping: %s" % str(e))
else:
self.debug.show('skipping movie without title or original title')
def populate(self, movies=None, where=None):#{{{
if self.initialized is False:
return False
from sqlalchemy import Select, desc
if movies is None:
movies = Select([self.db.Movie.c.number,
self.db.Movie.c.o_title, self.db.Movie.c.title,
self.db.Movie.c.director, self.db.Movie.c.image,
self.db.Movie.c.genre, self.db.Movie.c.seen,
self.db.Movie.c.year, self.db.Movie.c.runtime,
self.db.Movie.c.rating])
if isinstance(movies, Select):
if not where: # because of possible 'seen', 'loaned', 'collection_id' in where
# seen / loaned
loaned_only = self.widgets['menu']['loaned_movies'].get_active()
not_seen_only = self.widgets['menu']['not_seen_movies'].get_active()
if loaned_only:
movies.append_whereclause(self.db.Movie.c.loaned==True)
if not_seen_only:
movies.append_whereclause(self.db.Movie.c.seen==False)
# collection
pos = self.widgets['filter']['collection'].get_active()
if pos >= 0:
col_id = self.collection_combo_ids[pos]
if col_id > 0:
movies.append_whereclause(self.db.Movie.c.collection_id==col_id)
# volume
pos = self.widgets['filter']['volume'].get_active()
if pos >= 0:
vol_id = self.volume_combo_ids[pos]
if vol_id > 0:
movies.append_whereclause(self.db.Movie.c.volume_id==vol_id)
# loaned to
pos = self.widgets['filter']['loanedto'].get_active()
if pos >= 0:
per_id = self.loanedto_combo_ids[pos]
if per_id > 0:
from sqlalchemy import join, exists, and_
loan_exists = exists([self.db.Loan.c.movie_id], \
and_(self.db.Movie.c.movie_id==self.db.Loan.c.movie_id, self.db.Loan.c.person_id==per_id, self.db.Loan.c.return_date==None))
movies.append_whereclause(loan_exists)
#loan_join = join(self.db.metadata.tables['movies'], \
# self.db.metadata.tables['loans'], \
# self.db.metadata.tables['movies'].c.movie_id==self.db.metadata.tables['loans'].c.movie_id)
#movies = movies.select_from(loan_join)
# tag
pos = self.widgets['filter']['tag'].get_active()
if pos >= 0:
tag_id = self.bytag_combo_ids[pos]
if tag_id > 0:
from sqlalchemy import join, exists, and_
tag_exists = exists([self.db.MovieTag.c.movie_id], \
and_(self.db.Movie.c.movie_id==self.db.MovieTag.c.movie_id, self.db.MovieTag.c.tag_id==tag_id))
movies.append_whereclause(tag_exists)
# select sort column
sort_column_name = self.config.get('sortby', 'number', section='mainlist')
sort_reverse = self.config.get('sortby_reverse', False, section='mainlist')
for i in sort_column_name.split(','):
if self.db.Movie.c.has_key(i):
if sort_reverse:
movies.order_by_clause.append(desc(self.db.Movie.c[i]))
else:
movies.order_by_clause.append(self.db.Movie.c[i])
# additional whereclause (volume_id, collection_id, ...)
if where:
for i in where:
if self.db.Movie.c.has_key(i):
movies.append_whereclause(self.db.Movie.c[i]==where[i])
movies = movies.execute().fetchall()
self.total = len(movies)
# disable refreshing while inserting
self.widgets['treeview'].freeze_child_notify()
self.widgets['treeview'].set_model(None)
# save user sort column
sort_column_id, order = self.treemodel.get_sort_column_id()
# new treemodel (faster and prevents some problems)
self.treemodel = gtk.TreeStore(str, gtk.gdk.Pixbuf, str, str, str, str, bool, str, str, int)
# check preferences to hide or show columns
if self.config.get('number', True, 'mainlist') == True:
self.number_column.set_visible(True)
else:
self.number_column.set_visible(False)
if self.config.get('otitle', True, 'mainlist') == True:
self.otitle_column.set_visible(True)
else:
self.otitle_column.set_visible(False)
if self.config.get('title', True, 'mainlist') == True:
self.title_column.set_visible(True)
else:
self.title_column.set_visible(False)
if self.config.get('director', True, 'mainlist') == True:
self.director_column.set_visible(True)
else:
self.director_column.set_visible(False)
if self.config.get('image', True, 'mainlist') == True:
self.image_column.set_visible(True)
else:
self.image_column.set_visible(False)
if self.config.get('genre', True, 'mainlist') == True:
self.genre_column.set_visible(True)
else:
self.genre_column.set_visible(False)
if self.config.get('seen', True, 'mainlist') == True:
self.seen_column.set_visible(True)
else:
self.seen_column.set_visible(False)
if self.config.get('year', True, 'mainlist') == True:
self.year_column.set_visible(True)
else:
self.year_column.set_visible(False)
if self.config.get('runtime', True, 'mainlist') == True:
self.runtime_column.set_visible(True)
else:
self.runtime_column.set_visible(False)
if self.config.get('rating', True, 'mainlist') == True:
self.rating_column.set_visible(True)
else:
self.rating_column.set_visible(False)
for movie in movies:
myiter = self.treemodel.append(None)
self.treemodel.set_value(myiter,0,'%004d' % int(movie.number))
if self.config.get('image', True, section='mainlist') == True:
tmp_dest = self.locations['posters']
tmp_img = os.path.join(tmp_dest, "t_%s.jpg" % str(movie.image))
if movie.image and os.path.isfile(tmp_img):
image_path = tmp_img
else:
image_path = os.path.join(self.locations['images'], 'default_thumbnail.png')
# lets see if we have a scaled down thumbnail already created
if os.path.isfile(os.path.join(tmp_dest, "t_%s.jpg" % str(movie.image))):
pass
else:
# if not, lets make one for future use :D
original_image = os.path.join(tmp_dest, "%s.jpg" % movie.image)
if os.path.isfile(original_image):
gutils.make_thumbnail(self, "%s.jpg" % movie.image)
else:
self.Image.set_from_file("%s/default_thumbnail.png" % self.locations['images'])
pixbuf = self.Image.get_pixbuf()
self.Image.set_from_file(image_path)
pixbuf = self.Image.get_pixbuf()
self.treemodel.set_value(myiter, 1, pixbuf)
self.treemodel.set_value(myiter,2,movie.o_title)
self.treemodel.set_value(myiter,3,movie.title)
self.treemodel.set_value(myiter,4,movie.director)
self.treemodel.set_value(myiter,5,movie.genre)
self.treemodel.set_value(myiter,6,movie.seen)
if movie.year is not None and isinstance(movie.year, int):
self.treemodel.set_value(myiter,7,movie.year)
if movie.runtime is not None and isinstance(movie.runtime, int):
self.treemodel.set_value(myiter,8, '%003d' % movie.runtime + _(' min'))
if movie.rating is not None and isinstance(movie.rating, int):
self.treemodel.set_value(myiter,9,movie.rating)
# restore user sort column
if sort_column_id is not None:
self.treemodel.set_sort_column_id(sort_column_id, gtk.SORT_ASCENDING)
# add new treemodel and allow refreshs again
self.widgets['treeview'].set_model(self.treemodel)
self.widgets['treeview'].thaw_child_notify()
self.widgets['treeview'].set_cursor_on_cell(0)
self.count_statusbar()
def populate(self, movies=None, where=None):#{{{
if self.initialized is False:
return False
from sqlalchemy import Select, desc
if movies is None:
movies = Select([self.db.Movie.c.number,
self.db.Movie.c.o_title, self.db.Movie.c.title,
self.db.Movie.c.director, self.db.Movie.c.image])
if isinstance(movies, Select):
if not where: # because of possible 'seen', 'loaned', 'collection_id' in where
# seen / loaned
loaned_only = self.widgets['menu']['loaned_movies'].get_active()
not_seen_only = self.widgets['menu']['not_seen_movies'].get_active()
if loaned_only:
movies.append_whereclause(self.db.Movie.c.loaned==True)
if not_seen_only:
movies.append_whereclause(self.db.Movie.c.seen==False)
# collection
col_id = self.collection_combo_ids[self.widgets['filter']['collection'].get_active()]
if col_id > 0:
movies.append_whereclause(self.db.Movie.c.collection_id==col_id)
# select sort column
sort_column_name = self.config.get('sortby', 'number')
sort_reverse = self.config.get('sortby_reverse', False)
for i in sort_column_name.split(','):
if self.db.Movie.c.has_key(i):
if sort_reverse:
movies.order_by_clause.append(desc(self.db.Movie.c[i]))
else:
movies.order_by_clause.append(self.db.Movie.c[i])
# additional whereclause (volume_id, collection_id, ...)
if where:
for i in where:
if self.db.Movie.c.has_key(i):
movies.append_whereclause(self.db.Movie.c[i]==where[i])
movies = movies.execute().fetchall()
self.total = len(movies)
# disable refreshing while inserting
self.widgets['treeview'].freeze_child_notify()
self.widgets['treeview'].set_model(None)
# save user sort column
sort_column_id, order = self.treemodel.get_sort_column_id()
# new treemodel (faster and prevents some problems)
self.treemodel = gtk.TreeStore(str, gtk.gdk.Pixbuf, str, str, str)
# check preferences to hide or show columns
if self.config.get('view_number', 'True') == 'True':
self.number_column.set_visible(True)
else:
self.number_column.set_visible(False)
if self.config.get('view_otitle', 'True') == 'True':
self.otitle_column.set_visible(True)
else:
self.otitle_column.set_visible(False)
if self.config.get('view_title', 'True') == 'True':
self.title_column.set_visible(True)
else:
self.title_column.set_visible(False)
if self.config.get('view_director', 'True') == 'True':
self.director_column.set_visible(True)
else:
self.director_column.set_visible(False)
if self.config.get('view_image', 'True') == 'True':
self.image_column.set_visible(True)
else:
self.image_column.set_visible(False)
for movie in movies:
myiter = self.treemodel.append(None)
self.treemodel.set_value(myiter,0,'%004d' % int(movie.number))
if self.config.get('view_image', 'True') == 'True':
tmp_dest = self.locations['posters']
tmp_img = os.path.join(tmp_dest, "t_%s.jpg" % str(movie.image))
if movie.image and os.path.isfile(tmp_img):
image_path = tmp_img
else:
image_path = os.path.join(self.locations['images'], 'default_thumbnail.png')
# lets see if we have a scaled down thumbnail already created
if os.path.isfile(os.path.join(tmp_dest, "t_%s.jpg" % str(movie.image))):
pass
else:
# if not, lets make one for future use :D
original_image = os.path.join(tmp_dest, "%s.jpg" % movie.image)
if os.path.isfile(original_image):
gutils.make_thumbnail(self, "%s.jpg" % movie.image)
else:
self.Image.set_from_file("%s/default_thumbnail.png" % self.locations['images'])
pixbuf = self.Image.get_pixbuf()
self.Image.set_from_file(image_path)
pixbuf = self.Image.get_pixbuf()
self.treemodel.set_value(myiter, 1, pixbuf)
self.treemodel.set_value(myiter,2,movie.o_title)
self.treemodel.set_value(myiter,3,movie.title)
self.treemodel.set_value(myiter,4,movie.director)
# restore user sort column
if sort_column_id is not None:
self.treemodel.set_sort_column_id(sort_column_id, gtk.SORT_ASCENDING)
# add new treemodel and allow refreshs again
self.widgets['treeview'].set_model(self.treemodel)
self.widgets['treeview'].thaw_child_notify()
self.widgets['treeview'].set_cursor_on_cell(0)
def export_simple_pdf(self):
"""exports a simple movie list to a pdf file"""
if self.config.get('font', '') != '':
self.fontName = 'custom_font'
pdfmetrics.registerFont(TTFont(self.fontName, self.config.get('font', '')))
else:
self.fontName = "Helvetica"
basedir = None
if not self.config is None:
basedir = self.config.get('export_dir', None, section='export-pdf')
if basedir is None:
filename = gutils.file_chooser(_("Export a PDF"), action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_SAVE,gtk.RESPONSE_OK),name="griffith_simple_list.pdf")
else:
filename = gutils.file_chooser(_("Export a PDF"), action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_SAVE,gtk.RESPONSE_OK),name="griffith_simple_list.pdf",folder=basedir)
if filename is not False and filename[0]:
if not self.config is None and filename[1]:
self.config.set('export_dir', filename[1], section='export-pdf')
self.config.save()
overwrite = None
pdffilename = filename[0].decode('utf-8')
if os.path.isfile(pdffilename):
response = gutils.question(self,_("File exists. Do you want to overwrite it?"),1,self.parent)
if response==-8:
overwrite = True
else:
overwrite = False
if overwrite == True or overwrite is None:
# filename encoding
defaultLang, defaultEnc = getdefaultlocale()
if defaultEnc is None:
defaultEnc = 'UTF-8'
c = SimpleDocTemplate(pdffilename.encode(defaultEnc))
# data encoding
#if defaultEncoding == 'WinAnsiEncoding':
# defaultEnc = 'cp1252'
#else:
defaultEnc = 'utf-8'
style = self.styles["Normal"]
Story = [Spacer(1,2*inch)]
# define some custom stylesheetfont
total = self.db.Movie.count()
p = Paragraph("<font name='" + self.fontName +"' size=\"18\">" + saxutils.escape((_("List of films")).encode('utf-8')) + '</font>', self.styles["Heading1"] )
Story.append(p)
Story.append(Paragraph(" ",style))
p = Paragraph("<font name='" + self.fontName +"' size=\"10\">" + saxutils.escape((_("Total Movies: %s") % str(total)).encode('utf-8')) + '</font>', self.styles["Heading3"])
Story.append(p)
Story.append(Paragraph(" ",style))
movies = Select(self.db.Movie.c)
# select sort column
sort_column_name = self.config.get('sortby', 'number', section='mainlist')
sort_reverse = self.config.get('sortby_reverse', False, section='mainlist')
do_grouping = True
for i in sort_column_name.split(','):
if i != 'title' and i != 'o_title':
do_grouping = False
if self.db.Movie.c.has_key(i):
if sort_reverse:
movies.order_by_clause.append(desc(self.db.Movie.c[i]))
else:
movies.order_by_clause.append(self.db.Movie.c[i])
movies = movies.execute().fetchall()
first_letter = ''
for movie in movies:
number = movie.number
original_title = str(movie.o_title).encode(defaultEnc)
title = str(movie.title).encode(defaultEnc)
grouping_title = movie.title
if grouping_title is None:
grouping_title = u'None'
if movie.director:
director = ' - ' + str(movie.director).encode(defaultEnc)
else:
director = ""
# group by first letter
# use movie.title/grouping_title for grouping because of encoding problems !!!
if do_grouping and grouping_title[0] != first_letter:
if grouping_title[0] in '0123456789':
# Group Numbers
if first_letter != '0-9':
first_letter = '0-9'
paragraph_text = '<font name=' + self.fontName + ' size="15">' + saxutils.escape(first_letter) + '</fonts>'
p = Paragraph(paragraph_text.decode(defaultEnc), self.styles['Heading2'])
Story.append(p)
else:
first_letter = grouping_title[0]
paragraph_text = '<font name=' + self.fontName + ' size="15">' + saxutils.escape(first_letter) + '</fonts>'
p = Paragraph(paragraph_text.decode(defaultEnc), self.styles['Heading2'])
Story.append(p)
# add movie title
paragraph_text = '<font name=' + self.fontName + ' size="7">' + \
'<b>'+ saxutils.escape(title) + '</b>' + \
saxutils.escape(' (' + original_title + '), ' + director + ' | ' + str(number)) + \
'</font>'
p = Paragraph(paragraph_text.decode(defaultEnc), self.styles['Normal'])
Story.append(p)
if not movie.genre is None:
paragraph_text = '<font name=' + self.fontName + ' size="5">' + \
'<b>' + _('Genre') + ': </b>' + saxutils.escape(str(movie.genre).encode(defaultEnc)) + \
'</font>'
p = Paragraph(paragraph_text.decode(defaultEnc), self.styles['Normal'])
Story.append(p)
if not movie.cast is None:
paragraph_text = '<i><font name=' + self.fontName + ' size="5">' + \
'<b>' + _('Cast') + ': </b>' + saxutils.escape('; '.join(str(movie.cast).encode(defaultEnc).split("\n")[0:2])) + \
'</font></i>'
p = Paragraph(paragraph_text.decode(defaultEnc), self.styles['Normal'])
Story.append(p)
c.build(Story, onFirstPage=self.page_template, onLaterPages=self.page_template)
gutils.info(self, _('PDF has been created.'), self.parent)
def populate(self, movies=None, where=None):#{{{
import sys
if self.initialized is False:
return False
from sqlalchemy import Select, desc
if movies is None:
movies = Select([self.db.Movie.c.number,
self.db.Movie.c.o_title, self.db.Movie.c.title,
self.db.Movie.c.director, self.db.Movie.c.image,
self.db.Movie.c.genre, self.db.Movie.c.seen,
self.db.Movie.c.year, self.db.Movie.c.runtime])
if isinstance(movies, Select):
"""if not where: # because of possible 'seen', 'loaned', 'collection_id' in where
# seen / loaned
#loaned_only = self.widgets['menu']['loaned_movies'].get_active()
#not_seen_only = self.widgets['menu']['not_seen_movies'].get_active()
pass
if loaned_only:
movies.append_whereclause(self.db.Movie.c.loaned==True)
if not_seen_only:
movies.append_whereclause(self.db.Movie.c.seen==False)
# collection
#pos = self.widgets['filter']['collection'].get_active()
if pos >= 0:
#col_id = self.collection_combo_ids[pos]
if col_id > 0:
movies.append_whereclause(self.db.Movie.c.collection_id==col_id)
# volume
#pos = self.widgets['filter']['volume'].get_active()
if pos >= 0:
#vol_id = self.volume_combo_ids[pos]
if vol_id > 0:
movies.append_whereclause(self.db.Movie.c.volume_id==vol_id)
"""
# select sort column
sort_column_name = self.config.get('sortby', 'number', section='mainlist')
sort_reverse = self.config.get('sortby_reverse', False, section='mainlist')
for i in sort_column_name.split(','):
if self.db.Movie.c.has_key(i):
if sort_reverse:
movies.append_order_by(desc(self.db.Movie.c[i]))
else:
#movies.append_order_by(self.db.Movie.c[i])
pass
# additional whereclause (volume_id, collection_id, ...)
if where:
for i in where:
if self.db.Movie.c.has_key(i):
movies.append_whereclause(self.db.Movie.c[i]==where[i])
movies = movies.execute().fetchall()
self.main_listcontrol.DeleteAllItems()
for movie in movies:
index = self.main_listcontrol.InsertStringItem(sys.maxint, str(movie.number))
self.main_listcontrol.SetStringItem(index, 1, unicode(movie.o_title))
self.main_listcontrol.SetStringItem(index, 2, unicode(movie.title))
self.main_listcontrol.SetStringItem(index, 3, unicode(movie.director))
self.main_listcontrol.SetStringItem(index, 4, unicode(movie.genre))
self.main_listcontrol.SetStringItem(index, 5, str(movie.seen))
self.main_listcontrol.SetStringItem(index, 6, str(movie.year))
self.main_listcontrol.SetStringItem(index, 7, str(movie.runtime))
statusbar.count_statusbar(self)
self.main_listcontrol.SetColumnWidth(0, 40)
self.main_listcontrol.SetColumnWidth(1, wx.LIST_AUTOSIZE)
self.main_listcontrol.SetColumnWidth(2, wx.LIST_AUTOSIZE)
self.main_listcontrol.SetColumnWidth(3, wx.LIST_AUTOSIZE)
def populate(self, movies=None, where=None):#{{{
from sqlalchemy import Select, desc
if movies is None:
movies = Select([self.db.Movie.c.number,
self.db.Movie.c.o_title, self.db.Movie.c.title,
self.db.Movie.c.director, self.db.Movie.c.image])
if isinstance(movies, Select):
if not where: # because of possible 'seen', 'loaned', 'collection_id' in where
# seen / loaned
loaned_only = self.widgets['menu']['loaned_movies'].get_active()
not_seen_only = self.widgets['menu']['not_seen_movies'].get_active()
if loaned_only:
movies.append_whereclause(self.db.Movie.c.loaned==True)
if not_seen_only:
movies.append_whereclause(self.db.Movie.c.seen==False)
# collection
col_id = self.collection_combo_ids[self.widgets['filter']['collection'].get_active()]
if col_id > 0:
movies.append_whereclause(self.db.Movie.c.collection_id==col_id)
# select sort column
sort_column_name = self.config.get('sortby', 'number')
sort_reverse = self.config.get('sortby_reverse', False)
for i in sort_column_name.split(','):
if self.db.Movie.c.has_key(i):
if sort_reverse:
movies.order_by_clause.append(desc(self.db.Movie.c[i]))
else:
movies.order_by_clause.append(self.db.Movie.c[i])
# additional whereclause (volume_id, collection_id, ...)
if where:
for i in where:
if self.db.Movie.c.has_key(i):
movies.append_whereclause(self.db.Movie.c[i]==where[i])
movies = movies.execute().fetchall()
self.total = len(movies)
self.treemodel.clear()
for movie in movies:
myiter = self.treemodel.append(None)
self.treemodel.set_value(myiter,0,'%004d' % int(movie.number))
# check preferences to hide or show columns
if self.config.get('view_otitle') == 'True':
self.otitle_column.set_visible(True)
else:
self.otitle_column.set_visible(False)
if self.config.get('view_title') == 'True':
self.title_column.set_visible(True)
else:
self.title_column.set_visible(False)
if self.config.get('view_director') == 'True':
self.director_column.set_visible(True)
else:
self.director_column.set_visible(False)
if self.config['view_image'] == 'True':
self.image_column.set_visible(True)
tmp_dest = self.locations['posters']
tmp_img = os.path.join(tmp_dest, "t_%s.jpg" % str(movie.image))
if movie.image and os.path.isfile(tmp_img):
image_path = tmp_img
else:
image_path = os.path.join(self.locations['images'], 'default_thumbnail.png')
# lets see if we have a scaled down thumbnail already created
if os.path.isfile(os.path.join(tmp_dest, "t_%s.jpg" % str(movie.image))):
pass
else:
# if not, lets make one for future use :D
original_image = os.path.join(tmp_dest, "%s.jpg" % movie.image)
if os.path.isfile(original_image):
gutils.make_thumbnail(self, "%s.jpg" % movie.image)
else:
self.Image.set_from_file("%s/default_thumbnail.png" % self.locations['images'])
pixbuf = self.Image.get_pixbuf()
self.Image.set_from_file(image_path)
pixbuf = self.Image.get_pixbuf()
self.treemodel.set_value(myiter, 1, pixbuf)
else:
# let's hide image column from main treeview since we don't want it to be visible
self.image_column.set_visible(False)
self.treemodel.set_value(myiter,2,movie.o_title)
self.treemodel.set_value(myiter,3,movie.title)
self.treemodel.set_value(myiter,4,movie.director)
