def _append_group(self, dev_group):
group_id = dev_group.get_id()
group_name = dev_group.get_name()
group_iter = self.append(None, [group_id, group_name, 0, dev_group])
channellist = dev_group.get_channel_list()
d = Callback()
if self._use_channel_groups:
d.add_callback(self._append_channel_groups, channellist, group_id, group_iter, dev_group)
self._manager.get_channel_groups(
result_handler=lambda p, x, u: d.callback(x), error_handler=global_error_handler
)
# Put all available channels either in TV or radio group
tv_group_iter = self.append(group_iter, [group_id, _("TV Channels"), 0, dev_group])
radio_group_iter = self.append(group_iter, [group_id, _("Radio Channels"), 0, dev_group])
else:
# Do not distinguish between radio and TV
tv_group_iter = group_iter
radio_group_iter = group_iter
d_all = Callback()
d_all.add_callback(self._append_channels, group_id, dev_group, tv_group_iter, radio_group_iter)
channellist.get_channel_infos(
result_handler=lambda p, x, u: d_all.callback(x), error_handler=global_error_handler
)
def _on_button_delete_clicked(self, button):
def delete_timer_callback(proxy, success, user_data):
if not success:
error_dialog = Gtk.MessageDialog(parent=self,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
error_dialog.set_markup(
"<big><span weight=\"bold\">%s</span></big>" % _("Timer could not be deleted"))
error_dialog.run()
error_dialog.destroy()
model, aiter = self.timersview.get_selection().get_selected()
if aiter != None:
timer_id = model[aiter][self.COL_ID]
if self.recorder.is_timer_active(timer_id):
dialog = Gtk.MessageDialog(parent=self,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.QUESTION, buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(
"<big><span weight=\"bold\">%s</span></big>" % _("Abort active recording?"))
dialog.format_secondary_text(
_("The timer you selected belongs to a currently active recording.") + " " +
_("Deleting this timer will abort the recording."))
response = dialog.run()
dialog.destroy()
if response == Gtk.ResponseType.YES:
self.recorder.delete_timer(timer_id,
result_handler=delete_timer_callback,
error_handler=global_error_handler)
else:
self.recorder.delete_timer(timer_id,
result_handler=delete_timer_callback,
error_handler=global_error_handler)
def _append_group(self, dev_group):
group_id = dev_group.get_id()
group_name = dev_group.get_name()
group_iter = self.append(None, [group_id, group_name, 0, dev_group])
channellist = dev_group.get_channel_list()
d = Callback()
if self._use_channel_groups:
d.add_callback(self._append_channel_groups, channellist, group_id,
group_iter, dev_group)
self._manager.get_channel_groups(
result_handler=lambda p, x, u: d.callback(x),
error_handler=global_error_handler)
# Put all available channels either in TV or radio group
tv_group_iter = self.append(
group_iter,
[group_id, _("TV Channels"), 0, dev_group])
radio_group_iter = self.append(
group_iter,
[group_id, _("Radio Channels"), 0, dev_group])
else:
# Do not distinguish between radio and TV
tv_group_iter = group_iter
radio_group_iter = group_iter
d_all = Callback()
d_all.add_callback(self._append_channels, group_id, dev_group,
tv_group_iter, radio_group_iter)
channellist.get_channel_infos(
result_handler=lambda p, x, u: d_all.callback(x),
error_handler=global_error_handler)
def create_signal_box(self):
self.progress_table = Gtk.Grid(orientation=Gtk.Orientation.VERTICAL)
self.progress_table.set_row_spacing(6)
self.progress_table.set_column_spacing(12)
self.pack_start(self.progress_table, False, True, 0)
label = TextFieldLabel(_("Signal quality:"))
self.progress_table.add(label)
frame = Gtk.Frame(hexpand=True)
frame.set_shadow_type(Gtk.ShadowType.NONE)
self.progress_table.attach_next_to(frame, label, Gtk.PositionType.RIGHT,
1, 1)
self.signal_quality_bar = Gtk.ProgressBar()
self.signal_quality_bar.set_size_request(-1, 10)
frame.add(self.signal_quality_bar)
label = TextFieldLabel(_("Signal strength:"))
self.progress_table.add(label)
frame = Gtk.Frame(hexpand=True)
frame.set_shadow_type(Gtk.ShadowType.NONE)
self.progress_table.attach_next_to(frame, label, Gtk.PositionType.RIGHT,
1, 1)
self.signal_strength_bar = Gtk.ProgressBar()
self.signal_strength_bar.set_size_request(-1, 10)
frame.add(self.signal_strength_bar)
def show_devices(self):
self._label.hide()
if self.devicesview == None:
self.devicesview = Gtk.TreeView.new_with_model(self.deviceslist)
self.devicesview.get_selection().connect("changed",
self.on_device_selection_changed)
cell_name = Gtk.CellRendererText()
col_name = Gtk.TreeViewColumn(_("Name"))
col_name.pack_start(cell_name, True)
col_name.set_cell_data_func(cell_name, self.name_data_func, None)
self.devicesview.append_column(col_name)
cell_type = Gtk.CellRendererText()
col_type = Gtk.TreeViewColumn(_("Type"))
col_type.pack_start(cell_type, True)
col_type.add_attribute(cell_type, "text", 1)
self.devicesview.append_column(col_type)
scrolledview = Gtk.ScrolledWindow()
scrolledview.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
scrolledview.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolledview.add(self.devicesview)
scrolledview.show_all()
text = "<b>%s</b>" % _("Select the device you want to configure.")
self.frame = BaseFrame(text, scrolledview)
self.frame.show()
self.pack_start(self.frame, True, True, 0)
self.devicesview.grab_focus()
if len(self.deviceslist) == 1:
self.emit("next-page")
def create_signal_box(self):
self.progress_table = Gtk.Grid(orientation=Gtk.Orientation.VERTICAL)
self.progress_table.set_row_spacing(6)
self.progress_table.set_column_spacing(12)
self.pack_start(self.progress_table, False, True, 0)
label = TextFieldLabel(_("Signal quality:"))
self.progress_table.add(label)
frame = Gtk.Frame(hexpand=True)
frame.set_shadow_type(Gtk.ShadowType.NONE)
self.progress_table.attach_next_to(frame, label,
Gtk.PositionType.RIGHT, 1, 1)
self.signal_quality_bar = Gtk.ProgressBar()
self.signal_quality_bar.set_size_request(-1, 10)
frame.add(self.signal_quality_bar)
label = TextFieldLabel(_("Signal strength:"))
self.progress_table.add(label)
frame = Gtk.Frame(hexpand=True)
frame.set_shadow_type(Gtk.ShadowType.NONE)
self.progress_table.attach_next_to(frame, label,
Gtk.PositionType.RIGHT, 1, 1)
self.signal_strength_bar = Gtk.ProgressBar()
self.signal_strength_bar.set_size_request(-1, 10)
frame.add(self.signal_strength_bar)
def __init__(self, parent_window):
Gtk.MessageDialog.__init__(self, parent=parent_window,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
self.set_markup ("<big><span weight=\"bold\">%s</span></big>" % _("Timer could not be created"))
self.format_secondary_text(
_("Make sure that the timer doesn't conflict with another one and doesn't start in the past.")
)
def set_device_name_and_details(self, name, details, success):
if success:
text = "<span weight=\"bold\">%s</span>" % (_("The device %s has been configured successfully.") % name)
else:
text = "<span weight=\"bold\">%s</span>" % (_("Failed configuring device %s.") % name)
self._label.set_markup(text)
self._details_label.set_markup(details)
def show_all_configured(self):
if self.frame:
self.frame.hide()
text = "<big><span weight=\"bold\">%s</span></big>" % _('All devices are already configured.')
text += "\n\n"
text += _('Go to the control center if you want to alter the settings of already configured devices.')
self._label.set_markup (text)
self._label.show()
def show_no_devices(self):
if self.frame:
self.frame.hide()
text = "<big><span weight=\"bold\">%s</span></big>" % _('No devices have been found.')
text += "\n\n"
text += _('Either no DVB cards are installed or all cards are busy. In the latter case make sure you close all programs such as video players that access your DVB card.')
self._label.set_markup (text)
self._label.show()
def name_data_func(self, column, cell, model, aiter, user_data):
name = model[aiter][0]
adapter = model[aiter][3]
frontend = model[aiter][4]
text = _("<b>%s</b>\n") % name
text += "<small>%s</small>" % (_("Adapter: %d, Frontend: %d") % (adapter, frontend))
cell.set_property("markup", text)
def __init__(self, parent_window):
Gtk.MessageDialog.__init__(self,
parent=parent_window,
flags=Gtk.DialogFlags.MODAL
| Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
self.set_markup("<big><span weight=\"bold\">%s</span></big>" %
_("Timer could not be created"))
self.format_secondary_text(
_("Make sure that the timer doesn't conflict with another one and doesn't start in the past."
))
def add_device_to_new_group_callback(proxy, success, user_data):
if not success:
# "Error: create group"
error_dialog = Gtk.MessageDialog(parent=self,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
error_dialog.set_markup(
"<big><span weight=\"bold\">%s</span></big>" % _("Group could not be created"))
error_dialog.format_secondary_text(
_("Make sure that you selected the correct channels file and directory where recordings are stored and that both are readable.")
)
error_dialog.run()
error_dialog.destroy()
def add_device_callback(proxy, success, user_data):
if not success:
# "Error: add to group"
error_dialog = Gtk.MessageDialog(parent=self,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
error_dialog.set_markup(
"<big><span weight=\"bold\">%s</span></big>" % _("Device could not be added to group"))
error_dialog.format_secondary_text(
_("Make sure that the device isn't already assigned to a different group and that all devices in the group are of the same type.")
)
error_dialog.run()
error_dialog.destroy()
def show_error(self, error):
if self.frame:
self.frame.hide()
text = "<big><span weight=\"bold\">%s</span></big>" % _('An error occurred while retrieving devices.')
text += "\n\n"
text += _("Make sure other applications don't access DVB devices and you have permissions to access them.")
text += "\n\n"
text += _('The detailed error message is:')
text += "\n<i>%s</i>" % error
self._label.set_selectable(True)
self._label.set_markup (text)
self._label.show()
def __init__(self, parent, model, device_type):
Gtk.Dialog.__init__(self,
title=_("Add to Group"),
parent=parent,
buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT,
Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT))
self.set_modal(True)
self.set_destroy_with_parent(True)
self.__selected_group = None
self.set_border_width(5)
self.vbox_main = Gtk.Box(orientation=Gtk.Orientation.VERTICAL,
spacing=12)
self.vbox_main.set_border_width(5)
self.vbox_main.show()
self.get_content_area().pack_start(self.vbox_main, True, True, 0)
groupbox = Gtk.Box(spacing=18)
groupbox.show()
group_frame = BaseFrame("<b>%s</b>" % _("Add Device to Group"),
groupbox)
group_frame.show()
self.vbox_main.pack_start(group_frame, True, True, 0)
group_label = TextFieldLabel()
group_label.show()
group_label.set_markup_with_mnemonic(_("_Group:"))
groupbox.pack_start(group_label, False, False, 0)
self.groups = Gtk.ListStore(str, GObject.TYPE_PYOBJECT)
combo = Gtk.ComboBox.new_with_model(self.groups)
combo.connect("changed", self.on_combo_changed)
cell = Gtk.CellRendererText()
combo.pack_start(cell, True)
combo.add_attribute(cell, "text", 0)
combo.show()
group_label.set_mnemonic_widget(combo)
groupbox.pack_start(combo, True, True, 0)
def append_groups(groups):
for group in groups:
if group.get_type() == device_type:
name = group["name"]
if name == "":
name = "Group %d" % group["id"]
self.groups.append([name, group])
model.get_registered_device_groups(result_handler=append_groups)
def setup_dvb_c(self):
countries = {}
t = gettext.translation("iso_3166", fallback=True)
for lang in COUNTRIES_DVB_C:
countries[lang] = t.gettext(COUNTRIES[lang])
self._create_table()
country = Gtk.Label(halign=Gtk.Align.START)
country.set_markup_with_mnemonic(_("_Country:"))
country.show()
self.table.add(country)
self.countries = Gtk.ListStore(str, str)
self.countries.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.countries.set_sort_func(0, self.combobox_sort_func, None)
for code, name in list(countries.items()):
self.countries.append([name, code])
self.country_combo = Gtk.ComboBox.new_with_model_and_entry(self.countries)
self.country_combo.set_hexpand(True)
self.country_combo.connect('changed', self.on_country_changed)
self.__data_dir = "dvb-c"
cell = Gtk.CellRendererText()
self.country_combo.pack_start(cell, True)
self.country_combo.set_entry_text_column(0)
self.country_combo.show()
self.table.attach_next_to(self.country_combo, country,
Gtk.PositionType.RIGHT, 1, 1)
country.set_mnemonic_widget(self.country_combo)
providers = Gtk.Label()
providers.set_markup_with_mnemonic(_("_Providers:"))
providers.show()
self.table.add(providers)
self.providers = Gtk.ListStore(str, str)
self.providers.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.providers_view, scrolledview = self._create_providers_treeview(
self.providers, _("Provider"))
self.providers_view.get_selection().connect('changed',
self.on_providers_changed)
providers.set_mnemonic_widget(self.providers_view)
scrolledview.set_property("expand", True)
self.table.attach_next_to(scrolledview, providers,
Gtk.PositionType.BOTTOM, 2, 1)
self.providers_view.set_sensitive(False)
def setup_dvb_c(self):
countries = {}
t = gettext.translation("iso_3166", fallback=True)
for lang in COUNTRIES_DVB_C:
countries[lang] = t.gettext(COUNTRIES[lang])
self._create_table()
country = Gtk.Label(halign=Gtk.Align.START)
country.set_markup_with_mnemonic(_("_Country:"))
country.show()
self.table.add(country)
self.countries = Gtk.ListStore(str, str)
self.countries.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.countries.set_sort_func(0, self.combobox_sort_func, None)
for code, name in list(countries.items()):
self.countries.append([name, code])
self.country_combo = Gtk.ComboBox.new_with_model_and_entry(self.countries)
self.country_combo.set_hexpand(True)
self.country_combo.connect('changed', self.on_country_changed)
self.__data_dir = "cable"
cell = Gtk.CellRendererText()
self.country_combo.pack_start(cell, True)
self.country_combo.set_entry_text_column(0)
self.country_combo.show()
self.table.attach_next_to(self.country_combo, country,
Gtk.PositionType.RIGHT, 1, 1)
country.set_mnemonic_widget(self.country_combo)
providers = Gtk.Label()
providers.set_markup_with_mnemonic(_("_Providers:"))
providers.show()
self.table.add(providers)
self.providers = Gtk.ListStore(str, str)
self.providers.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.providers_view, scrolledview = self._create_providers_treeview(
self.providers, _("Provider"))
self.providers_view.get_selection().connect('changed',
self.on_providers_changed)
providers.set_mnemonic_widget(self.providers_view)
scrolledview.set_property("expand", True)
self.table.attach_next_to(scrolledview, providers,
Gtk.PositionType.BOTTOM, 2, 1)
self.providers_view.set_sensitive(False)
def on_delete_group_clicked(self, button):
dialog = Gtk.MessageDialog(parent=self,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.QUESTION, buttons=Gtk.ButtonsType.YES_NO)
group_id, group_name = self.get_selected_channel_group()
msg = _("Are you sure you want to delete the group '%s'?") % group_name
dialog.set_markup (
"<big><span weight=\"bold\">%s</span></big>\n\n%s" %
(msg, _("All assignments to this group will be lost.")))
if dialog.run() == Gtk.ResponseType.YES:
self.model.remove_channel_group(group_id,
result_handler=self.on_remove_channel_group_finished,
error_handler=gnomedvb.global_error_handler)
dialog.destroy()
def __init__(self, parent_window):
Gtk.MessageDialog.__init__(self, parent=parent_window,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.INFO, buttons=Gtk.ButtonsType.OK)
self.set_markup("<big><span weight=\"bold\">%s</span></big>" % (
_("Recording has been scheduled successfully"))
)
def _on_button_remove_clicked(self, button):
def remove_device_callback(proxy, success, user_data):
if success:
# "Success: remove device"
# Add device to unassigned devices
self.unassigned_devices.append([device])
else:
# "Error: remove device"
error_dialog = Gtk.MessageDialog(parent=self,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
error_dialog.set_markup(
"<big><span weight=\"bold\">%s</big></span>" % _("Device could not be removed from group"))
error_dialog.run()
error_dialog.destroy()
model, aiter = self.devicegroupsview.get_selection().get_selected()
if aiter != None:
group = model[aiter][model.COL_GROUP]
device = model[aiter][model.COL_DEVICE]
dialog = Gtk.MessageDialog(parent=self,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.QUESTION, buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(
_("Are you sure you want to remove device <b>%s</b> from <b>%s</b>?") % (device.name,
device.group_name))
response = dialog.run()
dialog.destroy()
if response == Gtk.ResponseType.YES:
if isinstance(device, Device):
group.remove_device(device,
result_handler=remove_device_callback,
error_handler=global_error_handler)
def _fill_providers(self, selected_country):
# Only DVB-T has bruteforce scan
if self.__adapter_info["type"] == GROUP_TERRESTRIAL:
self.providers.append([_("Don't know"), self.NOT_LISTED])
# only search in correct subfolders, to avoid errors if one of the
# DTV_SCAN_TABLES_DIRS exists, but has incorrect content
for d in DTV_SCAN_TABLES_DIRS:
if os.access(d, os.F_OK | os.R_OK) and os.access(os.path.join(d, self.__data_dir), os.F_OK | os.R_OK):
for f in os.listdir(os.path.join(d, self.__data_dir)):
values = f.split('-', 1)
if len(values) != 2:
continue
country, city = values
if country == selected_country:
self.providers.append([city,
os.path.join(d, self.__data_dir, f)])
self.providers_view.set_sensitive(True)
first_iter = self.providers.get_iter_first()
self.providers_view.get_selection().select_iter(first_iter)
self.get_toplevel().get_window().set_cursor(None)
self.emit("finished", True)
return False
def _fill_providers(self, selected_country):
# Only DVB-T has bruteforce scan
if self.__adapter_info["type"] == GROUP_TERRESTRIAL:
self.providers.append([_("Don't know"), self.NOT_LISTED])
for d in DVB_APPS_DIRS:
if os.access(d, os.F_OK | os.R_OK):
for f in os.listdir(os.path.join(d, self.__data_dir)):
values = f.split('-', 1)
if len(values) != 2:
continue
country, city = values
if country == selected_country:
self.providers.append([city,
os.path.join(d, self.__data_dir, f)])
self.providers_view.set_sensitive(True)
first_iter = self.providers.get_iter_first()
self.providers_view.get_selection().select_iter(first_iter)
self.get_toplevel().get_window().set_cursor(None)
self.emit("finished", True)
return False
def _get_description_data(self,
column,
cell,
model,
aiter,
user_data=None):
self._set_colors()
event_id = model[aiter][ScheduleStore.COL_EVENT_ID]
if event_id == ScheduleStore.NEW_DAY:
date = model[aiter][ScheduleStore.COL_DATETIME]
description = "<big><b>%s</b></big>" % date.strftime("%A %x")
cell.set_property("xalign", 0.5)
cell.set_property("cell-background-rgba", self.date_color)
else:
cell.set_property("xalign", 0)
cell.set_property("cell-background-rgba", self.entry_color)
duration = seconds_to_time_duration_string(
model[aiter][ScheduleStore.COL_DURATION])
title = model[aiter][ScheduleStore.COL_TITLE]
short_desc = model[aiter][ScheduleStore.COL_SHORT_DESC]
if len(short_desc) > 0:
short_desc += "\n"
description = "<b>%s</b>\n%s<small><i>%s: %s</i></small>" % (
title, short_desc, _("Duration"), duration)
cell.set_property("markup", description)
def _on_event_selected(self, treeview, event):
if event.type == getattr(Gdk.EventType, "2BUTTON_PRESS"):
model, aiter = treeview.get_selection().get_selected()
if aiter != None:
dialog = Gtk.MessageDialog(
parent=self,
flags=Gtk.DialogFlags.MODAL
| Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.QUESTION,
buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(
"<big><span weight=\"bold\">%s</span></big>" %
_("Schedule recording for the selected event?"))
success = True
if dialog.run() == Gtk.ResponseType.YES:
event_id = model[aiter][model.COL_EVENT_ID]
group = self._get_selected_group()
channel_sid = self._get_selected_channel_sid()
recorder = group.get_recorder()
rec_id, success = recorder.add_timer_for_epg_event(
event_id, channel_sid)
dialog.destroy()
if not success:
dialog = TimerFailureDialog(self)
dialog.run()
dialog.destroy()
def __init__(self, model=None):
GObject.GObject.__init__(self)
if model != None:
self.set_model(model)
self._append_text_column(_("Title"), RecordingsStore.COL_NAME)
self._append_text_column(_("Channel"), RecordingsStore.COL_CHANNEL)
col_length, cell_length = self._append_text_column(_("Length"),
RecordingsStore.COL_DURATION)
col_length.set_cell_data_func(cell_length, self._get_length_data, None)
cell = CellRendererDatetime()
col = Gtk.TreeViewColumn(_("Start"), cell,
datetime=RecordingsStore.COL_START)
self.append_column(col)
def on_prepare(self, assistant, page):
if isinstance(page, IntroPage):
# Reset to None so we can automatically search for adapter again
self.__adapter_info = None
elif isinstance(page, AdaptersPage):
self.__expert_mode = self.intro_page.has_expert_mode()
page.display_configured(self.__expert_mode)
page.run()
elif isinstance(page, InitialTuningDataPage):
page.set_adapter_info(self.__adapter_info)
elif isinstance(page, ChannelScanPage):
self.__ask_on_exit = True
if self.__adapter_info["name"] != None:
page.start_scanning(self.__adapter_info["adapter"],
self.__adapter_info["frontend"], self.__adapter_info["type"], self.tuning_data_page.get_tuning_data ())
elif isinstance(page, SetupDevicePage):
page.set_adapter(self.__adapter_info)
page.set_scanner(self.scan_page.get_scanner())
page.set_channels(self.scan_page.get_selected_channel_sids())
page.run(self.__create_group)
elif isinstance(page, SaveChannelListPage):
page.set_scanner(self.scan_page.get_scanner())
page.set_channels(self.scan_page.get_selected_channel_sids())
elif isinstance(page, SummaryPage):
self.__ask_on_exit = False
if self.__expert_mode:
summary = _('The generated channels file can be used to configure your devices in the control center.')
success = True
else:
success, summary = self.setup_page.get_summary()
page.set_device_name_and_details(self.__adapter_info["name"],
summary, success)
self.__adapter_info = None
self.set_page_title(page, page.get_page_title())
def get_description_data(self, column, cell, model, aiter, user_data=None):
device = model[aiter][model.COL_DEVICE]
if isinstance(device, Device):
# translators: first is device's name, second its type
text = _("<b>%s (%s)</b>\n") % (device.name, DVB_TYPE_TO_DESC[device.type])
text += "<small>%s</small>" % (_("Adapter: %d, Frontend: %d") % (device.adapter,
device.frontend))
else:
if device == "":
group = model[aiter][model.COL_GROUP]
text = _("Group %d") % group["id"]
else:
text = device[0]
cell.set_property("markup", text)
def __create_toolbar(self):
toolbar = Gtk.Toolbar()
toolbar.show()
self.vbox.pack_start(toolbar, False, True, 0)
self.button_prefs = Gtk.ToolButton.new_from_stock(Gtk.STOCK_EDIT)
self.button_prefs.connect("clicked", self._on_button_prefs_clicked)
self.button_prefs.set_sensitive(False)
self.button_prefs.set_tooltip_markup(_("Edit selected group"))
self.button_prefs.show()
toolbar.insert(self.button_prefs, self.BUTTON_EDIT)
self.button_remove = Gtk.ToolButton.new_from_stock(Gtk.STOCK_REMOVE)
self.button_remove.connect("clicked", self._on_button_remove_clicked)
self.button_remove.set_sensitive(False)
self.button_remove.set_tooltip_markup(_("Remove selected device"))
self.button_remove.show()
toolbar.insert(self.button_remove, self.BUTTON_REMOVE)
sep = Gtk.SeparatorToolItem()
sep.show()
toolbar.insert(sep, self.SEP1)
prefs_image = Gtk.Image.new_from_stock(Gtk.STOCK_PREFERENCES,
Gtk.IconSize.SMALL_TOOLBAR)
button_setup = Gtk.MenuToolButton(icon_widget=prefs_image,
label=_("Setup"))
button_setup.connect("clicked", self._on_button_setup_clicked)
button_setup.set_tooltip_markup(_("Setup devices"))
button_setup.show()
toolbar.insert(button_setup, self.BUTTON_PREFERENCES)
setup_menu = Gtk.Menu()
new_image = Gtk.Image.new_from_stock(Gtk.STOCK_NEW, Gtk.IconSize.MENU)
new_image.show()
self.button_new = Gtk.ImageMenuItem.new_with_label(
_("Create new group"))
self.button_new.connect("activate", self._on_button_new_clicked)
self.button_new.set_image(new_image)
self.button_new.set_sensitive(False)
self.button_new.set_tooltip_markup(
_("Create new group for selected device"))
self.button_new.show()
setup_menu.append(self.button_new)
add_image = Gtk.Image.new_from_stock(Gtk.STOCK_ADD, Gtk.IconSize.MENU)
add_image.show()
self.button_add = Gtk.ImageMenuItem.new_with_label(_("Add to group"))
self.button_add.connect("activate", self._on_button_add_clicked)
self.button_add.set_image(add_image)
self.button_add.set_sensitive(False)
self.button_add.set_tooltip_markup(
_("Add selected device to existing group"))
self.button_add.show()
setup_menu.append(self.button_add)
button_setup.set_menu(setup_menu)
def show_progressbar(self):
self._label.hide()
self._progressbar = Gtk.ProgressBar()
self._progressbar.set_text(_("Searching for devices"))
self._progressbar.set_fraction(0.1)
self._progressbar.show()
self.pack_start(self._progressbar, False, True, 0)
self._progressbar_timer = GLib.timeout_add(100, self.progressbar_pulse, None)
def __init__(self, name, recdir, parent=None):
NewGroupDialog.__init__(self, parent)
self.set_title(_("Edit group"))
self.show_channels_section(False)
self.name_entry.set_text(name)
self.recordings_entry.set_text(recdir)
def __init__(self):
BasePage.__init__(self)
text = "<b>%s</b>" % _('Welcome to the digital television Assistant.')
self._label.set_markup(text)
self._label.set_line_wrap(False)
text1 = _('It will automatically configure your devices and search for channels, if necessary.')
text2 = _("Click \"Forward\" to begin.")
label2 = Gtk.Label(text1 + "\n\n" + text2)
label2.set_line_wrap(True)
label2.set_halign(Gtk.Align.START)
label2.set_valign(Gtk.Align.START)
self.pack_start(label2, True, True, 0)
self.expert_mode = Gtk.CheckButton.new_with_mnemonic(_('_Expert mode'))
self.pack_start(self.expert_mode, False, False, 0)
def __init__(self, model=None):
GObject.GObject.__init__(self)
if model != None:
self.set_model(model)
self._append_text_column(_("Title"), RecordingsStore.COL_NAME)
self._append_text_column(_("Channel"), RecordingsStore.COL_CHANNEL)
col_length, cell_length = self._append_text_column(
_("Length"), RecordingsStore.COL_DURATION)
col_length.set_cell_data_func(cell_length, self._get_length_data, None)
cell = CellRendererDatetime()
col = Gtk.TreeViewColumn(_("Start"),
cell,
datetime=RecordingsStore.COL_START)
self.append_column(col)
def _on_channels_open_clicked(self, button):
dialog = Gtk.FileChooserDialog (title = _("Select File"),
parent=self, action=Gtk.FileChooserAction.OPEN,
buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT,
Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT))
if dialog.run() == Gtk.ResponseType.ACCEPT:
self.channels_entry.set_text(dialog.get_filename())
dialog.destroy()
def add_device_to_new_group_callback(proxy, success, user_data):
if not success:
# "Error: create group"
error_dialog = Gtk.MessageDialog(
parent=self,
flags=Gtk.DialogFlags.MODAL
| Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
error_dialog.set_markup(
"<big><span weight=\"bold\">%s</span></big>" %
_("Group could not be created"))
error_dialog.format_secondary_text(
_("Make sure that you selected the correct channels file and directory where recordings are stored and that both are readable."
))
error_dialog.run()
error_dialog.destroy()
def show_error(self):
if self._progressbar != None:
self._progressbar.destroy()
text = "<big><span weight=\"bold\">%s</span></big>" % _("An error occured while trying to setup the device.")
self._label.set_selectable(True)
self._label.set_markup (text)
self._label.show()
def add_device_callback(proxy, success, user_data):
if not success:
# "Error: add to group"
error_dialog = Gtk.MessageDialog(
parent=self,
flags=Gtk.DialogFlags.MODAL
| Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.ERROR,
buttons=Gtk.ButtonsType.OK)
error_dialog.set_markup(
"<big><span weight=\"bold\">%s</span></big>" %
_("Device could not be added to group"))
error_dialog.format_secondary_text(
_("Make sure that the device isn't already assigned to a different group and that all devices in the group are of the same type."
))
error_dialog.run()
error_dialog.destroy()
def __init__(self, name, recdir, parent=None):
NewGroupDialog.__init__(self, parent)
self.set_title (_("Edit group"))
self.show_channels_section(False)
self.name_entry.set_text(name)
self.recordings_entry.set_text(recdir)
def _on_recordings_open_clicked(self, button):
dialog = Gtk.FileChooserDialog (title = _("Select Directory"),
parent=self, action=Gtk.FileChooserAction.SELECT_FOLDER,
buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT,
Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT))
if dialog.run() == Gtk.ResponseType.ACCEPT:
self.recordings_entry.set_text(dialog.get_filename())
dialog.destroy()
def on_delete_group_clicked(self, button):
dialog = Gtk.MessageDialog(parent=self,
flags=Gtk.DialogFlags.MODAL
| Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.QUESTION,
buttons=Gtk.ButtonsType.YES_NO)
group_id, group_name = self.get_selected_channel_group()
msg = _("Are you sure you want to delete the group '%s'?") % group_name
dialog.set_markup(
"<big><span weight=\"bold\">%s</span></big>\n\n%s" %
(msg, _("All assignments to this group will be lost.")))
if dialog.run() == Gtk.ResponseType.YES:
self.model.remove_channel_group(
group_id,
result_handler=self.on_remove_channel_group_finished,
error_handler=gnomedvb.global_error_handler)
dialog.destroy()
def __init__(self, parent, model, device_type):
Gtk.Dialog.__init__(self, title=_("Add to Group"), parent=parent,
buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT,
Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT))
self.set_modal(True)
self.set_destroy_with_parent(True)
self.__selected_group = None
self.set_border_width(5)
self.vbox_main = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12)
self.vbox_main.set_border_width(5)
self.vbox_main.show()
self.get_content_area().pack_start(self.vbox_main, True, True, 0)
groupbox = Gtk.Box(spacing=18)
groupbox.show()
group_frame = BaseFrame("<b>%s</b>" % _("Add Device to Group"), groupbox)
group_frame.show()
self.vbox_main.pack_start(group_frame, True, True, 0)
group_label = TextFieldLabel()
group_label.show()
group_label.set_markup_with_mnemonic(_("_Group:"))
groupbox.pack_start(group_label, False, False, 0)
self.groups = Gtk.ListStore(str, GObject.TYPE_PYOBJECT)
combo = Gtk.ComboBox.new_with_model(self.groups)
combo.connect("changed", self.on_combo_changed)
cell = Gtk.CellRendererText()
combo.pack_start(cell, True)
combo.add_attribute(cell, "text", 0)
combo.show()
group_label.set_mnemonic_widget(combo)
groupbox.pack_start(combo, True, True, 0)
def append_groups(groups):
for group in groups:
if group.get_type() == device_type:
name = group["name"]
if name == "":
name = "Group %d" % group["id"]
self.groups.append([name, group])
model.get_registered_device_groups(result_handler=append_groups)
def setup_dvb_s(self):
satellite = Gtk.Label()
satellite.set_markup_with_mnemonic(_("_Satellite:"))
satellite.show()
self.pack_start(satellite, False, False, 0)
self.satellites = Gtk.ListStore(str, str)
self.satellites.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.satellite_view, scrolledview = self._create_providers_treeview(
self.satellites, _("Satellite"))
self.satellite_view.get_selection().connect("changed",
self.on_satellite_changed)
satellite.set_mnemonic_widget(self.satellite_view)
self.pack_start(scrolledview, True, True, 0)
self.read_satellites()
def delete_timer_callback(proxy, success, user_data):
if not success:
error_dialog = Gtk.MessageDialog(parent=self,
flags=Gtk.DialogFlags.MODAL|Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK)
error_dialog.set_markup(
"<big><span weight=\"bold\">%s</span></big>" % _("Timer could not be deleted"))
error_dialog.run()
error_dialog.destroy()
def setup_dvb_s(self):
satellite = Gtk.Label()
satellite.set_markup_with_mnemonic(_("_Satellite:"))
satellite.show()
self.pack_start(satellite, False, False, 0)
self.satellites = Gtk.ListStore(str, str)
self.satellites.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.satellite_view, scrolledview = self._create_providers_treeview(
self.satellites, _("Satellite"))
self.satellite_view.get_selection().connect("changed",
self.on_satellite_changed)
satellite.set_mnemonic_widget(self.satellite_view)
self.pack_start(scrolledview, True, True, 0)
self.read_satellites()
def __init__(self, parent_window):
Gtk.MessageDialog.__init__(self,
parent=parent_window,
flags=Gtk.DialogFlags.MODAL
| Gtk.DialogFlags.DESTROY_WITH_PARENT,
type=Gtk.MessageType.INFO,
buttons=Gtk.ButtonsType.OK)
self.set_markup("<big><span weight=\"bold\">%s</span></big>" %
(_("Recording has been scheduled successfully")))
def show_progressbar(self):
# From parent
self._label.hide()
self._progressbar = Gtk.ProgressBar()
self._progressbar.set_text(_("Configuring device"))
self._progressbar.set_fraction(0.1)
self._progressbar.show()
self.pack_start(self._progressbar, False, True, 0)
self._progressbar_timer = GLib.timeout_add(100, self.progressbar_pulse)
def _on_recordings_open_clicked(self, button):
dialog = Gtk.FileChooserDialog(
title=_("Select Directory"),
parent=self,
action=Gtk.FileChooserAction.SELECT_FOLDER,
buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT, Gtk.STOCK_OK,
Gtk.ResponseType.ACCEPT))
if dialog.run() == Gtk.ResponseType.ACCEPT:
self.recordings_entry.set_text(dialog.get_filename())
dialog.destroy()
def _on_channels_open_clicked(self, button):
dialog = Gtk.FileChooserDialog(
title=_("Select File"),
parent=self,
action=Gtk.FileChooserAction.OPEN,
buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT, Gtk.STOCK_OK,
Gtk.ResponseType.ACCEPT))
if dialog.run() == Gtk.ResponseType.ACCEPT:
self.channels_entry.set_text(dialog.get_filename())
dialog.destroy()
def __init__(self):
BasePage.__init__(self)
text = "<b>%s</b>" % _('Welcome to the digital television Assistant.')
self._label.set_markup(text)
self._label.set_line_wrap(False)
text1 = _(
'It will automatically configure your devices and search for channels, if necessary.'
)
text2 = _("Click \"Forward\" to begin.")
label2 = Gtk.Label(text1 + "\n\n" + text2)
label2.set_line_wrap(True)
label2.set_halign(Gtk.Align.START)
label2.set_valign(Gtk.Align.START)
self.pack_start(label2, True, True, 0)
self.expert_mode = Gtk.CheckButton.new_with_mnemonic(_('_Expert mode'))
self.pack_start(self.expert_mode, False, False, 0)
def __init__(self, model=None):
GObject.GObject.__init__(self)
if model != None:
self.set_model(model)
col_name = Gtk.TreeViewColumn(_("Channel group"))
self.cell_name = Gtk.CellRendererText()
col_name.pack_start(self.cell_name, True)
col_name.add_attribute(self.cell_name, "markup", ChannelGroupsStore.COL_NAME)
col_name.add_attribute(self.cell_name, "editable", ChannelGroupsStore.COL_EDITABLE)
self.append_column(col_name)
def __create_unassigned_devices(self):
self.unassigned_devices = UnassignedDevicesStore()
self.unassigned_view = DeviceGroupsView(self.unassigned_devices)
self.unassigned_view.get_selection().connect(
"changed", self._on_unassigned_selection_changed)
self.unassigned_view.show()
unassigned_frame = Frame("<b>%s</b>" % _("Unconfigured devices"),
self.unassigned_view)
unassigned_frame.show()
self.vbox_main.pack_start(unassigned_frame, True, True, 0)
def _on_about_clicked(self, action, user_data=None):
about = Gtk.AboutDialog()
about.set_transient_for(self)
#translators: These appear in the About dialog, usual format applies.
about.set_translator_credits(_("translator-credits"))
for prop, val in list(gnomedvb.INFOS.items()):
about.set_property(prop, val)
about.set_screen(self.get_screen())
about.run()
about.destroy()
