def _conversions_panel():
extras = []
lab = widgetset.Label(_("Binaries to use:"))
lab.set_bold(True)
extras.append(align_left(lab))
grid = dialogwidgets.ControlGrid()
grid.pack_label(_("ffmpeg binary path:"), grid.ALIGN_RIGHT)
ffmpeg_binary = widgetset.TextEntry()
attach_text(ffmpeg_binary, options.FFMPEG_BINARY)
grid.pack(ffmpeg_binary)
grid.end_line(spacing=4)
grid.pack_label(_("ffmpeg2theora binary path:"), grid.ALIGN_RIGHT)
ffmpeg2theora_binary = widgetset.TextEntry()
attach_text(ffmpeg2theora_binary, options.FFMPEG2THEORA_BINARY)
grid.pack(ffmpeg2theora_binary)
grid.end_line(spacing=4)
extras.append(align_left(grid.make_table()))
return extras
def ask_for_string(title, description, initial_text=None, transient_for=None):
"""Ask the user to enter a string in a TextEntry box.
description - textual description with newlines
initial_text - None, string or callable to pre-populate the entry box
Returns the value entered, or None if the user clicked cancel
"""
window = MainDialog(title, description)
try:
window.add_button(BUTTON_OK.text)
window.add_button(BUTTON_CANCEL.text)
entry = widgetset.TextEntry()
entry.set_activates_default(True)
if initial_text:
if callable(initial_text):
initial_text = initial_text()
entry.set_text(initial_text)
window.set_extra_widget(entry)
response = window.run()
if response == 0:
return entry.get_text()
else:
return None
finally:
window.destroy()
def build_extra_widget(self, window):
self.checkbox = widgetset.Checkbox(self.dialog.checkbox_text)
self.checkbox.set_checked(self.dialog.checkbox_value)
self.entry = widgetset.TextEntry(self.dialog.textbox_value)
self.entry.set_activates_default(True)
vbox = widgetset.VBox()
vbox.pack_start(self.checkbox)
vbox.pack_start(self.entry)
window.set_extra_widget(vbox)
def build_extra_widget(self, window):
self.entry = widgetset.TextEntry()
initial = None
if self.dialog.fillWithClipboardURL:
initial = 'http://clipboard.com/'
if initial is None and self.dialog.prefill_callback:
initial = self.dialog.prefill_callback()
if initial is not None:
self.entry.set_text(initial)
self.entry.set_activates_default(True)
window.set_extra_widget(self.entry)
def build_extra_widget(self, window):
table = widgetset.Table(2, 2)
table.set_column_spacing(12)
table.pack(widgetset.Label(_("Username:"******"Password:")), 0, 1)
self.password_entry = widgetset.SecureTextEntry(
self.dialog.prefill_password)
self.password_entry.set_activates_default(True)
table.pack(self.password_entry, 1, 1)
window.set_extra_widget(widgetutil.align_center(table))
def run_dialog(self):
"""
Returns (directory, show-in-sidebar) or None
"""
try:
extra = widgetset.VBox(spacing=10)
if self.previous_error:
extra.pack_start(widgetset.Label(self.previous_error))
self.folder_entry = widgetset.TextEntry()
self.folder_entry.set_activates_default(True)
self.folder_entry.set_text(filename_to_unicode(self.path))
self.folder_entry.set_size_request(300, -1)
choose_button = widgetset.Button(_("Choose..."))
choose_button.connect('clicked', self.handle_choose)
h = widgetset.HBox(spacing=5)
h.pack_start(
widgetutil.align_middle(widgetset.Label(_("Directory:"))))
h.pack_start(widgetutil.align_middle(self.folder_entry))
h.pack_start(widgetutil.align_middle(choose_button))
extra.pack_start(h)
self.visible_checkbox = widgetset.Checkbox(
_("Show in my sidebar as a podcast"))
self.visible_checkbox.set_checked(True)
extra.pack_start(self.visible_checkbox)
self.vbox = extra
self.set_extra_widget(extra)
self.add_button(BUTTON_ADD_FOLDER.text)
self.add_button(BUTTON_CANCEL.text)
ret = self.run()
if ret == 0:
# 17407 band-aid - don't init with PlatformFilenameType since
# str use ascii codec
dir = self.folder_entry.get_text()
if PlatformFilenameType == str:
dir = dir.encode('utf-8')
return (dir, self.visible_checkbox.get_checked())
return None
except StandardError:
logging.exception("newwatchedfolder threw exception.")
def _build_add_playlist_section(self, bottom):
hbox = widgetset.HBox()
label = widgetset.Label(_("Name"))
hbox.pack_start(widgetutil.align_middle(label))
self.name_entry = widgetset.TextEntry()
self.name_entry.set_size_request(400, -1)
self.name_entry.connect('activate', self._on_add_playlist)
hbox.pack_start(widgetutil.align_middle(self.name_entry, left_pad=15))
self.add_playlist_button = widgetutil.TitlebarButton(_("Add Playlist"))
self.add_playlist_button.connect('clicked', self._on_add_playlist)
hbox.pack_start(
widgetutil.align_middle(self.add_playlist_button, left_pad=15))
bg = widgetutil.RoundedSolidBackground(
widgetutil.css_to_color('#e4e4e4'))
bg.add(widgetutil.pad(hbox, 10, 10, 10, 10))
bottom.pack_start(bg)
def _run_dialog(title, description, default_type):
"""Creates and launches the New Folder dialog. This dialog waits for
the user to press "Create Folder" or "Cancel".
Returns a the name, or None.
"""
window = MainDialog(title, description)
try:
try:
window.add_button(BUTTON_CREATE_FOLDER.text)
window.add_button(BUTTON_CANCEL.text)
extra = widgetset.VBox()
lab = widgetset.Label(_('Folder name:'))
name_entry = widgetset.TextEntry()
name_entry.set_activates_default(True)
h = widgetset.HBox()
h.pack_start(lab, padding=5)
h.pack_start(name_entry, expand=True)
extra.pack_start(h, padding=5)
window.set_extra_widget(extra)
response = window.run()
if response == 0:
name = name_entry.get_text()
if name:
return name
return None
except StandardError:
logging.exception("newfeed threw exception.")
finally:
window.destroy()
def _run_dialog(title, description, initial_text):
"""Creates and launches the New Feed dialog. This dialog waits for
the user to press "Create Podcast" or "Cancel".
Returns the URL, or None.
"""
window = MainDialog(title, description)
try:
try:
window.add_button(BUTTON_CREATE_FEED.text)
window.add_button(BUTTON_CANCEL.text)
extra = widgetset.VBox()
lab = widgetset.Label(_('URL:'))
url_entry = widgetset.TextEntry()
url_entry.set_text(initial_text)
url_entry.set_activates_default(True)
h = widgetset.HBox()
h.pack_start(lab, padding=5)
h.pack_start(url_entry, expand=True)
extra.pack_start(h, padding=5)
window.set_extra_widget(extra)
response = window.run()
if response == 0:
text = url_entry.get_text()
return text
return None
except StandardError:
logging.exception("newfeed threw exception.")
finally:
window.destroy()
def __init__(self, field, items, label):
Field.__init__(self, field, items, label)
self.widget = widgetset.TextEntry()
self.widget.set_text(self.common_value or "")
def _build_daap_section(self, bottom):
label = self.build_header(
_("%(shortappname)s Sharing", self.trans_data))
bottom.pack_start(
widgetutil.align_left(label, left_pad=20, bottom_pad=10))
# Note: "Miro iPad app" is the name of a piece of software--
# don't substitute Miro for %(appname)s here.
label = widgetset.Label(
_(
"%(shortappname)s can stream and download files to and from "
"other %(shortappname)ss on your local network and to the "
"Miro iPad app. It's awesome!", self.trans_data))
label.set_size(self.TEXT_SIZE)
label.set_color(self.TEXT_COLOR)
label.set_wrap(True)
label.set_size_request(550, -1)
bottom.pack_start(
widgetutil.align_left(label, left_pad=20, bottom_pad=20))
if not app.sharing_manager.mdns_present:
label = widgetset.Label(_("Disabled: Needs Bonjour"))
label.set_bold(True)
bottom.pack_start(
widgetutil.align_left(label,
left_pad=20,
bottom_pad=20,
top_pad=10))
return
container = widgetset.HBox()
self.share_button = PrettyToggleButton()
self.share_button.connect('clicked', self.daap_changed)
self.share_button.connect('dragged-left', self.daap_changed)
self.share_button.connect('dragged-right', self.daap_changed)
self.share_button.set_value(app.config.get(prefs.SHARE_MEDIA))
container.pack_start(widgetutil.pad(self.share_button, right=20))
vbox = widgetset.VBox()
hbox = widgetset.HBox(spacing=30)
self.share_audio_cbx = widgetset.Checkbox(_("Share Music"), bold=True)
self.share_video_cbx = widgetset.Checkbox(_("Share Videos"), bold=True)
self.share_warnonquit_cbx = widgetset.Checkbox(
_('Warn on quit when others are connected to my media library.'))
hbox.pack_start(widgetutil.align_top(self.share_video_cbx))
hbox.pack_start(widgetutil.align_top(self.share_audio_cbx))
prefpanel.attach_boolean(self.share_audio_cbx, prefs.SHARE_AUDIO)
prefpanel.attach_boolean(self.share_video_cbx, prefs.SHARE_VIDEO)
vbox.pack_start(hbox)
label = widgetset.Label(
_("My %(shortappname)s Share Name", self.trans_data))
label.set_bold(True)
vbox.pack_start(widgetutil.align_left(label, top_pad=15, bottom_pad=5))
hbox = widgetset.HBox()
self.share_entry = widgetset.TextEntry()
self.share_entry.set_size_request(230, -1)
share_error = prefpanel.build_error_image()
prefpanel.attach_text(self.share_entry,
prefs.SHARE_NAME,
share_error,
check_function=prefpanel.text_is_not_blank)
if not self.share_button.get_value():
self.share_entry.disable()
self.share_video_cbx.disable()
self.share_audio_cbx.disable()
self.share_warnonquit_cbx.disable()
hbox.pack_start(self.share_entry)
hbox.pack_start(share_error)
vbox.pack_start(hbox)
vbox.pack_start(widgetutil.pad(self.share_warnonquit_cbx, top=15))
container.pack_start(vbox)
bg = widgetutil.RoundedSolidBackground(
widgetutil.css_to_color('#e4e4e4'))
bg.add(widgetutil.pad(container, 20, 20, 20, 20))
bottom.pack_start(widgetutil.align_left(bg, left_pad=20,
bottom_pad=50))
def __init__(self):
self.device = None
widgetset.VBox.__init__(self)
self.button_row = segmented.SegmentedButtonsRow()
for key, name in (('main', _('Main')), ('podcasts', _('Podcasts')),
('playlists', _('Playlists')), ('settings',
_('Settings'))):
button = DeviceTabButtonSegment(key, name, self._tab_clicked)
self.button_row.add_button(name.lower(), button)
self.button_row.set_active('main')
tbc = TabButtonContainer()
tbc.add(
widgetutil.align_center(self.button_row.make_widget(), top_pad=9))
width = tbc.child.get_size_request()[0]
tbc.child.set_size_request(-1, 24)
self.pack_start(tbc)
self.tabs = {}
self.tab_container = widgetset.Background()
scroller = widgetset.Scroller(False, True)
scroller.add(self.tab_container)
self.pack_start(scroller, expand=True)
vbox = widgetset.VBox()
vbox.pack_start(
widgetutil.align_left(tabcontroller.ConnectTab.build_header(
_("Individual Files")),
top_pad=10))
label = tabcontroller.ConnectTab.build_text(
_("Drag individual video and audio files onto "
"the device in the sidebar to copy them."))
label.set_size_request(width, -1)
label.set_wrap(True)
vbox.pack_start(widgetutil.align_left(label, top_pad=10))
vbox.pack_start(
widgetutil.align_left(tabcontroller.ConnectTab.build_header(
_("Syncing")),
top_pad=30))
label = tabcontroller.ConnectTab.build_text(
_("Use the tabs above and these options for "
"automatic syncing."))
label.set_size_request(width, -1)
label.set_wrap(True)
vbox.pack_start(widgetutil.align_left(label, top_pad=10))
self.auto_sync = widgetset.Checkbox(
_("Sync automatically when this "
"device is connected"))
self.auto_sync.connect('toggled', self._auto_sync_changed)
vbox.pack_start(widgetutil.align_left(self.auto_sync, top_pad=10))
max_fill_label = _(
"Don't fill more than %(count)i percent of the "
"free space when syncing", {'count': id(self)})
checkbox_label, text_label = max_fill_label.split(unicode(id(self)), 1)
self.max_fill_enabled = widgetset.Checkbox(checkbox_label)
self.max_fill_enabled.connect('toggled',
self._max_fill_enabled_changed)
self.max_fill_percent = widgetset.TextEntry()
self.max_fill_percent.set_size_request(50, -1)
self.max_fill_percent.connect('focus-out',
self._max_fill_percent_changed)
label = widgetset.Label(text_label)
vbox.pack_start(
widgetutil.align_left(widgetutil.build_hbox(
[self.max_fill_enabled, self.max_fill_percent, label], 0),
top_pad=10))
rounded_vbox = RoundedVBox()
vbox.pack_start(
widgetutil.align_left(tabcontroller.ConnectTab.build_header(
_("Auto Fill")),
top_pad=30,
bottom_pad=10))
self.auto_fill = widgetset.Checkbox(
_("After syncing my selections in the tabs above, "
"fill remaining space with:"))
self.auto_fill.connect('toggled', self._auto_fill_changed)
rounded_vbox.pack_start(
widgetutil.align_left(self.auto_fill, 20, 20, 20, 20))
names = [(_('Newest Music'), u'recent_music'),
(_('Random Music'), u'random_music'),
(_('Most Played Songs'), u'most_played_music'),
(_('New Playlists'), u'new_playlists'),
(_('Most Recent Podcasts'), u'recent_podcasts')]
longest = max(names, key=lambda x: len(x[0]))[0]
width = widgetset.Label(longest).get_width()
less_label = widgetset.Label(_('Less').upper())
less_label.set_size(tabcontroller.ConnectTab.TEXT_SIZE / 2)
more_label = widgetset.Label(_('More').upper())
more_label.set_size(tabcontroller.ConnectTab.TEXT_SIZE / 2)
label_hbox = widgetutil.build_hbox([
less_label,
widgetutil.pad(
more_label,
left=(200 - less_label.get_width() - more_label.get_width()))
],
padding=0)
label_hbox.set_size_request(200, -1)
scrollers = [widgetutil.align_right(label_hbox, right_pad=20)]
self.auto_fill_sliders = {}
for name, setting in names:
label = widgetutil.align_right(widgetset.Label(name))
label.set_size_request(width, -1)
dragger = AutoFillSlider()
dragger.connect('released', self._auto_fill_slider_changed,
setting)
self.auto_fill_sliders[setting] = dragger
hbox = widgetutil.build_hbox([label, dragger], 20)
scrollers.append(hbox)
rounded_vbox.pack_start(
widgetutil.align_left(widgetutil.build_vbox(scrollers, 10), 20, 20,
20, 20))
vbox.pack_start(widgetutil.align_left(rounded_vbox))
self.device_size = SizeWidget()
self.device_size.sync_button.connect('clicked', self.sync_clicked)
self.pack_end(self.device_size)
self.add_tab('main', widgetutil.align_center(vbox, 20, 20, 20, 20))
self.add_tab(
'podcasts',
widgetutil.align_center(PodcastSyncWidget(), 20, 20, 20, 20))
self.add_tab(
'playlists',
widgetutil.align_center(PlaylistSyncWidget(), 20, 20, 20, 20))
self.add_tab(
'settings',
widgetutil.align_center(DeviceSettingsWidget(), 20, 20, 20, 20))
def create_table(self):
self._background.remove()
def _get_conversion_name(id_):
if id_ == 'copy':
return _('Copy')
else:
return conversion_manager.lookup_converter(id_).name
conversion_details = {
'audio': _get_conversion_name(self.device.info.audio_conversion),
'video': _get_conversion_name(self.device.info.video_conversion)
}
audio_conversion_names = [
_('Device Default (%(audio)s)', conversion_details),
_('Copy')
]
self.audio_conversion_values = [None, 'copy']
video_conversion_names = [
_('Device Default (%(video)s)', conversion_details),
_('Copy')
]
self.video_conversion_values = [None, 'copy']
for section_name, converters in conversion_manager.get_converters():
for converter in converters:
if converter.mediatype == 'video':
video_conversion_names.append(converter.name)
self.video_conversion_values.append(converter.identifier)
elif converter.mediatype == 'audio':
audio_conversion_names.append(converter.name)
self.audio_conversion_values.append(converter.identifier)
widgets = []
for text, setting, type_ in (
(_("Name of Device"), u'name', 'text'),
(_("Video Conversion"), u'video_conversion', 'video_conversion'),
(_("Audio Conversion"), u'audio_conversion', 'audio_conversion'),
(_("Store video in this directory"), u'video_path',
'text'), (_("Store audio in this directory"), u'audio_path',
'text'), (_("Always show this device, even if "
"'show all devices' is turned off"),
u'always_show', 'bool'),
(_("Always convert videos before copying to this device, even "
"if the video can play without conversion\n(may reduce video "
"file sizes, but makes syncing much slower)"),
u"always_sync_videos", 'bool')):
if type_ == 'text':
widget = widgetset.TextEntry()
widget.set_size_request(260, -1)
elif type_.endswith('conversion'):
if type_ == 'video_conversion':
options = video_conversion_names
elif type_ == 'audio_conversion':
options = audio_conversion_names
widget = widgetset.OptionMenu(options)
widget.set_size_request(260, -1)
elif type_ == 'bool':
widget = widgetset.Checkbox(text)
widget.set_size_request(400, -1)
else:
raise RuntimeError('unknown settings widget: %r' % type_)
self.boxes[setting] = widget
if type_ != 'bool': # has a label already
widgets.append((widgetset.Label(text), widget))
if type_ == 'text':
widget.connect('focus-out', self.setting_changed, setting)
else:
widget.connect('changed', self.setting_changed, setting)
else:
widgets.append((widget, ))
widget.connect('toggled', self.setting_changed, setting)
table = widgetset.Table(2, len(widgets))
for row, widget in enumerate(widgets):
if len(widget) == 1: # checkbox
table.pack(widget[0], 0, row, column_span=2)
else:
table.pack(widgetutil.align_right(widget[0]), 0, row)
table.pack(widgetutil.align_left(widget[1]), 1, row)
table.set_column_spacing(20)
table.set_row_spacing(20)
self._background.set_child(
widgetutil.align_center(table, 20, 20, 20, 20))
def build_widgets(self):
self.vlayout = widgetset.VBox(spacing=5)
grid = dialogwidgets.ControlGrid()
donate_nothanks_textentry = widgetset.TextEntry()
donate_nothanks_textentry.set_width(5)
prefpanel.attach_integer(donate_nothanks_textentry,
prefs.DONATE_NOTHANKS,
prefpanel.build_error_image(),
prefpanel.create_value_checker(min_=0))
last_donate_time_textentry = widgetset.TextEntry()
last_donate_time_textentry.set_width(16)
prefpanel.attach_integer(last_donate_time_textentry,
prefs.LAST_DONATE_TIME,
prefpanel.build_error_image(),
prefpanel.create_value_checker(min_=0))
donate_counter_textentry = widgetset.TextEntry()
donate_counter_textentry.set_width(5)
prefpanel.attach_integer(donate_counter_textentry,
prefs.DONATE_COUNTER,
prefpanel.build_error_image(),
prefpanel.create_value_checker(min_=0))
set_ratelimit_button = widgetset.Button('Force ratelimit')
set_ratelimit_button.connect('clicked', self.on_set_ratelimit_clicked)
reset_ratelimit_button = widgetset.Button('Force no ratelimit')
reset_ratelimit_button.connect('clicked',
self.on_reset_ratelimit_clicked)
reset_button = widgetset.Button('Reset counters to factory defaults')
reset_button.connect('clicked', self.on_reset_clicked)
reset_donate_url_button = widgetset.Button('Reset')
reset_donate_url_button.connect('clicked',
self.on_reset_donate_url_clicked)
reset_payment_url_button = widgetset.Button('Reset')
reset_payment_url_button.connect('clicked',
self.on_reset_payment_url_clicked)
self.donate_url_textentry = widgetset.TextEntry()
self.donate_url_textentry.set_width(16)
self.payment_url_textentry = widgetset.TextEntry()
self.payment_url_textentry.set_width(16)
run_button = widgetset.Button('Run dialog')
run_button.connect('clicked', self.on_run_clicked)
grid.pack_label('Set DONATE_NOTHANKS', grid.ALIGN_RIGHT)
grid.pack(donate_nothanks_textentry, span=2)
grid.end_line(spacing=4)
grid.pack_label('Set LAST_DONATE_TIME', grid.ALIGN_RIGHT)
grid.pack(last_donate_time_textentry, span=2)
grid.end_line(spacing=4)
grid.pack_label('Set DONATE_COUNTER', grid.ALIGN_RIGHT)
grid.pack(donate_counter_textentry, span=2)
grid.end_line(spacing=4)
grid.pack(reset_button, grid.FILL, span=3)
grid.end_line(spacing=4)
hbox = widgetset.HBox()
hbox.pack_start(set_ratelimit_button)
hbox.pack_start(reset_ratelimit_button)
grid.pack(widgetutil.align_center(hbox), grid.FILL, span=3)
grid.end_line(spacing=4)
grid.pack_label('Use donate url', grid.ALIGN_RIGHT)
grid.pack(self.donate_url_textentry)
grid.pack(reset_donate_url_button, grid.FILL)
grid.end_line(spacing=4)
grid.pack_label('Use payment donate url', grid.ALIGN_RIGHT)
grid.pack(self.payment_url_textentry)
grid.pack(reset_payment_url_button, grid.FILL)
grid.end_line(spacing=4)
grid.pack(run_button, grid.FILL, span=3)
grid.end_line(spacing=12)
alignment = widgetset.Alignment(xalign=0.5, yalign=0.5)
alignment.set_padding(20, 20, 20, 20)
alignment.add(grid.make_table())
return alignment
def build_find_files_page(self):
vbox = widgetset.VBox(spacing=5)
vbox.pack_start(
_build_paragraph_text(
_(
"%(name)s can find music and video on your computer "
"and show them in your %(name)s library. No files "
"will be copied or duplicated.",
{"name": app.config.get(prefs.SHORT_APP_NAME)})))
vbox.pack_start(
_build_title_question(
_(
"Would you like %(name)s to search your computer "
"for media files?",
{"name": app.config.get(prefs.SHORT_APP_NAME)})))
rbg = widgetset.RadioButtonGroup()
no_rb = widgetset.RadioButton(_("No"), rbg)
yes_rb = widgetset.RadioButton(_("Yes"), rbg)
no_rb.set_selected()
vbox.pack_start(widgetutil.align_left(no_rb, left_pad=10))
vbox.pack_start(
widgetutil.align_left(yes_rb, left_pad=10, bottom_pad=5))
group_box = widgetset.VBox(spacing=5)
rbg2 = widgetset.RadioButtonGroup()
restrict_rb = widgetset.RadioButton(_("Search everywhere."), rbg2)
search_rb = widgetset.RadioButton(_("Just search in this folder:"),
rbg2)
restrict_rb.set_selected()
group_box.pack_start(widgetutil.align_left(restrict_rb, left_pad=30))
group_box.pack_start(widgetutil.align_left(search_rb, left_pad=30))
search_entry = widgetset.TextEntry(
filename_to_unicode(get_default_search_dir()))
search_entry.set_width(20)
change_button = widgetset.Button(_("Choose..."))
hbox = widgetutil.build_hbox((widgetutil.align_middle(search_entry),
widgetutil.align_middle(change_button)))
group_box.pack_start(widgetutil.align_left(hbox, left_pad=30))
def handle_change_clicked(widget):
dir_ = dialogs.ask_for_directory(
_("Choose directory to search for media files"),
initial_directory=get_default_search_dir(),
transient_for=self)
if dir_:
search_entry.set_text(filename_to_unicode(dir_))
self.search_directory = dir_
else:
self.search_directory = get_default_search_dir()
# reset the search results if they change the directory
self.gathered_media_files = None
change_button.connect('clicked', handle_change_clicked)
vbox.pack_start(group_box)
prev_button = widgetset.Button(_("< Previous"))
prev_button.connect('clicked', lambda x: self.prev_page())
def handle_search_finish_clicked(widget):
if widget.mode == "search":
if rbg2.get_selected() == restrict_rb:
self.search_directory = get_default_search_dir()
self.next_page()
else:
self.destroy()
search_button = widgetset.Button(_("Search"))
search_button.connect('clicked', handle_search_finish_clicked)
# FIXME - this is goofy naming
search_button.text_faces = {"search": _("Next >"), "next": _("Finish")}
search_button.mode = "search"
def switch_mode(mode):
search_button.set_text(search_button.text_faces[mode])
search_button.mode = mode
vbox.pack_start(self._force_space_label())
vbox.pack_start(widgetutil.align_bottom(
widgetutil.align_right(
widgetutil.build_hbox((prev_button, search_button)))),
expand=True)
def handle_radio_button_clicked(widget):
# Uggh this is a bit messy.
if widget is no_rb:
group_box.disable()
search_entry.disable()
change_button.disable()
switch_mode("next")
self.gathered_media_files = None
elif widget is yes_rb:
group_box.enable()
if rbg2.get_selected() is restrict_rb:
search_entry.disable()
change_button.disable()
else:
search_entry.enable()
change_button.enable()
switch_mode("search")
elif widget is restrict_rb:
search_entry.disable()
change_button.disable()
self.gathered_media_files = None
elif widget is search_rb:
search_entry.enable()
change_button.enable()
self.gathered_media_files = None
if widget is restrict_rb or widget is search_rb:
switch_mode("search")
no_rb.connect('clicked', handle_radio_button_clicked)
yes_rb.connect('clicked', handle_radio_button_clicked)
restrict_rb.connect('clicked', handle_radio_button_clicked)
search_rb.connect('clicked', handle_radio_button_clicked)
handle_radio_button_clicked(restrict_rb)
handle_radio_button_clicked(no_rb)
vbox = widgetutil.pad(vbox)
return vbox
def run_dialog():
"""Creates and launches the Add to Playlist dialog. This dialog
waits for the user to press "Add" or "Cancel".
In the case of "Add", returns a tuple of:
* ("new", playlist_name)
* ("existing", playlist id)
In the case of "Cancel", returns None.
"""
title = _('Add a Playlist')
description = _('Add items to an existing playlist or a new one.')
playlists = app.tabs['playlist'].get_playlists()
playlists = [pi for pi in playlists if not pi.is_folder]
playlists.sort(key=lambda x: name_sort_key(x.name))
window = MainDialog(title, description)
try:
try:
window.add_button(BUTTON_ADD.text)
window.add_button(BUTTON_CANCEL.text)
extra = widgetset.VBox()
choice_table = widgetset.Table(columns=2, rows=2)
choice_table.set_column_spacing(5)
choice_table.set_row_spacing(5)
rbg = widgetset.RadioButtonGroup()
existing_rb = widgetset.RadioButton(_("Existing playlist:"), rbg)
existing_option = widgetset.OptionMenu(
[clamp_text(pi.name) for pi in playlists])
choice_table.pack(existing_rb, 0, 0)
choice_table.pack(existing_option, 1, 0)
new_rb = widgetset.RadioButton(_("New playlist:"), rbg)
new_text = widgetset.TextEntry()
new_text.set_activates_default(True)
choice_table.pack(new_rb, 0, 1)
choice_table.pack(new_text, 1, 1)
# only the existing row is enabled
choice_table.disable(row=1, column=1)
def handle_clicked(widget):
# this enables and disables the fields in the table
# based on which radio button is selected
if widget is existing_rb:
choice_table.enable(row=0, column=1)
choice_table.disable(row=1, column=1)
else:
choice_table.disable(row=0, column=1)
choice_table.enable(row=1, column=1)
if new_rb.get_selected():
new_text.focus()
existing_rb.connect('clicked', handle_clicked)
new_rb.connect('clicked', handle_clicked)
existing_rb.set_selected()
extra.pack_start(widgetutil.align_top(choice_table, top_pad=6))
window.set_extra_widget(extra)
response = window.run()
if response == 0:
selected_option = rbg.get_selected()
if selected_option is existing_rb and len(playlists) > 0:
return ("existing",
playlists[existing_option.get_selected()])
elif new_text.get_text():
return ("new", new_text.get_text())
except StandardError:
logging.exception("addtoplaylistdialog threw exception.")
finally:
window.destroy()
def build_widgets(self):
self.window.add_button(BUTTON_CREATE_FEED.text)
self.window.add_button(BUTTON_CANCEL.text)
extra = widgetset.VBox()
hb1 = widgetset.HBox()
hb1.pack_start(widgetset.Label(_('Search for:')), padding=5)
self.searchterm = widgetset.TextEntry()
self.searchterm.set_activates_default(True)
hb1.pack_start(self.searchterm, expand=True)
extra.pack_start(hb1)
hb2 = widgetset.HBox()
hb2.pack_start(widgetutil.align_top(
widgetset.Label(_('In this:')), top_pad=3), padding=5)
self.choice_table = widgetset.Table(columns=2, rows=3)
self.choice_table.set_column_spacing(5)
self.choice_table.set_row_spacing(5)
self.rbg = widgetset.RadioButtonGroup()
self.channel_rb = widgetset.RadioButton(_("Podcast:"), self.rbg)
self.channel_option = widgetset.OptionMenu(
[ci.name + u" - " + ci.url for ci in self.channels])
self.channel_option.set_size_request(250, -1)
self.choice_table.pack(self.channel_rb, 0, 0)
self.choice_table.pack(self.channel_option, 1, 0)
self.search_engine_rb = widgetset.RadioButton(_("Search engine:"),
self.rbg)
self.search_engine_option = widgetset.OptionMenu(
[se.title for se in self.search_engines])
self.choice_table.pack(self.search_engine_rb, 0, 1)
self.choice_table.pack(self.search_engine_option, 1, 1)
url_rb = widgetset.RadioButton(_("URL:"), self.rbg)
self.url_text = widgetset.TextEntry()
self.choice_table.pack(url_rb, 0, 2)
self.choice_table.pack(self.url_text, 1, 2)
hb2.pack_start(self.choice_table, expand=True)
# by default only the channel row is enabled
self.enable_choice_table_row(0)
def handle_clicked(widget):
# this enables and disables the fields in the table
# based on which radio button is selected
if widget is self.channel_rb:
self.enable_choice_table_row(0)
elif widget is self.search_engine_rb:
self.enable_choice_table_row(1)
else:
self.enable_choice_table_row(2)
self.channel_rb.connect('clicked', handle_clicked)
self.search_engine_rb.connect('clicked', handle_clicked)
url_rb.connect('clicked', handle_clicked)
extra.pack_start(widgetutil.align_top(hb2, top_pad=6))
self.window.set_extra_widget(extra)
