# Copyright (C) 2008-2010 Adam Olsen
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
#
# The developers of the Exaile media player hereby grant permission
# for non-GPL compatible GStreamer and Exaile plugins to be used and
# distributed together with GStreamer and Exaile. This permission is
# above and beyond the permissions granted by the GPL license by which
# Exaile is covered. If you modify this code, you may extend this
# exception to your version of the code, but you are not obligated to
# do so. If you do not wish to do so, delete this exception statement
# from your version.
import logging
import os.path
from threading import Thread
from typing import Iterable, Optional, Union
from gi.repository import (
Gdk,
GdkPixbuf,
Gio,
GLib,
GObject,
Gtk,
Pango,
)
from xl import metadata, providers, settings, xdg
from xl.common import clamp
from xl.playlist import (
is_valid_playlist,
import_playlist,
export_playlist,
InvalidPlaylistTypeError,
PlaylistExportOptions,
)
from xl.nls import gettext as _
from xlgui import guiutil
from xlgui.guiutil import GtkTemplate
logger = logging.getLogger(__name__)
def error(parent, message=None, markup=None):
"""
Shows an error dialog
"""
if message is markup is None:
raise ValueError("message or markup must be specified")
dialog = Gtk.MessageDialog(
buttons=Gtk.ButtonsType.CLOSE,
message_type=Gtk.MessageType.ERROR,
modal=True,
transient_for=parent,
)
if markup is None:
dialog.props.text = message
else:
dialog.set_markup(markup)
dialog.run()
dialog.destroy()
def info(parent, message=None, markup=None):
"""
Shows an info dialog
"""
if message is markup is None:
raise ValueError("message or markup must be specified")
dialog = Gtk.MessageDialog(
buttons=Gtk.ButtonsType.OK,
message_type=Gtk.MessageType.INFO,
modal=True,
transient_for=parent,
)
if markup is None:
dialog.props.text = message
else:
dialog.set_markup(markup)
dialog.run()
dialog.destroy()
def yesno(parent, message):
'''Gets a Yes/No response from a user'''
dlg = Gtk.MessageDialog(
buttons=Gtk.ButtonsType.YES_NO,
message_type=Gtk.MessageType.QUESTION,
text=message,
transient_for=parent,
)
response = dlg.run()
dlg.destroy()
return response
@GtkTemplate('ui', 'about_dialog.ui')
class AboutDialog(Gtk.AboutDialog):
"""
A dialog showing program info and more
"""
__gtype_name__ = 'AboutDialog'
def __init__(self, parent=None):
Gtk.AboutDialog.__init__(self)
self.init_template()
self.set_transient_for(parent)
logo = GdkPixbuf.Pixbuf.new_from_file(
xdg.get_data_path('images', 'exailelogo.png')
)
self.set_logo(logo)
import xl.version
self.set_version(xl.version.__version__)
# The user may have changed the theme since startup.
theme = Gtk.Settings.get_default().props.gtk_theme_name
xl.version.__external_versions__["GTK+ theme"] = theme
comments = []
for name, version in sorted(xl.version.__external_versions__.items()):
comments.append('%s: %s' % (name, version))
self.set_comments('\n'.join(comments))
def on_response(self, *_):
self.destroy()
@GtkTemplate('ui', 'shortcuts_dialog.ui')
class ShortcutsDialog(Gtk.Dialog):
"""
Shows information about registered shortcuts
TODO: someday upgrade to Gtk.ShortcutsWindow when we require 3.20 as
a minimum GTK version. This would also enable automatically
localized (translated) accelerator names.
"""
# doesn't work if we don't set the treeview here too..
shortcuts_treeview, shortcuts_model = GtkTemplate.Child.widgets(2)
__gtype_name__ = 'ShortcutsDialog'
def __init__(self, parent=None):
Gtk.Dialog.__init__(self)
self.init_template()
self.set_transient_for(parent)
for a in sorted(
providers.get('mainwindow-accelerators'),
key=lambda a: ('%04d' % (a.key)) + a.name,
):
self.shortcuts_model.append(
(Gtk.accelerator_get_label(a.key, a.mods), a.helptext.replace('_', ''))
)
@GtkTemplate.Callback
def on_close_clicked(self, widget):
self.destroy()
class MultiTextEntryDialog(Gtk.Dialog):
"""
Exactly like a TextEntryDialog, except it can contain multiple
labels/fields.
Instead of using GetValue, use GetValues. It will return a list with
the contents of the fields. Each field must be filled out or the dialog
will not close.
"""
def __init__(self, parent, title):
Gtk.Dialog.__init__(self, title=title, transient_for=parent)
self.__entry_area = Gtk.Grid()
self.__entry_area.set_row_spacing(3)
self.__entry_area.set_column_spacing(3)
self.__entry_area.set_border_width(3)
self.vbox.pack_start(self.__entry_area, True, True, 0)
self.add_buttons(
Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.OK
)
self.fields = []
def add_field(self, label: str, value: str = None, tooltip: str = None):
"""
Adds a field and corresponding label
:param label: the label to display
:param value: the text in entry field
:param tooltip: a tooltip to show
:returns: the newly created entry
:rtype: :class:`Gtk.Entry`
"""
line_number = len(self.fields)
label = Gtk.Label(label=label)
label.set_xalign(0)
self.__entry_area.attach(label, 0, line_number, 1, 1)
entry = Gtk.Entry()
entry.set_width_chars(30)
entry.set_icon_activatable(Gtk.EntryIconPosition.SECONDARY, False)
entry.connect('activate', lambda *e: self.response(Gtk.ResponseType.OK))
if value is not None:
entry.set_text(value)
if tooltip is not None:
entry.set_icon_from_icon_name(
Gtk.EntryIconPosition.SECONDARY, 'dialog-information'
)
entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY, tooltip)
self.__entry_area.attach(entry, 1, line_number, 1, 1)
label.show()
entry.show()
self.fields.append(entry)
return entry
def get_values(self):
"""
Returns a list of the values from the added fields
"""
return [a.get_text() for a in self.fields]
def run(self):
"""
Shows the dialog, runs, hides, and returns
"""
self.show_all()
while True:
response = Gtk.Dialog.run(self)
if response in (Gtk.ResponseType.CANCEL, Gtk.ResponseType.DELETE_EVENT):
break
if response == Gtk.ResponseType.OK:
# Leave loop if all fields where filled
if len(min([f.get_text() for f in self.fields])) > 0:
break
# At least one field was not filled
for field in self.fields:
if len(field.get_text()) > 0:
# Unset possible previous marks
field.set_icon_from_icon_name(
Gtk.EntryIconPosition.SECONDARY, None
)
else:
# Mark via warning
field.set_icon_from_icon_name(
Gtk.EntryIconPosition.SECONDARY, 'dialog-warning'
)
self.hide()
return response
class TextEntryDialog(Gtk.Dialog):
"""
Shows a dialog with a single line of text
"""
def __init__(
self,
message,
title,
default_text=None,
parent=None,
cancelbutton=None,
okbutton=None,
):
"""
Initializes the dialog
"""
if not cancelbutton:
cancelbutton = Gtk.STOCK_CANCEL
if not okbutton:
okbutton = Gtk.STOCK_OK
Gtk.Dialog.__init__(
self, title=title, transient_for=parent, destroy_with_parent=True
)
self.add_buttons(
cancelbutton, Gtk.ResponseType.CANCEL, okbutton, Gtk.ResponseType.OK
)
label = Gtk.Label(label=message)
label.set_xalign(0)
self.vbox.set_border_width(5)
main = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
main.set_spacing(3)
main.set_border_width(5)
self.vbox.pack_start(main, True, True, 0)
main.pack_start(label, False, False, 0)
self.entry = Gtk.Entry()
self.entry.set_width_chars(35)
if default_text:
self.entry.set_text(default_text)
main.pack_start(self.entry, False, False, 0)
self.entry.connect('activate', lambda e: self.response(Gtk.ResponseType.OK))
def get_value(self):
"""
Returns the text value
"""
return self.entry.get_text()
def set_value(self, value):
"""
Sets the value of the text
"""
self.entry.set_text(value)
def run(self):
self.show_all()
response = Gtk.Dialog.run(self)
self.hide()
return response
class URIOpenDialog(TextEntryDialog):
"""
A dialog specialized for opening an URI
"""
__gsignals__ = {
'uri-selected': (
GObject.SignalFlags.RUN_LAST,
GObject.TYPE_BOOLEAN,
(GObject.TYPE_PYOBJECT,),
GObject.signal_accumulator_true_handled,
)
}
def __init__(self, parent=None):
"""
:param parent: a parent window for modal operation or None
:type parent: :class:`Gtk.Window`
"""
TextEntryDialog.__init__(
self, message=_('Enter the URL to open'), title=_('Open URL'), parent=parent
)
self.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.connect('response', self.on_response)
def run(self):
"""
Show the dialog and block until it's closed.
The dialog will be automatically destroyed on user response.
To obtain the entered URI, handle the "uri-selected" signal.
"""
self.show()
response = TextEntryDialog.run(self)
self.emit('response', response)
def show(self):
"""
Show the dialog and return immediately.
The dialog will be automatically destroyed on user response.
To obtain the entered URI, handle the "uri-selected" signal.
"""
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
text = clipboard.wait_for_text()
if text is not None:
f = Gio.File.new_for_uri(text)
if f.get_uri_scheme():
self.set_value(text)
TextEntryDialog.show_all(self)
def do_uri_selected(self, uri):
"""
Destroys the dialog
"""
self.destroy()
def on_response(self, dialog, response):
"""
Notifies about the selected URI
"""
self.hide()
if response == Gtk.ResponseType.OK:
self.emit('uri-selected', self.get_value())
# self.destroy()
'''
dialog = dialogs.TextEntryDialog(_('Enter the URL to open'),
_('Open URL'))
dialog.set_transient_for(self.main.window)
dialog.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
text = clipboard.wait_for_text()
if text is not None:
location = Gio.File.new_for_uri(text)
if location.get_uri_scheme() is not None:
dialog.set_value(text)
result = dialog.run()
dialog.hide()
if result == Gtk.ResponseType.OK:
url = dialog.get_value()
self.open_uri(url, play=False)
'''
class ListDialog(Gtk.Dialog):
"""
Shows a dialog with a list of specified items
Items must define a __str__ method, or be a string
"""
def __init__(self, title, parent=None, multiple=False, write_only=False):
"""
Initializes the dialog
"""
Gtk.Dialog.__init__(self, title=title, transient_for=parent)
self.vbox.set_border_width(5)
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.model = Gtk.ListStore(object)
self.list = Gtk.TreeView(model=self.model)
self.list.set_headers_visible(False)
self.list.connect(
'row-activated', lambda *e: self.response(Gtk.ResponseType.OK)
)
scroll.add(self.list)
scroll.set_shadow_type(Gtk.ShadowType.IN)
self.vbox.pack_start(scroll, True, True, 0)
if write_only:
self.add_buttons(Gtk.STOCK_OK, Gtk.ResponseType.OK)
else:
self.add_buttons(
Gtk.STOCK_CANCEL,
Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK,
Gtk.ResponseType.OK,
)
self.selection = self.list.get_selection()
if multiple:
self.selection.set_mode(Gtk.SelectionMode.MULTIPLE)
else:
self.selection.set_mode(Gtk.SelectionMode.SINGLE)
text = Gtk.CellRendererText()
col = Gtk.TreeViewColumn()
col.pack_start(text, True)
col.set_cell_data_func(text, self.cell_data_func)
self.list.append_column(col)
self.list.set_model(self.model)
self.resize(400, 240)
def get_items(self):
"""
Returns the selected items
"""
items = []
check = self.selection.get_selected_rows()
if not check:
return None
(model, paths) = check
for path in paths:
iter = self.model.get_iter(path)
item = self.model.get_value(iter, 0)
items.append(item)
return items
def run(self):
self.show_all()
result = Gtk.Dialog.run(self)
self.hide()
return result
def set_items(self, items):
"""
Sets the items
"""
for item in items:
self.model.append([item])
def cell_data_func(self, column, cell, model, iter, user_data):
"""
Called when the tree needs a value for column 1
"""
object = model.get_value(iter, 0)
cell.set_property('text', str(object))
# TODO: combine this and list dialog
class ListBox:
"""
Represents a list box
"""
def __init__(self, widget, rows=None):
"""
Initializes the widget
"""
self.list = widget
self.store = Gtk.ListStore(str)
widget.set_headers_visible(False)
cell = Gtk.CellRendererText()
col = Gtk.TreeViewColumn('', cell, text=0)
self.list.append_column(col)
self.rows = rows
if not rows:
self.rows = []
if rows:
for row in rows:
self.store.append([row])
self.list.set_model(self.store)
def connect(self, signal, func, data=None):
"""
Connects a signal to the underlying treeview
"""
self.list.connect(signal, func, data)
def append(self, row):
"""
Appends a row to the list
"""
self.rows.append(row)
self.set_rows(self.rows)
def remove(self, row):
"""
Removes a row
"""
try:
index = self.rows.index(row)
except ValueError:
return
path = (index,)
iter = self.store.get_iter(path)
self.store.remove(iter)
del self.rows[index]
def set_rows(self, rows):
"""
Sets the rows
"""
self.rows = rows
self.store = Gtk.ListStore(str)
for row in rows:
self.store.append([row])
self.list.set_model(self.store)
def get_selection(self):
"""
Returns the selection
"""
selection = self.list.get_selection()
(model, iter) = selection.get_selected()
if not iter:
return None
return model.get_value(iter, 0)
class FileOperationDialog(Gtk.FileChooserDialog):
"""
An extension of the Gtk.FileChooserDialog that
adds a collapsible panel to the bottom listing
valid file extensions that the file can be
saved in. (similar to the one in GIMP)
"""
def __init__(
self,
title: str = None,
parent: Optional[Gtk.Window] = None,
action: Gtk.FileChooserAction = Gtk.FileChooserAction.OPEN,
buttons: Optional[Iterable[Union[str, int]]] = None,
backend=None,
):
"""
Standard __init__ of the Gtk.FileChooserDialog.
Also sets up the expander and list for extensions
"""
Gtk.FileChooserDialog.__init__(self, title, parent, action, buttons, backend)
self.set_do_overwrite_confirmation(True)
# Container for additional option widgets
self.extras_box = Gtk.Box(spacing=3, orientation=Gtk.Orientation.VERTICAL)
self.set_extra_widget(self.extras_box)
self.extras_box.show()
# Create the list that will hold the file type/extensions pair
self.liststore = Gtk.ListStore(str, str)
self.list = Gtk.TreeView(model=self.liststore)
self.list.set_headers_visible(False)
# Create the columns
filetype_cell = Gtk.CellRendererText()
extension_cell = Gtk.CellRendererText()
column = Gtk.TreeViewColumn()
column.pack_start(filetype_cell, True)
column.pack_start(extension_cell, False)
column.set_attributes(filetype_cell, text=0)
column.set_attributes(extension_cell, text=1)
self.list.append_column(column)
self.list.show_all()
self.expander = Gtk.Expander.new(_('Select File Type (by Extension)'))
self.expander.add(self.list)
self.extras_box.pack_start(self.expander, False, False, 0)
self.expander.show()
selection = self.list.get_selection()
selection.connect('changed', self.on_selection_changed)
def on_selection_changed(self, selection):
"""
When the user selects an extension the filename
that is entered will have its extension changed
to the selected extension
"""
model, iter = selection.get_selected()
(extension,) = model.get(iter, 1)
filename = ""
if self.get_filename():
filename = os.path.basename(self.get_filename())
filename, old_extension = os.path.splitext(filename)
filename += '.' + extension
else:
filename = '*.' + extension
self.set_current_name(filename)
def add_extensions(self, extensions):
"""
Adds extensions to the list
@param extensions: a dictionary of extension:file type pairs
i.e. { 'm3u':'M3U Playlist' }
"""
for key, value in extensions.items():
self.liststore.append((value, key))
class MediaOpenDialog(Gtk.FileChooserDialog):
"""
A dialog for opening general media
"""
__gsignals__ = {
'uris-selected': (
GObject.SignalFlags.RUN_LAST,
GObject.TYPE_BOOLEAN,
(GObject.TYPE_PYOBJECT,),
GObject.signal_accumulator_true_handled,
)
}
_last_location = None
def __init__(self, parent=None):
"""
:param parent: a parent window for modal operation or None
:type parent: :class:`Gtk.Window`
"""
Gtk.FileChooserDialog.__init__(
self,
title=_('Choose Media to Open'),
parent=parent,
buttons=(
Gtk.STOCK_CANCEL,
Gtk.ResponseType.CANCEL,
Gtk.STOCK_OPEN,
Gtk.ResponseType.OK,
),
)
self.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.set_local_only(False)
self.set_select_multiple(True)
supported_filter = Gtk.FileFilter()
supported_filter.set_name(_('Supported Files'))
audio_filter = Gtk.FileFilter()
audio_filter.set_name(_('Music Files'))
playlist_filter = Gtk.FileFilter()
playlist_filter.set_name(_('Playlist Files'))
all_filter = Gtk.FileFilter()
all_filter.set_name(_('All Files'))
all_filter.add_pattern('*')
for extension in metadata.formats.keys():
pattern = '*.%s' % extension
supported_filter.add_pattern(pattern)
audio_filter.add_pattern(pattern)
playlist_file_extensions = (
ext
for p in providers.get('playlist-format-converter')
for ext in p.file_extensions
)
for extension in playlist_file_extensions:
pattern = '*.%s' % extension
supported_filter.add_pattern(pattern)
playlist_filter.add_pattern(pattern)
self.add_filter(supported_filter)
self.add_filter(audio_filter)
self.add_filter(playlist_filter)
self.add_filter(all_filter)
self.connect('response', self.on_response)
def run(self):
"""
Override to take care of the response
"""
if MediaOpenDialog._last_location is not None:
self.set_current_folder_uri(MediaOpenDialog._last_location)
response = Gtk.FileChooserDialog.run(self)
self.emit('response', response)
def show(self):
"""
Override to restore last location
"""
if MediaOpenDialog._last_location is not None:
self.set_current_folder_uri(MediaOpenDialog._last_location)
Gtk.FileChooserDialog.show(self)
def do_uris_selected(self, uris):
"""
Destroys the dialog
"""
self.destroy()
def on_response(self, dialog, response):
"""
Notifies about selected URIs
"""
self.hide()
if response == Gtk.ResponseType.OK:
MediaOpenDialog._last_location = self.get_current_folder_uri()
self.emit('uris-selected', self.get_uris())
# self.destroy()
class DirectoryOpenDialog(Gtk.FileChooserDialog):
"""
A dialog specialized for opening directories
"""
__gsignals__ = {
'uris-selected': (
GObject.SignalFlags.RUN_LAST,
GObject.TYPE_BOOLEAN,
(GObject.TYPE_PYOBJECT,),
GObject.signal_accumulator_true_handled,
)
}
_last_location = None
def __init__(
self,
parent: Optional[Gtk.Window] = None,
title: str = _('Choose Directory to Open'),
select_multiple: bool = True,
):
Gtk.FileChooserDialog.__init__(self, title=title, transient_for=parent)
self.add_buttons(
Gtk.STOCK_CANCEL,
Gtk.ResponseType.CANCEL,
Gtk.STOCK_OPEN,
Gtk.ResponseType.OK,
)
self.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.set_action(Gtk.FileChooserAction.SELECT_FOLDER)
self.set_local_only(False)
self.set_select_multiple(select_multiple)
self.connect('response', self.on_response)
def run(self):
"""
Override to take care of the response
"""
if DirectoryOpenDialog._last_location is not None:
self.set_current_folder_uri(DirectoryOpenDialog._last_location)
Gtk.FileChooserDialog.run(self)
def show(self):
"""
Override to restore last location
"""
if DirectoryOpenDialog._last_location is not None:
self.set_current_folder_uri(DirectoryOpenDialog._last_location)
Gtk.FileChooserDialog.show(self)
def do_uris_selected(self, uris):
"""
Destroys the dialog
"""
self.destroy()
def on_response(self, dialog, response):
"""
Notifies about selected URIs
"""
self.hide()
if response == Gtk.ResponseType.OK:
DirectoryOpenDialog._last_location = self.get_current_folder_uri()
self.emit('uris-selected', self.get_uris())
# self.destroy()
class PlaylistImportDialog(Gtk.FileChooserDialog):
"""
A dialog for importing a playlist
"""
__gsignals__ = {
'playlists-selected': (
GObject.SignalFlags.RUN_LAST,
GObject.TYPE_BOOLEAN,
(GObject.TYPE_PYOBJECT,),
GObject.signal_accumulator_true_handled,
)
}
_last_location = None
def __init__(self, parent=None):
"""
:param parent: a parent window for modal operation or None
:type parent: :class:`Gtk.Window`
"""
Gtk.FileChooserDialog.__init__(
self,
title=_('Import Playlist'),
parent=parent,
buttons=(
Gtk.STOCK_CANCEL,
Gtk.ResponseType.CANCEL,
Gtk.STOCK_OPEN,
Gtk.ResponseType.OK,
),
)
self.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.set_local_only(False)
self.set_select_multiple(True)
playlist_filter = Gtk.FileFilter()
playlist_filter.set_name(_('Playlist Files'))
all_filter = Gtk.FileFilter()
all_filter.set_name(_('All Files'))
all_filter.add_pattern('*')
playlist_file_extensions = (
ext
for p in providers.get('playlist-format-converter')
for ext in p.file_extensions
)
for extension in playlist_file_extensions:
pattern = '*.%s' % extension
playlist_filter.add_pattern(pattern)
self.add_filter(playlist_filter)
self.add_filter(all_filter)
self.connect('response', self.on_response)
def run(self):
"""
Override to take care of the response
"""
if PlaylistImportDialog._last_location is not None:
self.set_current_folder_uri(PlaylistImportDialog._last_location)
response = Gtk.FileChooserDialog.run(self)
self.emit('response', response)
def show(self):
"""
Override to restore last location
"""
if PlaylistImportDialog._last_location is not None:
self.set_current_folder_uri(PlaylistImportDialog._last_location)
Gtk.FileChooserDialog.show(self)
def do_playlist_selected(self, uris):
"""
Destroys the dialog
"""
self.destroy()
def on_response(self, dialog, response):
"""
Notifies about selected URIs
"""
self.hide()
if response == Gtk.ResponseType.OK:
PlaylistImportDialog._last_location = self.get_current_folder_uri()
playlists = []
for uri in self.get_uris():
try:
playlists.append(import_playlist(uri))
except InvalidPlaylistTypeError as e:
error(
self.get_transient_for(), 'Invalid playlist "%s": %s' % (uri, e)
)
self.destroy()
return
except Exception as e:
error(
self.get_transient_for(),
'Invalid playlist "%s": (internal error): %s' % (uri, e),
)
self.destroy()
return
self.emit('playlists-selected', playlists)
# self.destroy()
class PlaylistExportDialog(FileOperationDialog):
"""
A dialog specialized for playlist export
"""
__gsignals__ = {
'message': (
GObject.SignalFlags.RUN_LAST,
GObject.TYPE_BOOLEAN,
(Gtk.MessageType, GObject.TYPE_STRING),
GObject.signal_accumulator_true_handled,
)
}
def __init__(self, playlist, parent=None):
"""
:param playlist: the playlist to export
:type playlist: :class:`xl.playlist.Playlist`
:param parent: a parent window for modal operation or None
:type parent: :class:`Gtk.Window`
"""
FileOperationDialog.__init__(
self,
title=_('Export Current Playlist'),
parent=parent,
action=Gtk.FileChooserAction.SAVE,
buttons=(
Gtk.STOCK_CANCEL,
Gtk.ResponseType.CANCEL,
Gtk.STOCK_SAVE,
Gtk.ResponseType.OK,
),
)
self.set_current_folder_uri(
settings.get_option('gui/playlist_export_dir')
or GLib.filename_to_uri(xdg.homedir, None)
)
self.set_local_only(False)
self.relative_checkbox = Gtk.CheckButton(_('Use relative paths to tracks'))
self.relative_checkbox.set_active(True)
self.extras_box.pack_start(self.relative_checkbox, False, False, 3)
self.relative_checkbox.show()
self.playlist = playlist
extensions = {}
for provider in providers.get('playlist-format-converter'):
extensions[provider.name] = provider.title
self.add_extensions(extensions)
self.set_current_name('%s.m3u' % playlist.name)
self.connect('response', self.on_response)
def run(self):
"""
Override to take care of the response
"""
response = FileOperationDialog.run(self)
self.emit('response', response)
def do_message(self, message_type, message):
"""
Displays simple dialogs on messages
"""
if message_type == Gtk.MessageType.INFO:
info(self.get_transient_for(), markup=message)
elif message_type == Gtk.MessageType.ERROR:
error(self.get_transient_for(), markup=message)
def on_response(self, dialog, response):
"""
Exports the playlist if requested
"""
self.hide()
if response == Gtk.ResponseType.OK:
gfile = self.get_file()
settings.set_option('gui/playlist_export_dir', gfile.get_parent().get_uri())
path = gfile.get_uri()
if not is_valid_playlist(path):
path = '%s.m3u' % path
options = PlaylistExportOptions(
relative=self.relative_checkbox.get_active()
)
try:
export_playlist(self.playlist, path, options)
except InvalidPlaylistTypeError as e:
self.emit('message', Gtk.MessageType.ERROR, str(e))
else:
gio = Gio.File.new_for_uri(path)
path = gio.get_path()
self.emit(
'message',
Gtk.MessageType.INFO,
_('Playlist saved as %s.') % path,
)
class ConfirmCloseDialog(Gtk.MessageDialog):
"""
Shows the dialog to confirm closing of the playlist
"""
def __init__(self, document_name):
"""
Initializes the dialog
"""
Gtk.MessageDialog.__init__(self, type=Gtk.MessageType.WARNING)
self.set_title(_('Close %s' % document_name))
self.set_markup(_('Save changes to %s before closing?') % document_name)
self.format_secondary_text(
_('Your changes will be lost if you don\'t save them')
)
self.add_buttons(
_('Close Without Saving'),
100,
Gtk.STOCK_CANCEL,
Gtk.ResponseType.CANCEL,
Gtk.STOCK_SAVE,
110,
)
def run(self):
self.show_all()
response = Gtk.Dialog.run(self)
self.hide()
return response
class MessageBar(Gtk.InfoBar):
type_map = {
Gtk.MessageType.INFO: 'dialog-information',
Gtk.MessageType.QUESTION: 'dialog-question',
Gtk.MessageType.WARNING: 'dialog-warning',
Gtk.MessageType.ERROR: 'dialog-error',
}
buttons_map = {
Gtk.ButtonsType.OK: [(Gtk.STOCK_OK, Gtk.ResponseType.OK)],
Gtk.ButtonsType.CLOSE: [(Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE)],
Gtk.ButtonsType.CANCEL: [(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)],
Gtk.ButtonsType.YES_NO: [
(Gtk.STOCK_NO, Gtk.ResponseType.NO),
(Gtk.STOCK_YES, Gtk.ResponseType.YES),
],
Gtk.ButtonsType.OK_CANCEL: [
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL),
(Gtk.STOCK_OK, Gtk.ResponseType.OK),
],
}
def __init__(
self,
parent=None,
type=Gtk.MessageType.INFO,
buttons=Gtk.ButtonsType.NONE,
text=None,
):
"""
Report important messages to the user
:param parent: the parent container box
:type parent: :class:`Gtk.Box`
:param type: the type of message: Gtk.MessageType.INFO,
Gtk.MessageType.WARNING, Gtk.MessageType.QUESTION or
Gtk.MessageType.ERROR.
:param buttons: the predefined set of buttons to
use: Gtk.ButtonsType.NONE, Gtk.ButtonsType.OK,
Gtk.ButtonsType.CLOSE, Gtk.ButtonsType.CANCEL,
Gtk.ButtonsType.YES_NO, Gtk.ButtonsType.OK_CANCEL
:param text: a string containing the message
text or None
"""
if parent is not None and not isinstance(parent, Gtk.Box):
raise TypeError('Parent needs to be of type Gtk.Box')
Gtk.InfoBar.__init__(self)
self.set_no_show_all(True)
if parent is not None:
parent.add(self)
parent.reorder_child(self, 0)
parent.child_set_property(self, 'expand', False)
self.image = Gtk.Image()
self.set_message_type(type)
self.primary_text = Gtk.Label(label=text)
self.primary_text.set_property('xalign', 0)
self.primary_text.set_line_wrap(True)
self.secondary_text = Gtk.Label()
self.secondary_text.set_property('xalign', 0)
self.secondary_text.set_line_wrap(True)
self.secondary_text.set_no_show_all(True)
self.secondary_text.set_selectable(True)
self.message_area = Gtk.Box(spacing=12, orientation=Gtk.Orientation.VERTICAL)
self.message_area.pack_start(self.primary_text, False, False, 0)
self.message_area.pack_start(self.secondary_text, False, False, 0)
box = Gtk.Box(spacing=6)
box.pack_start(self.image, False, True, 0)
box.pack_start(self.message_area, True, True, 0)
content_area = self.get_content_area()
content_area.add(box)
content_area.show_all()
self.action_area = self.get_action_area()
self.action_area.set_property('layout-style', Gtk.ButtonBoxStyle.START)
if buttons != Gtk.ButtonsType.NONE:
for text, response in self.buttons_map[buttons]:
self.add_button(text, response)
self.primary_text_attributes = Pango.AttrList()
# TODO: GI: Pango attr
# self.primary_text_attributes.insert(
# Pango.AttrWeight(Pango.Weight.NORMAL, 0, -1))
# self.primary_text_attributes.insert(
# Pango.AttrScale(Pango.SCALE_MEDIUM, 0, -1))'''
self.primary_text_emphasized_attributes = Pango.AttrList()
# TODO: GI: Pango attr
# self.primary_text_emphasized_attributes.insert(
# Pango.AttrWeight(Pango.Weight.BOLD, 0, -1))
# self.primary_text_emphasized_attributes.insert(
# Pango.AttrScale(Pango.SCALE_LARGE, 0, -1))'''
self.connect('response', self.on_response)
# Workaround for https://bugzilla.gnome.org/show_bug.cgi?id=710888
# -> From pitivi: https://phabricator.freedesktop.org/D1103#34aa2703
def _make_sure_revealer_does_nothing(widget):
if not isinstance(widget, Gtk.Revealer):
return
widget.set_transition_type(Gtk.RevealerTransitionType.NONE)
self.forall(_make_sure_revealer_does_nothing)
def set_text(self, text):
"""
Sets the primary text of the message bar
:param markup: a regular text string
:type markup: string
"""
self.primary_text.set_text(text)
def set_markup(self, markup):
"""
Sets the primary markup text of the message bar
:param markup: a markup string
:type markup: string
"""
self.primary_text.set_markup(markup)
def set_secondary_text(self, text):
"""
Sets the secondary text to the text
specified by message_format
:param text: The text to be displayed
as the secondary text or None.
:type text: string
"""
if text is None:
self.secondary_text.hide()
self.primary_text.set_attributes(self.primary_text_attributes)
else:
self.secondary_text.set_text(text)
self.secondary_text.show()
self.primary_text.set_attributes(self.primary_text_emphasized_attributes)
def set_secondary_markup(self, markup):
"""
Sets the secondary text to the markup text
specified by text.
:param text: A string containing the
pango markup to use as secondary text.
:type text: string
"""
if markup is None:
self.secondary_text.hide()
self.primary_text.set_attributes(self.primary_text_attributes)
else:
self.secondary_text.set_markup(markup)
self.secondary_text.show()
self.primary_text.set_attributes(self.primary_text_emphasized_attributes)
def set_image(self, image):
"""
Sets the contained image to the :class:`Gtk.Widget`
specified by image.
:param image: the image widget
:type image: :class:`Gtk.Widget`
"""
box = self.image.get_parent()
box.remove(self.image)
self.image = image
box.pack_start(self.image, False, True, 0)
box.reorder_child(self.image, 0)
self.image.show()
def get_image(self):
"""
Gets the contained image
"""
return self.image
def add_button(self, button_text, response_id):
"""
Overrides :class:`Gtk.InfoBar` to prepend
instead of append to the action area
:param button_text: text of button, or stock ID
:type button_text: string
:param response_id: response ID for the button
:type response_id: int
"""
button = Gtk.InfoBar.add_button(self, button_text, response_id)
self.action_area.reorder_child(button, 0)
return button
def clear_buttons(self):
"""
Removes all buttons currently
placed in the action area
"""
for button in self.action_area:
self.action_area.remove(button)
def set_message_type(self, type):
"""
Sets the message type of the message area.
:param type: the type of message: Gtk.MessageType.INFO,
Gtk.MessageType.WARNING, Gtk.MessageType.QUESTION or
Gtk.MessageType.ERROR.
"""
if type != Gtk.MessageType.OTHER:
self.image.set_from_icon_name(self.type_map[type], Gtk.IconSize.DIALOG)
Gtk.InfoBar.set_message_type(self, type)
def get_message_area(self):
"""
Retrieves the message area
"""
return self.message_area
def _show_message(
self, message_type, text, secondary_text, markup, secondary_markup, timeout
):
"""
Helper for the various `show_*` methods. See `show_info` for
documentation on the parameters.
"""
if text is markup is None:
raise ValueError("text or markup must be specified")
self.set_message_type(message_type)
if markup is None:
self.set_text(text)
else:
self.set_markup(markup)
if secondary_markup is None:
self.set_secondary_text(secondary_text)
else:
self.set_secondary_markup(secondary_markup)
self.show()
if timeout > 0:
GLib.timeout_add_seconds(timeout, self.hide)
def show_info(
self,
text=None,
secondary_text=None,
markup=None,
secondary_markup=None,
timeout=5,
):
"""
Convenience method which sets all
required flags for an info message
:param text: the message to display
:type text: string
:param secondary_text: additional information
:type secondary_text: string
:param markup: the message to display, in Pango markup format
(overrides `text`)
:type markup: string
:param secondary_markup: additional information, in Pango markup
format (overrides `secondary_text`)
:type secondary_markup: string
:param timeout: after how many seconds the
message should be hidden automatically,
use 0 to disable this behavior
:type timeout: int
"""
self._show_message(
Gtk.MessageType.INFO,
text,
secondary_text,
markup,
secondary_markup,
timeout,
)
def show_question(
self, text=None, secondary_text=None, markup=None, secondary_markup=None
):
"""
Convenience method which sets all
required flags for a question message
:param text: the message to display
:param secondary_text: additional information
:param markup: the message to display, in Pango markup format
:param secondary_markup: additional information, in Pango markup format
"""
self._show_message(
Gtk.MessageType.QUESTION, text, secondary_text, markup, secondary_markup, 0
)
def show_warning(
self, text=None, secondary_text=None, markup=None, secondary_markup=None
):
"""
Convenience method which sets all
required flags for a warning message
:param text: the message to display
:param secondary_text: additional information
:param markup: the message to display, in Pango markup format
:param secondary_markup: additional information, in Pango markup format
"""
self._show_message(
Gtk.MessageType.WARNING, text, secondary_text, markup, secondary_markup, 0
)
def show_error(
self, text=None, secondary_text=None, markup=None, secondary_markup=None
):
"""
Convenience method which sets all
required flags for a warning message
:param text: the message to display
:param secondary_text: additional information
:param markup: the message to display, in Pango markup format
:param secondary_markup: additional information, in Pango markup format
"""
self._show_message(
Gtk.MessageType.ERROR, text, secondary_text, markup, secondary_markup, 0
)
def on_response(self, widget, response):
"""
Handles the response for closing
"""
if response == Gtk.ResponseType.CLOSE:
self.hide()
#
# Message ID's used by the XMessageDialog
#
XRESPONSE_YES = Gtk.ResponseType.YES
XRESPONSE_YES_ALL = 8000
XRESPONSE_NO = Gtk.ResponseType.NO
XRESPONSE_NO_ALL = 8001
XRESPONSE_CANCEL = Gtk.ResponseType.CANCEL
class XMessageDialog(Gtk.Dialog):
'''Used to show a custom message dialog with custom buttons'''
def __init__(
self,
title,
text,
parent=None,
show_yes=True,
show_yes_all=True,
show_no=True,
show_no_all=True,
show_cancel=True,
):
Gtk.Dialog.__init__(self, title=title, transient_for=parent)
#
# TODO: Make these buttons a bit prettier
#
if show_yes:
self.add_button(Gtk.STOCK_YES, XRESPONSE_YES)
self.set_default_response(XRESPONSE_YES)
if show_yes_all:
self.add_button(_('Yes to all'), XRESPONSE_YES_ALL)
self.set_default_response(XRESPONSE_YES_ALL)
if show_no:
self.add_button(Gtk.STOCK_NO, XRESPONSE_NO)
self.set_default_response(XRESPONSE_NO)
if show_no_all:
self.add_button(_('No to all'), XRESPONSE_NO_ALL)
self.set_default_response(XRESPONSE_NO_ALL)
if show_cancel:
self.add_button(Gtk.STOCK_CANCEL, XRESPONSE_CANCEL)
self.set_default_response(XRESPONSE_CANCEL)
vbox = self.get_content_area()
self._label = Gtk.Label()
self._label.set_use_markup(True)
self._label.set_markup(text)
vbox.pack_start(self._label, True, True, 0)
class FileCopyDialog(Gtk.Dialog):
"""
Used to copy a list of files to a single destination directory
Usage:
dialog = FileCopyDialog( [file_uri,..], destination_uri, text, parent)
dialog.do_copy()
Do not use run() on this dialog!
"""
class CopyThread(Thread):
def __init__(self, source, dest, callback_finish_single_copy, copy_flags):
Thread.__init__(self, name='CopyThread')
self.__source = source
self.__dest = dest
self.__cb_single_copy = callback_finish_single_copy
self.__copy_flags = copy_flags
self.__cancel = Gio.Cancellable()
self.start()
def run(self):
try:
result = self.__source.copy(
self.__dest, flags=self.__copy_flags, cancellable=self.__cancel
)
GLib.idle_add(self.__cb_single_copy, self.__source, result, None)
except GLib.Error as err:
GLib.idle_add(self.__cb_single_copy, self.__source, False, err)
def cancel_copy(self):
self.__cancel.cancel()
def __init__(
self,
file_uris,
destination_uri,
title,
text=_("Saved %(count)s of %(total)s."),
parent=None,
):
self.file_uris = file_uris
self.destination_uri = destination_uri
self.is_copying = False
Gtk.Dialog.__init__(self, title=title, transient_for=parent)
self.parent = parent
self.count = 0
self.total = len(file_uris)
self.text = text
self.overwrite_response = None
# self.set_modal(True)
# self.set_decorated(False)
self.set_resizable(False)
# self.set_focus_on_map(False)
vbox = self.get_content_area()
vbox.set_spacing(12)
vbox.set_border_width(12)
self._label = Gtk.Label()
self._label.set_use_markup(True)
self._label.set_markup(self.text % {'count': 0, 'total': self.total})
vbox.pack_start(self._label, True, True, 0)
self._progress = Gtk.ProgressBar()
self._progress.set_size_request(300, -1)
vbox.pack_start(self._progress, True, True, 0)
self.show_all()
# TODO: Make dialog cancelable
# self.cancel_button.connect('activate', lambda *e: self.cancel.cancel() )
self.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
def do_copy(self):
logger.info("Copy started.")
self._start_next_copy()
self.show_all()
self.connect('response', self._on_response)
def run(self):
raise NotImplementedError("Don't use this")
def _on_response(self, widget, response):
logger.info("Copy complete.")
self.destroy()
def _step(self):
'''Steps the progress bar'''
self.count += 1
self._progress.set_fraction(clamp(self.count / float(self.total), 0, 1))
self._label.set_markup(self.text % {'count': self.count, 'total': self.total})
def _start_next_copy(self, overwrite=False):
if self.count == len(self.file_uris):
self.response(Gtk.ResponseType.OK)
return
flags = Gio.FileCopyFlags.NONE
src_uri = self.file_uris[self.count]
dst_uri = self.destination_uri + '/' + src_uri.split('/')[-1]
self.source = Gio.File.new_for_uri(src_uri)
self.destination = Gio.File.new_for_uri(dst_uri)
if not overwrite:
if self.destination.query_exists(None):
if self.overwrite_response == XRESPONSE_YES_ALL:
overwrite = True
elif (
self.overwrite_response == XRESPONSE_NO_ALL
or self.overwrite_response == XRESPONSE_NO
):
# only deny the overwrite once..
if self.overwrite_response == XRESPONSE_NO:
self.overwrite_response = None
logging.info("NoOverwrite: %s" % self.destination.get_uri())
self._step()
GLib.idle_add(self._start_next_copy) # don't recurse
return
else:
self._query_overwrite()
return
if overwrite:
flags = Gio.FileCopyFlags.OVERWRITE
try:
# Gio.FileCopyFlags.OVERWRITE doesn't actually work
logging.info("DeleteDest : %s" % self.destination.get_uri())
self.destination.delete()
except GLib.Error:
pass
logging.info("CopySource : %s" % self.source.get_uri())
logging.info("CopyDest : %s" % self.destination.get_uri())
# TODO g_file_copy_async() isn't introspectable
# see https://github.com/exaile/exaile/issues/198 for details
# self.source.copy_async( self.destination, self._finish_single_copy_async, flags=flags, cancellable=self.cancel )
self.cpthr = self.CopyThread(
self.source, self.destination, self._finish_single_copy, flags
)
def _finish_single_copy(self, source, success, error):
if error:
self._on_error(
_("Error occurred while copying %s: %s")
% (
GLib.markup_escape_text(self.source.get_uri()),
GLib.markup_escape_text(str(error)),
)
)
if success:
self._step()
self._start_next_copy()
def _finish_single_copy_async(self, source, async_result):
try:
if source.copy_finish(async_result):
self._step()
self._start_next_copy()
except GLib.Error as e:
self._on_error(
_("Error occurred while copying %s: %s")
% (
GLib.markup_escape_text(self.source.get_uri()),
GLib.markup_escape_text(str(e)),
)
)
def _query_overwrite(self):
self.hide()
text = _('File exists, overwrite %s ?') % GLib.markup_escape_text(
self.destination.get_uri()
)
dialog = XMessageDialog(self.parent, text)
dialog.connect('response', self._on_query_overwrite_response, dialog)
dialog.show_all()
dialog.grab_focus()
self.query_dialog = dialog
def _on_query_overwrite_response(self, widget, response, dialog):
dialog.destroy()
self.overwrite_response = response
if response == Gtk.ResponseType.CANCEL:
self.response(response)
else:
if response == XRESPONSE_NO or response == XRESPONSE_NO_ALL:
overwrite = False
else:
overwrite = True
self.show_all()
self._start_next_copy(overwrite)
def _on_error(self, message):
self.hide()
dialog = Gtk.MessageDialog(
buttons=Gtk.ButtonsType.CLOSE,
message_type=Gtk.MessageType.ERROR,
modal=True,
text=message,
transient_for=self.parent,
)
dialog.set_markup(message)
dialog.connect('response', self._on_error_response, dialog)
dialog.show()
dialog.grab_focus()
self.error_dialog = dialog
def _on_error_response(self, widget, response, dialog):
self.response(Gtk.ResponseType.CANCEL)
dialog.destroy()
def ask_for_playlist_name(parent, playlist_manager, name=None):
"""
Returns a user-selected name that is not already used
in the specified playlist manager
:param name: A default name to show to the user
Returns None if the user hits cancel
"""
while True:
dialog = TextEntryDialog(
_('Playlist name:'),
_('Add new playlist...'),
name,
parent=parent,
okbutton=Gtk.STOCK_ADD,
)
result = dialog.run()
if result != Gtk.ResponseType.OK:
return None
name = dialog.get_value()
if name == '':
error(parent, _("You did not enter a name for your playlist"))
elif playlist_manager.has_playlist_name(name):
# name is already in use
error(parent, _("The playlist name you entered is already in use."))
else:
return name
def save(
parent, output_fname, output_setting=None, extensions=None, title=_("Save As")
):
"""
A 'save' dialog utility function, which can be used to easily
remember the last location the user saved something.
:param parent: Parent window
:param output_fname: Output filename
:param output_setting: Setting to store the last 'output directory' saved at
:param extensions: Valid output extensions. Dict { '.m3u': 'Description', .. }
:param title: Title of dialog
:returns: None if user cancels, chosen URI otherwise
"""
uri = None
dialog = FileOperationDialog(
title,
parent,
Gtk.FileChooserAction.SAVE,
(
Gtk.STOCK_CANCEL,
Gtk.ResponseType.CANCEL,
Gtk.STOCK_SAVE,
Gtk.ResponseType.ACCEPT,
),
)
if extensions is not None:
dialog.add_extensions(extensions)
dialog.set_current_name(output_fname)
if output_setting:
output_dir = settings.get_option(output_setting)
if output_dir:
dialog.set_current_folder_uri(output_dir)
if dialog.run() == Gtk.ResponseType.ACCEPT:
uri = dialog.get_uri()
settings.set_option(output_setting, dialog.get_current_folder_uri())
dialog.destroy()
return uri
def export_playlist_dialog(playlist, parent=None):
'''Exports the playlist to a user-specified path'''
if playlist is not None:
dialog = PlaylistExportDialog(playlist, parent)
dialog.show()
def export_playlist_files(playlist, parent=None):
'''Exports the playlist files to a user-specified URI'''
if playlist is None:
return
def _on_uri(uri):
if hasattr(playlist, 'get_playlist'):
pl = playlist.get_playlist()
else:
pl = playlist
pl_files = [track.get_loc_for_io() for track in pl]
dialog = FileCopyDialog(
pl_files, uri, _('Exporting %s') % playlist.name, parent=parent
)
dialog.do_copy()
dialog = DirectoryOpenDialog(
title=_('Choose directory to export files to'), parent=parent
)
dialog.set_select_multiple(False)
dialog.connect('uris-selected', lambda widget, uris: _on_uri(uris[0]))
dialog.run()
dialog.destroy()
class UpdateInfoDialog:
def __init__(self, parent=None):
self.builder = guiutil.get_builder(
xdg.get_data_path('ui', 'widgets', 'info_dialog.ui')
)
self.builder.connect_signals(self)
self.window = self.builder.get_object('info_dialog')
self.window.set_transient_for(parent)
self.window.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.window.show_all()
self.dont_show_again = self.builder.get_object('dont_show_again')
def on_close_button_clicked(self, widget):
self.window.destroy()
def on_window_destroy(self, widget):
if self.dont_show_again.get_active():
settings.set_option('general/hide_413_dialog', True)
else:
settings.set_option('general/hide_413_dialog', False)