def __init__(self, title, data, parent=None):
super(EnvDisplay, self).__init__(parent=parent)
self.data = data
self.tree = EnvTree('environ', self.data)
self.ok_button = QtGui.QPushButton('Ok')
self.ok_button.setSizePolicy(
QtGui.QSizePolicy.Maximum,
QtGui.QSizePolicy.Maximum,
)
self.ok_button.clicked.connect(self.accept)
self.copy_button = QtGui.QPushButton(
icon=QtGui.QIcon(res.get_path('copy.png')),
text='Copy to Clipboard',
)
self.copy_button.clicked.connect(self.copy_to_clipboard)
self.button_layout = QtGui.QHBoxLayout()
self.button_layout.setDirection(self.button_layout.RightToLeft)
self.button_layout.addWidget(self.ok_button)
self.button_layout.addWidget(self.copy_button)
self.button_layout.addStretch()
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.tree)
self.layout.addLayout(self.button_layout)
self.setLayout(self.layout)
self.setWindowTitle(title)
self.setWindowIcon(QtGui.QIcon(res.get_path('icon_dark_256.png')))
def __init__(self, parent):
"""
:param parent: The model parent.
:type parent: :class:`~PySide.QtGui.QObject`
"""
super(WorkAreaButton, self).__init__(parent)
# an icon to represent all items which
# aren't the current work area
self._normal_icon = QtGui.QIcon()
self._normal_icon.addPixmap(
QtGui.QPixmap(":/tk_multi_infopanel/pin.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
# an icon to represent the current work area
self._current_work_area_icon = QtGui.QIcon()
self._current_work_area_icon.addPixmap(
QtGui.QPixmap(":/tk_multi_infopanel/pin_blue.png"),
QtGui.QIcon.Disabled, QtGui.QIcon.Off)
self.setIcon(self._normal_icon)
self.setIconSize(
QtCore.QSize(self.WIDGET_WIDTH_COLLAPSED, self.WIDGET_HEIGHT))
self._bundle = sgtk.platform.current_bundle()
self._entity_type = None
self._entity_id = None
self._is_static = False
self._caption = "Set Work Area"
self._width = 120
self.clicked.connect(self._on_click)
self.setVisible(False)
def __init__(self, editor_widget, parent=None):
"""
Initialize the wrapper widget.
:param editor_widget: The ``EDITOR`` widget instance
:type editor_widget: :class:`~PySide.QtGui.QWidget`
:param parent: The parent widget instance or None
:type parent: :class:`~PySide.QtGui.QWidget`
:return:
"""
super(_EditorWidget, self).__init__(parent)
self._editor_widget = editor_widget
self._editor_widget.setFocusPolicy(QtCore.Qt.StrongFocus)
self._done_btn = QtGui.QPushButton()
self._done_btn.setIcon(QtGui.QIcon(":/qtwidgets-shotgun-fields/edit_close.png"))
self._done_btn.setFixedSize(QtCore.QSize(16, 16))
self._done_btn.setFocusPolicy(QtCore.Qt.NoFocus)
self._apply_btn = QtGui.QPushButton()
self._apply_btn.setIcon(
QtGui.QIcon(":/qtwidgets-shotgun-fields/apply_value.png")
)
self._apply_btn.setFixedSize(QtCore.QSize(16, 16))
self._apply_btn.setFocusPolicy(QtCore.Qt.NoFocus)
# make sure there's never a bg color or border
self._done_btn.setStyleSheet(BUTTON_STYLE)
self._apply_btn.setStyleSheet(BUTTON_STYLE)
if self._editor_widget.sizeHint().height() >= 32:
btn_layout = QtGui.QVBoxLayout()
btn_layout.addWidget(self._done_btn)
btn_layout.addStretch()
btn_layout.addWidget(self._apply_btn)
else:
btn_layout = QtGui.QHBoxLayout()
btn_layout.addWidget(self._apply_btn)
btn_layout.addWidget(self._done_btn)
btn_layout.addStretch()
if getattr(editor_widget, "_IMMEDIATE_APPLY", None):
# widget is set to immediately apply value. no need to display the btn
self._apply_btn.hide()
layout = QtGui.QHBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(4)
layout.addWidget(editor_widget)
layout.addLayout(btn_layout)
layout.addStretch()
layout.setAlignment(self._done_btn, QtCore.Qt.AlignBottom)
self.installEventFilter(self)
# ---- connect singals
self._done_btn.clicked.connect(lambda: self.done_editing.emit())
self._apply_btn.clicked.connect(self._apply_value)
def _get_default_thumbnail(self, sg_entity):
"""
Get the default icon for the specified entity.
:param sg_entity: A Shotgun entity dictionary for the entity to get the
icon for.
:returns: A QIcon for the entity if available. For Step entities, a
swatch representing the step colour is returned. If no
icon is available for the entity type then None is returned
"""
if sg_entity.get("type") == "Step":
# special case handling for steps to return a colour swatch:
step_id = sg_entity.get("id")
if step_id != None:
# get the colour from the cache:
if step_id not in ShotgunEntityModel._SG_STEP_COLOURS:
ShotgunEntityModel._SG_STEP_COLOURS[step_id] = None
# refresh cache:
bundle = sgtk.platform.current_bundle()
try:
sg_steps = bundle.shotgun.find("Step", [], ["color"])
for sg_step in sg_steps:
colour = None
try:
colour = tuple([
int(c)
for c in sg_step.get("color").split(",")
])
except:
pass
ShotgunEntityModel._SG_STEP_COLOURS[
sg_step["id"]] = colour
except:
pass
colour = ShotgunEntityModel._SG_STEP_COLOURS[step_id]
if colour and isinstance(colour, tuple) and len(colour) == 3:
# get the icon for this colour from the cache:
if colour not in self._step_swatch_icons:
# build icon and add to cache:
pm = QtGui.QPixmap(16, 16)
pm.fill(QtCore.Qt.transparent)
painter = QtGui.QPainter(pm)
try:
painter.setBrush(
QtGui.QBrush(
QtGui.QColor(colour[0], colour[1],
colour[2])))
painter.setPen(QtCore.Qt.black)
painter.drawRect(2, 2, 12, 12)
finally:
painter.end()
self._step_swatch_icons[colour] = QtGui.QIcon(pm)
# return the icon:
return QtGui.QIcon(self._step_swatch_icons[colour])
# just return the entity icon:
return self.get_entity_icon(sg_entity.get("type"))
def _add_dummy_placeholder_item(self, parent_item, refreshing):
"""
Create a dummy child item under the given item.
These items are used in tree views to show that a deferred query didn't
return any Shotgun record or that the data is being refreshed from Shotgun.
:param parent_item: A :class:`ShotgunStandardItem` instance.
:returns: A string, the unique id for the item.
"""
parent_uid = parent_item.data(self._SG_ITEM_UNIQUE_ID)
self._deferred_cache.add_item(parent_uid=None,
sg_data={},
field_name="",
is_leaf=False,
uid=parent_uid)
uid = self._dummy_placeholder_item_uid(parent_item)
display_name = shotgun_globals.get_type_display_name(
self._deferred_query["entity_type"])
if refreshing:
text = "Retrieving %ss..." % display_name
else:
text = "No %ss found" % display_name
exists = self._deferred_cache.item_exists(uid)
# Update or create the dummy item in the cache
self._deferred_cache.add_item(
parent_uid=parent_uid,
# We need to use something which looks like a SG Entity dictionary.
# By having a "text" key and using it for the field name, the tree
# view will display its contents.
sg_data={
"text": text,
"type": ""
},
field_name="text",
is_leaf=True,
uid=uid,
)
if not exists:
# Create the item in the model
sub_item = self._create_item(
parent=parent_item,
data_item=self._deferred_cache.get_entry_by_uid(uid))
sub_item.setData(True, self._SG_ITEM_FETCHED_MORE)
# This item can't be used.
sub_item.setSelectable(False)
sub_item.setEnabled(False)
sub_item.setIcon(QtGui.QIcon())
else:
sub_item = self._get_item_by_unique_id(uid)
if sub_item:
self._update_item(sub_item,
self._deferred_cache.get_entry_by_uid(uid))
# We don't want an icon to appear in the view. Updating the item
# reset the icon, so we have to reset it after the update.
sub_item.setIcon(QtGui.QIcon())
return uid
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(490, 618)
self.verticalLayout = QtGui.QVBoxLayout(Dialog)
self.verticalLayout.setObjectName("verticalLayout")
self.browser = SceneBrowserWidget(Dialog)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.browser.sizePolicy().hasHeightForWidth())
self.browser.setSizePolicy(sizePolicy)
self.browser.setObjectName("browser")
self.verticalLayout.addWidget(self.browser)
self.horizontalLayout_3 = QtGui.QHBoxLayout()
self.horizontalLayout_3.setSpacing(3)
self.horizontalLayout_3.setObjectName("horizontalLayout_3")
self.groupBox = QtGui.QGroupBox(Dialog)
self.groupBox.setTitle("")
self.groupBox.setObjectName("groupBox")
self.horizontalLayout_2 = QtGui.QHBoxLayout(self.groupBox)
self.horizontalLayout_2.setSpacing(10)
self.horizontalLayout_2.setContentsMargins(2, 2, 2, 2)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.label = QtGui.QLabel(self.groupBox)
self.label.setObjectName("label")
self.horizontalLayout_2.addWidget(self.label)
self.chk_green = QtGui.QCheckBox(self.groupBox)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/res/green_bullet.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.chk_green.setIcon(icon)
self.chk_green.setObjectName("chk_green")
self.horizontalLayout_2.addWidget(self.chk_green)
self.chk_red = QtGui.QCheckBox(self.groupBox)
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap(":/res/red_bullet.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.chk_red.setIcon(icon1)
self.chk_red.setObjectName("chk_red")
self.horizontalLayout_2.addWidget(self.chk_red)
self.horizontalLayout_3.addWidget(self.groupBox)
spacerItem = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Minimum)
self.horizontalLayout_3.addItem(spacerItem)
self.select_all = QtGui.QPushButton(Dialog)
self.select_all.setObjectName("select_all")
self.horizontalLayout_3.addWidget(self.select_all)
self.update = QtGui.QPushButton(Dialog)
self.update.setObjectName("update")
self.horizontalLayout_3.addWidget(self.update)
self.verticalLayout.addLayout(self.horizontalLayout_3)
self.retranslateUi(Dialog)
QtCore.QMetaObject.connectSlotsByName(Dialog)
def __init__(self, parent, schema_generation=0, bg_task_manager=None):
"""
Initialize the Hierarcy model.
:param parent: The model's parent.
:type parent: :class:`~PySide.QtGui.QObject`
"""
super(ShotgunHierarchyModel, self).__init__(parent, bg_task_manager)
# check for hierarchy support
(self._hierarchy_is_supported, self._hierarchy_not_supported_reason) = \
self.__hierarchy_is_supported()
if not self._hierarchy_is_supported:
self._log_warning(self._hierarchy_not_supported_reason)
self._path = None
self._seed_entity_field = None
self._entity_fields = None
self._schema_generation = schema_generation
# flag to indicate a full refresh
self._request_full_refresh = False
# is the model set up with a query?
self._has_query = False
# keeps track of the currently running queries by mapping the id
# returned by the data retriever to the path being queried
self._running_query_lookup = {}
# keep these icons around so they're not constantly being created
self._folder_icon = QtGui.QIcon(
":tk-framework-shotgunutils/icon_Folder.png")
self._none_icon = QtGui.QIcon(
":tk-framework-shotgunutils/icon_None_dark.png")
# Define the foreground color of "empty" items.
# These special items are used as placeholders in the tree where the
# parent has no children. An example would be `Shots > No Shots` where
# `No Shots` is the "empty" item. By default, the color is a mix of the
# application instance's base and text colors. This will typically
# result in a dimmed appearance for these special items indicating that
# they are not clickable. This makes goes outside the typical bounds of
# the model by pulling the palette colors from the app instance. This
# can be overridden in subclasses via ``_finalize_item()`` though.
base_color = QtGui.QApplication.instance().palette().base().color()
text_color = QtGui.QApplication.instance().palette().text().color()
# local import to avoid doc generation issues
from ..utils import color_mix
self._empty_item_color = color_mix(text_color, 1, base_color, 2)
def __init__(self, parent, command_name, button_name, icon, tooltip,
timestamp):
"""
:param str command_name: Name of the command.
:param str button_name: Name of the button.
:param str icon: Path to the icon for this command.
:param str tooltip: Toolkit for this command.
:param datetime.datetime timestamp: When the command was last launched.
"""
super(RecentButton, self).__init__(parent)
# No borders
self.setFlat(True)
self.setSizePolicy(QtGui.QSizePolicy.MinimumExpanding,
QtGui.QSizePolicy.MinimumExpanding)
self.setFocusPolicy(QtCore.Qt.NoFocus)
layout = QtGui.QVBoxLayout(self)
layout.setAlignment(QtCore.Qt.AlignHCenter)
layout.setSpacing(self.SPACING)
layout.setContentsMargins(self.MARGIN, self.MARGIN, self.MARGIN,
self.MARGIN)
self._timestamp = timestamp
self.icon_label = QtGui.QLabel(self)
self.icon_label.setAlignment(QtCore.Qt.AlignHCenter)
self.layout().addWidget(self.icon_label, QtCore.Qt.AlignHCenter)
# setting the stretch to 0 on the icon means the the text label will
# stretch and the icon won't creating a more stable looking effect.
layout.setStretch(0, 0)
self.text_label = QtGui.QLabel(parent)
self.text_label.setWordWrap(True)
self.text_label.setAlignment(QtCore.Qt.AlignHCenter
| QtCore.Qt.AlignTop)
self.layout().addWidget(self.text_label, QtCore.Qt.AlignHCenter)
self.setFocusPolicy(QtCore.Qt.NoFocus)
self.setStyleSheet(BUTTON_STYLE)
self.text_label.setText(button_name)
if icon is None:
self.icon_label.setPixmap(QtGui.QIcon().pixmap(ICON_SIZE))
else:
self.icon_label.setPixmap(QtGui.QIcon(icon).pixmap(ICON_SIZE))
self.setToolTip(tooltip)
self._command_name = command_name
self.clicked.connect(lambda: self.command_triggered.emit(
six.ensure_str(self._command_name)))
def __init__(self, parent):
"""
:param parent: The parent QWidget for this control
:type parent: :class:`~PySide.QtGui.QWidget`
"""
# first, call the base class and let it do its thing.
QtGui.QWidget.__init__(self, parent)
# now load in the UI that was created in the UI designer
self.ui = Ui_NoteInputWidget()
self.ui.setupUi(self)
self._load_stylesheet()
# set up some handy references
self._bundle = sgtk.platform.current_bundle()
self._camera_icon = QtGui.QIcon(
QtGui.QPixmap(
":/tk_framework_qtwidgets.note_input_widget/camera_hl.png"))
self._trash_icon = QtGui.QIcon(
QtGui.QPixmap(
":/tk_framework_qtwidgets.note_input_widget/trash.png"))
# initialize state variables
self._processing_id = None # async task id
self._entity_type = None # current associated entity
self._entity_id = None # current associated entity
self._pixmap = None #
self._attachments = []
self._cleanup_after_upload = []
# set up an overlay that spins when note is submitted
self.__overlay = SmallOverlayWidget(self)
# create a separate sg data handler for submission
self.__sg_data_retriever = None
# hook up signals and slots
self.ui.screenshot.clicked.connect(self._screenshot_or_clear)
self.ui.submit.clicked.connect(self._submit)
self.ui.close.clicked.connect(self._cancel)
self.ui.close.clicked.connect(self.close_clicked)
self.ui.attach.clicked.connect(self.open_attachments)
self.ui.add_attachments.clicked.connect(self._apply_attachments)
self.ui.close_attachments.clicked.connect(self._cancel_attachments)
self.ui.add_button.clicked.connect(self._add_attachments)
self.ui.remove_button.clicked.connect(
self._remove_selected_attachments)
# reset state of the UI
self.pre_submit_callback = None
self.clear()
def update_tk_templates(self):
if not self.context:
self.log.error('TK context is not defined, unable to update TK templates.')
return
tk = self._app.context.sgtk
if not tk:
self.log.error('Unable to get TK instance, unable to update TK templates.')
return
templates = tk.templates
# Support non-engine template definitions. If None, then use engine key name instead. ie: Data > data > take_data
app_name = str(self.ui.appComboBox.itemData(self.ui.appComboBox.currentIndex()))
if app_name:
app_name = app_name.lower().replace(' ', '').replace('tk-', '')
else:
app_name = self.ui.appComboBox.currentText().lower()
entity_type = self.context.entity['type']
# Remap entity name
entity_type = self.custom_entity_name_remap.get(entity_type, entity_type).lower()
regex = '%s_%s' % (entity_type, app_name)
active_templates = {}
for k, v in templates.iteritems():
if re.search(regex, k):
active_templates[k] = v
self.ui.tkTemplateComboBox.clear()
active_keys = active_templates.keys()
active_keys.sort()
self.ui.tkTemplateComboBox.addItem(QtGui.QIcon(':/res/block.png'), 'Select Template')
for key in active_keys:
key_title = key.replace(entity_type, '').replace('_', ' ').title()
self.ui.tkTemplateComboBox.addItem(QtGui.QIcon(':/res/sg_logo.png'), key_title, active_templates[key])
# Default to "work" template if available
index = self.ui.tkTemplateComboBox.findText('Work', QtCore.Qt.MatchContains)
if index > -1:
self.ui.tkTemplateComboBox.setCurrentIndex(index)
self.ui.tkTemplateComboBox.currentIndexChanged.connect(self.update_template_definition)
self.update_template_definition()
def __init__(self, item, parent):
"""
:param item:
:param parent: The parent QWidget for this control
"""
self._item = item
super(TreeNodeItem, self).__init__(parent)
self.setFlags(self.flags() | QtCore.Qt.ItemIsSelectable)
# go ahead and keep a handle on these so they can be reused
self._expanded_icon = QtGui.QIcon(":/tk_multi_publish2/down_arrow.png")
self._collapsed_icon = QtGui.QIcon(
":/tk_multi_publish2/right_arrow.png")
def choose_thumbnail(self, model_index):
original_tn = model_index.data(self._ORIGINAL_THUMBNAIL)
pinned_tn = model_index.data(self._PINNED_THUMBNAIL)
filter_tn = model_index.data(self._FILTER_THUMBNAIL)
if pinned_tn:
return QtGui.QIcon(pinned_tn)
if filter_tn:
return QtGui.QIcon(filter_tn)
if original_tn:
return QtGui.QIcon(original_tn)
return None
def update_applications(self):
self.ui.appComboBox.clear()
self.ui.appComboBox.addItem(QtGui.QIcon(':/res/block.png'), 'Select Application')
app_keys = list(self.applications.keys())
app_keys.sort()
for appKey in app_keys:
self.ui.appComboBox.addItem(QtGui.QIcon(':/res/sg_logo.png'), appKey, self.applications[appKey])
self.ui.appComboBox.currentIndexChanged.connect(self.update_tk_context)
self.ui.appComboBox.currentIndexChanged.connect(self.update_tk_templates)
def setModelData(self, editor, model, index):
"""
Gets data from the editor widget and stores it in the specified model at
the item index.
:param editor: The editor widget.
:type editor: :class:`~PySide.QtGui.QWidget`
:param model: The SG model where the data lives.
:type model: :class:`~PySide.QtCore.QAbstractItemModel`
:param index: The index of the model to be edited.
:type index: :class:`~PySide.QtCore.QModelIndex`
"""
src_index = _map_to_source(index)
if not src_index or not src_index.isValid():
# invalid index, do nothing
return
# compare the new/old values to see if there is a change
new_value = editor.get_value()
cur_value = src_index.data(self.field_data_role)
if cur_value == new_value:
# value didn't change. nothing to do here.
return
bundle = sgtk.platform.current_bundle()
# special case for image fields in the ShotgunModel. The SG model stores
# the image field in the first column. If the value has changed, set the
# icon value there.
if editor.get_field_name() == "image":
primary_item = src_index.model().item(src_index.row(), 0)
try:
if new_value:
# update the value locally in the model
primary_item.setIcon(QtGui.QIcon(new_value))
else:
primary_item.setIcon(QtGui.QIcon())
except Exception as e:
bundle.log_error("Unable to set icon for widget delegate: %s" % (e,))
return
successful = src_index.model().setData(
src_index, new_value, self.field_data_role
)
if not successful:
bundle.log_error(
"Unable to set model data for widget delegate: %s, %s"
% (self._entity_type, self._field_name)
)
def __init__(self, parent=None):
super(ProgressDialog, self).__init__(parent)
# Window options
self.setWindowTitle('tk-cpenv')
self.setWindowIcon(QtGui.QIcon(res.get_path('module_dark_256.png')))
self.setWindowFlags(self.windowFlags()
| QtCore.Qt.WindowStaysOnTopHint)
self.hide_timer = None
# Layout widgets
self.label = QtGui.QLabel('Starting...')
self.progress = QtGui.QProgressBar()
self.progress.setRange(0, 100)
self.progress.setTextVisible(True)
self.progress.setAlignment(QtCore.Qt.AlignCenter)
self.progress.setFormat('starting')
self.frame = QtGui.QLabel()
self.button = QtGui.QPushButton('Cancel')
self.button.setSizePolicy(
QtGui.QSizePolicy.Maximum,
QtGui.QSizePolicy.Maximum,
)
self.button.clicked.connect(self.cancel)
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.label)
self.layout.addWidget(self.progress)
self.layout.addWidget(self.frame)
self.layout.addWidget(self.button)
self.layout.setAlignment(self.button, QtCore.Qt.AlignRight)
self.setLayout(self.layout)
def _populate_thumbnail(self, item, field, path):
"""
Called whenever a thumbnail for an item has arrived on disk. In the case of
an already cached thumbnail, this may be called very soon after data has been
loaded, in cases when the thumbs are downloaded from Shotgun, it may happen later.
This method will be called only if the model has been instantiated with the
download_thumbs flag set to be true. It will be called for items which are
associated with shotgun entities (in a tree data layout, this is typically
leaf nodes).
This method makes it possible to control how the thumbnail is applied and associated
with the item. The default implementation will simply set the thumbnail to be icon
of the item, but this can be altered by subclassing this method.
Any thumbnails requested via the _request_thumbnail_download() method will also
resurface via this callback method.
:param item: QStandardItem which is associated with the given thumbnail
:param field: The Shotgun field which the thumbnail is associated with.
:param path: A path on disk to the thumbnail. This is a file in jpeg format.
"""
# pass the thumbnail through out special image compositing methods
# before associating it with the model
is_folder = item.data(SgLatestPublishModel.IS_FOLDER_ROLE)
if is_folder:
# composite the thumbnail nicely on top of the folder icon
thumb = utils.create_overlayed_folder_thumbnail(path)
else:
thumb = utils.create_overlayed_publish_thumbnail(path)
item.setIcon(QtGui.QIcon(thumb))
def _add_context_menu(self):
"""
Adds a context menu which displays the current context.
"""
from sgtk.platform.qt import QtGui
# create the context menu
ctx = self.engine.context
menu = self.root_menu.addMenu(str(ctx))
style = menu.style()
action = menu.addAction('Jump to File System')
action.triggered.connect(self._jump_to_fs)
action.setIcon(style.standardIcon(style.SP_DialogOpenButton))
action = menu.addAction('Jump to Shotgun')
action.triggered.connect(self._jump_to_sg)
try:
import sgtk.platform.qt.resources_rc
except ImportError:
self.engine.logger.warn(traceback.format_exc())
else:
action.setIcon(QtGui.QIcon(':/Tank.Platform.Qt/tank_logo.png'))
menu.addSeparator()
return menu
def init_qt_app(self):
"""
Initializes if not done already the QT Application for the engine.
"""
from sgtk.platform.qt import QtGui
self.logger.debug("Initializing QT Application for the engine")
if not QtGui.QApplication.instance():
self._qt_app = QtGui.QApplication(sys.argv)
else:
self._qt_app = QtGui.QApplication.instance()
# set icon for the engine windows
self._qt_app.setWindowIcon(QtGui.QIcon(self.icon_256))
self._qt_app_main_window = QtGui.QMainWindow()
self._qt_app_central_widget = QtGui.QWidget()
self._qt_app_main_window.setCentralWidget(self._qt_app_central_widget)
self._qt_app.setQuitOnLastWindowClosed(False)
# Make the QApplication use the dark theme. Must be called after the
# QApplication is instantiated
self._initialize_dark_look_and_feel()
self.logger.debug("QT Application: %s" % self._qt_app)
def setupUi(self, BannerWidget):
BannerWidget.setObjectName("BannerWidget")
BannerWidget.resize(618, 71)
self.horizontalLayout = QtGui.QHBoxLayout(BannerWidget)
self.horizontalLayout.setContentsMargins(6, 0, 0, 0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.message = QtGui.QLabel(BannerWidget)
self.message.setStyleSheet("border-style: outset;\n"
"border-color: rgb(0, 0, 0);")
self.message.setWordWrap(True)
self.message.setOpenExternalLinks(False)
self.message.setObjectName("message")
self.horizontalLayout.addWidget(self.message)
self.close_button = QtGui.QToolButton(BannerWidget)
self.close_button.setStyleSheet("border: none;")
self.close_button.setText("")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/tk-desktop/cross.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.close_button.setIcon(icon)
self.close_button.setIconSize(QtCore.QSize(30, 30))
self.close_button.setObjectName("close_button")
self.horizontalLayout.addWidget(self.close_button)
self.retranslateUi(BannerWidget)
QtCore.QMetaObject.connectSlotsByName(BannerWidget)
def __init__(self, environment, parent):
super(EnvPermissions, self).__init__(parent)
self.state = {
'environment': environment,
}
self.save_button = QtGui.QPushButton('Save')
self.cancel_button = QtGui.QPushButton('Cancel')
# Layout widgets
button_layout = QtGui.QHBoxLayout()
button_layout.addWidget(self.save_button)
button_layout.addWidget(self.cancel_button)
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(QtGui.QLabel('Restrict to Users'))
self.layout.addLayout(button_layout)
self.setLayout(self.layout)
# Connect widgets
self.save_button.clicked.connect(self.on_save_clicked)
self.cancel_button.clicked.connect(self.on_cancel_clicked)
self.setWindowTitle('Environment Permissions')
self.setWindowIcon(QtGui.QIcon(res.get_path('icon_dark_256.png')))
shotgun_fields = sgtk.platform.import_framework(
"tk-framework-qtwidgets",
"shotgun_fields",
)
self._fields_manager = shotgun_fields.ShotgunFieldManager(self)
self._fields_manager.initialized.connect(self.on_initialized)
self._fields_manager.initialize()
def __init__(self, parent=None):
super(Console, self).__init__(parent)
self.setWindowTitle('Shotgun Desktop Console')
self.setWindowIcon(QtGui.QIcon(":/tk-desktop/default_systray_icon.png"))
self.__logs = QtGui.QPlainTextEdit()
layout = QtGui.QHBoxLayout()
layout.addWidget(self.__logs)
self.setLayout(layout)
# configure the text widget
self.__logs.setReadOnly(True)
self.__logs.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.__logs.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
self.__logs.customContextMenuRequested.connect(self.on_logs_context_menu_request)
self.__logs.setStyleSheet("QPlainTextEdit:focus { border: none; }")
# load up previous size
self._settings_manager = settings.UserSettings(sgtk.platform.current_bundle())
pos = self._settings_manager.retrieve("console.pos", self.pos(), self._settings_manager.SCOPE_GLOBAL)
size = self._settings_manager.retrieve(
"console.size", QtCore.QSize(800, 400), self._settings_manager.SCOPE_GLOBAL)
self.move(pos)
self.resize(size)
def __init__(self, parent):
super(Attachments, self).__init__(parent)
self.setFlow(QtGui.QListView.LeftToRight)
self.setViewMode(QtGui.QListView.IconMode)
self.setResizeMode(QtGui.QListView.Adjust)
self.setGridSize(QtCore.QSize(36, 36))
self.setStyleSheet(self.style)
self.setMaximumHeight(36)
self.setSelectionMode(self.NoSelection)
self.setFocusPolicy(QtCore.Qt.NoFocus)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self._show_context_menu)
self._attachments = []
self._default_items = []
# Capture button
self.capture_button = QtGui.QToolButton(
icon=QtGui.QIcon(res.get_path('camera.png')))
self.capture_button.setToolTip('Grab part of the screen.')
self.capture_button.clicked.connect(self._on_capture)
item = QtGui.QListWidgetItem()
item.setSizeHint(self.gridSize())
self.addItem(item)
self.setItemWidget(item, self.capture_button)
self._default_items.append(item)
def __init__(self, environments, parent=None):
super(EnvSelector, self).__init__(parent)
self.state = {
'environments': environments,
'choice': environments[0],
}
self.msg = QtGui.QLabel('Select an Environment')
self.msg.setAlignment(QtCore.Qt.AlignCenter)
buttons = []
for environment in environments:
button = QtGui.QPushButton(environment['code'])
button.setToolTip(
'Modules:\n'
+ '\n'.join(environment['sg_requires'].split())
)
button.setObjectName('SelectButton')
button.clicked.connect(self.choose(environment))
buttons.append(button)
# Layout widgets
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.msg)
for button in buttons:
self.layout.addWidget(button)
self.setLayout(self.layout)
self.setWindowTitle('tk-cpenv')
self.setWindowIcon(QtGui.QIcon(res.get_path('icon_dark_256.png')))
self.setStyleSheet(self.style)
def _populate_thumbnail_image(self, item, field, image, path):
"""
Called whenever a thumbnail for an item has arrived on disk. In the case of
an already cached thumbnail, this may be called very soon after data has been
loaded, in cases when the thumbs are downloaded from Shotgun, it may happen later.
This method will be called only if the model has been instantiated with the
download_thumbs flag set to be true. It will be called for items which are
associated with shotgun entities (in a tree data layout, this is typically
leaf nodes).
This method makes it possible to control how the thumbnail is applied and associated
with the item. The default implementation will simply set the thumbnail to be icon
of the item, but this can be altered by subclassing this method.
Any thumbnails requested via the _request_thumbnail_download() method will also
resurface via this callback method.
:param item: QStandardItem which is associated with the given thumbnail
:param field: The Shotgun field which the thumbnail is associated with.
:param path: A path on disk to the thumbnail. This is a file in jpeg format.
"""
if field not in self._sg_formatter.thumbnail_fields:
# there may be other thumbnails being loaded in as part of the data flow
# (in particular, created_by.HumanUser.image) - these ones we just want to
# ignore and not display.
return
sg_data = item.get_sg_data()
icon = self._sg_formatter.create_thumbnail(image, sg_data)
item.setIcon(QtGui.QIcon(icon))
def __init__(self, parent = None ) :
QtGui.QWidget.__init__(self, parent)
lay = QtGui.QHBoxLayout()
lay.setContentsMargins(0,0,0,0)
lay.setSpacing(0)
self.writeTo = ToDoLineEdit("who ?")
self.writeWhat = ToDoLineEdit("what ?")
self.sendButton = QtGui.QPushButton()
self.sendButton.setIcon(QtGui.QIcon(getRessources("sendNotification") ))
self.sendButton.setFlat(True);
self.sendButton.setIconSize(QtCore.QSize(20,20));
style = 'QPushButton:hover{border: 1px solid rgb(48,226,227)}'
self.sendButton.setStyleSheet("QPushButton{outline: none;}"+style);
self.sendButton.notificationAttr = True
lay.addWidget(self.writeTo)
lay.addSpacing(5)
lay.addWidget(self.writeWhat)
lay.addSpacing(5)
lay.addWidget(self.sendButton)
self.setLayout(lay)
self.writeTo.setMaximumWidth(150)
def set_status(self, status, message="", info_below=True):
"""
Set the status for the plugin
:param status: An integer representing on of the
status constants defined by the class
"""
if status not in self._icon_lookup:
raise ValueError("Invalid icon index!")
if status == self.NEUTRAL:
self.ui.status.hide()
else:
default_message = "Click for more details."
if message:
if info_below:
message += "<br>See below or click for more details."
else:
message += "<br>%s" % (default_message, )
else:
message = default_message
self.ui.status.setToolTip(
QtGui.QApplication.translate(
"ItemWidget",
"<p>%s</p>" % (message, ),
None,
QtGui.QApplication.UnicodeUTF8,
))
self.ui.status.show()
self._status_icon = QtGui.QIcon()
self._status_icon.addPixmap(self._icon_lookup[status],
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.ui.status.setIcon(self._status_icon)
def _handle_search_results(self, data):
"""
Populates the model associated with the completer with the data coming back from Shotgun.
:param dict data: Data received back from the job sent to the
:class:`~tk-framework-shotgunutils:shotgun_data.ShotgunDataRetriever` in :method:``_launch_sg_search``.
"""
matches = data["sg"]["matches"]
if len(matches) == 0:
item = QtGui.QStandardItem("No matches found!")
item.setData(self.MODE_NOT_FOUND, self.MODE_ROLE)
self.model().appendRow(item)
# insert new data into model
for d in matches:
item = QtGui.QStandardItem(d["name"])
item.setData(self.MODE_RESULT, self.MODE_ROLE)
item.setData(shotgun_model.sanitize_for_qt_model(d),
self.SG_DATA_ROLE)
item.setIcon(QtGui.QIcon(self._pixmaps.no_thumbnail))
if d.get("image") and self._sg_data_retriever:
uid = self._sg_data_retriever.request_thumbnail(
d["image"], d["type"], d["id"], "image", load_image=True)
self._thumb_map[uid] = {"item": item}
self.model().appendRow(item)
def _populate_thumbnail_image(self, item, field, image, path):
"""
Called whenever a thumbnail for an item has arrived on disk. In the case of
an already cached thumbnail, this may be called very soon after data has been
loaded, in cases when the thumbs are downloaded from Shotgun, it may happen later.
This method will be called only if the model has been instantiated with the
download_thumbs flag set to be true. It will be called for items which are
associated with shotgun entities (in a tree data layout, this is typically
leaf nodes).
This method makes it possible to control how the thumbnail is applied and associated
with the item. The default implementation will simply set the thumbnail to be icon
of the item, but this can be altered by subclassing this method.
Any thumbnails requested via the _request_thumbnail_download() method will also
resurface via this callback method.
:param item: QStandardItem which is associated with the given thumbnail
:param field: The Shotgun field which the thumbnail is associated with.
:param path: A path on disk to the thumbnail. This is a file in jpeg format.
"""
if field == "image":
thumb = QtGui.QPixmap.fromImage(image)
item.setData(thumb, SgPublishHistoryModel.PUBLISH_THUMB_ROLE)
else:
thumb = QtGui.QPixmap.fromImage(image)
item.setData(thumb, SgPublishHistoryModel.USER_THUMB_ROLE)
# composite the user thumbnail and the publish thumb into a single image
thumb = utils.create_overlayed_user_publish_thumbnail(
item.data(SgPublishHistoryModel.PUBLISH_THUMB_ROLE),
item.data(SgPublishHistoryModel.USER_THUMB_ROLE),
)
item.setIcon(QtGui.QIcon(thumb))
def __init__(self, label, message, parent=None):
super(ErrorDialog, self).__init__(parent)
self.setWindowTitle('tk-multi-tickets Error')
self.setWindowIcon(QtGui.QIcon(res.get_path('icon_256.png')))
self.setWindowFlags(self.windowFlags()
| QtCore.Qt.WindowStaysOnTopHint)
self.label = QtGui.QLabel(label)
self.text = QtGui.QPlainTextEdit(message)
self.text.setTextInteractionFlags(QtCore.Qt.TextBrowserInteraction)
self.button = QtGui.QPushButton('Dismiss')
self.button.setSizePolicy(
QtGui.QSizePolicy.Maximum,
QtGui.QSizePolicy.Maximum,
)
self.button.clicked.connect(self.accept)
self.layout = QtGui.QVBoxLayout()
self.layout.setStretch(1, 1)
self.layout.addWidget(self.label)
self.layout.addWidget(self.text)
self.layout.addWidget(self.button)
self.layout.setAlignment(self.button, QtCore.Qt.AlignRight)
self.setLayout(self.layout)
def __init__(self, label, parent=None):
QtGui.QPushButton.__init__(self, parent)
self.setIcon(QtGui.QIcon(getRessources("refreshUI.png")))
self.setFlat(True)
self.setIconSize(QtCore.QSize(16, 16))
style = 'QPushButton:hover{border: 1px solid rgb(48,226,227)}'
self.setStyleSheet("QPushButton{outline: none;}" + style)
