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

   1 #!/usr/bin/env python2.5
   2 import hildon
   3 import gtk, gobject
   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
  59     def __create_view (self):
  60         vbox = gtk.VBox (homogeneous=False)
  61
  62         menu = hildon.AppMenu ()
  63         self.all_items = gtk.RadioButton (None, _("All"))
  64         self.all_items.set_mode (False)
  65         self.all_items.connect_after ("toggled", self.__set_filter_mode, SHOW_ALL)
  66         menu.add_filter (self.all_items)
  67         self.broken_items = gtk.RadioButton (self.all_items, _("Incomplete"))
  68         self.broken_items.set_mode (False)
  69         self.broken_items.connect_after ("toggled",
  70                                          self.__set_filter_mode, SHOW_UNCOMPLETE)
  71         menu.add_filter (self.broken_items)
  72         menu.show_all ()
  73         self.set_app_menu (menu)
  74
  75         self.treeview = gtk.TreeView ()
  76         self.treeview.connect ("row-activated", self.row_activated_cb)
  77         desc_column = gtk.TreeViewColumn ("Song", gtk.CellRendererText (), markup=6)
  78         desc_column.set_expand (True)
  79         self.treeview.append_column (desc_column)
  80
  81         pannable_area = hildon.PannableArea ()
  82         pannable_area.add (self.treeview)
  83
  84         vbox.pack_start (pannable_area, expand=True)
  85
  86         self.search_hbox = gtk.HBox ()
  87         self.search_entry = hildon.Entry (gtk.HILDON_SIZE_FINGER_HEIGHT)
  88         self.search_hbox.pack_start (self.search_entry, expand=True)
  89
  90         self.search_close = gtk.Button (stock=gtk.STOCK_CLOSE)
  91         self.search_hbox.pack_start (self.search_close, expand=False)
  92         self.search_close.connect ("clicked", self.close_search_cb)
  93
  94         # Hide it when the window is created
  95         self.search_box_visible = False
  96         self.search_hbox.set_no_show_all (True)
  97         self.search_hbox.hide ()
  98         vbox.pack_start (self.search_hbox, expand=False)
  99         self.add (vbox)
 100
 101     def search_type (self, widget):
 102         self.filtered_model.refilter ()
 103
 104     def close_search_cb (self, widget):
 105         assert not self.search_box_visible
 106         self.search_hbox.hide_all ()
 107         self.search_entry.set_text ("")
 108         self.search_box_visible = False
 109         if (self.all_items.get_active ()):
 110             self.filter_mode = SHOW_ALL
 111         else:
 112             self.filter_mode = SHOW_UNCOMPLETE
 113         self.filtered_model.refilter ()
 114         self.kpid = self.connect ("key-press-event", self.key_pressed_cb)
 115
 116     def key_pressed_cb (self, widget, event):
 117         if (event.type == gtk.gdk.KEY_PRESS):
 118             if (event.keyval == gtk.gdk.keyval_from_name ("Alt_L")):
 119                 return
 120
 121             if (not self.search_box_visible ):
 122                 self.filter_mode = SHOW_MATCH
 123                 self.search_hbox.set_no_show_all (False)
 124                 self.search_hbox.show_all ()
 125
 126             self.search_entry.grab_focus ()
 127             self.search_entry.connect ("changed", self.search_type)
 128             self.disconnect (self.kpid)
 129
 130
 131     def row_activated_cb (self, treeview, path, view_colum):
 132         edit_view = MussorgskyEditPanel ()
 133         edit_view.set_artist_alternatives (self.artist_set.as_list ())
 134         edit_view.set_album_alternatives (self.albums_set.as_list ())
 135         edit_view.set_model (self.treeview.get_model (), self.treeview.get_model ().get_iter (path))
 136         edit_view.show_all ()
 137
 138     def __update_title_with_filter (self, filter_mode):
 139         if self.filter_mode == SHOW_ALL:
 140             self.set_title (_("All music"))
 141         elif self.filter_mode == SHOW_UNCOMPLETE:
 142             self.set_title (_("Music with uncomplete metadata"))
 143         elif self.filter_mode == SHOW_MATCH:
 144             self.set_title (_("Search results"))
 145
 146
 147     def __set_filter_mode (self, button, filter_mode):
 148         """
 149         Parameter to use it as callback as well as regular function
 150         """
 151         if (filter_mode == self.filter_mode):
 152             # Don't refilter if there is no change!
 153             return
 154         self.filter_mode = filter_mode
 155         self.__update_title_with_filter (self.filter_mode)
 156         self.treeview.set_model (None)
 157         self.filtered_model.refilter ()
 158         self.treeview.set_model (self.filtered_model)
 159
 160     def filter_entry (self, model, it):
 161         if self.filter_mode == SHOW_ALL:
 162             return True
 163         elif self.filter_mode == SHOW_UNCOMPLETE:
 164             return self.entry_uncomplete (model, it)
 165         elif self.filter_mode == SHOW_MATCH:
 166             return self.entry_with_text (model, it)
 167
 168     def entry_with_text (self, model, it):
 169         t = self.search_entry.get_text ()
 170         return t.lower () in model.get_value (it, SEARCH_COLUMN)
 171
 172     def entry_uncomplete (self, model, it):
 173         r = filter (lambda x: not x or len(x.strip()) == 0,
 174                     model.get (it, ARTIST_COLUMN, TITLE_COLUMN, ALBUM_COLUMN))
 175         return len (r) > 0
 176
 177 if __name__ == "__main__":
 178
 179     import random
 180     def get_random_path ():
 181         path = "file://"
 182         for i in range (0, random.randint (1, 8)):
 183             path = path + "/" + ("x"* random.randint (4, 12))
 184         return path
 185
 186     def get_some_empty_titles (i):
 187         if random.randint (0, 5) <= 1:
 188             return ""
 189         else:
 190             return "Title <%d>" % i
 191
 192
 193     songs = [(get_random_path (),
 194               "Music",
 195               "Artist%d" % i,
 196               get_some_empty_titles (i),
 197               "album <%d>" % i,
 198               "audio/non-supported") for i in range (0, 100)]
 199
 200     songs.append (("file:///no/metadata/at/all",
 201                    "music",
 202                    "",
 203                    "",
 204                    "",
 205                    "audio/mpeg"))
 206
 207     window = MussorgskyBrowsePanel (songs)
 208     window.connect ("destroy", gtk.main_quit )
 209     window.show_all ()
 210     gtk.main ()