def createInputWidgets(self, propertiesWidget):
inputsCategory = super(UIConstantNode,
self).createInputWidgets(propertiesWidget)
selector = QComboBox()
overrideType = QCheckBox()
for i in self._rawNode.pinTypes:
selector.addItem(i)
if self.input.dataType in self._rawNode.pinTypes:
selector.setCurrentIndex(
self._rawNode.pinTypes.index(self.input.dataType))
structSelector = QComboBox()
for i in [i.name for i in list(PinStructure)]:
structSelector.addItem(i)
overrideType.setChecked(self.input._rawPin.changeTypeOnConnection)
structSelector.setCurrentIndex(self.input._rawPin._currStructure)
selector.setEnabled(self.input._rawPin.changeTypeOnConnection)
overrideType.stateChanged.connect(selector.setEnabled)
overrideType.stateChanged.connect(self._rawNode.overrideTypeChanged)
selector.activated.connect(self._rawNode.updateType)
structSelector.activated.connect(self._rawNode.selectStructure)
structSelector.activated.connect(self.selectStructure)
inputsCategory.insertWidget(0, "DataType", selector)
inputsCategory.insertWidget(1, "Change Type On Connection",
overrideType)
inputsCategory.insertWidget(1, "Structure", structSelector)
def createInputWidgets(self, inputsCategory, group=None, pins=True):
if pins:
super(UIMakeDictNode, self).createInputWidgets(inputsCategory, group)
selector = QComboBox()
for i in self.input._rawPin._defaultSupportedDataTypes:
selector.addItem(i)
selector.setCurrentIndex(self.input._rawPin._defaultSupportedDataTypes.index(
self.input._rawPin.dataType))
selector.activated.connect(self.changeType)
inputsCategory.insertWidget(0, "DataType", selector, group=group)
def createInputWidgets(self, inputsCategory, group=None, pins=True):
preIndex = inputsCategory.Layout.count()
if pins:
super(UIConvertToNode, self).createInputWidgets(inputsCategory, group)
selector = QComboBox()
for i in self._rawNode.pinTypes:
selector.addItem(i)
if self.output.dataType in self._rawNode.pinTypes:
selector.setCurrentIndex(
self._rawNode.pinTypes.index(self.output.dataType))
selector.activated.connect(self._rawNode.updateType)
inputsCategory.insertWidget(preIndex, "DataType", selector, group=group)
class EnumInputWidget(InputWidgetSingle):
"""
Enum input widget
"""
def __init__(self, parent=None, **kwds):
super(EnumInputWidget, self).__init__(parent=parent, **kwds)
# self._userStruct = kwds['userStructClass']
self.cb = QComboBox(self)
self.setWidget(self.cb)
for i in list(kwds['userStructClass']):
self.cb.addItem(i.name, i.value)
self.cb.currentIndexChanged[int].connect(self.dataSetCallback)
def setWidgetValue(self, val):
self.cb.setCurrentIndex(val)
def onUpdatePropertyView(self, formLayout):
# name
le_name = QLineEdit(self.name)
le_name.returnPressed.connect(lambda: self.setName(le_name.text()))
formLayout.addRow("Name", le_name)
# data type
cbTypes = VarTypeComboBox(self)
formLayout.addRow("Type", cbTypes)
# current value
def valSetter(x):
self.value = x
w = InputWidgets.getInputWidget(
self.dataType, valSetter,
Pins.getPinDefaultValueByType(self.dataType), None)
if w:
w.setWidgetValue(self.value)
w.setObjectName(self.name)
formLayout.addRow(self.name, w)
# access level
cb = QComboBox()
cb.addItem('public', 0)
cb.addItem('private', 1)
cb.addItem('protected', 2)
def accessLevelChanged(x):
self.accessLevel = x
cb.currentIndexChanged[int].connect(accessLevelChanged)
cb.setCurrentIndex(self.accessLevel)
formLayout.addRow('Access level', cb)
def createPropertiesWidget(self, propertiesWidget):
baseCategory = CollapsibleFormWidget(headName="Base", modify=True)
# name
le_name = QLineEdit(self._rawVariable.name)
le_name.returnPressed.connect(lambda: self.setName(le_name.text()))
baseCategory.addWidget("Name", le_name)
# data type
cbTypes = EnumComboBox([
pin.__name__ for pin in getAllPinClasses() if pin.IsValuePin()
if pin.__name__ != "AnyPin"
])
cbTypes.setCurrentIndex(cbTypes.findText(self.dataType))
cbTypes.setEditable(False)
cbTypes.changeCallback.connect(self.setDataType)
propertiesWidget.addWidget(baseCategory)
# structure type
cbStructure = EnumComboBox(
[i.name for i in (PinStructure.Single, PinStructure.Array)])
cbStructure.setEditable(False)
cbStructure.setCurrentIndex(
cbStructure.findText(self._rawVariable.structure.name))
cbStructure.changeCallback.connect(self.onStructureChanged)
propertiesWidget.addWidget(baseCategory)
baseCategory.addWidget("Type", cbTypes)
baseCategory.addWidget("Structure", cbStructure)
valueCategory = CollapsibleFormWidget(headName="Value")
# current value
if self._rawVariable.structure == PinStructure.Single:
if not type(self._rawVariable.value) in {list, set, dict, tuple}:
def valSetter(x):
self._rawVariable.value = x
w = createInputWidget(
self._rawVariable.dataType, valSetter,
getPinDefaultValueByType(self._rawVariable.dataType))
if w:
w.setWidgetValue(self._rawVariable.value)
w.setObjectName(self._rawVariable.name)
valueCategory.addWidget(self._rawVariable.name, w)
# access level
cb = QComboBox()
cb.addItem('public', 0)
cb.addItem('private', 1)
cb.addItem('protected', 2)
def accessLevelChanged(x):
self._rawVariable.accessLevel = AccessLevel[x]
EditorHistory().saveState("Change variable access level",
modify=True)
cb.currentTextChanged.connect(accessLevelChanged)
cb.setCurrentIndex(self._rawVariable.accessLevel)
valueCategory.addWidget('Access level', cb)
propertiesWidget.addWidget(valueCategory)
def createInputWidgets(self, inputsCategory, group=None, pins=True):
inputVal = None
preIndex = inputsCategory.Layout.count()
if pins:
super(UIConstantNode,
self).createInputWidgets(inputsCategory, group)
inputVal = inputsCategory.getWidgetByName("in")
selector = QComboBox()
for i in self._rawNode.pinTypes:
selector.addItem(i)
if self.input.dataType in self._rawNode.pinTypes:
selector.setCurrentIndex(
self._rawNode.pinTypes.index(self.input.dataType))
structSelector = QComboBox()
for i in [i.name for i in list(PinStructure)]:
structSelector.addItem(i)
structSelector.inputsCategory = inputsCategory
structSelector.setCurrentIndex(self.input._rawPin._currStructure)
selector.activated.connect(self._rawNode.updateType)
selector.activated.connect(
lambda: self.updateType(inputVal, inputsCategory, group))
structSelector.activated.connect(self._rawNode.selectStructure)
structSelector.activated.connect(
lambda: self.selectStructure(inputVal, inputsCategory, group))
inputsCategory.insertWidget(preIndex,
"DataType",
selector,
group=group)
inputsCategory.insertWidget(preIndex + 1,
"Structure",
structSelector,
group=group)
def createPropertiesWidget(self, propertiesWidget):
baseCategory = CollapsibleFormWidget(headName="Base")
# name
le_name = QLineEdit(self._rawVariable.name)
le_name.returnPressed.connect(lambda: self.setName(le_name.text()))
baseCategory.addWidget("Name", le_name)
# data type
cbTypes = VarTypeComboBox(self)
baseCategory.addWidget("Type", cbTypes)
propertiesWidget.addWidget(baseCategory)
valueCategory = CollapsibleFormWidget(headName="Value")
# current value
def valSetter(x):
self._rawVariable.value = x
w = createInputWidget(
self._rawVariable.dataType, valSetter,
getPinDefaultValueByType(self._rawVariable.dataType))
if w:
w.setWidgetValue(self._rawVariable.value)
w.setObjectName(self._rawVariable.name)
valueCategory.addWidget(self._rawVariable.name, w)
# access level
cb = QComboBox()
cb.addItem('public', 0)
cb.addItem('private', 1)
cb.addItem('protected', 2)
def accessLevelChanged(x):
self._rawVariable.accessLevel = AccessLevel[x]
cb.currentTextChanged.connect(accessLevelChanged)
cb.setCurrentIndex(self._rawVariable.accessLevel)
valueCategory.addWidget('Access level', cb)
propertiesWidget.addWidget(valueCategory)
class RingTable(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
layout = QGridLayout(self)
self.table = QTableWidget()
self.table.setColumnCount(1)
self.table.setHorizontalHeaderLabels(['name'])
self.add_rings()
for i in range(0, 1):
self.table.resizeColumnToContents(i)
self.table.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.table.setSortingEnabled(True)
self.table.setSelectionBehavior(QTableWidget.SelectRows)
self.table.setEditTriggers(QTableWidget.NoEditTriggers)
self.filterEdit = QLineEdit()
self.filterEdit.textChanged.connect(self.apply_filter)
self.filterEdit.setClearButtonEnabled(True)
self.filter_columns = QComboBox()
self.filter_columns.addItem("name")
self.filter_columns.currentTextChanged.connect(
self.change_filter_method)
self.name_regex_option = QComboBox()
self.name_regex_option.addItem("case-insensitive")
self.name_regex_option.addItem("case-sensitive")
self.name_regex_option.currentTextChanged.connect(self.apply_filter)
self.name_regex_option.setVisible(
self.filter_columns.currentText() == "name")
layout.addWidget(self.table, 0, 0, 1, 4)
layout.addWidget(QLabel("filter based on"), 1, 0)
layout.addWidget(self.filter_columns, 1, 1)
layout.addWidget(self.name_regex_option, 1, 2)
layout.addWidget(self.filterEdit, 1, 3)
self.change_filter_method("name")
def change_filter_method(self, text):
if text == "name":
self.filterEdit.setToolTip("name regex")
self.name_regex_option.setVisible(True)
self.apply_filter()
def apply_filter(self, *args):
text = self.filterEdit.text()
if text:
if self.filter_columns.currentText() == "name":
m = QRegularExpression(text)
if m.isValid():
if self.name_regex_option.currentText(
) == "case-insensitive":
m.setPatternOptions(
QRegularExpression.CaseInsensitiveOption)
m.optimize()
filter = lambda row_num: m.match(
self.table.item(row_num, 0).text()).hasMatch()
else:
return
else:
filter = lambda row: True
for i in range(0, self.table.rowCount()):
self.table.setRowHidden(i, not filter(i))
def add_rings(self):
from AaronTools.ring import Ring
names = []
for lib in [Ring.AARON_LIBS, Ring.BUILTIN]:
if not os.path.exists(lib):
continue
for ring in os.listdir(lib):
name, ext = os.path.splitext(ring)
if not any(".%s" % x == ext for x in read_types):
continue
if name in names:
continue
names.append(name)
row = self.table.rowCount()
self.table.insertRow(row)
self.table.setItem(row, 0, QTableWidgetItem(name))
self.ring_list = names
class SubstituentTable(QWidget):
def __init__(self, parent=None, singleSelect=False):
super().__init__(parent)
layout = QGridLayout(self)
self.table = QTableWidget()
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(
['name', 'conformers', 'conf. angle'])
self.add_subs()
for i in range(0, 3):
self.table.resizeColumnToContents(i)
self.table.horizontalHeader().setStretchLastSection(False)
self.table.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Fixed)
self.table.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Fixed)
self.table.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Stretch)
self.table.setSortingEnabled(True)
self.table.setSelectionBehavior(QTableWidget.SelectRows)
if singleSelect:
self.table.setSelectionMode(QTableWidget.SingleSelection)
self.table.setEditTriggers(QTableWidget.NoEditTriggers)
self.filterEdit = QLineEdit()
self.filterEdit.textChanged.connect(self.apply_filter)
self.filterEdit.setClearButtonEnabled(True)
self.filter_columns = QComboBox()
self.filter_columns.addItem("name")
self.filter_columns.addItem("conformers")
self.filter_columns.addItem("conf. angle")
self.filter_columns.currentTextChanged.connect(
self.change_filter_method)
self.name_regex_option = QComboBox()
self.name_regex_option.addItem("case-insensitive")
self.name_regex_option.addItem("case-sensitive")
self.name_regex_option.currentTextChanged.connect(self.apply_filter)
self.name_regex_option.setVisible(
self.filter_columns.currentText() == "name")
layout.addWidget(self.table, 0, 0, 1, 4)
layout.addWidget(QLabel("filter based on"), 1, 0)
layout.addWidget(self.filter_columns, 1, 1)
layout.addWidget(self.name_regex_option, 1, 2)
layout.addWidget(self.filterEdit, 1, 3)
self.change_filter_method("name")
def change_filter_method(self, text):
if text == "name":
self.filterEdit.setToolTip("name regex")
self.name_regex_option.setVisible(True)
elif text == "conformers":
self.filterEdit.setToolTip("number of conformers")
self.name_regex_option.setVisible(False)
elif text == "conf. angle":
self.filterEdit.setToolTip("angle between conformers")
self.name_regex_option.setVisible(False)
self.apply_filter()
def apply_filter(self, *args):
text = self.filterEdit.text()
if text:
if self.filter_columns.currentText() == "name":
m = QRegularExpression(text)
if m.isValid():
if self.name_regex_option.currentText(
) == "case-insensitive":
m.setPatternOptions(
QRegularExpression.CaseInsensitiveOption)
m.optimize()
filter = lambda row_num: m.match(
self.table.item(row_num, 0).text()).hasMatch()
else:
return
elif self.filter_columns.currentText() == "conformers":
if text.isdigit():
filter = lambda row_num: int(
self.table.item(row_num, 1).text()) == int(text)
else:
filter = lambda row: True
elif self.filter_columns.currentText() == "conf. angle":
if text.isdigit():
filter = lambda row_num: int(
self.table.item(row_num, 2).text()) == int(text)
else:
filter = lambda row: True
else:
filter = lambda row: True
for i in range(0, self.table.rowCount()):
self.table.setRowHidden(i, not filter(i))
def add_subs(self):
from AaronTools.substituent import Substituent
names = []
for lib in [Substituent.AARON_LIBS, Substituent.BUILTIN]:
if not os.path.exists(lib):
continue
for ring in os.listdir(lib):
name, ext = os.path.splitext(ring)
if not any(".%s" % x == ext for x in read_types):
continue
if name in names:
continue
names.append(name)
geom = Geometry(
os.path.join(lib, ring),
refresh_connected=False,
refresh_ranks=False,
)
conf_info = re.search(r"CF:(\d+),(\d+)", geom.comment)
row = self.table.rowCount()
self.table.insertRow(row)
self.table.setItem(row, 0, QTableWidgetItem(name))
#the next two items are integers - need to initialize then setData so they sort and display correctly
conf_num = QTableWidgetItem()
conf_num.setData(Qt.DisplayRole, conf_info.group(1))
self.table.setItem(row, 1, conf_num)
conf_angle = QTableWidgetItem()
conf_angle.setData(Qt.DisplayRole, conf_info.group(2))
self.table.setItem(row, 2, conf_angle)
self.substituent_list = names
class LigandTable(QWidget):
def __init__(
self,
parent=None,
singleSelect=False,
maxDenticity=None,
include_substituents=False,
):
super().__init__(parent)
self._include_substituents = include_substituents
layout = QGridLayout(self)
self.table = QTableWidget()
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(
['name', 'denticity', 'coordinating elements'])
self.add_ligands(maxDenticity)
for i in range(0, 3):
self.table.resizeColumnToContents(i)
self.table.horizontalHeader().setStretchLastSection(False)
self.table.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Fixed)
self.table.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Fixed)
self.table.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Stretch)
self.table.setSortingEnabled(True)
self.table.setSelectionBehavior(QTableWidget.SelectRows)
if singleSelect:
self.table.setSelectionMode(QTableWidget.SingleSelection)
self.table.setEditTriggers(QTableWidget.NoEditTriggers)
self.filterEdit = QLineEdit()
self.filterEdit.textChanged.connect(self.apply_filter)
self.filterEdit.setClearButtonEnabled(True)
self.filter_columns = QComboBox()
self.filter_columns.addItem("name")
self.filter_columns.addItem("denticity")
self.filter_columns.addItem("coordinating elements")
self.filter_columns.currentTextChanged.connect(
self.change_filter_method)
self.name_regex_option = QComboBox()
self.name_regex_option.addItem("case-insensitive")
self.name_regex_option.addItem("case-sensitive")
self.name_regex_option.currentTextChanged.connect(self.apply_filter)
self.name_regex_option.setVisible(
self.filter_columns.currentText() == "name")
self.coordinating_elements_method = QComboBox()
self.coordinating_elements_method.addItem("exactly")
self.coordinating_elements_method.addItem("at least")
self.coordinating_elements_method.currentTextChanged.connect(
self.apply_filter)
self.coordinating_elements_method.setVisible(
self.filter_columns.currentText() == "coordinating elements")
layout.addWidget(self.table, 0, 0, 1, 4)
layout.addWidget(QLabel("filter based on"), 1, 0)
layout.addWidget(self.filter_columns, 1, 1)
layout.addWidget(self.coordinating_elements_method, 1, 2)
layout.addWidget(self.name_regex_option, 1, 2)
layout.addWidget(self.filterEdit, 1, 3)
self.change_filter_method("name")
def add_ligands(self, maxDenticity=None):
from AaronTools.component import Component
names = []
for lib in [Component.AARON_LIBS, Component.BUILTIN]:
if not os.path.exists(lib):
continue
for lig in os.listdir(lib):
name, ext = os.path.splitext(lig)
if not any(".%s" % x == ext for x in read_types):
continue
if name in names:
continue
names.append(name)
geom = Geometry(
os.path.join(lib, lig),
refresh_connected=False,
refresh_ranks=False,
)
key_atoms = [geom.atoms[i] for i in geom.other["key_atoms"]]
if maxDenticity and len(key_atoms) > maxDenticity:
continue
row = self.table.rowCount()
self.table.insertRow(row)
self.table.setItem(row, 0, QTableWidgetItem(name))
#this is an integer, so I need to initialize it then set the data
denticity = QTableWidgetItem()
denticity.setData(Qt.DisplayRole, len(key_atoms))
self.table.setItem(row, 1, denticity)
self.table.setItem(
row, 2,
QTableWidgetItem(", ".join(
sorted([atom.element for atom in key_atoms]))))
if self._include_substituents:
from AaronTools.substituent import Substituent
for lib in [Substituent.AARON_LIBS, Substituent.BUILTIN]:
if not os.path.exists(lib):
continue
for sub in os.listdir(lib):
name, ext = os.path.splitext(sub)
if not any(".%s" % x == ext for x in read_types):
continue
if name in names:
continue
names.append(name)
geom = Geometry(
os.path.join(lib, sub),
refresh_connected=False,
refresh_ranks=False,
)
key_atoms = [geom.atoms[0]]
if maxDenticity and len(key_atoms) > maxDenticity:
continue
row = self.table.rowCount()
self.table.insertRow(row)
self.table.setItem(row, 0, QTableWidgetItem(name))
#this is an integer, so I need to initialize it then set the data
denticity = QTableWidgetItem()
denticity.setData(Qt.DisplayRole, len(key_atoms))
self.table.setItem(row, 1, denticity)
self.table.setItem(
row, 2,
QTableWidgetItem(", ".join(
sorted([atom.element for atom in key_atoms]))))
self.ligand_list = names
def change_filter_method(self, text):
if text == "coordinating elements":
self.filterEdit.setToolTip("comma and/or space delimited elements")
self.coordinating_elements_method.setVisible(True)
self.name_regex_option.setVisible(False)
elif text == "name":
self.filterEdit.setToolTip("name regex")
self.coordinating_elements_method.setVisible(False)
self.name_regex_option.setVisible(True)
elif text == "denticity":
self.filterEdit.setToolTip("number of key atoms")
self.coordinating_elements_method.setVisible(False)
self.name_regex_option.setVisible(False)
self.apply_filter()
def apply_filter(self, *args):
text = self.filterEdit.text()
if text:
if self.filter_columns.currentText() == "name":
m = QRegularExpression(text)
if m.isValid():
if self.name_regex_option.currentText(
) == "case-insensitive":
m.setPatternOptions(
QRegularExpression.CaseInsensitiveOption)
m.optimize()
filter = lambda row_num: m.match(
self.table.item(row_num, 0).text()).hasMatch()
else:
return
elif self.filter_columns.currentText() == "denticity":
if text.isdigit():
filter = lambda row_num: int(
self.table.item(row_num, 1).text()) == int(text)
else:
filter = lambda row: True
elif self.filter_columns.currentText() == "coordinating elements":
method = self.coordinating_elements_method.currentText()
def filter(row_num):
row_key_atoms = [
item.strip() for item in self.table.item(
row_num, 2).text().split(',')
]
search_atoms = []
for item in text.split():
for ele in item.split(','):
if ele.strip() != "":
search_atoms.append(ele)
if method == "exactly":
if all([row_key_atoms.count(element) == search_atoms.count(element) for element in set(search_atoms)]) and \
all([row_key_atoms.count(element) == search_atoms.count(element) for element in set(row_key_atoms)]):
return True
else:
return False
elif method == "at least":
if all([
row_key_atoms.count(element) >=
search_atoms.count(element)
for element in set(search_atoms)
]):
return True
else:
return False
else:
filter = lambda row: True
for i in range(0, self.table.rowCount()):
self.table.setRowHidden(i, not filter(i))
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)
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 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)
