expanders = GObject.property(type=str, default='{1:True}')

def __init__(self, toolbar, rbtree):

"""

Initialises the object.

"""

super(AltToolbarSidebar, self).__init__()

self.shell = toolbar.shell

self.toolbar = toolbar

self.plugin = toolbar.plugin

self.rbtree = rbtree

self._drag_dest_source = None

self._drag_motion_counter = -1

# locale stuff

cl = CoverLocale()

cl.switch_locale(cl.Locale.LOCALE_DOMAIN)

self.set_name("AltToolbarSideBar")

self._category = {}

self._last_click_source = None

self._user_clicked = False

gs = GSetting()

plugin_settings = gs.get_setting(gs.Path.PLUGIN)

plugin_settings.bind(gs.PluginKey.EXPANDERS, self, 'expanders',

Gio.SettingsBindFlags.DEFAULT)

# title, source, visible

self.treestore = Gtk.TreeStore.new([str, GObject.Object, bool])

self.treestore_filter = self.treestore.filter_new(root=None)

self.treestore_filter.set_visible_column(2)

self.set_model(self.treestore_filter)

context = self.get_style_context()

context.add_class(Gtk.STYLE_CLASS_SIDEBAR)

self.set_headers_visible(False)

# define the headers - not visible by default

def define_category(text, category):

local = self.treestore.append(None)

self.treestore[local] = [text, None, False]

self._category[category] = local

define_category(_("Local collection"), AltControllerCategory.LOCAL)

define_category(_("Online sources"), AltControllerCategory.ONLINE)

define_category(_("Other sources"), AltControllerCategory.OTHER)

define_category(_("Playlists"), AltControllerCategory.PLAYLIST)

def delayed(*args):

model = self.shell.props.display_page_model

rootiter = model.get_iter_first()

depth = 0

self._traverse_rows(model, rootiter, None, depth)

# switch on/off headers depending upon what's in the model

self._refresh_headers()

# tidy up syncing by connecting signals

self._connect_signals()

# now expand or collapse each expander that we have saved from a

# previous session

expanders = eval(self.expanders)

print(expanders)

print(self.expanders)

for category in expanders:

print(category)

path = self.treestore.get_path(self._category[category])

if path and expanders[category]:

# self._user_clicked = True

self.expand_row(path, False) # expanders[category])

return False

GLib.timeout_add_seconds(1, delayed)

column = Gtk.TreeViewColumn.new()

column.set_fixed_width(5)

column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)

self.append_column(column)

column = Gtk.TreeViewColumn.new()

pixbuf_renderer = Gtk.CellRendererPixbuf()

column.pack_start(pixbuf_renderer, False)

renderer = Gtk.CellRendererText()

renderer.connect('edited', self.on_renderertext_edited)

self.text_renderer = renderer

column.pack_start(renderer, False)

column.set_cell_data_func(pixbuf_renderer, self._set_pixbuf)

column.set_cell_data_func(renderer, self._set_text)

self.tree_column = column

self.append_column(column)

self.set_expander_column(column)

self.show_all()

self.set_can_focus(True)

cl = CoverLocale()

cl.switch_locale(cl.Locale.RB)

def _connect_signals(self):

# display_page_model signals to keep the sidebar model in sync

model = self.shell.props.display_page_model

# model.props.child_model.connect('row-inserted',

# self._model_page_inserted)

# model.connect('row-inserted', self._model_page_inserted)

self._cpi = model.connect('page-inserted', self._model_page_inserted)

self._crd = model.connect('row-deleted', self._model_page_deleted)

self._crc = model.connect('row-changed', self._model_page_changed)

# when we click on the sidebar -

# need to keep the display_page_tree in sync

self.connect('button-press-event', self._row_click)

# and visa versa

tree = self.shell.props.display_page_tree

tree.connect('selected',

self._display_page_tree_selected)

self.shell.props.shell_player.connect('playing-song-changed',

self._on_playing_song_changed)

# drag drop

from gi.repository import Gdk

self.enable_model_drag_dest([], Gdk.DragAction.COPY)

self.drag_dest_add_uri_targets()

