def ui(self):
super(AssetsManagerSettingsWidget, self).ui()
self._auto_check_published_cbx = QCheckBox('Auto Check Published Versions?')
self.main_layout.addWidget(self._auto_check_published_cbx)
self._auto_check_working_cbx = QCheckBox('Auto Check Working Versions?')
self.main_layout.addWidget(self._auto_check_working_cbx)
self._auto_check_lock_cbx = QCheckBox('Check Lock/Unlock Working Versions?')
self.main_layout.addWidget(self._auto_check_lock_cbx)
self.main_layout.addLayout(dividers.DividerLayout())
self.main_layout.addItem(QSpacerItem(0, 10, QSizePolicy.Preferred, QSizePolicy.Expanding))
bottom_layout = QHBoxLayout()
bottom_layout.setContentsMargins(0, 0, 0, 0)
bottom_layout.setSpacing(1)
self.main_layout.addLayout(bottom_layout)
save_icon = tpDcc.ResourcesMgr().icon('save')
cancel_icon = tpDcc.ResourcesMgr().icon('close')
self._save_btn = QPushButton('Save')
self._save_btn.setIcon(save_icon)
self._cancel_btn = QPushButton('Cancel')
self._cancel_btn.setIcon(cancel_icon)
bottom_layout.addWidget(self._save_btn)
bottom_layout.addWidget(self._cancel_btn)
def _create_context_menu(self, context_menu):
"""
Internal function that generates contextual menu for asset widget
Reimplement for custom functionality
:param context_menu: Menu
"""
sync_icon = tpDcc.ResourcesMgr().icon('sync')
artella_icon = tpDcc.ResourcesMgr().icon('artella')
eye_icon = tpDcc.ResourcesMgr().icon('eye')
artella_action = QAction(artella_icon, 'Open in Artella', context_menu)
view_locally_action = QAction(eye_icon, 'View Locally', context_menu)
sync_action = QAction(sync_icon, 'Synchronize', context_menu)
sync_menu = menu.Menu(self)
actions_added = self._fill_sync_action_menu(sync_menu)
artella_action.triggered.connect(self._on_open_in_artella)
view_locally_action.triggered.connect(self._on_view_locally)
context_menu.addAction(artella_action)
context_menu.addAction(view_locally_action)
context_menu.addSeparator()
if actions_added:
sync_action.setMenu(sync_menu)
context_menu.addAction(sync_action)
def update_asset_categories(self, asset_categories):
"""
Updates current categories with the given ones
:param asset_categories: list(str)
"""
for btn in self._categories_btn_grp.buttons():
self._categories_btn_grp.removeButton(btn)
qtutils.clear_layout(self._categories_menu_layout)
all_asset_categories = [defines.ArtellaFileStatus.ALL]
all_asset_categories.extend(asset_categories)
for category in all_asset_categories:
new_btn = QPushButton(category)
new_btn.setMinimumWidth(
QFontMetrics(new_btn.font()).width(category) + 10)
new_btn.setIcon(tpDcc.ResourcesMgr().icon(category.lower()))
new_btn.setCheckable(True)
self._categories_menu_layout.addWidget(new_btn)
self._categories_btn_grp.addButton(new_btn)
if category == defines.ArtellaFileStatus.ALL:
new_btn.setIcon(tpDcc.ResourcesMgr().icon('home'))
new_btn.setChecked(True)
new_btn.toggled.connect(partial(self._change_category, category))
def _setup_menubar(self):
"""
Internal function used to setup Artella Manager menu bar
"""
menubar_widget = QWidget()
menubar_layout = QGridLayout()
menubar_layout.setAlignment(Qt.AlignTop)
menubar_layout.setContentsMargins(0, 0, 0, 0)
menubar_layout.setSpacing(2)
menubar_widget.setLayout(menubar_layout)
self._project_artella_btn = QToolButton()
self._project_artella_btn.setText('Artella')
self._project_artella_btn.setIcon(tpDcc.ResourcesMgr().icon('artella'))
self._project_artella_btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self._project_folder_btn = QToolButton()
self._project_folder_btn.setText('Project')
self._project_folder_btn.setIcon(tpDcc.ResourcesMgr().icon('folder'))
self._project_folder_btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self._synchronize_btn = QToolButton()
self._synchronize_btn.setText('Synchronize')
self._synchronize_btn.setPopupMode(QToolButton.InstantPopup)
self._synchronize_btn.setIcon(tpDcc.ResourcesMgr().icon('sync'))
self._synchronize_btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self._settings_btn = QToolButton()
self._settings_btn.setText('Settings')
self._settings_btn.setIcon(tpDcc.ResourcesMgr().icon('settings'))
self._settings_btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
for i, btn in enumerate(
[self._project_artella_btn, self._project_folder_btn, self._synchronize_btn, self._settings_btn]):
menubar_layout.addWidget(btn, 0, i, 1, 1, Qt.AlignCenter)
self._setup_synchronize_menu()
return menubar_widget
def get_icon(cls):
"""
Returns icon resource of the current plugin
:return: QIcon
"""
plugin_icon = cls.ICON
icon_split = plugin_icon.split('/')
if len(icon_split) == 1:
theme = 'default'
elif len(icon_split) > 1:
theme = icon_split[0]
else:
theme = 'default'
icon_path = tpDcc.ResourcesMgr().get('icons',
theme,
'{}.png'.format(cls.ICON),
key='project')
if not icon_path or not os.path.isfile(icon_path):
icon_path = tpDcc.ResourcesMgr().get('icons', theme,
'{}.png'.format(cls.ICON))
if not icon_path or not os.path.isfile(icon_path):
plugin_icon = tpDcc.ResourcesMgr().icon('plugin')
else:
plugin_icon = tpDcc.ResourcesMgr().icon(cls.ICON, theme=theme)
else:
plugin_icon = tpDcc.ResourcesMgr().icon(cls.ICON,
theme=theme,
key='launcher')
return plugin_icon
class AssetDisplayButtons(DisplayButtonsWidget, object):
open_eye_icon = tpDcc.ResourcesMgr().icon('eye')
closed_eye_icon = tpDcc.ResourcesMgr().icon('eye_closed')
def __init__(self, parent=None):
super(AssetDisplayButtons, self).__init__(parent=parent)
def custom_ui(self):
self.setMinimumWidth(25)
self.view_btn = QPushButton()
self.view_btn.setIcon(tpDcc.ResourcesMgr().icon('eye'))
self.view_btn.setFlat(True)
self.view_btn.setFixedWidth(25)
self.view_btn.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred)
self.main_layout.addWidget(self.view_btn)
self.main_layout.addWidget(dividers.get_horizontal_separator_widget())
def show(self):
"""
Updates icon of the button to show
"""
self.view_btn.setIcon(self.open_eye_icon)
def hide(self):
"""
Updates icon of the button to hide
"""
self.view_btn.setIcon(self.closed_eye_icon)
def ui(self):
super(OutlinerOverrideItem, self).ui()
self.setMouseTracking(True)
self._item_widget.setFrameStyle(QFrame.Raised | QFrame.StyledPanel)
self.setStyleSheet('background-color: rgb(45,45,45);')
icon_lbl = QLabel()
icon_lbl.setMaximumWidth(18)
icon_lbl.setPixmap(self._override.OVERRIDE_ICON.pixmap(self._override.OVERRIDE_ICON.actualSize(QSize(20, 20))))
self._target_lbl = QLabel(self._name.title())
self._editor_btn = QPushButton('Editor')
self._editor_btn.setFlat(True)
self._save_btn = QPushButton()
self._editor_btn.setIcon(tp.ResourcesMgr().icon('editor'))
self._save_btn.setFlat(True)
self._save_btn.setIcon(tp.ResourcesMgr().icon('save'))
self._delete_btn = QPushButton()
self._delete_btn.setFlat(True)
self._delete_btn.setIcon(tp.ResourcesMgr().icon('delete'))
self._item_layout.addWidget(icon_lbl, 0, 1, 1, 1)
self._item_layout.addWidget(dividers.get_horizontal_separator_widget(), 0, 2, 1, 1)
self._item_layout.addWidget(self._target_lbl, 0, 3, 1, 1)
self._item_layout.addWidget(dividers.get_horizontal_separator_widget(), 0, 4, 1, 1)
self._item_layout.addWidget(self._editor_btn, 0, 5, 1, 1)
self._item_layout.setColumnStretch(6, 7)
self._item_layout.addWidget(self._save_btn, 0, 8, 1, 1)
self._item_layout.addWidget(self._delete_btn, 0, 9, 1, 1)
def ui(self):
self.main_layout = QHBoxLayout()
self.main_layout.setAlignment(Qt.AlignTop)
self.main_layout.setContentsMargins(0, 0, 0, 0)
self.main_layout.setSpacing(0)
self.setLayout(self.main_layout)
self.setFrameShape(QFrame.Panel)
self.setFrameShadow(QFrame.Raised)
self.setLineWidth(1)
shutdown_icon = tpDcc.ResourcesMgr().icon('shutdown')
self._kitsu_off_icon = tpDcc.ResourcesMgr().icon('kitsu_off')
self._kitsu_on_icon = tpDcc.ResourcesMgr().icon('kitsu_on')
self._kitsu_btn = QPushButton('Kitsu')
self._kitsu_btn.setIconSize(QSize(50, 50))
self._kitsu_btn.setFixedHeight(25)
self._kitsu_btn.setMinimumWidth(90)
self._kitsu_btn.setFlat(True)
self._kitsu_logout_btn = QPushButton()
self._kitsu_logout_btn.setVisible(False)
self._kitsu_logout_btn.setIcon(shutdown_icon)
self._kitsu_btn.setFlat(True)
self.main_layout.addWidget(self._kitsu_btn)
self.main_layout.addWidget(self._kitsu_logout_btn)
self._kitsu_btn.clicked.connect(self._on_open_kitsu_login)
self._kitsu_logout_btn.clicked.connect(self._on_kitsu_logout)
if self._project:
self.update_kitsu_status()
def _create_sequence_toolbar(self):
"""
Creates toolbar widget for the sequence
"""
toolbar_widget = QWidget()
toolbar_widget.setMaximumWidth(40)
toolbar_layout = QVBoxLayout()
toolbar_layout.setContentsMargins(2, 2, 2, 2)
toolbar_layout.setSpacing(5)
toolbar_widget.setLayout(toolbar_layout)
artella_btn = QToolButton()
artella_btn.setText('Artella')
artella_btn.setIcon(tpDcc.ResourcesMgr().icon('artella'))
artella_btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
view_locally_btn = QToolButton()
view_locally_btn.setText('Folder')
view_locally_btn.setIcon(tpDcc.ResourcesMgr().icon('folder'))
view_locally_btn.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
toolbar_layout.addItem(
QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Preferred))
toolbar_layout.addWidget(artella_btn)
toolbar_layout.addWidget(view_locally_btn)
toolbar_layout.addItem(
QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Preferred))
artella_btn.clicked.connect(self._on_open_artella)
view_locally_btn.clicked.connect(self._on_view_locally)
return toolbar_widget
def _create_replace_actions(self, replace_menu, item):
"""
Internal function that creates replacement options for current file
:param replace_menu: QMenu
:return: bool
"""
rig_icon = tpDcc.ResourcesMgr().icon('rig')
alembic_icon = tpDcc.ResourcesMgr().icon('alembic')
standin_icon = tpDcc.ResourcesMgr().icon('standin')
rig_action = QAction(rig_icon, 'Rig', replace_menu)
gpu_cache_action = QAction(alembic_icon, 'Gpu Cache', replace_menu)
standin_action = QAction(standin_icon, 'Standin', replace_menu)
replace_menu.addAction(rig_action)
replace_menu.addAction(gpu_cache_action)
replace_menu.addAction(standin_action)
rig_replace_menu = QMenu()
rig_action.setMenu(rig_replace_menu)
rig_root_control_action = QAction('Root Control', replace_menu)
rig_main_control_action = QAction('Main Control', replace_menu)
rig_replace_menu.addAction(rig_root_control_action)
rig_replace_menu.addAction(rig_main_control_action)
gpu_cache_replace_menu = QMenu()
gpu_cache_action.setMenu(gpu_cache_replace_menu)
gpu_cache_root_control_action = QAction('Root Control', replace_menu)
gpu_cache_main_control_action = QAction('Main Control', replace_menu)
gpu_cache_replace_menu.addAction(gpu_cache_root_control_action)
gpu_cache_replace_menu.addAction(gpu_cache_main_control_action)
standin_replace_menu = QMenu()
standin_action.setMenu(standin_replace_menu)
standin_root_control_action = QAction('Root Control', replace_menu)
standin_main_control_action = QAction('Main Control', replace_menu)
standin_replace_menu.addAction(standin_root_control_action)
standin_replace_menu.addAction(standin_main_control_action)
if item.asset_node.is_rig():
rig_action.setEnabled(False)
elif item.asset_node.is_gpu_cache():
gpu_cache_action.setEnabled(False)
elif item.asset_node.is_standin():
standin_action.setEnabled(False)
rig_root_control_action.triggered.connect(
partial(self._on_replace_rig, item, 'root_ctrl'))
rig_main_control_action.triggered.connect(
partial(self._on_replace_rig, item, 'main_ctrl'))
gpu_cache_root_control_action.triggered.connect(
partial(self._on_replace_gpu_cache, item, 'root_ctrl'))
gpu_cache_main_control_action.triggered.connect(
partial(self._on_replace_gpu_cache, item, 'main_ctrl'))
standin_root_control_action.triggered.connect(
partial(self._on_replace_standin, item, 'root_ctrl'))
gpu_cache_main_control_action.triggered.connect(
partial(self._on_replace_standin, item, 'main_ctrl'))
return replace_menu
def _fill_sync_action_menu(self, sync_menu):
"""
Internal function that fills sync menu with proper actions depending of the asset files supported
:param sync_menu: Menu
"""
if not sync_menu:
return
actions_to_add = list()
for asset_type_name in self.asset.FILES:
asset_type_icon = tpDcc.ResourcesMgr().icon(asset_type_name)
asset_type_action = QAction(asset_type_icon,
asset_type_name.title(), sync_menu)
asset_type_action.triggered.connect(
partial(self._on_sync, asset_type_name,
defines.ArtellaFileStatus.ALL))
actions_to_add.append(asset_type_action)
if actions_to_add:
download_icon = tpDcc.ResourcesMgr().icon('download')
all_action = QAction(download_icon, 'All', sync_menu)
all_action.triggered.connect(
partial(self._on_sync, defines.ArtellaFileStatus.ALL,
defines.ArtellaFileStatus.ALL))
actions_to_add.insert(0, all_action)
for action in actions_to_add:
sync_menu.addAction(action)
return actions_to_add
def ui(self):
super(DCCButton, self).ui()
dcc_name = self._dcc.name.lower().replace(' ', '_')
dcc_icon = self._dcc.icon
icon_split = dcc_icon.split('/')
if len(icon_split) == 1:
theme = ''
icon_name = icon_split[0]
elif len(icon_split) > 1:
theme = icon_split[0]
icon_name = icon_split[1]
else:
theme = 'color'
icon_name = dcc_name
icon_path = tpDcc.ResourcesMgr().get('icons', theme,
'{}.png'.format(icon_name))
if not os.path.isfile(icon_path):
icon_path = tpDcc.ResourcesMgr().get('icons', theme,
'{}.png'.format(icon_name))
if not os.path.isfile(icon_path):
dcc_icon = tpDcc.ResourcesMgr().icon('artella')
else:
dcc_icon = tpDcc.ResourcesMgr().icon(icon_name, theme=theme)
else:
dcc_icon = tpDcc.ResourcesMgr().icon(icon_name, theme=theme)
self._title = QPushButton(self._dcc.name.title())
self._title.setStyleSheet("""
border-top-left-radius: 10px;
border-top-right-radius: 10px;
""")
self._title.setFixedHeight(20)
self.main_layout.addWidget(self._title)
self._dcc_btn = QPushButton()
self._dcc_btn.setFixedSize(QSize(100, 100))
self._dcc_btn.setIconSize(QSize(110, 110))
self._dcc_btn.setIcon(dcc_icon)
self._dcc_btn.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
self.main_layout.addWidget(self._dcc_btn)
self._version_combo = QComboBox()
self.main_layout.addWidget(self._version_combo)
for version in self._dcc.supported_versions:
self._version_combo.addItem(str(version))
default_version = self._dcc.default_version
index = self._version_combo.findText(default_version,
Qt.MatchFixedString)
if index > -1:
self._version_combo.setCurrentIndex(index)
self.setMaximumWidth(105)
def _setup_splash(self, dcc_name):
"""
Internal function that is used to setup launch splash depending on the selected DCC
:param dcc_name: str
"""
splash_pixmap = self._get_splash_pixmap()
self._splash = QSplashScreen(splash_pixmap)
# self._splash.setFixedSize(QSize(800, 270))
self._splash.setWindowFlags(Qt.FramelessWindowHint)
self._splash.setEnabled(True)
self.main_layout = QVBoxLayout()
self.main_layout.setContentsMargins(5, 2, 5, 2)
self.main_layout.setSpacing(2)
self.main_layout.setAlignment(Qt.AlignBottom)
self._splash.setLayout(self.main_layout)
self.progress_bar = self.project.get_progress_bar()
self.main_layout.addWidget(self.progress_bar)
self.progress_bar.setMaximum(6)
self.progress_bar.setTextVisible(False)
self._progress_text = QLabel('Loading {} Tools ...'.format(
self.project.name.title()))
self._progress_text.setAlignment(Qt.AlignCenter)
self._progress_text.setStyleSheet(
"QLabel { background-color : rgba(0, 0, 0, 180); color : white; }")
font = self._progress_text.font()
font.setPointSize(10)
self._progress_text.setFont(font)
self.main_layout.addWidget(self._progress_text)
self.main_layout.addItem(QSpacerItem(0, 20))
artella_icon = tpDcc.ResourcesMgr().icon('artella')
artella_lbl = QLabel()
artella_lbl.setFixedSize(QSize(52, 52))
artella_lbl.setParent(self._splash)
artella_lbl.move(self._splash.width() - artella_lbl.width(), 0)
artella_lbl.setPixmap(
artella_icon.pixmap(artella_icon.actualSize(QSize(48, 48))))
dcc_icon = tpDcc.ResourcesMgr().icon(dcc_name.lower())
dcc_lbl = QLabel()
dcc_lbl.setFixedSize(QSize(52, 52))
dcc_lbl.setParent(self._splash)
dcc_lbl.move(self._splash.width() - dcc_lbl.width(), 52)
dcc_lbl.setPixmap(dcc_icon.pixmap(dcc_icon.actualSize(QSize(48, 48))))
self._splash.show()
self._splash.raise_()
def ui(self):
super(AssetShadersStack, self).ui()
export_icon = tpDcc.ResourcesMgr().icon('export')
open_folder_icon = tpDcc.ResourcesMgr().icon('folder')
self._export_btn = QPushButton('Shaders Exporter')
self._export_btn.setIcon(export_icon)
self._export_btn.setMinimumWidth(80)
self._open_folder_btn = QPushButton('Open Shaders Folder')
self._open_folder_btn.setIcon(open_folder_icon)
self._open_folder_btn.setMaximumWidth(135)
buttons_layout = QHBoxLayout()
buttons_layout.setContentsMargins(0, 0, 0, 0)
buttons_layout.setSpacing(10)
buttons_layout.addWidget(self._open_folder_btn)
buttons_layout.addWidget(self._export_btn)
self._shaders_stack = stack.SlidingStackedWidget()
project = self._asset_widget.asset.project
shaders_viewer_widget = QWidget()
self._shaders_viewer = artellapipe.ShadersViewer(
project=project,
shaders_path=self._asset_widget.asset.get_shaders_path())
shaders_viewer_widget.setLayout(self._shaders_viewer)
no_shaders_widget = QFrame()
no_shaders_widget.setFrameShape(QFrame.StyledPanel)
no_shaders_widget.setFrameShadow(QFrame.Sunken)
no_shaders_layout = QVBoxLayout()
no_shaders_layout.setContentsMargins(0, 0, 0, 0)
no_shaders_layout.setSpacing(0)
no_shaders_widget.setLayout(no_shaders_layout)
no_shaders_lbl = QLabel()
no_shaders_pixmap = tpDcc.ResourcesMgr().pixmap('no_shaders_available')
no_shaders_lbl.setPixmap(no_shaders_pixmap)
no_shaders_lbl.setAlignment(Qt.AlignCenter)
no_shaders_layout.addItem(
QSpacerItem(0, 10, QSizePolicy.Preferred, QSizePolicy.Expanding))
no_shaders_layout.addWidget(no_shaders_lbl)
no_shaders_layout.addItem(
QSpacerItem(0, 10, QSizePolicy.Preferred, QSizePolicy.Expanding))
self._shaders_exporter = shaderexporter.ShaderExporter(project=project)
self._shaders_stack.addWidget(no_shaders_widget)
self._shaders_stack.addWidget(shaders_viewer_widget)
self._shaders_stack.addWidget(self._shaders_exporter)
self.main_layout.addLayout(buttons_layout)
self.main_layout.addWidget(self._shaders_stack)
def __init__(self, spinner_type=SpinnerType.Thumb, parent=None):
super(WaitSpinner, self).__init__(parent=parent)
self._spin_icons = list()
empty_thumb = tpDcc.ResourcesMgr().pixmap(self.EMPTY_FILE)
if spinner_type == SpinnerType.Thumb:
for i in range(self.THUMB_INFO[0]):
self._spin_icons.append(tpDcc.ResourcesMgr().pixmap(
self.THUMB_INFO[1].format(i + 1)))
elif spinner_type == SpinnerType.Loading:
for i in range(self.LOADING_INFO[0]):
self._spin_icons.append(tpDcc.ResourcesMgr().pixmap(
self.LOADING_INFO[1].format(i + 1)))
else:
for i in range(self.CIRCLE_INFO[0]):
self._spin_icons.append(tpDcc.ResourcesMgr().pixmap(
self.CIRCLE_INFO[1].format(i + 1)))
main_layout = QVBoxLayout()
main_layout.setAlignment(Qt.AlignTop)
main_layout.setContentsMargins(5, 5, 5, 5)
main_layout.setSpacing(2)
self.setLayout(main_layout)
self._bg = QFrame(self)
self._bg.setStyleSheet(
"#background {border-radius: 3px;border-style: solid;border-width: 1px;border-color: rgb(32,32,32);}"
)
self._bg.setFrameShape(QFrame.StyledPanel)
self._bg.setFrameShadow(QFrame.Raised)
self.frame_layout = QHBoxLayout()
self.frame_layout.setContentsMargins(4, 4, 4, 4)
self._bg.setLayout(self.frame_layout)
main_layout.addWidget(self._bg)
self._thumb_lbl = label.ThumbnailLabel()
self._thumb_lbl.setMinimumSize(QSize(80, 55))
self._thumb_lbl.setMaximumSize(QSize(80, 55))
self._thumb_lbl.setStyleSheet('')
self._thumb_lbl.setPixmap(empty_thumb)
self._thumb_lbl.setScaledContents(False)
self._thumb_lbl.setAlignment(Qt.AlignCenter)
self.frame_layout.addWidget(self._thumb_lbl)
self._current_spinner_index = 0
self._timer = QTimer(self)
self._timer.timeout.connect(self._on_update_spinner)
def ui(self):
super(ArtellaLightRigManager, self).ui()
buttons_layout = QHBoxLayout()
buttons_layout.setContentsMargins(0, 0, 0, 0)
buttons_layout.setSpacing(0)
self.main_layout.addLayout(buttons_layout)
self._open_btn = QToolButton()
self._open_btn.setIcon(tpDcc.ResourcesMgr().icon('open'))
self._sync_btn = QToolButton()
self._sync_btn.setIcon(tpDcc.ResourcesMgr().icon('sync'))
buttons_layout.addItem(
QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Fixed))
buttons_layout.addWidget(self._open_btn)
buttons_layout.addWidget(dividers.get_horizontal_separator_widget())
buttons_layout.addWidget(self._sync_btn)
buttons_layout.addItem(
QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Fixed))
self.main_layout.addLayout(dividers.DividerLayout())
self._stack = stack.SlidingStackedWidget()
self.main_layout.addWidget(self._stack)
no_lights_pixmap = tpDcc.ResourcesMgr().pixmap('no_light_rigs')
no_lights_lbl = QLabel()
no_lights_lbl.setPixmap(no_lights_pixmap)
no_lights_widget = QWidget()
no_lights_layout = QHBoxLayout()
no_lights_widget.setLayout(no_lights_layout)
no_lights_layout.setContentsMargins(2, 2, 2, 2)
no_lights_layout.setSpacing(2)
no_lights_layout.addItem(
QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Preferred))
no_lights_layout.addWidget(no_lights_lbl)
no_lights_layout.addItem(
QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Preferred))
self._stack.addWidget(no_lights_widget)
light_rigs_widget = QWidget()
self._light_rigs_layout = QHBoxLayout()
light_rigs_widget.setLayout(self._light_rigs_layout)
self._light_rigs_layout.setContentsMargins(5, 5, 5, 5)
self._light_rigs_layout.setSpacing(5)
self._light_rigs_layout.setAlignment(Qt.AlignCenter)
self._stack.addWidget(light_rigs_widget)
self._update_ui()
def ui(self):
super(RadioButtonExample, self).ui()
folder_icon = tpDcc.ResourcesMgr().icon('folder')
play_icon = tpDcc.ResourcesMgr().icon('play')
user_icon = tpDcc.ResourcesMgr().icon('user')
lyt1 = layouts.HorizontalLayout()
lyt1.addWidget(buttons.BaseRadioButton('Maya'))
lyt1.addWidget(buttons.BaseRadioButton('Nuke'))
lyt1.addWidget(buttons.BaseRadioButton('Houdini'))
cbx_single = buttons.BaseRadioButton('Single')
cbx_single.setChecked(True)
cbx_single.setEnabled(False)
lyt2 = layouts.HorizontalLayout()
cbx_icon1 = buttons.BaseRadioButton('Folder')
cbx_icon1.setIcon(folder_icon)
cbx_icon2 = buttons.BaseRadioButton('Play')
cbx_icon2.setIcon(play_icon)
cbx_icon3 = buttons.BaseRadioButton('User')
cbx_icon3.setIcon(user_icon)
lyt2.addWidget(cbx_icon1)
lyt2.addWidget(cbx_icon2)
lyt2.addWidget(cbx_icon3)
cbx_bind = buttons.BaseRadioButton('Data Bind')
lbl = label.BaseLabel()
btn = buttons.BaseButton(text='Change State')
btn.clicked.connect(
lambda: self.set_field('checked', not self.field('checked')))
self.register_field('checked', True)
self.register_field('checked_text', lambda: 'Yes!'
if self.field('checked') else 'No!')
self.bind('checked', cbx_bind, 'checked', signal='toggled')
self.bind('checked_text', lbl, 'text')
self.main_layout.addWidget(dividers.Divider('Basic'))
self.main_layout.addLayout(lyt1)
self.main_layout.addWidget(cbx_single)
self.main_layout.addWidget(dividers.Divider('Icon'))
self.main_layout.addLayout(lyt2)
self.main_layout.addWidget(dividers.Divider('Data Bind'))
self.main_layout.addWidget(cbx_bind)
self.main_layout.addWidget(lbl)
self.main_layout.addWidget(btn)
self.main_layout.addStretch()
def tray_icon(self):
"""
Returns icon used by the tray of the project
:return: QIcon
"""
return tp.ResourcesMgr().icon(self.tray_icon_name, key='project')
def ui(self):
super(SliderPanelExample, self).ui()
add_icon = tpDcc.ResourcesMgr().icon('add', color=QColor(125, 0, 0))
self._button_grp = group.RadioButtonGroup()
self._button_grp.set_button_list(
['top', {
'text': 'right',
'checked': True
}, 'bottom', 'left'])
self._open_btn_2 = buttons.BaseButton('Open', parent=self).tiny()
lyt = layouts.HorizontalLayout()
lyt.addWidget(self._button_grp)
lyt.addSpacing(20)
lyt.addWidget(self._open_btn_2)
lyt.addStretch()
self._new_account_btn = buttons.BaseButton(text='New account',
icon=add_icon).primary()
lyt1 = layouts.HorizontalLayout()
lyt1.addWidget(label.BaseLabel('Submit form in drawer'))
lyt1.addWidget(self._new_account_btn)
lyt1.addStretch()
self.main_layout.addWidget(dividers.Divider('Custom Placement'))
self.main_layout.addLayout(lyt)
self.main_layout.addWidget(dividers.Divider('Submit form in drawer'))
self.main_layout.addLayout(lyt1)
def ui(self):
super(ShotInfoWidget, self).ui()
self._shot_title_breadcrumb = breadcrumb.BreadcrumbFrame()
self._shot_icon_frame = QFrame()
self._shot_icon_frame.setFrameShape(QFrame.StyledPanel)
self._shot_icon_frame.setFrameShadow(QFrame.Sunken)
self._shot_icon_frame.setLineWidth(3)
self._shot_icon_frame.setStyleSheet(
'background-color: rgba(60, 60, 60, 100); border-radius:5px;')
shot_icon_layout = QHBoxLayout()
shot_icon_layout.setContentsMargins(0, 0, 0, 0)
shot_icon_layout.setSpacing(0)
self._shot_icon_frame.setLayout(shot_icon_layout)
self._shot_icon_lbl = QLabel()
self._shot_icon_lbl.setAlignment(Qt.AlignCenter)
self._shot_icon_lbl.setPixmap(tpDcc.ResourcesMgr().pixmap('default'))
self._shot_toolbar_layout = QVBoxLayout()
self._shot_toolbar_layout.setContentsMargins(2, 2, 2, 2)
self._shot_toolbar_layout.setSpacing(5)
shot_icon_layout.addLayout(self._shot_toolbar_layout)
shot_icon_layout.addWidget(self._shot_icon_lbl)
self.main_layout.addWidget(self._shot_title_breadcrumb)
self.main_layout.addWidget(self._shot_icon_frame)
def create_bug_tracker_action(self, package_name):
"""
Creates bug tracker action
:return:
"""
main_win = tpDcc.Dcc.get_main_window()
parent_menu_bar = main_win.menuBar() if main_win else None
if not parent_menu_bar:
return
bug_object_action_name = '{}_bugTracker'.format(package_name)
# Remove previous created menu
for child_widget in parent_menu_bar.children():
if child_widget.objectName() == bug_object_action_name:
child_widget.deleteLater()
bug_tracker_action = QAction(parent_menu_bar)
bug_tracker_action.setIcon(tpDcc.ResourcesMgr().icon('bug',
theme='color'))
parent_menu_bar.addAction(bug_tracker_action)
bug_tracker_action.setObjectName(bug_object_action_name)
bug_tracker_action.triggered.connect(
partial(self._launch_tool_by_id, 'artellapipe-tools-bugtracker'))
def __init__(self, parent=None):
super(KitsuLoginWidget, self).__init__(parent)
self.setStyleSheet(
"#background {border-radius: 3px;border-style: solid;border-width: 1px;border-color: rgb(32,32,32);}"
)
self.setFrameShape(QFrame.StyledPanel)
self.setFrameShadow(QFrame.Raised)
main_layout = QVBoxLayout()
main_layout.setContentsMargins(0, 0, 0, 0)
main_layout.setSpacing(0)
self.setLayout(main_layout)
kitsu_pixmap = tpDcc.ResourcesMgr().pixmap('kitsu',
category='icons',
theme='color')
kitsu_icon = QLabel()
kitsu_icon.setAlignment(Qt.AlignCenter)
kitsu_icon.setPixmap(kitsu_pixmap)
main_layout.addWidget(kitsu_icon)
self.wait_spinner = spinner.WaitSpinner(
spinner_type=spinner.SpinnerType.Loading)
self.wait_spinner._bg.setFrameShape(QFrame.NoFrame)
self.wait_spinner._bg.setFrameShadow(QFrame.Plain)
# main_layout.addItem(QSpacerItem(0, 20, QSizePolicy.Fixed, QSizePolicy.Expanding))
main_layout.addWidget(self.wait_spinner)
def get_media_profile_data(self, media_profile_name):
"""
Returns data stored in given media profile name if exists
:param media_profile_name: str
:return: dict
"""
media_profile_path = self.get_media_profile_path(media_profile_name)
if not media_profile_path or not os.path.isfile(media_profile_path):
return dict()
config_data = yamlio.read_file(media_profile_path)
# We try to update config files with proper reosurce paths
profile_resource_folders = config_data.get('resources_folders', list())
if profile_resource_folders:
for profile_resource_folder in profile_resource_folders:
for key, value in config_data.items():
try:
if value and os.path.isfile(value):
continue
resource_path = tpDcc.ResourcesMgr().get(
profile_resource_folder, value, key='project')
except Exception:
continue
if resource_path and os.path.isfile(resource_path):
config_data[key] = resource_path
continue
return config_data
def ui(self):
super(SequencesPublisher, self).ui()
self._stack = stack.SlidingStackedWidget()
self.main_layout.addWidget(self._stack)
self._sequences_viewer = artellapipe.SequencesViewer(project=self._project)
self._stack.addWidget(self._sequences_viewer)
publisher_widget = QWidget()
self._publisher_layout = QVBoxLayout()
self._publisher_layout.setContentsMargins(0, 0, 0, 0)
self._publisher_layout.setSpacing(2)
publisher_widget.setLayout(self._publisher_layout)
self._stack.addWidget(publisher_widget)
back_icon = tpDcc.ResourcesMgr().icon('back')
self._back_btn = QPushButton()
self._back_btn.setIcon(back_icon)
buttons_layout = QHBoxLayout()
buttons_layout.setContentsMargins(0, 0, 0, 0)
buttons_layout.setSpacing(2)
self._publisher_layout.addLayout(buttons_layout)
buttons_layout.addWidget(self._back_btn)
buttons_layout.addItem(QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Preferred))
self._publisher_layout.addLayout(splitters.SplitterLayout())
options_layout = QHBoxLayout()
options_layout.setContentsMargins(0, 0, 0, 0)
options_layout.setSpacing(2)
self._publisher_layout.addLayout(options_layout)
self._upload_new_version_cbx = QCheckBox('Upload New Version')
os.environ['{}_SEQUENCES_PUBLISHER_NEW_VERSION'.format(self._project.get_clean_name().upper())] = str(False)
options_layout.addWidget(self._upload_new_version_cbx)
options_layout.addItem(QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Preferred))
def update_sequences_categories(self):
"""
Updates current sequences categories
"""
from artellapipe.widgets import sequence as sequence_widgets
for btn in self._sequences_btn_grp.buttons():
self._sequences_btn_grp.removeButton(btn)
qtutils.clear_layout(self._sequences_menu_layout)
all_sequences_categories = ['All']
all_sequences = artellapipe.SequencesMgr().find_all_sequences()
if all_sequences:
sequence_names = [
sequence.get_name() for sequence in all_sequences
]
all_sequences_categories.extend(sequence_names)
for sequence_name in all_sequences_categories:
sequence = artellapipe.SequencesMgr().find_sequence(sequence_name)
new_btn = sequence_widgets.SequenceCategoryButton(
sequence_name, sequence)
new_btn.setMinimumWidth(
QFontMetrics(new_btn.font()).width(sequence_name) + 10)
new_btn.setCheckable(True)
self._sequences_menu_layout.addWidget(new_btn)
self._sequences_btn_grp.addButton(new_btn)
if sequence_name == 'All':
new_btn.setIcon(tpDcc.ResourcesMgr().icon('home'))
new_btn.setChecked(True)
new_btn.toggled.connect(
partial(self._on_change_sequence, sequence_name))
def update_supported_types(self):
"""
Updates current supported types
"""
for btn in self._supported_types_btn_grp.buttons():
self._supported_types_btn_grp.removeButton(btn)
qtutils.clear_layout(self._supported_types_layout)
if not self._supported_files:
LOGGER.warning('No Supported Files for AssetsLibrary!')
return
total_buttons = 0
for supported_file in self._supported_files:
for type_name, file_info in supported_file.items():
new_btn = QPushButton(type_name.title())
new_btn.setIcon(tp.ResourcesMgr().icon(
type_name.lower().replace(' ', '')))
new_btn.setCheckable(True)
new_btn.file_info = file_info
self._supported_types_layout.addWidget(new_btn)
self._supported_types_btn_grp.addButton(new_btn)
if total_buttons == 0:
new_btn.setChecked(True)
total_buttons += 1
def update_categories(self):
"""
Updates current tag categories with the given ones
"""
for btn in self._tags_btn_grp.buttons():
self._tags_btn_grp.removeButton(btn)
qtutils.clear_layout(self._tags_menu_layout)
if not self._outliners:
return
total_buttons = 0
categories_list = self._outliners.keys()
for category in categories_list:
new_btn = QPushButton(category.title())
new_btn.category = category
category_icon = tpDcc.ResourcesMgr().icon(category.strip().lower())
new_btn.setIcon(category_icon)
new_btn.setCheckable(True)
new_btn.clicked.connect(partial(self._on_change_outliner, new_btn))
self._tags_menu_layout.addWidget(new_btn)
self._tags_btn_grp.addButton(new_btn)
if total_buttons == 0:
new_btn.blockSignals(True)
new_btn.setChecked(True)
new_btn.blockSignals(False)
total_buttons += 1
def update_thumbnail_icon(self, force=False):
"""
Function that updates the thumbnail icon
:return:
"""
try:
thumbnail_path = self.get_thumbnail_path()
if thumbnail_path and os.path.isfile(thumbnail_path) and not force:
thumb_icon = QIcon(QPixmap(thumbnail_path))
self._asset_btn.setIcon(thumb_icon)
self._thumbnail_icon = thumb_icon
return thumb_icon
else:
self._thumbnail_icon = tpDcc.ResourcesMgr().icon(
artellapipe.AssetsMgr().get_default_asset_thumb())
self._asset_btn.setIcon(self._thumbnail_icon)
asset_thumbnail_path = self._asset.get_thumbnail_path()
if not asset_thumbnail_path:
return self._thumbnail_icon
self._worker_started = True
self._worker.set_path(thumbnail_path)
self._worker.set_force(force)
self._worker.set_preview_id(asset_thumbnail_path)
self.ThreadPool.start(self._worker)
return self._thumbnail_icon
except Exception as exc:
LOGGER.error('Impossible to update thumbnail icon: {} | {}'.format(
exc, traceback.format_exc()))
def register_resources():
"""
Registers artellapipe-launcher-plugins-artellamanager resources
"""
resources_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'resources')
tp.ResourcesMgr().register_resource(resources_path, 'launcher')
def icon(self):
"""
Returns project icon
:return: QIcon
"""
return tp.ResourcesMgr().icon(self.icon_name,
theme=self.icon_resources_folder)
