def after_view_init(self) -> None:
self.tree_view.set_model(self.model)
time_column = Gtk.TreeViewColumn(title='Time [s]')
time_column.set_spacing(5)
self.tree_view.append_column(time_column)
status_icon = Gtk.CellRendererPixbuf()
time_column.pack_start(status_icon, False)
time_column.set_cell_data_func(status_icon, self.status_icon_data_func)
status_spinner = Gtk.CellRendererSpinner()
time_column.pack_start(status_spinner, False)
time_column.set_cell_data_func(status_spinner, self.status_spinner_data_func)
time_text = Gtk.CellRendererText()
time_column.pack_start(time_text, True)
time_column.set_attributes(time_text, text=Column.TIMESTAMP)
self.tree_view.append_column(Gtk.TreeViewColumn(
title='Left CA [°]',
cell_renderer=Gtk.CellRendererText(),
text=Column.LEFT_CA))
self.tree_view.append_column(Gtk.TreeViewColumn(
title='Right CA [°]',
cell_renderer=Gtk.CellRendererText(),
text=Column.RIGHT_CA
))
self.view_ready = True
self.analyses_changed()
self.selection = self._initial_selection
def __init__(self):
Gtk.Window.__init__(self)
self.set_title("CellRendererSpinner")
self.connect("destroy", Gtk.main_quit)
self.liststore = Gtk.ListStore(str, bool, int)
self.liststore.append(["Copying files", True, 0])
self.liststore.append(["Downloading access logs", False, 0])
self.liststore.append(["Connecting to server", True, 0])
treeview = Gtk.TreeView()
treeview.set_model(self.liststore)
self.add(treeview)
cellrenderertext = Gtk.CellRendererText()
self.cellrendererspinner = Gtk.CellRendererSpinner()
treeviewcolumn = Gtk.TreeViewColumn("Activity")
treeview.append_column(treeviewcolumn)
treeviewcolumn.pack_start(cellrenderertext, False)
treeviewcolumn.add_attribute(cellrenderertext, "text", 0)
treeviewcolumn = Gtk.TreeViewColumn("Status")
treeview.append_column(treeviewcolumn)
treeviewcolumn.pack_start(self.cellrendererspinner, False)
treeviewcolumn.add_attribute(self.cellrendererspinner, "active", 1)
def setup_ui_tasks(self, widget):
self.janitor_model.set_sort_column_id(self.JANITOR_NAME,
Gtk.SortType.ASCENDING)
#add janitor columns
janitor_column = Gtk.TreeViewColumn()
renderer = Gtk.CellRendererToggle()
renderer.connect('toggled', self.on_janitor_check_button_toggled)
janitor_column.pack_start(renderer, False)
janitor_column.add_attribute(renderer, 'active', self.JANITOR_CHECK)
self.janitor_view.append_column(janitor_column)
janitor_column = Gtk.TreeViewColumn()
renderer = Gtk.CellRendererPixbuf()
janitor_column.pack_start(renderer, False)
janitor_column.add_attribute(renderer, 'pixbuf', self.JANITOR_ICON)
janitor_column.set_cell_data_func(renderer, self.icon_column_view_func,
self.JANITOR_ICON)
renderer = Gtk.CellRendererText()
renderer.set_property('ellipsize', Pango.EllipsizeMode.END)
janitor_column.pack_start(renderer, True)
janitor_column.add_attribute(renderer, 'markup', self.JANITOR_DISPLAY)
renderer = Gtk.CellRendererSpinner()
janitor_column.pack_start(renderer, False)
janitor_column.add_attribute(renderer, 'active',
self.JANITOR_SPINNER_ACTIVE)
janitor_column.add_attribute(renderer, 'pulse',
self.JANITOR_SPINNER_PULSE)
self.janitor_view.append_column(janitor_column)
#end janitor columns
#new result columns
result_display_renderer = self.builder.get_object(
'result_display_renderer')
result_display_renderer.set_property('ellipsize',
Pango.EllipsizeMode.END)
result_icon_renderer = self.builder.get_object('result_icon_renderer')
self.result_column.set_cell_data_func(result_icon_renderer,
self.icon_column_view_func,
self.RESULT_ICON)
#end new result columns
auto_scan = self.autoscan_setting.get_value()
log.info("Auto scan status: %s", auto_scan)
self.scan_button.set_visible(not auto_scan)
self.update_model()
self._expand_janitor_view()
self.hpaned1.connect('notify::position', self.on_move_handle)
def after_view_init(self) -> None:
self.tree_view.set_model(self.model)
time_column = Gtk.TreeViewColumn(title='Time [s]')
time_column.set_spacing(5)
self.tree_view.append_column(time_column)
status_icon = Gtk.CellRendererPixbuf()
time_column.pack_start(status_icon, False)
time_column.set_cell_data_func(status_icon, self.status_icon_data_func)
status_spinner = Gtk.CellRendererSpinner()
time_column.pack_start(status_spinner, False)
time_column.set_cell_data_func(status_spinner,
self.status_spinner_data_func)
time_text = Gtk.CellRendererText()
time_column.pack_start(time_text, True)
time_column.set_attributes(time_text, text=Column.TIMESTAMP)
self.tree_view.append_column(
Gtk.TreeViewColumn(title='IFT [mN/m]',
cell_renderer=Gtk.CellRendererText(),
text=Column.IFT))
self.tree_view.append_column(
Gtk.TreeViewColumn(title='V [mm³]',
cell_renderer=Gtk.CellRendererText(),
text=Column.VOLUME))
self.tree_view.append_column(
Gtk.TreeViewColumn(title='SA [mm²]',
cell_renderer=Gtk.CellRendererText(),
text=Column.SURFACE_AREA))
self.tree_view.append_column(
Gtk.TreeViewColumn(title='Bond',
cell_renderer=Gtk.CellRendererText(),
text=Column.BOND))
self.tree_view.append_column(
Gtk.TreeViewColumn(title='Worth.',
cell_renderer=Gtk.CellRendererText(),
text=Column.WORTHINGTON))
self.view_ready = True
self.analyses_changed()
self.selection = self._initial_selection
def add_columns(self, treeview):
model = treeview.get_model()
# column for is_fixed toggle
renderer = Gtk.CellRendererToggle()
renderer.connect('toggled', self.is_fixed_toggled, model)
column = Gtk.TreeViewColumn("Fixed?",
renderer,
active=self.COLUMN_FIXED)
column.set_fixed_width(50)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
treeview.append_column(column)
# column for severities
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Severity",
renderer,
text=self.COLUMN_SEVERITY)
column.set_sort_column_id(self.COLUMN_SEVERITY)
treeview.append_column(column)
# column for description
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Description",
renderer,
text=self.COLUMN_DESCRIPTION)
column.set_sort_column_id(self.COLUMN_DESCRIPTION)
treeview.append_column(column)
# column for spinner
renderer = Gtk.CellRendererSpinner()
column = Gtk.TreeViewColumn("Spinning",
renderer,
pulse=self.COLUMN_PULSE,
active=self.COLUMN_ACTIVE)
column.set_sort_column_id(self.COLUMN_PULSE)
treeview.append_column(column)
# column for symbolic icon
renderer = Gtk.CellRendererPixbuf()
renderer.props.follow_state = True
column = Gtk.TreeViewColumn("Symbolic icon",
renderer,
icon_name=self.COLUMN_ICON,
sensitive=self.COLUMN_SENSITIVE)
column.set_sort_column_id(self.COLUMN_ICON)
treeview.append_column(column)
def add_columns(self, treeview):
model = treeview.get_model()
# 命令名字
renderer = Gtk.CellRendererText()
renderer.connect("edited", self.on_cmdgroup_name_changed);
self.renderer_name = renderer
self.renderer_name.set_property("editable", True)
column = Gtk.TreeViewColumn("命令组", renderer, text=self.COLUMN_NAME)
#column.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
column.set_alignment(0.5)
column.set_expand(True)
column.set_resizable(True)
treeview.append_column(column)
# 是否成功
renderer = Gtk.CellRendererPixbuf()
renderer.props.follow_state = True
column = Gtk.TreeViewColumn("结果", renderer, stock_id = self.COLUMN_IS_OK)
#sensitive=self.COLUMN_SENSITIVE)
#column.set_sort_column_id(self.COLUMN_ICON)
column.set_min_width(50)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.set_expand(False)
column.set_alignment(0.5)
treeview.append_column(column)
# 是否正在运行
renderer = Gtk.CellRendererSpinner()
column = Gtk.TreeViewColumn("运行", renderer, pulse=self.COLUMN_PROGRESS,
active=self.COLUMN_START_PROCESS)
column.set_min_width(50)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.set_alignment(0.5)
treeview.append_column(column)
def build_ui(self):
# Dark theme at start
if self._settings.get_boolean('dark-theme'):
self.toggle_dark_theme(True)
# Headerbar
builder = Gtk.Builder.new_from_resource(UI_PATH + 'menu.ui')
window_menu = builder.get_object('window-menu')
self.menu_button.set_menu_model(window_menu)
# Mainbox - drag&drop
enforce_target = Gtk.TargetEntry.new('text/uri-list',
Gtk.TargetFlags(4), 0)
self.mainbox.drag_dest_set(Gtk.DestDefaults.ALL, [enforce_target],
Gdk.DragAction.COPY)
self.mainbox.connect('drag-data-received', self.on_receive)
# Treeview
self.store = Gtk.ListStore(bool, str, str, int, str, int, str, float)
self.treeview.set_model(self.store)
self.renderer = Gtk.CellRendererText()
self.spinner_renderer = Gtk.CellRendererSpinner()
col_bool = Gtk.TreeViewColumn('', self.spinner_renderer, active=0)
self.treeview.append_column(col_bool)
self.add_column_to_treeview(_("Filename"), 1, True)
self.add_column_to_treeview(_("Old Size"), 2, True, 3)
self.add_column_to_treeview(_("New Size"), 4, True, 5)
self.add_column_to_treeview(_("Savings"), 6, True, 7)
self.adjustment = self.treeview_scrolled_window.get_vadjustment()
# Lossy toggle
self.toggle_lossy.set_active(self._settings.get_boolean('lossy'))
self.toggle_lossy.connect('notify::active', self.on_lossy_changed)
# Info label
self.change_save_info_label()
def get_main_widget(self):
vbox = Gtk.VBox()
self._sw = Gtk.ScrolledWindow()
self._sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
vbox.pack_start(self._sw, True, True, 0)
self._model = Gtk.ListStore(object, str, str, bool, int)
self._treeview = Gtk.TreeView(model=self._model)
self._treeview.connect('motion-notify-event',
self._on_treeview__motion_notify_event)
self._treeview.connect('button-release-event',
self._on_treeview__button_release_event)
self._treeview.add_events(Gdk.EventMask.BUTTON_PRESS_MASK
| Gdk.EventMask.KEY_PRESS_MASK)
self._treeview.set_tooltip_column(COL_TOOLTIP)
self._treeview.set_enable_search(False)
self._selection = self._treeview.get_selection()
self._selection.set_mode(Gtk.SelectionMode.BROWSE)
self._spinner_renderer = Gtk.CellRendererSpinner()
self._spinner_column = Gtk.TreeViewColumn('',
self._spinner_renderer,
active=COL_SPINNER_ACTIVE,
pulse=COL_SPINNER_PULSE)
self._renderer = ComboDetailsCellRenderer(use_markup=True)
self._treeview.append_column(
Gtk.TreeViewColumn('', self._renderer, label=COL_MARKUP))
self._treeview.set_headers_visible(False)
self._sw.add(self._treeview)
vbox.show_all()
return vbox
def add_columns(self, treeview):
model = treeview.get_model()
# 是否需要执行
renderer = Gtk.CellRendererToggle()
renderer.connect('toggled', self.on_is_selected_toggled, model)
self.renderer_is_selected = renderer
column = Gtk.TreeViewColumn("选中",
renderer,
active=self.COLUMN_IS_SELECTED)
column.set_fixed_width(50)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.set_alignment(0.5)
treeview.append_column(column)
# 命令类型
renderer = Gtk.CellRendererCombo()
renderer.set_property("text-column", 0)
renderer.set_property("model", self.create_selected_cmd_list())
renderer.connect("changed", self.on_cmd_content_changed, model)
self.renderer_content = renderer
column = Gtk.TreeViewColumn("命令", renderer, text=self.COLUMN_CMD)
#column.set_sort_column_id(self.COLUMN_SEVERITY)
#column.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
column.set_resizable(True)
column.set_expand(True)
column.set_alignment(0.5)
treeview.append_column(column)
# 命令内容或者参数
renderer = Gtk.CellRendererText()
renderer.connect("edited", self.on_param_edited, model)
self.renderer_name = renderer
column = Gtk.TreeViewColumn("详细", renderer, text=self.COLUMN_PARAM)
#column.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
column.set_alignment(0.5)
column.set_expand(True)
column.set_resizable(True)
treeview.append_column(column)
# 是否正在运行
renderer = Gtk.CellRendererSpinner()
column = Gtk.TreeViewColumn("运行",
renderer,
pulse=self.COLUMN_PROGRESS,
active=self.COLUMN_CMD_START_PROCESS)
column.set_min_width(50)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.set_alignment(0.5)
treeview.append_column(column)
# 是否成功
renderer = Gtk.CellRendererPixbuf()
renderer.props.follow_state = True
column = Gtk.TreeViewColumn("结果", renderer, stock_id=self.COLUMN_IS_OK)
#sensitive=self.COLUMN_SENSITIVE)
#column.set_sort_column_id(self.COLUMN_ICON)
column.set_min_width(50)
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
column.set_expand(False)
column.set_alignment(0.5)
treeview.append_column(column)
def __init__(self):
"""
Initializes the class.
"""
super().__init__()
# Settings
self.set_headers_visible(False)
# Create model
self.model = Gtk.TreeStore(
str, # Reason
bool, # Status
str, # Icon
int, # ID
str, # Name
str, # Version
str, # Size/Download status
bool, # Downloading
int, # Downloading pulse
bool, # Checkbox and package_name visibility
bool, # Icon visibility
)
self.set_model(self.model)
# Create columns
# Package
self.package_column = Gtk.TreeViewColumn("Package")
self.package_column.set_expand(True)
self.package_checkbox = Gtk.CellRendererToggle()
self.package_checkbox.set_activatable(True)
self.package_column.pack_start(self.package_checkbox, False)
self.package_column.add_attribute(self.package_checkbox, "visible", 9)
self.package_column.add_attribute(self.package_checkbox, "active", 1)
# Handle checkbox toggled signal
self.package_checkbox.connect("toggled", self.on_status_toggled)
self.package_icon = Gtk.CellRendererPixbuf()
self.package_column.pack_start(self.package_icon, False)
self.package_column.add_attribute(self.package_icon, "visible", 10)
self.package_column.add_attribute(self.package_icon, "icon_name", 2)
self.version_spinner = Gtk.CellRendererSpinner()
self.package_column.pack_start(self.version_spinner, False)
self.package_column.add_attribute(self.version_spinner, "visible", 7)
self.package_column.add_attribute(self.version_spinner, "active", 7)
self.package_column.add_attribute(self.version_spinner, "pulse", 8)
self.package_name = Gtk.CellRendererText()
self.package_column.pack_start(self.package_name, True)
#self.package_column.add_attribute(self.package_name, "visible", 7)
self.package_column.add_attribute(self.package_name, "text", 4)
self.append_column(self.package_column)
# Size column
self.size_column = Gtk.TreeViewColumn("Size")
#self.size_column.set_expand(True)
self.version_size = Gtk.CellRendererText()
self.size_column.pack_start(self.version_size, True)
self.size_column.add_attribute(self.version_size, "visible", 9)
self.size_column.add_attribute(self.version_size, "text", 6)
self.append_column(self.size_column)
# Version
self.version_column = Gtk.TreeViewColumn("Version")
#self.version_column.set_expand(True)
self.version_version = Gtk.CellRendererText()
self.version_column.pack_start(self.version_version, False)
self.version_column.add_attribute(self.version_version, "text", 5)
self.append_column(self.version_column)
# Create main sections:
# Application updates, New packages, packages to remove, package updates
self.clear()
window = Gtk.Window()
window.set_default_size(200, 200)
window.connect("destroy", lambda q: Gtk.main_quit())
liststore = Gtk.ListStore(str, bool, int)
liststore.append(["OpenSuSE", True, 1])
liststore.append(["Aptosid", False, 0])
liststore.append(["Crunchbang", True, 3])
treeview = Gtk.TreeView(model=liststore)
window.add(treeview)
treeviewcolumn = Gtk.TreeViewColumn("Distribution")
treeview.append_column(treeviewcolumn)
cellrenderertext = Gtk.CellRendererText()
treeviewcolumn.pack_start(cellrenderertext, False)
treeviewcolumn.add_attribute(cellrenderertext, "text", 0)
treeviewcolumn = Gtk.TreeViewColumn("Active")
treeview.append_column(treeviewcolumn)
cellrendererspinner = Gtk.CellRendererSpinner()
treeviewcolumn.pack_start(cellrendererspinner, False)
treeviewcolumn.add_attribute(cellrendererspinner, "active", 1)
treeviewcolumn.add_attribute(cellrendererspinner, "pulse", 2)
window.show_all()
GObject.timeout_add(100, pulse_spinner)
Gtk.main()
def _build_ui(self):
# connection status ----------------------
self._ds_connect_btn = self._ui.get_object('connect_to_display_server_button')
self._ds_connect_btn.connect('clicked', self.on_connect_to_display_server)
self._ds_disconnect_btn = self._ui.get_object('disconnect_from_display_server_button')
self._ds_disconnect_btn.connect('clicked', self.on_disconnect_from_display_server)
self._ds_status_lbl = self._ui.get_object('ds_connection_status_label')
# save calibration EXR button -----------
button = self._ui.get_object('save_calibration_exr_button')
button.connect('clicked', self.on_save_calibration_exr)
# build main window ----------------------
window = self._ui.get_object('main_box')
nb = Gtk.Notebook()
window.add(nb)
nb.append_page(self._ui.get_object('checkerboard_grid'),
Gtk.Label(label='intrinsics'))
nb.append_page(self._ui.get_object('virtual_display_layout_grid'),
Gtk.Label(label='virtual displays'))
nb.append_page(self._ui.get_object('geom_grid'),
Gtk.Label(label='display geometry'))
nb.append_page(self._ui.get_object('corresponding_points_grid'),
Gtk.Label(label='extrinsics'))
self._ui.get_object('file_open_menu_item').connect(
'activate', self.on_open)
self._ui.get_object('file_save_menu_item').connect(
'activate', self.on_save)
self._ui.get_object('file_saveas_menu_item').connect(
'activate', self.on_save_as)
self._ui.get_object('file_quit_menu_item').connect(
'activate', rosgobject.main_quit)
self._ui.get_object('help_about_menu_item').connect(
'activate', self.on_help_about)
self._ui.get_object('view_mock_ds_item').connect(
'activate', self.on_view_mock_ds)
# setup checkerboard treeview ----------------
self.checkerboard_store = Gtk.ListStore(object)
treeview = self._ui.get_object('checkerboard_treeview')
treeview.set_model( self.checkerboard_store )
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("rows", renderer)
column.set_cell_data_func(renderer, self.render_checkerboard_row, func_data='rows')
treeview.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("columns", renderer)
column.set_cell_data_func(renderer, self.render_checkerboard_row, func_data='columns')
treeview.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("size", renderer)
column.set_cell_data_func(renderer, self.render_checkerboard_row, func_data='size')
treeview.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("time", renderer)
column.set_cell_data_func(renderer, self.render_checkerboard_row, func_data='date_string')
treeview.append_column(column)
self._ui.get_object('CK_add_button').connect('clicked', self.on_CK_add)
self._ui.get_object('CK_remove_button').connect('clicked', self.on_CK_remove)
self._ui.get_object('compute_intrinsics').connect('clicked', self.on_compute_intrinsics)
# setup checkerboard dialog ----------------
self.add_CK_dialog = AddCheckerboardDialog(self._ui,
nrows=DEFAULT_CHECKER_NROWS,
ncols=DEFAULT_CHECKER_NCOLS,
size=DEFAULT_CHECKER_SIZE)
# setup help->about dialog -----------------
self.help_about_dialog = Gtk.Dialog(title='About',
parent=None,
buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK))
self.help_about_dialog.get_content_area().add(self._ui.get_object('help_about_dialog_grid'))
version_str = getattr(flyvr,'__version__','0.0')
self._ui.get_object('version_label').set_text(version_str)
# setup vdisp combobox ----------------
self.vdisp_store = Gtk.ListStore(str,int,bool,int,float,bool,object,bool)
# create vdisp treeview -----------------------
treeview = self._ui.get_object('vdisp_treeview')
treeview.set_model( self.vdisp_store )
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("virtual display", renderer, text=VS_VDISP)
column.set_sort_column_id(VS_VDISP)
treeview.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("count", renderer, text=VS_COUNT)
column.set_sort_column_id(VS_COUNT)
treeview.append_column(column)
renderer = CellRendererButton('Calibrate')
renderer.connect("clicked", self.on_trigger_cal)
column = Gtk.TreeViewColumn("calibration")
column.pack_start(renderer, False)
renderer = Gtk.CellRendererSpinner()
column.pack_start(renderer, False)
column.add_attribute(renderer, "active", VS_CALIBRATION_RUNNING)
column.add_attribute(renderer, "pulse", VS_CALIBRATION_PROGRESS)
treeview.append_column(column)
GObject.timeout_add(100, self._pulse_spinner)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("mean reproj. error", renderer,
text=VS_MRE)
column.set_sort_column_id(VS_MRE)
treeview.append_column(column)
renderer = Gtk.CellRendererToggle()
renderer.connect("toggled", self.on_toggle_show_beachball)
column = Gtk.TreeViewColumn("show beachball", renderer, active=VS_SHOW_BEACHBALL)
treeview.append_column(column)
renderer = Gtk.CellRendererToggle()
renderer.connect("toggled", self.on_toggle_publish_rviz)
column = Gtk.TreeViewColumn("publish RViz cam", renderer, active=VS_PUBLISH_RVIZ)
treeview.append_column(column)
# create point treeview -----------------------
self.point_store = Gtk.ListStore(str, float, float, float, float, bool, bool)
treeview = self._ui.get_object('treeview1')
treeview.set_model( self.point_store )
renderer_text = Gtk.CellRendererCombo(model=self.vdisp_store,
text_column=VDISP,
editable=True)
renderer_text.connect("edited", self.on_edit_vdisp, VDISP)
column = Gtk.TreeViewColumn("virtual display", renderer_text, text=VDISP)
column.set_sort_column_id(VDISP)
treeview.append_column(column)
renderer_text = Gtk.CellRendererText(editable=True)
renderer_text.connect("edited", self.on_edit_cell, TEXU)
column = Gtk.TreeViewColumn("texture U", renderer_text, text=TEXU)
column.set_cell_data_func(renderer_text, nice_float_fmt, func_data=TEXU)
column.set_sort_column_id(TEXU)
treeview.append_column(column)
renderer_text = Gtk.CellRendererText(editable=True)
renderer_text.connect("edited", self.on_edit_cell, TEXV)
column = Gtk.TreeViewColumn("texture V", renderer_text, text=TEXV)
column.set_cell_data_func(renderer_text, nice_float_fmt, func_data=TEXV)
column.set_sort_column_id(TEXV)
treeview.append_column(column)
renderer_text = Gtk.CellRendererText(editable=True)
renderer_text.connect("edited", self.on_edit_cell, DISPLAYX)
column = Gtk.TreeViewColumn("display X", renderer_text, text=DISPLAYX)
column.set_cell_data_func(renderer_text, nice_float_fmt, func_data=DISPLAYX)
column.set_sort_column_id(DISPLAYX)
treeview.append_column(column)
renderer_text = Gtk.CellRendererText(editable=True)
renderer_text.connect("edited", self.on_edit_cell, DISPLAYY)
column = Gtk.TreeViewColumn("display Y", renderer_text, text=DISPLAYY)
column.set_cell_data_func(renderer_text, nice_float_fmt, func_data=DISPLAYY)
column.set_sort_column_id(DISPLAYY)
treeview.append_column(column)
renderer_toggle = Gtk.CellRendererToggle()
renderer_toggle.connect("toggled", self.on_toggle_point_show)
column = Gtk.TreeViewColumn("show", renderer_toggle, active=SHOWPT)
column.set_sort_column_id(SHOWPT)
treeview.append_column(column)
renderer_pixbuf = Gtk.CellRendererToggle()
renderer_pixbuf.set_radio(True)
renderer_pixbuf.connect("toggled", self.on_do_point)
column = Gtk.TreeViewColumn('Joystick select', renderer_pixbuf, active=JOYLISTEN)
treeview.append_column(column)
self.point_store.connect("row-changed", self.on_points_updated)
self.point_store.connect("row-inserted", self.on_points_updated)
self.point_store.connect("row-deleted", self.on_points_updated)
# connect treeview buttons ---------------------------
self._ui.get_object('UV_add_button').connect('clicked', self.on_add_UV)
self._ui.get_object('UV_remove_button').connect('clicked', self.on_remove_UV)
# self._ui.get_object('save_points_button').connect('clicked', self.on_save_to_yaml,
# self.point_store_to_list)
# self._ui.get_object('load_points_button').connect('clicked', self.on_load_points_button)
self._ui.get_object('show_all_button').connect('clicked', self.on_show_all_button, True)
self._ui.get_object('show_none_button').connect('clicked', self.on_show_all_button, False)
# setup ComboBoxText
cal_method_cbtext = self._ui.get_object('cal_method_cbtext')
for method in EXTRINSIC_CALIBRATION_METHODS:
cal_method_cbtext.append(method,method)
cal_method_cbtext.set_active_id(EXTRINSIC_CALIBRATION_METHODS[0])
def __init__(self, madmin, log, config, settings, stationlist):
self.madmin = madmin
self.log = log
self.config = config
self.settings = settings
self.stationlist = stationlist
self.obj_timer_streamripper = None
self.record_status = False
self.count = 0
self.pre_stationlist = [
[
'Alternative', 'Radio freeFM Ulm',
'http://stream.freefm.de:7000/Studio'
],
[
'Alternative', 'Radio FM 4 at',
'https://orf-live.ors-shoutcast.at/fm4-q2a'
],
['Alternative', 'Zeilsteen Radio', 'http://live.zeilsteen.com:80'],
[
'Mix / Alternative', 'Gorilla FM',
'http://185.33.21.112:80/gorillafm_128'
],
[
'Electro', 'radio Top 40 Electro',
'http://antenne-th.divicon-stream.net/antth_top40electro_JlSz-mp3-192?sABC=58p2q700%230%232pn8rp1qoro76pp9n0r46nspn714s714%23fgernz.enqvbgbc40.qr'
],
[
'Electro', 'Sunshine Live',
'http://sunshinelive.hoerradar.de/sunshinelive-live-mp3-hq'
], ['Charts', 'Radio Fg', 'http://radiofg.impek.com:80/fg'],
[
'Charts', 'radio Top 40 Weimar Charts',
'http://antenne-th.divicon-stream.net/antth_top40char_0f6x-mp3-192?sABC=58p2q6s8%230%232pn8rp1qoro76pp9n0r46nspn714s714%23fgernz.enqvbgbc40.qr'
],
[
'Charts', 'Top 100 Station',
'http://www.top100station.de/switch/r3472.pls'
],
[
'Charts', 'radio Top 40 Weimar Live',
'http://antenne-th.divicon-stream.net/antth_top40live_SeJx-mp3-192?sABC=58p2q6rq%230%232pn8rp1qoro76pp9n0r46nspn714s714%23fgernz.enqvbgbc40.qr'
],
[
'Pop', 'Antenne Bayern Fresh4You',
'http://mp3channels.webradio.antenne.de/fresh'
],
[
'Rock', 'Antenne Bayern Rock',
'http://mp3channels.webradio.antenne.de/rockantenne'
], ['Rock', 'PureRock.US', 'http://167.114.64.181:8524/stream']
]
self.grid = Gtk.Grid()
self.grid.set_column_homogeneous(True)
#self.grid.set_row_homogeneous(True)
self.record_station = []
self.liststore = Gtk.ListStore(int, bool, str, str, str, str)
self.update_listmodel()
self.treeview = Gtk.TreeView.new_with_model(model=self.liststore)
#self.treeview.connect('button-press-event', self.treeview_press_event)
self.treeview.connect('row-activated', self.treeview_row_activated)
self.treeview.set_activate_on_single_click(True)
self.renderer_spinner = Gtk.CellRendererSpinner()
self.renderer_spinner.set_fixed_size(50, 30)
self.column_spinner = Gtk.TreeViewColumn('Rec',
self.renderer_spinner,
active=0)
self.treeview.append_column(self.column_spinner)
self.column_spinner.add_attribute(self.renderer_spinner, 'pulse', 0)
renderer_rec = Gtk.CellRendererToggle()
renderer_rec.set_fixed_size(50, 30)
column_rec = Gtk.TreeViewColumn('Sel', renderer_rec, active=1)
renderer_rec.connect('toggled', self.on_cell_toggled)
self.treeview.append_column(column_rec)
renderer_pixbuf = Gtk.CellRendererPixbuf()
renderer_pixbuf.set_fixed_size(50, 30)
self.column_delete = Gtk.TreeViewColumn('Del',
renderer_pixbuf,
icon_name=2)
self.treeview.append_column(self.column_delete)
self.renderer_genre = Gtk.CellRendererText()
self.renderer_genre.set_property('editable', True)
self.renderer_genre.set_fixed_size(150, 30)
column_genre = Gtk.TreeViewColumn('Genre', self.renderer_genre, text=3)
self.renderer_genre.connect('edited', self.renderer_genre_edited)
self.treeview.append_column(column_genre)
self.renderer_stations = Gtk.CellRendererText()
self.renderer_stations.set_property('editable', True)
self.renderer_stations.set_fixed_size(250, 30)
self.renderer_stations.connect('edited', self.renderer_stations_edited)
column_station = Gtk.TreeViewColumn('Station',
self.renderer_stations,
text=4)
self.treeview.append_column(column_station)
self.renderer_url = Gtk.CellRendererText()
self.renderer_url.set_property('editable', True)
self.renderer_url.connect('edited', self.renderer_url_edited)
column_url = Gtk.TreeViewColumn('Url', self.renderer_url, text=5)
column_url.set_expand(True)
self.treeview.append_column(column_url)
self.scrolledwindow = Gtk.ScrolledWindow()
self.scrolledwindow.set_vexpand(True)
self.scrolledwindow.set_hexpand(True)
self.scrolledwindow.set_child(self.treeview)
self.scrolledwindow.set_child(self.treeview)
self.scrolledwindow.set_margin_bottom(5)
self.grid.attach(self.scrolledwindow, 1, 1, 1, 1)
hbox_buttons = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
spacing=5)
button_selectall = Gtk.Button(label='Select All')
button_selectall.connect('clicked', self.button_selectall_clicked)
button_deselectall = Gtk.Button(label='Deselect All')
button_deselectall.connect('clicked', self.button_deselectall_clicked)
button_record_start = Gtk.Button(label='Start Record')
button_record_start.connect('clicked', self.button_record_clicked)
button_record_stop = Gtk.Button(label='Stop Record')
button_record_stop.connect('clicked', self.button_stop_clicked)
button_new_station = Gtk.Button(label='New Station')
button_new_station.connect('clicked', self.button_new_station_clicked)
button_reset = Gtk.Button(label='Reset')
button_reset.connect('clicked', self.button_reset_clicked)
button_info = Gtk.Button(label='Info')
button_info.connect('clicked', self.button_info_clicked)
hbox_buttons.append(button_selectall)
hbox_buttons.append(button_deselectall)
hbox_buttons.append(button_record_start)
hbox_buttons.append(button_record_stop)
hbox_buttons.append(button_new_station)
hbox_buttons.append(button_reset)
hbox_buttons.append(button_info)
hbox_buttons.set_margin_start(5)
self.grid.attach_next_to(hbox_buttons, self.scrolledwindow,
Gtk.PositionType.BOTTOM, 1, 1)
self.hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.hbox.append(self.grid)
self.hbox.set_margin_bottom(5)