self.connect('drag-drop', self.on_drag_drop)

self.connect('drag-data-received',

self.on_drag_data_received)

self.connect('drag-motion', self.on_drag_motion)

def cleanup(self):

model = self.shell.props.display_page_model

model.disconnect(self._cpi)

model.disconnect(self._crd)

model.disconnect(self._crc)

def on_drag_drop(self, widget, context, x, y, time):

"""

Callback called when a drag operation finishes over the treeview

It decides if the dropped item can be processed.

"""

print("on_drag_drop")

# stop the propagation of the signal (deactivates superclass callback)

widget.stop_emission_by_name('drag-drop')

target = self.drag_dest_find_target(context, None)

widget.drag_get_data(context, target, time)

self._drag_dest_source = None

return True

def on_drag_motion(self, widget, drag_context, x, y, time):

path = False

try:

path, pos = widget.get_dest_row_at_pos(x, y)

except:

pass

result = False

if path and (pos == Gtk.TreeViewDropPosition.BEFORE

or pos == Gtk.TreeViewDropPosition.AFTER):

if pos == Gtk.TreeViewDropPosition.BEFORE:

drop_pos = Gtk.TreeViewDropPosition.INTO_OR_BEFORE

else:

drop_pos = Gtk.TreeViewDropPosition.INTO_OR_AFTER

widget.set_drag_dest_row(None, drop_pos)

# Gdk.drag_status(drag_context, 0, time)

path = None

if path:

dest_source = self.treestore_filter[path][1]

try:

# note - some sources dont have a can_paste method so need to

# trap this case

if not dest_source:

result = False

elif dest_source.can_paste():

result = True

except:

result = False

if dest_source and result:

if dest_source != self._drag_dest_source:

if self._drag_motion_counter != -1:

self._drag_motion_counter = 0

self._drag_dest_source = dest_source

def delayed(*args):

if self._drag_motion_counter < 2 and \

self._drag_dest_source:

self._drag_motion_counter += 1

return True

if self._drag_dest_source \

and self._drag_motion_counter >= 2:

tree = self.shell.props.display_page_tree

if tree:

tree.select(self._drag_dest_source)

self.rbtree.expand_all()

self._drag_motion_counter = -1

return False

if self._drag_motion_counter == -1:

self._drag_motion_counter = 0

GLib.timeout_add_seconds(1, delayed)

if result:

Gdk.drag_status(drag_context, Gdk.DragAction.COPY, time)

else:

Gdk.drag_status(drag_context, 0, time)

self._drag_dest_source = None

return not result

def on_drag_data_received(self, widget, drag_context, x, y, data, info,

time):

"""

Callback called when the drag source has prepared the data (pixbuf)

for us to use.

"""

print("on_drag_data_received")

# stop the propagation of the signal (deactivates superclass callback)

widget.stop_emission_by_name('drag-data-received')

path, pos = widget.get_dest_row_at_pos(x, y)

dest_source = self.treestore_filter[path][1]

drag_context.finish(True, False, time)

uris = data.get_uris()

entries = []

for uri in uris:

entry = self.shell.props.db.entry_lookup_by_location(uri)

if entry:

entries.append(entry)

dest_source.paste(entries)

def _on_playing_song_changed(self, *args):

"""

signal when a playing song changes - need to invoke a tree-refresh

to ensure the user can see which source

:param args:

:return:

"""

print("playing song changed")

if hasattr(self.plugin, "db"): # curious crash when exiting - lets not

# send the queue_draw in this case

print("queuing")

self.queue_draw()

def on_renderertext_edited(self, renderer, path, new_text):

print("edited")

print(path)

print(new_text)

self.treestore_filter[path][1].props.name = new_text

def _traverse_rows(self, store, treeiter, new_parent_iter, depth):

while treeiter is not None:

print(depth, store[treeiter][1])

print(depth, store[treeiter][1].props.name)

if isinstance(store[treeiter][1], RB.DisplayPageGroup):

if store.iter_has_child(treeiter):

childiter = store.iter_children(treeiter)

self._traverse_rows(store, childiter, treeiter, depth)

