[gnome-music/wip/merge: 175/343] Fix some camelCase to lower_case in variable/method names
- From: Ignacio Casal Quinteiro <icq src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-music/wip/merge: 175/343] Fix some camelCase to lower_case in variable/method names
- Date: Thu, 25 Jul 2013 11:27:42 +0000 (UTC)
commit 4b3ffffc3446cf4f070e4c0af6938aa44fb441e7
Author: Arnel A. Borja <arnelborja src gnome org>
Date: Tue Jul 16 23:37:20 2013 +0800
Fix some camelCase to lower_case in variable/method names
gnomemusic/albumArtCache.py | 2 +-
gnomemusic/grilo.py | 16 ++--
gnomemusic/player.py | 2 +-
gnomemusic/toolbar.py | 14 ++--
gnomemusic/view.py | 101 ++++++++++++------------
gnomemusic/widgets.py | 178 +++++++++++++++++++++---------------------
gnomemusic/window.py | 26 +++---
7 files changed, 170 insertions(+), 169 deletions(-)
---
diff --git a/gnomemusic/albumArtCache.py b/gnomemusic/albumArtCache.py
index 2a8a725..3fdf88a 100644
--- a/gnomemusic/albumArtCache.py
+++ b/gnomemusic/albumArtCache.py
@@ -12,7 +12,7 @@ class AlbumArtCache:
instance = None
@classmethod
- def getDefault(self):
+ def get_default(self):
if self.instance:
return self.instance
else:
diff --git a/gnomemusic/grilo.py b/gnomemusic/grilo.py
index 52a113b..506d80a 100644
--- a/gnomemusic/grilo.py
+++ b/gnomemusic/grilo.py
@@ -46,16 +46,16 @@ class Grilo(GObject.GObject):
def _onSourceRemoved(self):
print('source removed')
- def populateArtists(self, offset, callback):
- self.populateItems(Query.artist, offset, callback)
+ def populate_artists(self, offset, callback):
+ self.populate_items(Query.ARTISTS, offset, callback)
- def populateAlbums(self, offset, callback, count=50):
- self.populateItems(Query.ALBUMS, offset, callback, count)
+ def populate_albums(self, offset, callback, count=50):
+ self.populate_items(Query.ALBUMS, offset, callback, count)
- def populateSongs(self, offset, callback):
- self.populateItems(Query.songs, offset, callback)
+ def populate_songs(self, offset, callback):
+ self.populate_items(Query.SONGS, offset, callback)
- def populateItems(self, query, offset, callback, count=50):
+ def populate_items(self, query, offset, callback, count=50):
options = Grl.OperationOptions()
options.set_flags(Grl.ResolutionFlags.FULL |
Grl.ResolutionFlags.IDLE_RELAY)
@@ -63,7 +63,7 @@ class Grilo(GObject.GObject):
options.set_count(count)
self.tracker.query(query, self.METADATA_KEYS, options, callback, None)
- def getAlbumSongs(self, album_id, callback):
+ def get_album_songs(self, album_id, callback):
query = Query.album_songs(album_id)
options = Grl.OperationOptions()
options.set_flags(Grl.ResolutionFlags.FULL |
diff --git a/gnomemusic/player.py b/gnomemusic/player.py
index ee4457a..2b984cf 100644
--- a/gnomemusic/player.py
+++ b/gnomemusic/player.py
@@ -72,7 +72,7 @@ class Player(GObject.GObject):
self.playlistField = None
self.currentTrack = None
self._lastState = Gst.State.PAUSED
- self.cache = AlbumArtCache.getDefault()
+ self.cache = AlbumArtCache.get_default()
self._symbolicIcon = self.cache.make_default_icon(ART_SIZE, ART_SIZE)
Gst.init(None)
diff --git a/gnomemusic/toolbar.py b/gnomemusic/toolbar.py
index 6e93ac6..81081de 100644
--- a/gnomemusic/toolbar.py
+++ b/gnomemusic/toolbar.py
@@ -21,7 +21,7 @@ class Toolbar(GObject.GObject):
self._stackSwitcher = Gtk.StackSwitcher()
self._ui = Gtk.Builder()
self._ui.add_from_resource('/org/gnome/music/Headerbar.ui')
- self.headerBar = self._ui.get_object('header-bar')
+ self.header_bar = self._ui.get_object('header-bar')
self._selectButton = self._ui.get_object('select-button')
self._cancelButton = self._ui.get_object('done-button')
self._backButton = self._ui.get_object('back-button')
@@ -30,7 +30,7 @@ class Toolbar(GObject.GObject):
self._selectionMenu = self._ui.get_object("selection-menu")
self._selectionMenuButton = self._ui.get_object("selection-menu-button")
self._selectionMenuButton.set_relief(Gtk.ReliefStyle.NONE)
- self.headerBar.set_custom_title(self._stackSwitcher)
+ self.header_bar.set_custom_title(self._stackSwitcher)
self._searchButton = self._ui.get_object("search-button")
self._backButton.connect('clicked', self.setState)
self._closeButton.connect('clicked', self._closeButtonClicked)
@@ -49,10 +49,10 @@ class Toolbar(GObject.GObject):
if selectionMode:
self._selectButton.hide()
self._cancelButton.show()
- self.headerBar.get_style_context().add_class('selection-mode')
+ self.header_bar.get_style_context().add_class('selection-mode')
self._cancelButton.get_style_context().remove_class('selection-mode')
else:
- self.headerBar.get_style_context().remove_class('selection-mode')
+ self.header_bar.get_style_context().remove_class('selection-mode')
self._selectButton.set_active(False)
self._selectButton.show()
self._cancelButton.hide()
@@ -65,15 +65,15 @@ class Toolbar(GObject.GObject):
def _update(self):
if (self._state == ToolbarState.SINGLE or self._selectionMode):
- self.headerBar.set_custom_title(None)
+ self.header_bar.set_custom_title(None)
self._backButton.show()
else:
self.title = ""
- self.headerBar.set_custom_title(self._stackSwitcher)
+ self.header_bar.set_custom_title(self._stackSwitcher)
self._backButton.hide()
if self._selectionMode:
- self.headerBar.set_custom_title(self._selectionMenuButton)
+ self.header_bar.set_custom_title(self._selectionMenuButton)
self._closeSeparator.hide()
self._closeButton.hide()
else:
diff --git a/gnomemusic/view.py b/gnomemusic/view.py
index 0cf8f1f..64a95cc 100644
--- a/gnomemusic/view.py
+++ b/gnomemusic/view.py
@@ -17,7 +17,7 @@ class ViewContainer(Gtk.Stack):
starIconName = 'starred-symbolic'
countQuery = None
- def __init__(self, title, headerBar, selectionToolbar, useStack=False):
+ def __init__(self, title, header_bar, selection_toolbar, useStack=False):
Gtk.Stack.__init__(self, transition_type=Gtk.StackTransitionType.CROSSFADE)
self._grid = Gtk.Grid(orientation=Gtk.Orientation.VERTICAL)
self._iconWidth = -1
@@ -44,7 +44,7 @@ class ViewContainer(Gtk.Stack):
)
self.view.set_view_type(Gd.MainViewType.ICON)
self.view.set_model(self._model)
- self.selectionToolbar = selectionToolbar
+ self.selection_toolbar = selection_toolbar
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
box.pack_start(self.view, True, True, 0)
if useStack:
@@ -62,11 +62,11 @@ class ViewContainer(Gtk.Stack):
self._loadMore = Widgets.LoadMoreButton(self._getRemainingItemCount)
box.pack_end(self._loadMore.widget, False, False, 0)
self._loadMore.widget.connect("clicked", self._populate)
- self.view.connect('item-activated', self._onItemActivated)
+ self.view.connect('item-activated', self._on_item_activated)
self._cursor = None
- self.headerBar = headerBar
- self.headerBar._selectButton.connect('toggled', self._onHeaderBarToggled)
- self.headerBar._cancelButton.connect('clicked', self._onCancelButtonClicked)
+ self.header_bar = header_bar
+ self.header_bar._selectButton.connect('toggled', self._onHeaderBarToggled)
+ self.header_bar._cancelButton.connect('clicked', self._onCancelButtonClicked)
self.title = title
self.add(self._grid)
@@ -75,12 +75,12 @@ class ViewContainer(Gtk.Stack):
self._items = []
self._loadMore.widget.hide()
self._connectView()
- self.cache = albumArtCache.getDefault()
+ self.cache = albumArtCache.get_default()
self._symbolicIcon = self.cache.make_default_icon(self._iconHeight, self._iconWidth)
self._init = False
grilo.connect('ready', self._onGriloReady)
- self.headerBar.headerBar.connect('state-changed', self._onStateChanged)
+ self.header_bar.header_bar.connect('state-changed', self._on_state_changed)
self.view.connect('view-selection-changed', self._onViewSelectionChanged)
def _onHeaderBarToggled(self, button):
@@ -96,12 +96,12 @@ class ViewContainer(Gtk.Stack):
def _onCancelButtonClicked(self, button):
self.view.set_selection_mode(False)
- self.headerBar.setSelectionMode(False)
+ self.header_bar.setSelectionMode(False)
def _onGriloReady(self, data=None):
- if (self.headerBar.get_stack().get_visible_child() == self and self._init is False):
+ if (self.header_bar.get_stack().get_visible_child() == self and self._init is False):
self._populate()
- self.headerBar.get_stack().connect('notify::visible-child', self._onHeaderBarVisible)
+ self.header_bar.get_stack().connect('notify::visible-child', self._onHeaderBarVisible)
def _onHeaderBarVisible(self, widget, param):
if self == widget.get_visible_child() and self._init:
@@ -109,13 +109,13 @@ class ViewContainer(Gtk.Stack):
def _onViewSelectionChanged(self):
items = self.view.get_selection()
- self.selectionToolbar._add_to_playlist_button.sensitive = items.length > 0
+ self.selection_toolbar._add_to_playlist_button.sensitive = items.length > 0
def _populate(self, data=None):
self._init = True
self.populate()
- def _onStateChanged(self, widget, data=None):
+ def _on_state_changed(self, widget, data=None):
pass
def _connectView(self):
@@ -184,31 +184,31 @@ class ViewContainer(Gtk.Stack):
return count - self._offset
def _updateAlbumArt(self, item, iter):
- def _albumArtCacheLookUp(icon, data=None):
+ def _album_art_cache_look_up(icon, data=None):
if icon:
self._model.set_value(iter, 4,
- albumArtCache.getDefault()._make_icon_frame(icon))
+ albumArtCache.get_default()._make_icon_frame(icon))
else:
self._model.set_value(iter, 4, None)
self.emit("album-art-updated")
pass
- albumArtCache.getDefault().lookup_or_resolve(item,
- self._iconWidth,
- self._iconHeight,
- _albumArtCacheLookUp)
+ albumArtCache.get_default().lookup_or_resolve(item,
+ self._iconWidth,
+ self._iconHeight,
+ _album_art_cache_look_up)
return False
- def _addListRenderers(self):
+ def _add_list_renderers(self):
pass
- def _onItemActivated(self, widget, id, path):
+ def _on_item_activated(self, widget, id, path):
pass
#Class for the Empty View
class Empty(Gtk.Stack):
- def __init__(self, headerBar, player):
+ def __init__(self, header_bar, player):
Gtk.Stack.__init__(self, transition_type=Gtk.StackTransitionType.CROSSFADE)
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/music/NoMusic.ui')
@@ -218,37 +218,38 @@ class Empty(Gtk.Stack):
class Albums(ViewContainer):
- def __init__(self, headerBar, selectionToolbar, player):
- ViewContainer.__init__(self, "Albums", headerBar, selectionToolbar)
+ def __init__(self, header_bar, selection_toolbar, player):
+ ViewContainer.__init__(self, "Albums", header_bar, selection_toolbar)
self.view.set_view_type(Gd.MainViewType.ICON)
self.countQuery = Query.ALBUMS_COUNT
self._albumWidget = Widgets.AlbumWidget(player)
self.add(self._albumWidget)
- def _onStateChanged(self, widget, data=None):
- if (self.headerBar.get_stack() is not None) and \
- (self == self.headerBar.get_stack().get_visible_child()):
+ def _on_state_changed(self, widget, data=None):
+ if (self.header_bar.get_stack() is not None) and \
+ (self == self.header_bar.get_stack().get_visible_child()):
self.visible_child = self._grid
- def _onItemActivated(self, widget, id, path):
+ def _on_item_activated(self, widget, id, path):
iter = self._model.get_iter(path)
title = self._model.get_value(iter, 2)
artist = self._model.get_value(iter, 3)
item = self._model.get_value(iter, 5)
- self._albumWidget.update(artist, title, item, self.headerBar, self.selectionToolbar)
- self.headerBar.setState(0)
- self.headerBar.headerBar.set_title(title)
- self.headerBar.headerBar.sub_title = artist
+ self._albumWidget.update(artist, title, item, self.header_bar, self.selection_toolbar)
+ self.header_bar.setState(0)
+ self.header_bar.header_bar.title = title
+ self.header_bar.header_bar.set_title(title)
+ self.header_bar.header_bar.sub_title = artist
self.set_visible_child(self._albumWidget)
def populate(self):
if grilo.tracker is not None:
- grilo.populateAlbums(self._offset, self._add_item)
+ grilo.populate_albums(self._offset, self._add_item)
class Songs(ViewContainer):
- def __init__(self, headerBar, selectionToolbar, player):
- ViewContainer.__init__(self, "Songs", headerBar, selectionToolbar)
+ def __init__(self, header_bar, selection_toolbar, player):
+ ViewContainer.__init__(self, "Songs", header_bar, selection_toolbar)
self.countQuery = Query.SONGS_COUNT
self._items = {}
self.isStarred = None
@@ -256,20 +257,20 @@ class Songs(ViewContainer):
self.view.get_generic_view().get_style_context().add_class("songs-list")
self._iconHeight = 32
self._iconWidth = 32
- self.cache = albumArtCache.getDefault()
+ self.cache = albumArtCache.get_default()
self._symbolicIcon = self.cache.make_default_icon(self._iconHeight,
self._iconWidth)
- self._addListRenderers()
+ self._add_list_renderers()
self.player = player
- self.player.connect('playlist-item-changed', self.updateModel)
+ self.player.connect('playlist-item-changed', self.update_model)
- def _onItemActivated(self, widget, id, path):
+ def _on_item_activated(self, widget, id, path):
iter = self._model.get_iter(path)[1]
if self._model.get_value(iter, 8) != self.errorIconName:
self.player.setPlaylist("Songs", None, self._model, iter, 5)
self.player.setPlaying(True)
- def updateModel(self, player, playlist, currentIter):
+ def update_model(self, player, playlist, currentIter):
if playlist != self._model:
return False
if self.iterToClean:
@@ -297,7 +298,7 @@ class Songs(ViewContainer):
[5, 8, 9, 10],
[item, self.errorIconName, False, True])
- def _addListRenderers(self):
+ def _add_list_renderers(self):
listWidget = self.view.get_generic_view()
cols = listWidget.get_columns()
cells = cols[0].get_cells()
@@ -370,17 +371,17 @@ class Songs(ViewContainer):
def populate(self):
if grilo.tracker is not None:
- grilo.populateSongs(self._offset, self._add_item, None)
+ grilo.populate_songs(self._offset, self._add_item, None)
class Playlist(ViewContainer):
- def __init__(self, headerBar, selectionToolbar, player):
- ViewContainer.__init__(self, "Playlists", headerBar, selectionToolbar)
+ def __init__(self, header_bar, selection_toolbar, player):
+ ViewContainer.__init__(self, "Playlists", header_bar, selection_toolbar)
class Artists (ViewContainer):
- def __init__(self, headerBar, selectionToolbar, player):
- ViewContainer.__init__(self, "Artists", headerBar, selectionToolbar, True)
+ def __init__(self, header_bar, selection_toolbar, player):
+ ViewContainer.__init__(self, "Artists", header_bar, selection_toolbar, True)
self.player = player
self._artists = {}
self.countQuery = Query.ARTISTS_COUNT
@@ -394,7 +395,7 @@ class Artists (ViewContainer):
self.view.get_generic_view().get_selection().set_mode(Gtk.SelectionMode.SINGLE)
self._grid.attach(Gtk.Separator(orientation=Gtk.Orientation.VERTICAL), 1, 0, 1, 1)
self._grid.attach(self._artistAlbumsWidget, 2, 0, 2, 2)
- self._addListRenderers()
+ self._add_list_renderers()
if Gtk.Settings.get_default().get_property('gtk_application_prefer_dark_theme'):
self.view.get_generic_view().get_style_context().add_class("artist-panel-dark")
else:
@@ -416,7 +417,7 @@ class Artists (ViewContainer):
self._init = True
self.populate()
- def _addListRenderers(self):
+ def _add_list_renderers(self):
listWidget = self.view.get_generic_view()
cols = listWidget.get_columns()
@@ -435,7 +436,7 @@ class Artists (ViewContainer):
listWidget.add_renderer(typeRenderer, type_render, None)
- def _onItemActivated(self, widget, id, path):
+ def _on_item_activated(self, widget, id, path):
children = self._artistAlbumsWidget.get_children()
for i in children.length:
self._artistAlbumsWidget.remove(children[i])
@@ -472,5 +473,5 @@ class Artists (ViewContainer):
def populate(self):
if grilo.tracker is not None:
- grilo.populateArtists(self._offset, self._add_item, None)
+ grilo.populate_artists(self._offset, self._add_item, None)
#FIXME: We're emitting self too early, need to wait for all artists to be filled in
diff --git a/gnomemusic/widgets.py b/gnomemusic/widgets.py
index 5dff967..15ad532 100644
--- a/gnomemusic/widgets.py
+++ b/gnomemusic/widgets.py
@@ -4,7 +4,7 @@ from gnomemusic.grilo import grilo
import logging
from gnomemusic.query import Query
from gnomemusic.albumArtCache import AlbumArtCache
-ALBUM_ART_CACHE = AlbumArtCache.getDefault()
+ALBUM_ART_CACHE = AlbumArtCache.get_default()
NOW_PLAYING_ICON_NAME = 'media-playback-start-symbolic'
ERROR_ICON_NAME = 'dialog-error-symbolic'
@@ -28,17 +28,17 @@ class LoadMoreButton:
self.widget = Gtk.Button(no_show_all=True,
child=child)
self.widget.get_style_context().add_class('documents-load-more')
- self.widget.connect('clicked', self._onLoadMoreClicked)
- self._onItemCountChanged()
+ self.widget.connect('clicked', self._on_load_more_clicked)
+ self._on_item_count_changed()
- def _onLoadMoreClicked(self, data=None):
+ def _on_load_more_clicked(self, data=None):
self._label.label = "Loading..."
self._spinner.show()
self._spinner.start()
- def _onItemCountChanged(self):
- remainingDocs = self._counter()
- visible = remainingDocs >= 0 and not self._block
+ def _on_item_count_changed(self):
+ remaining_docs = self._counter()
+ visible = remaining_docs >= 0 and not self._block
self.widget.set_visible(visible)
if visible:
@@ -46,12 +46,12 @@ class LoadMoreButton:
self._spinner.stop()
self._spinner.hide()
- def setBlock(self, block):
+ def set_block(self, block):
if (self._block == block):
return
self._block = block
- self._onItemCountChanged()
+ self._on_item_count_changed()
class AlbumWidget(Gtk.EventBox):
@@ -64,7 +64,7 @@ class AlbumWidget(Gtk.EventBox):
self.player = player
self.hbox = Gtk.HBox()
self.iterToClean = None
- self.cache = AlbumArtCache.getDefault()
+ self.cache = AlbumArtCache.get_default()
self._symbolicIcon = self.cache.make_default_icon(256, 256)
self.ui = Gtk.Builder()
@@ -87,7 +87,7 @@ class AlbumWidget(Gtk.EventBox):
)
self.view.set_view_type(Gd.MainViewType.LIST)
self.album = None
- self.view.connect('item-activated', self._onItemActivated)
+ self.view.connect('item-activated', self._on_item_activated)
view_box = self.ui.get_object("view")
child_view = self.view.get_children()[0]
@@ -98,13 +98,13 @@ class AlbumWidget(Gtk.EventBox):
view_box.add(child_view)
self.add(self.ui.get_object("AlbumWidget"))
- self._addListRenderers()
+ self._add_list_renderers()
# TODO: make this work
#self.get_style_context().add_class("view")
#self.get_style_context().add_class("content-view")
self.show_all()
- def _onItemActivated(self, widget, id, path):
+ def _on_item_activated(self, widget, id, path):
iter = self.model.get_iter(path)
if(self.model.get_value(iter, 7) != ERROR_ICON_NAME):
if (self.iterToClean and self.player.playlistId == self.album):
@@ -115,45 +115,45 @@ class AlbumWidget(Gtk.EventBox):
self.player.setPlaylist("Album", self.album, self.model, iter, 5)
self.player.setPlaying(True)
- def _addListRenderers(self):
- listWidget = self.view.get_generic_view()
+ def _add_list_renderers(self):
+ list_widget = self.view.get_generic_view()
- cols = listWidget.get_columns()
+ cols = list_widget.get_columns()
cols[0].set_min_width(310)
cols[0].set_max_width(470)
cells = cols[0].get_cells()
cells[2].visible = False
cells[1].visible = False
- nowPlayingSymbolRenderer = Gtk.CellRendererPixbuf(xpad=0)
+ now_playing_symbol_renderer = Gtk.CellRendererPixbuf(xpad=0)
- columnNowPlaying = Gtk.TreeViewColumn()
- nowPlayingSymbolRenderer.xalign = 1.0
- nowPlayingSymbolRenderer.yalign = 0.6
- columnNowPlaying.pack_start(nowPlayingSymbolRenderer, False)
- columnNowPlaying.fixed_width = 24
- columnNowPlaying.add_attribute(nowPlayingSymbolRenderer, "visible", 9)
- columnNowPlaying.add_attribute(nowPlayingSymbolRenderer, "icon_name",
+ column_now_playing = Gtk.TreeViewColumn()
+ now_playing_symbol_renderer.xalign = 1.0
+ now_playing_symbol_renderer.yalign = 0.6
+ column_now_playing.pack_start(now_playing_symbol_renderer, False)
+ column_now_playing.fixed_width = 24
+ column_now_playing.add_attribute(now_playing_symbol_renderer, "visible", 9)
+ column_now_playing.add_attribute(now_playing_symbol_renderer, "icon_name",
7)
- listWidget.insert_column(columnNowPlaying, 0)
+ list_widget.insert_column(column_now_playing, 0)
- typeRenderer = Gd.StyledTextRenderer(xpad=16)
- typeRenderer.ellipsize = Pango.EllipsizeMode.END
- typeRenderer.xalign = 0.0
- listWidget.add_renderer(typeRenderer, self._typeRendererText, None)
- cols[0].clear_attributes(typeRenderer)
- cols[0].add_attribute(typeRenderer, "markup", 0)
+ type_renderer = Gd.StyledTextRenderer(xpad=16)
+ type_renderer.ellipsize = Pango.EllipsizeMode.END
+ type_renderer.xalign = 0.0
+ list_widget.add_renderer(type_renderer, self._type_renderer_text, None)
+ cols[0].clear_attributes(type_renderer)
+ cols[0].add_attribute(type_renderer, "markup", 0)
durationRenderer = Gd.StyledTextRenderer(xpad=16)
durationRenderer.add_class('dim-label')
durationRenderer.ellipsize = Pango.EllipsizeMode.END
durationRenderer.xalign = 1.0
- listWidget.add_renderer(durationRenderer, self._durationRendererText, None)
+ list_widget.add_renderer(durationRenderer, self._duration_renderer_text, None)
- def _typeRendererText(self, col, cell, model, iter, data):
+ def _type_renderer_text(self, col, cell, model, iter, data):
pass
- def _durationRendererText(self, col, widget, model, iter, data):
+ def _duration_renderer_text(self, col, widget, model, iter, data):
item = self.model.get_value(iter, 5)
duration = item.get_duration()
if item is None:
@@ -169,15 +169,15 @@ class AlbumWidget(Gtk.EventBox):
self.ui.get_object("cover").set_from_pixbuf(self._symbolicIcon)
ALBUM_ART_CACHE.lookup(256, artist,
item.get_string(Grl.METADATA_KEY_ALBUM),
- self._onLookUp)
+ self._on_look_up)
# if the active queue has been set by self album,
# use it as model, otherwise build the liststore
- cachedPlaylist = self.player.runningPlaylist("Album", album)
- if cachedPlaylist is not None:
- self.model = cachedPlaylist
- self.updateModel(self.player, cachedPlaylist,
- self.player.currentTrack)
+ cached_playlist = self.player.runningPlaylist("Album", album)
+ if cached_playlist is not None:
+ self.model = cached_playlist
+ self.update_model(self.player, cached_playlist,
+ self.player.currentTrack)
else:
self.model = Gtk.ListStore(
GObject.TYPE_STRING, # title
@@ -191,10 +191,10 @@ class AlbumWidget(Gtk.EventBox):
GObject.TYPE_BOOLEAN,
GObject.TYPE_BOOLEAN,
)
- grilo.getAlbumSongs(item.get_id(), self._onGetAlbumSongs)
- header_bar._selectButton.connect('toggled', self._onHeaderSelectButtonToggled)
- header_bar._cancelButton.connect('clicked', self._onHeaderCancelButtonClicked)
- self.view.connect('view-selection-changed', self._onViewSelectionChanged)
+ grilo.get_album_songs(item.get_id(), self._on_get_album_songs)
+ header_bar._selectButton.connect('toggled', self._on_header_select_button_toggled)
+ header_bar._cancelButton.connect('clicked', self._on_header_cancel_button_clicked)
+ self.view.connect('view-selection-changed', self._on_view_selection_changed)
self.view.set_model(self.model)
escapedArtist = GLib.markup_escape_text(artist, -1)
escapedAlbum = GLib.markup_escape_text(album, -1)
@@ -205,19 +205,19 @@ class AlbumWidget(Gtk.EventBox):
str(item.get_creation_date().get_year()))
else:
self.ui.get_object("released_label_info").set_text("----")
- self.player.connect('playlist-item-changed', self.updateModel)
+ self.player.connect('playlist-item-changed', self.update_model)
#self.emit('loaded')
- def _onViewSelectionChanged(self):
+ def _on_view_selection_changed(self):
items = self.view.get_selection()
self.selection_toolbar._add_to_playlist_button.sensitive = items.length
- def _onHeaderCancelButtonClicked(self, button):
+ def _on_header_cancel_button_clicked(self, button):
self.view.set_selection_mode(False)
self.header_bar.setSelectionMode(False)
self.header_bar.header_bar.title = self.album
- def _onHeaderSelectButtonToggled(self, button):
+ def _on_header_select_button_toggled(self, button):
if(button.get_active()):
self.view.set_selection_mode(True)
self.header_bar.setSelectionMode(True)
@@ -232,7 +232,7 @@ class AlbumWidget(Gtk.EventBox):
if(self.player.PlaybackStatus != 'Stopped'):
self.player.eventBox.set_visible(True)
- def _onGetAlbumSongs(self, source, prefs, track, a, b, c):
+ def _on_get_album_songs(self, source, prefs, track, a, b, c):
if track is not None:
self.tracks.append(track)
self.duration = self.duration + track.get_duration()
@@ -256,12 +256,12 @@ class AlbumWidget(Gtk.EventBox):
"%d min" % (int(self.duration / 60) + 1))
#self.emit("track-added")
- def _onLookUp(self, pixbuf, path):
+ def _on_look_up(self, pixbuf, path):
if pixbuf is not None:
self.ui.get_object("cover").set_from_pixbuf(pixbuf)
self.model.set(iter, [4], [pixbuf])
- def updateModel(self, player, playlist, currentIter):
+ def update_model(self, player, playlist, currentIter):
#self is not our playlist, return
if (playlist != self.model):
return False
@@ -329,7 +329,7 @@ class ArtistAlbums(Gtk.VBox):
self.addAlbum(albums[i])
self.show_all()
- self.player.connect('playlist-item-changed', self.updateModel)
+ self.player.connect('playlist-item-changed', self.update_model)
self.emit("albums-loaded")
def addAlbum(self, album):
@@ -337,17 +337,17 @@ class ArtistAlbums(Gtk.VBox):
self._albumBox.pack_start(widget, False, False, 0)
self.widgets.append(widget)
- def cleanModel(self):
+ def clean_model(self):
[res, iter] = self.model.get_iter_first()
if not res:
return False
while self.model.iter_next(iter) is True:
song = self.model.get_value(iter, 5)
- songWidget = song.songWidget
+ song_widget = song.song_widget
escapedTitle = GLib.markup_escape_text(song.get_title(), -1)
- if songWidget.can_be_played is not None:
- songWidget.nowPlayingSign.hide()
- songWidget.title.set_markup("<span>" + escapedTitle + "</span>")
+ if song_widget.can_be_played is not None:
+ song_widget.nowPlayingSign.hide()
+ song_widget.title.set_markup("<span>" + escapedTitle + "</span>")
return False
@@ -356,10 +356,10 @@ class AllArtistsAlbums(ArtistAlbums):
def __init__(self, player):
super(ArtistAlbums, "All Artists", [], player).__init__()
self._offset = 0
- self.countQuery = Query.album_count
- self._loadMore = LoadMoreButton(self, self._getRemainingItemCount)
- self.pack_end(self._loadMore.widget, False, False, 0)
- self._loadMore.widget.connect("clicked", self._populate)
+ self.countQuery = Query.ALBUMS_COUNT
+ self._load_more = LoadMoreButton(self, self._get_remaining_item_count)
+ self.pack_end(self._load_more.widget, False, False, 0)
+ self._load_more.widget.connect("clicked", self._populate)
self._connectView()
self._populate()
@@ -378,7 +378,7 @@ class AllArtistsAlbums(ArtistAlbums):
# if there's no vscrollbar, or if it's not visible, hide the button
if not vScrollbar or not vScrollbar.get_visible():
- self._loadMore.setBlock(True)
+ self._load_more.set_block(True)
return
value = adjustment.value
@@ -390,20 +390,20 @@ class AllArtistsAlbums(ArtistAlbums):
end = False
else:
end = not (value < (upper - page_size - revealAreaHeight))
- if self._getRemainingItemCount() <= 0:
+ if self._get_remaining_item_count() <= 0:
end = False
- self._loadMore.setBlock(not end)
+ self._load_more.set_block(not end)
def _populate(self):
if grilo.tracker is not None:
- grilo.populateAlbums(self._offset, self.addItem, 5)
+ grilo.populate_albums(self._offset, self.addItem, 5)
def addItem(self, source, param, item, remaining):
if item is not None:
self._offset = self.offset + 1
self.addAlbum(item)
- def _getRemainingItemCount(self):
+ def _get_remaining_item_count(self):
count = -1
if self.countQuery is not None:
cursor = grilo.tracker.query(self.countQuery, None)
@@ -425,7 +425,7 @@ class ArtistAlbumWidget(Gtk.HBox):
self.ui = Gtk.Builder()
self.ui.add_from_resource('/org/gnome/music/ArtistAlbumWidget.ui')
- self.cache = AlbumArtCache.getDefault()
+ self.cache = AlbumArtCache.get_default()
pixbuf = self.cache.make_default_icon(128, 128)
GLib.idle_add(self._updateAlbumArt)
@@ -437,12 +437,12 @@ class ArtistAlbumWidget(Gtk.HBox):
album.get_creation_date().get_year() + ")</span>"
)
self.tracks = []
- grilo.getAlbumSongs(album.get_id(), self.getSongs)
+ grilo.get_album_songs(album.get_id(), self.get_songs)
self.pack_start(self.ui.get_object("ArtistAlbumWidget"), True, True, 0)
self.show_all()
self.emit("artist-album-loaded")
- def getSongs(self, source, prefs, track):
+ def get_songs(self, source, prefs, track):
if track is not None:
self.tracks.append(track)
@@ -451,8 +451,8 @@ class ArtistAlbumWidget(Gtk.HBox):
track = self.tracks[i]
ui = Gtk.Builder()
ui.add_from_resource('/org/gnome/music/TrackWidget.ui')
- songWidget = ui.get_object("eventbox1")
- self.songs.append(songWidget)
+ song_widget = ui.get_object("eventbox1")
+ self.songs.append(song_widget)
ui.get_object("num").set_markup("<span color='grey'>"
+ str(self.songs.length)
+ "</span>")
@@ -460,15 +460,15 @@ class ArtistAlbumWidget(Gtk.HBox):
ui.get_object("title").set_text(track.get_title())
ui.get_object("title").set_alignment(0.0, 0.5)
self.ui.get_object("grid1").attach(
- songWidget,
+ song_widget,
int(i / (self.tracks.length / 2)),
int((i) % (self.tracks.length / 2)), 1, 1
)
- track.songWidget = songWidget
+ track.song_widget = song_widget
iter = self.model.append()
- songWidget.iter = iter
- songWidget.model = self.model
- songWidget.title = ui.get_object("title")
+ song_widget.iter = iter
+ song_widget.model = self.model
+ song_widget.title = ui.get_object("title")
try:
self.player.discoverer.discover_uri(track.get_url())
@@ -476,15 +476,15 @@ class ArtistAlbumWidget(Gtk.HBox):
[0, 1, 2, 3, 4, 5],
[track.get_title(), "", "", False,
NOW_PLAYING_ICON_NAME, track])
- songWidget.nowPlayingSign = ui.get_object("image1")
- songWidget.nowPlayingSign.set_from_icon_name(
+ song_widget.nowPlayingSign = ui.get_object("image1")
+ song_widget.nowPlayingSign.set_from_icon_name(
NOW_PLAYING_ICON_NAME,
Gtk.IconSize.SMALL_TOOLBAR)
- songWidget.nowPlayingSign.set_no_show_all("true")
- songWidget.nowPlayingSign.set_alignment(0.0, 0.6)
- songWidget.can_be_played = True
- songWidget.connect('button-release-event',
- self.trackSelected)
+ song_widget.nowPlayingSign.set_no_show_all("true")
+ song_widget.nowPlayingSign.set_alignment(0.0, 0.6)
+ song_widget.can_be_played = True
+ song_widget.connect('button-release-event',
+ self.trackSelected)
except IOError as err:
print(err.message)
@@ -492,20 +492,20 @@ class ArtistAlbumWidget(Gtk.HBox):
self.model.set(iter, [0, 1, 2, 3, 4, 5],
[track.get_title(), "", "", True,
ERROR_ICON_NAME, track])
- songWidget.nowPlayingSign = ui.get_object("image1")
- songWidget.nowPlayingSign.set_from_icon_name(
+ song_widget.nowPlayingSign = ui.get_object("image1")
+ song_widget.nowPlayingSign.set_from_icon_name(
ERROR_ICON_NAME,
Gtk.IconSize.SMALL_TOOLBAR)
- songWidget.nowPlayingSign.set_alignment(0.0, 0.6)
- songWidget.can_be_played = False
+ song_widget.nowPlayingSign.set_alignment(0.0, 0.6)
+ song_widget.can_be_played = False
self.ui.get_object("grid1").show_all()
self.emit("tracks-loaded")
def _updateAlbumArt(self):
ALBUM_ART_CACHE.lookup(128, self.artist,
- self.album.get_title(), self.getAlbumCover)
+ self.album.get_title(), self.get_album_cover)
- def getAlbumCover(self, pixbuf):
+ def get_album_cover(self, pixbuf, path):
if pixbuf is not None:
self.ui.get_object("cover").set_from_pixbuf(pixbuf)
else:
diff --git a/gnomemusic/window.py b/gnomemusic/window.py
index 554024d..3354485 100644
--- a/gnomemusic/window.py
+++ b/gnomemusic/window.py
@@ -57,9 +57,9 @@ class Window(Gtk.ApplicationWindow):
def _setupView(self):
self._box = Gtk.VBox()
self.player = Player()
- self.selectionToolbar = SelectionToolbar()
+ self.selection_toolbar = SelectionToolbar()
self.toolbar = Toolbar()
- self.set_titlebar(self.toolbar.headerBar)
+ self.set_titlebar(self.toolbar.header_bar)
self.views = []
self._stack = Gtk.Stack(
transition_type=Gtk.StackTransitionType.CROSSFADE,
@@ -67,25 +67,25 @@ class Window(Gtk.ApplicationWindow):
visible=True)
self._box.pack_start(self._stack, True, True, 0)
self._box.pack_start(self.player.eventBox, False, False, 0)
- self._box.pack_start(self.selectionToolbar.eventbox, False, False, 0)
+ self._box.pack_start(self.selection_toolbar.eventbox, False, False, 0)
self.add(self._box)
count = 1
cursor = tracker.query(Query.SONGS_COUNT, None)
if cursor is not None and cursor.next(None):
count = cursor.get_integer(0)
if count > 0:
- self.views.append(Views.Albums(self.toolbar, self.selectionToolbar, self.player))
- self.views.append(Views.Artists(self.toolbar, self.selectionToolbar, self.player))
- self.views.append(Views.Songs(self.toolbar, self.selectionToolbar, self.player))
- #self.views.append(Views.Playlist(self.toolbar, self.selectionToolbar, self.player))
+ self.views.append(Views.Albums(self.toolbar, self.selection_toolbar, self.player))
+ self.views.append(Views.Artists(self.toolbar, self.selection_toolbar, self.player))
+ self.views.append(Views.Songs(self.toolbar, self.selection_toolbar, self.player))
+ #self.views.append(Views.Playlist(self.toolbar, self.selection_toolbar, self.player))
for i in self.views:
self._stack.add_titled(i, i.title, i.title)
self.toolbar.set_stack(self._stack)
- self._onNotifyModelId = self._stack.connect("notify::visible-child", self._onNotifyMode)
- self.connect("destroy", self._notifyModeDisconnect)
+ self._on_notify_model_id = self._stack.connect("notify::visible-child", self._on_notify_mode)
+ self.connect("destroy", self._notify_mode_disconnect)
self.views[0].populate()
#To revert to the No Music View when no songs are found
@@ -94,15 +94,15 @@ class Window(Gtk.ApplicationWindow):
self._stack.add_titled(self.views[0], "Empty", "Empty")
self.toolbar.setState(ToolbarState.ALBUMS)
- self.toolbar.headerBar.show()
+ self.toolbar.header_bar.show()
self.player.eventBox.show_all()
self._box.show()
self.show()
- def _notifyModeDisconnect(self, data=None):
- self._stack.disconnect(self._onNotifyModelId)
+ def _notify_mode_disconnect(self, data=None):
+ self._stack.disconnect(self._on_notify_model_id)
- def _onNotifyMode(self, stack, param):
+ def _on_notify_mode(self, stack, param):
#Slide out artist list on switching to artists view
if stack.get_visible_child() == self.views[1]:
stack.get_visible_child().stack.set_visible_child_name("dummy")
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
