class StringInputWidget(InputWidgetSingle):
"""
String data input widget
"""
def __init__(self, parent=None, **kwds):
super(StringInputWidget, self).__init__(parent=parent, **kwds)
self.le = QLineEdit(self)
self.le.setContextMenuPolicy(QtCore.Qt.NoContextMenu)
self.setWidget(self.le)
self.le.textChanged.connect(lambda val: self.dataSetCallback(val))
def setWidgetValue(self, val):
self.le.setText(str(val))
class NoneInputWidget(InputWidgetSingle):
"""
String data input widget
"""
def __init__(self, parent=None, **kwds):
super(NoneInputWidget, self).__init__(parent=parent, **kwds)
self.le = QLineEdit(self)
self.le.setContextMenuPolicy(QtCore.Qt.NoContextMenu)
self.setWidget(self.le)
self.le.textChanged.connect(lambda val: self.dataSetCallback(val))
self.le.setEnabled(False)
def blockWidgetSignals(self, bLocked):
self.le.blockSignals(bLocked)
def setWidgetValue(self, val):
self.le.setText(str(val))
class StringEditor(BaseEditor, object):
attr_type = 'str'
def __init__(self, parent=None, **kwargs):
super(StringEditor, self).__init__(parent=parent, **kwargs)
self._default_value = ""
self._clean_value = kwargs.get('clean', True)
self.value_line = QLineEdit(self)
reg_exp = QRegExp('^([a-zA-Z0-9_]+)')
self.main_layout.addWidget(self.value_line)
self.value_line.textEdited.connect(self._validate_text)
self.value_line.editingFinished.connect(self.OnValueUpdated)
self.value_line.returnPressed.connect(self.OnValueUpdated)
def get_value(self):
return str(self.value_line.text())
value = property(get_value)
def initialize_editor(self):
editor_value = self.default_value
node_values = self.values
if node_values:
if len(node_values) > 1:
pass
elif len(node_values) == 1:
if node_values[0]:
editor_value = node_values[0]
self.value_line.blockSignals(True)
self.value_line.setText(str(editor_value))
self.value_line.blockSignals(False)
def set_connected(self, conn):
if conn != self._connection:
self._connection = conn
self.value_line.setText(conn)
self.value_line.setEnabled(False)
self.value_line.setProperty('class', 'Connected')
def _validate_text(self, text):
"""
Validates the given value and update the current text
:param text: str, text to validate
"""
current_text = self.value
if self._clean_value:
cursor_pos = self.value_line.cursorPosition()
cleaned = string_utils.clean_string(text=text)
self.value_line.blockSignals(True)
self.value_line.setText(cleaned)
self.value_line.blockSignals(False)
self.value_line.setCursorPosition(cursor_pos)
def __init__(self, settings, parent=None, description=None, pstvOnly=True):
super(ConfigDialog, self).__init__(parent)
self.setWindowTitle("Configure source")
self.layout = QGridLayout(self)
row = 0
self.widgets = {}
self.settings = settings
# Settings should be a dictionary
for name, val in settings.items():
label = QLabel(self)
label.setText(str(name))
self.layout.addWidget(label, row, 0, 1, 1)
# Check the type of each setting, and create widgets accordingly
if isinstance(val, str):
# A string of some kind
widget = QLineEdit(self)
widget.setText(val)
elif isinstance(val, list):
# A list of alternative values, first is selected
print("List: ", name)
continue
elif isinstance(val, bool):
widget = QCheckBox(self)
if val:
widget.setCheckState(Qt.CheckState.Checked)
else:
widget.setCheckState(Qt.CheckState.Unchecked)
elif isinstance(val, int):
widget = QLineEdit(self)
widget.setInputMask("9000000")
widget.setText(str(val).strip())
elif isinstance(val, float):
widget = QLineEdit(self)
if pstvOnly:
widget.setInputMask("0.000")
widget.setText(str(val).strip())
else:
print("Ignoring: " + name)
continue
widget.config = name
self.widgets[name] = widget
self.layout.addWidget(widget, row, 1, 1, 1)
row += 1
# Add OK and Cancel buttons
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonbox.accepted.connect(self.getValues)
buttonbox.rejected.connect(self.reject)
self.layout.addWidget(buttonbox, row, 1, 2, 1)
class DockTitleBar(QWidget, object):
def __init__(self, dock_widget, renamable=False):
super(DockTitleBar, self).__init__(dock_widget)
self._renamable = renamable
main_layout = QHBoxLayout()
main_layout.setContentsMargins(0, 0, 0, 1)
self.setLayout(main_layout)
self._buttons_box = QGroupBox('')
self._buttons_box.setObjectName('Docked')
self._buttons_layout = QHBoxLayout()
self._buttons_layout.setSpacing(1)
self._buttons_layout.setMargin(2)
self._buttons_box.setLayout(self._buttons_layout)
main_layout.addWidget(self._buttons_box)
self._title_label = QLabel(self)
self._title_label.setStyleSheet('background: transparent')
self._title_edit = QLineEdit(self)
self._title_edit.setVisible(False)
self._button_size = QSize(14, 14)
self._dock_btn = QToolButton(self)
self._dock_btn.setIcon(resources.icon('restore_window', theme='color'))
self._dock_btn.setMaximumSize(self._button_size)
self._dock_btn.setAutoRaise(True)
self._close_btn = QToolButton(self)
self._close_btn.setIcon(resources.icon('close_window', theme='color'))
self._close_btn.setMaximumSize(self._button_size)
self._close_btn.setAutoRaise(True)
self._buttons_layout.addSpacing(2)
self._buttons_layout.addWidget(self._title_label)
self._buttons_layout.addWidget(self._title_edit)
self._buttons_layout.addStretch()
self._buttons_layout.addSpacing(5)
self._buttons_layout.addWidget(self._dock_btn)
self._buttons_layout.addWidget(self._close_btn)
self._buttons_box.mouseDoubleClickEvent = self.mouseDoubleClickEvent
self._buttons_box.mousePressEvent = self.mousePressEvent
self._buttons_box.mouseMoveEvent = self.mouseMoveEvent
self._buttons_box.mouseReleaseEvent = self.mouseReleaseEvent
dock_widget.featuresChanged.connect(self._on_dock_features_changed)
self._title_edit.editingFinished.connect(self._on_finish_edit)
self._dock_btn.clicked.connect(self._on_dock_btn_clicked)
self._close_btn.clicked.connect(self._on_close_btn_clicked)
self._on_dock_features_changed(dock_widget.features())
self.set_title(dock_widget.windowTitle())
dock_widget.installEventFilter(self)
dock_widget.topLevelChanged.connect(self._on_change_floating_style)
@property
def renamable(self):
return self._renamable
@renamable.setter
def renamable(self, flag):
self._renamable = flag
def eventFilter(self, obj, event):
if event.type() == QEvent.WindowTitleChange:
self.set_title(obj.windowTitle())
return super(DockTitleBar, self).eventFilter(obj, event)
def mouseMoveEvent(self, event):
event.ignore()
def mousePressEvent(self, event):
event.ignore()
def mouseReleaseEvent(self, event):
event.ignore()
def mouseDoubleClickEvent(self, event):
if event.pos().x() <= self._title_label.width() and self._renamable:
self._start_edit()
else:
super(DockTitleBar, self).mouseDoubleClickEvent(event)
def update(self, *args, **kwargs):
self._on_change_floating_style(self.parent().isFloating())
super(DockTitleBar, self).update(*args, **kwargs)
def set_title(self, title):
self._title_label.setText(title)
self._title_edit.setText(title)
def add_button(self, button):
button.setAutoRaise(True)
button.setMaximumSize(self._button_size)
self._buttons_layout.insertWidget(5, button)
def _start_edit(self):
self._title_label.hide()
self._title_edit.show()
self._title_edit.setFocus()
def _finish_edit(self):
self._title_edit.hide()
self._title_label.show()
self.parent().setWindowTitle(self._title_edit.text())
def _on_dock_features_changed(self, features):
if not features & QDockWidget.DockWidgetVerticalTitleBar:
self._close_btn.setVisible(features
& QDockWidget.DockWidgetClosable)
self._dock_btn.setVisible(features
& QDockWidget.DockWidgetFloatable)
else:
raise ValueError('Vertical title bar is not supported!')
def _on_finish_edit(self):
self._finish_edit()
def _on_dock_btn_clicked(self):
self.parent().setFloating(not self.parent().isFloating())
def _on_close_btn_clicked(self):
self.parent().toggleViewAction().setChecked(False)
self.parent().close()
def _on_change_floating_style(self, state):
pass
class BaseFileFolderDialog(BaseDialog,
abstract_dialog.AbstractFileFolderDialog):
"""
Base dialog classes for folders and files
"""
def_title = 'Select File'
def_size = (200, 125)
def_use_app_browser = False
def __init__(self, name='BaseFileFolder', parent=None, **kwargs):
super(BaseFileFolderDialog, self).__init__(name=name, parent=parent)
self.directory = None
self.filters = None
self._use_app_browser = kwargs.pop('use_app_browser',
self.def_use_app_browser)
self.set_filters('All Files (*.*)')
# By default, we set the directory to the user folder
self.set_directory(os.path.expanduser('~'))
self.center()
def open_app_browser(self):
return
def ui(self):
super(BaseFileFolderDialog, self).ui()
from tpDcc.libs.qt.widgets import directory
self.places = dict()
self.grid = layouts.GridLayout()
sub_grid = layouts.GridLayout()
self.grid.addWidget(QLabel('Path:'), 0, 0, Qt.AlignRight)
self.path_edit = QLineEdit(self)
self.path_edit.setReadOnly(True)
self.filter_box = QComboBox(self)
self.file_edit = QLineEdit(self)
self.view = directory.FileListWidget(self)
self.view.setWrapping(True)
self.view.setFocusPolicy(Qt.StrongFocus)
self.open_button = QPushButton('Select', self)
self.cancel_button = QPushButton('Cancel', self)
size = QSize(32, 24)
self.up_button = QPushButton('Up')
self.up_button.setToolTip('Go up')
self.up_button.setMinimumSize(size)
self.up_button.setMaximumSize(size)
size = QSize(56, 24)
self.refresh_button = QPushButton('Reload')
self.refresh_button.setToolTip('Reload file list')
self.refresh_button.setMinimumSize(size)
self.refresh_button.setMaximumSize(size)
self.show_hidden = QCheckBox('Hidden')
self.show_hidden.setChecked(False)
self.show_hidden.setToolTip('Toggle show hidden files')
sub_grid.addWidget(self.up_button, 0, 1)
sub_grid.addWidget(self.path_edit, 0, 2)
sub_grid.addWidget(self.refresh_button, 0, 3)
sub_grid.addWidget(self.show_hidden, 0, 4)
self.grid.addLayout(sub_grid, 0, 1)
self.grid.addWidget(self.get_drives_widget(), 1, 0)
self.grid.addWidget(self.view, 1, 1)
self.grid.addWidget(QLabel('File name:'), 7, 0, Qt.AlignRight)
self.grid.addWidget(self.file_edit, 7, 1)
self.filter_label = QLabel('Filter:')
self.grid.addWidget(self.filter_label, 8, 0, Qt.AlignRight)
self.grid.addWidget(self.filter_box, 8, 1)
hbox = layouts.GridLayout()
hbox.addWidget(self.open_button, 0, 0, Qt.AlignRight)
hbox.addWidget(self.cancel_button, 0, 1, Qt.AlignRight)
self.grid.addLayout(hbox, 9, 1, Qt.AlignRight)
self.main_layout.addLayout(self.grid)
self.setGeometry(200, 100, 600, 400)
self.open_button.clicked.connect(self.accept)
self.cancel_button.clicked.connect(self.reject)
self.up_button.clicked.connect(self.go_up)
self.refresh_button.clicked.connect(self.update_view)
self.show_hidden.stateChanged.connect(self.update_view)
self.view.directory_activated.connect(
self.activate_directory_from_view)
self.view.file_activated.connect(self.activate_file_from_view)
self.view.file_selected.connect(self.select_file_item)
self.view.folder_selected.connect(self.select_folder_item)
self.view.up_requested.connect(self.go_up)
self.view.update_requested.connect(self.update_view)
def exec_(self, *args, **kwargs):
if self._use_app_browser:
return self.open_app_browser()
else:
self.update_view()
self.filter_box.currentIndexChanged.connect(self.update_view)
accepted = super(BaseFileFolderDialog, self).exec_()
self.filter_box.currentIndexChanged.disconnect(self.update_view)
return self.get_result() if accepted == 1 else None
def set_filters(self, filters, selected=0):
self.filter_box.clear()
filter_types = filters.split(';;')
for ft in filter_types:
extensions = string.extract(ft, '(', ')')
filter_name = string.rstrips(ft, '({})'.format(extensions))
extensions = extensions.split(' ')
self.filter_box.addItem(
'{} ({})'.format(filter_name, ','.join(extensions)),
extensions)
if 0 <= selected < self.filter_box.count():
self.filter_box.setCurrentIndex(selected)
self.filters = filters
def get_drives_widget(self):
"""
Returns a QGroupBox widget that contains all disk drivers of the PC in a vertical layout
:return: QGroupBox
"""
w = QGroupBox('')
w.setParent(self)
box = layouts.VerticalLayout()
box.setAlignment(Qt.AlignTop)
places = [(getpass.getuser(),
os.path.realpath(os.path.expanduser('~')))]
places += [
(q, q) for q in
[os.path.realpath(x.absolutePath()) for x in QDir().drives()]
]
for label, loc in places:
icon = QFileIconProvider().icon(QFileInfo(loc))
drive_btn = QRadioButton(label)
drive_btn.setIcon(icon)
drive_btn.setToolTip(loc)
drive_btn.setProperty('path', loc)
drive_btn.clicked.connect(self.go_to_drive)
self.places[loc] = drive_btn
box.addWidget(drive_btn)
w.setLayout(box)
return w
def go_to_drive(self):
"""
Updates widget to show the content of the selected disk drive
"""
sender = self.sender()
self.set_directory(sender.property('path'), False)
def get_result(self):
tf = self.file_edit.text()
sf = self.get_file_path(tf)
return sf, os.path.dirname(sf), tf.split(os.pathsep)
def get_filter_patterns(self):
"""
Get list of filter patterns that are being used by the widget
:return: list<str>
"""
idx = self.filter_box.currentIndex()
if idx >= 0:
return self.filter_box.itemData(idx)
else:
return []
def get_file_path(self, file_name):
"""
Returns file path of the given file name taking account the selected directory
:param file_name: str, name of the file without path
:return: str
"""
sname = file_name.split(os.pathsep)[0]
return os.path.realpath(
os.path.join(os.path.abspath(self.directory), sname))
# def accept(self):
# self._overlay.close()
# super(BaseFileFolderDialog, self).accept()
#
#
# def reject(self):
# self._overlay.close()
# super(BaseFileFolderDialog, self).reject()
def update_view(self):
"""
Updates file/folder view
:return:
"""
self.view.clear()
qdir = QDir(self.directory)
qdir.setNameFilters(self.get_filter_patterns())
filters = QDir.Dirs | QDir.AllDirs | QDir.Files | QDir.NoDot | QDir.NoDotDot
if self.show_hidden.isChecked():
filters = filters | QDir.Hidden
entries = qdir.entryInfoList(filters=filters,
sort=QDir.DirsFirst | QDir.Name)
file_path = self.get_file_path('..')
if os.path.exists(file_path) and file_path != self.directory:
icon = QFileIconProvider().icon(QFileInfo(self.directory))
QListWidgetItem(icon, '..', self.view, 0)
for info in entries:
icon = QFileIconProvider().icon(info)
suf = info.completeSuffix()
name, tp = (info.fileName(), 0) if info.isDir() else (
'%s%s' % (info.baseName(), '.%s' % suf if suf else ''), 1)
QListWidgetItem(icon, name, self.view, tp)
self.view.setFocus()
def set_directory(self, path, check_drive=True):
"""
Sets the directory that you want to explore
:param path: str, valid path
:param check_drive: bool,
:return:
"""
self.directory = os.path.realpath(path)
self.path_edit.setText(self.directory)
self.file_edit.setText('')
# If necessary, update selected disk driver
if check_drive:
for loc in self.places:
rb = self.places[loc]
rb.setAutoExclusive(False)
rb.setChecked(loc.lower() == self.directory.lower())
rb.setAutoExclusive(True)
self.update_view()
self.up_button.setEnabled(not self.cant_go_up())
def go_up(self):
"""
Updates the current directory to go to its parent directory
"""
self.set_directory(os.path.dirname(self.directory))
def cant_go_up(self):
"""
Checks whether we can naviage to current selected parent directory or not
:return: bool
"""
return os.path.dirname(self.directory) == self.directory
def activate_directory_from_view(self, name):
"""
Updates selected directory
:param name: str, name of the directory
"""
self.set_directory(os.path.join(self.directory, name))
def activate_file_from_view(self, name):
"""
Updates selected file text and returns its info by accepting it
:param name: str, name of the file
"""
self.select_file_item(name=name)
self.accept()
def select_file_item(self, name):
"""
Updates selected file text and returns its info by accepting it
:param name: str, name of the file
"""
self.file_edit.setText(name)
def select_folder_item(self, name):
"""
Updates selected folder text and returns its info by accepting it
:param name: str, name of the folder
"""
self.file_edit.setText(name)
class CSSEditor:
"""
Make sure to instanciate *after* creating the top level widgets of your QApplication
"""
def __init__(self, project_name):
self.project_name = project_name
self._app = QApplication.instance()
self._css_filepath = None
self.main_window = QWidget()
self.main_window.setWindowFlags(Qt.Tool)
self.main_window.setWindowTitle("CSS Editor - " + self.project_name)
self.variables = Variables()
self.variables.changed.connect(self._variables_changed)
self.variables.changed.connect(self._render_and_apply)
self.template = CSSTextEdit()
self.template.changed.connect(self._template_changed)
self.template.changed.connect(self._render_and_apply)
self.save = QPushButton('Save stylesheet to')
self.save.clicked.connect(self._save_stylesheet)
self.save_destination = QLineEdit()
self.save_destination.textChanged.connect(self._destination_changed)
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Vertical)
self.splitter.addWidget(self.variables)
self.splitter.addWidget(self.template)
layout = QGridLayout(self.main_window)
layout.addWidget(self.splitter, 0, 0, 1, 2)
layout.addWidget(self.save, 1, 0)
layout.addWidget(self.save_destination, 1, 1)
self.main_window.resize(800, 600)
self._project_dir = self._ensure_project_dir()
self._top_level_widgets = [
widget for widget in QApplication.topLevelWidgets() if
widget.windowTitle() != self.main_window.windowTitle()
]
self._variables = dict()
self._template = None
self._stylesheet = ""
self._app.aboutToQuit.connect(self._save_editor_state)
self._open()
self.save_destination.setText(self.css_filepath)
self.main_window.show()
@property
def css_filepath(self):
if self._css_filepath is None:
return self._project_dir + self.project_name + '.css'
return self._css_filepath
def _ensure_project_dir(self):
dir_ = os.path.expanduser('~/CSSEditor/' + self.project_name + '/')
if not os.path.isdir(dir_):
os.makedirs(dir_)
return dir_
def _open(self):
self.variables.blockSignals(True)
self.template.blockSignals(True)
try:
with open(self._project_dir + EDITOR_STATE, 'r') as qsseditor_file:
qsseditor = json.load(qsseditor_file)
WindowPosition.restore(self.main_window, qsseditor['window'])
self.splitter.setSizes(qsseditor['splitter'])
self._css_filepath = qsseditor.get('save_destination', self.css_filepath)
self.save_destination.setText(self._css_filepath)
with open(self._project_dir + THEME_VARIABLES, 'r') as f_variables:
self.variables.variables = json.load(f_variables)
with open(self._project_dir + THEME_TEMPLATE, 'r') as f_template:
self.template.set_plain_text(f_template.read())
except Exception as e:
pass
self.variables.blockSignals(False)
self.template.blockSignals(False)
self._template_changed()
self._variables_changed()
self._render_and_apply()
def _destination_changed(self):
self._css_filepath = self.save_destination.text()
self._save_editor_state()
def _save_editor_state(self):
with open(self._project_dir + EDITOR_STATE, 'w+') as f_qsseditor:
json.dump({
'window': WindowPosition.save(self.main_window),
'splitter': self.splitter.sizes(),
'save_destination': self.css_filepath
}, f_qsseditor)
def _template_changed(self):
template = self.template.plain_text()
with open(self._project_dir + THEME_TEMPLATE, 'w+') as f_template:
f_template.write(template)
try:
self._template = jinja2.Template(template)
except TemplateSyntaxError:
pass
def _variables_changed(self):
with open(self._project_dir + THEME_VARIABLES, 'w+') as f_variables:
f_variables.write(json.dumps(self.variables.variables, indent=2))
self._variables = dict()
for variable_name, variable_value in self.variables.variables.items():
if isinstance(variable_value, list) and len(variable_value) == 3:
self._variables[variable_name] = 'rgb({})'.format(', '.join([str(channel) for channel in variable_value]))
for variant in COLOR_VARIANTS:
channels = [str(int(channel * variant * 0.01)) for channel in variable_value]
self._variables['{}{:02d}'.format(variable_name, variant)] = 'rgb({})'.format(', '.join(channels))
else:
self._variables[variable_name] = variable_value
def _apply_style(self, style):
for widget in self._top_level_widgets:
widget.setStyleSheet(style)
def _render_and_apply(self):
self._apply_style("")
if self._template is None:
return
self._stylesheet = self._template.render(**self._variables)
self._apply_style(self._stylesheet)
def _save_stylesheet(self):
stylesheet = [
"/* GUI Bedos - CSS Template */",
"/****************************/",
"",
"/* VARIABLES",
json.dumps(self.variables.variables, indent=2),
"/****************************/",
"",
"/* TEMPLATE",
self.template.plain_text().replace('*/', '*|'),
"/****************************/",
"",
"/* ACTUAL CSS */",
"",
self._stylesheet
]
with open(self.css_filepath, 'w+') as f_stylesheet:
f_stylesheet.write('\n'.join(stylesheet))
def addAttributeSlot(self):
""" Adds a new attribute (column) to the table """
dialog = QDialog(self)
dialog.setModal(True)
dialog.setWindowTitle('Add Attribute')
layout = QVBoxLayout()
dialog.setLayout(layout)
form = QFormLayout()
nameBox = QLineEdit()
typeCombo = QComboBox()
for attrType in _attrTypes:
typeName = partio.TypeName(attrType)
typeCombo.addItem(typeName)
typeCombo.setCurrentIndex(partio.FLOAT)
countBox = QLineEdit()
countBox.setValidator(QIntValidator())
countBox.setText('1')
fixedCheckbox = QCheckBox()
valueBox = QLineEdit()
valueBox.setText('0')
form.addRow('Name:', nameBox)
form.addRow('Type:', typeCombo)
form.addRow('Count:', countBox)
form.addRow('Fixed:', fixedCheckbox)
form.addRow('Default Value:', valueBox)
layout.addLayout(form)
buttons = QHBoxLayout()
layout.addLayout(buttons)
add = QPushButton('Add')
add.clicked.connect(dialog.accept)
buttons.addWidget(add)
cancel = QPushButton('Cancel')
cancel.clicked.connect(dialog.reject)
buttons.addWidget(cancel)
if not dialog.exec_():
return
name = str(nameBox.text())
if not name:
print('Please supply a name for the new attribute') # TODO: prompt
return
attrType = typeCombo.currentIndex()
count = int(countBox.text())
fixed = fixedCheckbox.isChecked()
values = list(str(valueBox.text()).strip().split())
for i in range(count):
if i < len(values):
value = values[i]
else:
value = values[-1]
if attrType == partio.INT or attrType == partio.INDEXEDSTR:
values[i] = int(value)
elif attrType == partio.FLOAT or attrType == partio.VECTOR:
values[i] = float(value) # pylint:disable=R0204
else:
values[i] = 0.0 # pylint:disable=R0204
value = tuple(values)
self.data.addAttribute(name, attrType, count, fixed, value)
def _addQLineEditBox(self, label): lineEdit = QLineEdit() lineEdit.setText(label) return lineEdit
class MainWindow(QMainWindow):
def __init__(self, url):
super().__init__()
self.setAttribute(Qt.WA_DeleteOnClose, True)
self.progress = 0
f = QFile()
f.setFileName(":/jquery.min.js")
f.open(QIODevice.ReadOnly)
self.jQuery = f.readAll().data().decode()
self.jQuery += "\nvar qt = { 'jQuery': jQuery.noConflict(true) };"
f.close()
self.view = QWebEngineView(self)
self.view.load(url)
self.view.loadFinished.connect(self.adjustLocation)
self.view.titleChanged.connect(self.adjustTitle)
self.view.loadProgress.connect(self.setProgress)
self.view.loadFinished.connect(self.finishLoading)
self.locationEdit = QLineEdit(self)
self.locationEdit.setSizePolicy(
QSizePolicy.Expanding,
self.locationEdit.sizePolicy().verticalPolicy())
self.locationEdit.returnPressed.connect(self.changeLocation)
toolBar = self.addToolBar(self.tr("Navigation"))
toolBar.addAction(self.view.pageAction(QWebEnginePage.Back))
toolBar.addAction(self.view.pageAction(QWebEnginePage.Forward))
toolBar.addAction(self.view.pageAction(QWebEnginePage.Reload))
toolBar.addAction(self.view.pageAction(QWebEnginePage.Stop))
toolBar.addWidget(self.locationEdit)
viewMenu = self.menuBar().addMenu(self.tr("&View"))
viewSourceAction = QAction(self.tr("Page Source"), self)
viewSourceAction.triggered.connect(self.viewSource)
viewMenu.addAction(viewSourceAction)
effectMenu = self.menuBar().addMenu(self.tr("&Effect"))
effectMenu.addAction(self.tr("Highlight all links"),
self.highlightAllLinks)
self.rotateAction = QAction(self)
self.rotateAction.setIcon(self.style().standardIcon(
QStyle.SP_FileDialogDetailedView))
self.rotateAction.setCheckable(True)
self.rotateAction.setText(self.tr("Turn images upside down"))
self.rotateAction.toggled.connect(self.rotateImages)
effectMenu.addAction(self.rotateAction)
toolsMenu = self.menuBar().addMenu(self.tr("&Tools"))
toolsMenu.addAction(self.tr("Remove GIF images"), self.removeGifImages)
toolsMenu.addAction(self.tr("Remove all inline frames"),
self.removeInlineFrames)
toolsMenu.addAction(self.tr("Remove all object elements"),
self.removeObjectElements)
toolsMenu.addAction(self.tr("Remove all embedded elements"),
self.removeEmbeddedElements)
self.setCentralWidget(self.view)
@Slot()
def adjustLocation(self):
self.locationEdit.setText(self.view.url().toString())
@Slot()
def changeLocation(self):
url = QUrl.fromUserInput(self.locationEdit.text())
self.view.load(url)
self.view.setFocus()
@Slot()
def adjustTitle(self):
if self.progress <= 0 or self.progress >= 100:
self.setWindowTitle(self.view.title())
else:
self.setWindowTitle("%s (%2d)" %
(self.view.title(), self.progress))
@Slot(int)
def setProgress(self, p):
self.progress = p
self.adjustTitle()
@Slot()
def finishLoading(self):
self.progress = 100
self.adjustTitle()
self.view.page().runJavaScript(self.jQuery)
self.rotateImages(self.rotateAction.isChecked())
@Slot()
def viewSource(self):
self.textEdit = QTextEdit()
self.textEdit.setAttribute(Qt.WA_DeleteOnClose)
self.textEdit.adjustSize()
self.textEdit.move(self.geometry().center() -
self.textEdit.rect().center())
self.textEdit.show()
self.view.page().toHtml(self.textEdit.setPlainText)
@Slot()
def highlightAllLinks(self):
code = "qt.jQuery('a').each( function () { qt.jQuery(this).css('background-color', 'yellow') } )"
self.view.page().runJavaScript(code)
@Slot(bool)
def rotateImages(self, invert):
code = ""
if invert:
code = "qt.jQuery('img').each( function () { qt.jQuery(this).css('transition', 'transform 2s'); qt.jQuery(this).css('transform', 'rotate(180deg)') } )" # noqa: E501
else:
code = "qt.jQuery('img').each( function () { qt.jQuery(this).css('transition', 'transform 2s'); qt.jQuery(this).css('transform', 'rotate(0deg)') } )" # noqa: E501
self.view.page().runJavaScript(code)
@Slot()
def removeGifImages(self):
code = "qt.jQuery('[src*=gif]').remove()"
self.view.page().runJavaScript(code)
@Slot()
def removeInlineFrames(self):
code = "qt.jQuery('iframe').remove()"
self.view.page().runJavaScript(code)
@Slot()
def removeObjectElements(self):
code = "qt.jQuery('object').remove()"
self.view.page().runJavaScript(code)
@Slot()
def removeEmbeddedElements(self):
code = "qt.jQuery('embed').remove()"
self.view.page().runJavaScript(code)
class RowTableWidget(QFrame):
double_clicked = Signal(object)
def __init__(self,
auto_resize=False,
single_row_select=True,
context_menu_callback=None,
last_column_stretch=True,
has_counters=False,
parent=None
):
QFrame.__init__(self, parent)
self._has_counters = has_counters
self.model = None
self.table_view = RowTableView(auto_resize, single_row_select, context_menu_callback, last_column_stretch)
self.table_view.doubleClicked.connect(self._double_clicked)
if has_counters:
self.counters = Counters()
self.counters.button_clicked.connect(self._counter_clicked)
self.search_bar = QLineEdit()
self.search_bar.setFixedHeight(SEARCHBAR_HEIGHT)
self.search_bar.textChanged.connect(self.set_search_text)
self.search_bar.setToolTip("Search bar")
self.auto_size_button = QPushButton('<>')
self.auto_size_button.setFixedSize(SEARCHBAR_HEIGHT, SEARCHBAR_HEIGHT)
self.auto_size_button.clicked.connect(self._auto_size_clicked)
self.auto_size_button.setToolTip("Auto size")
self.status_label = QLabel(STATUS_LABEL_MESSAGE.format(0, 0))
self.status_label.setFixedWidth(STATUS_LABEL_WIDTH)
self.progress_bar = QProgressBar()
self.progress_bar.setFormat('')
layout = QGridLayout()
layout.addWidget(self.search_bar, 0, 0, 1, 3)
layout.addWidget(self.auto_size_button, 0, 3)
if has_counters:
layout.addWidget(self.counters, 1, 0, 1, 2)
layout.addWidget(self.table_view, 1, 2, 1, 2)
else:
layout.addWidget(self.table_view, 1, 0, 1, 4)
layout.addWidget(self.status_label, 2, 0)
layout.addWidget(self.progress_bar, 2, 1, 1, 3)
layout.setColumnStretch(2, 100)
self.setLayout(layout)
def set_model(self, model):
self.model = model
self.table_view.setModel(model)
model.modelReset.connect(self._set_progress_maximum)
model.modelReset.connect(self._update_status)
if self._has_counters:
model.modelReset.connect(self._update_counters)
self._update_counters()
model.progress_updated.connect(self._update_progress)
self._set_progress_maximum()
self._update_status()
self.progress_bar.setVisible(model.has_background_callback)
@property
def selected_rows(self):
return [self.model.data(index, Qt.UserRole) for index
in self.table_view.selectionModel().selectedIndexes() if index.column() == 0]
@property
def search_text(self):
return self.search_bar.text()
def set_search_text(self, text):
self.search_bar.blockSignals(True)
self.search_bar.setText(text)
self.search_bar.blockSignals(False)
self.model.set_search_text(text)
def _set_progress_maximum(self):
self.progress_bar.setMaximum(self.model.progress_max) # do better ?
def _update_progress(self, value):
self.progress_bar.setValue(value)
def _update_status(self):
self.status_label.setText(STATUS_LABEL_MESSAGE.format(
self.model.rowCount(), self.model.total_row_count
))
def _counter_clicked(self, entry, checked_buttons):
entries = [entry for entry, active in checked_buttons.items() if active]
self.model.set_search_counters(entries)
def _update_counters(self):
self.counters.set(self.model.counters)
def _auto_size_clicked(self):
with Hourglass():
self.table_view.resizeColumnsToContents()
def _double_clicked(self, index):
row = self.model.data(index, Qt.UserRole)
self.double_clicked.emit(row)
def state(self):
header_sizes = list()
header = self.table_view.horizontalHeader()
for section_index in range(header.count()):
header_sizes.append(header.sectionSize(section_index))
return {
'header_sizes': header_sizes,
'search_text': self.search_bar.text()
}
def load_state(self, state):
header = self.table_view.horizontalHeader()
for section_index, size in enumerate(state['header_sizes']):
header.resizeSection(section_index, size)
self.search_bar.setText(state['search_text'])
class LibAdd(ToolInstance):
help = "https://github.com/QChASM/SEQCROW/wiki/Add-to-Personal-Library-Tool"
SESSION_ENDURING = False
SESSION_SAVE = False
def __init__(self, session, name):
super().__init__(session, name)
from chimerax.ui import MainToolWindow
self.tool_window = MainToolWindow(self)
self.key_atomspec = []
self._build_ui()
def _build_ui(self):
layout = QGridLayout()
library_tabs = QTabWidget()
#ligand tab
ligand_tab = QWidget()
ligand_layout = QFormLayout(ligand_tab)
self.ligand_name = QLineEdit()
self.ligand_name.setText("")
self.ligand_name.setPlaceholderText("leave blank to preview")
self.ligand_name.setToolTip(
"name of ligand you are adding to your ligand library\nleave blank to open a new model with just the ligand"
)
ligand_layout.addRow("ligand name:", self.ligand_name)
ligand_key_atoms = QPushButton("set key atoms to current selection")
ligand_key_atoms.clicked.connect(self.update_key_atoms)
ligand_key_atoms.setToolTip(
"the current selection will be the key atoms for the ligand\nleave blank to automatically determine key atoms"
)
ligand_layout.addRow(ligand_key_atoms)
libadd_ligand = QPushButton("add current selection to library")
libadd_ligand.clicked.connect(self.libadd_ligand)
ligand_layout.addRow(libadd_ligand)
#substituent tab
sub_tab = QWidget()
sub_layout = QFormLayout(sub_tab)
self.sub_name = QLineEdit()
self.sub_name.setText("")
self.sub_name.setPlaceholderText("leave blank to preview")
self.sub_name.setToolTip(
"name of substituent you are adding to your substituent library\nleave blank to open a new model with just the substituent"
)
sub_layout.addRow("substituent name:", self.sub_name)
self.sub_confs = QSpinBox()
self.sub_confs.setMinimum(1)
sub_layout.addRow("number of conformers:", self.sub_confs)
self.sub_angle = QSpinBox()
self.sub_angle.setRange(0, 180)
self.sub_angle.setSingleStep(30)
sub_layout.addRow("angle between conformers:", self.sub_angle)
libadd_sub = QPushButton("add current selection to library")
libadd_sub.clicked.connect(self.libadd_substituent)
sub_layout.addRow(libadd_sub)
#ring tab
ring_tab = QWidget()
ring_layout = QFormLayout(ring_tab)
self.ring_name = QLineEdit()
self.ring_name.setText("")
self.ring_name.setPlaceholderText("leave blank to preview")
self.ring_name.setToolTip(
"name of ring you are adding to your ring library\nleave blank to open a new model with just the ring"
)
ring_layout.addRow("ring name:", self.ring_name)
libadd_ring = QPushButton("add ring with selected walk to library")
libadd_ring.clicked.connect(self.libadd_ring)
ring_layout.addRow(libadd_ring)
library_tabs.addTab(sub_tab, "substituent")
library_tabs.addTab(ring_tab, "ring")
library_tabs.addTab(ligand_tab, "ligand")
self.library_tabs = library_tabs
layout.addWidget(library_tabs)
whats_this = QLabel()
whats_this.setText(
"<a href=\"req\" style=\"text-decoration: none;\">what's this?</a>"
)
whats_this.setTextFormat(Qt.RichText)
whats_this.setTextInteractionFlags(Qt.TextBrowserInteraction)
whats_this.linkActivated.connect(self.open_link)
whats_this.setToolTip(
"click for more information about AaronTools libraries")
layout.addWidget(whats_this)
self.tool_window.ui_area.setLayout(layout)
self.tool_window.manage(None)
def update_key_atoms(self):
selection = selected_atoms(self.session)
if not selection.single_structure:
raise RuntimeError("selected atoms must be on the same model")
else:
self.key_atomspec = selection
self.tool_window.status("key atoms set to %s" %
" ".join(atom.atomspec for atom in selection))
def libadd_ligand(self):
"""add ligand to library or open it in a new model"""
selection = selected_atoms(self.session)
if not selection.single_structure:
raise RuntimeError("selected atoms must be on the same model")
rescol = ResidueCollection(selection[0].structure)
ligand_atoms = [
atom for atom in rescol.atoms if atom.chix_atom in selection
]
key_chix_atoms = [
atom for atom in self.key_atomspec if not atom.deleted
]
if len(key_chix_atoms) < 1:
key_atoms = set([])
for atom in ligand_atoms:
for atom2 in atom.connected:
if atom2 not in ligand_atoms:
key_atoms.add(atom)
else:
key_atoms = rescol.find(
[AtomSpec(atom.atomspec) for atom in key_chix_atoms])
if len(key_atoms) < 1:
raise RuntimeError("no key atoms could be determined")
lig_name = self.ligand_name.text()
ligand = Component(ligand_atoms, name=lig_name, key_atoms=key_atoms)
ligand.comment = "K:%s" % ",".join(
[str(ligand.atoms.index(atom) + 1) for atom in key_atoms])
if len(lig_name) == 0:
chimerax_ligand = ResidueCollection(ligand).get_chimera(
self.session)
chimerax_ligand.name = "ligand preview"
self.session.models.add([chimerax_ligand])
bild_obj = key_atom_highlight(ligand, [0.2, 0.5, 0.8, 0.5],
self.session)
self.session.models.add(bild_obj, parent=chimerax_ligand)
else:
check_aaronlib_dir()
filename = os.path.join(AARONLIB, "Ligands", lig_name + ".xyz")
if os.path.exists(filename):
exists_warning = QMessageBox()
exists_warning.setIcon(QMessageBox.Warning)
exists_warning.setText(
"%s already exists.\nWould you like to overwrite?" %
filename)
exists_warning.setStandardButtons(QMessageBox.Yes
| QMessageBox.No)
rv = exists_warning.exec_()
if rv == QMessageBox.Yes:
ligand.write(outfile=filename)
self.tool_window.status("%s added to ligand library" %
lig_name)
else:
self.tool_window.status(
"%s has not been added to ligand library" % lig_name)
else:
ligand.write(outfile=filename)
self.tool_window.status("%s added to ligand library" %
lig_name)
def libadd_ring(self):
"""add ring to library or open it in a new model"""
selection = self.session.seqcrow_ordered_selection_manager.selection
if not selection.single_structure:
raise RuntimeError("selected atoms must be on the same model")
rescol = ResidueCollection(selection[0].structure)
walk_atoms = rescol.find(
[AtomSpec(atom.atomspec) for atom in selection])
if len(walk_atoms) < 1:
raise RuntimeError("no walk direction could be determined")
ring_name = self.ring_name.text()
ring = Ring(rescol, name=ring_name, end=walk_atoms)
ring.comment = "E:%s" % ",".join(
[str(rescol.atoms.index(atom) + 1) for atom in walk_atoms])
if len(ring_name) == 0:
chimerax_ring = ResidueCollection(ring).get_chimera(self.session)
chimerax_ring.name = "ring preview"
self.session.models.add([chimerax_ring])
bild_obj = show_walk_highlight(ring, chimerax_ring,
[0.9, 0.4, 0.3, 0.9], self.session)
self.session.models.add(bild_obj, parent=chimerax_ring)
else:
check_aaronlib_dir()
filename = os.path.join(AARONLIB, "Rings", ring_name + ".xyz")
if os.path.exists(filename):
exists_warning = QMessageBox()
exists_warning.setIcon(QMessageBox.Warning)
exists_warning.setText(
"%s already exists.\nWould you like to overwrite?" %
filename)
exists_warning.setStandardButtons(QMessageBox.Yes
| QMessageBox.No)
rv = exists_warning.exec_()
if rv == QMessageBox.Yes:
ring.write(outfile=filename)
self.tool_window.status("%s added to ring library" %
ring_name)
else:
self.tool_window.status(
"%s has not been added to ring library" % ring_name)
else:
ring.write(outfile=filename)
self.tool_window.status("%s added to ring library" % ring_name)
def libadd_substituent(self):
"""add ligand to library or open it in a new model"""
selection = selected_atoms(self.session)
if not selection.single_structure:
raise RuntimeError("selected atoms must be on the same model")
residues = []
for atom in selection:
if atom.residue not in residues:
residues.append(atom.residue)
rescol = ResidueCollection(selection[0].structure,
convert_residues=residues)
substituent_atoms = [
atom for atom in rescol.atoms if atom.chix_atom in selection
]
start = None
avoid = None
for atom in substituent_atoms:
for atom2 in atom.connected:
if atom2 not in substituent_atoms:
if start is None:
start = atom
avoid = atom2
else:
raise RuntimeError(
"substituent must only have one connection to the molecule"
)
if start is None:
raise RuntimeError(
"substituent is not connected to a larger molecule")
substituent_atoms.remove(start)
substituent_atoms.insert(0, start)
sub_name = self.sub_name.text()
confs = self.sub_confs.value()
angle = self.sub_angle.value()
comment = "CF:%i,%i" % (confs, angle)
if len(sub_name) == 0:
sub = Substituent(substituent_atoms,
name="test",
conf_num=confs,
conf_angle=angle)
else:
sub = Substituent(substituent_atoms,
name=sub_name,
conf_num=confs,
conf_angle=angle)
sub.comment = comment
#align substituent bond to x axis
sub.coord_shift(-avoid.coords)
x_axis = np.array([1., 0., 0.])
n = np.linalg.norm(start.coords)
vb = start.coords / n
d = np.linalg.norm(vb - x_axis)
theta = np.arccos((d**2 - 2) / -2)
vx = np.cross(vb, x_axis)
sub.rotate(vx, theta)
add = False
if len(sub_name) == 0:
chimerax_sub = ResidueCollection(sub).get_chimera(self.session)
chimerax_sub.name = "substituent preview"
self.session.models.add([chimerax_sub])
bild_obj = ghost_connection_highlight(
sub, [0.60784, 0.145098, 0.70196, 0.5], self.session)
self.session.models.add(bild_obj, parent=chimerax_sub)
else:
check_aaronlib_dir()
filename = os.path.join(AARONLIB, "Subs", sub_name + ".xyz")
if os.path.exists(filename):
exists_warning = QMessageBox()
exists_warning.setIcon(QMessageBox.Warning)
exists_warning.setText(
"%s already exists.\nWould you like to overwrite?" %
filename)
exists_warning.setStandardButtons(QMessageBox.Yes
| QMessageBox.No)
rv = exists_warning.exec_()
if rv == QMessageBox.Yes:
add = True
else:
self.tool_window.status(
"%s has not been added to substituent library" %
sub_name)
else:
add = True
if add:
sub.write(outfile=filename)
self.tool_window.status("%s added to substituent library" %
sub_name)
register_selectors(self.session.logger, sub_name)
if self.session.ui.is_gui:
if (sub_name not in ELEMENTS and sub_name[0].isalpha()
and (len(sub_name) > 1
and not any(not (c.isalnum() or c in "+-")
for c in sub_name[1:]))):
add_submenu = self.session.ui.main_window.add_select_submenu
add_selector = self.session.ui.main_window.add_menu_selector
substituent_menu = add_submenu(['Che&mistry'],
'Substituents')
add_selector(substituent_menu, sub_name, sub_name)
def display_help(self):
"""Show the help for this tool in the help viewer."""
from chimerax.core.commands import run
run(self.session,
'open %s' % self.help if self.help is not None else "")
def open_link(self, *args):
if self.library_tabs.currentIndex() == 0:
link = "https://github.com/QChASM/AaronTools.py/wiki/AaronTools-Libraries#substituents"
elif self.library_tabs.currentIndex() == 1:
link = "https://github.com/QChASM/AaronTools.py/wiki/AaronTools-Libraries#rings"
elif self.library_tabs.currentIndex() == 2:
link = "https://github.com/QChASM/AaronTools.py/wiki/AaronTools-Libraries#ligands"
run(self.session, "open %s" % link)
def addAttributeSlot(self):
""" Adds a new attribute (column) to the table """
dialog = QDialog(self)
dialog.setModal(True)
dialog.setWindowTitle('Add Attribute')
layout = QVBoxLayout()
dialog.setLayout(layout)
form = QFormLayout()
nameBox = QLineEdit()
typeCombo = QComboBox()
for attrType in _attrTypes:
typeName = partio.TypeName(attrType)
typeCombo.addItem(typeName)
typeCombo.setCurrentIndex(partio.FLOAT)
countBox = QLineEdit()
countBox.setValidator(QIntValidator())
countBox.setText('1')
fixedCheckbox = QCheckBox()
valueBox = QLineEdit()
valueBox.setText('0')
form.addRow('Name:', nameBox)
form.addRow('Type:', typeCombo)
form.addRow('Count:', countBox)
form.addRow('Fixed:', fixedCheckbox)
form.addRow('Default Value:', valueBox)
layout.addLayout(form)
buttons = QHBoxLayout()
layout.addLayout(buttons)
add = QPushButton('Add')
add.clicked.connect(dialog.accept)
buttons.addWidget(add)
cancel = QPushButton('Cancel')
cancel.clicked.connect(dialog.reject)
buttons.addWidget(cancel)
if not dialog.exec_():
return
name = str(nameBox.text())
if not name:
print 'Please supply a name for the new attribute' # TODO: prompt
return
attrType = typeCombo.currentIndex()
count = int(countBox.text())
fixed = fixedCheckbox.isChecked()
values = list(str(valueBox.text()).strip().split())
for i in range(count):
if i < len(values):
value = values[i]
else:
value = values[-1]
if attrType == partio.INT or attrType == partio.INDEXEDSTR:
values[i] = int(value)
elif attrType == partio.FLOAT or attrType == partio.VECTOR:
values[i] = float(value) # pylint:disable=R0204
else:
values[i] = 0.0 # pylint:disable=R0204
value = tuple(values)
self.data.addAttribute(name, attrType, count, fixed, value)
class EditableTabBar(QTabBar, object):
"""
Basic implementation of an editable tab bar
"""
addTabClicked = Signal()
tabRenamed = Signal(object, object, object)
def __init__(self, parent=None):
super(EditableTabBar, self).__init__(parent=parent)
self._is_editable = True
self._editor = QLineEdit(self)
self._editor.setWindowFlags(Qt.Popup)
self._editor.setFocusProxy(self)
self._editor.editingFinished.connect(self.handle_editing_finished)
self._editor.installEventFilter(self)
self.add_tab_btn = EditableAddButton(parent=self)
self._move_add_tab_btn()
self.setDrawBase(False)
self.add_tab_btn.clicked.connect(self.addTabClicked.emit)
def is_editable(self):
"""
Returns whether the tab bar enables rename mode when the user double clicks on the tab
:return: bool
"""
return self._is_editable
def set_is_editable(self, flag):
"""
Sets whether the tabs are editable or not
:param flag: bool
"""
self._is_editable = bool(flag)
def edit_tab(self, index):
"""
Function that is called when the tab is going to be edited
:param index:
:return:
"""
if not self._is_editable:
return
rect = self.tabRect(index)
self._editor.setFixedSize(rect.size())
self._editor.move(self.parent().mapToGlobal(rect.topLeft()))
self._editor.setText(self.tabText(index))
self._editor.selectAll()
if not self._editor.isVisible():
self._editor.show()
def handle_editing_finished(self):
"""
Function that is called when the tab edit has been completed
"""
index = self.currentIndex()
if index >= 0:
self._editor.hide()
for i in range(self.count()):
if self.tabText(i) == self._editor.text():
LOGGER.warning(
'Impossible to rename category because exists a tab with the same name!'
)
return
old_name = self.tabText(index)
self.setTabText(index, self._editor.text())
self.tabRenamed.emit(index, self.tabText(index), old_name)
def sizeHint(self):
"""
Return the size of the tab bar with increased width for the add tab button
:return: QSize, size of the tab bar
"""
size_hint = super(EditableTabBar, self).sizeHint()
return QSize(size_hint.width() + 25, size_hint.height())
def resizeEvent(self, event):
"""
Resize the widget and make sure the add tab button is in the correct location
"""
super(EditableTabBar, self).resizeEvent(event)
self._move_add_tab_btn()
def tabLayoutChange(self):
"""
This virtual handler is called whenever the tab layout changes.
If anything changes make sure the add char btn is in the correct location
"""
super(EditableTabBar, self).tabLayoutChange()
self._move_add_tab_btn()
def eventFilter(self, widget, event):
if ((event.type() == QEvent.MouseButtonPress
and not self._editor.geometry().contains(event.globalPos()))
or (event.type() == QEvent.KeyPress
and event.key() == Qt.Key_Escape)):
self._editor.hide()
return True
return QTabBar.eventFilter(self, widget, event)
def mouseDoubleClickEvent(self, event):
index = self.tabAt(event.pos())
if index >= 0:
if not self._is_editable:
return
self.edit_tab(index)
def _move_add_tab_btn(self):
"""
Move the add tab button to the correct location
"""
# Find the width of all of the tabs
size = sum([self.tabRect(i).width() for i in range(self.count())])
# Set the add tab button location in a visible area
h = self.geometry().top()
w = self.width()
if size > w:
self.add_tab_btn.move(w - 50, h)
else:
self.add_tab_btn.move(size, h)
class EditableTearOffTabBar(TearOffTabBar, object):
"""
Extended implementation of an editable tab bar with:
- Rename functionality
- Tear off functionality
"""
tab_label_renamed = Signal(str, str)
request_remove = Signal(int)
tab_changed = Signal(int)
def __init__(self, parent=None):
super(EditableTearOffTabBar, self).__init__(parent=parent)
self._editor = QLineEdit(self)
self._editor.setWindowFlags(Qt.Popup)
self._editor.setFocusProxy(self)
self._editor.setFocusPolicy(Qt.StrongFocus)
self._editor.editingFinished.connect(self.handle_editing_finished)
self._editor.installEventFilter(self)
self._editor.setValidator(QRegExpValidator(nameRegExp))
self._edit_index = -1
def edit_tab(self, index):
"""
This set the tab in edit mode
This method is called when double click on the tab
:param index: int, Index of the tab to be renamed
"""
# Show the editable line and position it on top of the selected tab
rect = self.tabRect(index)
self._editor.setFixedSize(rect.size())
self._editor.move(self.parent().mapToGlobal(rect.topLeft()))
self._editor.setText(self.tabText(index))
if not self._editor.isVisible():
self._editor.show()
self._edit_index = index
def handle_editing_finished(self):
"""
This finish the edit of the tab name
"""
# This method only works of we are editing any tab
if self._edit_index >= 0:
# Hide the text and update tab text
self._editor.hide()
old_text = self.tabText(self.__editIndex)
new_text = self._editor.text()
if old_text != new_text:
names = [self.tabText(i) for i in range(self.count())]
new_text = naming.get_numeric_name(new_text, names)
self.setTabText(self._edit_index, new_text)
self.tab_label_renamed.emit(old_text, new_text)
self._edit_index = -1
def eventFilter(self, widget, event):
"""
If we click (with mouse or keyboard) on registered widgets we hide the editor
"""
if event.type(
) == QEvent.MouseButtonPress and not self._editor.geometry().contains(
event.globalPos()) or event.type(
) == QEvent.KeyPress and event.key() == Qt.Key_Escape:
self._editor.hide()
return False
return QTabBar.eventFilter(self, widget, event)