treeiter = store.iter_next(treeiter)

continue

if depth == 0:

category_iter = self._get_category_iter(store[treeiter][1])

leaf_iter = self.treestore.append(category_iter)

else:

leaf_iter = self.treestore.append(new_parent_iter)

self.treestore[leaf_iter][1] = store[treeiter][1]

self.treestore[leaf_iter][0] = ""

self.treestore[leaf_iter][2] = True

if store.iter_has_child(treeiter):

childiter = store.iter_children(treeiter)

self._traverse_rows(store, childiter, leaf_iter, depth + 1)

treeiter = store.iter_next(treeiter)

def _model_page_changed(self, model, path, page_iter):

print(model[page_iter][1].props.name)

print(path)

def _model_page_inserted(self, model, page, page_iter):

print(page)

print(page_iter)

parent_iter = model.iter_parent(page_iter)

print(parent_iter)

def find_lookup_rows(store, treeiter, page):

while treeiter is not None:

found_page = store[treeiter][1]

print(found_page)

if found_page is not None and found_page == page:

print("found %s" % found_page.props.name)

return treeiter

if store.iter_has_child(treeiter):

childiter = store.iter_children(treeiter)

ret = find_lookup_rows(store, childiter, page)

if ret:

return ret

treeiter = store.iter_next(treeiter)

print("nothing found")

return None

# first check if we've already got the page in the model

rootiter = self.treestore.get_iter_first()

if find_lookup_rows(self.treestore, rootiter, page):

return

if (parent_iter and isinstance(model[parent_iter][1],

RB.DisplayPageGroup)) or \

not parent_iter:

# the parent of the inserted row is a top-level item in the

# display-page-model

print("top level")

category_iter = self._get_category_iter(page)

leaf_iter = self.treestore.append(category_iter)

else:

# the parent is another source so we need to find the iter in our

# model to hang it off

print("child level")

searchpage = model[parent_iter][1]

print("####", searchpage)

leaf_iter = find_lookup_rows(self.treestore, rootiter, searchpage)

print("##2", leaf_iter)

leaf_iter = self.treestore.append(leaf_iter)

self.treestore[leaf_iter][1] = page

self.treestore[leaf_iter][0] = ""

self.treestore[leaf_iter][2] = True

self._refresh_headers()

if "PlaylistSource" in type(page).__name__:

# a playlist of somesort has been added - so lets put the user into

# edit mode

self.edit_playlist(leaf_iter)

self.rbtree.expand_all()

def edit_playlist(self, leaf_iter):

"""

edit the playlist

:param leaf_iter: treestore iter

:return:

"""

print("edit_playlist")

self.text_renderer.props.editable = True

path = self.treestore.get_path(leaf_iter)

path = self.treestore_filter.convert_child_path_to_path(path)

print(path)

self.grab_focus()

def delayed(*args):

self.set_cursor_on_cell(path,

self.tree_column, self.text_renderer, True)

GLib.timeout_add_seconds(1, delayed, None)

def _model_page_deleted(self, model, path):

"""

signal from the displaytreemodel - we dont actually know what is

deleted ... just that something has been

:param model:

:param path:

:return:

"""

# first do a reverse lookup so that we can search quicker later

# dict of sources in the sidebar model with their treeiter

lookup = {}

rootiter = self.treestore.get_iter_first()

def find_lookup_rows(store, treeiter):

while treeiter is not None:

# if store[treeiter][0] == "":

# lookup[store[treeiter][1]] = treeiter

if store[treeiter][1] is not None:

lookup[store[treeiter][1]] = treeiter

if store.iter_has_child(treeiter):

childiter = store.iter_children(treeiter)

find_lookup_rows(store, childiter)

treeiter = store.iter_next(treeiter)

find_lookup_rows(self.treestore, rootiter)

# next iterate through the displaytreemodel - where we have a matching

# source, delete it from our lookup

def find_rows(store, treeiter):

while treeiter is not None:

if store[treeiter][1] in lookup:

del lookup[store[treeiter][1]]

if store.iter_has_child(treeiter):

childiter = store.iter_children(treeiter)

find_rows(store, childiter)

