vcs.maemo.org Git - mussorgsky/blob - src/browse_panel.py

   1 #!/usr/bin/env python2.5
   2 import hildon
   3 import gtk, gobject, glib
   4 from edit_panel_tm import MussorgskyEditPanel
   5 from utils import escape_html, Set, is_empty
   6
   7 # Shared with edit_panel_tm
   8 URI_COLUMN = 0
   9 ARTIST_COLUMN = 2
  10 TITLE_COLUMN = 3
  11 ALBUM_COLUMN = 4
  12 MIME_COLUMN = 5
  13 UI_COLUMN = 6
  14 SEARCH_COLUMN = 7
  15
  16 SHOW_ALL = 1
  17 SHOW_UNCOMPLETE = 2
  18 SHOW_MATCH = 3
  19
  20 import time
  21 import i18n
  22 _ = i18n.language.gettext
  23
  24 class MussorgskyBrowsePanel (hildon.StackableWindow):
  25
  26     def __init__ (self, songs_list):
  27         hildon.StackableWindow.__init__ (self)
  28         self.set_title (_("All music"))
  29         self.set_border_width (12)
  30         self.__create_view ()
  31
  32         # Prepare cache of artists and albums
  33         self.artist_set = Set ()
  34         self.albums_set = Set ()
  35
  36         # (uri, "Music", artist, title, album, mimetype) + "string" + search_string
  37         full_model = gtk.ListStore (str, str, str, str, str, str, str, str)
  38         for (uri, category, artist, title, album, mime) in songs_list:
  39             if is_empty (artist) and is_empty (title) and is_empty (album):
  40                 text = "<small>%s</small>" % (escape_html (uri))
  41             else:
  42                 text = "<b>%s</b>\n<small>%s</small>" % (escape_html (title),
  43                                                          escape_html (artist) + " / " + escape_html (album))
  44             search_str = " ".join ([artist.lower (),
  45                                    title.lower (),
  46                                    album.lower ()])
  47             full_model.append ((uri, None, artist, title, album, mime, text, search_str))
  48             self.artist_set.insert (artist)
  49             self.albums_set.insert (album)
  50
  51         self.filtered_model = full_model.filter_new ()
  52         self.treeview.set_model (self.filtered_model)
  53         self.filter_mode = SHOW_ALL
  54         self.filtered_model.set_visible_func (self.filter_entry)
  55         self.__set_filter_mode (None, SHOW_ALL)
  56
  57         self.kpid = self.connect ("key-press-event", self.key_pressed_cb)
  58         self.fpid = None
  59
  60     def __create_view (self):
  61         vbox = gtk.VBox (homogeneous=False)
  62
  63         menu = hildon.AppMenu ()
  64         self.all_items = gtk.RadioButton (None, _("All"))
  65         self.all_items.set_mode (False)
  66         self.all_items.connect_after ("toggled", self.__set_filter_mode, SHOW_ALL)
  67         menu.add_filter (self.all_items)
  68         self.broken_items = gtk.RadioButton (self.all_items, _("Incomplete"))
  69         self.broken_items.set_mode (False)
  70         self.broken_items.connect_after ("toggled",
  71                                          self.__set_filter_mode, SHOW_UNCOMPLETE)
  72         menu.add_filter (self.broken_items)
  73         menu.show_all ()
  74         self.set_app_menu (menu)
  75
  76         self.treeview = gtk.TreeView ()
  77         self.treeview.connect ("row-activated", self.row_activated_cb)
  78         desc_column = gtk.TreeViewColumn ("Song", gtk.CellRendererText (), markup=6)
  79         desc_column.set_expand (True)
  80         self.treeview.append_column (desc_column)
  81
  82         pannable_area = hildon.PannableArea ()
  83         pannable_area.add (self.treeview)
  84
  85         vbox.pack_start (pannable_area, expand=True)
  86
  87         self.search_hbox = gtk.HBox ()
  88         self.search_entry = hildon.Entry (gtk.HILDON_SIZE_FINGER_HEIGHT)
  89         self.search_hbox.pack_start (self.search_entry, expand=True)
  90
  91         self.search_close = gtk.Button (stock=gtk.STOCK_CLOSE)
  92         self.search_hbox.pack_start (self.search_close, expand=False)
  93         self.search_close.connect ("clicked", self.close_search_cb)
  94
  95         # Hide it when the window is created
  96         self.search_box_visible = False
  97         self.search_hbox.set_no_show_all (True)
  98         self.search_hbox.hide ()
  99         vbox.pack_start (self.search_hbox, expand=False)
 100         self.add (vbox)
 101
 102     def search_refilter_cb (self):
 103         self.treeview.set_model (None)
 104         self.filtered_model.refilter ()
 105         self.treeview.set_model (self.filtered_model)
 106         self.fpid = None
 107         return False
 108
 109     def search_type (self, widget):
 110         if (self.fpid):
 111             glib.source_remove (self.fpid)
 112         self.fpid = glib.timeout_add (300, self.search_refilter_cb)
 113
 114     def close_search_cb (self, widget):
 115         assert not self.search_box_visible
 116         self.search_hbox.hide_all ()
 117         self.search_entry.set_text ("")
 118         self.search_box_visible = False
 119         if (self.all_items.get_active ()):
 120             self.filter_mode = SHOW_ALL
 121         else:
 122             self.filter_mode = SHOW_UNCOMPLETE
 123         self.filtered_model.refilter ()
 124         self.kpid = self.connect ("key-press-event", self.key_pressed_cb)
 125
 126     def key_pressed_cb (self, widget, event):
 127         if (event.type == gtk.gdk.KEY_PRESS):
 128             if (event.keyval == gtk.gdk.keyval_from_name ("Alt_L")):
 129                 return
 130
 131             if (not self.search_box_visible ):
 132                 self.filter_mode = SHOW_MATCH
 133                 self.search_hbox.set_no_show_all (False)
 134                 self.search_hbox.show_all ()
 135
 136             self.search_entry.grab_focus ()
 137             self.search_entry.connect ("changed", self.search_type)
 138             self.disconnect (self.kpid)
 139
 140
 141     def row_activated_cb (self, treeview, path, view_colum):
 142         edit_view = MussorgskyEditPanel ()
 143         edit_view.set_artist_alternatives (self.artist_set.as_list ())
 144         edit_view.set_album_alternatives (self.albums_set.as_list ())
 145         edit_view.set_model (self.treeview.get_model (), self.treeview.get_model ().get_iter (path))
 146         edit_view.show_all ()
 147
 148     def __update_title_with_filter (self, filter_mode):
 149         if self.filter_mode == SHOW_ALL:
 150             self.set_title (_("All music"))
 151         elif self.filter_mode == SHOW_UNCOMPLETE:
 152             self.set_title (_("Music with uncomplete metadata"))
 153         elif self.filter_mode == SHOW_MATCH:
 154             self.set_title (_("Search results"))
 155
 156
 157     def __set_filter_mode (self, button, filter_mode):
 158         """
 159         Parameter to use it as callback as well as regular function
 160         """
 161         if (filter_mode == self.filter_mode):
 162             # Don't refilter if there is no change!
 163             return
 164         self.filter_mode = filter_mode
 165         self.__update_title_with_filter (self.filter_mode)
 166         self.treeview.set_model (None)
 167         self.filtered_model.refilter ()
 168         self.treeview.set_model (self.filtered_model)
 169
 170     def filter_entry (self, model, it):
 171         if self.filter_mode == SHOW_ALL:
 172             return True
 173         elif self.filter_mode == SHOW_UNCOMPLETE:
 174             return self.entry_uncomplete (model, it)
 175         elif self.filter_mode == SHOW_MATCH:
 176             return self.entry_with_text (model, it)
 177
 178     def entry_with_text (self, model, it):
 179         t = self.search_entry.get_text ()
 180         #return t.lower () in model.get_value (it, SEARCH_COLUMN)
 181         return model.get_value (it, SEARCH_COLUMN).find (t.lower ()) != -1
 182
 183     def entry_uncomplete (self, model, it):
 184         r = filter (lambda x: not x or len(x.strip()) == 0,
 185                     model.get (it, ARTIST_COLUMN, TITLE_COLUMN, ALBUM_COLUMN))
 186         return len (r) > 0
 187
 188 if __name__ == "__main__":
 189
 190     import random
 191     def get_random_path ():
 192         path = "file://"
 193         for i in range (0, random.randint (1, 8)):
 194             path = path + "/" + ("x"* random.randint (4, 12))
 195         return path
 196
 197     def get_some_empty_titles (i):
 198         if random.randint (0, 5) <= 1:
 199             return ""
 200         else:
 201             return "Title <%d>" % i
 202
 203
 204     songs = [(get_random_path (),
 205               "Music",
 206               "Artist%d" % i,
 207               get_some_empty_titles (i),
 208               "album <%d>" % i,
 209               "audio/mpeg") for i in range (0, 10000)]
 210
 211     songs.append (("file:///no/metadata/at/all",
 212                    "music",
 213                    "",
 214                    "",
 215                    "",
 216                    "audio/mpeg"))
 217
 218     window = MussorgskyBrowsePanel (songs)
 219     window.connect ("destroy", gtk.main_quit )
 220     window.show_all ()
 221     gtk.main ()