-
Notifications
You must be signed in to change notification settings - Fork 51
/
engine.py
715 lines (593 loc) · 27.7 KB
/
engine.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
# Copyright (c) 2015 Shotgun Software Inc.
#
# CONFIDENTIAL AND PROPRIETARY
#
# This work is provided "AS IS" and subject to the Shotgun Pipeline Toolkit
# Source Code License included in this distribution package. See LICENSE.
# By accessing, using, copying or modifying this work you indicate your
# agreement to the Shotgun Pipeline Toolkit Source Code License. All rights
# not expressly granted therein are reserved by Shotgun Software Inc.
"""
A Maya engine for Tank.
"""
import tank
import sys
import traceback
import time
import os
import maya.OpenMaya as OpenMaya
import pymel.core as pm
import maya.cmds as cmds
import maya.utils
###############################################################################################
# methods to support the state when the engine cannot start up
# for example if a non-tank file is loaded in maya
class SceneEventWatcher(object):
"""
Encapsulates event handling for multiple scene events and routes them
into a single callback.
This uses OpenMaya.MSceneMessage rather than scriptJobs as the former
can safely be removed from inside of the callback itself
Specifying run_once=True in the constructor causes all events to be
cleaned up after the first one has triggered
"""
def __init__(self, cb_fn,
scene_events = [OpenMaya.MSceneMessage.kAfterOpen,
OpenMaya.MSceneMessage.kAfterSave,
OpenMaya.MSceneMessage.kAfterNew],
run_once=False):
"""
Constructor.
:param cb_fn: Callcack to invoke everytime a scene event happens.
:param scene_events: List of scene events to watch for. Defaults to new, open and save.
:param run_once: If True, the watcher will notify only on the first event. Defaults to False.
"""
self.__message_ids = []
self.__cb_fn = cb_fn
self.__scene_events = scene_events
self.__run_once=run_once
# register scene event callbacks:
self.start_watching()
def start_watching(self):
"""
Starts watching for scene events.
"""
# if currently watching then stop:
self.stop_watching()
# now add callbacks to watch for some scene events:
for ev in self.__scene_events:
try:
msg_id = OpenMaya.MSceneMessage.addCallback(ev, SceneEventWatcher.__scene_event_callback, self);
except Exception:
# report warning...
continue
self.__message_ids.append(msg_id);
# create a callback that will be run when Maya
# exits so we can do some clean-up:
msg_id = OpenMaya.MSceneMessage.addCallback(OpenMaya.MSceneMessage.kMayaExiting, SceneEventWatcher.__maya_exiting_callback, self)
self.__message_ids.append(msg_id);
def stop_watching(self):
"""
Stops watching the Maya scene.
"""
for msg_id in self.__message_ids:
OpenMaya.MMessage.removeCallback(msg_id)
self.__message_ids = []
@staticmethod
def __scene_event_callback(watcher):
"""
Called on a scene event:
"""
if watcher.__run_once:
watcher.stop_watching()
watcher.__cb_fn()
@staticmethod
def __maya_exiting_callback(watcher):
"""
Called on Maya exit - should clean up any existing calbacks
"""
watcher.stop_watching()
def refresh_engine(engine_name, prev_context, menu_name):
"""
refresh the current engine
"""
current_engine = tank.platform.current_engine()
# first make sure that the disabled menu is removed, if it exists...
menu_was_disabled = remove_sgtk_disabled_menu()
# determine the tk instance and ctx to use:
tk = current_engine.sgtk
ctx = prev_context
if pm.sceneName() == "":
# if the scene opened is actually a file->new, then maintain the current
# context/engine.
if not menu_was_disabled:
# just return the current engine - no need to restart it!
return current_engine
else:
# loading a scene file
new_path = pm.sceneName().abspath()
# this file could be in another project altogether, so create a new
# API instance.
try:
tk = tank.tank_from_path(new_path)
except tank.TankError, e:
OpenMaya.MGlobal.displayInfo("Shotgun: Engine cannot be started: %s" % e)
# build disabled menu
create_sgtk_disabled_menu(menu_name)
return current_engine
# and construct the new context for this path:
ctx = tk.context_from_path(new_path, prev_context)
if current_engine:
# if context is unchanged and the menu was not previously disabled
# then no need to rebuild the same engine again!
if ctx == prev_context and not menu_was_disabled:
return current_engine
# tear down existing engine
current_engine.log_debug("Ready to switch to context because of scene event !")
current_engine.log_debug("Prev context: %s" % prev_context)
current_engine.log_debug("New context: %s" % ctx)
current_engine.destroy()
# start new engine
new_engine = None
try:
new_engine = tank.platform.start_engine(engine_name, tk, ctx)
except tank.TankEngineInitError, e:
OpenMaya.MGlobal.displayInfo("Shotgun: Engine cannot be started: %s" % e)
# build disabled menu
create_sgtk_disabled_menu(menu_name)
else:
new_engine.log_debug("Launched new engine for context!")
return new_engine
def on_scene_event_callback(engine_name, prev_context, menu_name):
"""
Callback that's run whenever a scene is saved or opened.
"""
new_engine = None
try:
new_engine = refresh_engine(engine_name, prev_context, menu_name)
except Exception:
(exc_type, exc_value, exc_traceback) = sys.exc_info()
message = ""
message += "Message: Shotgun encountered a problem starting the Engine.\n"
message += "Please contact support@shotgunsoftware.com\n\n"
message += "Exception: %s - %s\n" % (exc_type, exc_value)
message += "Traceback (most recent call last):\n"
message += "\n".join( traceback.format_tb(exc_traceback))
OpenMaya.MGlobal.displayError(message)
new_engine = None
if not new_engine:
# don't have an engine but still want to watch for
# future scene events:
cb_fn = lambda en=engine_name, pc=prev_context, mn=menu_name:on_scene_event_callback(en, pc, mn)
SceneEventWatcher(cb_fn, run_once=True)
def sgtk_disabled_message():
"""
Explain why tank is disabled.
"""
msg = ("Shotgun integration is disabled because it cannot recognize "
"the currently opened file. Try opening another file or restarting "
"Maya.")
cmds.confirmDialog( title="Sgtk is disabled",
message=msg,
button=["Ok"],
defaultButton="Ok",
cancelButton="Ok",
dismissString="Ok" )
def create_sgtk_disabled_menu(menu_name):
"""
Render a special "shotgun is disabled" menu
"""
if cmds.about(batch=True):
# don't create menu in batch mode
return
if pm.menu("ShotgunMenu", exists=True):
pm.deleteUI("ShotgunMenu")
sg_menu = pm.menu("ShotgunMenuDisabled", label=menu_name, parent=pm.melGlobals["gMainWindow"])
pm.menuItem(label="Sgtk is disabled.", parent=sg_menu,
command=lambda arg: sgtk_disabled_message())
def remove_sgtk_disabled_menu():
"""
Remove the special "shotgun is disabled" menu if it exists
:returns: True if the menu existed and was deleted
"""
if cmds.about(batch=True):
# don't create menu in batch mode
return False
if pm.menu("ShotgunMenuDisabled", exists=True):
pm.deleteUI("ShotgunMenuDisabled")
return True
return False
###############################################################################################
# The Tank Maya engine
# for debug logging with time stamps
g_last_message_time = 0
class MayaEngine(tank.platform.Engine):
"""
Toolkit engine for Maya.
"""
##########################################################################################
# init and destroy
def pre_app_init(self):
"""
Runs after the engine is set up but before any apps have been initialized.
"""
# unicode characters returned by the shotgun api need to be converted
# to display correctly in all of the app windows
from tank.platform.qt import QtCore
# tell QT to interpret C strings as utf-8
utf8 = QtCore.QTextCodec.codecForName("utf-8")
QtCore.QTextCodec.setCodecForCStrings(utf8)
self.log_debug("set utf-8 codec for widget text")
def init_engine(self):
"""
Initializes the Maya engine.
"""
self.log_debug("%s: Initializing..." % self)
# check that we are running an ok version of maya
current_os = cmds.about(operatingSystem=True)
if current_os not in ["mac", "win64", "linux64"]:
raise tank.TankError("The current platform is not supported! Supported platforms "
"are Mac, Linux 64 and Windows 64.")
maya_ver = cmds.about(version=True)
if maya_ver.startswith("Maya "):
maya_ver = maya_ver[5:]
if maya_ver.startswith(("2012", "2013", "2014", "2015", "2016")):
self.log_debug("Running Maya version %s" % maya_ver)
else:
# show a warning that this version of Maya isn't yet fully tested with Shotgun:
msg = ("The Shotgun Pipeline Toolkit has not yet been fully tested with Maya %s. "
"You can continue to use Toolkit but you may experience bugs or instability."
"\n\nPlease report any issues to: support@shotgunsoftware.com"
% (maya_ver))
# determine if we should show the compatibility warning dialog:
show_warning_dlg = self.has_ui and "SGTK_COMPATIBILITY_DIALOG_SHOWN" not in os.environ
if show_warning_dlg:
# make sure we only show it once per session:
os.environ["SGTK_COMPATIBILITY_DIALOG_SHOWN"] = "1"
# split off the major version number - accomodate complex version strings and decimals:
major_version_number_str = maya_ver.split(" ")[0].split(".")[0]
if major_version_number_str and major_version_number_str.isdigit():
# check against the compatibility_dialog_min_version setting:
if int(major_version_number_str) < self.get_setting("compatibility_dialog_min_version"):
show_warning_dlg = False
if show_warning_dlg:
# Note, title is padded to try to ensure dialog isn't insanely narrow!
title = "Warning - Shotgun Pipeline Toolkit Compatibility! " # padded!
cmds.confirmDialog(title = title, message = msg, button = "Ok")
# always log the warning to the script editor:
self.log_warning(msg)
self._maya_version = maya_ver
try:
self.log_user_attribute_metric("Maya version", maya_ver)
except:
# ignore all errors. ex: using a core that doesn't support metrics
pass
# Set the Maya project based on config
self._set_project()
# add qt paths and dlls
self._init_pyside()
# default menu name is Shotgun but this can be overriden
# in the configuration to be Sgtk in case of conflicts
self._menu_name = "Shotgun"
if self.get_setting("use_sgtk_as_menu_name", False):
self._menu_name = "Sgtk"
# need to watch some scene events in case the engine needs rebuilding:
cb_fn = lambda en=self.instance_name, pc=self.context, mn=self._menu_name:on_scene_event_callback(en, pc, mn)
self.__watcher = SceneEventWatcher(cb_fn)
self.log_debug("Registered open and save callbacks.")
def post_app_init(self):
"""
Called when all apps have initialized
"""
# detect if in batch mode
if self.has_ui:
self._menu_handle = pm.menu("ShotgunMenu", label=self._menu_name, parent=pm.melGlobals["gMainWindow"])
# create our menu handler
tk_maya = self.import_module("tk_maya")
self._menu_generator = tk_maya.MenuGenerator(self, self._menu_handle)
# hook things up so that the menu is created every time it is clicked
self._menu_handle.postMenuCommand(self._menu_generator.create_menu)
# Run a series of app instance commands at startup.
self._run_app_instance_commands()
def _run_app_instance_commands(self):
"""
Runs the series of app instance commands listed in the 'run_at_startup' setting
of the environment configuration yaml file.
"""
# Build a dictionary mapping app instance names to dictionaries of commands they registered with the engine.
app_instance_commands = {}
for (command_name, value) in self.commands.iteritems():
app_instance = value["properties"].get("app")
if app_instance:
# Add entry 'command name: command function' to the command dictionary of this app instance.
command_dict = app_instance_commands.setdefault(app_instance.instance_name, {})
command_dict[command_name] = value["callback"]
# Run the series of app instance commands listed in the 'run_at_startup' setting.
for app_setting_dict in self.get_setting("run_at_startup", []):
app_instance_name = app_setting_dict["app_instance"]
# Menu name of the command to run or '' to run all commands of the given app instance.
setting_command_name = app_setting_dict["name"]
# Retrieve the command dictionary of the given app instance.
command_dict = app_instance_commands.get(app_instance_name)
if command_dict is None:
self.log_warning(
"%s configuration setting 'run_at_startup' requests app '%s' that is not installed." %
(self.name, app_instance_name))
else:
if not setting_command_name:
# Run all commands of the given app instance.
for (command_name, command_function) in command_dict.iteritems():
self.log_debug("%s startup running app '%s' command '%s'." %
(self.name, app_instance_name, command_name))
command_function()
else:
# Run the command whose name is listed in the 'run_at_startup' setting.
command_function = command_dict.get(setting_command_name)
if command_function:
self.log_debug("%s startup running app '%s' command '%s'." %
(self.name, app_instance_name, setting_command_name))
command_function()
else:
known_commands = ', '.join("'%s'" % name for name in command_dict)
self.log_warning(
"%s configuration setting 'run_at_startup' requests app '%s' unknown command '%s'. "
"Known commands: %s" %
(self.name, app_instance_name, setting_command_name, known_commands))
def destroy_engine(self):
"""
Stops watching scene events and tears down menu.
"""
self.log_debug("%s: Destroying..." % self)
# stop watching scene events:
self.__watcher.stop_watching()
# clean up UI:
if self.has_ui and pm.menu(self._menu_handle, exists=True):
pm.deleteUI(self._menu_handle)
def _init_pyside(self):
"""
Handles the pyside init
"""
# first see if pyside2 is present
try:
from PySide2 import QtGui
except:
# fine, we don't expect PySide2 to be present just yet
self.log_debug("PySide2 not detected - trying for PySide now...")
else:
# looks like pyside2 is already working! No need to do anything
self.log_debug("PySide2 detected - the existing version will be used.")
return
# then see if pyside is present
try:
from PySide import QtGui
except:
# must be a very old version of Maya.
self.log_debug("PySide not detected - it will be added to the setup now...")
else:
# looks like pyside is already working! No need to do anything
self.log_debug("PySide detected - the existing version will be used.")
return
if sys.platform == "darwin":
pyside_path = os.path.join(self.disk_location, "resources","pyside112_py26_qt471_mac", "python")
self.log_debug("Adding pyside to sys.path: %s" % pyside_path)
sys.path.append(pyside_path)
elif sys.platform == "win32" and self._maya_version.startswith("2013"):
# special 2013 version of pyside
pyside_path = os.path.join(self.disk_location, "resources","pyside113_py26_qt471maya2013_win64", "python")
self.log_debug("Adding pyside to sys.path: %s" % pyside_path)
sys.path.append(pyside_path)
dll_path = os.path.join(self.disk_location, "resources","pyside113_py26_qt471maya2013_win64", "lib")
path = os.environ.get("PATH", "")
path += ";%s" % dll_path
os.environ["PATH"] = path
elif sys.platform == "win32":
# default windows version of pyside for 2011 and 2012
pyside_path = os.path.join(self.disk_location, "resources","pyside111_py26_qt471_win64", "python")
self.log_debug("Adding pyside to sys.path: %s" % pyside_path)
sys.path.append(pyside_path)
dll_path = os.path.join(self.disk_location, "resources","pyside111_py26_qt471_win64", "lib")
path = os.environ.get("PATH", "")
path += ";%s" % dll_path
os.environ["PATH"] = path
elif sys.platform == "linux2":
pyside_path = os.path.join(self.disk_location, "resources","pyside112_py26_qt471_linux", "python")
self.log_debug("Adding pyside to sys.path: %s" % pyside_path)
sys.path.append(pyside_path)
else:
self.log_error("Unknown platform - cannot initialize PySide!")
# now try to import it
try:
from PySide import QtGui
except Exception, e:
self.log_error("PySide could not be imported! Apps using pyside will not "
"operate correctly! Error reported: %s" % e)
def _get_dialog_parent(self):
"""
Get the QWidget parent for all dialogs created through
show_dialog & show_modal.
"""
# Find a parent for the dialog - this is the Maya mainWindow()
from tank.platform.qt import QtGui
import maya.OpenMayaUI as OpenMayaUI
try:
import shiboken2 as shiboken
except ImportError:
import shiboken
ptr = OpenMayaUI.MQtUtil.mainWindow()
parent = shiboken.wrapInstance(long(ptr), QtGui.QMainWindow)
return parent
@property
def has_ui(self):
"""
Detect and return if maya is running in batch mode
"""
if cmds.about(batch=True):
# batch mode or prompt mode
return False
else:
return True
##########################################################################################
# logging
def log_debug(self, msg):
"""
Log debug to the Maya script editor
:param msg: The message to log
"""
global g_last_message_time
# get the time stamps
prev_time = g_last_message_time
current_time = time.time()
# update global counter
g_last_message_time = current_time
if not self.get_setting("debug_logging", False):
return
msg = "Shotgun Debug [%0.3fs]: %s" % ((current_time-prev_time), msg)
self.async_execute_in_main_thread(OpenMaya.MGlobal.displayInfo, msg)
def log_info(self, msg):
"""
Log info to the Maya script editor
:param msg: The message to log
"""
msg = "Shotgun: %s" % msg
self.async_execute_in_main_thread(OpenMaya.MGlobal.displayInfo, msg)
def log_warning(self, msg):
"""
Log warning to the Maya script editor
:param msg: The message to log
"""
msg = "Shotgun: %s" % msg
self.async_execute_in_main_thread(OpenMaya.MGlobal.displayWarning, msg)
def log_error(self, msg):
"""
Log error to the Maya script editor
:param msg: The message to log
"""
msg = "Shotgun: %s" % msg
self.async_execute_in_main_thread(OpenMaya.MGlobal.displayError, msg)
##########################################################################################
# scene and project management
def _set_project(self):
"""
Set the maya project
"""
setting = self.get_setting("template_project")
if setting is None:
return
tmpl = self.tank.templates.get(setting)
fields = self.context.as_template_fields(tmpl)
proj_path = tmpl.apply_fields(fields)
self.log_info("Setting Maya project to '%s'" % proj_path)
pm.mel.setProject(proj_path)
##########################################################################################
# panel support
def show_panel(self, panel_id, title, bundle, widget_class, *args, **kwargs):
"""
Docks an app widget in a maya panel.
:param panel_id: Unique identifier for the panel, as obtained by register_panel().
:param title: The title of the panel
:param bundle: The app, engine or framework object that is associated with this window
:param widget_class: The class of the UI to be constructed. This must derive from QWidget.
Additional parameters specified will be passed through to the widget_class constructor.
:returns: the created widget_class instance
"""
from tank.platform.qt import QtCore, QtGui
tk_maya = self.import_module("tk_maya")
self.log_debug("Begin showing panel %s" % panel_id)
# The general approach below is as follows:
#
# 1. First create our qt tk app widget using QT.
# parent it to the maya main window to give it
# a well established parent. If the widget already
# exists, don't create it again, just retrieve its
# handle
#
# 2. Now create a native maya window and layout and
# attach our QT control to this. For this, we use
# the QT objectname property to do the bind. Note that
# the window won't show in the UI, this is all just
# setting up the hiearchy.
#
# 3. If a panel already exists, delete it. The panel
# no longer has the tk widget inside it, since that is
# parented to the window that was just created
#
# 4. Create a new panel using the dockControl command and
# pass our maya window in as the object to dock.
#
# 5. Lastly, since our widgets won't get notified about
# when the parent dock is closed (and sometimes when it
# needs redrawing), attach some QT event watchers to it
#
#
# Note: It is possible that the close event and some of the
# refresh doesn't propagate down to the widget because
# of a misaligned parenting: The tk widget exists inside
# the pane layout but is still parented to the main
# maya window. It's possible that by setting up the parenting
# explicitly, the missing signals we have to compensate for
# may start to work. I tried a bunch of stuff but couldn't get
# it to work and instead resorted to the event watcher setup.
# make a unique id for the app widget based off of the panel id
widget_id = "wdgt_%s" % panel_id
# create a maya window and layout
window = pm.window()
self.log_debug("Created window: %s" % window)
maya_layout = pm.formLayout(parent=window)
self.log_debug("Created layout %s" % maya_layout)
if pm.control(widget_id, query=1, exists=1):
self.log_debug("Toolkit widget already exists. Reparenting it...")
# find the widget for later use
for widget in QtGui.QApplication.allWidgets():
if widget.objectName() == widget_id:
widget_instance = widget
break
else:
self.log_debug("Toolkit widget does not exist - creating it...")
# parent the UI to the main maya window
parent = self._get_dialog_parent()
widget_instance = widget_class(*args, **kwargs)
widget_instance.setParent(parent)
# set its name - this means that it can also be found via the maya API
widget_instance.setObjectName(widget_id)
self.log_debug("Created %s (Object Name '%s')" % (widget_instance, widget_id))
# apply external stylesheet
self._apply_external_styleshet(bundle, widget_instance)
# now reparent the widget instance to the layout
# we can now refer to the QT widget via the widget name
self.log_debug("Parenting widget %s to temporary window %s..." % (widget_id, maya_layout))
pm.control(widget_id, edit=True, parent=maya_layout)
# now attach our widget in all four corners to the maya layout so that it fills
# the entire panel space
pm.formLayout(maya_layout,
edit=True,
attachForm=[(widget_id, 'top', 1),
(widget_id, 'left', 1),
(widget_id, 'bottom', 1),
(widget_id, 'right', 1)] )
if pm.control(panel_id, query=1, exists=1):
# exists already - delete it
self.log_debug("Panel exists. Deleting it.")
pm.deleteUI(panel_id)
# lastly, move the maya window into a dock
pm.dockControl(panel_id, area="right", content=window, label=title)
self.log_debug("Created panel %s" % panel_id)
# Once Maya will have completed its UI update and be idle,
# raise (with "r=True") the docked panel window to the top dock tab.
maya.utils.executeDeferred("cmds.dockControl('%s', edit=True, r=True)" % panel_id)
# just like nuke, maya doesn't give us any hints when a panel is being closed.
# QT widgets contained within this panel are just unparented and the floating
# around, taking up memory.
#
# the visibleChangeCommand callback offered by the dockControl command
# doesn't seem to work
#
# instead, install a QT event watcher to track when the parent
# is closed and make sure that the tk widget payload is closed and
# deallocated at the same time.
#
# Also, there are some obscure issues relating to UI refresh. These are also
# resolved by looking at the stream of event and force triggering refreshes at the
# right locations
#
tk_maya.install_callbacks(panel_id, widget_id)
return widget_instance