treeiter = store.iter_next(treeiter)

rootiter = model.get_iter_first()

find_rows(model, rootiter)

# from what is left is the stuff to remove from our treeview

# (treestore)

for source in lookup:

self.treestore.remove(lookup[source])

self._refresh_headers()

def _row_click(self, widget, event):

"""

event called when clicking on a row

"""

print('_row_click')

try:

treepath, treecolumn, cellx, celly = \

widget.get_path_at_pos(event.x, event.y)

except:

print("exit")

return

active_object = self.treestore_filter[treepath][1]

print(active_object)

if active_object:

# we have a source

self._user_clicked = True

self.shell.props.display_page_tree.select(active_object)

self.rbtree.expand_all()

if self._last_click_source == active_object:

self.text_renderer.props.editable = \

"PlaylistSource" in type(active_object).__name__

else:

self.text_renderer.props.editable = False

self._last_click_source = active_object

def delayed(*args):

# save current state of each category in the treeview

cat_vals = {}

for category in self._category:

path = self.treestore.get_path(self._category[category])

if path:

cat_vals[category] = self.row_expanded(path)

self.expanders = str(cat_vals)

print(self.expanders)

GLib.timeout_add_seconds(1, delayed)

def _display_page_tree_selected(self, display_page_tree, page):

"""

signal from when a page is selected in the display-page-tree -

we need to sync with our tree

:param display_page_tree:

:param page:

:return:

"""

if self._user_clicked:

self._user_clicked = False

return

# first do a reverse lookup so that we can search quicker later

# dict of sources in the sidebar model with their treeiter

lookup = {}

rootiter = self.treestore_filter.get_iter_first()

def find_lookup_rows(store, treeiter):

while treeiter is not None:

if store[treeiter][1] is not None:

lookup[store[treeiter][1]] = treeiter

print(store[treeiter][1].props.name)

if store.iter_has_child(treeiter):

childiter = store.iter_children(treeiter)

find_lookup_rows(store, childiter)

treeiter = store.iter_next(treeiter)

find_lookup_rows(self.treestore_filter, rootiter)

if page in lookup:

path = self.treestore_filter.get_path(lookup[page])

self.expand_to_path(path)

self.set_cursor(path)

def _set_text(self, column, renderer, model, treeiter, arg):

source = model[treeiter][1]

if source is None:

renderer.props.weight = Pango.Weight.BOLD

renderer.props.text = model[treeiter][0]

renderer.props.visible = model[treeiter][2]

else:

renderer.props.visible = True

player = self.shell.props.shell_player

playing = \

player.get_playing and player.get_playing_source() == source

renderer.props.text = source.props.name

if playing:

renderer.props.weight = Pango.Weight.BOLD

else:

renderer.props.weight = Pango.Weight.NORMAL

renderer.props.ypad = 3

path = model.get_path(treeiter)

if path.get_depth() == 1:

renderer.props.ypad = 6

renderer.props.xpad = 3

else:

renderer.props.ypad = 3

renderer.props.xpad = 0

renderer.props.ellipsize = Pango.EllipsizeMode.END

def _refresh_headers(self):

treeiter = self.treestore.get_iter_first()

while treeiter is not None:

self.treestore[treeiter][2] = \

self.treestore.iter_has_child(treeiter)

treeiter = self.treestore.iter_next(treeiter)

def _set_pixbuf(self, column, renderer, model, treeiter, arg):

source = model[treeiter][1]

if source is None:

renderer.props.pixbuf = None

else:

ret_bool, controller = self.toolbar.is_controlled(source)

renderer.props.gicon = controller.get_gicon(source)

renderer.props.follow_state = True

path = model.get_path(treeiter)

if path.get_depth() == 2:

renderer.props.visible = True # must be a child so show the

# pixbuf renderer

else:

renderer.props.visible = False # headers or children of child

# dont have pixbuf's so no renderer to display

renderer.props.xpad = 3

def _get_category_iter(self, source):

ret_bool, controller = self.toolbar.is_controlled(source)

category = AltControllerCategory.OTHER

if ret_bool:

category = controller.get_category()