def __init__(self, parent, light):
Gtk.Window.__init__(self, title="Light Settings")
self.set_type_hint(Gdk.WindowTypeHint.DIALOG)
self.connect("delete-event", self.on_quit)
self.set_border_width(10)
self.set_default_size(250, 250)
self.parent = parent
self.light = light
self.complete = False
LightSettingsUI.open_lights.append(light)
main_vertical_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL,
spacing=10)
main_vertical_box.set_homogeneous(False)
label = Gtk.Label("Light Settings")
label.set_markup("<b>Light Settings</b>")
main_vertical_box.pack_start(label, False, True, 0)
#New Light Box
new_light_vertical_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL,
spacing=10)
label = Gtk.Label("Name")
new_light_vertical_box.pack_start(label, False, True, 0)
self.light_name = entry = Gtk.Entry()
entry.set_text(light.light_name)
entry.connect('changed', self.on_update)
new_light_vertical_box.pack_start(entry, False, True, 0)
label = Gtk.Label("Channel Index")
new_light_vertical_box.pack_start(label, False, True, 0)
self.channel_index = entry = Gtk.Entry()
entry.connect('changed', self.on_update)
entry.set_text(str(light.light_channel_index))
new_light_vertical_box.pack_start(entry, False, True, 0)
label = Gtk.Label("Size (px)")
new_light_vertical_box.pack_start(label, False, True, 0)
self.size_adjustment = size_adjustment = Gtk.Adjustment(
50, 25, 250, 1, 10, 0)
size_adjustment.connect('value-changed', self.on_update)
self.scale = scale = Gtk.Scale(adjustment=size_adjustment)
scale.set_digits(0)
scale.set_value(light.light_size)
scale.set_value_pos(Gtk.PositionType.BOTTOM)
new_light_vertical_box.pack_start(scale, False, True, 0)
label = Gtk.Label("Channel Size (3, 7, or 8)")
new_light_vertical_box.pack_start(label, False, True, 0)
self.channel_size = entry = Gtk.Entry()
entry.connect('changed', self.on_update)
entry.set_text("3")
entry.root = self
new_light_vertical_box.pack_start(entry, False, True, 0)
location_box = Gtk.Box(spacing=10)
label = Gtk.Label("X%:")
location_box.pack_start(label, False, True, 0)
self.x_adjustment = x_adjustment = Gtk.Adjustment(50, 0, 100, 1, 10, 0)
x_adjustment.connect('value-changed', self.on_update)
scale = Gtk.Scale(adjustment=x_adjustment)
scale.set_digits(0)
scale.set_value(light.light_x)
scale.set_value_pos(Gtk.PositionType.BOTTOM)
location_box.pack_start(scale, True, True, 0)
label = Gtk.Label("Y%:")
location_box.pack_start(label, False, True, 0)
self.y_adjustment = y_adjustment = Gtk.Adjustment(50, 0, 100, 1, 10, 0)
y_adjustment.connect('value-changed', self.on_update)
scale = Gtk.Scale(adjustment=y_adjustment)
scale.set_digits(0)
scale.set_value(light.light_y)
scale.set_value_pos(Gtk.PositionType.BOTTOM)
location_box.pack_start(scale, True, True, 0)
new_light_vertical_box.pack_start(location_box, False, True, 0)
button = Gtk.Button.new_with_label("Remove Light")
button.connect("clicked", self.on_remove_light)
new_light_vertical_box.pack_start(button, False, True, 0)
button = Gtk.Button.new_with_label("Single Capture Light")
button.connect("clicked", self.on_update_light)
new_light_vertical_box.pack_start(button, False, True, 0)
self.cont_cap_btn = button = Gtk.Button.new_with_label(
"Enable Continuous Capture")
button.connect("clicked", self.on_cont_light)
if light in self.parent.multi_capture_queue:
button.set_sensitive(False)
new_light_vertical_box.pack_start(button, False, True, 0)
self.dis_cont_cap_btn = button = Gtk.Button.new_with_label(
"Disable Continuous Capture")
button.connect("clicked", self.on_dis_cont_light)
if light not in self.parent.multi_capture_queue:
button.set_sensitive(False)
new_light_vertical_box.pack_start(button, False, True, 0)
main_vertical_box.pack_start(new_light_vertical_box, False, True, 0)
self.add(main_vertical_box)
self.show_all()
self.complete = True
def __init__(self, parent):
Gtk.Dialog.__init__(self, "add new movement", parent, 0,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
self.set_default_size(150, 100)
box = self.get_content_area()
grid = Gtk.Grid()
# value field
value_label = Gtk.Label("value")
value_adjustment = Gtk.Adjustment(0, -99999, 99999, 0.1, 1, 0)
self.value_button = Gtk.SpinButton()
self.value_button.set_adjustment(value_adjustment)
self.value_button.set_digits(2)
self.value_button.set_numeric(True)
grid.add(value_label)
grid.attach_next_to(self.value_button, value_label,
Gtk.PositionType.RIGHT, 1, 1)
cause_label = Gtk.Label("Cause")
self.cause_entry = Gtk.Entry()
self.cause_entry.set_placeholder_text("cause")
grid.attach_next_to(cause_label, value_label, Gtk.PositionType.BOTTOM,
1, 1)
grid.attach_next_to(self.cause_entry, cause_label,
Gtk.PositionType.RIGHT, 1, 1)
#Date selection
date = datetime.datetime.today().date()
date_label = Gtk.Label("Date")
grid.attach_next_to(date_label, cause_label, Gtk.PositionType.BOTTOM,
1, 1)
year_label = Gtk.Label("Year")
year_adjustment = Gtk.Adjustment(date.year, 1900, 2100, 1, 1, 0)
self.year_spin = Gtk.SpinButton()
self.year_spin.configure(year_adjustment, 1, 0)
self.year_spin.connect("value-changed", self.update_day_adj)
grid.attach_next_to(year_label, date_label, Gtk.PositionType.BOTTOM, 1,
1)
grid.attach_next_to(self.year_spin, year_label, Gtk.PositionType.RIGHT,
1, 1)
month_label = Gtk.Label("Month")
month_adjustment = Gtk.Adjustment(date.month, 1, 12, 1, 1, 0)
self.month_spin = Gtk.SpinButton()
self.month_spin.configure(month_adjustment, 1, 0)
self.month_spin.connect("value-changed", self.update_day_adj)
grid.attach_next_to(month_label, year_label, Gtk.PositionType.BOTTOM,
1, 1)
grid.attach_next_to(self.month_spin, month_label,
Gtk.PositionType.RIGHT, 1, 1)
day_label = Gtk.Label("Day")
day_adjustment = Gtk.Adjustment(date.day, 1,
monthrange(date.year, date.month)[1],
1, 1, 0)
self.day_spin = Gtk.SpinButton()
self.day_spin.configure(day_adjustment, 1, 0)
grid.attach_next_to(day_label, month_label, Gtk.PositionType.BOTTOM, 1,
1)
grid.attach_next_to(self.day_spin, day_label, Gtk.PositionType.RIGHT,
1, 1)
box.add(grid)
self.show_all()
def create_adj(self):
return Gtk.Adjustment(1, 1, 65535, 1, 10, 0)
def show_reverse_dialog(media_file, default_range_render, _response_callback):
folder, file_name = os.path.split(media_file.path)
if media_file.is_proxy_file:
folder, file_name = os.path.split(media_file.second_file_path)
name, ext = os.path.splitext(file_name)
dialog = Gtk.Dialog(
_("Render Reverse Motion Video File"), gui.editor_window.window,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT,
_("Render").encode('utf-8'), Gtk.ResponseType.ACCEPT))
media_file_label = Gtk.Label(label=_("Source Media File: "))
media_name = Gtk.Label(label="<b>" + media_file.name + "</b>")
media_name.set_use_markup(True)
SOURCE_PAD = 8
SOURCE_HEIGHT = 20
mf_row = guiutils.get_left_justified_box([
media_file_label,
guiutils.pad_label(SOURCE_PAD, SOURCE_HEIGHT), media_name
])
mark_in = Gtk.Label(label=_("<b>not set</b>"))
mark_out = Gtk.Label(label=_("<b>not set</b>"))
if media_file.mark_in != -1:
mark_in = Gtk.Label(label="<b>" +
utils.get_tc_string(media_file.mark_in) + "</b>")
if media_file.mark_out != -1:
mark_out = Gtk.Label(label="<b>" +
utils.get_tc_string(media_file.mark_out) + "</b>")
mark_in.set_use_markup(True)
mark_out.set_use_markup(True)
fb_widgets = utils.EmptyClass()
fb_widgets.file_name = Gtk.Entry()
fb_widgets.file_name.set_text(name + "_REVERSE")
fb_widgets.extension_label = Gtk.Label()
fb_widgets.extension_label.set_size_request(45, 20)
name_row = Gtk.HBox(False, 4)
name_row.pack_start(fb_widgets.file_name, True, True, 0)
name_row.pack_start(fb_widgets.extension_label, False, False, 4)
fb_widgets.out_folder = Gtk.FileChooserButton(_("Select Target Folder"))
fb_widgets.out_folder.set_action(Gtk.FileChooserAction.SELECT_FOLDER)
fb_widgets.out_folder.set_current_folder(folder)
label = Gtk.Label(label=_("Speed %:"))
adjustment = Gtk.Adjustment(float(-100), float(-600), float(-1), float(1))
fb_widgets.hslider = Gtk.HScale()
fb_widgets.hslider.set_adjustment(adjustment)
fb_widgets.hslider.set_draw_value(False)
spin = Gtk.SpinButton()
spin.set_numeric(True)
spin.set_adjustment(adjustment)
fb_widgets.hslider.set_digits(0)
spin.set_digits(0)
slider_hbox = Gtk.HBox(False, 4)
slider_hbox.pack_start(fb_widgets.hslider, True, True, 0)
slider_hbox.pack_start(spin, False, False, 4)
slider_hbox.set_size_request(450, 35)
hbox = Gtk.HBox(False, 2)
hbox.pack_start(guiutils.pad_label(8, 8), False, False, 0)
hbox.pack_start(slider_hbox, False, False, 0)
profile_selector = ProfileSelector()
profile_selector.fill_options()
profile_selector.widget.set_sensitive(True)
fb_widgets.out_profile_combo = profile_selector.widget
quality_selector = RenderQualitySelector()
fb_widgets.quality_cb = quality_selector.widget
# Encoding
encoding_selector = RenderEncodingSelector(quality_selector,
fb_widgets.extension_label,
None)
encoding_selector.encoding_selection_changed()
fb_widgets.encodings_cb = encoding_selector.widget
objects_list = Gtk.TreeStore(str, bool)
objects_list.append(None, [_("Full Source Length"), True])
if media_file.mark_in != -1 and media_file.mark_out != -1:
range_available = True
else:
range_available = False
objects_list.append(None,
[_("Source Mark In to Mark Out"), range_available])
fb_widgets.render_range = Gtk.ComboBox.new_with_model(objects_list)
renderer_text = Gtk.CellRendererText()
fb_widgets.render_range.pack_start(renderer_text, True)
fb_widgets.render_range.add_attribute(renderer_text, "text", 0)
fb_widgets.render_range.add_attribute(renderer_text, 'sensitive', 1)
if default_range_render == False:
fb_widgets.render_range.set_active(0)
else:
fb_widgets.render_range.set_active(1)
fb_widgets.render_range.show()
# To update rendered length display
clip_length = _get_rendered_slomo_clip_length(media_file,
fb_widgets.render_range, 100)
clip_length_label = Gtk.Label(label=utils.get_tc_string(clip_length))
fb_widgets.hslider.connect("value-changed", _reverse_speed_changed,
media_file, fb_widgets.render_range,
clip_length_label)
fb_widgets.render_range.connect("changed", _reverse_range_changed,
media_file, fb_widgets.hslider,
clip_length_label)
# Build gui
vbox = Gtk.VBox(False, 2)
vbox.pack_start(mf_row, False, False, 0)
vbox.pack_start(
guiutils.get_left_justified_box([
Gtk.Label(label=_("Source Mark In: ")),
guiutils.pad_label(SOURCE_PAD, SOURCE_HEIGHT), mark_in
]), False, False, 0)
vbox.pack_start(
guiutils.get_left_justified_box([
Gtk.Label(label=_("Source Mark Out: ")),
guiutils.pad_label(SOURCE_PAD, SOURCE_HEIGHT), mark_out
]), False, False, 0)
vbox.pack_start(guiutils.pad_label(18, 12), False, False, 0)
vbox.pack_start(label, False, False, 0)
vbox.pack_start(hbox, False, False, 0)
vbox.pack_start(guiutils.pad_label(18, 12), False, False, 0)
vbox.pack_start(
guiutils.get_two_column_box(Gtk.Label(label=_("Target File:")),
name_row, 120), False, False, 0)
vbox.pack_start(
guiutils.get_two_column_box(Gtk.Label(label=_("Target Folder:")),
fb_widgets.out_folder, 120), False, False,
0)
vbox.pack_start(
guiutils.get_two_column_box(Gtk.Label(label=_("Target Profile:")),
fb_widgets.out_profile_combo, 200), False,
False, 0)
vbox.pack_start(
guiutils.get_two_column_box(Gtk.Label(label=_("Target Encoding:")),
fb_widgets.encodings_cb, 200), False,
False, 0)
vbox.pack_start(
guiutils.get_two_column_box(Gtk.Label(label=_("Target Quality:")),
fb_widgets.quality_cb, 200), False, False,
0)
vbox.pack_start(guiutils.pad_label(18, 12), False, False, 0)
vbox.pack_start(
guiutils.get_two_column_box(Gtk.Label(label=_("Render Range:")),
fb_widgets.render_range, 180), False,
False, 0)
vbox.pack_start(
guiutils.get_two_column_box(
Gtk.Label(label=_("Rendered Clip Length:")), clip_length_label,
180), False, False, 0)
alignment = guiutils.set_margins(vbox, 6, 24, 24, 24)
dialog.vbox.pack_start(alignment, True, True, 0)
dialogutils.set_outer_margins(dialog.vbox)
dialogutils.default_behaviour(dialog)
dialog.connect('response', _response_callback, fb_widgets, media_file)
dialog.show_all()
#!/usr/bin/env python
from gi.repository import Gtk
window = Gtk.Window()
window.connect("destroy", lambda q: Gtk.main_quit())
adjustment = Gtk.Adjustment(value=5,
lower=0,
upper=10,
step_increment=1,
page_increment=1,
page_size=0)
spinbutton = Gtk.SpinButton(adjustment=adjustment)
window.add(spinbutton)
window.show_all()
Gtk.main()
def make_menu(self, initialize=True):
"""build the menu"""
if initialize:
self.window = Gtk.Window(Gtk.WindowType.TOPLEVEL)
self.window.connect("delete_event", self.close_application)
self.window.set_title("Handymenu configuration")
self.window.set_border_width(0)
else:
self.window.remove(self.mainbox)
# Conteneur principal
self.mainbox = Gtk.VBox(False, 10)
self.mainbox.set_border_width(10)
# configuration principale
self.make_entrylist()
# extra options
extrabox = Gtk.HBox(False, 5)
self.mainbox.pack_start(extrabox, False, False, 0)
# coches pour modules
modulesbox = Gtk.HBox(False, 5)
modulesframe = Gtk.Frame(label=_("Modules"))
modulesframe.add(modulesbox)
extrabox.pack_start(modulesframe, False, False, 0)
recents_files_check = Gtk.CheckButton(_("Show recent files"))
recents_files_check.set_tooltip_text(_("Show recent files"))
if "_recent_files_" in load_modules()[1]:
recents_files_check.set_active(True)
recents_files_check.connect("toggled", self.module_toggle,
"_recent_files_")
modulesbox.pack_start(recents_files_check, False, False, 0)
# module firefox most viewed
most_ffox_check = Gtk.CheckButton(_("Most visited"))
most_ffox_check.set_tooltip_text(_("Show most visited uri"))
if "_most_ffox_view_" in load_modules()[1]:
most_ffox_check.set_active(True)
most_ffox_check.connect("toggled", self.module_toggle,
"_most_ffox_view_")
modulesbox.pack_start(most_ffox_check, False, False, 0)
# position des modules
self.modules_position = Gtk.SpinButton()
#adjustment = Gtk.Adjustment(0, start, max, step, 10, 0)
adjustment = Gtk.Adjustment(0, 1, len(self.config) + 1, 1, 10, 0)
self.modules_position.set_adjustment(adjustment)
self.modules_position.set_numeric(True)
self.modules_position.set_value(load_modules()[0])
self.modules_position.set_tooltip_text(
_("Position of modules in menu"))
self.modules_position.connect("value-changed", \
lambda x: set_modules_position(self.modules_position.get_value_as_int()))
modulesbox.pack_start(self.modules_position, False, False, 1)
# conteneur pour les boutons
btnbox = Gtk.HBox(True, 2)
self.mainbox.pack_start(btnbox, False, False, 0)
defaultbtn = Gtk.Button(label=_("Reset"))
resetimg = Gtk.Image()
resetimg.set_from_stock(Gtk.STOCK_REDO, Gtk.IconSize.BUTTON)
defaultbtn.set_image(resetimg)
defaultbtn.connect_object("clicked", self.back_to_default, self.window)
btnbox.pack_start(defaultbtn, False, False, 0)
viewbtn = Gtk.Button(label=_("View config"))
viewbtn.connect("clicked", lambda x: self.view_config())
btnbox.pack_start(viewbtn, False, False, 0)
savebtn = Gtk.Button(label=_("Quit"), stock=Gtk.STOCK_CLOSE)
savebtn.connect_object("clicked", self.close_application, self.window,
None)
btnbox.pack_start(savebtn, False, False, 0)
self.window.add(self.mainbox)
self.window.set_default_size(620, 560)
self.window.show_all()
def init_components(self) -> None:
grid = Gtk.Grid(
row_homogeneous=True,
column_homogeneous=True,
row_spacing=5,
column_spacing=5,
)
# Simulate Switch ------------------------------------------------------
top_box = Gtk.Box(spacing=2)
self.simulating_label = Gtk.Label(label="Start Simulating")
self.simulating_switch = Gtk.Switch()
self.simulating_switch.set_active(False)
self.simulating_switch.connect("notify::active",
self.execute_simulation)
self.executing_spinner = Gtk.Spinner()
self.quantum_rat_spin_button = Gtk.SpinButton(
adjustment=Gtk.Adjustment(value=750,
lower=125,
upper=10000,
step_increment=125,
page_increment=0,
page_size=0),
climb_rate=1,
digits=0,
)
self.quantum_rat_spin_button.connect("value-changed",
self.change_quantum_rat)
# Inactive Processes List ----------------------------------------------
self.inactive_processes_list_box = Gtk.ListBox()
self.inactive_processes_list_box.set_selection_mode(
Gtk.SelectionMode.NONE)
inactive_processes_scrolled_window = Gtk.ScrolledWindow()
inactive_processes_scrolled_window.add(
self.inactive_processes_list_box)
for i in self.process_manager.inactive_processes:
process_button = Gtk.Button(label=i.name)
process_button.connect("clicked", self.prepare_process_action)
self.inactive_processes_list_box.add(process_button)
add_process_button = Gtk.Button(label="Add Process")
add_process_button.connect("clicked", self.add_process_action)
# Prepared Processes List ----------------------------------------------
self.prepared_processes_list_box = Gtk.ListBox()
self.prepared_processes_list_box.set_selection_mode(
Gtk.SelectionMode.NONE)
prepared_processes_scrolled_window = Gtk.ScrolledWindow()
prepared_processes_scrolled_window.add(
self.prepared_processes_list_box)
# Executed Process Progress Bar ----------------------------------------
self.executed_process_list_box = Gtk.ListBox()
self.executed_process_list_box.set_selection_mode(
Gtk.SelectionMode.NONE)
executed_process_scrolled_window = Gtk.ScrolledWindow()
executed_process_scrolled_window.add(self.executed_process_list_box)
# Suspended Processes List ---------------------------------------------
self.suspended_processes_list_box = Gtk.ListBox()
self.suspended_processes_list_box.set_selection_mode(
Gtk.SelectionMode.NONE)
suspended_processes_scrolled_window = Gtk.ScrolledWindow()
suspended_processes_scrolled_window.add(
self.suspended_processes_list_box)
# Add Components -------------------------------------------------------
top_box.add(Gtk.Label(label='Quantum Rat (ms):'))
top_box.add(self.quantum_rat_spin_button)
top_box.add(self.simulating_label)
top_box.add(self.simulating_switch)
top_box.add(self.executing_spinner)
grid.attach(top_box, 0, 0, 3, 1)
grid.attach(Gtk.Label(label="Inactive Processes"), 0, 1, 1, 1)
grid.attach(inactive_processes_scrolled_window, 0, 2, 1, 15)
grid.attach(add_process_button, 0, 17, 1, 1)
grid.attach(Gtk.Label(label="Prepared Processes"), 1, 1, 3, 1)
grid.attach(prepared_processes_scrolled_window, 1, 2, 3, 16)
grid.attach(Gtk.Label(label="Executed Process"), 4, 1, 3, 1)
grid.attach(executed_process_scrolled_window, 4, 2, 3, 1)
grid.attach(Gtk.Label(label="Suspended Processes"), 4, 3, 3, 1)
grid.attach(suspended_processes_scrolled_window, 4, 4, 3, 14)
self.update_components()
self.add(grid)
def __init__(self):
Gtk.Window.__init__(self, title=_("Favorites Applet Settings"))
window_icon = self.render_icon(Gtk.STOCK_PREFERENCES, 6)
self.set_icon(window_icon)
self.set_position(3)
self.set_border_width(15)
box_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL,
spacing=30)
box_container.set_homogeneous(False)
# Righ options column
vbox_right = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
vbox_right.set_homogeneous(False)
# Columns options container box
box_options = Gtk.HBox(spacing=15)
box_options.set_homogeneous(False)
box_options.pack_start(vbox_right, False, False, 0)
# Bottom options box
#box_extra = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
#box_extra.set_homogeneous(False)
# Buttons box
box_buttons = Gtk.HBox(spacing=10)
box_buttons.set_homogeneous(False)
box_container.pack_start(box_options, True, True, 0)
#box_container.pack_start(box_extra, True, True, 0)
box_container.pack_start(box_buttons, True, True, 0)
# Build options for right column
if (config.has_key('SHOW_POPUPS')):
switch_SHOW_POPUPS = switch_option()
switch_SHOW_POPUPS.create(
vbox_right, 'SHOW_POPUPS', config['SHOW_POPUPS'],
_("Display pop-up confirmation windows for \"Quit...\" and \"Log Out...\"?"
))
vbox_right.pack_start(Gtk.HSeparator(), False, False, 0)
# Icon size slider
box_icon_size = Gtk.VBox(0)
adjust_icon_size = Gtk.Adjustment(config['ICON_SIZE'], 16, 46, 6, 6, 0)
adjust_icon_size.connect("value_changed", self.on_slider_change,
'ICON_SIZE')
slider_icon_size = Gtk.HScale()
slider_icon_size.set_adjustment(adjust_icon_size)
slider_icon_size.set_digits(0)
box_icon_size.pack_start(Gtk.Label(_("Icon size")), False, False, 0)
box_icon_size.pack_start(slider_icon_size, False, False, 0)
vbox_right.pack_start(box_icon_size, False, False, 0)
# Build extra options
#self.restart = False
#self.check_restart = Gtk.CheckButton("Restart Cinnamon on close")
#self.check_restart.connect('toggled', self.change_restart_status)
#self.check_restart.set_active(False)
#box_extra.pack_start(self.check_restart, True, True, 0)
# Build buttons
#img_default = Gtk.Image()
#img_default.set_from_stock(Gtk.STOCK_PROPERTIES, 3)
#btn_default = Gtk.Button(_("Default settings"))
#btn_default.set_property("image", img_default)
#btn_default.connect('clicked', self.generate_config_file)
#box_buttons.pack_start(btn_default, False, False, 0)
btn_close = Gtk.Button(stock=Gtk.STOCK_CLOSE)
btn_close.connect('clicked', self.exit_application)
box_buttons.pack_end(btn_close, False, False, 0)
img_restart = Gtk.Image()
img_restart.set_from_stock(Gtk.STOCK_REFRESH, 3)
btn_restart = Gtk.Button(_("Restart Cinnamon"))
btn_restart.set_property("image", img_restart)
btn_restart.connect('clicked', self.restart_shell)
box_buttons.pack_end(btn_restart, False, False, 0)
self.add(box_container)
def createOptionWidgets (self):
n=0
if self.option_label:
n=1
lab=Gtk.Label()
lab.set_text('<span weight="bold"><u>%s</u></span>'%self.option_label)
lab.set_use_markup(True)
lab.set_alignment(0.0,0.5)
lab.set_justify(Gtk.Justification.LEFT)
self.attach(lab, 0, 1, 0, 1, xpadding=self.xpadding, ypadding=self.ypadding)
#xoptions=Gtk.AttachOptions.SHRINK, yoptions=Gtk.AttachOptions.SHRINK)
lab.show()
if self.value_label:
n=1
lab=Gtk.Label()
lab.set_markup('<span weight="bold"><u>%s</u></span>'%self.value_label)
lab.set_alignment(0,0.5)
lab.set_justify(Gtk.Justification.CENTER)
self.attach(lab, 1, 2, 0, 1, xpadding=self.xpadding, ypadding=self.ypadding,
xoptions=Gtk.AttachOptions.SHRINK, yoptions=Gtk.AttachOptions.SHRINK)
lab.show()
for l,v in self.options:
if isinstance(v,CustomOption):
w = v
self.widgets.append([v,'get_value','set_value'])
v.connect('changed',lambda * args: self.emit('changed'))
elif isinstance(v, bool):
w=Gtk.CheckButton()
w.set_active(v)
# widgets contains the widget, the get method and the set method
self.widgets.append([w,'get_active','set_active'])
w.connect('toggled',lambda *args: self.emit('changed'))
if self.changedcb:
w.connect('toggled',self.changedcb)
elif isinstance(v, str):
w=Gtk.Entry()
w.set_text(v)
self.widgets.append([w, 'get_text', 'set_text'])
w.connect('changed',lambda *args: self.emit('changed'))
if self.changedcb:
w.connect('changed',self.changedcb)
elif isinstance(v, (int, float)):
adj = Gtk.Adjustment(value=0, lower=0, upper=100*(v or 1), step_incr=(v or 1)*0.1, page_incr=(v or 1)*0.5)
if isinstance(v, int):
# if an integer...
w=Gtk.SpinButton(adj, digits=0)
self.widgets.append([w,'get_value_as_int','set_value'])
else:
w=Gtk.SpinButton(adj, digits=2)
self.widgets.append([w,'get_value','set_value'])
w.set_value(v)
w.connect('changed',lambda *args: self.emit('changed'))
if self.changedcb:
w.connect('changed',self.changedcb)
elif isinstance(v, (list, tuple)):
default,value_list = v
w = Gtk.ComboBoxText()
for itm in value_list:
w.append_text(itm)
cb_extras.cb_set_active_text(w,default)
cb_extras.setup_typeahead(w)
self.widgets.append([w,'get_active_text',cb_extras.cb_set_active_text])
w.connect('changed',lambda *args: self.emit('changed'))
if self.changedcb: w.connect('changed',self.changedcb)
else:
raise Exception("I don't know what to do with a value of type %s (%s)" % (type(v),v))
# attach out label and our widget
lab = Gtk.Label()
lab.set_text_with_mnemonic(l)
lab.set_mnemonic_widget(w)
lab.set_justify(Gtk.Justification.LEFT)
lab.set_alignment(0,0)
self.attach(lab, 0, 1, n, n+1, xpadding=self.xpadding, ypadding=self.ypadding,
xoptions=Gtk.AttachOptions.FILL,yoptions=Gtk.AttachOptions.SHRINK)
lab.show()
self.attach(w, 1, 2, n, n+1, xpadding=self.xpadding, ypadding=self.ypadding,
xoptions=Gtk.AttachOptions.FILL,yoptions=Gtk.AttachOptions.SHRINK)
w.show()
n += 1
def crop_page_dialog(self, widget):
"""Opens a dialog box to define margins for page cropping"""
sides = ('L', 'R', 'T', 'B')
side_names = {
'L': _('Left'),
'R': _('Right'),
'T': _('Top'),
'B': _('Bottom')
}
opposite_sides = {'L': 'R', 'R': 'L', 'T': 'B', 'B': 'T'}
def set_crop_value(spinbutton, side):
opp_side = opposite_sides[side]
pos = sides.index(opp_side)
adj = spin_list[pos].get_adjustment()
adj.set_upper(99.0 - spinbutton.get_value())
model = self.iconview.get_model()
selection = self.iconview.get_selected_items()
crop = [0., 0., 0., 0.]
if selection:
path = selection[0]
pos = model.get_iter(path)
crop = [model.get_value(pos, 7 + side) for side in range(4)]
dialog = Gtk.Dialog(title=(_('Crop Selected Pages')),
parent=self.window,
flags=Gtk.DialogFlags.MODAL,
buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
dialog.set_size_request(340, 250)
dialog.set_default_response(Gtk.ResponseType.OK)
frame = Gtk.Frame(_('Crop Margins'))
dialog.vbox.pack_start(frame, False, False, 20)
vbox = Gtk.VBox(False, 0)
frame.add(vbox)
spin_list = []
units = 2 * [_('% of width')] + 2 * [_('% of height')]
for side in sides:
hbox = Gtk.HBox(True, 0)
vbox.pack_start(hbox, False, False, 5)
label = Gtk.Label(label=side_names[side])
label.set_alignment(0, 0.0)
hbox.pack_start(label, True, True, 20)
adj = Gtk.Adjustment(100. * crop.pop(0), 0.0, 99.0, 1.0, 5.0, 0.0)
spin = Gtk.SpinButton(adj, 0, 1)
spin.set_activates_default(True)
spin.connect('value-changed', set_crop_value, side)
spin_list.append(spin)
hbox.pack_start(spin, False, False, 30)
label = Gtk.Label(label=units.pop(0))
label.set_alignment(0, 0.0)
hbox.pack_start(label, True, True, 0)
dialog.show_all()
result = dialog.run()
if result == Gtk.ResponseType.OK:
modified = False
crop = [spin.get_value() / 100. for spin in spin_list]
for path in selection:
pos = model.get_iter(path)
for it in range(4):
old_val = model.get_value(pos, 7 + it)
model.set_value(pos, 7 + it, crop[it])
if crop[it] != old_val:
modified = True
self.update_geometry(pos)
if modified:
self.set_unsaved(True)
self.reset_iv_width()
elif result == Gtk.ResponseType.CANCEL:
print(_('Dialog closed'))
dialog.destroy()
def __init__(self, controls):
self.controls = controls
box = Gtk.VBox(False, 0)
box.hide()
download_frame = Gtk.Frame(label=_("File downloads"))
df_vbox = Gtk.VBox(False, 5)
df_vbox.set_border_width(4)
"""save to"""
hbox = Gtk.HBox(False, 5)
self.online_dir = Gtk.FileChooserButton("set place")
self.online_dir.set_action(Gtk.FileChooserAction.SELECT_FOLDER)
self.online_dir.connect("current-folder-changed",
self.on_change_folder)
hbox.pack_start(Gtk.Label(_("Save online music to folder:")), False,
True, 0)
hbox.pack_start(self.online_dir, True, True, 0)
"""automatic save"""
self.automatic_save_checkbutton = Gtk.CheckButton(
label=_("Automatic online music save"), use_underline=True)
self.nosubfolder_checkbutton = Gtk.CheckButton(
label=_("Save to one folder (no subfolders)"), use_underline=True)
"""download threads"""
thbox = Gtk.HBox(False, 5)
tab_label = Gtk.Label(_("Download in threads"))
adjustment = Gtk.Adjustment(value=1,
lower=1,
upper=10,
step_incr=1,
page_incr=1,
page_size=0)
self.threads_count = Gtk.SpinButton(adjustment=adjustment)
thbox.pack_start(tab_label, False, False, 0)
thbox.pack_start(self.threads_count, False, True, 0)
df_vbox.pack_start(hbox, False, False, 2)
df_vbox.pack_start(self.automatic_save_checkbutton, False, False, 2)
df_vbox.pack_start(self.nosubfolder_checkbutton, False, False, 2)
df_vbox.pack_start(thbox, False, False, 2)
download_frame.add(df_vbox)
download_frame.show_all()
"""disc cover size"""
dc_frame = Gtk.Frame(label=_("Disc cover settings"))
cbox = Gtk.HBox(False, 5)
cbox.set_border_width(4)
tab_label = Gtk.Label(_("Disc cover size:"))
adjustment = Gtk.Adjustment(value=1,
lower=100,
upper=350,
step_incr=20,
page_incr=50,
page_size=0)
self.image_size_spin = Gtk.SpinButton(adjustment=adjustment)
cbox.pack_start(tab_label, False, False, 0)
cbox.pack_start(self.image_size_spin, False, True, 0)
dc_frame.add(cbox)
dc_frame.show_all()
"""notification"""
updates_frame = Gtk.Frame(label=_("Updates"))
uhbox = Gtk.HBox(False, 5)
uhbox.set_border_width(4)
self.check_new_version = Gtk.CheckButton(
label=_("Check for new foobnix release on start"),
use_underline=True)
demo = Gtk.Button(label=_("Check for update"))
demo.connect(
"clicked",
lambda *a: info_dialog_with_link_and_donate("foobnix [version]"))
uhbox.pack_start(self.check_new_version, True, True, 0)
uhbox.pack_start(demo, False, False, 0)
updates_frame.add(uhbox)
updates_frame.show_all()
"""background image"""
theme_frame = Gtk.Frame(label=_("Theming"))
thvbox = Gtk.VBox(False, 1)
thvbox.set_border_width(4)
"""menu position"""
pbox = Gtk.HBox(False, 5)
pbox.show()
label = Gtk.Label(_("Menu type: "))
self.old_style = Gtk.RadioButton(_("Old Style (Menu Bar)"))
self.new_style = Gtk.RadioButton.new_with_label_from_widget(
self.old_style, _("New Style (Button)"))
pbox.pack_start(label, False, False, 0)
pbox.pack_start(self.new_style, False, True, 0)
pbox.pack_start(self.old_style, False, False, 0)
o_r_box = Gtk.HBox(False, 5)
o_r_box.show()
o_r_label = Gtk.Label(_("Order-Repeat Switcher Style:"))
self.buttons = Gtk.RadioButton(None, _("Toggle Buttons"))
self.labels = Gtk.RadioButton.new_with_label_from_widget(
self.buttons, _("Text Labels"))
o_r_box.pack_start(o_r_label, False, False, 0)
o_r_box.pack_start(self.buttons, False, True, 0)
o_r_box.pack_start(self.labels, False, False, 0)
"""opacity"""
obox = Gtk.HBox(False, 5)
obox.show()
tab_label = Gtk.Label(_("Opacity:"))
tab_label.show()
adjustment = Gtk.Adjustment(value=1,
lower=20,
upper=100,
step_incr=1,
page_incr=1,
page_size=0)
self.opacity_size = Gtk.SpinButton(adjustment=adjustment)
self.opacity_size.connect("value-changed", self.on_chage_opacity)
self.opacity_size.show()
obox.pack_start(tab_label, False, False, 0)
obox.pack_start(self.opacity_size, False, True, 0)
self.fmgrs_combo = self.fmgr_combobox()
hcombobox = Gtk.HBox(False, 5)
hcombobox.pack_start(
Gtk.Label(_('Choose your preferred file manager:')), False, False,
0)
hcombobox.pack_start(self.fmgrs_combo, False, False, 0)
self.disable_screensaver = Gtk.CheckButton(
label=_("Disable Xscreensaver"), use_underline=True)
thvbox.pack_start(pbox, False, False, 1)
thvbox.pack_start(o_r_box, False, False, 1)
thvbox.pack_start(obox, False, False, 1)
thvbox.pack_start(hcombobox, False, False, 1)
thvbox.pack_start(self.disable_screensaver, False, False, 0)
theme_frame.add(thvbox)
theme_frame.show_all()
"""packaging"""
box.pack_start(download_frame, False, True, 2)
box.pack_start(dc_frame, False, True, 2)
box.pack_start(theme_frame, False, False, 2)
box.pack_start(updates_frame, False, True, 2)
self.widget = box
def createTraceToolBar(self):
toolbar = Gtk.Toolbar()
#toolbar.set_orientation(Gtk.Orientation.VERTICAL)
#toolbar.set_icon_size(Gtk.IconSize.MENU)
toolbar.set_icon_size(Gtk.IconSize.LARGE_TOOLBAR)
toolbar.set_style(Gtk.ToolbarStyle.ICONS)
toolbar.set_show_arrow(False)
# build the zoom controls
self.zoomin_button = Gtk.ToolButton(Gtk.STOCK_ZOOM_IN)
self.zoomin_button.set_homogeneous(False)
self.zoomin_button.set_tooltip_text('Zoom in')
self.zoomin_button.connect('clicked', self.zoomButtons, 1)
toolbar.insert(self.zoomin_button, -1)
self.zoomout_button = Gtk.ToolButton(Gtk.STOCK_ZOOM_OUT)
self.zoomout_button.set_homogeneous(False)
self.zoomout_button.set_tooltip_text('Zoom out')
self.zoomout_button.connect('clicked', self.zoomButtons, -1)
toolbar.insert(self.zoomout_button, -1)
self.zoom_combo = Gtk.ComboBoxText()
for zoom in self.zoom_levels:
self.zoom_combo.append_text(str(zoom) + '%')
self.zoom_combo.set_active(self.curr_zoom)
self.zoom_combo.connect('changed', self.zoomComboBox)
# Place the combo box in a VButtonBox to prevent it from expanding
# vertically.
vbox = Gtk.VButtonBox()
vbox.pack_start(self.zoom_combo, False, True, 0)
t_item = Gtk.ToolItem()
t_item.add(vbox)
t_item.set_tooltip_text('Adjust the zoom level')
t_item.set_expand(False)
toolbar.insert(t_item, -1)
toolbar.insert(Gtk.SeparatorToolItem(), -1)
# build the y scale adjustment slider
t_item = Gtk.ToolItem()
t_item.add(Gtk.Label(label='Y:'))
toolbar.insert(t_item, -1)
self.vscale_adj = Gtk.Adjustment(0, 0, 0)
hslider = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL,
adjustment=self.vscale_adj)
hslider.set_draw_value(False)
self.initYScaleSlider(self.selected_seqtv)
sizereq = hslider.get_size_request()
hslider.set_size_request(60, sizereq.height)
self.y_slider = Gtk.ToolItem()
self.y_slider.add(hslider)
self.y_slider.set_tooltip_text('Adjust the Y scale of the trace view')
toolbar.insert(self.y_slider, -1)
self.vscale_adj.connect('value_changed', self.yScaleChanged)
toolbar.insert(Gtk.SeparatorToolItem(), -1)
# build the toggle button for phred scores
toggle = Gtk.CheckButton()
toggle.set_label('conf. scores')
toggle.set_active(True)
toggle.connect('toggled', self.showConfToggled)
# Place the toggle button in a VButtonBox to prevent it from expanding
# vertically.
vbox = Gtk.VButtonBox()
vbox.pack_start(toggle, False, True, 0)
t_item = Gtk.ToolItem()
t_item.add(vbox)
t_item.set_tooltip_text('Turn the display of phred scores on or off')
t_item.set_expand(False)
toolbar.insert(t_item, -1)
# if we got two sequences, build a combo box to choose between them
if len(self.seqt_viewers) == 2:
trace_combo = Gtk.ComboBoxText()
# see if the forward trace is first or second
if self.seqt_viewers[0].getSequenceTrace().isReverseComplemented():
trace_combo.append_text('Reverse:')
trace_combo.append_text('Forward:')
else:
trace_combo.append_text('Forward:')
trace_combo.append_text('Reverse:')
trace_combo.append_text('Both:')
trace_combo.set_active(0)
trace_combo.connect('changed', self.traceComboBox)
# Place the combo box in a VButtonBox to prevent it from expanding
# vertically.
vbox = Gtk.VButtonBox()
vbox.pack_start(trace_combo, False, True, 0)
t_item = Gtk.ToolItem()
t_item.add(vbox)
#t_item.set_tooltip_text('Adjust the zoom level')
toolbar.insert(t_item, 0)
trace_combo.set_active(2)
return toolbar
def __init__(self, abiword_canvas):
Gtk.Toolbar.__init__(self)
self._abiword_canvas = abiword_canvas
self._zoom_percentage = 0
self._zoom_out = ToolButton('zoom-out')
self._zoom_out.set_tooltip(_('Zoom Out'))
self._zoom_out_id = self._zoom_out.connect(
'clicked', self._zoom_out_cb)
self.insert(self._zoom_out, -1)
self._zoom_out.show()
self._zoom_in = ToolButton('zoom-in')
self._zoom_in.set_tooltip(_('Zoom In'))
self._zoom_in_id = self._zoom_in.connect('clicked', self._zoom_in_cb)
self.insert(self._zoom_in, -1)
self._zoom_in.show()
# TODO: fix the initial value
self._zoom_spin_adj = Gtk.Adjustment(0, 25, 400, 25, 50, 0)
self._zoom_spin = Gtk.SpinButton.new(self._zoom_spin_adj, 0, 0)
self._zoom_spin_id = self._zoom_spin.connect('value-changed',
self._zoom_spin_cb)
self._zoom_spin.set_numeric(True)
self._zoom_spin.show()
tool_item_zoom = Gtk.ToolItem()
tool_item_zoom.add(self._zoom_spin)
self.insert(tool_item_zoom, -1)
tool_item_zoom.show()
zoom_perc_label = Gtk.Label(_("%"))
zoom_perc_label.show()
tool_item_zoom_perc_label = Gtk.ToolItem()
tool_item_zoom_perc_label.add(zoom_perc_label)
self.insert(tool_item_zoom_perc_label, -1)
tool_item_zoom_perc_label.show()
separator = Gtk.SeparatorToolItem()
separator.set_draw(True)
separator.show()
self.insert(separator, -1)
page_label = Gtk.Label(_("Page: "))
page_label.show()
tool_item_page_label = Gtk.ToolItem()
tool_item_page_label.add(page_label)
self.insert(tool_item_page_label, -1)
tool_item_page_label.show()
self._page_spin_adj = Gtk.Adjustment(0, 1, 0, -1, -1, 0)
self._page_spin = Gtk.SpinButton.new(self._page_spin_adj, 0, 0)
self._page_spin_id = self._page_spin.connect('value-changed',
self._page_spin_cb)
self._page_spin.set_numeric(True)
self._page_spin.show()
tool_item_page = Gtk.ToolItem()
tool_item_page.add(self._page_spin)
self.insert(tool_item_page, -1)
tool_item_page.show()
self._total_page_label = Gtk.Label(" / 0")
self._total_page_label.show()
tool_item = Gtk.ToolItem()
tool_item.add(self._total_page_label)
self.insert(tool_item, -1)
tool_item.show()
self._abiword_canvas.connect("page-count", self._page_count_cb)
self._abiword_canvas.connect("current-page", self._current_page_cb)
self._abiword_canvas.connect("zoom", self._zoom_cb)
def __init__(self, songs):
super().__init__()
self.image_cache = []
self.image_cache_size = 10
self.search_lock = False
self.set_title(_('Album Art Downloader'))
self.set_icon_name(Icons.EDIT_FIND)
self.set_default_size(800, 550)
image = CoverArea(self, songs[0])
self.liststore = Gtk.ListStore(object, object)
self.treeview = treeview = AllTreeView(model=self.liststore)
self.treeview.set_headers_visible(False)
self.treeview.set_rules_hint(True)
targets = [("text/uri-list", 0, 0)]
targets = [Gtk.TargetEntry.new(*t) for t in targets]
treeview.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, targets,
Gdk.DragAction.COPY)
treeselection = self.treeview.get_selection()
treeselection.set_mode(Gtk.SelectionMode.SINGLE)
treeselection.connect('changed', self.__select_callback, image)
self.treeview.connect("drag-data-get", self.__drag_data_get,
treeselection)
rend_pix = Gtk.CellRendererPixbuf()
img_col = Gtk.TreeViewColumn('Thumb')
img_col.pack_start(rend_pix, False)
def cell_data_pb(column, cell, model, iter_, *args):
surface = model[iter_][0]
cell.set_property("surface", surface)
img_col.set_cell_data_func(rend_pix, cell_data_pb, None)
treeview.append_column(img_col)
rend_pix.set_property('xpad', 2)
rend_pix.set_property('ypad', 2)
border_width = self.get_scale_factor() * 2
rend_pix.set_property('width', self.THUMB_SIZE + 4 + border_width)
rend_pix.set_property('height', self.THUMB_SIZE + 4 + border_width)
def escape_data(data):
for rep in ('\n', '\t', '\r', '\v'):
data = data.replace(rep, ' ')
return util.escape(' '.join(data.split()))
def cell_data(column, cell, model, iter, data):
cover = model[iter][1]
esc = escape_data
txt = '<b><i>%s</i></b>' % esc(cover['name'])
txt += "\n<small>%s</small>" % (
_('from %(source)s') % {
"source": util.italic(esc(cover['source']))
})
if 'resolution' in cover:
txt += "\n" + _('Resolution: %s') % util.italic(
esc(cover['resolution']))
if 'size' in cover:
txt += "\n" + _('Size: %s') % util.italic(esc(cover['size']))
cell.markup = txt
cell.set_property('markup', cell.markup)
rend = Gtk.CellRendererText()
rend.set_property('ellipsize', Pango.EllipsizeMode.END)
info_col = Gtk.TreeViewColumn('Info', rend)
info_col.set_cell_data_func(rend, cell_data)
treeview.append_column(info_col)
sw_list = Gtk.ScrolledWindow()
sw_list.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sw_list.set_shadow_type(Gtk.ShadowType.IN)
sw_list.add(treeview)
search_labelraw = Gtk.Label('raw')
search_labelraw.set_alignment(xalign=1.0, yalign=0.5)
self.search_fieldraw = Gtk.Entry()
self.search_fieldraw.connect('activate', self.start_search)
self.search_fieldraw.connect('changed', self.__searchfieldchanged)
search_labelclean = Gtk.Label('clean')
search_labelclean.set_alignment(xalign=1.0, yalign=0.5)
self.search_fieldclean = Gtk.Label()
self.search_fieldclean.set_can_focus(False)
self.search_fieldclean.set_alignment(xalign=0.0, yalign=0.5)
self.search_radioraw = Gtk.RadioButton(group=None, label=None)
self.search_radioraw.connect("toggled", self.__searchtypetoggled,
"raw")
self.search_radioclean = Gtk.RadioButton(group=self.search_radioraw,
label=None)
self.search_radioclean.connect("toggled", self.__searchtypetoggled,
"clean")
#note: set_active(False) appears to have no effect
#self.search_radioraw.set_active(
# self.config_get_bool('searchraw', False))
if self.config_get_bool('searchraw', False):
self.search_radioraw.set_active(True)
else:
self.search_radioclean.set_active(True)
search_labelresultsmax = Gtk.Label('limit')
search_labelresultsmax.set_alignment(xalign=1.0, yalign=0.5)
search_labelresultsmax.set_tooltip_text(
_("Per engine 'at best' results limit"))
search_adjresultsmax = Gtk.Adjustment(value=int(
self.config_get("resultsmax", 3)),
lower=1,
upper=REQUEST_LIMIT_MAX,
step_incr=1,
page_incr=0,
page_size=0)
self.search_spinresultsmax = Gtk.SpinButton(
adjustment=search_adjresultsmax, climb_rate=0.2, digits=0)
self.search_spinresultsmax.set_alignment(xalign=0.5)
self.search_spinresultsmax.set_can_focus(False)
self.search_button = Button(_("_Search"), Icons.EDIT_FIND)
self.search_button.connect('clicked', self.start_search)
search_button_box = Gtk.Alignment()
search_button_box.set(1, 0, 0, 0)
search_button_box.add(self.search_button)
search_table = Gtk.Table(rows=3, columns=4, homogeneous=False)
search_table.attach(search_labelraw,
0,
1,
0,
1,
xoptions=Gtk.AttachOptions.FILL,
xpadding=6)
search_table.attach(self.search_radioraw,
1,
2,
0,
1,
xoptions=0,
xpadding=0)
search_table.attach(self.search_fieldraw, 2, 4, 0, 1)
search_table.attach(search_labelclean,
0,
1,
1,
2,
xoptions=Gtk.AttachOptions.FILL,
xpadding=6)
search_table.attach(self.search_radioclean,
1,
2,
1,
2,
xoptions=0,
xpadding=0)
search_table.attach(self.search_fieldclean, 2, 4, 1, 2, xpadding=4)
search_table.attach(search_labelresultsmax,
0,
2,
2,
3,
xoptions=Gtk.AttachOptions.FILL,
xpadding=6)
search_table.attach(self.search_spinresultsmax,
2,
3,
2,
3,
xoptions=Gtk.AttachOptions.FILL,
xpadding=0)
search_table.attach(search_button_box, 3, 4, 2, 3)
widget_space = 5
self.progress = Gtk.ProgressBar()
left_vbox = Gtk.VBox(spacing=widget_space)
left_vbox.pack_start(search_table, False, True, 0)
left_vbox.pack_start(sw_list, True, True, 0)
hpaned = Paned()
hpaned.set_border_width(widget_space)
hpaned.pack1(left_vbox, shrink=False)
hpaned.pack2(image, shrink=False)
hpaned.set_position(275)
self.add(hpaned)
self.show_all()
left_vbox.pack_start(self.progress, False, True, 0)
self.connect('destroy', self.__save_config)
song = songs[0]
text = SEARCH_PATTERN.format(song)
self.set_text(text)
self.start_search()
def UCI_options(self):
self.check_running()
options = self.get_options()
# option
# [name, otype, default, minimum, maximum, uvars, userval]
wdgts = []
opt_i = -1
for option in options:
opt_i += 1
name = option[0]
otype = option[1]
default = option[2]
minimum = option[3]
maximum = option[4]
uvars = option[5]
userval = option[6]
# if in common engine settings then skip
if name in ("Hash", "Ponder"):
continue
wdgts.append((
opt_i, name, otype, default, minimum, maximum, uvars, userval))
diagtitle = self.get_engine()
dialog = Gtk.Dialog(
diagtitle, gv.gui.get_window(), 0,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
sw = Gtk.ScrolledWindow.new(None, None)
dialog.vbox.pack_start(sw, True, True, 0)
vb=Gtk.Box.new(Gtk.Orientation.VERTICAL, 0)
sw.add(vb)
sw.show()
vb.show()
wlist = []
for w in wdgts:
opt_i, name, otype, default, minimum, maximum, uvars, userval = w
#print(name)
if otype == "spin":
if minimum == "":
minimum = 0
if maximum == "":
maximum = 10
if default == "":
default = minimum
if userval != "":
default = userval
adj = Gtk.Adjustment(
value=float(default), lower=float(minimum), upper=float(maximum),
step_increment=1, page_increment=5, page_size=0)
spinner = Gtk.SpinButton.new(adj, 1.0, 0)
# spinner.set_width_chars(14)
al = Gtk.Alignment.new(
xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
lbl = Gtk.Label(label=name + ":")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
v = (opt_i, adj, name, otype)
wlist.append(v)
lbl.show()
spinner.show()
al.show()
hb.show()
elif otype == "string":
ent = Gtk.Entry()
if userval != "":
default = userval
ent.set_text(default)
al = Gtk.Alignment.new(
xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(ent)
lbl = Gtk.Label(label=name + ":")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
v = (opt_i, ent, name, otype)
wlist.append(v)
lbl.show()
ent.show()
al.show()
hb.show()
elif otype == "check":
cb = Gtk.CheckButton(label=None)
if userval != "":
default = userval
if default == "true":
cb.set_active(True)
else:
cb.set_active(False)
al = Gtk.Alignment.new(
xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(cb)
lbl = Gtk.Label(label=name + ":")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
v = (opt_i, cb, name, otype)
wlist.append(v)
lbl.show()
cb.show()
al.show()
hb.show()
elif otype == "combo":
if userval != "":
default = userval
combobox = Gtk.ComboBoxText()
i = 0
for v in uvars:
combobox.append_text(v)
if v == default:
combobox.set_active(i)
i += 1
al = Gtk.Alignment.new(
xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(combobox)
al.show()
combobox.show()
lbl = Gtk.Label(label=name + ":")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
v = (opt_i, combobox, name, otype)
wlist.append(v)
lbl.show()
hb.show()
elif otype == "button":
b = Gtk.Button(label=name)
al = Gtk.Alignment.new(
xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(b)
b.connect(
"clicked",
lambda widget: self.command(
"setoption name " +
widget.get_label() + "\n"))
lbl = Gtk.Label(label=name + ":")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
lbl.show()
b.show()
al.show()
hb.show()
else:
if gv.verbose:
print("type ignored - ", otype)
# set size of scrollwindow to size of child
minsize, naturalsize = vb.get_preferred_size()
sw.set_size_request(minsize.width+20, min(minsize.height, 500))
dialog.set_default_response(Gtk.ResponseType.OK)
response = dialog.run()
if response == Gtk.ResponseType.OK:
for w in wlist:
opt_i, widge, name, otype = w
if otype == "spin":
av = int(widge.get_value())
elif otype == "string":
av = widge.get_text()
elif otype == "check":
if widge.get_active():
av = "true"
else:
av = "false"
elif otype == "combo":
av = widge.get_active_text()
else:
if gv.verbose:
print("unknown type", otype)
# setoption name <id> [value <x>]
# uci.set_option(
# "option name LimitDepth type spin default 10 min 4 max 10")
a = "setoption name " + name + " value " + str(av)
self.set_option(a)
# update user value
options[opt_i][6] = str(av)
self.set_options(options)
gv.engine_manager.set_uservalues(self.engine, options)
dialog.destroy()
self.stop_engine()
def set_widget_formats(self):
for widget in (self.cost, self.price):
widget.set_adjustment(
Gtk.Adjustment(lower=0, upper=MAX_INT, step_incr=1))
self.requires_weighing_label.set_size("small")
self.requires_weighing_label.set_text("")
def __init__(self):
Gtk.Settings.get_default().set_long_property('gtk-tooltip-timeout', 0,
'')
##################################
# init GUI
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(WORK_DIR, 'GameConqueror.xml'))
self.main_window = self.builder.get_object('MainWindow')
self.main_window.set_title('GameConqueror %s' % (VERSION, ))
self.about_dialog = self.builder.get_object('AboutDialog')
# set version
self.about_dialog.set_version(VERSION)
self.process_list_dialog = self.builder.get_object('ProcessListDialog')
self.addcheat_dialog = self.builder.get_object('AddCheatDialog')
# init memory editor
self.memoryeditor_window = self.builder.get_object(
'MemoryEditor_Window')
self.memoryeditor_hexview = HexView()
self.memoryeditor_window.get_child().pack_start(
self.memoryeditor_hexview, True, True, 0)
self.memoryeditor_hexview.show_all()
self.memoryeditor_address_entry = self.builder.get_object(
'MemoryEditor_Address_Entry')
self.memoryeditor_hexview.connect(
'char-changed', self.memoryeditor_hexview_char_changed_cb)
self.found_count_label = self.builder.get_object('FoundCount_Label')
self.process_label = self.builder.get_object('Process_Label')
self.value_input = self.builder.get_object('Value_Input')
self.scanoption_frame = self.builder.get_object('ScanOption_Frame')
self.scanprogress_progressbar = self.builder.get_object(
'ScanProgress_ProgressBar')
self.scan_button = self.builder.get_object('Scan_Button')
self.reset_button = self.builder.get_object('Reset_Button')
self.is_first_scan = True
###
# Set scan data type
self.scan_data_type_combobox = self.builder.get_object(
'ScanDataType_ComboBox')
misc.build_combobox(self.scan_data_type_combobox, SCAN_VALUE_TYPES)
# apply setting
misc.combobox_set_active_item(self.scan_data_type_combobox,
SETTINGS['scan_data_type'])
###
# set search scope
self.search_scope_scale = self.builder.get_object('SearchScope_Scale')
self.search_scope_scale_adjustment = Gtk.Adjustment(lower=0,
upper=2,
step_incr=1,
page_incr=1,
page_size=0)
self.search_scope_scale.set_adjustment(
self.search_scope_scale_adjustment)
# apply setting
self.search_scope_scale.set_value(SETTINGS['search_scope'])
# init scanresult treeview
# we may need a cell data func here
# create model
self.scanresult_tv = self.builder.get_object('ScanResult_TreeView')
self.scanresult_liststore = Gtk.ListStore(
str, str, str, bool) #addr, value, type, valid
self.scanresult_tv.set_model(self.scanresult_liststore)
# init columns
misc.treeview_append_column(self.scanresult_tv,
'Address',
attributes=(('text', 0), ),
properties=(('family', 'monospace'), ))
misc.treeview_append_column(self.scanresult_tv,
'Value',
attributes=(('text', 1), ),
properties=(('family', 'monospace'), ))
# init CheatList TreeView
self.cheatlist_tv = self.builder.get_object('CheatList_TreeView')
self.cheatlist_liststore = Gtk.ListStore(
str, bool, str, str, str, str,
bool) #lockflag, locked, description, addr, type, value, valid
self.cheatlist_tv.set_model(self.cheatlist_liststore)
self.cheatlist_tv.set_reorderable(True)
self.cheatlist_updates = []
self.cheatlist_editing = False
self.cheatlist_tv.connect('key-press-event', self.cheatlist_keypressed)
# Lock Flag
misc.treeview_append_column(
self.cheatlist_tv,
'',
renderer_class=Gtk.CellRendererCombo,
attributes=(('text', 0), ),
properties=(('editable', True), ('has-entry', False),
('model', LOCK_FLAG_TYPES), ('text-column', 0)),
signals=(
('edited', self.cheatlist_toggle_lock_flag_cb),
('editing-started', self.cheatlist_edit_start),
('editing-canceled', self.cheatlist_edit_cancel),
))
# Lock
misc.treeview_append_column(
self.cheatlist_tv,
'Lock',
renderer_class=Gtk.CellRendererToggle,
attributes=(('active', 1), ),
properties=(('activatable', True), ('radio', False),
('inconsistent', False)),
signals=(('toggled', self.cheatlist_toggle_lock_cb), ))
# Description
misc.treeview_append_column(
self.cheatlist_tv,
'Description',
attributes=(('text', 2), ),
properties=(('editable', True), ),
signals=(
('edited', self.cheatlist_edit_description_cb),
('editing-started', self.cheatlist_edit_start),
('editing-canceled', self.cheatlist_edit_cancel),
))
# Address
misc.treeview_append_column(self.cheatlist_tv,
'Address',
attributes=(('text', 3), ),
properties=(('family', 'monospace'), ))
# Type
misc.treeview_append_column(
self.cheatlist_tv,
'Type',
renderer_class=Gtk.CellRendererCombo,
attributes=(('text', 4), ),
properties=(('editable', True), ('has-entry', False),
('model', LOCK_VALUE_TYPES), ('text-column', 0)),
signals=(
('edited', self.cheatlist_edit_type_cb),
('editing-started', self.cheatlist_edit_start),
('editing-canceled', self.cheatlist_edit_cancel),
))
# Value
misc.treeview_append_column(
self.cheatlist_tv,
'Value',
attributes=(('text', 5), ),
properties=(('editable', True), ('family', 'monospace')),
signals=(
('edited', self.cheatlist_edit_value_cb),
('editing-started', self.cheatlist_edit_start),
('editing-canceled', self.cheatlist_edit_cancel),
))
# init ProcessList
self.processfilter_input = self.builder.get_object(
'ProcessFilter_Input')
self.userfilter_input = self.builder.get_object('UserFilter_Input')
# init ProcessList_TreeView
self.processlist_tv = self.builder.get_object('ProcessList_TreeView')
self.processlist_tv.get_selection().set_mode(Gtk.SelectionMode.SINGLE)
self.processlist_liststore = Gtk.ListStore(str, str, str)
self.processlist_filter = self.processlist_liststore.filter_new(
root=None)
self.processlist_filter.set_visible_func(self.processlist_filter_func,
data=None)
self.processlist_tv.set_model(self.processlist_filter)
self.processlist_tv.set_enable_search(True)
self.processlist_tv.set_search_column(1)
# first col
misc.treeview_append_column(self.processlist_tv,
'PID',
attributes=(('text', 0), ))
# second col
misc.treeview_append_column(self.processlist_tv,
'User',
attributes=(('text', 1), ))
# third col
misc.treeview_append_column(self.processlist_tv,
'Process',
attributes=(('text', 2), ))
# init AddCheatDialog
self.addcheat_address_input = self.builder.get_object('Address_Input')
self.addcheat_description_input = self.builder.get_object(
'Description_Input')
self.addcheat_type_combobox = self.builder.get_object('Type_ComboBox')
misc.build_combobox(self.addcheat_type_combobox, LOCK_VALUE_TYPES)
misc.combobox_set_active_item(self.addcheat_type_combobox,
SETTINGS['lock_data_type'])
# init popup menu for scanresult
self.scanresult_popup = Gtk.Menu()
misc.menu_append_item(self.scanresult_popup, 'Add to cheat list',
self.scanresult_popup_cb, 'add_to_cheat_list')
misc.menu_append_item(self.scanresult_popup, 'Browse this address',
self.scanresult_popup_cb, 'browse_this_address')
misc.menu_append_item(self.scanresult_popup, 'Scan for this address',
self.scanresult_popup_cb,
'scan_for_this_address')
self.scanresult_popup.show_all()
# init popup menu for cheatlist
self.cheatlist_popup = Gtk.Menu()
misc.menu_append_item(self.cheatlist_popup, 'Browse this address',
self.cheatlist_popup_cb, 'browse_this_address')
misc.menu_append_item(self.cheatlist_popup, 'Copy address',
self.cheatlist_popup_cb, 'copy_address')
misc.menu_append_item(self.cheatlist_popup, 'Remove this entry',
self.cheatlist_popup_cb, 'remove_entry')
self.cheatlist_popup.show_all()
self.builder.connect_signals(self)
self.main_window.connect('destroy', self.exit)
###########################
# init others (backend, flag...)
self.pid = 0 # target pid
self.maps = []
self.last_hexedit_address = (0, 0) # used for hexview
self.is_scanning = False
self.exit_flag = False # currently for data_worker only, other 'threads' may also use this flag
self.is_data_worker_working = False
self.backend = GameConquerorBackend()
self.check_backend_version()
self.search_count = 0
GObject.timeout_add(DATA_WORKER_INTERVAL, self.data_worker)
self.command_lock = threading.RLock()
def build_gui(self):
self.win = win = Gtk.Window(title='GnomeCast')
win.set_border_width(0)
win.set_icon(self.get_logo_pixbuf(color='#000000'))
self.cast_store = cast_store = Gtk.ListStore(object, str)
cast_store.append([None, "Searching local network - please wait..."])
vbox_outer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=16)
self.thumbnail_image = Gtk.Image()
self.thumbnail_image.set_from_pixbuf(self.get_logo_pixbuf())
vbox_outer.pack_start(self.thumbnail_image, True, False, 0)
alignment = Gtk.Alignment(xscale=1, yscale=1)
alignment.add(vbox)
alignment.set_padding(16, 20, 16, 16)
vbox_outer.pack_start(alignment, False, False, 0)
self.cast_combo = cast_combo = Gtk.ComboBox.new_with_model(cast_store)
cast_combo.set_entry_text_column(1)
renderer_text = Gtk.CellRendererText()
cast_combo.pack_start(renderer_text, True)
cast_combo.add_attribute(renderer_text, "text", 1)
cast_combo.set_active(0)
vbox.pack_start(cast_combo, False, False, 0)
win.add(vbox_outer)
self.file_button = button1 = Gtk.Button(
"Choose an audio or video file...")
button1.connect("clicked", self.on_file_clicked)
vbox.pack_start(button1, False, False, 0)
self.subtitle_store = subtitle_store = Gtk.ListStore(str, int, str)
subtitle_store.append(["No subtitles.", -1, None])
subtitle_store.append(["Add subtitle file...", -2, None])
self.subtitle_combo = Gtk.ComboBox.new_with_model(subtitle_store)
self.subtitle_combo.connect("changed", self.on_subtitle_combo_changed)
self.subtitle_combo.set_entry_text_column(0)
renderer_text = Gtk.CellRendererText()
self.subtitle_combo.pack_start(renderer_text, True)
self.subtitle_combo.add_attribute(renderer_text, "text", 0)
self.subtitle_combo.set_active(0)
vbox.pack_start(self.subtitle_combo, False, False, 0)
self.scrubber_adj = Gtk.Adjustment(0, 0, 100, 15, 60, 0)
self.scrubber = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL,
adjustment=self.scrubber_adj)
self.scrubber.set_digits(0)
def f(scale, s):
notes = [self.humanize_seconds(s)]
if self.cast and self.cast.media_controller.status.player_state == 'BUFFERING':
notes.append('...')
return ''.join(notes)
self.scrubber.connect("format-value", f)
self.scrubber.connect("change-value", self.scrubber_move_started)
self.scrubber.connect("change-value", self.scrubber_moved)
self.scrubber.set_sensitive(False)
vbox.pack_start(self.scrubber, False, False, 0)
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=16)
self.rewind_button = Gtk.Button(
None, image=Gtk.Image(stock=Gtk.STOCK_MEDIA_REWIND))
self.rewind_button.connect("clicked", self.rewind_clicked)
self.rewind_button.set_sensitive(False)
hbox.pack_start(self.rewind_button, True, False, 0)
self.play_button = Gtk.Button(
None, image=Gtk.Image(stock=Gtk.STOCK_MEDIA_PLAY))
self.play_button.connect("clicked", self.play_clicked)
self.play_button.set_sensitive(False)
hbox.pack_start(self.play_button, True, False, 0)
self.forward_button = Gtk.Button(
None, image=Gtk.Image(stock=Gtk.STOCK_MEDIA_FORWARD))
self.forward_button.connect("clicked", self.forward_clicked)
self.forward_button.set_sensitive(False)
hbox.pack_start(self.forward_button, True, False, 0)
self.stop_button = Gtk.Button(
None, image=Gtk.Image(stock=Gtk.STOCK_MEDIA_STOP))
self.stop_button.connect("clicked", self.stop_clicked)
self.stop_button.set_sensitive(False)
hbox.pack_start(self.stop_button, True, False, 0)
vbox.pack_start(hbox, False, False, 0)
cast_combo.connect("changed", self.on_cast_combo_changed)
win.connect("delete-event", self.quit)
win.connect("key_press_event", self.on_key_press)
win.show_all()
GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, self.quit)
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
self.dic = {}
# Canvas
self._canvas = Gtk.VBox()
hbox = Gtk.HBox()
self._liststore = Gtk.ListStore(str)
self.combo1 = Gtk.ComboBox.new_with_model_and_entry(self._liststore)
cell = Gtk.CellRendererText()
self.combo1.pack_start(cell, True)
self.combo1.set_entry_text_column(0)
self.combo1.connect('changed', self._call)
flip_btn = Gtk.Button()
flip_btn.connect('clicked', self._flip)
flip_btn.add(Gtk.Image.new_from_file('icons/flip.svg'))
self.combo2 = Gtk.ComboBox.new_with_model_and_entry(self._liststore)
cell = Gtk.CellRendererText()
self.combo2.pack_start(cell, True)
self.combo2.set_entry_text_column(0)
self.combo2.connect('changed', self._call)
self.label_box = Gtk.HBox()
self.adjustment = Gtk.Adjustment(1.0, 0, 10.00**10.00, 1.0, 1.0, 0)
self.spin = Gtk.SpinButton()
self.spin.set_adjustment(self.adjustment)
self.spin.set_numeric(True)
self.label = Gtk.Label()
self.label._size = 12
self.label.set_selectable(True)
self.label.connect('draw', self.resize_label)
self.convert_btn = Gtk.Button(_('Convert'))
self.convert_btn.connect('clicked', self._call)
self._canvas.pack_start(hbox, False, False, 20)
hbox.pack_start(self.combo1, False, True, 20)
hbox.pack_start(flip_btn, True, False, 20)
hbox.pack_end(self.combo2, False, True, 20)
spin_box = Gtk.HBox()
convert_box = Gtk.HBox()
convert_box.pack_start(spin_box, True, False, 0)
spin_box.pack_start(self.spin, False, False, 0)
self._canvas.pack_start(convert_box, False, False, 5)
self._canvas.pack_start(self.label_box, True, False, 0)
self.label_box.add(self.label)
spin_box.pack_start(self.convert_btn, False, False, 20)
self.set_canvas(self._canvas)
# Toolbar
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbarbox.toolbar.insert(activity_button, 0)
separator = Gtk.SeparatorToolItem()
separator.set_expand(False)
separator.set_draw(True)
toolbarbox.toolbar.insert(separator, -1)
self._edit_toolbar = EditToolbar()
self._edit_toolbar.undo.props.visible = False
self._edit_toolbar.redo.props.visible = False
self._edit_toolbar.separator.props.visible = False
self._edit_toolbar.copy.set_sensitive = False
self._edit_toolbar.copy.connect('clicked', self._edit_copy_cb)
edit_toolbar_button = ToolbarButton(page=self._edit_toolbar,
icon_name='toolbar-edit')
edit_toolbar_button.props.label = _('Edit')
self._edit_toolbar.show()
edit_toolbar_button.show()
toolbarbox.toolbar.insert(edit_toolbar_button, -1)
# RadioToolButton
self._length_btn = RadioToolButton()
self._length_btn.connect('clicked',
lambda w: self._update_combo(convert.length))
# TRANS: https://en.wikipedia.org/wiki/Length
self._length_btn.set_tooltip(_('Length'))
self._length_btn.props.icon_name = 'length'
self._volume_btn = RadioToolButton()
self._volume_btn.connect('clicked',
lambda w: self._update_combo(convert.volume))
# TRANS: https://en.wikipedia.org/wiki/Volume
self._volume_btn.set_tooltip(_('Volume'))
self._volume_btn.props.icon_name = 'volume'
self._volume_btn.props.group = self._length_btn
self._area_btn = RadioToolButton()
self._area_btn.connect('clicked',
lambda w: self._update_combo(convert.area))
# TRANS: https://en.wikipedia.org/wiki/Area
self._area_btn.set_tooltip(_('Area'))
self._area_btn.props.icon_name = 'area'
self._area_btn.props.group = self._length_btn
self._weight_btn = RadioToolButton()
self._weight_btn.connect('clicked',
lambda w: self._update_combo(convert.weight))
# TRANS: https://en.wikipedia.org/wiki/Weight
self._weight_btn.set_tooltip(_('Weight'))
self._weight_btn.props.icon_name = 'weight'
self._weight_btn.props.group = self._length_btn
self._speed_btn = RadioToolButton()
self._speed_btn.connect('clicked',
lambda w: self._update_combo(convert.speed))
# TRANS: https://en.wikipedia.org/wiki/Speed
self._speed_btn.set_tooltip(_('Speed'))
self._speed_btn.props.icon_name = 'speed'
self._speed_btn.props.group = self._length_btn
self._time_btn = RadioToolButton()
self._time_btn.connect('clicked',
lambda w: self._update_combo(convert.time))
# TRANS: https://en.wikipedia.org/wiki/Time
self._time_btn.set_tooltip(_('Time'))
self._time_btn.props.icon_name = 'time'
self._time_btn.props.group = self._length_btn
self._temp_btn = RadioToolButton()
self._temp_btn.connect('clicked',
lambda w: self._update_combo(convert.temp))
# TRANS: https://en.wikipedia.org/wiki/Temperature
self._temp_btn.set_tooltip(_('Temperature'))
self._temp_btn.props.icon_name = 'temp'
self._temp_btn.props.group = self._length_btn
toolbarbox.toolbar.insert(self._length_btn, -1)
toolbarbox.toolbar.insert(self._volume_btn, -1)
toolbarbox.toolbar.insert(self._area_btn, -1)
toolbarbox.toolbar.insert(self._weight_btn, -1)
toolbarbox.toolbar.insert(self._speed_btn, -1)
toolbarbox.toolbar.insert(self._time_btn, -1)
toolbarbox.toolbar.insert(self._temp_btn, -1)
separator = Gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
self._update_combo(convert.length)
self.show_all()
col = Gtk.ColorSelection(has_palette=True) #Color Pallete
button1 = Gtk.Button(label="Width++") #Width of brush
button2= Gtk.Button(label="Width--")
button3=Gtk.ComboBoxText()
button3.append("1","Rectangle")
button3.append("2","Ellipse")
button3.append("3","Circle")
button4=Gtk.Button(label="Ok")
button5=Gtk.Entry()
button6=Gtk.Button(label="Save")
button5.set_text("Enter file name with extn")
range=Gtk.Adjustment(lower=1,upper=1000,step_increment=1)
range2=Gtk.Adjustment(lower=1,upper=1000,step_increment=1)
range3=Gtk.Adjustment(lower=1,upper=750,step_increment=1)
shape_length=Gtk.SpinButton(adjustment=range)
shape_width=Gtk.SpinButton(adjustment=range2)
shape_radius=Gtk.SpinButton(adjustment=range3)
listb=Gtk.ListBox()
listb.set_selection_mode(Gtk.SelectionMode.NONE)
row = Gtk.ListBoxRow()
row2= Gtk.ListBoxRow()
row3= Gtk.ListBoxRow()
label1 = Gtk.Label(label="Length ")
def __init__(self, keys=None):
"""Initialize and display a keyboard
keys is an optional array of frequency indexes
"""
# I18n
######
# Using local path
local_path = os.path.abspath(os.path.dirname(sys.argv[0])) + "/locale"
gettext.install("tuner", local_path)
# Create empty if no key specified
self._default_keys = keys or []
# Variables
###########
# Buttons and handlers
self._buttons = []
# Beep process
self._beep_process = 0
# Beep queue
self._beep_queue = deque([])
# Note playing token
self._note_playing = False
# Keys modified flag
self._keys_modified_flag = False
# Settings
self._beep_length = 1
self._notestyle = _Note.INDEX_FR_NAME
self._backend = self._SOX_PLUCK
# Create window
###############
self._dialog = Gtk.Dialog()
self._dialog.connect("destroy", self._close_request)
self._dialog.set_title(_("Tuner"))
self._dialog.set_border_width(10)
# Create vertical box and horizontal sub-boxes
vbox = Gtk.Box(homogeneous=False, spacing=10,
orientation=Gtk.Orientation.VERTICAL)
hbox_controls = Gtk.ButtonBox()
self._hbox_keys = Gtk.Box(homogeneous=True)
hbox_settings = Gtk.Box(homogeneous=False, spacing=10)
# Control horizontal box
########################
hbox_controls.set_layout(Gtk.ButtonBoxStyle.START)
# Reset keys modifications
self._reset_button = Gtk.Button(stock=Gtk.STOCK_CANCEL)
self._reset_button.set_sensitive(False)
hbox_controls.add(self._reset_button)
self._reset_button.connect("clicked", self._reset_keys)
self._reset_button.show()
# Remove key
self._button_rem = Gtk.Button(stock=Gtk.STOCK_REMOVE)
hbox_controls.add(self._button_rem)
self._button_rem.connect("clicked", self._rem_key)
self._button_rem.show()
# Add key
self._button_add = Gtk.Button(stock=Gtk.STOCK_ADD)
hbox_controls.add(self._button_add)
self._button_add.connect("clicked", self._add_key)
self._button_add.show()
# Stop playback
self._stop_playback_button = Gtk.Button(stock=Gtk.STOCK_MEDIA_STOP)
self._stop_playback_button.set_sensitive(False)
hbox_controls.add(self._stop_playback_button)
hbox_controls.set_child_secondary(self._stop_playback_button, True)
self._stop_playback_button.connect("clicked",
self._stop_playback_request)
self._stop_playback_button.show()
# Play all keys
self._play_all_button = Gtk.Button(stock=Gtk.STOCK_MEDIA_PLAY)
hbox_controls.add(self._play_all_button)
hbox_controls.set_child_secondary(self._play_all_button, True)
self._play_all_button.connect("clicked", self._play_all)
self._play_all_button.show()
# Keys horizontal box
#####################
# Add global incrementor / decrementor buttons
vbox_inc_dec = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5)
# Octave decrement
hbox_arrow = Gtk.Box()
arrow = Gtk.Arrow(arrow_type=Gtk.ArrowType.DOWN,
shadow_type=Gtk.ShadowType.OUT)
hbox_arrow.pack_start(arrow, True, True, 0)
arrow.show()
label = Gtk.Label(label="8")
hbox_arrow.pack_start(label, True, True, 0)
label.show()
self._button_oct_down = Gtk.Button()
self._button_oct_down.add(hbox_arrow)
vbox_inc_dec.pack_end(self._button_oct_down, False, True, 0)
hbox_arrow.show()
self._button_oct_down.show()
# Semitone decrement
hbox_arrow = Gtk.Box()
arrow = Gtk.Arrow(arrow_type=Gtk.ArrowType.DOWN,
shadow_type=Gtk.ShadowType.OUT)
hbox_arrow.pack_start(arrow, True, True, 0)
arrow.show()
label = Gtk.Label(label=u"\u266D")
hbox_arrow.pack_start(label, True, True, 0)
label.show()
self._button_down = Gtk.Button()
self._button_down.add(hbox_arrow)
vbox_inc_dec.pack_end(self._button_down, False, True, 0)
hbox_arrow.show()
self._button_down.show()
# Semitone increment
hbox_arrow = Gtk.Box()
arrow = Gtk.Arrow(arrow_type=Gtk.ArrowType.UP,
shadow_type=Gtk.ShadowType.OUT)
hbox_arrow.pack_start(arrow, True, True, 0)
arrow.show()
label = Gtk.Label(label=u"\u266F")
hbox_arrow.pack_start(label, True, True, 0)
label.show()
self._button_up = Gtk.Button()
self._button_up.add(hbox_arrow)
vbox_inc_dec.pack_end(self._button_up, False, True, 0)
hbox_arrow.show()
self._button_up.show()
# Octave increment
hbox_arrow = Gtk.Box()
arrow = Gtk.Arrow(arrow_type=Gtk.ArrowType.UP,
shadow_type=Gtk.ShadowType.OUT)
hbox_arrow.pack_start(arrow, True, True, 0)
arrow.show()
label = Gtk.Label(label="8")
hbox_arrow.pack_start(label, True, True, 0)
label.show()
self._button_oct_up = Gtk.Button()
self._button_oct_up.add(hbox_arrow)
vbox_inc_dec.pack_end(self._button_oct_up, False, True, 0)
hbox_arrow.show()
self._button_oct_up.show()
vbox_inc_dec.show()
self._hbox_keys.pack_start(vbox_inc_dec, True, True, 0)
self._button_up.connect("clicked", self._adjust_freq, 1)
self._button_down.connect("clicked", self._adjust_freq, -1)
self._button_oct_up.connect("clicked", self._adjust_freq, 12)
self._button_oct_down.connect("clicked", self._adjust_freq, -12)
# Set default keys
self._reset_keys()
# Settings horizontal box
#########################
# Note style selector
vbox_notestyle = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
label = Gtk.Label(label=_("Notestyle"))
label.set_alignment(0, 1)
vbox_notestyle.pack_start(label, False, True, 0)
label.show()
button = Gtk.RadioButton.new_with_label_from_widget(None, _("French"))
button.connect("clicked", self._set_notestyle, _Note.INDEX_FR_NAME)
vbox_notestyle.pack_start(button, False, True, 0)
button.show()
button = Gtk.RadioButton.new_with_label_from_widget(button, _("English"))
button.connect("clicked", self._set_notestyle, _Note.INDEX_EN_NAME)
button.emit('clicked')
vbox_notestyle.pack_start(button, False, True, 0)
button.show()
hbox_settings.pack_start(vbox_notestyle, False, True, 0)
vbox_notestyle.show()
# Separator
separator = Gtk.VSeparator()
hbox_settings.pack_start(separator, False, True, 0)
separator.show()
# Beep length
vbox_beep_length = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
label = Gtk.Label(label=_("Length (s)"))
label.set_alignment(0, 1)
vbox_beep_length.pack_start(label, False, True, 0)
label.show()
beep_length_adj = Gtk.Adjustment(value=self._beep_length, \
lower=1, \
upper=10, \
step_increment=1, \
page_increment=1, \
page_size=0)
beep_length_spin = Gtk.SpinButton(adjustment=beep_length_adj,
climb_rate=0,
digits=1)
beep_length_adj.connect("value_changed",
self._set_beep_length,
beep_length_spin)
vbox_beep_length.pack_start(beep_length_spin, False, True, 0)
beep_length_spin.show()
hbox_settings.pack_start(vbox_beep_length, False, True, 0)
vbox_beep_length.show()
# Separator
separator = Gtk.VSeparator()
hbox_settings.pack_start(separator, False, True, 0)
separator.show()
# Backend selector
vbox_backend = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
label = Gtk.Label(label=_("Output"))
label.set_alignment(0, 1)
vbox_backend.pack_start(label, False, True, 0)
label.show()
button = Gtk.RadioButton.new_with_label_from_widget(None,
"Sox (pluck)")
button.connect("clicked", self._set_backend, self._SOX_PLUCK)
vbox_backend.pack_start(button, False, True, 0)
button.show()
button = Gtk.RadioButton.new_with_label_from_widget(button,
"Sox (sine)")
button.connect("clicked", self._set_backend, self._SOX_SINE)
vbox_backend.pack_start(button, False, True, 0)
button.show()
button = Gtk.RadioButton.new_with_label_from_widget(button,
"Beep")
button.connect("clicked", self._set_backend, self._BEEP)
vbox_backend.pack_start(button, False, True, 0)
button.show()
hbox_settings.pack_start(vbox_backend, False, True, 0)
vbox_backend.show()
# Show everything
#################
vbox.pack_start(hbox_controls, True, True, 0)
vbox.pack_start(self._hbox_keys, True, True, 0)
vbox.pack_start(hbox_settings, True, True, 0)
hbox_controls.show()
self._hbox_keys.show()
hbox_settings.show()
vbox.show()
self._dialog.vbox.add(vbox)
self._dialog.show()
# Poll note queue
GObject.idle_add(self._play_note_from_queue)
def PluginPreferences(self, win):
vb = Gtk.VBox(spacing=6)
if not self.player_has_eq:
l = Gtk.Label()
l.set_markup(
_('The current backend does not support equalization.'))
vb.pack_start(l, False, True, 0)
return vb
def format_hertz(band):
if band >= 1000:
return _('%.1f kHz') % (band / 1000.)
return _('%d Hz') % band
bands = [format_hertz(band) for band in app.player.eq_bands]
levels = get_config() + [0.] * len(bands)
table = Gtk.Table(rows=len(bands), columns=3)
table.set_col_spacings(6)
def set_band(adj, idx):
levels[idx] = adj.get_value()
config.set('plugins', 'equalizer_levels',
','.join(map(str, levels)))
self.apply()
adjustments = []
for i, band in enumerate(bands):
# align numbers and suffixes in separate rows for great justice
lbl = Gtk.Label(label=band.split()[0])
lbl.set_alignment(1, 0.5)
lbl.set_padding(0, 4)
table.attach(lbl, 0, 1, i, i + 1, xoptions=Gtk.AttachOptions.FILL)
lbl = Gtk.Label(label=band.split()[1])
lbl.set_alignment(1, 0.5)
table.attach(lbl, 1, 2, i, i + 1, xoptions=Gtk.AttachOptions.FILL)
adj = Gtk.Adjustment(levels[i], -24., 12., 0.1)
adj.connect('value-changed', set_band, i)
adjustments.append(adj)
hs = Gtk.HScale(adjustment=adj)
hs.set_draw_value(True)
hs.set_value_pos(Gtk.PositionType.RIGHT)
hs.connect('format-value', lambda s, v: _('%.1f dB') % v)
table.attach(hs, 2, 3, i, i + 1)
vb.pack_start(table, True, True, 0)
def clicked_cb(button):
[adj.set_value(0) for adj in adjustments]
sorted_presets = sorted(PRESETS.iteritems())
def combo_changed(combo):
# custom, skip
if not combo.get_active():
return
gain = sorted_presets[combo.get_active() - 1][1][1]
gain = interp_bands(PRESET_BANDS, app.player.eq_bands, gain)
for (g, a) in zip(gain, adjustments):
a.set_value(g)
combo = Gtk.ComboBoxText()
combo.append_text(_("Custom"))
combo.set_active(0)
for key, (name, gain) in sorted_presets:
combo.append_text(name)
combo.connect("changed", combo_changed)
bbox = Gtk.HButtonBox()
clear = Button(_("_Clear"), Icons.EDIT_CLEAR)
clear.connect('clicked', clicked_cb)
bbox.pack_start(combo, True, True, 0)
bbox.pack_start(clear, True, True, 0)
vb.pack_start(bbox, True, True, 0)
return vb
def _fill(self, main):
label = Gtk.Label(label="Ligne d'influence:")
label.set_alignment(0., 0.5)
label.set_padding(5, 0)
self.vbox.pack_start(label, False, False, 0)
button = Gtk.RadioButton.new_with_label_from_widget(
None, "Effort tranchant")
button.set_name("1")
self.vbox.pack_start(button, False, False, 0)
button = Gtk.RadioButton.new_with_label_from_widget(
button, "Moment fléchissant")
button.set_name("2")
self.vbox.pack_start(button, False, False, 0)
button = Gtk.RadioButton.new_with_label_from_widget(button, "Flèche")
button.set_name("3")
self.vbox.pack_start(button, False, False, 0)
button = Gtk.RadioButton.new_with_label_from_widget(
button, "Réaction d'appui")
button.set_name("4")
self.vbox.pack_start(button, False, False, 0)
self.group = button.get_group()
self.combobox1 = Gtk.ComboBoxText()
hbox = Gtk.HBox() # permet de controler la largeur du combo
label = Gtk.Label(label="Elément: ")
hbox.pack_start(label, False, False, 0)
self.combobox1.set_size_request(80, -1)
hbox.pack_start(self.combobox1, False, False, 0)
self.vbox.pack_start(hbox, False, False, 0)
#self.handler1 = self.combobox.connect("changed", main._get_one_value_influ)
hbox = Gtk.HBox()
label = self.spin_label1 = Gtk.Label(label="Position en %: ")
hbox.pack_start(label, False, False, 0)
adjust = Gtk.Adjustment(0., 0., 100., 1., 5.)
spin = self.spin1 = Gtk.SpinButton.new(adjust, 5, 0)
spin.connect("event", self._update)
hbox.pack_start(spin, False, False, 0)
self.vbox.pack_start(hbox, False, False, 0)
#hbox = Gtk.HBox()
b = self.check1 = Gtk.CheckButton("Longueur en m")
b.connect('clicked', self._set_length_unit)
#hbox.pack_start(b, False, False, 0)
self.vbox.pack_start(b, False, False, 0)
toolbar = Gtk.Toolbar()
b = Gtk.ToolButton(Gtk.STOCK_EXECUTE)
b.set_label("Calculer")
b.set_tooltip_text("Calculer la ligne d'influence")
b.connect("clicked", main.area_expose_influ)
toolbar.insert(b, -1)
b = Gtk.ToolButton(Gtk.STOCK_ADD)
b.set_label("Superposer")
b.set_tooltip_text("Superposer une nouvelle ligne d'influence")
b.connect("clicked", main.area_expose_influ, False)
toolbar.insert(b, -1)
b = Gtk.ToolButton(Gtk.STOCK_CLEAR)
b.set_label("Effacer")
b.set_tooltip_text("Effacer les lignes d'influence")
b.connect("clicked", main.on_del_influs)
toolbar.insert(b, -1)
self.vbox.pack_start(toolbar, False, False, 0)
self.vbox.show_all()
def __init__(self, activity):
GObject.GObject.__init__(self)
self.playing = False
self.playingbackwards = False
self.toplevel = activity
self.stickselected = 'RIGHT SHOULDER'
self.surface = None
self._emit_move_handle = None
self.setplayspeed(50)
self.keys_overlap_stack = []
for i in range(len(model.keys)):
self.keys_overlap_stack.append(i)
self.key = screenflip.ScreenFrame()
self.kfselected = 0
self.jointpressed = None
self.kfpressed = -1
self.middlepressed = False
self.rotatepressed = False
self.iconsdir = os.path.join(get_bundle_path(), 'icons')
# screen
self.mfdraw = Gtk.DrawingArea()
self.mfdraw.connect('draw', self.__draw_cb)
self.mfdraw.connect('configure_event', self.configure_event)
self.mfdraw.connect('motion_notify_event', self.motion_notify_event)
self.mfdraw.connect('button_press_event', self.button_press_event)
self.mfdraw.connect('button_release_event', self.button_release_event)
self.mfdraw.set_events(Gdk.EventMask.EXPOSURE_MASK
| Gdk.EventMask.LEAVE_NOTIFY_MASK
| Gdk.EventMask.BUTTON_PRESS_MASK
| Gdk.EventMask.BUTTON_RELEASE_MASK
| Gdk.EventMask.POINTER_MOTION_MASK
| Gdk.EventMask.POINTER_MOTION_HINT_MASK)
self.mfdraw.set_size_request(DRAWWIDTH, DRAWHEIGHT)
screen_box = Gtk.EventBox()
screen_box.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(BACKGROUND))
screen_box.set_border_width(PAD / 2)
screen_box.add(self.mfdraw)
screen_pink = Gtk.EventBox()
screen_pink.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(PINK))
screen_pink.set_border_width(PAD)
screen_pink.add(screen_box)
# keyframes
self.kfdraw = Gtk.DrawingArea()
self.kfdraw.set_size_request(KEYFRAMEWIDTH, KEYFRAMEHEIGHT)
self.kfdraw.connect('draw', self.__kf_draw_cb)
self.kfdraw.connect('configure_event', self.kf_configure_event)
self.kfdraw.connect('motion_notify_event', self.kf_motion_notify_event)
self.kfdraw.connect('button_press_event', self.kf_button_press_event)
self.kfdraw.connect('button_release_event',
self.kf_button_release_event)
self.kfdraw.set_events(Gdk.EventMask.EXPOSURE_MASK
| Gdk.EventMask.LEAVE_NOTIFY_MASK
| Gdk.EventMask.BUTTON_PRESS_MASK
| Gdk.EventMask.BUTTON_RELEASE_MASK
| Gdk.EventMask.POINTER_MOTION_MASK
| Gdk.EventMask.POINTER_MOTION_HINT_MASK)
kfdraw_box = Gtk.EventBox()
kfdraw_box.set_border_width(PAD)
kfdraw_box.add(self.kfdraw)
# control box
angle_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
anglelabel = Gtk.Label(label=_('Angle:'))
anglelabel.modify_fg(Gtk.StateType.NORMAL,
Gdk.color_parse(BUTTON_BACKGROUND))
anglelabel.set_size_request(60, -1)
angle_box.pack_start(anglelabel, False, False, 5)
self.angleentry = Gtk.Entry()
self.angleentry.set_max_length(3)
self.angleentry.set_width_chars(3)
self.angleentry.connect('activate', self.enterangle_callback,
self.angleentry)
self.angleentry.modify_bg(Gtk.StateType.INSENSITIVE,
Gdk.color_parse(BUTTON_FOREGROUND))
angle_box.pack_start(self.angleentry, False, False, 0)
self.anglel_adj = Gtk.Adjustment(0, 0, 360, 1, 60, 0)
self.anglel_adj.connect('value_changed', self._anglel_adj_cb)
self.anglel_slider = Gtk.Scale.new(0, self.anglel_adj)
self.anglel_slider.set_draw_value(False)
for state, color in COLOR_BG_BUTTONS:
self.anglel_slider.modify_bg(state, Gdk.color_parse(color))
angle_box.pack_start(self.anglel_slider, True, True, 0)
size_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
sizelabel = Gtk.Label(label=_('Size:'))
sizelabel.modify_fg(Gtk.StateType.NORMAL,
Gdk.color_parse(BUTTON_BACKGROUND))
sizelabel.set_size_request(60, -1)
size_box.pack_start(sizelabel, False, False, 5)
self.sizeentry = Gtk.Entry()
self.sizeentry.set_max_length(3)
self.sizeentry.set_width_chars(3)
self.sizeentry.connect('activate', self.enterlen_callback,
self.sizeentry)
self.sizeentry.modify_bg(Gtk.StateType.INSENSITIVE,
Gdk.color_parse(BUTTON_FOREGROUND))
size_box.pack_start(self.sizeentry, False, False, 0)
self.size_adj = Gtk.Adjustment(0, 0, 200, 1, 30, 0)
self.size_adj.connect('value_changed', self._size_adj_cb)
size_slider = Gtk.Scale.new(0, self.size_adj)
size_slider.set_draw_value(False)
for state, color in COLOR_BG_BUTTONS:
size_slider.modify_bg(state, Gdk.color_parse(color))
size_box.pack_start(size_slider, True, True, 0)
control_head_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
control_head_box.pack_start(angle_box, True, True, 0)
control_head_box.pack_start(size_box, True, True, 0)
control_head = Gtk.EventBox()
control_head.modify_bg(Gtk.StateType.NORMAL,
Gdk.color_parse(BUTTON_FOREGROUND))
control_head.add(control_head_box)
control_options = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.stickbuttons = {}
self.sticklabels = {}
for stickpartname in LABELLIST:
label = Gtk.Label(label=STRINGS[stickpartname])
label.modify_fg(Gtk.StateType.NORMAL,
Gdk.color_parse(BUTTON_FOREGROUND))
self.sticklabels[stickpartname] = label
ebox = Gtk.EventBox()
ebox.modify_bg(Gtk.StateType.NORMAL,
Gdk.color_parse(BUTTON_BACKGROUND))
ebox.set_events(Gdk.EventMask.BUTTON_PRESS_MASK)
ebox.connect('button_press_event', self.selectstick, stickpartname)
ebox.add(label)
self.stickbuttons[stickpartname] = ebox
control_options.pack_start(ebox, False, False, 0)
self.selectstickebox()
control_scroll = Gtk.ScrolledWindow()
control_scroll.set_policy(Gtk.PolicyType.NEVER,
Gtk.PolicyType.AUTOMATIC)
control_scroll.add_with_viewport(control_options)
control_options.get_parent().modify_bg(
Gtk.StateType.NORMAL, Gdk.color_parse(BUTTON_BACKGROUND))
control_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
control_box.pack_start(control_head, False, False, 0)
control_box.pack_start(control_scroll, True, True, 0)
control_bg = Gtk.EventBox()
control_bg.modify_bg(Gtk.StateType.NORMAL,
Gdk.color_parse(BUTTON_BACKGROUND))
control_bg.set_border_width(PAD / 2)
control_bg.add(control_box)
control_pink = Gtk.EventBox()
control_pink.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(PINK))
control_pink.set_border_width(PAD)
control_pink.add(control_bg)
# left control box
logo = Gtk.Image()
logo.set_from_file(os.path.join(self.iconsdir, 'logo.png'))
leftbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
leftbox.pack_start(logo, False, False, 0)
leftbox.pack_start(control_pink, True, True, 0)
# desktop
hdesktop = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
hdesktop.pack_start(leftbox, False, False, 0)
hdesktop.pack_start(screen_pink, False, False, 0)
desktop = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
desktop.pack_start(hdesktop, True, True, 0)
desktop.pack_start(kfdraw_box, False, False, 0)
greenbox = Gtk.EventBox()
greenbox.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(BACKGROUND))
greenbox.set_border_width(PAD / 2)
greenbox.add(desktop)
self.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(YELLOW))
self.add(greenbox)
self.show_all()
def build_gui(self):
self.win = win = Gtk.ApplicationWindow(title='Gnomecast v%s' % __version__)
win.set_border_width(0)
win.set_icon(self.get_logo_pixbuf(color='#000000'))
self.cast_store = cast_store = Gtk.ListStore(object, str)
vbox_outer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=16)
self.thumbnail_image = Gtk.Image()
self.thumbnail_image.set_from_pixbuf(self.get_logo_pixbuf())
vbox_outer.pack_start(self.thumbnail_image, True, False, 0)
alignment = Gtk.Alignment(xscale=1, yscale=1)
alignment.add(vbox)
alignment.set_padding(16, 20, 16, 16)
vbox_outer.pack_start(alignment, False, False, 0)
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
vbox.pack_start(hbox, False, False, 0)
self.cast_combo = cast_combo = Gtk.ComboBox.new_with_model(cast_store)
cast_combo.set_entry_text_column(1)
renderer_text = Gtk.CellRendererText()
cast_combo.pack_start(renderer_text, True)
cast_combo.add_attribute(renderer_text, "text", 1)
hbox.pack_start(cast_combo, True, True, 0)
refresh_button = Gtk.Button(None, image=Gtk.Image(stock=Gtk.STOCK_REFRESH))
refresh_button.connect("clicked", self.init_casts)
hbox.pack_start(refresh_button, False, False, 0)
win.add(vbox_outer)
# list of queued files
self.files_store = Gtk.ListStore(str, str, int, str, str, int, str, object) # name, path, duration, duration_str, thumbnail_fn, transcode_progress, status_icon, transcoder
self.files_store.connect("row-inserted", self.update_button_visible)
self.files_store.connect("row-deleted", self.update_button_visible)
self.files_view = Gtk.TreeView(self.files_store)
self.files_view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
self.files_view.set_headers_visible(False)
self.files_view.set_rules_hint(True)
column = Gtk.TreeViewColumn("Name", Gtk.CellRendererText(), text=0)
column.set_expand(True)
self.files_view.append_column(column)
self.file_view_column_renderer = r = Gtk.CellRendererText()
r.props.xalign = 1.0
self.files_view.append_column(Gtk.TreeViewColumn("Duration", r, text=3))
self.files_view_progress_column = column_progress = Gtk.TreeViewColumn("Progress", Gtk.CellRendererProgress(), value=5)
self.files_view.append_column(column_progress)
column_pixbuf = Gtk.TreeViewColumn("Playing", Gtk.CellRendererPixbuf(), icon_name=6)
self.files_view.append_column(column_pixbuf)
select = self.files_view.get_selection()
select.connect("changed", self.on_files_view_selection_changed)
self.files_view.connect("row-activated", self.on_files_view_row_activated)
# contains the files list and the buttons to add/del
self.hbox = hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
vbox.pack_start(hbox, False, False, 0)
self.scrolled_window = Gtk.ScrolledWindow()
self.scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
self.scrolled_window.add(self.files_view)
hbox.pack_start(self.scrolled_window, True, True, 0)
self.btn_vbox = btn_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
hbox.pack_start(btn_vbox, True, True, 0)
self.file_button = Gtk.Button(None, image=Gtk.Image(stock=Gtk.STOCK_ADD))
self.file_button.set_tooltip_text('Add one or more audio or video files...')
self.file_button.set_always_show_image(True)
self.file_button.connect("clicked", self.on_file_clicked)
btn_vbox.pack_start(self.file_button, True, True, 0)
self.remove_button = Gtk.Button(None, image=Gtk.Image(stock=Gtk.STOCK_REMOVE))
self.remove_button.set_tooltip_text('Overwrite original file with transcoded version.')
self.remove_button.connect("clicked", self.remove_files)
self.remove_button.set_sensitive(False)
btn_vbox.pack_start(self.remove_button, False, False, 0)
self.file_detail_row = hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
vbox.pack_start(hbox, False, False, 0)
self.subtitle_store = subtitle_store = Gtk.ListStore(str, int, str)
subtitle_store.append(["No subtitles.", -1, None])
subtitle_store.append(["Add subtitle file...", -2, None])
self.subtitle_combo = Gtk.ComboBox.new_with_model(subtitle_store)
self.subtitle_combo.connect("changed", self.on_subtitle_combo_changed)
self.subtitle_combo.set_entry_text_column(0)
renderer_text = Gtk.CellRendererText()
self.subtitle_combo.pack_start(renderer_text, True)
self.subtitle_combo.add_attribute(renderer_text, "text", 0)
self.subtitle_combo.set_active(0)
hbox.pack_start(self.subtitle_combo, True, True, 0)
self.save_button = Gtk.Button(None, image=Gtk.Image(stock=Gtk.STOCK_SAVE))
self.save_button.set_tooltip_text('Overwrite original file with transcoded version.')
self.save_button.connect("clicked", self.save_transcoded_file)
hbox.pack_start(self.save_button, False, False, 0)
# force transcode button
self.transcode_button = Gtk.MenuButton()
self.transcode_button.set_tooltip_text("Force transcode (if your Chromecast won't play a file)...")
menumodel = Gio.Menu()
menumodel.append("Transcode Audio Only (fast)", 'win.transcode-audio')
menumodel.append("Transcode Audio and Video (slow)", "win.transcode-all")
self.transcode_button.set_menu_model(menumodel)
self.transcode_button.set_image(Gtk.Image(stock=Gtk.STOCK_CONVERT))
action = Gio.SimpleAction.new("transcode-audio", None)
action.connect("activate", lambda a,b: self.force_transcode(audio=True, video=False))
self.win.add_action(action)
action = Gio.SimpleAction.new("transcode-all", None)
action.connect("activate", lambda a,b: self.force_transcode(audio=True, video=True))
self.win.add_action(action)
hbox.pack_start(self.transcode_button, False, False, 0)
self.scrubber_adj = Gtk.Adjustment(0, 0, 100, 15, 60, 0)
self.scrubber = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL, adjustment=self.scrubber_adj)
self.scrubber.set_digits(0)
def f(scale, s):
notes = [self.humanize_seconds(s)]
return ''.join(notes)
self.scrubber.connect("format-value", f)
self.scrubber.connect("change-value", self.scrubber_move_started)
self.scrubber.connect("change-value", self.scrubber_moved)
self.scrubber.set_sensitive(False)
vbox.pack_start(self.scrubber, False, False, 0)
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=16)
self.rewind_button = Gtk.Button(None, image=Gtk.Image(stock=Gtk.STOCK_MEDIA_REWIND))
self.rewind_button.connect("clicked", self.rewind_clicked)
self.rewind_button.set_sensitive(False)
self.rewind_button.set_relief(Gtk.ReliefStyle.NONE)
hbox.pack_start(self.rewind_button, True, False, 0)
self.play_button = Gtk.Button(None, image=Gtk.Image(stock=Gtk.STOCK_MEDIA_PLAY))
self.play_button.connect("clicked", self.play_clicked)
self.play_button.set_sensitive(False)
self.play_button.set_relief(Gtk.ReliefStyle.NONE)
hbox.pack_start(self.play_button, True, False, 0)
self.forward_button = Gtk.Button(None, image=Gtk.Image(stock=Gtk.STOCK_MEDIA_FORWARD))
self.forward_button.connect("clicked", self.forward_clicked)
self.forward_button.set_sensitive(False)
self.forward_button.set_relief(Gtk.ReliefStyle.NONE)
hbox.pack_start(self.forward_button, True, False, 0)
self.stop_button = Gtk.Button(None, image=Gtk.Image(stock=Gtk.STOCK_MEDIA_STOP))
self.stop_button.connect("clicked", self.stop_clicked)
self.stop_button.set_sensitive(False)
self.stop_button.set_relief(Gtk.ReliefStyle.NONE)
hbox.pack_start(self.stop_button, True, False, 0)
self.volume_button = Gtk.VolumeButton()
self.volume_button.set_value(1)
self.volume_button.connect("value-changed", self.volume_moved)
self.volume_button.set_sensitive(False)
hbox.pack_start(self.volume_button, True, False, 0)
vbox.pack_start(hbox, False, False, 0)
cast_combo.connect("changed", self.on_cast_combo_changed)
win.connect("delete-event", self.quit)
win.connect("key_press_event", self.on_key_press)
win.show_all()
self.update_button_visible()
win.resize(1,1)
GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, self.quit)
def create_ui(self):
screen = self.get_screen()
w = screen.get_width() - 10
h = screen.get_height() - 65
self.set_default_size(w, h)
hbox = Gtk.HBox()
self.add(hbox)
da = Gtk.DrawingArea()
da.set_size_request(1280, 720)
da.modify_bg(Gtk.StateType.NORMAL, Gdk.Color(0, 0, 0))
hbox.pack_start(da, False, False, 2)
vbox = Gtk.VBox()
hbox.pack_end(vbox, True, True, 2)
lblLeft = Gtk.Label("Left :")
lblLeft.set_halign(Gtk.Align.START)
vbox.pack_start(lblLeft, False, False, 0)
adjLeft = Gtk.Adjustment(0, 0, 200, 10, 20, 0)
adjLeft.connect('value-changed', self.on_left_changed)
sclLeft = Gtk.HScale(adjustment=adjLeft)
vbox.pack_start(sclLeft, False, True, 0)
vbox.pack_start(Gtk.Label(""), False, False, 2)
lblTop = Gtk.Label("Top :")
lblTop.set_halign(Gtk.Align.START)
vbox.pack_start(lblTop, False, False, 0)
adjTop = Gtk.Adjustment(0, 0, 200, 10, 20, 0)
adjTop.connect('value-changed', self.on_top_changed)
sclTop = Gtk.HScale(adjustment=adjTop)
vbox.pack_start(sclTop, False, True, 0)
vbox.pack_start(Gtk.Label(""), False, False, 2)
lblRight = Gtk.Label("Right :")
lblRight.set_halign(Gtk.Align.START)
vbox.pack_start(lblRight, False, False, 0)
adjRight = Gtk.Adjustment(0, 0, 400, 10, 20, 0)
adjRight.connect('value-changed', self.on_right_changed)
sclRight = Gtk.HScale(adjustment=adjRight)
vbox.pack_start(sclRight, False, True, 0)
vbox.pack_start(Gtk.Label(""), False, False, 2)
lblBottom = Gtk.Label("Bottom :")
lblBottom.set_halign(Gtk.Align.START)
vbox.pack_start(lblBottom, False, False, 0)
adjBottom = Gtk.Adjustment(0, 0, 200, 10, 20, 0)
adjBottom.connect('value-changed', self.on_bottom_changed)
sclBottom = Gtk.HScale(adjustment=adjBottom)
vbox.pack_start(sclBottom, False, True, 0)
hbox2 = Gtk.HBox()
vbox.pack_end(hbox2, True, False, 2)
startBtn = Gtk.Button(label='Start')
startBtn.connect('clicked', self.run)
hbox2.pack_start(startBtn, True, True, 2)
exitBtn = Gtk.Button(label='Exit')
exitBtn.connect('clicked', self.on_quit)
hbox2.pack_start(exitBtn, True, True, 2)
def __init__(self, min, max):
Gtk.SpinButton.__init__(self)
self.set_adjustment(
Gtk.Adjustment(value=min, lower=min, upper=max, step_increment=1))
self.show()
def __init__(self, controls):
self.controls = controls
box = VBox(self, Gtk.Orientation.VERTICAL, 0)
box.hide()
"""LAST.FM"""
l_layout = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0)
l_frame = FrameDecorator(_("Last.FM"), l_layout, border_width=0)
"""LOGIN"""
lbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 0)
lbox.show()
login = Gtk.Label.new(_("Login"))
login.set_size_request(150, -1)
login.show()
self.login_text = Gtk.Entry()
self.login_text.show()
lbox.pack_start(login, False, False, 0)
lbox.pack_start(self.login_text, False, True, 0)
"""PASSWORD"""
pbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 0)
pbox.show()
password = Gtk.Label.new(_("Password"))
password.set_size_request(150, -1)
password.show()
self.password_text = Gtk.Entry()
self.password_text.set_visibility(False)
self.password_text.set_invisible_char("*")
self.password_text.show()
limit_text = Gtk.Label.new(_("Limit search results: "))
limit_text.show()
self.adjustment = Gtk.Adjustment(value=50,
lower=10,
upper=200,
step_incr=10)
limit = Gtk.SpinButton.new(self.adjustment, 0.0, 0)
limit.show()
limitbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 0)
limitbox.pack_start(limit_text, False, False, 0)
limitbox.pack_start(limit, False, False, 0)
self.music_scrobbler = Gtk.CheckButton.new_with_label(
_("Enable Music Scrobbler"))
self.music_scrobbler.show()
self.radio_scrobbler = Gtk.CheckButton.new_with_label(
_("Enable Radio Scrobbler"))
self.radio_scrobbler.show()
pbox.pack_start(password, False, False, 0)
pbox.pack_start(self.password_text, False, True, 0)
l_layout.pack_start(lbox, False, True, 0)
l_layout.pack_start(pbox, False, True, 0)
l_layout.pack_start(limitbox, False, True, 10)
l_layout.pack_start(self.music_scrobbler, False, True, 0)
l_layout.pack_start(self.radio_scrobbler, False, True, 0)
"""VK"""
vk_layout = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0)
vk_frame = FrameDecorator(_("VKontakte"), vk_layout, border_width=0)
self.default_label_value = _("Not connected")
self.frase_begin = _("You vk account is:")
self.vk_account_label = Gtk.Label.new(self.frase_begin +
" %s" % self.default_label_value)
self.reset_vk_auth_button = Gtk.Button.new_with_label(
_("Reset vk authorization"))
self.reset_vk_auth_button.connect("button-release-event",
self.on_reset_vk_click)
self.vk_autocomplete = Gtk.CheckButton.new_with_label(
_("Enable VK autocomplete"))
self.vk_autocomplete.show()
vk_layout.pack_start(self.vk_account_label, False, False, 0)
vk_layout.pack_start(self.reset_vk_auth_button, False, False, 0)
vk_layout.pack_start(self.vk_autocomplete, False, False, 0)
"""all"""
box.pack_start(l_frame, False, True, 0)
box.pack_start(vk_frame, False, True, 0)
self.widget = box
def time_control(self, b):
dialog = Gtk.Dialog("Time Control", gv.gui.get_window(), 0,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
dialog.set_title("Time Control")
dialog.vbox.set_spacing(20)
# list of time control types
combobox = Gtk.ComboBoxText()
combobox.append_text("Byoyomi")
combobox.append_text("Classical")
combobox.append_text("Incremental")
combobox.append_text("Fixed Time Per Move")
combobox.append_text("Fixed Search Depth")
combobox.append_text("Infinite Search")
combobox.append_text("Nodes")
combobox.set_active(self.type)
al = Gtk.Alignment.new(xalign=0.0, yalign=1.0, xscale=0.0, yscale=0.5)
# top, bottom, left, right
al.set_padding(9, 0, 9, 9)
al.add(combobox)
dialog.vbox.pack_start(al, False, True, 5)
self.combobox = combobox
dialog.connect("draw", self.dialog_expose_event)
#
# settings for the byoyomi time control type
#
# byoyomi
# e.g. 60 mins available time plus 10 seconds byoyomi
# go btime 3600000 wtime 3600000 byoyomi 10000
#
# list of time control vboxes. 1 per time control type
self.tcvb = [Gtk.VBox(False, 0) for x in range(8)]
byo_frame1 = Gtk.Frame.new("Available Time")
vb = Gtk.VBox(False, 0)
byo_frame1.add(vb)
# available time - hours
minimum = 0
maximum = 10
default = self.byo_hours
byo_adj_hours = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(byo_adj_hours, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
hb = Gtk.HBox(False, 0)
hb.pack_start(Gtk.Label("Hours:"), False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
# available time - minutes
minimum = 0
maximum = 59
default = self.byo_minutes
byo_adj_mins = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(byo_adj_mins, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
lbl = Gtk.Label(label="Minutes :")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
# byoyomi - seconds
byo_frame2 = Gtk.Frame.new("Byoyomi")
minimum = 0
maximum = 60
default = self.byo_byoyomi
byo_adj_byoyomi = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(byo_adj_byoyomi, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
hb = Gtk.HBox(False, 0)
hb.pack_start(Gtk.Label("Seconds:"), False, False, 0)
hb.pack_start(al, True, True, 10)
byo_frame2.add(hb)
self.tcvb[0].pack_start(byo_frame1, False, False, 0)
self.tcvb[0].pack_start(byo_frame2, False, False, 0)
self.tcvb[0].set_spacing(20)
#
# settings for the classical time control type
#
# classical
# e.g. 40 moves in 5 minutes
# go wtime 300000 btime 300000 movestogo 40
#
cls_frame1 = Gtk.Frame()
vb = Gtk.VBox(False, 0)
cls_frame1.add(vb)
adj_cls_settings = []
for i in range(0, self.cls_max_sessions):
(moves_to_go, minutes, repeat_times) = self.cls_settings[i]
# session
hb = Gtk.HBox(False, 0)
if i != 0:
vb.pack_start(Gtk.HSeparator(), False, True, 0)
hb.pack_start(Gtk.Label("#" + str(i + 1)), False, False, 0)
# if i != 0:
# hb.pack_start(Gtk.CheckButton(, True, True, 0), True, True, 10)
vb.pack_start(hb, False, True, 0)
# moves
minimum = 1
maximum = 200
default = moves_to_go
# default = 40
# if i == 0:
# default = 40
# else:
# default = 0
adj_moves_to_go = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(adj_moves_to_go, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0,
yalign=0.0,
xscale=0.0,
yscale=0.0)
al.add(spinner)
hb = Gtk.HBox(False, 0)
hb.pack_start(Gtk.Label("Moves:"), False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
# minutes
minimum = 0
maximum = 500
# default = 5
default = minutes
# if i == 0:
# default = 5
# else:
# default = 0
adj_cls_mins = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(adj_cls_mins, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0,
yalign=0.0,
xscale=0.0,
yscale=0.0)
al.add(spinner)
lbl = Gtk.Label(label="Minutes :")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
# repeating
minimum = 0
maximum = 9
default = repeat_times
# if i == 0:
# default = 1
# else:
# default = 0
adj_cls_repeat = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(adj_cls_repeat, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0,
yalign=0.0,
xscale=0.0,
yscale=0.0)
al.add(spinner)
lbl = Gtk.Label(label="Count :")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
# enabled
# lbl = Gtk.Label(label="Enabled :")
# hb = Gtk.HBox(False, 0)
# hb.pack_start(lbl, False, False, 0)
# hb.pack_start(Gtk.CheckButton(, True, True, 0), True, True, 10)
# vb.pack_start(hb, False, True, 0)
adj_cls_settings.append(
(adj_moves_to_go, adj_cls_mins, adj_cls_repeat))
self.tcvb[1].pack_start(cls_frame1, False, False, 0)
# Blitz (incremental)
# e.g. 2 mins 0 seconds for whole game, 6 seconds 0 milliseconds bonus
# per move
# base is for whole game, bonus will be given for every move made
# go wtime 126000 btime 120000 winc 6000 binc 6000
# go wtime 130591 btime 118314 winc 6000 binc 6000
# go wtime 135329 btime 118947 winc 6000 binc 6000
inc_frame1 = Gtk.Frame.new("Time")
vb = Gtk.VBox(False, 0)
inc_frame1.add(vb)
# available time - hours
minimum = 0
maximum = 10
default = self.inc_hours
inc_adj_hours = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(inc_adj_hours, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
hb = Gtk.HBox(False, 0)
hb.pack_start(Gtk.Label("Hours:"), False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
# available time - minutes
minimum = 0
maximum = 59
default = self.inc_minutes
inc_adj_mins = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(inc_adj_mins, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
lbl = Gtk.Label(label="Minutes :")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
# bonus time per move - seconds
inc_frame2 = Gtk.Frame.new("Bonus Time per Move")
minimum = 0
maximum = 60
default = self.inc_bonus
inc_adj_bonus = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(inc_adj_bonus, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
hb = Gtk.HBox(False, 0)
hb.pack_start(Gtk.Label("Seconds:"), False, False, 0)
hb.pack_start(al, True, True, 10)
inc_frame2.add(hb)
self.tcvb[2].pack_start(inc_frame1, False, False, 0)
self.tcvb[2].pack_start(inc_frame2, False, False, 0)
self.tcvb[2].set_spacing(20)
#
# settings for the fixed time per move time control type
#
# fixed time per move
# e.g. 6 seconds per move
# go movetime 6000
# ftpm_frame1 = Gtk.Frame("Fixed Time Per Move")
ftpm_frame1 = Gtk.Frame()
ftpm_frame1.set_shadow_type(Gtk.ShadowType.NONE)
vb = Gtk.VBox(False, 0)
ftpm_frame1.add(vb)
# seconds per move
minimum = 0
maximum = 10000
default = self.ftpm_seconds
adj_ftpm_secs = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(adj_ftpm_secs, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
lbl = Gtk.Label(label="Seconds :")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
self.tcvb[3].pack_start(ftpm_frame1, False, False, 0)
#
# settings for the fixed search depth time control type
#
# fixed search depth
# e.g.
# go depth 8
dpth_frame1 = Gtk.Frame()
dpth_frame1.set_shadow_type(Gtk.ShadowType.NONE)
vb = Gtk.VBox(False, 0)
dpth_frame1.add(vb)
# depth
minimum = 0
maximum = 999
default = self.dpth_depth
adj_dpth_depth = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(adj_dpth_depth, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
lbl = Gtk.Label(label="Search Depth :")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
self.tcvb[4].pack_start(dpth_frame1, False, False, 0)
# calculate to engines maximum search depth
# (sends back bestmove if it gets the stop command)
# go infinite
# there are no cutomisable options for go infinite
self.tcvb[5].pack_start(Gtk.Label("No customisable options"), True,
True, 0)
#
# settings for the fixed no. of nodes time control type
#
# fixed no. of nodes
# e.g. search for 1 million nodes
# go nodes 1000000
nodes_frame1 = Gtk.Frame()
nodes_frame1.set_shadow_type(Gtk.ShadowType.NONE)
vb = Gtk.VBox(False, 0)
nodes_frame1.add(vb)
# nodes
minimum = 1
maximum = 2000000000
default = self.nodes_nodes
adj_nodes_nodes = Gtk.Adjustment(value=default,
lower=minimum,
upper=maximum,
step_increment=1,
page_increment=5,
page_size=0)
spinner = Gtk.SpinButton.new(adj_nodes_nodes, 1.0, 0)
al = Gtk.Alignment.new(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0)
al.add(spinner)
lbl = Gtk.Label(label="No. of Nodes to Search :")
hb = Gtk.HBox(False, 0)
hb.pack_start(lbl, False, False, 0)
hb.pack_start(al, True, True, 10)
vb.pack_start(hb, False, True, 0)
self.tcvb[6].pack_start(nodes_frame1, False, False, 0)
# mate search
# e.g. look for mate in 5 moves
# go mate 5
self.al = Gtk.Alignment.new(xalign=0.5,
yalign=0.5,
xscale=1.0,
yscale=0.0)
# top, bottom, left, right
self.al.set_padding(0, 0, 9, 9)
self.al.add(self.tcvb[self.type])
dialog.vbox.pack_start(self.al, False, True, 0)
combobox.connect("changed", self.tc_method_changed, dialog)
dialog.set_default_response(Gtk.ResponseType.OK)
dialog.show_all()
self.set_frame_visibility(self.type)
while True:
response = dialog.run()
if response != Gtk.ResponseType.OK:
# cancelled - exit loop
break
# OK pressed - validate input"
# print "ok pressed"
self.type = combobox.get_active()
# byoyomi
if self.type == 0:
byo_hours = int(byo_adj_hours.get_value())
byo_minutes = int(byo_adj_mins.get_value())
byo_byoyomi = int(byo_adj_byoyomi.get_value())
if byo_hours == 0 and byo_minutes == 0 and byo_byoyomi == 0:
gv.gui.info_box("Time fields cannot all be zero!")
else:
# input ok - exit loop
self.byo_hours = byo_hours
self.byo_minutes = byo_minutes
self.byo_byoyomi = byo_byoyomi
self.reset_clock()
self.set_toolbar_time_control(self.type, 0, WHITE)
self.set_toolbar_time_control(self.type, 0, BLACK)
break
# classical
elif self.type == 1:
self.cls_settings = []
rep_zero = True
for i in range(0, self.cls_max_sessions):
moves_to_go, mins, rep = adj_cls_settings[i]
if rep.get_value() != 0:
rep_zero = False
if rep_zero:
gv.gui.info_box("Count fields cannot all be zero!")
else:
for i in range(0, self.cls_max_sessions):
moves_to_go, mins, rep = adj_cls_settings[i]
self.cls_settings.append(
(moves_to_go.get_value(), mins.get_value(),
rep.get_value()))
# fields for go command
self.reset_clock()
self.set_toolbar_time_control(self.type, 0, WHITE)
self.set_toolbar_time_control(self.type, 0, BLACK)
break
# incremental
if self.type == 2:
inc_hours = int(inc_adj_hours.get_value())
inc_minutes = int(inc_adj_mins.get_value())
inc_bonus = int(inc_adj_bonus.get_value())
if inc_hours == 0 and inc_minutes == 0 and inc_bonus == 0:
gv.gui.info_box(
"Incremental Time fields cannot all be zero!")
else:
# input ok - exit loop
self.inc_hours = inc_hours
self.inc_minutes = inc_minutes
self.inc_bonus = inc_bonus
self.reset_clock()
self.set_toolbar_time_control(self.type, 0, WHITE)
self.set_toolbar_time_control(self.type, 0, BLACK)
break
# fixed time per move
elif self.type == 3:
self.ftpm_seconds = int(adj_ftpm_secs.get_value())
# fields for go command
self.reset_clock()
self.set_toolbar_time_control(self.type, 0, WHITE)
self.set_toolbar_time_control(self.type, 0, BLACK)
break
# fixed search depth
elif self.type == 4:
self.dpth_depth = int(adj_dpth_depth.get_value())
# fields for go command
self.reset_clock()
self.set_toolbar_time_control(self.type, 0, WHITE)
self.set_toolbar_time_control(self.type, 0, BLACK)
break
# infinite search
elif self.type == 5:
break
# fixed number of nodes search
elif self.type == 6:
self.nodes_nodes = int(adj_nodes_nodes.get_value())
# fields for go command
self.reset_clock()
self.set_toolbar_time_control(self.type, 0, WHITE)
self.set_toolbar_time_control(self.type, 0, BLACK)
break
dialog.destroy()
def __init__(self, *args, **kwargs):
Operation.__init__(self, *args, **kwargs)
self._grid = Gtk.Grid(border_width=5,
row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False)
self.add(self._grid)
# we need boxes for at least
# hostname
# port
# username
# password
# auto add new host keys
# remote directory
# create remote directory if necessary
# Hostname
tempgrid = Gtk.Grid(row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False)
self._grid.attach(tempgrid, 0, 0, 1, 1)
tempgrid.attach(
Gtk.Label(
label='Hostname',
halign=Gtk.Align.START,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 0, 0, 1, 1)
widget = self.register_widget(
Gtk.Entry(
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
), 'hostname')
tempgrid.attach(widget, 1, 0, 1, 1)
# Port
tempgrid.attach(
Gtk.Label(
label='Port',
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 2, 0, 1, 1)
widget = self.register_widget(
Gtk.SpinButton(adjustment=Gtk.Adjustment(lower=1,
upper=10000,
value=5,
page_size=0,
step_increment=1),
value=22,
update_policy=Gtk.SpinButtonUpdatePolicy.IF_VALID,
numeric=True,
climb_rate=5,
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False), 'port')
tempgrid.attach(widget, 3, 0, 1, 1)
# Username
tempgrid = Gtk.Grid(
row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
)
self._grid.attach(tempgrid, 0, 1, 1, 1)
tempgrid.attach(
Gtk.Label(
label='Username',
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 0, 0, 1, 1)
widget = self.register_widget(
Gtk.Entry(
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
), 'username')
tempgrid.attach(widget, 1, 0, 1, 1)
# Password
tempgrid.attach(
Gtk.Label(
label='Password',
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 2, 0, 1, 1)
widget = self.register_widget(Gtk.Entry(
visibility=False,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
),
'password',
exportable=False)
tempgrid.attach(widget, 3, 0, 1, 1)
# Remote directory
tempgrid = Gtk.Grid(
row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
)
self._grid.attach(tempgrid, 0, 2, 1, 1)
tempgrid.attach(
Gtk.Label(
label='Destination folder',
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 0, 0, 1, 1)
widget = self.register_widget(
Gtk.Entry(
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
), 'destination')
tempgrid.attach(widget, 1, 0, 1, 1)
# Create directory
widget = self.register_widget(
Gtk.CheckButton(
active=True,
label="Create destination folder if necessary",
halign=Gtk.Align.END,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 'force_folder_creation')
tempgrid.attach(widget, 2, 0, 1, 1)
# Automatically accept new host keys
tempgrid = Gtk.Grid(
row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
)
self._grid.attach(tempgrid, 0, 3, 1, 1)
widget = self.register_widget(
Gtk.CheckButton(
active=False,
label="Automatically accept new host keys (dangerous!!)",
halign=Gtk.Align.END,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 'auto_add_keys')
tempgrid.attach(widget, 0, 0, 1, 1)
