def enable(self):
self.builder = Gtk.Builder()
self.builder.add_from_file(get_resource('config.ui'))
component.get('Preferences').add_page('Streaming', self.builder.get_object('prefs_box'))
component.get('PluginManager').register_hook('on_apply_prefs', self.on_apply_prefs)
component.get('PluginManager').register_hook('on_show_prefs', self.on_show_prefs)
file_menu = self.get_widget('menu_file_tab')
self.sep = SeparatorMenuItem()
self.item = MenuItem(_("Stream this file"))
self.item.connect("activate", self.on_menuitem_stream)
file_menu.append(self.sep)
file_menu.append(self.item)
self.sep.show()
self.item.show()
torrentmenu = component.get("MenuBar").torrentmenu
self.sep_torrentmenu = SeparatorMenuItem()
self.item_torrentmenu = MenuItem(_("Stream this torrent"))
self.item_torrentmenu.connect("activate", self.on_torrentmenu_menuitem_stream)
torrentmenu.append(self.sep_torrentmenu)
torrentmenu.append(self.item_torrentmenu)
self.sep_torrentmenu.show()
self.item_torrentmenu.show()
def on_menu(self, menuitem: Gtk.MenuItem):
name = menuitem.get_name()
if not (name.startswith('menuitem') or name.startswith('toolitem')):
raise ValueError('Invalid menu item name: {}'.format(name))
name = name.split('_', 1)[1]
if name == 'quit':
return self.on_quit()
elif name == 'savesettings':
self.instrument.save_state()
elif name == 'about':
builder = Gtk.Builder.new_from_file(
pkg_resources.resource_filename('cct', 'resource/glade/help_about.glade'))
ad = builder.get_object('aboutdialog')
ad.set_version(pkg_resources.get_distribution('cct').version)
ad.set_logo(GdkPixbuf.Pixbuf.new_from_file_at_size(
pkg_resources.resource_filename('cct', 'resource/icons/scalable/cctlogo.svg'), 256, 256))
ad.run()
ad.destroy()
del ad
else:
for nm, cls, toplevelname, gladefile, connections in self.toolwindow_registry:
if nm != name:
continue
self.construct_and_run_dialog(cls, toplevelname, gladefile, menuitem.get_label().replace('_', ''),
connections)
return False
raise ValueError(name)
def __init__(self):
MenuItem.__init__(self, _('Label')) # noqa: F821
self.sub_menu = Menu()
self.set_submenu(self.sub_menu)
self.items = []
# attach..
self.sub_menu.connect('show', self.on_show, None)
def add_submenu(self, submenu, name, terminal):
# create menu item
menu = MenuItem(name)
# call on_click method while Clicking on menu item
menu.connect("activate", self.on_click, terminal)
# append menu item to context menu
submenu.append(menu)
return menu
def repack_language_menuitem(menuitem: Gtk.MenuItem):
"""Repack language menu items for better visibility."""
menuitemname = menuitem.get_name()
langimage = get_flag_image(menuitemname)
langlabel = Gtk.Label(menuitemname.split("_")[0])
langbox = Gtk.Box()
langbox.pack_start(langimage, False, False, 12)
langbox.pack_start(langlabel, False, False, 0)
[menuitem.remove(child) for child in menuitem.get_children()]
menuitem.add(langbox)
def crawl(container: Gtk.MenuItem, path: str):
if container.get_submenu():
for child in container.get_submenu():
if hasattr(child, "get_label") and child.get_label():
child_path = path + ZimMenuBarCrawler.SEPARATOR + child.get_label(
).replace("_", "")
crawl(child, child_path)
else:
accel_name = None
if container.get_accel_path():
accel = Gtk.AccelMap.lookup_entry(
container.get_accel_path())[1]
accel_name = Gtk.accelerator_get_label(
accel.accel_key, accel.accel_mods)
result[path] = [container.activate, accel_name]
def generate_menu(self, device: Device, item: Gtk.MenuItem) -> None:
info = self.devices[device['Address']]
group: Sequence[Gtk.RadioMenuItem] = []
sub = Gtk.Menu()
if info:
for profile in info["profiles"]:
i = Gtk.RadioMenuItem.new_with_label(group, profile["description"])
group = i.get_group()
if profile["name"] == info["active_profile"]:
i.set_active(True)
i.connect("toggled", self.on_selection_changed,
device, profile["name"])
sub.append(i)
i.show()
item.set_submenu(sub)
item.show()
def create_tab_pos_menuitem(self):
"""Returns a menu to select which side of the notebook the tabs should be shown"""
tab_pos_menu = Menu()
tab_pos_menuitem = MenuItem.new_with_label(_('Position'))
group = []
for pos in ('top', 'right', 'bottom', 'left'):
menuitem = RadioMenuItem.new_with_mnemonic(group, _(pos.capitalize()))
group = menuitem.get_group()
menuitem.connect('toggled', self._on_tabs_pos_toggled, pos)
menuitem.set_active(pos == self.notebook.get_tab_pos().value_nick)
tab_pos_menu.append(menuitem)
tab_pos_menuitem.set_submenu(tab_pos_menu)
return tab_pos_menuitem
def on_fitpeak(self, menuentry: Gtk.MenuItem):
curvetype = menuentry.get_name()[:-1]
if menuentry.get_name().endswith('0'):
signs = (1, -1)
elif menuentry.get_name().endswith('+'):
signs = (1,)
elif menuentry.get_name().endswith('-'):
signs = (-1,)
else:
raise ValueError(menuentry.get_name())
model, it = self.builder.get_object('counterview').get_selection().get_selected()
if it is None:
return False
signalname = model[it][0]
abscissa = self.abscissa
signal = self._data[signalname]
left, right, bottom, top = self.axes.axis()
index = (abscissa >= left) & (abscissa <= right) & (signal <= top) & (signal >= bottom)
try:
position, hwhm, baseline, amplitude, stat = findpeak_single(abscissa[index], signal[index], None,
return_stat=True, curve=curvetype, signs=signs)
except ValueError:
self.error_message('Fitting error: Probably no points of the selected curve are in the zoomed area.')
return
x = np.linspace(abscissa[index].min(), abscissa[index].max(), index.sum() * 5)
assert isinstance(x, np.ndarray)
if curvetype == 'Gaussian':
y = amplitude * np.exp(-0.5 * (x - position) ** 2 / hwhm ** 2) + baseline
elif curvetype == 'Lorentzian':
y = amplitude * hwhm ** 2 / (hwhm ** 2 + (position - x) ** 2) + baseline
else:
raise ValueError(curvetype)
self.axes.plot(x, y, 'r-', label='Fit')
self.axes.text(position.val, amplitude.val + baseline.val, str(position), ha='center', va='bottom')
self.canvas.draw()
self._lastpeakposition = position
self.builder.get_object('move_to_peak_button').set_sensitive(True)
def cb_labels(self, labels):
for child in self.sub_menu.get_children():
self.sub_menu.remove(child)
for label in [NO_LABEL] + list(labels):
if label == NO_LABEL:
item = MenuItem(_(NO_LABEL)) # noqa: F821
else:
item = MenuItem(label.replace('_', '__'))
item.connect('activate', self.on_select_label, label)
self.sub_menu.append(item)
self.show_all()
def set_temp(menuItem: gtk.MenuItem):
temp = int(menuItem.get_label())
os.system(
f'gsettings set org.gnome.settings-daemon.plugins.color night-light-temperature "uint32 {temp}"'
)
def build_menu_radio_list(
value_list,
callback,
pref_value=None,
suffix=None,
show_notset=False,
notset_label='∞',
notset_lessthan=0,
show_other=False,
):
"""Build a menu with radio menu items from a list and connect them to the callback.
Params:
value_list [list]: List of values to build into a menu.
callback (function): The function to call when menu item is clicked.
pref_value (int): A preferred value to insert into value_list
suffix (str): Append a suffix the the menu items in value_list.
show_notset (bool): Show the unlimited menu item.
notset_label (str): The text for the unlimited menu item.
notset_lessthan (int): Activates the unlimited menu item if pref_value is less than this.
show_other (bool): Show the `Other` menu item.
The pref_value is what you would like to test for the default active radio item.
Returns:
Menu: The menu radio
"""
menu = Menu()
# Create menuitem to prevent unwanted toggled callback when creating menu.
menuitem = RadioMenuItem()
group = menuitem.get_group()
if pref_value > -1 and pref_value not in value_list:
value_list.pop()
value_list.append(pref_value)
for value in sorted(value_list):
item_text = str(value)
if suffix:
item_text += ' ' + suffix
menuitem = RadioMenuItem.new_with_label(group, item_text)
if pref_value and value == pref_value:
menuitem.set_active(True)
if callback:
menuitem.connect('toggled', callback)
menu.append(menuitem)
if show_notset:
menuitem = RadioMenuItem.new_with_label(group, notset_label)
menuitem.set_name('unlimited')
if pref_value and pref_value < notset_lessthan:
menuitem.set_active(True)
menuitem.connect('toggled', callback)
menu.append(menuitem)
if show_other:
menuitem = SeparatorMenuItem()
menu.append(menuitem)
menuitem = MenuItem.new_with_label(_('Other...'))
menuitem.set_name('other')
menuitem.connect('activate', callback)
menu.append(menuitem)
return menu
class Gtk3UI(Gtk3PluginBase):
def enable(self):
self.builder = Gtk.Builder()
self.builder.add_from_file(get_resource('config.ui'))
component.get('Preferences').add_page('Streaming', self.builder.get_object('prefs_box'))
component.get('PluginManager').register_hook('on_apply_prefs', self.on_apply_prefs)
component.get('PluginManager').register_hook('on_show_prefs', self.on_show_prefs)
file_menu = self.get_widget('menu_file_tab')
self.sep = SeparatorMenuItem()
self.item = MenuItem(_("Stream this file"))
self.item.connect("activate", self.on_menuitem_stream)
file_menu.append(self.sep)
file_menu.append(self.item)
self.sep.show()
self.item.show()
torrentmenu = component.get("MenuBar").torrentmenu
self.sep_torrentmenu = SeparatorMenuItem()
self.item_torrentmenu = MenuItem(_("Stream this torrent"))
self.item_torrentmenu.connect("activate", self.on_torrentmenu_menuitem_stream)
torrentmenu.append(self.sep_torrentmenu)
torrentmenu.append(self.item_torrentmenu)
self.sep_torrentmenu.show()
self.item_torrentmenu.show()
def disable(self):
component.get('Preferences').remove_page('Streaming')
component.get('PluginManager').deregister_hook('on_apply_prefs', self.on_apply_prefs)
component.get('PluginManager').deregister_hook('on_show_prefs', self.on_show_prefs)
file_menu = self.get_widget('menu_file_tab')
file_menu.remove(self.item)
file_menu.remove(self.sep)
torrentmenu = component.get("MenuBar").torrentmenu
torrentmenu.remove(self.item_torrentmenu)
torrentmenu.remove(self.sep_torrentmenu)
def get_widget(self, widget_name):
main_builder = component.get('MainWindow').get_builder()
return main_builder.get_object(widget_name)
@defer.inlineCallbacks
def on_apply_prefs(self):
log.debug("applying prefs for Streaming")
serve_method = 'standalone'
# if self.builder.get_object("input_serve_standalone").get_active():
# serve_method = 'standalone'
# elif self.builder.get_object("input_serve_webui").get_active():
# serve_method = 'webui'
if self.builder.get_object("input_ssl_cert_daemon").get_active():
ssl_source = 'daemon'
elif self.builder.get_object("input_ssl_cert_custom").get_active():
ssl_source = 'custom'
config = {
"ip": self.builder.get_object("input_ip").get_text(),
"port": int(self.builder.get_object("input_port").get_text()),
"use_stream_urls": self.builder.get_object("input_use_stream_urls").get_active(),
"auto_open_stream_urls": self.builder.get_object("input_auto_open_stream_urls").get_active(),
"aggressive_prioritizing": self.builder.get_object("input_aggressive_prioritizing").get_active(),
"allow_remote": self.builder.get_object("input_allow_remote").get_active(),
"download_only_streamed": self.builder.get_object("input_download_only_streamed").get_active(),
"reverse_proxy_enabled": self.builder.get_object("input_reverse_proxy_enabled").get_active(),
# "download_in_order": self.builder.get_object("input_download_in_order").get_active(),
"use_ssl": self.builder.get_object("input_use_ssl").get_active(),
# "remote_username": self.builder.get_object("input_remote_username").get_text(),
"reverse_proxy_base_url": self.builder.get_object("input_reverse_proxy_base_url").get_text(),
"remote_password": self.builder.get_object("input_remote_password").get_text(),
"ssl_priv_key_path": self.builder.get_object("input_ssl_priv_key_path").get_text(),
"ssl_cert_path": self.builder.get_object("input_ssl_cert_path").get_text(),
"serve_method": serve_method,
"ssl_source": ssl_source,
}
result = yield client.streaming.set_config(config)
if result:
message_type, message_class, message = result
if message_type == 'error':
topic = 'Unknown error type'
if message_class == 'ssl':
topic = 'SSL Failed'
dialogs.ErrorDialog(topic, message).run()
def on_show_prefs(self):
client.streaming.get_config().addCallback(self.cb_get_config)
def cb_get_config(self, config):
"""callback for on show_prefs"""
self.builder.get_object("input_ip").set_text(config["ip"])
self.builder.get_object("input_port").set_text(str(config["port"]))
self.builder.get_object("input_use_stream_urls").set_active(config["use_stream_urls"])
self.builder.get_object("input_auto_open_stream_urls").set_active(config["auto_open_stream_urls"])
self.builder.get_object("input_aggressive_prioritizing").set_active(config["aggressive_prioritizing"])
self.builder.get_object("input_allow_remote").set_active(config["allow_remote"])
self.builder.get_object("input_use_ssl").set_active(config["use_ssl"])
self.builder.get_object("input_download_only_streamed").set_active(config["download_only_streamed"])
self.builder.get_object("input_reverse_proxy_enabled").set_active(config["reverse_proxy_enabled"])
# self.builder.get_object("input_download_in_order").set_active(config["download_in_order"])
# self.builder.get_object("input_download_everything").set_active(not config["download_in_order"] and not config["download_only_streamed"])
# self.builder.get_object("input_remote_username").set_text(config["remote_username"])
self.builder.get_object("input_reverse_proxy_base_url").set_text(config["reverse_proxy_base_url"])
self.builder.get_object("input_remote_password").set_text(config["remote_password"])
self.builder.get_object("input_ssl_priv_key_path").set_text(config["ssl_priv_key_path"])
self.builder.get_object("input_ssl_cert_path").set_text(config["ssl_cert_path"])
# self.builder.get_object("input_serve_standalone").set_active(config["serve_method"] == "standalone")
# self.builder.get_object("input_serve_webui").set_active(config["serve_method"] == "webui")
self.builder.get_object("input_ssl_cert_daemon").set_active(config["ssl_source"] == "daemon")
self.builder.get_object("input_ssl_cert_custom").set_active(config["ssl_source"] == "custom")
api_url = 'http%s://%s:%s@%s:%s/streaming/stream' % (('s' if config["use_ssl"] else ''), config["remote_username"], config["remote_password"], config["ip"], config["port"])
self.builder.get_object("output_remote_url").set_text(api_url)
def on_torrentmenu_menuitem_stream(self, data=None):
torrent_id = component.get("TorrentView").get_selected_torrents()[0]
client.streaming.stream_torrent(infohash=torrent_id).addCallback(self.stream_ready)
def on_menuitem_stream(self, data=None):
torrent_id = component.get("TorrentView").get_selected_torrents()[0]
ft = component.get("TorrentDetails").tabs['Files']
paths = ft.listview.get_selection().get_selected_rows()[1]
selected = []
for path in paths:
selected.append(ft.treestore.get_iter(path))
for select in selected:
path = ft.get_file_path(select)
client.streaming.stream_torrent(infohash=torrent_id, filepath_or_index=path, includes_name=True).addCallback(self.stream_ready)
break
def stream_ready(self, result):
if result['status'] == 'success':
if result.get('use_stream_urls', False):
url = "stream+%s" % result['url']
if result.get('auto_open_stream_urls', False):
threads.deferToThread(execute_url, url)
else:
def on_dialog_callback(response):
if response == Gtk.ResponseType.YES:
threads.deferToThread(execute_url, url)
dialogs.YesNoDialog('Stream ready', 'Do you want to play the video?').run().addCallback(on_dialog_callback)
else:
dialogs.ErrorDialog('Stream ready', 'Copy the link into a media player', details=result['url']).run()
else:
dialogs.ErrorDialog('Stream failed', 'Was unable to prepare the stream', details=result).run()
