def __init__(self,
text=None,
shadow=True,
orientation=Qt.Horizontal,
alignment=Qt.AlignLeft,
parent=None):
"""
Basic standard splitter with optional text
:param str text: Optional text to include as title in the splitter
:param bool shadow: True if you want a shadow above the splitter
:param Qt.Orientation orientation: Orientation of the splitter
:param Qt.Align alignment: Alignment of the splitter
:param QWidget parent: Parent of the splitter
"""
super(Divider, self).__init__(parent=parent)
self._orient = orientation
self._text = None
main_layout = layouts.HorizontalLayout(spacing=0, margins=(0, 0, 0, 0))
self.setLayout(main_layout)
self._label = label.BaseLabel().strong(True)
first_line = QFrame()
self._second_line = QFrame()
main_layout.addWidget(first_line)
main_layout.addWidget(self._label)
main_layout.addWidget(self._second_line)
if orientation == Qt.Horizontal:
first_line.setFrameShape(QFrame.HLine)
first_line.setFrameShadow(QFrame.Sunken)
first_line.setFixedHeight(
2) if shadow else first_line.setFixedHeight(1)
self._second_line.setFrameShape(QFrame.HLine)
self._second_line.setFrameShadow(QFrame.Sunken)
self._second_line.setFixedHeight(
2) if shadow else self._second_line.setFixedHeight(1)
else:
self._label.setVisible(False)
self._second_line.setVisible(False)
first_line.setFrameShape(QFrame.VLine)
first_line.setFrameShadow(QFrame.Plain)
self.setFixedWidth(2)
first_line.setFixedWidth(
2) if shadow else first_line.setFixedWidth(1)
main_layout.setStretchFactor(first_line,
self._ALIGN_MAP.get(alignment, 50))
main_layout.setStretchFactor(self._second_line,
100 - self._ALIGN_MAP.get(alignment, 50))
self.set_text(text)
def create_vertical_line():
"""
Creates and returns a new vertical line
:return: QFrame
"""
line_frame = QFrame()
line_frame.setFrameShape(QFrame.VLine)
line_frame.setFrameShadow(QFrame.Sunken)
return line_frame
def create_horizontal_line():
"""
Creates and returns a new horizontal line
:return: QFrame
"""
line_frame = QFrame()
line_frame.setFrameShape(QFrame.HLine)
line_frame.setFrameShadow(QFrame.Sunken)
return line_frame
def get_horizontal_separator():
v_div_w = QWidget()
v_div_l = QVBoxLayout()
v_div_l.setAlignment(Qt.AlignLeft)
v_div_l.setContentsMargins(0, 0, 0, 0)
v_div_l.setSpacing(0)
v_div_w.setLayout(v_div_l)
v_div = QFrame()
v_div.setMinimumHeight(30)
v_div.setFrameShape(QFrame.VLine)
v_div.setFrameShadow(QFrame.Sunken)
v_div_l.addWidget(v_div)
return v_div_w
def ui(self):
super(BaseSaveWidget, self).ui()
title_layout = layouts.HorizontalLayout()
title_layout.setContentsMargins(2, 2, 0, 0)
title_layout.setSpacing(2)
self._icon_lbl = QLabel()
self._icon_lbl.setMaximumSize(QSize(14, 14))
self._icon_lbl.setMinimumSize(QSize(14, 14))
self._icon_lbl.setScaledContents(True)
self._title_lbl = QLabel()
title_layout.addWidget(self._icon_lbl)
title_layout.addWidget(self._title_lbl)
self._folder_widget = directory.SelectFolder('Folder',
use_app_browser=True)
buttons_layout = layouts.HorizontalLayout()
buttons_layout.setContentsMargins(4, 4, 4, 4)
buttons_layout.setSpacing(4)
buttons_frame = QFrame()
buttons_frame.setFrameShape(QFrame.NoFrame)
buttons_frame.setFrameShadow(QFrame.Plain)
buttons_frame.setLayout(buttons_layout)
buttons_layout.addStretch()
self.save_btn = buttons.BaseButton('Save')
self.cancel_btn = buttons.BaseButton('Cancel')
buttons_layout.addWidget(self.save_btn, parent=self)
buttons_layout.addWidget(self.cancel_btn, parent=self)
buttons_layout.addStretch()
self._options_layout = layouts.VerticalLayout()
self._options_layout.setContentsMargins(0, 0, 0, 0)
self._options_layout.setSpacing(2)
self._options_frame = QFrame()
self._options_frame.setFrameShape(QFrame.NoFrame)
self._options_frame.setFrameShadow(QFrame.Plain)
self._options_frame.setLineWidth(0)
self._options_frame.setLayout(self._options_layout)
self._extra_layout = layouts.VerticalLayout()
self._extra_layout.setContentsMargins(0, 0, 0, 0)
self._extra_layout.setSpacing(2)
self.main_layout.addLayout(title_layout)
self.main_layout.addWidget(self._folder_widget)
self._extra_layout.addWidget(self._options_frame)
self.main_layout.addWidget(dividers.Divider())
self.main_layout.addLayout(self._extra_layout)
self.main_layout.addWidget(dividers.Divider())
self.main_layout.addWidget(buttons_frame)
def __init__(self, title='', animation_duration=300, parent=None):
super(ExpandableLine, self).__init__(parent=parent)
self._animation_duration = animation_duration
base_layout = layouts.GridLayout(margins=(0, 0, 0, 0))
base_layout.setVerticalSpacing(0)
self.setLayout(base_layout)
self.expand_btn = QToolButton()
self.expand_btn.setText(str(title))
self.expand_btn.setStyleSheet('QToolButton { border : none; }')
self.expand_btn.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.expand_btn.setArrowType(Qt.ArrowType.RightArrow)
self.expand_btn.setCheckable(True)
self.expand_btn.setChecked(True)
header_line = QFrame()
header_line.setFrameShape(QFrame.HLine)
header_line.setFrameShadow(QFrame.Sunken)
header_line.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
self.content_area = QScrollArea()
self.content_area.setStyleSheet('QScrollArea { border: none;}')
self.content_area.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.content_area.setMaximumHeight(0)
self.content_area.setMinimumHeight(0)
self.toggle_anim = QParallelAnimationGroup()
self.toggle_anim.addAnimation(QPropertyAnimation(self, 'minimumHeight'))
self.toggle_anim.addAnimation(QPropertyAnimation(self, 'maximumHeight'))
self.toggle_anim.addAnimation(QPropertyAnimation(self.content_area, 'maximumHeight'))
row = 0
base_layout.addWidget(self.expand_btn, row, 0, 1, 1, Qt.AlignLeft)
base_layout.addWidget(header_line, row, 2, 1, 1)
row += 1
base_layout.addWidget(self.content_area, row, 0, 1, 3)
def expand_view(checked):
arrow_type = Qt.DownArrow if checked else Qt.RightArrow
direction = QAbstractAnimation.Forward if checked else QAbstractAnimation.Backward
self.expand_btn.setArrowType(arrow_type)
self.toggle_anim.setDirection(direction)
self.toggle_anim.start()
# === SIGNALS === #
self.expand_btn.toggled.connect(expand_view)
expand_view(True)
def ui(self):
super(OptionsViewer, self).ui()
edit_mode_icon = resources.icon('edit')
move_up_icon = resources.icon('sort_up')
move_down_icon = resources.icon('sort_down')
remove_icon = resources.icon('delete')
self._edit_widget = QWidget()
top_layout = layouts.HorizontalLayout()
top_layout.setContentsMargins(0, 0, 0, 0)
top_layout.setSpacing(2)
self._edit_widget.setLayout(top_layout)
self.main_layout.addWidget(self._edit_widget)
self._edit_mode_btn = buttons.BaseButton(parent=self)
self._edit_mode_btn.setIcon(edit_mode_icon)
self._edit_mode_btn.setCheckable(True)
top_layout.addWidget(self._edit_mode_btn)
horizontal_separator = QFrame()
horizontal_separator.setFrameShape(QFrame.VLine)
horizontal_separator.setFrameShadow(QFrame.Sunken)
top_layout.addWidget(horizontal_separator)
self._move_up_btn = buttons.BaseButton(parent=self)
self.move_down_btn = buttons.BaseButton(parent=self)
self.remove_btn = buttons.BaseButton(parent=self)
self._move_up_btn.setIcon(move_up_icon)
self.move_down_btn.setIcon(move_down_icon)
self.remove_btn.setIcon(remove_icon)
self._move_up_btn.setVisible(False)
self.move_down_btn.setVisible(False)
self.remove_btn.setVisible(False)
top_layout.addWidget(self._move_up_btn)
top_layout.addWidget(self.move_down_btn)
top_layout.addWidget(self.remove_btn)
top_layout.addStretch()
self.main_layout.addWidget(dividers.Divider())
self._scroll = QScrollArea()
self._scroll.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self._scroll.setFocusPolicy(Qt.NoFocus)
self._scroll.setWidgetResizable(True)
self.setFocusPolicy(Qt.NoFocus)
self._options_list = self.OPTION_LIST_CLASS(parent=self)
self._scroll.setWidget(self._options_list)
self.main_layout.addWidget(self._scroll)
def get_vertical_separator_widget(max_height=30, parent=None):
"""
Returns horizontal separator widget
:param max_height: int, maximum height for the separator
:param parent: QWidget or None, parent widget
:return: QWidget
"""
h_div_w = QWidget(parent=parent)
h_div_l = layouts.VerticalLayout(spacing=0, margins=(5, 5, 5, 5))
h_div_l.setAlignment(Qt.AlignLeft)
h_div_w.setLayout(h_div_l)
h_div = QFrame(parent=h_div_w)
h_div.setObjectName('dividerSeparator') # ID selector used by style
h_div.setMaximumHeight(qtutils.dpi_scale(max_height))
h_div.setFrameShape(QFrame.VLine)
h_div.setFrameShadow(QFrame.Sunken)
h_div_l.addWidget(h_div)
return h_div_w
def ui(self):
super(ExpandablePanel, self).ui()
widget_palette = QPalette()
widget_palette.setColor(QPalette.Background, QColor.fromRgb(60, 60, 60))
self.setAutoFillBackground(True)
self.setPalette(widget_palette)
frame = QFrame()
frame.setFrameShape(QFrame.StyledPanel)
frame.setFrameShadow(QFrame.Sunken)
self.main_layout.addWidget(frame)
main_layout = layouts.VerticalLayout(spacing=0, margins=(2, 2, 2, 2), parent=frame)
main_layout.setAlignment(Qt.AlignTop)
self._header_area = QWidget()
self._header_area.setMinimumHeight(20)
self._widget_area = QWidget()
self._widget_area.setAutoFillBackground(True)
self._widget_area.setPalette(widget_palette)
self._header_text_label = dividers.Divider(self._header_text)
self._widget_layout = layouts.VerticalLayout(spacing=5)
self._widget_layout.setMargin(5)
self._widget_area.setLayout(self._widget_layout)
header_layout = layouts.HorizontalLayout(margins=(0, 0, 0, 0))
header_layout.addWidget(self._icon)
header_layout.addWidget(self._header_text_label)
self._header_area.setLayout(header_layout)
main_layout.addWidget(self._header_area)
main_layout.addWidget(self._widget_area)
self._icon.clicked.connect(self.change_state)
class BaseSaveWidget(base.BaseWidget, object):
def __init__(self, item, settings, temp_path=None, parent=None):
# self._item = None
self._settings = settings
self._temp_path = temp_path
self._options_widget = None
# super(BaseSaveWidget, self).__init__(parent=parent)
#
# self.setObjectName('LibrarySaveWidget')
# self.set_item(item)
def ui(self):
super(BaseSaveWidget, self).ui()
title_layout = layouts.HorizontalLayout()
title_layout.setContentsMargins(2, 2, 0, 0)
title_layout.setSpacing(2)
self._icon_lbl = QLabel()
self._icon_lbl.setMaximumSize(QSize(14, 14))
self._icon_lbl.setMinimumSize(QSize(14, 14))
self._icon_lbl.setScaledContents(True)
self._title_lbl = QLabel()
title_layout.addWidget(self._icon_lbl)
title_layout.addWidget(self._title_lbl)
self._folder_widget = directory.SelectFolder('Folder',
use_app_browser=True)
buttons_layout = layouts.HorizontalLayout()
buttons_layout.setContentsMargins(4, 4, 4, 4)
buttons_layout.setSpacing(4)
buttons_frame = QFrame()
buttons_frame.setFrameShape(QFrame.NoFrame)
buttons_frame.setFrameShadow(QFrame.Plain)
buttons_frame.setLayout(buttons_layout)
buttons_layout.addStretch()
self.save_btn = buttons.BaseButton('Save')
self.cancel_btn = buttons.BaseButton('Cancel')
buttons_layout.addWidget(self.save_btn, parent=self)
buttons_layout.addWidget(self.cancel_btn, parent=self)
buttons_layout.addStretch()
self._options_layout = layouts.VerticalLayout()
self._options_layout.setContentsMargins(0, 0, 0, 0)
self._options_layout.setSpacing(2)
self._options_frame = QFrame()
self._options_frame.setFrameShape(QFrame.NoFrame)
self._options_frame.setFrameShadow(QFrame.Plain)
self._options_frame.setLineWidth(0)
self._options_frame.setLayout(self._options_layout)
self._extra_layout = layouts.VerticalLayout()
self._extra_layout.setContentsMargins(0, 0, 0, 0)
self._extra_layout.setSpacing(2)
self.main_layout.addLayout(title_layout)
self.main_layout.addWidget(self._folder_widget)
self._extra_layout.addWidget(self._options_frame)
self.main_layout.addWidget(dividers.Divider())
self.main_layout.addLayout(self._extra_layout)
self.main_layout.addWidget(dividers.Divider())
self.main_layout.addWidget(buttons_frame)
def setup_signals(self):
self.save_btn.clicked.connect(self._on_save)
self.cancel_btn.clicked.connect(self._on_cancel)
def settings(self):
"""
Returns settings object
:return: JSONSettings
"""
return self._settings
def set_settings(self, settings):
"""
Sets save widget settings
:param settings: JSONSettings
"""
self._settings = settings
# def item(self):
# """
# Returns the library item to be created
# :return: LibraryItem
# """
#
# return self._item
def set_item(self, item):
"""
Sets the base item to be created
:param item: LibraryItem
"""
self._item = item
self._title_lbl.setText(item.MenuName)
self._icon_lbl.setPixmap(QPixmap(item.type_icon_path()))
schema = item.save_schema()
if schema:
options_widget = formwidget.FormWidget(self)
options_widget.set_schema(schema)
options_widget.set_validator(item.save_validator)
self._options_frame.layout().addWidget(options_widget)
self._options_widget = options_widget
self.load_settings()
options_widget.stateChanged.connect(self._on_options_changed)
options_widget.validate()
else:
self._options_frame.setVisible(False)
def library_window(self):
"""
Returns library widget window for the item
:return: LibraryWindow
"""
return self._item.library_window()
def set_library_window(self, library_window):
"""
Sets the library widget for the item
:param library_window: LibraryWindow
"""
self._item.set_library_window(library_window)
def name(self):
"""
Returns the name of the field
:return: str
"""
return self._title_lbl.text().strip()
def description(self):
"""
Returns the string from the comment field
:return: str
"""
return self._comment.toPlainText().strip()
def folder_frame(self):
"""
Returns the frame that contains the folder edit, label and button
:return: QFrame
"""
return self._folder_frame
def folder_path(self):
"""
Returns the folder path
:return: str
"""
return self._folder_widget.folder_line.text()
def set_folder_path(self, path):
"""
Sets the destination folder path
:param path: str
"""
self._folder_widget.folder_line.setText(path)
def default_values(self):
"""
Returns all the default values for the save fields
:return: dict
"""
values = dict()
for option in self.item().save_schema():
values[option.get('name')] = option.get('default')
return values
def save_settings(self):
"""
Saves the current state of the widget to disk
"""
state = self._options_widget.options_state()
self.settings().set(self.item().__class__.__name__,
{'SaveOptions': state})
def load_settings(self):
"""
Returns the settings object for saving the state of the widget
"""
option_settings = self.settings().get(self.item().__class__.__name__,
{})
options = option_settings.get('SaveOptions', dict())
values = self.default_values()
if options:
for option in self.item().save_schema():
name = option.get('name')
persistent = option.get('persistent')
if not persistent and name in options:
options[name] = values[name]
self._options_widget.set_state_from_options(options)
def save(self, path, icon_path, objects=None):
"""
Saves the item with the given objects to the given disk location path
:param path: list(str)
:param icon_path: str
:param objects: str
"""
item = self.item()
options = self._options_widget.values()
item.save(path=path, objects=objects, icon_path=icon_path, **options)
self.close()
def _save(self):
if not self.library_window():
return
try:
path = self.folder_path()
options = self._options_widget.values()
name = options.get('name')
objects = dcc.selected_nodes(full_path=True) or list()
if not path:
raise Exception(
'No folder selected. Please select a destination folder')
if not name:
raise Exception(
'No name specified. Please set a name before saving')
if not os.path.exists(self.icon_path()):
btn = self.show_thumbnail_capture_dialog()
if btn == QDialogButtonBox.Cancel:
return
path += '/{}'.format(name)
icon_path = self.icon_path()
self.save(path=path, icon_path=icon_path, objects=objects)
except Exception as e:
messagebox.MessageBox.critical(self.library_window(),
'Error while saving', str(e))
LOGGER.error(traceback.format_exc())
raise
self.library_window().stack.slide_in_index(0)
def _on_options_changed(self):
"""
Internal callback function that is called when an option value changes
"""
self.save_settings()
def _on_save(self):
if not self.library_window():
return
self._save()
self.library_window().stack.slide_in_index(0)
def _on_cancel(self):
self.close()
self.library_window().stack.slide_in_index(0)
class Divider(QWidget, object):
_ALIGN_MAP = {Qt.AlignCenter: 50, Qt.AlignLeft: 20, Qt.AlignRight: 80}
def __init__(self,
text=None,
shadow=True,
orientation=Qt.Horizontal,
alignment=Qt.AlignLeft,
parent=None):
"""
Basic standard splitter with optional text
:param str text: Optional text to include as title in the splitter
:param bool shadow: True if you want a shadow above the splitter
:param Qt.Orientation orientation: Orientation of the splitter
:param Qt.Align alignment: Alignment of the splitter
:param QWidget parent: Parent of the splitter
"""
super(Divider, self).__init__(parent=parent)
self._orient = orientation
self._text = None
main_layout = layouts.HorizontalLayout(spacing=0, margins=(0, 0, 0, 0))
self.setLayout(main_layout)
self._label = label.BaseLabel().strong(True)
first_line = QFrame()
self._second_line = QFrame()
main_layout.addWidget(first_line)
main_layout.addWidget(self._label)
main_layout.addWidget(self._second_line)
if orientation == Qt.Horizontal:
first_line.setFrameShape(QFrame.HLine)
first_line.setFrameShadow(QFrame.Sunken)
first_line.setFixedHeight(
2) if shadow else first_line.setFixedHeight(1)
self._second_line.setFrameShape(QFrame.HLine)
self._second_line.setFrameShadow(QFrame.Sunken)
self._second_line.setFixedHeight(
2) if shadow else self._second_line.setFixedHeight(1)
else:
self._label.setVisible(False)
self._second_line.setVisible(False)
first_line.setFrameShape(QFrame.VLine)
first_line.setFrameShadow(QFrame.Plain)
self.setFixedWidth(2)
first_line.setFixedWidth(
2) if shadow else first_line.setFixedWidth(1)
main_layout.setStretchFactor(first_line,
self._ALIGN_MAP.get(alignment, 50))
main_layout.setStretchFactor(self._second_line,
100 - self._ALIGN_MAP.get(alignment, 50))
self.set_text(text)
@classmethod
def left(cls, text=''):
"""
Creates an horizontal splitter with text at left
:param text:
:return:
"""
return cls(text, alignment=Qt.AlignLeft)
@classmethod
def right(cls, text=''):
"""
Creates an horizontal splitter with text at right
:param text:
:return:
"""
return cls(text, alignment=Qt.AlignRight)
@classmethod
def center(cls, text=''):
"""
Creates an horizontal splitter with text at center
:param text:
:return:
"""
return cls(text, alignment=Qt.AlignCenter)
@classmethod
def vertical(cls):
"""
Creates a vertical splitter
:return:
"""
return cls(orientation=Qt.Vertical)
def get_text(self):
"""
Returns splitter text
:return: str
"""
return self._label.text()
def set_text(self, text):
"""
Sets splitter text
:param str text:
"""
self._text = text
self._label.setText(text)
if self._orient == Qt.Horizontal:
self._label.setVisible(bool(text))
self._second_line.setVisible(bool(text))
class IndexedStringsWidget(QWidget):
""" Holds the list of indexed string attributes """
def __init__(self, data, parent=None):
QWidget.__init__(self, parent)
self.data = data
vbox = QVBoxLayout()
self.setLayout(vbox)
title = QLabel('Indexed Strings')
vbox.addWidget(title)
self.frame = QFrame()
vbox.addWidget(self.frame)
self.vbox = QVBoxLayout()
self.frame.setLayout(self.vbox)
self.frame.setFrameShape(QFrame.Panel)
self.frame.setFrameShadow(QFrame.Sunken)
self.table = QTableWidget()
self.table.horizontalHeader().hide()
self.vbox.addWidget(self.table)
self.table.hide()
self.noStringsLabel = QLabel('<i>No indexed strings</i>')
self.vbox.addWidget(self.noStringsLabel)
self.widgets = []
self.populate()
self.data.attributeAdded.connect(self.attributeAddedSlot)
self.data.dataReset.connect(self.dataResetSlot)
self.data.dirtied.connect(self.dataDirtiedSlot)
def dataDirtiedSlot(self, dirty):
""" SLOT when the particle data is dirtied or cleaned."""
if not dirty:
for widget in self.widgets:
widget.drawBorder(False)
def dataResetSlot(self):
""" SLOT when particle data is reconstructed """
self.populate()
def attributeAddedSlot(self, name): #pylint:disable=W0613
""" SLOT when an attribute is added to the particle set """
attr = self.data.attributeInfo(name)
if attr.type == partio.INDEXEDSTR:
self.populate()
def populate(self):
""" Populates the table of indexed strings """
self.widgets = []
# If no widgets, just drop that in
attrs = []
for anum in range(self.data.numAttributes()):
attr = self.data.attributeInfo(anum)
if attr.type == partio.INDEXEDSTR:
attrs.append(attr)
if not attrs:
self.table.hide()
self.noStringsLabel.show()
return
self.table.show()
self.noStringsLabel.hide()
self.table.setColumnCount(1)
self.table.setRowCount(len(attrs))
for row, attr in enumerate(attrs):
item = QTableWidgetItem(attr.name)
self.table.setVerticalHeaderItem(row, item)
strings = self.data.indexedStrs(attr)
table = QTableWidget()
table.setColumnCount(1)
table.setRowCount(len(strings))
table.horizontalHeader().hide()
table.setVerticalHeaderLabels(
[str(i) for i in range(len(strings))])
for i, string in enumerate(strings):
widget = QLabel(string)
table.setCellWidget(i, 0, widget)
self.widgets.append(widget)
self.table.setCellWidget(row, 0, table)
self.table.horizontalHeader().setStretchLastSection(False)
self.table.setTabKeyNavigation(True)
self.table.horizontalHeader().setSectionsMovable(False)
self.table.horizontalHeader().resizeSections(
QHeaderView.ResizeToContents)
self.table.verticalHeader().resizeSections(
QHeaderView.ResizeToContents)
class FixedAttributesWidget(QWidget):
""" A widget for viewing/editing fixed attributes (non-varying) """
def __init__(self, data, parent=None):
QWidget.__init__(self, parent)
self.data = data
vbox = QVBoxLayout()
self.setLayout(vbox)
title = QLabel('Fixed Attributes')
vbox.addWidget(title)
self.frame = QFrame()
vbox.addWidget(self.frame)
self.vbox = QVBoxLayout()
self.frame.setLayout(self.vbox)
self.frame.setFrameShape(QFrame.Panel)
self.frame.setFrameShadow(QFrame.Sunken)
self.table = QTableWidget()
self.table.horizontalHeader().hide()
self.vbox.addWidget(self.table)
self.table.hide()
self.noAttrLabel = QLabel('<i>No fixed attributes</i>')
self.vbox.addWidget(self.noAttrLabel)
self.widgets = []
self.populate()
self.data.fixedAttributeAdded.connect(self.fixedAttributeAddedSlot)
self.data.dataReset.connect(self.dataResetSlot)
self.data.dirtied.connect(self.dataDirtiedSlot)
def dataDirtiedSlot(self, dirty):
""" SLOT when the particle data is dirtied or cleaned."""
if not dirty:
for widget in self.widgets:
widget.drawBorder(False)
def dataResetSlot(self):
""" SLOT when particle data is reconstructed """
self.populate()
def fixedAttributeAddedSlot(self, name): #pylint:disable=W0613
""" SLOT when a fixed attribute is added to the particle set """
self.populate()
def populate(self):
""" Populates the table of fixed attributes """
self.widgets = []
# If no widgets, just drop that in
numAttrs = self.data.numFixedAttributes()
if not numAttrs:
self.table.hide()
self.noAttrLabel.show()
return
self.table.show()
self.noAttrLabel.hide()
self.table.setColumnCount(1)
self.table.setRowCount(numAttrs)
self.attrs = getAttrs(self.data.numFixedAttributes,
self.data.fixedAttributeInfo, True)
for row, (_, attr) in enumerate(self.attrs):
item = QTableWidgetItem(attr.name)
tooltip = '<p><tt> Name: {}<br> Type: {}<br>Count: {}</tt></p>'.\
format(attr.name, partio.TypeName(attr.type), attr.count)
item.setToolTip(tooltip)
self.table.setVerticalHeaderItem(row, item)
value = self.data.getFixed(attr)
widget = getWidget(value, self.data, attr)
self.table.setCellWidget(row, 0, widget)
self.widgets.append(widget)
self.table.horizontalHeader().setStretchLastSection(False)
self.table.setTabKeyNavigation(True)
self.table.horizontalHeader().setSectionsMovable(False)
self.table.horizontalHeader().resizeSections(
QHeaderView.ResizeToContents)
self.table.verticalHeader().resizeSections(
QHeaderView.ResizeToContents)
class FixedAttributesWidget(QWidget):
""" A widget for viewing/editing fixed attributes (non-varying) """
def __init__(self, data, parent=None):
QWidget.__init__(self, parent)
self.data = data
vbox = QVBoxLayout()
self.setLayout(vbox)
title = QLabel('Fixed Attributes')
vbox.addWidget(title)
self.frame = QFrame()
vbox.addWidget(self.frame)
self.vbox = QVBoxLayout()
self.frame.setLayout(self.vbox)
self.frame.setFrameShape(QFrame.Panel)
self.frame.setFrameShadow(QFrame.Sunken)
self.table = QTableWidget()
self.table.horizontalHeader().hide()
self.vbox.addWidget(self.table)
self.table.hide()
self.noAttrLabel = QLabel('<i>No fixed attributes</i>')
self.vbox.addWidget(self.noAttrLabel)
self.widgets = []
self.populate()
self.data.fixedAttributeAdded.connect(self.fixedAttributeAddedSlot)
self.data.dataReset.connect(self.dataResetSlot)
self.data.dirtied.connect(self.dataDirtiedSlot)
def dataDirtiedSlot(self, dirty):
""" SLOT when the particle data is dirtied or cleaned."""
if not dirty:
for widget in self.widgets:
widget.drawBorder(False)
def dataResetSlot(self):
""" SLOT when particle data is reconstructed """
self.populate()
def fixedAttributeAddedSlot(self, name): #pylint:disable=W0613
""" SLOT when a fixed attribute is added to the particle set """
self.populate()
def populate(self):
""" Populates the table of fixed attributes """
self.widgets = []
# If no widgets, just drop that in
numAttrs = self.data.numFixedAttributes()
if not numAttrs:
self.table.hide()
self.noAttrLabel.show()
return
self.table.show()
self.noAttrLabel.hide()
self.table.setColumnCount(1)
self.table.setRowCount(numAttrs)
self.attrs = getAttrs(self.data.numFixedAttributes, self.data.fixedAttributeInfo, True)
for row, (_, attr) in enumerate(self.attrs):
item = QTableWidgetItem(attr.name)
tooltip = '<p><tt> Name: {}<br> Type: {}<br>Count: {}</tt></p>'.\
format(attr.name, partio.TypeName(attr.type), attr.count)
item.setToolTip(tooltip)
self.table.setVerticalHeaderItem(row, item)
value = self.data.getFixed(attr)
widget = getWidget(value, self.data, attr)
self.table.setCellWidget(row, 0, widget)
self.widgets.append(widget)
self.table.horizontalHeader().setStretchLastSection(False)
self.table.setTabKeyNavigation(True)
self.table.horizontalHeader().setSectionsMovable(False)
self.table.horizontalHeader().resizeSections(QHeaderView.ResizeToContents)
self.table.verticalHeader().resizeSections(QHeaderView.ResizeToContents)
class SaveWidget(BaseSaveWidget, object):
def __init__(self, item, settings, temp_path=None, parent=None):
self._script_job = None
self._sequence_path = None
self._icon_path = ''
super(SaveWidget, self).__init__(item=item,
settings=settings,
temp_path=temp_path,
parent=parent)
self.create_sequence_widget()
self.update_thumbnail_size()
try:
self._on_selection_changed()
# self.set_script_job_enabled(True)
except NameError as e:
LOGGER.error('{} | {}'.format(e, traceback.format_exc()))
def ui(self):
super(SaveWidget, self).ui()
model_panel_layout = layouts.HorizontalLayout()
model_panel_layout.setContentsMargins(0, 0, 0, 0)
model_panel_layout.setSpacing(0)
thumbnail_layout = layouts.VerticalLayout()
thumbnail_layout.setContentsMargins(0, 0, 0, 0)
thumbnail_layout.setSpacing(0)
self._thumbnail_frame = QFrame()
self._thumbnail_frame.setMinimumSize(QSize(50, 50))
self._thumbnail_frame.setMaximumSize(QSize(150, 150))
self._thumbnail_frame.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self._thumbnail_frame.setFrameShape(QFrame.NoFrame)
self._thumbnail_frame.setFrameShadow(QFrame.Plain)
self._thumbnail_frame.setLineWidth(0)
self._thumbnail_frame.setLayout(thumbnail_layout)
model_panel_layout.addWidget(self._thumbnail_frame)
self._thumbnail_btn = QPushButton()
self._thumbnail_btn.setMinimumSize(QSize(0, 0))
self._thumbnail_btn.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self._thumbnail_btn.setMaximumSize(QSize(150, 150))
self._thumbnail_btn.setToolTip('Take snapshot')
self._thumbnail_btn.setStyleSheet(
'color: rgb(40, 40, 40);border: 0px solid rgb(0, 0, 0, 150);background-color: rgb(254, 255, 230, 200);'
)
self._thumbnail_btn.setIcon(resources.icon('thumbnail'))
self._thumbnail_btn.setToolTip("""
Click to capture a thumbnail from the current viewport.\n
CTRL + Click to show the capture window for better framing
""")
thumbnail_layout.addWidget(self._thumbnail_btn)
self._extra_layout.addLayout(model_panel_layout)
def setup_signals(self):
super(SaveWidget, self).setup_signals()
self._thumbnail_btn.clicked.connect(self._on_thumbnail_capture)
def resizeEvent(self, event):
"""
Overrides base QWidget resizeEvent function
:param event: QResizeEvent
"""
self.update_thumbnail_size()
def icon_path(self):
"""
Returns the icon path to be used for the thumbnail
:return: str
"""
return self._icon_path
def set_icon(self, icon):
"""
Sets the icon for the create widget thumbnail
:param icon: QIcon
"""
self._thumbnail_btn.setIcon(icon)
self._thumbnail_btn.setIconSize(QSize(200, 200))
self._thumbnail_btn.setText('')
def sequence_path(self):
"""
Returns the playblast path
:return: str
"""
return self._sequence_path
def set_sequence_path(self, path):
"""
Sets the disk location for the image sequence to be saved
:param path: str
"""
self._sequence_path = path
self._thumbnail_btn.set_dirname(os.path.dirname(path))
def create_sequence_widget(self):
"""
Creates a sequence widget to replace the static thumbnail widget
"""
sequence_widget = widgets.LibraryImageSequenceWidget(self)
sequence_widget.setObjectName('thumbnailButton')
sequence_widget.setStyleSheet(self._thumbnail_btn.styleSheet())
sequence_widget.setToolTip(self._thumbnail_btn.toolTip())
camera_icon = resources.get('icons', 'camera.svg')
expand_icon = resources.get('icons', 'expand.svg')
folder_icon = resources.get('icons', 'folder.svg')
sequence_widget.addAction(camera_icon, 'Capture new image',
'Capture new image',
self._on_thumbnail_capture)
sequence_widget.addAction(expand_icon, 'Show Capture window',
'Show Capture window',
self._on_show_capture_window)
sequence_widget.addAction(folder_icon, 'Load image from disk',
'Load image from disk',
self._on_show_browse_image_dialog)
sequence_widget.setIcon(resources.icon('thumbnail2'))
self._thumbnail_frame.layout().insertWidget(0, sequence_widget)
self._thumbnail_btn.hide()
self._thumbnail_btn = sequence_widget
self._thumbnail_btn.clicked.connect(self._on_thumbnail_capture)
def set_sequence(self, source):
"""
Sets the sequenced path for the thumbnail widget
:param source: str
"""
self.set_thumbnail(source, sequence=True)
def set_thumbnail(self, source, sequence=False):
"""
Sets the thumbnail
:param source: str
:param sequence: bool
"""
source = os.path.normpath(source)
# TODO: Find a way to remove temp folder afteer saving the file
# filename, extension = os.path.splitext(source)
# with path_utils.temp_dir() as dir_path:
# dir_path = path_utils.temp_dir()
# target = os.path.join(dir_path, 'thumbnail{}'.format(extension))
# shutil.copyfile(source, target)
# tpQtLib.logger.debug('Source Thumbnail: {}'.format(source))
# tpQtLib.logger.debug('Target Thumbnail: {}'.format(target))
# self._icon_path = target
# self._thumbnail_btn.set_path(target)
self._icon_path = source
self._thumbnail_btn.set_path(source)
if sequence:
self.set_sequence_path(source)
def update_thumbnail_size(self):
"""
Updates the thumbnail button to teh size of the widget
"""
width = self.width() - 10
if width > 250:
width = 250
size = QSize(width, width)
self._thumbnail_btn.setIconSize(size)
self._thumbnail_btn.setMaximumSize(size)
self._thumbnail_frame.setMaximumSize(size)
def show_by_frame_dialog(self):
"""
Show the by frame dialog
"""
help_text = """
To help speed up the playblast you can set the "by frame" to another greather than 1.
For example if the "by frame" is set to 2 it will playblast every second frame
"""
options = self._options_widget.values()
by_frame = options.get('byFrame', 1)
start_frame, end_frame = options.get('frameRange', [None, None])
duration = 1
if start_frame is not None and end_frame is not None:
duration = end_frame - start_frame
if duration > 100 and by_frame == 1:
buttons = QDialogButtonBox.Ok | QDialogButtonBox.Cancel
result = messagebox.MessageBox.question(
self.library_window(),
title='Tip',
text=help_text,
buttons=buttons,
enable_dont_show_checkbox=True)
if result != QDialogButtonBox.Ok:
raise Exception('Cancelled by user')
def show_thumbnail_capture_dialog(self):
"""
Asks the user if they would like to capture a thumbnail
:return: int
"""
buttons = QDialogButtonBox.Yes | QDialogButtonBox.Ignore | QDialogButtonBox.Cancel
parent = self.item().library_window()
btn = messagebox.MessageBox.question(
None,
'Create a thumbnail',
'Would you like to capture a thumbnail?',
buttons=buttons)
if btn == QDialogButtonBox.Yes:
self.thumbnail_capture()
return btn
def thumbnail_capture(self, show=False):
"""
Captures a playblast and saves it to the temporal thumbnail path
:param show: bool
"""
options = self._options_widget.values()
start_frame, end_frame = options.get('frameRange', [None, None])
step = options.get('byFrame', 1)
if not qtutils.is_control_modifier():
self.show_by_frame_dialog()
if not self._temp_path or not os.path.isdir(self._temp_path):
self._temp_path = tempfile.mkdtemp()
self._temp_path = os.path.join(self._temp_path, 'thumbnail.jpg')
try:
snapshot.SnapshotWindow(path=self._temp_path,
on_save=self._on_thumbnail_captured)
# thumbnail.ThumbnailCaptureDialog.thumbnail_capture(
# path=self._temp_path,
# show=show,
# start_frame=start_frame,
# end_frame=end_frame,
# step=step,
# clear_cache=False,
# captured=self._on_thumbnail_captured
# )
except Exception as e:
messagebox.MessageBox.critical(self.library_window(),
'Error while capturing thumbnail',
str(e))
LOGGER.error(traceback.format_exc())
def save(self, path, icon_path, objects=None):
"""
Saves the item with the given objects to the given disk location path
:param path: list(str)
:param icon_path: str
:param objects: str
"""
item = self.item()
options = self._options_widget.values()
sequence_path = self.sequence_path()
if sequence_path:
sequence_path = os.path.dirname(sequence_path)
item.save(path=path,
objects=objects,
icon_path=icon_path,
sequence_path=sequence_path,
**options)
self.close()
def _on_selection_changed(self):
"""
Internal callback functino that is called when DCC selection changes
"""
if self._options_widget:
self._options_widget.validate()
def _on_thumbnail_capture(self):
self.thumbnail_capture(show=False)
def _on_thumbnail_captured(self, captured_path):
"""
Internal callback function that is called when thumbnail is captured
:param captured_path: str
"""
self.set_sequence(captured_path)
def _on_show_capture_window(self):
"""
Internal callback function that shows the capture window for framing
"""
self.thumbnail_capture(show=True)
def _on_show_browse_image_dialog(self):
"""
Internal callback function that shows a file dialog for choosing an image from disk
"""
file_dialog = QFileDialog(self,
caption='Open Image',
filter='Image Files (*.png *.jpg)')
file_dialog.fileSelected.connect(self.set_thumbnail)
file_dialog.exec_()
def ui(self):
super(NameIt, self).ui()
tools_toolbar = toolbar.ToolBar('Main ToolBar', parent=self)
tools_toolbar.setMovable(False)
# tools_toolbar.setAllowedAreas(Qt.TopToolBarArea | Qt.BottomToolBarArea)
self.main_layout.addWidget(tools_toolbar)
refresh_btn = buttons.BaseToolButton(parent=tools_toolbar)
refresh_btn.setIcon(resources.icon('refresh'))
refresh_btn.clicked.connect(self._on_refresh)
self._refresh_btn = tools_toolbar.addWidget(refresh_btn)
self._refresh_btn.setEnabled(False)
save_btn = buttons.BaseToolButton(parent=tools_toolbar)
save_btn.setIcon(resources.icon('save'))
save_btn.clicked.connect(self._on_save)
self._save_btn = tools_toolbar.addWidget(save_btn)
self._save_btn.setEnabled(False)
if self._is_renamer_tool_available():
renamer_btn = buttons.BaseToolButton(parent=tools_toolbar)
renamer_btn.setIcon(resources.icon('rename'))
renamer_btn.clicked.connect(self._on_open_renamer_tool)
tools_toolbar.addWidget(renamer_btn)
self._name_file_line = directory.SelectFile(label_text='Naming File',
parent=tools_toolbar)
tools_toolbar.addWidget(self._name_file_line)
base_layout = layouts.HorizontalLayout(spacing=0, margins=(0, 0, 0, 0))
self.main_layout.addLayout(base_layout)
panels_splitter = QSplitter(parent=self)
panels_splitter.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
base_layout.addWidget(panels_splitter)
left_panel_widget = QWidget()
left_panel_layout = layouts.VerticalLayout(margins=(5, 0, 5, 0))
left_panel_widget.setLayout(left_panel_layout)
panels_splitter.addWidget(left_panel_widget)
# Tab Widget
rules_tab = QWidget()
tokens_tab = QWidget()
templates_tab = QWidget()
templates_tokens_tab = QWidget()
self.tabs = tabs.BaseTabWidget()
self.tabs.addTab(rules_tab, 'Rules')
self.tabs.addTab(tokens_tab, 'Tokens')
self.tabs.addTab(templates_tab, 'Templates')
self.tabs.addTab(templates_tokens_tab, 'Templates Tokens')
left_panel_layout.addWidget(self.tabs)
# Rules Tab
rules_main_layout = layouts.VerticalLayout(spacing=0,
margins=(5, 5, 5, 5))
self.rules_list = QListWidget()
rules_main_layout.addWidget(self.rules_list)
left_panel_buttons_layout_rules = layouts.HorizontalLayout(margins=(5,
5,
5,
0))
rules_main_layout.addLayout(left_panel_buttons_layout_rules)
self.add_rule_btn = buttons.BaseButton(parent=self)
self.remove_rule_btn = buttons.BaseButton(parent=self)
self.add_rule_btn.setIcon(resources.icon('plus'))
self.remove_rule_btn.setIcon(resources.icon('minus'))
left_panel_buttons_layout_rules.addStretch()
left_panel_buttons_layout_rules.addWidget(self.add_rule_btn)
left_panel_buttons_layout_rules.addWidget(self.remove_rule_btn)
rules_tab.setLayout(rules_main_layout)
# Tokens Tab
tokens_main_layout = layouts.VerticalLayout(margins=(5, 5, 5, 5))
tokens_main_layout.setSpacing(0)
self.tokens_list = QListWidget()
tokens_main_layout.addWidget(self.tokens_list)
left_panel_buttons_layout_tokens = layouts.HorizontalLayout(
margins=(5, 5, 5, 0))
tokens_main_layout.addLayout(left_panel_buttons_layout_tokens)
self.add_token_btn = buttons.BaseButton(parent=self)
self.remove_token_btn = buttons.BaseButton(parent=self)
self.add_token_btn.setIcon(resources.icon('plus'))
self.remove_token_btn.setIcon(resources.icon('minus'))
left_panel_buttons_layout_tokens.addStretch()
left_panel_buttons_layout_tokens.addWidget(self.add_token_btn)
left_panel_buttons_layout_tokens.addWidget(self.remove_token_btn)
tokens_tab.setLayout(tokens_main_layout)
# Templates Tab
templates_main_layout = layouts.VerticalLayout(spacing=0,
margins=(5, 5, 5, 5))
self.templates_list = QListWidget()
templates_main_layout.addWidget(self.templates_list)
left_panel_buttons_layout_templates = layouts.HorizontalLayout(
margins=(5, 5, 5, 0))
templates_main_layout.addLayout(left_panel_buttons_layout_templates)
self.add_template_btn = buttons.BaseButton(parent=self)
self.remove_template_btn = buttons.BaseButton(parent=self)
self.add_template_btn.setIcon(resources.icon('plus'))
self.remove_template_btn.setIcon(resources.icon('minus'))
left_panel_buttons_layout_templates.addStretch()
left_panel_buttons_layout_templates.addWidget(self.add_template_btn)
left_panel_buttons_layout_templates.addWidget(self.remove_template_btn)
templates_tab.setLayout(templates_main_layout)
# Template Tokens Tab
templates_tokens_main_layout = layouts.VerticalLayout(spacing=0,
margins=(5, 5, 5,
5))
self.template_tokens_list = QListWidget()
templates_tokens_main_layout.addWidget(self.template_tokens_list)
left_panel_buttons_layout_templates_tokens = layouts.HorizontalLayout(
margins=(5, 5, 5, 0))
left_panel_buttons_layout_templates_tokens.setContentsMargins(
5, 5, 5, 0)
templates_tokens_main_layout.addLayout(
left_panel_buttons_layout_templates_tokens)
self.add_template_token_btn = buttons.BaseButton(parent=self)
self.remove_template_token_btn = buttons.BaseButton(parent=self)
self.add_template_token_btn.setIcon(resources.icon('plus'))
self.remove_template_token_btn.setIcon(resources.icon('minus'))
left_panel_buttons_layout_templates_tokens.addStretch()
left_panel_buttons_layout_templates_tokens.addWidget(
self.add_template_token_btn)
left_panel_buttons_layout_templates_tokens.addWidget(
self.remove_template_token_btn)
templates_tokens_tab.setLayout(templates_tokens_main_layout)
# === PROPERTIES === #
main_group = QGroupBox('Properties')
panels_splitter.addWidget(main_group)
self.group_layout = layouts.VerticalLayout(spacing=0,
margins=(5, 5, 5, 5))
main_group.setLayout(self.group_layout)
# Rules Panel
self.rules_widget = QWidget(self)
rules_layout = layouts.GridLayout()
self.rules_widget.setLayout(rules_layout)
expression_lbl = label.BaseLabel('Expression', parent=self)
self.expression_line = lineedit.BaseLineEdit(parent=self)
self.expression_btn = buttons.BaseButton(' <', parent=self)
self.expression_btn.setEnabled(False)
self.expression_btn.setStyleSheet(
"QPushButton::menu-indicator{image:url(none.jpg);}")
self.expression_menu = QMenu(self)
self.expression_btn.setMenu(self.expression_menu)
iterator_lbl = label.BaseLabel('Iterator', parent=self)
self.iterator_cbx = combobox.BaseComboBox(parent=self)
for it_format in [
'@', '@^', '#', '##', '###', '####', '#####', 'None'
]:
self.iterator_cbx.addItem(it_format)
description_rule_lbl = label.BaseLabel('Description', parent=self)
self.description_rule_text = QTextEdit(parent=self)
self.group_layout.addWidget(self.rules_widget)
rules_layout.addWidget(expression_lbl, 0, 0, Qt.AlignRight)
rules_layout.addWidget(self.expression_line, 0, 1)
rules_layout.addWidget(self.expression_btn, 0, 2)
rules_layout.addWidget(iterator_lbl, 1, 0, Qt.AlignRight | Qt.AlignTop)
rules_layout.addWidget(self.iterator_cbx, 1, 1, 1, 2)
rules_layout.addWidget(description_rule_lbl, 2, 0,
Qt.AlignRight | Qt.AlignTop)
rules_layout.addWidget(self.description_rule_text, 2, 1, 1, 2)
# Tokens Panel
self.tokens_widget = QWidget(parent=self)
tokens_layout = layouts.GridLayout()
self.tokens_widget.setLayout(tokens_layout)
values_lbl = label.BaseLabel('Values')
data = {'key': list(), 'value': list()}
self.values_table = TokensTable(data, 0, 2)
self.values_table.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
values_buttons_layout = layouts.HorizontalLayout(margins=(5, 5, 5, 0))
self.add_key_value_btn = buttons.BaseButton(parent=self)
self.remove_key_value_btn = buttons.BaseButton(parent=self)
self.add_key_value_btn.setIcon(resources.icon('plus'))
self.remove_key_value_btn.setIcon(resources.icon('minus'))
values_buttons_layout.addWidget(self.add_key_value_btn)
values_buttons_layout.addWidget(self.remove_key_value_btn)
values_buttons_layout.addStretch()
default_lbl = label.BaseLabel('Default', parent=self)
self.default_cbx = combobox.BaseComboBox(parent=self)
description_tokens_lbl = label.BaseLabel('Description', parent=self)
self.description_token_text = QTextEdit(parent=self)
self.group_layout.addWidget(self.tokens_widget)
self.tokens_widget.hide()
tokens_layout.addWidget(values_lbl, 0, 0, Qt.AlignRight | Qt.AlignTop)
tokens_layout.addWidget(self.values_table, 0, 1, 2, 1)
tokens_layout.addLayout(values_buttons_layout, 0, 2)
tokens_layout.addWidget(default_lbl, 4, 0, Qt.AlignRight)
tokens_layout.addWidget(self.default_cbx, 4, 1, 1, 2)
tokens_layout.addWidget(description_tokens_lbl, 5, 0,
Qt.AlignRight | Qt.AlignTop)
tokens_layout.addWidget(self.description_token_text, 5, 1, 1, 2)
# Templates Panel
self.templates_widget = QWidget(parent=self)
templates_layout = layouts.VerticalLayout()
self.templates_widget.setLayout(templates_layout)
pattern_layout = layouts.HorizontalLayout(spacing=5,
margins=(5, 5, 5, 5))
pattern_lbl = label.BaseLabel('Pattern: ', parent=self)
self.pattern_line = lineedit.BaseLineEdit(parent=self)
pattern_layout.addWidget(pattern_lbl)
pattern_layout.addWidget(self.pattern_line)
templates_layout.addLayout(pattern_layout)
templates_layout.addLayout(dividers.DividerLayout())
self.template_tokens_layout = layouts.GridLayout()
self.template_tokens_layout.setAlignment(Qt.AlignTop)
template_tokens_frame = QFrame(parent=self)
template_tokens_frame.setFrameShape(QFrame.StyledPanel)
template_tokens_frame.setFrameShadow(QFrame.Sunken)
template_tokens_frame.setLayout(self.template_tokens_layout)
templates_layout.addWidget(template_tokens_frame)
self.group_layout.addWidget(self.templates_widget)
self.templates_widget.hide()
# Templates Tokens Panel
self.templates_tokens_widget = QWidget(parent=self)
templates_tokens_layout = layouts.VerticalLayout()
self.templates_tokens_widget.setLayout(templates_tokens_layout)
description_templates_token_layout = layouts.HorizontalLayout(
spacing=5, margins=(5, 5, 5, 5))
description_tokens_layout = layouts.VerticalLayout()
description_templates_token_lbl = label.BaseLabel('Description: ',
parent=self)
description_tokens_layout.addWidget(description_templates_token_lbl)
description_tokens_layout.addStretch()
self.description_templates_token_text = QTextEdit(parent=self)
description_templates_token_layout.addLayout(description_tokens_layout)
description_templates_token_layout.addWidget(
self.description_templates_token_text)
templates_tokens_layout.addLayout(description_templates_token_layout)
self.group_layout.addWidget(self.templates_tokens_widget)
self.templates_tokens_widget.hide()
# Initialize database
self._init_db()
# First update of the UI
self.update_expression_menu()
self.update_tokens_properties_state()
self.update_rules_properties_state()
self.update_templates_properties_state()
class MyToolBar(QWidget):
""" ToolBar widget """
# signal
trigger = Signal(int)
def __init__(self, flags, parent=None):
super(MyToolBar, self).__init__(parent)
self.setWindowFlags(Qt.ToolTip)
self.paddingX = 5
self.paddingY = 2
self.iconWidth = self.iconHeight = 28
self.setFixedHeight(self.iconHeight + 2 * self.paddingY)
# self.setFixedWidth(300)
self.rectButton = None
self.ellipseButton = None
self.arrowButton = None
self.lineButton = None
self.freePenButton = None
self.textButton = None
self.undoButton = None
self.cancelButton = None
self.okButton = None
self.saveButton = None
self.button_list = []
self.initWindow(flags)
def initDrawButtons(self, flags):
self.drawButtonGroup = QButtonGroup(self)
# draw action buttons
if flags & constant.RECT:
self.rectButton = QPushButton(self)
self.rectButton.setIcon(QIcon(":/resource/icon/rect.png"))
self.rectButton.setFixedSize(self.iconWidth, self.iconHeight)
self.rectButton.setCheckable(True)
self.drawButtonGroup.addButton(self.rectButton)
self.hlayout.addWidget(self.rectButton)
self.button_list.append(self.rectButton)
if flags & constant.ELLIPSE:
self.ellipseButton = QPushButton(self)
self.ellipseButton.setIcon(QIcon(":/resource/icon/ellipse.png"))
self.ellipseButton.setFixedSize(self.iconWidth, self.iconHeight)
self.ellipseButton.setCheckable(True)
self.drawButtonGroup.addButton(self.ellipseButton)
self.hlayout.addWidget(self.ellipseButton)
self.button_list.append(self.ellipseButton)
if flags & constant.ARROW:
self.arrowButton = QPushButton(self)
self.arrowButton.setIcon(QIcon(":/resource/icon/arrow.png"))
self.arrowButton.setFixedSize(self.iconWidth, self.iconHeight)
self.arrowButton.setCheckable(True)
self.drawButtonGroup.addButton(self.arrowButton)
self.hlayout.addWidget(self.arrowButton)
self.button_list.append(self.arrowButton)
if flags & constant.LINE:
self.lineButton = QPushButton(self)
self.lineButton.setIcon(QIcon(":/resource/icon/line.png"))
self.lineButton.setFixedSize(self.iconWidth, self.iconHeight)
self.lineButton.setCheckable(True)
self.drawButtonGroup.addButton(self.lineButton)
self.hlayout.addWidget(self.lineButton)
self.button_list.append(self.lineButton)
if flags & constant.FREEPEN:
self.freePenButton = QPushButton(self)
self.freePenButton.setIcon(QIcon(":/resource/icon/pen.png"))
self.freePenButton.setFixedSize(self.iconWidth, self.iconHeight)
self.freePenButton.setCheckable(True)
self.drawButtonGroup.addButton(self.freePenButton)
self.hlayout.addWidget(self.freePenButton)
self.button_list.append(self.freePenButton)
if flags & constant.TEXT:
self.textButton = QPushButton(self)
self.textButton.setIcon(QIcon(":/resource/icon/text.png"))
self.textButton.setFixedSize(self.iconWidth, self.iconHeight)
self.textButton.setCheckable(True)
self.drawButtonGroup.addButton(self.textButton)
self.hlayout.addWidget(self.textButton)
self.button_list.append(self.textButton)
self.drawButtonGroup.buttonClicked.connect(self.buttonToggled)
def initOtherButtons(self, flags):
# other action buttons
if len(self.button_list) != 0:
self.separator1 = QFrame(self)
self.separator1.setFrameShape(QFrame.VLine)
self.separator1.setFrameShadow(QFrame.Sunken)
self.hlayout.addWidget(self.separator1)
self.undoButton = QPushButton(self)
self.undoButton.setIcon(QIcon(":/resource/icon/undo.png"))
self.undoButton.setFixedSize(self.iconWidth, self.iconWidth)
self.undoButton.clicked.connect(self.otherButtonsClicked)
self.hlayout.addWidget(self.undoButton)
if flags & constant.SAVE_TO_FILE:
self.saveButton = QPushButton(self)
self.saveButton.setIcon(QIcon(":/resource/icon/save.png"))
self.saveButton.setFixedSize(self.iconWidth, self.iconHeight)
self.saveButton.clicked.connect(self.otherButtonsClicked)
self.hlayout.addWidget(self.saveButton)
self.separator2 = QFrame(self)
self.separator2.setFrameShape(QFrame.VLine)
self.separator2.setFrameShadow(QFrame.Sunken)
self.hlayout.addWidget(self.separator2)
self.cancelButton = QPushButton(self)
self.cancelButton.setIcon(QIcon(":/resource/icon/close.png"))
self.cancelButton.setFixedSize(self.iconWidth, self.iconHeight)
self.cancelButton.clicked.connect(self.otherButtonsClicked)
if flags & constant.CLIPBOARD:
self.okButton = QPushButton(self)
self.okButton.setIcon(QIcon(":/resource/icon/check.png"))
self.okButton.setFixedSize(self.iconWidth, self.iconHeight)
self.okButton.clicked.connect(self.otherButtonsClicked)
self.hlayout.addWidget(self.okButton)
self.hlayout.addWidget(self.cancelButton)
def initWindow(self, flags):
self.hlayout = QHBoxLayout()
self.hlayout.setSpacing(2)
self.hlayout.setContentsMargins(10, 2, 10, 2)
self.setLayout(self.hlayout)
self.initDrawButtons(flags)
self.initOtherButtons(flags)
# slots
def buttonToggled(self, button):
"""
:type button: QPushButton
:param button:
:return:
"""
if button == self.rectButton:
self.trigger.emit(ACTION_RECT)
elif button == self.ellipseButton:
self.trigger.emit(ACTION_ELLIPSE)
elif button == self.arrowButton:
self.trigger.emit(ACTION_ARROW)
elif button == self.lineButton:
self.trigger.emit(ACTION_LINE)
elif button == self.freePenButton:
self.trigger.emit(ACTION_FREEPEN)
elif button == self.textButton:
self.trigger.emit(ACTION_TEXT)
else:
pass
def otherButtonsClicked(self):
if self.sender() == self.undoButton:
self.trigger.emit(ACTION_UNDO)
elif self.sender() == self.cancelButton:
self.trigger.emit(ACTION_CANCEL)
elif self.sender() == self.okButton:
self.trigger.emit(ACTION_SURE)
elif self.sender() == self.saveButton:
self.trigger.emit(ACTION_SAVE)
def ui(self):
super(LoadWidget, self).ui()
tabs_widget = tabs.BaseTabWidget(parent=self)
info_widget = QWidget()
info_layout = layouts.VerticalLayout(spacing=0, margins=(0, 0, 0, 0))
info_widget.setLayout(info_layout)
if self.OPTIONS_WIDGET:
self._options_widget = self.OPTIONS_WIDGET(parent=self)
title_layout = layouts.HorizontalLayout(spacing=1,
margins=(1, 1, 0, 0))
self._icon_lbl = label.BaseLabel('', parent=self)
self._icon_lbl.setMaximumSize(QSize(14, 14))
self._icon_lbl.setMinimumSize(QSize(14, 14))
self._icon_lbl.setScaledContents(True)
self._title_lbl = label.BaseLabel('Title', parent=self)
title_layout.addWidget(self._icon_lbl)
title_layout.addWidget(self._title_lbl)
icon_toggle_box = QFrame()
icon_toggle_box.setFrameShape(QFrame.NoFrame)
icon_toggle_box.setFrameShadow(QFrame.Plain)
icon_toggle_box_lyt = layouts.VerticalLayout(spacing=1,
margins=(0, 1, 0, 0))
icon_toggle_box.setLayout(icon_toggle_box_lyt)
icon_toggle_box_header = QFrame()
icon_toggle_box_header.setFrameShape(QFrame.NoFrame)
icon_toggle_box_header.setFrameShadow(QFrame.Plain)
icon_toggle_box_header_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0,
0))
icon_toggle_box_header.setLayout(icon_toggle_box_header_lyt)
self._icon_toggle_box_btn = buttons.BaseButton('ICON', parent=self)
self._icon_toggle_box_btn.setObjectName('iconButton')
self._icon_toggle_box_btn.setCheckable(True)
self._icon_toggle_box_btn.setChecked(True)
icon_toggle_box_header_lyt.addWidget(self._icon_toggle_box_btn)
self._icon_toggle_box_frame = QFrame()
self._icon_toggle_box_frame.setFrameShape(QFrame.NoFrame)
self._icon_toggle_box_frame.setFrameShadow(QFrame.Plain)
icon_toggle_box_frame_lyt = layouts.VerticalLayout(spacing=1,
margins=(0, 1, 0,
0))
self._icon_toggle_box_frame.setLayout(icon_toggle_box_frame_lyt)
thumbnail_layout = layouts.HorizontalLayout(spacing=0,
margins=(0, 0, 0, 0))
icon_toggle_box_frame_lyt.addLayout(thumbnail_layout)
thumbnail_frame_layout = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
self._thumbnail_frame = QFrame()
self._thumbnail_frame.setFrameShape(QFrame.NoFrame)
self._thumbnail_frame.setFrameShadow(QFrame.Plain)
self._thumbnail_frame.setLayout(thumbnail_frame_layout)
thumbnail_layout.addWidget(self._thumbnail_frame)
self._thumbnail_btn = QToolButton()
self._thumbnail_btn.setObjectName('thumbnailButton')
self._thumbnail_btn.setMinimumSize(QSize(0, 0))
self._thumbnail_btn.setMaximumSize(QSize(150, 150))
self._thumbnail_btn.setStyleSheet(
'color: rgb(40, 40, 40);\nborder: 1px solid rgb(0, 0, 0, 0);\nbackground-color: rgb(254, 255, 230, 0);'
)
self._thumbnail_btn.setLayoutDirection(Qt.LeftToRight)
self._thumbnail_btn.setText('Snapshot')
self._thumbnail_btn.setIcon(resources.icon('thumbnail'))
thumbnail_frame_layout.addWidget(self._thumbnail_btn)
icon_toggle_box_lyt.addWidget(icon_toggle_box_header)
icon_toggle_box_lyt.addWidget(self._icon_toggle_box_frame)
info_toggle_box = QFrame()
info_toggle_box.setFrameShape(QFrame.NoFrame)
info_toggle_box.setFrameShadow(QFrame.Plain)
info_toggle_box_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
info_toggle_box.setLayout(info_toggle_box_lyt)
info_toggle_box_header = QFrame()
info_toggle_box_header.setFrameShape(QFrame.NoFrame)
info_toggle_box_header.setFrameShadow(QFrame.Plain)
info_toggle_box_header_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0,
0))
info_toggle_box_header.setLayout(info_toggle_box_header_lyt)
self._info_toggle_box_btn = buttons.BaseButton('INFO', parent=self)
self._info_toggle_box_btn.setObjectName('infoButton')
self._info_toggle_box_btn.setCheckable(True)
self._info_toggle_box_btn.setChecked(True)
info_toggle_box_header_lyt.addWidget(self._info_toggle_box_btn)
self._info_toggle_box_frame = QFrame()
self._info_toggle_box_frame.setFrameShape(QFrame.NoFrame)
self._info_toggle_box_frame.setFrameShadow(QFrame.Plain)
info_toggle_box_frame_lyt = layouts.VerticalLayout(spacing=1,
margins=(0, 1, 0,
0))
self._info_toggle_box_frame.setLayout(info_toggle_box_frame_lyt)
self._info_frame = QFrame()
self._info_frame.setFrameShape(QFrame.NoFrame)
self._info_frame.setFrameShadow(QFrame.Plain)
info_frame_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
self._info_frame.setLayout(info_frame_lyt)
info_toggle_box_frame_lyt.addWidget(self._info_frame)
info_toggle_box_lyt.addWidget(info_toggle_box_header)
info_toggle_box_lyt.addWidget(self._info_toggle_box_frame)
version_toggle_box = QFrame()
version_toggle_box.setFrameShape(QFrame.NoFrame)
version_toggle_box.setFrameShadow(QFrame.Plain)
version_toggle_box_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
version_toggle_box.setLayout(version_toggle_box_lyt)
version_toggle_box_header = QFrame()
version_toggle_box_header.setFrameShape(QFrame.NoFrame)
version_toggle_box_header.setFrameShadow(QFrame.Plain)
version_toggle_box_header_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0,
0, 0))
version_toggle_box_header.setLayout(version_toggle_box_header_lyt)
self._version_toggle_box_btn = buttons.BaseButton('VERSION',
parent=self)
self._version_toggle_box_btn.setObjectName('versionButton')
self._version_toggle_box_btn.setCheckable(True)
self._version_toggle_box_btn.setChecked(True)
version_toggle_box_header_lyt.addWidget(self._version_toggle_box_btn)
self._version_toggle_box_frame = QFrame()
self._version_toggle_box_frame.setFrameShape(QFrame.NoFrame)
self._version_toggle_box_frame.setFrameShadow(QFrame.Plain)
version_toggle_box_frame_lyt = layouts.VerticalLayout(spacing=1,
margins=(0, 1, 0,
0))
self._version_toggle_box_frame.setLayout(version_toggle_box_frame_lyt)
self._version_frame = QFrame()
self._version_frame.setFrameShape(QFrame.NoFrame)
self._version_frame.setFrameShadow(QFrame.Plain)
version_frame_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
self._version_frame.setLayout(version_frame_lyt)
version_toggle_box_frame_lyt.addWidget(self._version_frame)
self._history_widget = self.HISTORY_WIDGET()
version_frame_lyt.addWidget(self._history_widget)
version_toggle_box_lyt.addWidget(version_toggle_box_header)
version_toggle_box_lyt.addWidget(self._version_toggle_box_frame)
preview_buttons_frame = QFrame()
preview_buttons_frame.setObjectName('previewButtons')
preview_buttons_frame.setFrameShape(QFrame.NoFrame)
preview_buttons_frame.setFrameShadow(QFrame.Plain)
self._preview_buttons_frame_lyt = layouts.VerticalLayout(spacing=0,
margins=(2, 2,
2,
2))
self._preview_buttons_lyt = layouts.HorizontalLayout(spacing=2,
margins=(0, 0, 0,
0))
self._load_btn = buttons.BaseButton('Load', parent=self)
self._load_btn.setObjectName('loadButton')
self._load_btn.setMinimumSize(QSize(60, 35))
self._load_btn.setMaximumSize(QSize(125, 35))
self._preview_buttons_frame_lyt.addStretch()
self._preview_buttons_frame_lyt.addLayout(self._preview_buttons_lyt)
self._preview_buttons_frame_lyt.addStretch()
self._preview_buttons_lyt.addWidget(self._load_btn)
preview_buttons_frame.setLayout(self._preview_buttons_frame_lyt)
info_layout.addLayout(title_layout)
info_layout.addWidget(icon_toggle_box)
info_layout.addWidget(info_toggle_box)
info_layout.addWidget(version_toggle_box)
tabs_widget.addTab(info_widget, 'Info')
if self._options_widget:
tabs_widget.addTab(self._options_widget, 'Options')
self.main_layout.addWidget(tabs_widget)
self.main_layout.addWidget(dividers.Divider())
self.main_layout.addWidget(preview_buttons_frame)
self.main_layout.addItem(
QSpacerItem(0, 250, QSizePolicy.Preferred, QSizePolicy.Expanding))
class LoadWidget(BaseLoadWidget, object):
HISTORY_WIDGET = history.HistoryFileWidget
OPTIONS_WIDGET = None
def __init__(self, item, parent=None):
self._icon_path = ''
self._script_job = None
self._options_widget = None
super(LoadWidget, self).__init__(item, parent=parent)
self.load_settings()
self.create_sequence_widget()
self.update_thumbnail_size()
def ui(self):
super(LoadWidget, self).ui()
tabs_widget = tabs.BaseTabWidget(parent=self)
info_widget = QWidget()
info_layout = layouts.VerticalLayout(spacing=0, margins=(0, 0, 0, 0))
info_widget.setLayout(info_layout)
if self.OPTIONS_WIDGET:
self._options_widget = self.OPTIONS_WIDGET(parent=self)
title_layout = layouts.HorizontalLayout(spacing=1,
margins=(1, 1, 0, 0))
self._icon_lbl = label.BaseLabel('', parent=self)
self._icon_lbl.setMaximumSize(QSize(14, 14))
self._icon_lbl.setMinimumSize(QSize(14, 14))
self._icon_lbl.setScaledContents(True)
self._title_lbl = label.BaseLabel('Title', parent=self)
title_layout.addWidget(self._icon_lbl)
title_layout.addWidget(self._title_lbl)
icon_toggle_box = QFrame()
icon_toggle_box.setFrameShape(QFrame.NoFrame)
icon_toggle_box.setFrameShadow(QFrame.Plain)
icon_toggle_box_lyt = layouts.VerticalLayout(spacing=1,
margins=(0, 1, 0, 0))
icon_toggle_box.setLayout(icon_toggle_box_lyt)
icon_toggle_box_header = QFrame()
icon_toggle_box_header.setFrameShape(QFrame.NoFrame)
icon_toggle_box_header.setFrameShadow(QFrame.Plain)
icon_toggle_box_header_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0,
0))
icon_toggle_box_header.setLayout(icon_toggle_box_header_lyt)
self._icon_toggle_box_btn = buttons.BaseButton('ICON', parent=self)
self._icon_toggle_box_btn.setObjectName('iconButton')
self._icon_toggle_box_btn.setCheckable(True)
self._icon_toggle_box_btn.setChecked(True)
icon_toggle_box_header_lyt.addWidget(self._icon_toggle_box_btn)
self._icon_toggle_box_frame = QFrame()
self._icon_toggle_box_frame.setFrameShape(QFrame.NoFrame)
self._icon_toggle_box_frame.setFrameShadow(QFrame.Plain)
icon_toggle_box_frame_lyt = layouts.VerticalLayout(spacing=1,
margins=(0, 1, 0,
0))
self._icon_toggle_box_frame.setLayout(icon_toggle_box_frame_lyt)
thumbnail_layout = layouts.HorizontalLayout(spacing=0,
margins=(0, 0, 0, 0))
icon_toggle_box_frame_lyt.addLayout(thumbnail_layout)
thumbnail_frame_layout = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
self._thumbnail_frame = QFrame()
self._thumbnail_frame.setFrameShape(QFrame.NoFrame)
self._thumbnail_frame.setFrameShadow(QFrame.Plain)
self._thumbnail_frame.setLayout(thumbnail_frame_layout)
thumbnail_layout.addWidget(self._thumbnail_frame)
self._thumbnail_btn = QToolButton()
self._thumbnail_btn.setObjectName('thumbnailButton')
self._thumbnail_btn.setMinimumSize(QSize(0, 0))
self._thumbnail_btn.setMaximumSize(QSize(150, 150))
self._thumbnail_btn.setStyleSheet(
'color: rgb(40, 40, 40);\nborder: 1px solid rgb(0, 0, 0, 0);\nbackground-color: rgb(254, 255, 230, 0);'
)
self._thumbnail_btn.setLayoutDirection(Qt.LeftToRight)
self._thumbnail_btn.setText('Snapshot')
self._thumbnail_btn.setIcon(resources.icon('thumbnail'))
thumbnail_frame_layout.addWidget(self._thumbnail_btn)
icon_toggle_box_lyt.addWidget(icon_toggle_box_header)
icon_toggle_box_lyt.addWidget(self._icon_toggle_box_frame)
info_toggle_box = QFrame()
info_toggle_box.setFrameShape(QFrame.NoFrame)
info_toggle_box.setFrameShadow(QFrame.Plain)
info_toggle_box_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
info_toggle_box.setLayout(info_toggle_box_lyt)
info_toggle_box_header = QFrame()
info_toggle_box_header.setFrameShape(QFrame.NoFrame)
info_toggle_box_header.setFrameShadow(QFrame.Plain)
info_toggle_box_header_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0,
0))
info_toggle_box_header.setLayout(info_toggle_box_header_lyt)
self._info_toggle_box_btn = buttons.BaseButton('INFO', parent=self)
self._info_toggle_box_btn.setObjectName('infoButton')
self._info_toggle_box_btn.setCheckable(True)
self._info_toggle_box_btn.setChecked(True)
info_toggle_box_header_lyt.addWidget(self._info_toggle_box_btn)
self._info_toggle_box_frame = QFrame()
self._info_toggle_box_frame.setFrameShape(QFrame.NoFrame)
self._info_toggle_box_frame.setFrameShadow(QFrame.Plain)
info_toggle_box_frame_lyt = layouts.VerticalLayout(spacing=1,
margins=(0, 1, 0,
0))
self._info_toggle_box_frame.setLayout(info_toggle_box_frame_lyt)
self._info_frame = QFrame()
self._info_frame.setFrameShape(QFrame.NoFrame)
self._info_frame.setFrameShadow(QFrame.Plain)
info_frame_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
self._info_frame.setLayout(info_frame_lyt)
info_toggle_box_frame_lyt.addWidget(self._info_frame)
info_toggle_box_lyt.addWidget(info_toggle_box_header)
info_toggle_box_lyt.addWidget(self._info_toggle_box_frame)
version_toggle_box = QFrame()
version_toggle_box.setFrameShape(QFrame.NoFrame)
version_toggle_box.setFrameShadow(QFrame.Plain)
version_toggle_box_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
version_toggle_box.setLayout(version_toggle_box_lyt)
version_toggle_box_header = QFrame()
version_toggle_box_header.setFrameShape(QFrame.NoFrame)
version_toggle_box_header.setFrameShadow(QFrame.Plain)
version_toggle_box_header_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0,
0, 0))
version_toggle_box_header.setLayout(version_toggle_box_header_lyt)
self._version_toggle_box_btn = buttons.BaseButton('VERSION',
parent=self)
self._version_toggle_box_btn.setObjectName('versionButton')
self._version_toggle_box_btn.setCheckable(True)
self._version_toggle_box_btn.setChecked(True)
version_toggle_box_header_lyt.addWidget(self._version_toggle_box_btn)
self._version_toggle_box_frame = QFrame()
self._version_toggle_box_frame.setFrameShape(QFrame.NoFrame)
self._version_toggle_box_frame.setFrameShadow(QFrame.Plain)
version_toggle_box_frame_lyt = layouts.VerticalLayout(spacing=1,
margins=(0, 1, 0,
0))
self._version_toggle_box_frame.setLayout(version_toggle_box_frame_lyt)
self._version_frame = QFrame()
self._version_frame.setFrameShape(QFrame.NoFrame)
self._version_frame.setFrameShadow(QFrame.Plain)
version_frame_lyt = layouts.VerticalLayout(spacing=0,
margins=(0, 0, 0, 0))
self._version_frame.setLayout(version_frame_lyt)
version_toggle_box_frame_lyt.addWidget(self._version_frame)
self._history_widget = self.HISTORY_WIDGET()
version_frame_lyt.addWidget(self._history_widget)
version_toggle_box_lyt.addWidget(version_toggle_box_header)
version_toggle_box_lyt.addWidget(self._version_toggle_box_frame)
preview_buttons_frame = QFrame()
preview_buttons_frame.setObjectName('previewButtons')
preview_buttons_frame.setFrameShape(QFrame.NoFrame)
preview_buttons_frame.setFrameShadow(QFrame.Plain)
self._preview_buttons_frame_lyt = layouts.VerticalLayout(spacing=0,
margins=(2, 2,
2,
2))
self._preview_buttons_lyt = layouts.HorizontalLayout(spacing=2,
margins=(0, 0, 0,
0))
self._load_btn = buttons.BaseButton('Load', parent=self)
self._load_btn.setObjectName('loadButton')
self._load_btn.setMinimumSize(QSize(60, 35))
self._load_btn.setMaximumSize(QSize(125, 35))
self._preview_buttons_frame_lyt.addStretch()
self._preview_buttons_frame_lyt.addLayout(self._preview_buttons_lyt)
self._preview_buttons_frame_lyt.addStretch()
self._preview_buttons_lyt.addWidget(self._load_btn)
preview_buttons_frame.setLayout(self._preview_buttons_frame_lyt)
info_layout.addLayout(title_layout)
info_layout.addWidget(icon_toggle_box)
info_layout.addWidget(info_toggle_box)
info_layout.addWidget(version_toggle_box)
tabs_widget.addTab(info_widget, 'Info')
if self._options_widget:
tabs_widget.addTab(self._options_widget, 'Options')
self.main_layout.addWidget(tabs_widget)
self.main_layout.addWidget(dividers.Divider())
self.main_layout.addWidget(preview_buttons_frame)
self.main_layout.addItem(
QSpacerItem(0, 250, QSizePolicy.Preferred, QSizePolicy.Expanding))
def setup_signals(self):
self._info_toggle_box_btn.clicked.connect(self.save_settings)
self._info_toggle_box_btn.toggled[bool].connect(
self._info_toggle_box_frame.setVisible)
self._icon_toggle_box_btn.clicked.connect(self.save_settings)
self._icon_toggle_box_btn.toggled[bool].connect(
self._icon_toggle_box_frame.setVisible)
self._version_toggle_box_btn.clicked.connect(self.save_settings)
self._version_toggle_box_btn.toggled[bool].connect(
self._version_toggle_box_frame.setVisible)
self._load_btn.clicked.connect(self.load)
def resizeEvent(self, event):
"""
Function that overrides base.BaseWidget function
:param event: QSizeEvent
"""
self.update_thumbnail_size()
def set_item(self, item):
"""
Sets the library item to load
:param item: LibraryItem
"""
super(LoadWidget, self).set_item(item)
self._title_lbl.setText(item.MenuName)
self._icon_lbl.setPixmap(QPixmap(item.type_icon_path()))
info_widget = formwidget.FormWidget(self)
info_widget.set_schema(item.info())
self._info_frame.layout().addWidget(info_widget)
self.refresh()
def load_btn(self):
"""
Returns button that loads the data
:return: QPushButton
"""
return self._load_btn
def icon_path(self):
"""
Returns the icon path to be used for the thumbnail
:return: str
"""
return self._icon_path
def set_icon_path(self, path):
"""
Sets the icon path to be used for the thumbnail
:param path: str
"""
self._icon_path = path
icon = QIcon(QPixmap(path))
self.set_icon(icon)
self.update_thumbnail_size()
self.item().update()
def set_icon(self, icon):
"""
Sets the icon to be shown for the preview
:param icon: QIcon
"""
self._thumbnail_btn.setIcon(icon)
self._thumbnail_btn.setIconSize(QSize(200, 200))
self._thumbnail_btn.setText('')
def refresh(self):
"""
Refreshes load widgetz
"""
self.update_history()
self.update_options()
def update_history(self):
"""
Updates history version of the current selected item
"""
if not self._item:
return
data_object = self._item.data_object()
if not data_object:
return
self._history_widget.set_directory(data_object.directory)
self._history_widget.refresh()
def update_options(self):
"""
Updates options widget
"""
if not self._options_widget:
return
if not self._item:
return
data_object = self._item.data_object()
if not data_object:
return
self._options_widget.set_data_object(data_object)
def is_editable(self):
"""
Returns whether the user can edit the item or not
:return: bool
"""
item = self.item()
editable = True
if item and item.library_window():
editable = not item.library_window().is_locked()
return editable
def create_sequence_widget(self):
"""
Creates a sequence widget to replace the static thumbnail widget
"""
self._sequence_widget = widgets.LibraryImageSequenceWidget(self)
self._sequence_widget.setStyleSheet(self._thumbnail_btn.styleSheet())
self._sequence_widget.setToolTip(self._thumbnail_btn.toolTip())
self._thumbnail_frame.layout().insertWidget(0, self._sequence_widget)
self._thumbnail_btn.hide()
self._thumbnail_btn = self._sequence_widget
path = self.item().thumbnail_path()
if path and os.path.exists(path):
self.set_icon_path(path)
if self.item().image_sequence_path():
self._sequence_widget.set_dirname(
self.item().image_sequence_path())
def update_thumbnail_size(self):
"""
Updates the thumbnail button to the size of the widget
"""
width = self.width() - 10
if width > 250:
width = 250
size = QSize(width, width)
self._thumbnail_btn.setIconSize(size)
self._thumbnail_btn.setMaximumSize(size)
self._thumbnail_frame.setMaximumSize(size)
def settings(self):
"""
Returns the current state of the widget
:return: dict
"""
settings = dict()
settings['iconToggleBoxChecked'] = self._icon_toggle_box_btn.isChecked(
)
settings['infoToggleBoxChecked'] = self._info_toggle_box_btn.isChecked(
)
settings[
'versionToggleBoxChecked'] = self._version_toggle_box_btn.isChecked(
)
return settings
def save_settings(self):
pass
def load_settings(self):
pass
def load(self):
"""
Loads current item
"""
if not self.item():
return
self.item().load_from_current_options()
class PenSetWidget(QWidget):
penSizeTrigger = Signal(int)
penColorTrigger = Signal(str)
fontChangeTrigger = Signal(QFont)
def __init__(self, parent=None):
super(PenSetWidget, self).__init__(parent)
self.paddingX = 5
self.paddingY = 2
self.iconWidth = self.iconHeight = 24
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.setWindowFlags(Qt.ToolTip)
self.initWindows()
self.prevSizeButton = self.penSize1
self.penSize1.setChecked(True)
self.presentColor.setStyleSheet(
'QPushButton { background-color: %s; }' % PENCOLOR)
def generateButtons(self, parent=None):
""" Generate buttons due to colorDic """
self.colorButtons = []
for color in self.colorList:
button = QPushButton(parent)
button.setObjectName(color[0])
button.setStyleSheet('QPushButton { background-color: %s; }' %
color[1])
button.setFixedSize(self.iconWidth / 2, self.iconHeight / 2)
button.setCheckable(True)
self.colorButtons.append(button)
def initWindows(self):
self.mainLayout = QHBoxLayout()
self.setLayout(self.mainLayout)
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(5, 2, 5, 2)
self.initPenSizeButtons()
self.initFontWidget()
self.initPenColorButtons()
self.separator = QFrame(self)
self.separator.setFrameShape(QFrame.VLine)
self.separator.setFrameShadow(QFrame.Sunken)
self.mainLayout.addWidget(self.penSize)
self.mainLayout.addWidget(self.changeFontButton)
self.mainLayout.addWidget(self.separator)
self.mainLayout.addWidget(self.colorSet)
def initPenSizeButtons(self):
self.penSize = QWidget(self)
self.penSizeLayout = QHBoxLayout()
self.penSize.setLayout(self.penSizeLayout)
# adjust pen size
self.penSize1 = QPushButton(self.penSize)
self.penSize1.setIcon(QIcon(":/resource/icon/pensize1.png"))
self.penSize1.setObjectName('1')
self.penSize1.setFixedSize(self.iconWidth, self.iconHeight)
self.penSize1.setCheckable(True)
self.penSize2 = QPushButton(self.penSize)
self.penSize2.setIcon(QIcon(":/resource/icon/pensize2.png"))
self.penSize2.setObjectName('2')
self.penSize2.setFixedSize(self.iconWidth, self.iconHeight)
self.penSize2.setCheckable(True)
self.penSize3 = QPushButton(self.penSize)
self.penSize3.setIcon(QIcon(":/resource/icon/pensize3.png"))
self.penSize3.setObjectName('3')
self.penSize3.setFixedSize(self.iconWidth, self.iconHeight)
self.penSize3.setCheckable(True)
self.sizeButtonGroup = QButtonGroup(self.penSize)
self.sizeButtonGroup.addButton(self.penSize1)
self.sizeButtonGroup.addButton(self.penSize2)
self.sizeButtonGroup.addButton(self.penSize3)
self.sizeButtonGroup.buttonClicked.connect(self.sizeButtonToggled)
self.penSizeLayout.addWidget(self.penSize1)
self.penSizeLayout.addWidget(self.penSize2)
self.penSizeLayout.addWidget(self.penSize3)
self.penSizeLayout.setSpacing(5)
self.penSizeLayout.setContentsMargins(0, 0, 0, 0)
def initPenColorButtons(self):
self.colorSet = QWidget(self)
self.colorLayout = QHBoxLayout()
self.colorLayout.setSpacing(5)
self.colorLayout.setContentsMargins(5, 0, 5, 0)
self.colorSet.setLayout(self.colorLayout)
self.presentColor = QPushButton(self.colorSet)
self.presentColor.setFixedSize(self.iconWidth, self.iconHeight)
self.presentColor.setEnabled(False)
# adjust pen color
self.colorPick = QWidget(self.colorSet)
self.colorGrid = QGridLayout()
self.colorGrid.setSpacing(0)
self.colorGrid.setContentsMargins(5, 0, 5, 0)
self.colorPick.setLayout(self.colorGrid)
self.colorList = [('white', '#ffffff'), ('red', '#ff0000'),
('green', '#00ff00'), ('blue', '#0000ff'),
('cyan', '#00ffff'), ('magenta', '#ff00ff'),
('yellow', '#ffff00'), ('gray', '#a0a0a4'),
('black', '#000000'), ('darkRed', '#800000'),
('darkGreen', '#008000'), ('darkBlue', '#000080'),
('darkCyan', '#008080'), ('darkMagenta', '#800080'),
('darkYellow', '#808000'), ('darkGray', '#808080')]
self.generateButtons()
self.colorButtonGroup = QButtonGroup(self)
for button in self.colorButtons:
self.colorButtonGroup.addButton(button)
self.colorButtonGroup.buttonClicked.connect(self.colorButtonToggled)
# set the layout
tmp = 0
for x in range(0, 2):
for y in range(0, int(len(self.colorList) / 2)):
self.colorGrid.addWidget(self.colorButtons[tmp], x, y)
tmp += 1
self.colorGrid.setSpacing(0)
self.colorGrid.setContentsMargins(0, 0, 0, 0)
self.colorLayout.addWidget(self.presentColor)
self.colorLayout.addWidget(self.colorPick)
def initFontWidget(self):
self.fontDialog = QFontDialog()
self.changeFontButton = QPushButton(self)
self.fontDialog.setCurrentFont(QFont('Sans serif'))
self.changeFontButton.setText('{0} {1}'.format(
self.fontDialog.currentFont().family(),
self.fontDialog.currentFont().pointSize()))
self.changeFontButton.clicked.connect(self.fontButtonClicked)
def showFontWidget(self):
self.changeFontButton.show()
self.penSize1.hide()
self.penSize2.hide()
self.penSize3.hide()
def showPenWidget(self):
self.changeFontButton.hide()
self.penSize1.show()
self.penSize2.show()
self.penSize3.show()
# slots
def colorButtonToggled(self, button):
self.presentColor.setStyleSheet(
'QPushButton { background-color: %s; }' % button.objectName())
self.penColorTrigger.emit(button.objectName())
def sizeButtonToggled(self, button):
self.penSizeTrigger.emit(int(button.objectName()) * 2)
def fontButtonClicked(self):
ok = True
font = QFontDialog.getFont(self)
if font[1]:
self.changeFontButton.setText('{0} {1}'.format(
font[0].family(), font[0].pointSize()))
self.fontChangeTrigger.emit(font[0])
class IndexedStringsWidget(QWidget):
""" Holds the list of indexed string attributes """
def __init__(self, data, parent=None):
QWidget.__init__(self, parent)
self.data = data
vbox = QVBoxLayout()
self.setLayout(vbox)
title = QLabel('Indexed Strings')
vbox.addWidget(title)
self.frame = QFrame()
vbox.addWidget(self.frame)
self.vbox = QVBoxLayout()
self.frame.setLayout(self.vbox)
self.frame.setFrameShape(QFrame.Panel)
self.frame.setFrameShadow(QFrame.Sunken)
self.table = QTableWidget()
self.table.horizontalHeader().hide()
self.vbox.addWidget(self.table)
self.table.hide()
self.noStringsLabel = QLabel('<i>No indexed strings</i>')
self.vbox.addWidget(self.noStringsLabel)
self.widgets = []
self.populate()
self.data.attributeAdded.connect(self.attributeAddedSlot)
self.data.dataReset.connect(self.dataResetSlot)
self.data.dirtied.connect(self.dataDirtiedSlot)
def dataDirtiedSlot(self, dirty):
""" SLOT when the particle data is dirtied or cleaned."""
if not dirty:
for widget in self.widgets:
widget.drawBorder(False)
def dataResetSlot(self):
""" SLOT when particle data is reconstructed """
self.populate()
def attributeAddedSlot(self, name): #pylint:disable=W0613
""" SLOT when an attribute is added to the particle set """
attr = self.data.attributeInfo(name)
if attr.type == partio.INDEXEDSTR:
self.populate()
def populate(self):
""" Populates the table of indexed strings """
self.widgets = []
# If no widgets, just drop that in
attrs = []
for anum in range(self.data.numAttributes()):
attr = self.data.attributeInfo(anum)
if attr.type == partio.INDEXEDSTR:
attrs.append(attr)
if not attrs:
self.table.hide()
self.noStringsLabel.show()
return
self.table.show()
self.noStringsLabel.hide()
self.table.setColumnCount(1)
self.table.setRowCount(len(attrs))
for row, attr in enumerate(attrs):
item = QTableWidgetItem(attr.name)
self.table.setVerticalHeaderItem(row, item)
strings = self.data.indexedStrs(attr)
table = QTableWidget()
table.setColumnCount(1)
table.setRowCount(len(strings))
table.horizontalHeader().hide()
table.setVerticalHeaderLabels([str(i) for i in range(len(strings))])
for i, string in enumerate(strings):
widget = QLabel(string)
table.setCellWidget(i, 0, widget)
self.widgets.append(widget)
self.table.setCellWidget(row, 0, table)
self.table.horizontalHeader().setStretchLastSection(False)
self.table.setTabKeyNavigation(True)
self.table.horizontalHeader().setSectionsMovable(False)
self.table.horizontalHeader().resizeSections(QHeaderView.ResizeToContents)
self.table.verticalHeader().resizeSections(QHeaderView.ResizeToContents)
