def show_shortcut(self):
"""Show the list of valid keyboard shortcut.
"""
self.parent.dialog = QDialog(self.parent)
table = QTableWidget()
vbox = QVBoxLayout()
self.parent.dialog.setLayout(vbox)
self.parent.dialog.setWindowTitle("Keyboard shortcut")
header = ["key", "description"]
keys = MessageText.keylist
table.setColumnCount(len(header))
table.setRowCount(len(keys))
table.setHorizontalHeaderLabels(header)
table.verticalHeader().setVisible(False)
table.setAlternatingRowColors(True)
table.horizontalHeader().setStretchLastSection(True)
table.setEditTriggers(QAbstractItemView.NoEditTriggers)
table.setFocusPolicy(Qt.NoFocus)
for row, content in enumerate(keys):
for col, elem in enumerate(content):
item = QTableWidgetItem(elem)
item.setFlags(Qt.ItemIsDragEnabled | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
table.setItem(row, col, item)
button = QPushButton("&Ok")
button.clicked.connect(self.close)
button.setAutoDefault(True)
vbox.addWidget(table)
vbox.addWidget(button)
self.parent.dialog.resize(640, 480)
self.parent.dialog.exec_()
def add_url_to_group_callback(self):
"""
Callback method for the button "Add url to group"
It creates a window that allows the user to mark the groups
that and urls that are supposed to be added to them
"""
w = QWidget()
f = QHBoxLayout(w)
db = DatabaseHandler()
entries = db.get_entry(CredentialsHandler.lastUsername)
ldata = [url for url in entries['groups']]
ldata = self.exclude_groups(ldata)
ls = ListerView('Groups', 'Groups', ldata, self.parent)
rdata = []
for index in entries['groups']['All']:
rdata.append(entries['urls'][index]['actual_url'])
rs = ListerView('Urls', 'Urls', rdata, self.parent)
rs.layout().setContentsMargins(0, 0, 0, 0)
ls.layout().setContentsMargins(0, 0, 0, 0)
f.addWidget(ls)
f.addWidget(rs)
q = QDialog(self.parent)
q.setWindowTitle('Add URL to Group')
mf = QVBoxLayout(q)
mf.addWidget(w)
buttonBox = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self.parent)
mf.addWidget(buttonBox)
buttonBox.accepted.connect(q.accept)
buttonBox.rejected.connect(q.reject)
if q.exec_():
groups = ls.get_results()
urls = rs.get_results()
for group in groups:
for url in urls:
index = URLHandler.add_url_to_group(url, group)
if index > -1:
self.mainView.group_view.add_url(url, group, index)
def ask_login_and_create_connection(self):
loginf = QDialog()
diagui = Ui_Dialog()
diagui.setupUi(loginf)
last_frommail = keyring.get_password(KEYRING_SERVICE, LAST_FROMMAIL)
last_fromname = keyring.get_password(KEYRING_SERVICE, LAST_FROMNAME)
last_mailserver = keyring.get_password(KEYRING_SERVICE,
LAST_MAILSERVER)
last_copylist = keyring.get_password(KEYRING_SERVICE, LAST_COPYLIST)
last_saveflag = keyring.get_password(KEYRING_SERVICE, LAST_SAVEFLAG)
last_password = keyring.get_password(KEYRING_SERVICE, LAST_PASSWORD)
diagui.line_email.setText(last_frommail or '')
diagui.line_password.setText(last_password or '')
diagui.line_sender.setText(last_fromname or '')
diagui.line_smtpserver.setText(last_mailserver
or 'smtp.googlemail.com')
diagui.line_send_copy.setText(last_copylist or '')
diagui.save_passw_cb.setCheckState([Qt.Unchecked,
Qt.Checked][bool(last_saveflag)])
if loginf.exec_() == QDialog.Accepted:
last_frommail = diagui.line_email.text()
last_password = diagui.line_password.text()
last_fromname = diagui.line_sender.text()
last_mailserver = diagui.line_smtpserver.text()
last_copylist = diagui.line_send_copy.text()
last_saveflag = '1' if diagui.save_passw_cb.checkState() else ''
keyring.set_password(KEYRING_SERVICE, LAST_FROMMAIL, last_frommail)
keyring.set_password(KEYRING_SERVICE, LAST_FROMNAME, last_fromname)
keyring.set_password(KEYRING_SERVICE, LAST_MAILSERVER,
last_mailserver)
keyring.set_password(KEYRING_SERVICE, LAST_COPYLIST, last_copylist)
keyring.set_password(KEYRING_SERVICE, LAST_SAVEFLAG, last_saveflag)
keyring.set_password(KEYRING_SERVICE, LAST_PASSWORD,
last_password if last_saveflag else '')
envelope = EmailEnvelope(smtp_server=last_mailserver,
login=last_frommail,
password=last_password,
sender_addr=last_frommail,
sender_name=last_fromname,
copy_addrs=re.findall(
EMAIL_REGEX, last_copylist))
envelope.verify_credentials()
return envelope
else:
raise ConnectionAbortedError(
'Необходимо ввести логин, пароль и т.д.')
def __init__(self, n_frames, default_name="", parent=None):
QDialog.__init__(self, parent)
Ui_Dialog.setupUi(self, self)
self.selectButton.clicked.connect(self.slot_accept)
self.cancelButton.clicked.connect(self.slot_reject)
self.startFrameSlider.valueChanged.connect(self.slider_frame_changed)
self.endFrameSlider.valueChanged.connect(self.slider_frame_changed)
self.startFrameSpinBox.valueChanged.connect(self.spinbox_frame_changed)
self.endFrameSpinBox.valueChanged.connect(self.spinbox_frame_changed)
self.success = False
self.name = default_name
self.n_frames = n_frames
self.start_frame = 0
self.end_frame = n_frames - 1
self.nameLineEdit.setText(default_name)
self.set_frame_range()
def __init__(self, elementary_action, scene, controller, constraint=None, parent=None):
QDialog.__init__(self, parent)
Ui_Dialog.setupUi(self, self)
self.acceptButton.clicked.connect(self.slot_accept)
self.rejectButton.clicked.connect(self.slot_reject)
self.setConstraintButton.clicked.connect(self.get_constraint)
self._elementary_action = elementary_action
self._controller = controller
self._scene = scene
self.success = False
if constraint is not None:
self.fill_joints_combobox(constraint.joint_name)
else:
self.fill_joints_combobox()
self.fill_annotation_combobox()
self._constraint_object = None
self.constraint_definition = None
def __init__(self, bdd_version: str):
"""
About-us frame.
:param bdd_version: current BDD version
"""
QDialog.__init__(self)
self.setWindowTitle(f"{tr('app_title')} | {tr('about_us')}")
self.setFixedSize(QSize(600, 500))
self.bdd_version = bdd_version
self.links_style = "<style>a { text-decoration:none; color:#416284; font-weight: bold;}</style>"
self._set_labels_and_layout()
self.setStyleSheet(get_stylesheet("dialog2"))
def __init__(self, subject, settings):
Observation.__init__(self, subject)
QDialog.__init__(self)
self.model = settings
self.model.open()
self.setWindowTitle("Settings")
self.setFixedSize(300, 300)
self.setModal(True)
layout = QVBoxLayout()
layout.setAlignment(Qt.AlignTop)
self.setLayout(layout)
self._initTabs()
self._initButtons()
def __init__(self, stats):
QDialog.__init__(self)
self.stats = stats
self.setWindowTitle("Initialization")
self.setMinimumWidth(200)
self.layout = QFormLayout()
self.kill_spinbox = QSpinBox()
self.death_spinbox = QSpinBox()
self.kill_spinbox.setRange(0,1000000)
self.death_spinbox.setRange(0,1000000)
self.layout.addRow(QLabel("Kills"), self.kill_spinbox)
self.layout.addRow(QLabel("Deaths"), self.death_spinbox)
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Cancel | QDialogButtonBox.Ok)
self.layout.addWidget(self.buttonBox)
self.setLayout(self.layout)
self.buttonBox.accepted.connect(self.ok)
self.buttonBox.rejected.connect(self.cancel)
def __init__(self):
QDialog.__init__(self)
self.layout = QVBoxLayout()
self.txtEdit1 = LabeledTextField('IP adresse')
self.txtEdit2 = LabeledTextField('User')
self.txtEdit3 = LabeledTextField('Password')
self.layout.addWidget(self.txtEdit1)
self.layout.addWidget(self.txtEdit2)
self.layout.addWidget(self.txtEdit3)
self.setLayout(self.layout)
self.win = SQLClientWindow()
self.win.show()
self.show()
def success_dialog(self, desc):
""" Is triggered if schedules were created """
d = QDialog()
b1 = QPushButton("Ok", d)
lbl1 = QLabel(f"Results successfully saved as result{desc}.txt")
vbox = QVBoxLayout()
vbox.addWidget(lbl1)
vbox.addStretch()
vbox.addWidget(b1)
vbox.addStretch()
d.setWindowTitle("Success")
d.setLayout(vbox)
b1.clicked.connect(d.accept)
d.setWindowIcon(QIcon("res/logo.ico"))
self.get_finallistsize()
d.exec_()
def fail_dialog(self):
""" Is triggered if schedules cannot be created """
d = QDialog()
b1 = QPushButton("Ok", d)
lbl1 = QLabel("Cannot create a schedule with these subjects")
vbox = QVBoxLayout()
vbox.addWidget(lbl1)
vbox.addStretch()
vbox.addWidget(b1)
vbox.addStretch()
d.setWindowTitle("Failed")
d.setLayout(vbox)
b1.clicked.connect(d.accept)
d.setWindowIcon(QIcon("res/logo.ico"))
self.get_finallistsize()
d.exec_()
def selecCentre(self):
qt = self.ui
wAffichCentre = QDialog()
uiAffichCentre = Ui_Form()
uiAffichCentre.setupUi(wAffichCentre)
rowSelec = qt.tableWidget.currentItem().row()
idSelec = int(qt.tableWidget.item(rowSelec, 0).text())
listIdSelec = reqPostgresql(f"""SELECT * FROM centre WHERE id_c = {idSelec};""")
listAnIdSelect = reqOnePostgresql(f"""SELECT intitule FROM animation a
JOIN proposer p ON a.id_an = p.id_an
JOIN centre c ON p.id_c = c.id_c
WHERE c.id_c = {idSelec};""")
textDescr = ""
for i in range(len(self.namesColList)):
if i != 0:
textDescr += self.namesColList[i] + " : " + listIdSelec[0][i] + "\n"
textAnim = "Animation(s) proposée(s) : \n"
for elem in listAnIdSelect:
textAnim += elem + "\n"
uiAffichCentre.teDescr.setText(textDescr)
uiAffichCentre.teAnim.setText(textAnim)
freq = [np.random.randint(100, 200), np.random.randint(100, 200), np.random.randint(100, 200), np.random.randint(200, 300),
np.random.randint(300, 400), np.random.randint(500, 600), np.random.randint(700, 800), np.random.randint(700, 800),
np.random.randint(500, 600), np.random.randint(300, 400), np.random.randint(200, 300), np.random.randint(100, 200)]
mois = range(1, 13)
fig, ax = plt.subplots()
ax.plot(mois, freq)
plt.xticks(np.arange(min(mois), max(mois) + 1, 1.0))
ax.set(xlabel='mois', ylabel='fréq.',
title='Fréquentation du centre')
ax.grid(True, linestyle='dotted')
canvas = FigureCanvas(fig)
uiAffichCentre.horizontalLayout_2.addWidget(canvas)
self.setLayout(uiAffichCentre.horizontalLayout_2)
wAffichCentre.exec_()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.ui = Ui_GlobalPrefs()
self.ui.setupUi(self)
# set default values
options = get_prefs()
self.ui.persist.line_edit.setText(options["persist"] or "")
self.ui.http_timeout.setValue(options["http_timeout"])
self.ui.persist_size_limit.setValue(options["persist_size_limit"])
self.ui.bg_downloads.setChecked(options["background_downloads"])
self.ui.approx.setChecked(options["approx_policy"])
self.ui.archive_base_url.setText(options["archive_base_url"])
self.ui.advanced_options.setText("Show Advanced Options")
self.ui.enable_telemetry.setChecked(options["enable_telemetry"])
self.toggle_visibility(False)
self.ui.advanced_options.clicked.connect(self.toggle_adv_options)
def __init__(self, parent=QWidget.find(mxs.windows.getMAXHWND())):
QDialog.__init__(self, parent)
self.init()
self.setWindowFlags(QtCore.Qt.WindowType.Window)
self.resize(720, 460)
self.setWindowTitle("AnimRef v1.3.1")
self.defineVariables()
self.defineSignals()
self.defineIcons()
self.start()
self.setWindowIcon(self.icon)
self.timer = QtCore.QTimer(self)
def __init__(self, parent, path, restoreFolder, dialog_id=0):
super(LostFolderDialog, self).__init__()
self._path = path
self._restoreFolder = restoreFolder
self._dialog_id = dialog_id
self._dialog = QDialog(
parent, Qt.Dialog | Qt.CustomizeWindowHint | Qt.WindowTitleHint)
self._dialog.setAttribute(Qt.WA_MacFrameworkScaled)
self._dialog.setWindowIcon(QIcon(':/images/icon.png'))
self._ui = lost_folder_dialog.Ui_Dialog()
self._ui.setupUi(self._dialog)
self._ui.textLabel.setText(self._ui.textLabel.text().replace(
'{PATH}', path))
self._connect_slots()
def __init__(self, machine=None):
"""Initialize the widget according to machine
Parameters
----------
self : PMagnet13
A PMagnet13 widget
machine : Machine
current machine to edit
"""
# Build the interface according to the .ui file
QDialog.__init__(self)
self.setupUi(self)
# Saving arguments
self.machine = machine
# Set FloatEdit unit
self.lf_H0.unit = "m"
self.lf_Hmag.unit = "m"
self.lf_Wmag.unit = "m"
self.lf_Rtopm.unit = "m"
self.u = gui_option.unit
# Set unit name (m ou mm)
wid_list = [
self.unit_Rtopm, self.unit_H0, self.unit_Hmag, self.unit_Wmag
]
for wid in wid_list:
wid.setText(self.u.get_m_name())
# Fill the fields with the lamination values (if they're filled)
self.lf_Hmag.setValue(self.machine.rotor.slot.magnet[0].Hmag)
self.lf_Wmag.setValue(self.machine.rotor.slot.magnet[0].Wmag)
self.lf_Rtopm.setValue(self.machine.rotor.slot.magnet[0].Rtop)
if self.machine.type_machine == 6 and self.machine.rotor.slot.H0 is None:
self.machine.rotor.slot.H0 = 0 # Default value for SPMSM
self.lf_H0.setValue(self.machine.rotor.slot.H0)
# Display the main output of the slot (surface, height...)
self.w_out.comp_output()
# Connect the signal/slot
self.lf_Hmag.editingFinished.connect(self.set_Hmag)
self.lf_Wmag.editingFinished.connect(self.set_Wmag)
self.lf_Rtopm.editingFinished.connect(self.set_Rtopm)
self.lf_H0.editingFinished.connect(self.set_H0)
class DialogSteamapiKey:
steamapi_window: QDialog
def is_valid_steampi_key(self, key):
if len(key) == 32:
return True
return False
def steamapi_key_dialog(self):
self.steamapi_window = QDialog()
self.steamapi_window.setWindowTitle(_("Set steamapi key"))
self.steamapi_window.setWindowIcon(self.switcher_logo)
layout = QVBoxLayout()
self.steamapi_window.setLayout(layout)
text_label = QLabel(
_("Used for getting avatars. Get yours from <a href='https://steamcommunity.com/dev/apikey'>steam</a>"
))
apikey_edit = QLineEdit()
save_button = QPushButton(_("Save"))
text_label.setOpenExternalLinks(True)
apikey_edit.setText(self.switcher.settings.get("steam_api_key"))
layout.addWidget(text_label)
layout.addWidget(apikey_edit)
layout.addWidget(save_button)
def save_enabled():
save_button.setEnabled(
self.is_valid_steampi_key(apikey_edit.text()))
def save():
self.switcher.settings["steam_api_key"] = apikey_edit.text()
self.switcher.settings_write()
self.steamapi_window.hide()
if self.switcher.first_run:
self.import_accounts_dialog()
save_enabled()
apikey_edit.textChanged.connect(lambda: save_enabled())
save_button.clicked.connect(lambda: save())
self.steamapi_window.show()
def __init__(self, scene, filter_function=get_all_objects, parent=None, name=None, properties=None):
QDialog.__init__(self, parent)
Ui_Dialog.setupUi(self, self)
if name is not None:
self.setWindowTitle(name)
self._filter_function = filter_function
self.selectButton.clicked.connect(self.slot_accept)
self.cancelButton.clicked.connect(self.slot_reject)
self.success = False
self.selected_node_id = -1
self._fill_list_with_scene_objects(scene)
self.properties = dict()
if properties is not None:
self.properties = properties
for key in list(self.properties.keys()):
self.add_line(key)
def __init__(self):
QDialog.__init__(self)
self.layout = QVBoxLayout()
self.setWindowTitle("Configuration")
self.o1 = LabeledTextField("IP adress")
self.o2 = LabeledTextField("User")
self.o3 = LabeledTextField("Password")
self.layout.addWidget(self.o1)
self.layout.addWidget(self.o2)
self.layout.addWidget(self.o3)
self.setLayout(self.layout)
self.win = SQLClientWindow()
self.show()
def __init__(self, scene, controller, parent=None):
self._parent = parent
QDialog.__init__(self, parent)
Ui_Dialog.setupUi(self, self)
self.acceptButton.clicked.connect(self.slot_accept)
self.rejectButton.clicked.connect(self.slot_reject)
self.addButton.clicked.connect(self.add_action_from_combobox)
self.clearButton.clicked.connect(self.clear_actions)
self.setStartNodeButton.clicked.connect(self.set_start_node)
self.success = False
self._scene = scene
self._controller = controller
self._current_constraints = None
self.start_node_object = None
self.fill_action_combobox()
self.initialize_action_sequence_list()
def accept(self):
"""
Applies given information when the user clicks "OK"
"""
warningShown = False
for tabNum in range(1, 2): # TODO: Change to 4 when done
for planetNum in range(1, 6):
planet = 'self.mainWindow.ui.pie' + str(planetNum) + 'series'
spinBox = 'self.ui.planet' + str(planetNum) + 'Num'
button = 'self.ui.planet' + str(planetNum) + 'Enable'
if tabNum in (2, 3):
planet += '_' + str(tabNum)
spinBox += '_' + str(tabNum)
button += '_' + str(tabNum)
exec('checked = ' + button + '.isChecked()', locals())
exec('pE = ' + planet + '.enabled', locals())
if locals()['checked']:
exec('pieces = ' + spinBox + '.value()', locals())
pcs = locals()['pieces']
exec('samePcNum = ' + planet + '.sum() == ' + str(pcs),
locals())
if not locals()['pE']:
exec(planet + '.setEnabled(' + str(pcs) + ')')
elif not locals()['samePcNum']:
if not warningShown:
result = self.showChangeWarning()
warningShown = True
if result == QMessageBox.Cancel:
return
exec(planet + '.clear()')
exec(planet + '.setEnabled(' + str(pcs) + ')')
# Only other case is planet already being enabled with the same num of pcs, nothing to do.
else:
if locals()['pE']:
if not warningShown:
result = self.showChangeWarning()
warningShown = True
if result == QMessageBox.Cancel:
return
toDelete = []
for wo in self.mainWindow.machines[tabNum -
1].workOrders:
if wo.planetNum == planetNum:
toDelete.append(wo)
for wo in toDelete:
self.mainWindow.deleteWorkOrder(wo)
toDelete.clear()
exec(planet + '.setDisabled()')
return QDialog.accept(self)
def about_dialog(self):
self.about_dialog = QDialog(self)
self.about_dialog.setWindowTitle("About")
layout = QVBoxLayout()
self.about_dialog.setLayout(layout)
text_label = QLabel(
_("Steam account switcher<br>"
"Author: Tommi Saira <[email protected]><br>"
"Url: <a href='https://github.com/tommis/steam_account_switcher'>github.com/tommis/steam_account_switcher</a>"
))
text_label.setOpenExternalLinks(True)
layout.addWidget(text_label)
self.about_dialog.show()
def __init__(self, controller_list, parent=None):
QDialog.__init__(self, parent)
self.controller_list = controller_list
Ui_Dialog.setupUi(self, self)
self.selectButton.clicked.connect(self.slot_accept)
self.cancelButton.clicked.connect(self.slot_reject)
self.db_url = constants.DB_URL
self.session = SessionManager.session
self.urlLineEdit.setText(self.db_url)
self.motion_table = "motion_clips"
self.action_table = "motion_primitives"
self.action_table = "actions"
self.action = "grasp"
self.success = False
self.fill_combo_box_with_skeletons()
t = threading.Thread(target=self.fill_tree_widget)
t.start()
self.urlLineEdit.textChanged.connect(self.set_url)
def __init__(self, *args, **kwargs):
QDialog.__init__(self, *args, **kwargs)
# front end config
self.setupUi(self)
self.folderButton.clicked.connect(self.set_grad_path)
self.loggerPath = join(dirname(dirname(__file__)), 'log', 'latest_gradView.json')
if exists(self.loggerPath):
with open(self.loggerPath, 'r') as f:
tmp = json.load(f)['path']
self.lineEdit.setText(tmp)
self.path = tmp
else:
self.path = None
self.lineEdit.returnPressed.connect(self.extract_gradient)
def __init__(self, parent):
QDialog.__init__(self, parent)
self.parent = parent
self.setWindowTitle('新建窗口')
tabwidget = QTabWidget()
tabwidget.addTab(SerialConnectForm(self), '串口')
tabwidget.addTab(SshConnectForm(self), u'SSH')
layout = QVBoxLayout()
layout.addWidget(tabwidget)
self.setLayout(layout)
self.new_connect_window_signal.connect(parent.new_connect_window)
def __init__(self, parent, dp=None, signal_server_address=''):
self._dialog = QDialog(parent)
self._dp = dp
self._parent = parent
self._link = ''
self._password = ''
self._is_shared = True
self._password_mode = False
self._signal_server_address = signal_server_address
self._dialog.setWindowIcon(QIcon(':/images/icon.png'))
self._ui = Ui_insert_link_dialog()
self._ui.setupUi(self._dialog)
self._init_ui()
self._cant_validate = tr("Cannot validate share link")
def __init__(self, scene, parent=None):
QDialog.__init__(self, parent)
Ui_Dialog.setupUi(self, self)
self.scene = scene
self.loadStateMachineButton.clicked.connect(self.slot_load_graph)
self.addButton.clicked.connect(self.slot_add_graph)
self.copyButton.clicked.connect(self.slot_copy_graph)
self.editButton.clicked.connect(self.slot_edit_graph)
self.removeButton.clicked.connect(self.slot_remove_graph)
self.exportButton.clicked.connect(self.slot_export_graph)
self.skeletonListComboBox.currentIndexChanged.connect(
self.fill_graph_list)
self.db_url = DB_URL
self.session = SessionManager.session
print("set session", self.session)
self.fill_combo_box_with_skeletons()
self.fill_graph_list()
self.success = False
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi(self)
self.minBlockSizeSpinBox.valueChanged.connect(
self.maxBlockSizeSpinBox.setMinimum)
self.maxBlockSizeSpinBox.valueChanged.connect(
self.minBlockSizeSpinBox.setMaximum)
min_val = self.minBlockSizeSpinBox.value()
max_val = self.maxBlockSizeSpinBox.value()
# Update bounds
self.minBlockSizeSpinBox.valueChanged.emit(min_val)
self.maxBlockSizeSpinBox.valueChanged.emit(max_val)
self.accepted.connect(self.emit_data)
def __init__(self,
parent,
description,
current_account,
recent_account=None):
QDialog.__init__(self)
self.setupUi(self)
self.account_id = recent_account
self.current_account = current_account
self.DescriptionLbl.setText(description)
if self.account_id:
self.AccountWidget.selected_id = self.account_id
# center dialog with respect to parent window
x = parent.x() + parent.width() / 2 - self.width() / 2
y = parent.y() + parent.height() / 2 - self.height() / 2
self.setGeometry(x, y, self.width(), self.height())
def __init__(self, controller, share_widget, parent=None):
QDialog.__init__(self, parent)
Ui_Dialog.setupUi(self, self)
self.view = SceneViewerWidget(parent, share_widget, size=(400,400))
self.view.setObjectName("left")
self.view.setMinimumSize(400,400)
self.view.initializeGL()
self.view.enable_mouse_interaction = True
self.viewerLayout.addWidget(self.view)
self.success = False
self.okButton.clicked.connect(self.slot_accept)
self.cancelButton.clicked.connect(self.slot_reject)
self.removeButton.clicked.connect(self.remove_label)
self.addButton.clicked.connect(self.add_label)
self.setColorButton.clicked.connect(self.set_color)
self.displayFrameSlider.valueChanged.connect(self.slider_frame_changed)
self.displayFrameSpinBox.valueChanged.connect(self.spinbox_frame_changed)
self.displayFrameSlider.valueChanged.connect(self.display_changed)
self.displayFrameSpinBox.valueChanged.connect(self.display_changed)
self.fps = 60
self.dt = 1/60
self.timer = QTimer()
self.timer.timeout.connect(self.draw)
self.timer.start(0)
self.timer.setInterval(1000.0/self.fps)
self.view.makeCurrent()
self.edit_scene = EditorScene(True)
self.edit_scene.enable_scene_edit_widget = False
self.edit_controller = self.copy_controller(controller, self.edit_scene)
self.n_frames = controller._motion.get_n_frames()
self.editor = AnnotationEditor()
motion = self.edit_controller._motion
self.editor.set_annotation(motion._semantic_annotation, motion.label_color_map)
self.set_frame_range()
self.fill_label_combobox()
self.initialized = False
self.init_actions()
self.labelView.setTimeLineParameters(100000, 10)
self.labelView.initScene()
self.labelView.show()
self.init_label_time_line()
self.plot_objects = []
