def create_tab(self):
panel = {
"body": QtWidgets.QWidget(),
"top": QtWidgets.QWidget(),
"control": QtWidgets.QWidget(),
"table": QtWidgets.QWidget(),
}
widget = {
"label": QtWidgets.QLabel("Table Name:"),
"line": QtWidgets.QLineEdit(),
"nameChk": QtWidgets.QCheckBox("Show Long Name"),
"selectorA": views.SelectorWidget(side=views.SIDE_A),
"selectorB": views.SelectorWidget(side=views.SIDE_B),
"comparer": views.ComparingTable(),
"statusLine": widgets.StatusLineWidget(main_logger, self),
}
layout = QtWidgets.QHBoxLayout(panel["top"])
layout.addWidget(widget["label"])
layout.addWidget(widget["line"])
layout.addWidget(widget["nameChk"])
layout = QtWidgets.QHBoxLayout(panel["control"])
layout.addWidget(widget["selectorA"])
layout.addWidget(widget["selectorB"])
layout = QtWidgets.QVBoxLayout(panel["table"])
layout.addWidget(widget["comparer"])
layout.addWidget(widget["statusLine"])
layout = QtWidgets.QVBoxLayout(panel["body"])
layout.addWidget(panel["top"])
layout.addSpacing(-14)
layout.addWidget(panel["control"])
layout.addSpacing(-24)
layout.addWidget(panel["table"], stretch=True)
layout.setContentsMargins(0, 0, 0, 0)
tab = self.page["tab"]
# Add Tab
name = "New %d" % tab.count()
index = tab.addTab(panel["body"], name)
tab.setCurrentIndex(index)
widget["line"].setText(name)
# Connect
widget["selectorA"].connect_comparer(widget["comparer"])
widget["selectorB"].connect_comparer(widget["comparer"])
widget["nameChk"].stateChanged.connect(
widget["comparer"].on_name_mode_changed)
widget["line"].textChanged.connect(
lambda text: tab.setTabText(index, text))
def __init__(self, parent=None):
super(HostSelectorWidget, self).__init__(parent=parent)
panel = {
"selection": QtWidgets.QWidget(),
"container": QtWidgets.QWidget(),
}
model = {
"containerModel": models.HostContainerListModel(),
}
widget = {
"selectionChk": QtWidgets.QCheckBox("Use Selection"),
"selectionBtn": QtWidgets.QPushButton("Compare Selection"),
"containerChk": QtWidgets.QCheckBox("Use Container"),
"containerBox": QtWidgets.QComboBox(),
}
widget["containerBox"].setModel(model["containerModel"])
layout = QtWidgets.QVBoxLayout(panel["selection"])
layout.addWidget(widget["selectionChk"])
layout.addWidget(widget["selectionBtn"])
layout = QtWidgets.QVBoxLayout(panel["container"])
layout.addWidget(widget["containerChk"])
layout.addWidget(widget["containerBox"])
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(panel["selection"])
layout.addWidget(panel["container"])
# Connect
widget["selectionChk"].stateChanged.connect(self.on_use_selection)
widget["containerChk"].stateChanged.connect(self.on_use_container)
widget["selectionBtn"].pressed.connect(self.on_selection_pressed)
widget["containerBox"].currentIndexChanged.connect(
self.on_container_picked)
# Init
self.widget = widget
self.model = model
widget["containerChk"].setCheckState(QtCore.Qt.Checked)
# Confirm host registered
if not has_host():
# Disable all widgets
for widget in self.widget.values():
widget.setEnabled(False)
def setup_ui(self):
"""Build the UI"""
# Assets (left)
asset_outliner = widgets.AssetOutliner()
# Looks (right)
looks_widget = QtWidgets.QWidget()
looks_layout = QtWidgets.QVBoxLayout(looks_widget)
look_outliner = widgets.LookOutliner() # Database look overview
assign_selected = QtWidgets.QCheckBox("Assign to selected only")
assign_selected.setToolTip("Whether to assign only to selected nodes "
"or to the full asset")
remove_unused_btn = QtWidgets.QPushButton("Remove Unused Looks")
looks_layout.addWidget(look_outliner)
looks_layout.addWidget(assign_selected)
looks_layout.addWidget(remove_unused_btn)
# Footer
status = QtWidgets.QStatusBar()
status.setSizeGripEnabled(False)
status.setFixedHeight(25)
warn_layer = QtWidgets.QLabel("Current Layer is not "
"defaultRenderLayer")
warn_layer.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
warn_layer.setStyleSheet("color: #DD5555; font-weight: bold;")
warn_layer.setFixedHeight(25)
footer = QtWidgets.QHBoxLayout()
footer.setContentsMargins(0, 0, 0, 0)
footer.addWidget(status)
footer.addWidget(warn_layer)
# Build up widgets
main_layout = QtWidgets.QVBoxLayout(self)
main_layout.setSpacing(0)
main_splitter = QtWidgets.QSplitter()
main_splitter.setStyleSheet("QSplitter{ border: 0px; }")
main_splitter.addWidget(asset_outliner)
main_splitter.addWidget(looks_widget)
main_splitter.setSizes([350, 200])
main_layout.addWidget(main_splitter)
main_layout.addLayout(footer)
# Set column width
asset_outliner.view.setColumnWidth(0, 200)
look_outliner.view.setColumnWidth(0, 150)
# Open widgets
self.asset_outliner = asset_outliner
self.look_outliner = look_outliner
self.status = status
self.warn_layer = warn_layer
# Buttons
self.remove_unused = remove_unused_btn
self.assign_selected = assign_selected
def add_data(self, header, data):
"""Add information which needs to be displayed"""
if header in self.data_table:
print("Cannot add similar header, please use `update` in stead")
return
data_widget = QtWidgets.QWidget()
data_widget.setFixedHeight(self._tile_height)
layout = QtWidgets.QVBoxLayout()
title = QtWidgets.QLabel(header.upper())
title.setStyleSheet(style.overview_tile_title)
formlayout = QtWidgets.QFormLayout()
for label, value in data.items():
value_label = QtWidgets.QLabel(value)
formlayout.addRow("%s :" % label, value_label)
layout.addWidget(title)
layout.addLayout(formlayout)
layout.addStretch()
data_widget.setLayout(layout)
self.data_table[header] = {"widget": data_widget, "data": data}
position = self.layout.count() + 1
self.layout.insertWidget(position, data_widget)
def __init__(self, parent=None):
super(Window, self).__init__(parent=parent)
self.setWindowIcon(lib.icon("share-alt-square", color="#EC905C"))
self.setWindowTitle("Model Differ")
self.setWindowFlags(QtCore.Qt.Window)
page = {
"tab": QtWidgets.QTabWidget(),
"tables": list(),
}
page["tab"].addTab(QtWidgets.QWidget(), "+")
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(page["tab"])
# Connect
page["tab"].currentChanged.connect(self.on_tab_changed)
# Init
self.page = page
self.create_tab()
self.resize(840, 720)
def __init__(self, root=None, callback=None, with_keys=None, parent=None):
super(Window, self).__init__(parent=parent)
self.setWindowTitle("Setup Sequences")
icon_dir = qtawesome.icon("fa.folder-open", color="gray")
data = pindict.to_pindict({
"rootPath": {
"main": QtWidgets.QWidget(),
"label": QtWidgets.QLabel("Root: "),
"path": QtWidgets.QLineEdit(),
"find": QtWidgets.QPushButton(icon_dir, "Browse.."),
},
"sequences": {
"main": QtWidgets.QWidget(),
"options": QtWidgets.QWidget(),
"single": QtWidgets.QCheckBox("Include Single Frame"),
"stereo": QtWidgets.QCheckBox("Pair Stereo Sequences"),
"nameRegex": QtWidgets.QWidget(),
"label": QtWidgets.QLabel("Channel Name: "),
"nHead": QtWidgets.QLineEdit(),
"nTail": QtWidgets.QLineEdit(),
"view": widgets.SequenceWidget(),
},
"endDialog": {
"main": QtWidgets.QWidget(),
"accept": QtWidgets.QPushButton("Accept"),
"cancel": QtWidgets.QPushButton("Cancel"),
"callback": callback,
"with_keys": with_keys,
},
})
with data.pin("rootPath") as root_path:
layout = QtWidgets.QHBoxLayout(root_path["main"])
layout.addWidget(root_path["label"])
layout.addWidget(root_path["path"], stretch=True)
layout.addWidget(root_path["find"])
layout.setContentsMargins(4, 0, 4, 0)
with data.pin("sequences") as sequences:
layout = QtWidgets.QHBoxLayout(sequences["options"])
layout.addWidget(sequences["single"])
layout.addSpacing(5)
layout.addWidget(sequences["stereo"])
layout.addStretch()
layout.setContentsMargins(2, 2, 2, 2)
layout = QtWidgets.QHBoxLayout(sequences["nameRegex"])
layout.addWidget(sequences["label"])
layout.addWidget(sequences["nHead"], stretch=True)
layout.addWidget(sequences["nTail"], stretch=True)
layout.setContentsMargins(2, 2, 2, 2)
layout = QtWidgets.QVBoxLayout(sequences["main"])
layout.addWidget(sequences["options"])
layout.addSpacing(8)
layout.addWidget(sequences["nameRegex"])
layout.addWidget(sequences["view"])
layout.setContentsMargins(4, 6, 4, 0)
with data.pin("endDialog") as end_dialog:
layout = QtWidgets.QHBoxLayout(end_dialog["main"])
layout.addWidget(end_dialog["accept"])
layout.addWidget(end_dialog["cancel"])
layout.setContentsMargins(4, 0, 4, 0)
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(data["rootPath"]["main"])
layout.addWidget(data["sequences"]["main"], stretch=True)
layout.addWidget(data["endDialog"]["main"])
if root:
data["rootPath"]["path"].setText(root)
data["rootPath"]["find"].setEnabled(False)
data["sequences"]["single"].setEnabled(False)
data["rootPath"]["path"].setReadOnly(True)
data["rootPath"]["path"].textChanged.connect(self.find_sequences)
data["rootPath"]["find"].clicked.connect(self.open_browser)
data["sequences"]["single"].stateChanged.connect(self.on_single)
data["sequences"]["stereo"].stateChanged.connect(self.on_stereo)
data["sequences"]["nHead"].textChanged.connect(self.on_nhead_changed)
data["sequences"]["nTail"].textChanged.connect(self.on_ntail_changed)
data["endDialog"]["accept"].clicked.connect(self.on_accepted)
data["endDialog"]["cancel"].clicked.connect(self.reject)
self.data = data
# Defaults
self.is_single = False
self.is_stereo = False
self.from_cache = False
self.resize(600, 800)
def setup_ui(self):
"""Build the UI"""
# Assets (left)
asset_outliner = widgets.AssetOutliner()
# Looks (right)
looks_widget = QtWidgets.QWidget()
looks_layout = QtWidgets.QVBoxLayout(looks_widget)
# Sub widgets and layouts
db_looks_widget = QtWidgets.QWidget()
db_looks_layout = QtWidgets.QVBoxLayout(db_looks_widget)
loaded_looks_widget = QtWidgets.QWidget()
loaded_looks_layout = QtWidgets.QVBoxLayout(loaded_looks_widget)
# Database look overview
look_outliner = widgets.LookOutliner()
# Scene look overview
loaded_look_outliner = widgets.LoadedLookOutliner()
# Button and checkBox
overload_chk = QtWidgets.QCheckBox("Overload Looks")
remove_unused_btn = QtWidgets.QPushButton("Remove Unused Looks")
db_looks_layout.addWidget(look_outliner)
db_looks_layout.addWidget(overload_chk)
loaded_looks_layout.addWidget(loaded_look_outliner)
# Look Splitter
look_splitter = QtWidgets.QSplitter()
look_splitter.setOrientation(QtCore.Qt.Vertical)
look_splitter.setStyleSheet("QSplitter{ border: 0px; }")
look_splitter.addWidget(db_looks_widget)
look_splitter.addWidget(loaded_looks_widget)
look_splitter.setSizes([200, 120])
looks_layout.addWidget(look_splitter)
looks_layout.addWidget(remove_unused_btn)
# Footer
status = QtWidgets.QStatusBar()
status.setSizeGripEnabled(False)
status.setFixedHeight(25)
warn_layer = QtWidgets.QLabel("Current Layer is not "
"defaultRenderLayer")
warn_layer.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
warn_layer.setStyleSheet("color: #DD5555; font-weight: bold;")
warn_layer.setFixedHeight(25)
footer = QtWidgets.QHBoxLayout()
footer.setContentsMargins(0, 0, 0, 0)
footer.addWidget(status)
footer.addWidget(warn_layer)
# Build up widgets
main_layout = QtWidgets.QVBoxLayout(self)
main_layout.setSpacing(0)
main_splitter = QtWidgets.QSplitter()
main_splitter.setStyleSheet("QSplitter{ border: 0px; }")
main_splitter.addWidget(asset_outliner)
main_splitter.addWidget(looks_widget)
main_splitter.setSizes([350, 280])
main_layout.addWidget(main_splitter)
main_layout.addLayout(footer)
# Set column width
asset_outliner.view.setColumnWidth(0, 200)
look_outliner.view.setColumnWidth(0, 140) # "label" column
look_outliner.view.setColumnWidth(2, 50) # "match" column
loaded_look_outliner.view.setColumnWidth(0, 140) # "label" column
loaded_look_outliner.view.setColumnWidth(1, 60) # "ident" column
# Open widgets
self.asset_outliner = asset_outliner
self.look_outliner = look_outliner
self.loaded_look_outliner = loaded_look_outliner
self.status = status
self.warn_layer = warn_layer
# Buttons and CheckBoxes
self.remove_unused = remove_unused_btn
self.overload = overload_chk
def __init__(self, parent=None, context=None):
super(Window, self).__init__(parent)
self.context = context
project_name = io.active_project()
self.setWindowTitle("Asset creator ({0})".format(project_name))
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
# Validators
self.valid_parent = False
self.session = None
# assets widget
assets_widget = QtWidgets.QWidget()
assets_widget.setContentsMargins(0, 0, 0, 0)
assets_layout = QtWidgets.QVBoxLayout(assets_widget)
assets = widget.AssetWidget()
assets.view.setSelectionMode(assets.view.ExtendedSelection)
assets_layout.addWidget(assets)
# Outlink
label_outlink = QtWidgets.QLabel("Outlink:")
input_outlink = QtWidgets.QLineEdit()
input_outlink.setReadOnly(True)
input_outlink.setStyleSheet("background-color: #333333;")
checkbox_outlink = QtWidgets.QCheckBox("Use outlink")
# Parent
label_parent = QtWidgets.QLabel("*Parent:")
input_parent = QtWidgets.QLineEdit()
input_parent.setReadOnly(True)
input_parent.setStyleSheet("background-color: #333333;")
# Name
label_name = QtWidgets.QLabel("*Name:")
input_name = QtWidgets.QLineEdit()
input_name.setPlaceholderText("<asset name>")
# Asset Build
label_assetbuild = QtWidgets.QLabel("Asset Build:")
combo_assetbuilt = QtWidgets.QComboBox()
# Task template
label_task_template = QtWidgets.QLabel("Task template:")
combo_task_template = QtWidgets.QComboBox()
# Info widget
info_widget = QtWidgets.QWidget()
info_widget.setContentsMargins(10, 10, 10, 10)
info_layout = QtWidgets.QVBoxLayout(info_widget)
# Inputs widget
inputs_widget = QtWidgets.QWidget()
inputs_widget.setContentsMargins(0, 0, 0, 0)
inputs_layout = QtWidgets.QFormLayout(inputs_widget)
inputs_layout.addRow(label_outlink, input_outlink)
inputs_layout.addRow(None, checkbox_outlink)
inputs_layout.addRow(label_parent, input_parent)
inputs_layout.addRow(label_name, input_name)
inputs_layout.addRow(label_assetbuild, combo_assetbuilt)
inputs_layout.addRow(label_task_template, combo_task_template)
# Add button
btns_widget = QtWidgets.QWidget()
btns_widget.setContentsMargins(0, 0, 0, 0)
btn_layout = QtWidgets.QHBoxLayout(btns_widget)
btn_create_asset = QtWidgets.QPushButton("Create asset")
btn_create_asset.setToolTip(
"Creates all neccessary components for asset"
)
checkbox_app = None
if self.context is not None:
checkbox_app = QtWidgets.QCheckBox("Open {}".format(
self.context.capitalize())
)
btn_layout.addWidget(checkbox_app)
btn_layout.addWidget(btn_create_asset)
task_view = QtWidgets.QTreeView()
task_view.setIndentation(0)
task_model = model.TasksModel()
task_view.setModel(task_model)
info_layout.addWidget(inputs_widget)
info_layout.addWidget(task_view)
info_layout.addWidget(btns_widget)
# Body
body = QtWidgets.QSplitter()
body.setContentsMargins(0, 0, 0, 0)
body.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
body.setOrientation(QtCore.Qt.Horizontal)
body.addWidget(assets_widget)
body.addWidget(info_widget)
body.setStretchFactor(0, 100)
body.setStretchFactor(1, 150)
# statusbar
message = QtWidgets.QLabel()
message.setFixedHeight(20)
statusbar = QtWidgets.QWidget()
layout = QtWidgets.QHBoxLayout(statusbar)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(message)
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(body)
layout.addWidget(statusbar)
self.data = {
"label": {
"message": message,
},
"view": {
"tasks": task_view
},
"model": {
"assets": assets,
"tasks": task_model
},
"inputs": {
"outlink": input_outlink,
"outlink_cb": checkbox_outlink,
"parent": input_parent,
"name": input_name,
"assetbuild": combo_assetbuilt,
"tasktemplate": combo_task_template,
"open_app": checkbox_app
},
"buttons": {
"create_asset": btn_create_asset
}
}
# signals
btn_create_asset.clicked.connect(self.create_asset)
assets.selection_changed.connect(self.on_asset_changed)
input_name.textChanged.connect(self.on_asset_name_change)
checkbox_outlink.toggled.connect(self.on_outlink_checkbox_change)
combo_task_template.currentTextChanged.connect(
self.on_task_template_changed
)
if self.context is not None:
checkbox_app.toggled.connect(self.on_app_checkbox_change)
# on start
self.on_start()
self.resize(600, 500)
self.echo("Connected to project: {0}".format(project_name))
def _show_no_gui():
"""
Popup with information about how to register a new GUI
In the event of no GUI being registered or available,
this information dialog will appear to guide the user
through how to get set up with one.
"""
messagebox = QtWidgets.QMessageBox()
messagebox.setIcon(messagebox.Warning)
messagebox.setWindowIcon(
QtGui.QIcon(
os.path.join(os.path.dirname(pyblish.__file__), "icons",
"logo-32x32.svg")))
spacer = QtWidgets.QWidget()
spacer.setMinimumSize(400, 0)
spacer.setSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
layout = messagebox.layout()
layout.addWidget(spacer, layout.rowCount(), 0, 1, layout.columnCount())
messagebox.setWindowTitle("Uh oh")
messagebox.setText("No registered GUI found.")
if not pyblish.api.registered_guis():
messagebox.setInformativeText(
"In order to show you a GUI, one must first be registered. "
"Press \"Show details...\" below for information on how to "
"do that.")
messagebox.setDetailedText(
"Pyblish supports one or more graphical user interfaces "
"to be registered at once, the next acting as a fallback to "
"the previous."
"\n"
"\n"
"For example, to use Pyblish Lite, first install it:"
"\n"
"\n"
"$ pip install pyblish-lite"
"\n"
"\n"
"Then register it, like so:"
"\n"
"\n"
">>> import pyblish.api\n"
">>> pyblish.api.register_gui(\"pyblish_lite\")"
"\n"
"\n"
"The next time you try running this, Lite will appear."
"\n"
"See http://api.pyblish.com/register_gui.html for "
"more information.")
else:
messagebox.setInformativeText(
"None of the registered graphical user interfaces "
"could be found."
"\n"
"\n"
"Press \"Show details\" for more information.")
messagebox.setDetailedText("These interfaces are currently registered."
"\n"
"%s" %
"\n".join(pyblish.api.registered_guis()))
messagebox.setStandardButtons(messagebox.Ok)
messagebox.exec_()
def create_tab(self):
widget = pindict.to_pindict({
"main":
QtWidgets.QWidget(),
"top": {
"main": QtWidgets.QWidget(),
"label": QtWidgets.QLabel("Table Name:"),
"line": QtWidgets.QLineEdit(),
},
"ctrl": {
"tabs": {
"main": QtWidgets.QTabWidget(),
"focus": views.FocusComparing(),
"select": {
"main": QtWidgets.QWidget(),
"selectorA": views.SelectorWidget(side=views.SIDE_A),
"selectorB": views.SelectorWidget(side=views.SIDE_B),
},
},
},
"table": {
"tabs": {
"main": QtWidgets.QTabWidget(),
"comparer": views.ComparingTable(),
},
},
"statusLine":
widgets.StatusLineWidget(main_logger, self),
})
with widget.pin("top") as top:
layout = QtWidgets.QHBoxLayout(top["main"])
layout.addWidget(top["label"])
layout.addWidget(top["line"])
with widget.pin("ctrl.tabs.select") as selectors:
layout = QtWidgets.QHBoxLayout(selectors["main"])
layout.addWidget(selectors["selectorA"])
layout.addSpacing(-12)
layout.addWidget(selectors["selectorB"])
layout.setContentsMargins(2, 2, 2, 2)
with widget.pin("ctrl.tabs") as ctrl:
icon_1 = lib.icon("hand-o-right", "white")
icon_2 = lib.icon("bullseye", "#BEBEBE")
ctrl["main"].addTab(ctrl["select"]["main"], icon_1, "Select")
ctrl["main"].addTab(ctrl["focus"], icon_2, "Focus")
ctrl["main"].setTabPosition(QtWidgets.QTabWidget.West)
with widget.pin("table.tabs") as table:
icon = lib.icon("adjust", "#BEBEBE")
table["main"].addTab(table["comparer"], icon, "Compare")
table["main"].setTabPosition(QtWidgets.QTabWidget.West)
layout = QtWidgets.QVBoxLayout(widget["main"])
layout.addWidget(widget["top"]["main"])
layout.addWidget(widget["ctrl"]["tabs"]["main"])
layout.addWidget(widget["table"]["tabs"]["main"], stretch=True)
layout.addWidget(widget["statusLine"])
layout.setContentsMargins(4, 4, 4, 4)
tab = self.page["tab"]
# Add Tab
name = "New %d" % tab.count()
index = tab.addTab(widget["main"], name)
tab.setCurrentIndex(index)
widget["top"]["line"].setText(name)
self.page["tables"].append(widget)
# Connect
with widget.pin("table.tabs") as table:
with widget.pin("ctrl.tabs.select") as selectors:
selectors["selectorA"].connect_comparer(table["comparer"])
selectors["selectorB"].connect_comparer(table["comparer"])
with widget.pin("ctrl.tabs") as ctrl:
table["comparer"].picked.connect(ctrl["focus"].on_picked)
ctrl["main"].currentChanged.connect(
ctrl["focus"].focus_enabled)
ctrl["main"].currentChanged.connect(
table["comparer"].focus_enabled)
with widget.pin("top") as top:
top["line"].textChanged.connect(
lambda text: tab.setTabText(index, text))
def __init__(self, parent=None):
super(SelectionOutline, self).__init__(parent=parent)
data = pindict({
"model": model.SelectionModel(),
"proxy": QtCore.QSortFilterProxyModel(),
})
panels = {
"header": QtWidgets.QWidget(),
"body": QtWidgets.QWidget(),
"footer": QtWidgets.QWidget(),
}
widgets = pindict({
"view": QtWidgets.QTreeView(),
"lock": QtWidgets.QPushButton("Lock"),
"unlock": QtWidgets.QPushButton("Unlock"),
"save": QtWidgets.QPushButton("Save"),
"refresh": QtWidgets.QPushButton(),
})
data["proxy"].setSourceModel(data["model"])
widgets["view"].setModel(data["proxy"])
with widgets.pin("view") as _:
_.setAllColumnsShowFocus(True)
_.setAlternatingRowColors(True)
_.setSortingEnabled(True)
_.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
_.sortByColumn(1, QtCore.Qt.AscendingOrder)
_.setSelectionMode(_.ExtendedSelection)
_.setIndentation(20)
_.setStyleSheet("""
QTreeView::item{
padding: 4px 1px;
border: 0px;
}
""")
_.setColumnWidth(0, 240)
layout = QtWidgets.QHBoxLayout(panels["header"])
layout.setContentsMargins(0, 0, 0, 0)
layout.setMargin(0)
layout.addStretch()
layout.addWidget(widgets["refresh"])
layout = QtWidgets.QHBoxLayout(panels["body"])
layout.setContentsMargins(0, 0, 0, 0)
layout.setMargin(0)
layout.addWidget(widgets["view"])
layout = QtWidgets.QHBoxLayout(panels["footer"])
layout.setContentsMargins(0, 0, 0, 0)
layout.setMargin(0)
layout.addWidget(widgets["lock"])
layout.addWidget(widgets["unlock"])
layout.addWidget(widgets["save"])
layout = QtWidgets.QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setMargin(0)
layout.addWidget(panels["header"])
layout.addWidget(panels["body"])
layout.addWidget(panels["footer"])
widgets["view"].customContextMenuRequested.connect(self.on_menu)
widgets["lock"].clicked.connect(lambda: self.on_locked(True))
widgets["unlock"].clicked.connect(lambda: self.on_locked(False))
widgets["save"].clicked.connect(self.on_saved)
widgets["refresh"].clicked.connect(self.on_refreshed)
icon = qtawesome.icon("fa.lock", color="gray")
widgets["lock"].setIcon(icon)
icon = qtawesome.icon("fa.unlock", color="gray")
widgets["unlock"].setIcon(icon)
icon = qtawesome.icon("fa.save", color="gray")
widgets["save"].setIcon(icon)
icon = qtawesome.icon("fa.refresh", color="white")
widgets["refresh"].setIcon(icon)
self.data = data
self.widgets = widgets
self._selection_sync = True
def setup_ui(self):
"""Build the UI"""
main_layout = QtWidgets.QHBoxLayout()
splitter = QtWidgets.QSplitter()
# Container overview
container_widget = QtWidgets.QWidget()
container_title = self._create_label("Assets")
container_layout = QtWidgets.QVBoxLayout()
container_model = models.ContainerModel()
container_view = views.View()
container_view.setModel(container_model)
container_view.setContextMenuPolicy(QtCore.Qt.NoContextMenu)
from_selection_btn = QtWidgets.QPushButton("Get Looks From Selection")
from_all_asset_btn = QtWidgets.QPushButton("Get Looks From All Assets")
container_layout.addWidget(container_title)
container_layout.addWidget(from_selection_btn)
container_layout.addWidget(from_all_asset_btn)
container_layout.addWidget(container_view)
# Add container view
container_widget.setLayout(container_layout)
splitter.addWidget(container_widget)
# look manager layout
look_views_widget = QtWidgets.QWidget()
look_views_layout = QtWidgets.QVBoxLayout()
look_views_layout.setSpacing(10)
# Looks from database
documents_title = self._create_label("Available looks")
documents_title.setAlignment(QtCore.Qt.AlignCenter)
document_model = models.FlatModel()
document_view = views.View()
document_view.setToolTip("Use right mouse button menu for direct actions")
document_view.setModel(document_model)
document_view.setMinimumHeight(230)
look_views_layout.addWidget(documents_title)
look_views_layout.addWidget(document_view)
# Turn off queue at start, show this widget
queue_off_message = QtWidgets.QLabel(
"Queue is empty, add items to the queue to active it")
queue_off_message.setAlignment(QtCore.Qt.AlignCenter)
queue_off_message.setStyleSheet("font-size: 12px;")
# Queue view
queue_title = self._create_label("Queue")
queue_title.setAlignment(QtCore.Qt.AlignCenter)
queue_model = models.LookQueueModel()
queue_view = views.View()
queue_view.setModel(queue_model)
queue_widgets = QtWidgets.QStackedWidget()
queue_widgets.addWidget(queue_off_message)
queue_widgets.addWidget(queue_view)
look_views_layout.addWidget(queue_title)
look_views_layout.addWidget(queue_widgets)
# Method buttons
method_buttons_layout = QtWidgets.QHBoxLayout()
assign_to_selected_btn = QtWidgets.QPushButton("Process Selected Queue")
assign_to_all_btn = QtWidgets.QPushButton("Process Queued Looks")
remove_unused_btn = QtWidgets.QPushButton("Remove Unused Looks")
method_buttons_layout.addWidget(assign_to_selected_btn)
method_buttons_layout.addWidget(assign_to_all_btn)
method_buttons_layout.addWidget(remove_unused_btn)
load_save_buttons_layout = QtWidgets.QHBoxLayout()
load_queue_btn = QtWidgets.QPushButton("Load Queue from File")
save_queue_btn = QtWidgets.QPushButton("Save Queue to File")
load_save_buttons_layout.addWidget(load_queue_btn)
load_save_buttons_layout.addWidget(save_queue_btn)
look_views_layout.addLayout(method_buttons_layout)
look_views_layout.addLayout(load_save_buttons_layout)
look_views_widget.setLayout(look_views_layout)
splitter.addWidget(look_views_widget)
main_layout.addWidget(splitter)
container_view.setColumnWidth(0, 200) # subset
document_view.setColumnWidth(0, 200)
queue_view.setColumnWidth(0, 200)
self.from_selection_btn = from_selection_btn
self.from_all_asset_btn = from_all_asset_btn
self.assign_to_selected_btn = assign_to_selected_btn
self.assign_to_all_btn = assign_to_all_btn
self.remove_unused_btn = remove_unused_btn
self.container_model = container_model
self.container_view = container_view
self.document_model = document_model
self.document_view = document_view
self.queue_widgets = queue_widgets
self.queue_model = queue_model
self.queue_view = queue_view
self.save_queue = save_queue_btn
self.load_queue = load_queue_btn
self.setLayout(main_layout)
def __init__(self, parent=None):
QtWidgets.QDialog.__init__(self, parent)
self.resize(640, 360)
project = api.Session["AVALON_PROJECT"]
self.setWindowTitle("Context Manager 1.0 - {}".format(project))
self.setObjectName("contextManager")
splitter = QtWidgets.QSplitter(self)
main_layout = QtWidgets.QVBoxLayout()
column_layout = QtWidgets.QHBoxLayout()
accept_btn = QtWidgets.QPushButton("Accept")
# Asset picker
assets = AssetWidget()
# Task picker
tasks_widgets = QtWidgets.QWidget()
tasks_widgets.setContentsMargins(0, 0, 0, 0)
tasks_layout = QtWidgets.QVBoxLayout(tasks_widgets)
task_view = QtWidgets.QTreeView()
task_view.setIndentation(0)
task_model = TasksModel()
task_view.setModel(task_model)
tasks_layout.addWidget(task_view)
tasks_layout.addWidget(accept_btn)
task_view.setColumnHidden(1, True)
# region results
result_widget = QtWidgets.QGroupBox("Current Context")
result_layout = QtWidgets.QVBoxLayout()
result_widget.setLayout(result_layout)
project_label = QtWidgets.QLabel("Project: {}".format(project))
asset_label = QtWidgets.QLabel()
task_label = QtWidgets.QLabel()
result_layout.addWidget(project_label)
result_layout.addWidget(asset_label)
result_layout.addWidget(task_label)
result_layout.addStretch()
# endregion results
context_widget = QtWidgets.QWidget()
column_layout.addWidget(assets)
column_layout.addWidget(tasks_widgets)
context_widget.setLayout(column_layout)
splitter.addWidget(context_widget)
splitter.addWidget(result_widget)
splitter.setSizes([1, 0])
main_layout.addWidget(splitter)
# Enable for other functions
self._last_selected_task = None
self._task_view = task_view
self._task_model = task_model
self._assets = assets
self._context_asset = asset_label
self._context_task = task_label
assets.selection_changed.connect(self.on_asset_changed)
accept_btn.clicked.connect(self.on_accept_clicked)
assets.refresh()
self.select_asset(api.Session["AVALON_ASSET"])
self.select_task(api.Session["AVALON_TASK"])
self.setLayout(main_layout)
# Enforce current context to be up-to-date
self.refresh_context_view()
def __init__(self, parent=None):
super(Window, self).__init__(parent=parent)
icon = qtawesome.icon("fa.map-pin", color="#E74C3C")
unlink = qtawesome.icon("fa.chain-broken", color="#DFDFDF")
self.setWindowIcon(icon)
self.setWindowTitle("Pinner")
self.setWindowFlags(QtCore.Qt.Window)
widgets = {
"pin": QtWidgets.QWidget(),
"addPinBtn": QtWidgets.QPushButton("Create/Add Pin"),
"pinName": QtWidgets.QLineEdit(),
"ref": QtWidgets.QWidget(),
"setReference": QtWidgets.QPushButton("Set Reference"),
"refName": QtWidgets.QLineEdit(),
"tar": QtWidgets.QWidget(),
"setTarget": QtWidgets.QPushButton("Set Target"),
"tarName": QtWidgets.QLineEdit(),
"btm": QtWidgets.QWidget(),
"runBtn": QtWidgets.QPushButton(icon, ""),
"unlinkBtn": QtWidgets.QPushButton(unlink, ""),
}
widgets["addPinBtn"].setFixedWidth(160)
widgets["setReference"].setFixedWidth(160)
widgets["setTarget"].setFixedWidth(160)
widgets["runBtn"].setFixedWidth(80)
widgets["pinName"].setPlaceholderText(
"A transform node to pin onto, default is a locator")
widgets["refName"].setPlaceholderText(
"Set motion reference object, like character's main geometry")
widgets["tarName"].setPlaceholderText(
"A transform node to be pinned, e.g. a rig controller")
layout = QtWidgets.QHBoxLayout(widgets["pin"])
layout.addWidget(widgets["addPinBtn"])
layout.addWidget(widgets["pinName"], stretch=True)
layout.setContentsMargins(0, 0, 0, 0)
layout = QtWidgets.QHBoxLayout(widgets["ref"])
layout.addWidget(widgets["setReference"])
layout.addWidget(widgets["refName"], stretch=True)
layout.setContentsMargins(0, 0, 0, 0)
layout = QtWidgets.QHBoxLayout(widgets["tar"])
layout.addWidget(widgets["setTarget"])
layout.addWidget(widgets["tarName"], stretch=True)
layout.setContentsMargins(0, 0, 0, 0)
layout = QtWidgets.QHBoxLayout(widgets["btm"])
layout.addStretch()
layout.addWidget(widgets["runBtn"])
layout.addWidget(widgets["unlinkBtn"])
layout.setContentsMargins(0, 0, 0, 0)
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(widgets["pin"])
layout.addWidget(widgets["ref"])
layout.addWidget(widgets["tar"])
layout.addStretch()
layout.addWidget(widgets["btm"])
# Connect
widgets["addPinBtn"].clicked.connect(self.on_add_pin_clicked)
widgets["setReference"].clicked.connect(self.on_set_ref_clicked)
widgets["setTarget"].clicked.connect(self.on_set_target_clicked)
widgets["runBtn"].clicked.connect(self.on_run_clicked)
widgets["unlinkBtn"].clicked.connect(self.on_unlink_clicked)
self.widgets = widgets
self.resize(560, 150)
def __init__(self, parent=None):
super(DatabaseSelectorWidget, self).__init__(parent=parent)
panel = {
"silo": QtWidgets.QWidget(),
"asset": QtWidgets.QWidget(),
"subset": QtWidgets.QWidget(),
"version": QtWidgets.QWidget(),
}
label = {
"silo": QtWidgets.QLabel("Silo"),
"asset": QtWidgets.QLabel("Asset"),
"subset": QtWidgets.QLabel("Subset"),
"version": QtWidgets.QLabel("Version"),
}
widget = {
"silo": QtWidgets.QComboBox(),
"asset": QtWidgets.QComboBox(),
"subset": QtWidgets.QComboBox(),
"version": QtWidgets.QComboBox(),
}
model = {
"silo": models.DatabaseDocumentModel(level="silo"),
"asset": models.DatabaseDocumentModel(level="asset"),
"subset": models.DatabaseDocumentModel(level="subset"),
"version": models.DatabaseDocumentModel(level="version"),
}
view = {
"silo": QtWidgets.QListView(),
"asset": QtWidgets.QListView(),
"subset": QtWidgets.QListView(),
"version": QtWidgets.QListView(),
}
widget["silo"].setModel(model["silo"])
widget["asset"].setModel(model["asset"])
widget["subset"].setModel(model["subset"])
widget["version"].setModel(model["version"])
widget["silo"].setView(view["silo"])
widget["asset"].setView(view["asset"])
widget["subset"].setView(view["subset"])
widget["version"].setView(view["version"])
def build_panel(level):
label[level].setFixedWidth(60)
label[level].setAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignRight)
layout = QtWidgets.QHBoxLayout(panel[level])
layout.addWidget(label[level])
layout.addWidget(widget[level])
build_panel("silo")
build_panel("asset")
build_panel("subset")
build_panel("version")
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(panel["silo"])
layout.addSpacing(-16)
layout.addWidget(panel["asset"])
layout.addSpacing(-16)
layout.addWidget(panel["subset"])
layout.addSpacing(-16)
layout.addWidget(panel["version"])
# Connect
def connect_index_changed(level, callback):
widget[level].currentIndexChanged.connect(callback)
connect_index_changed("silo", self.on_silo_changed)
connect_index_changed("asset", self.on_asset_changed)
connect_index_changed("subset", self.on_subset_changed)
connect_index_changed("version", self.on_version_changed)
# Init
self.widget = widget
self.model = model
self.view = view
silo = api.Session.get("AVALON_SILO")
if silo:
init_index = self.widget["silo"].findText(silo)
self.widget["silo"].setCurrentIndex(init_index)
asset = api.Session.get("AVALON_ASSET")
if silo and asset:
init_index = self.widget["asset"].findText(asset)
self.widget["asset"].setCurrentIndex(init_index)
def __init__(self, parent=None):
super(FocusComparing, self).__init__(parent=parent)
widget = pindict.to_pindict({
"overallDiff": {
"main": QtWidgets.QGroupBox("Compare Features"),
"name": {
"main": QtWidgets.QWidget(),
"icon": QtWidgets.QLabel(),
"label": QtWidgets.QLabel("Hierarchy"),
"status": QtWidgets.QLabel("--"),
},
"id": {
"main": QtWidgets.QWidget(),
"icon": QtWidgets.QLabel(),
"label": QtWidgets.QLabel("Avalon Id"),
"status": QtWidgets.QLabel("--"),
},
"mesh": {
"main": QtWidgets.QWidget(),
"icon": QtWidgets.QLabel(),
"label": QtWidgets.QLabel("Mesh"),
"status": QtWidgets.QLabel("--"),
},
"uv": {
"main": QtWidgets.QWidget(),
"icon": QtWidgets.QLabel(),
"label": QtWidgets.QLabel("UV"),
"status": QtWidgets.QLabel("--"),
},
},
"featureMenu": {
"main": QtWidgets.QWidget(),
"label": QtWidgets.QLabel("Focus On"),
"list": QtWidgets.QComboBox(),
},
"focus": {
"view": QtWidgets.QTreeView(),
"model": models.FocusModel(),
"pathDelegate": delegates.PathTextDelegate(),
}
})
with widget.pin("overallDiff") as diff:
layout = QtWidgets.QVBoxLayout(diff["main"])
for key in ["name", "id", "mesh", "uv"]:
with widget.pin("overallDiff." + key) as feature:
lay = QtWidgets.QHBoxLayout(feature["main"])
lay.addWidget(feature["label"])
lay.addSpacing(8)
lay.addWidget(feature["icon"])
lay.addSpacing(12)
lay.addWidget(feature["status"], stretch=True)
feature["label"].setFixedWidth(60)
feature["label"].setAlignment(QtCore.Qt.AlignRight)
icon = delegates.FEATURE_ICONS[key]
pixmap = lib.icon(icon, models.COLOR_DARK).pixmap(16, 16)
feature["icon"].setPixmap(pixmap)
layout.addWidget(feature["main"])
layout.addSpacing(-16)
layout.addSpacing(16)
layout.setContentsMargins(0, 0, 0, 0)
with widget.pin("featureMenu") as menu:
layout = QtWidgets.QHBoxLayout(menu["main"])
layout.addWidget(menu["label"])
layout.addWidget(menu["list"])
layout.addStretch()
layout = QtWidgets.QVBoxLayout(self)
layout.addSpacing(-16)
layout.addWidget(widget["overallDiff"]["main"])
layout.addSpacing(-8)
layout.addWidget(widget["featureMenu"]["main"])
layout.addSpacing(-8)
layout.addWidget(widget["focus"]["view"])
# Init
with widget.pin("featureMenu") as menu:
menu["list"].addItem(" Hierarchy", "longName")
menu["list"].addItem(" Avalon Id", "avalonId")
menu["list"].addItem(" Full Path", "fullPath")
menu["list"].addItem(" Mesh", "points")
menu["list"].addItem(" UV", "uvmap")
with widget.pin("focus") as focus:
focus["view"].setModel(focus["model"])
focus["view"].setItemDelegateForColumn(1, focus["pathDelegate"])
focus["view"].setHeaderHidden(True)
focus["view"].setUniformRowHeights(True)
focus["view"].setAlternatingRowColors(False)
focus["view"].setIndentation(6)
focus["view"].setStyleSheet("""
QTreeView::item{
padding: 2px 1px;
border: 0px;
}
""")
focus["view"].setSelectionMode(focus["view"].NoSelection)
height = focus["view"].sizeHintForRow(0) * 2 + 4 # MagicNum
focus["view"].setFixedHeight(height)
focus["view"].setColumnWidth(0, 28)
self.widget = widget
self._focusing = False
# Connect
with widget.pin("featureMenu") as menu:
menu["list"].currentIndexChanged.connect(self.on_feature_changed)
self.focus_enabled.connect(self.on_focus_enabled)
