def loadPage(url):
page = QtWebKit.QWebPage()
loop = QtCore.QEventLoop() # Create event loop
page.mainFrame().loadFinished.connect(loop.quit) # Connect loadFinished to loop quit
page.mainFrame().load(url)
loop.exec_() # Run event loop, it will end on loadFinished
return page.mainFrame().toHtml()
def __init__(self, parent=None, *args, **kwargs):
super(OverlayDialogBase, self).__init__(parent, *args, **kwargs)
self.parent = parent
self.setColor(QtGui.QColor(255, 255, 255, 200))
self.ret = None
self.layout = None
self.button = None
self.messageLabel = None
self.content = None
self.outerLayout = None
self.contentLayout = None
self.returnValueSet = False
self.eventLoop = QtCore.QEventLoop()
self.closeHint = QtGui.QLabel(self)
self.closeHint.setText("Close/Abort with [esc]")
self.closeHint.adjustSize()
self.setGeometry(self.parent.geometry())
# self.setGeometry(QtCore.QRect(0,0,100,100))
self.parentEventHandler = OverlayDialogBase.ParentEventHandler(self)
self.parent.installEventFilter(self.parentEventHandler)
#
# self.setupContent()
# self.setupLayout()
self.show()
self.setFocus()
def __init__(self, application, dialog):
"""Initialize an IntegratedEventLoop object.
Args:
application : (QtGui.QApplication)
The PySide application.
dialog : (QtGui.QWidget)
The widget to display.
Raises:
N/A
Returns
N/A
"""
# The PySide application.
self._application = application
# The dialog to display.
self._dialog = dialog
# Stash a new version of the PySide event loop.
self._eventLoop = QtCore.QEventLoop()
def __init__(self, application, dialogs):
# We need the application to send posted events. We hold a reference
# to any dialogs to ensure that they don't get garbage collected
# (and thus close in the process). The reference count for this object
# will go to zero when it removes itself from Houdini's event loop.
self.application = application
self.dialogs = dialogs
self.event_loop = QtCore.QEventLoop()
def __init__(self, application, dialog):
# The PySide application.
self._application = application
# The dialog to display.
self._dialog = dialog
# Stash a new version of the PySide event loop.
self._eventLoop = QtCore.QEventLoop()
def waittasks(tasks, timeout=0, abortSignal=None, autoQuit=False):
"""
@param tasks [Task]
@param* timeout int
@param* abortSignal Signal or None signal with auto type
@param* autoQuit bool if quit eventloop when qApp.aboutToQuit
"""
if not tasks:
return
loop = QtCore.QEventLoop()
connectCount = 0
for task in tasks:
if not task.completed:
task.finished.connect(loop.quit, Qt.QueuedConnection)
connectCount += 1
if not connectCount:
return
aborted = False
def abort():
aborted = True
loop.quit()
if abortSignal:
abortSignal.connect(abort)
# Make sure the eventloop quit before closing
if autoQuit:
qApp = QtCore.QCoreApplication.instance()
qApp.aboutToQuit.connect(abort)
timer = None
if timeout:
timer = QtCore.QTimer()
timer.setInterval(timeout)
timer.setSingleShot(True)
timer.timeout.connect(abort)
finishCount = 0
completeCount = 0
while not aborted and finishCount < connectCount and completeCount < len(
tasks):
loop.exec_()
finishCount += 1
completeCount = 0
for it in tasks:
if it.completed:
completeCount += 1
if timer:
timer.timeout.disconnect(abort)
if abortSignal:
abortSignal.disconnect(abort)
if autoQuit:
qApp.aboutToQuit.disconnect(abort)
def waitForReadyRead(self, msecs=30000):
wait = QtCore.QEventLoop()
self.readyRead.connect(wait.quit)
if msecs > 0:
timer = QtCore.QTimer()
timer.setSingleShot(True)
timer.setInterval(msecs)
self.readyRead.connect(timer.stop)
timer.timeout.connect(wait.quit)
wait.exec_()
return len(self.__queue) > 0
def accept(self):
"""Compute the RAOs and plot them"""
if not self.lc:
return False
if self.running:
return
self.form.group_pbar.show()
min_period = Units.parseQuantity(self.form.min_period.text())
max_period = Units.parseQuantity(self.form.max_period.text())
n_period = self.form.n_period.value()
periods = [min_period + (max_period - min_period) * i / (n_period - 1) \
for i in range(n_period)]
omegas = [2.0 * np.pi / T.getValueAs('s').Value for T in periods]
# Generate the simulations
sims = Tools.simulation(self.lc, self.ship, self.weights, self.tanks,
self.mesh, omegas)
# Start solving the problems
self.loop = QtCore.QEventLoop()
self.timer = QtCore.QTimer()
self.timer.setSingleShot(True)
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"),
self.loop, QtCore.SLOT("quit()"))
self.running = True
n = len(periods) * len(Tools.DIRS)
self.form.pbar.setMinimum(0)
self.form.pbar.setMaximum(n)
self.form.pbar.setValue(0)
msg = QtGui.QApplication.translate("ship_console", "Computing RAOs",
None)
App.Console.PrintMessage(msg + '...\n')
points = []
plts = {}
for dof in Tools.DOFS:
plts[dof] = PlotAux.Plot(dof, periods)
for i, data in enumerate(Tools.solve_sim(sims, omegas)):
App.Console.PrintMessage("\t{} / {}\n".format(i + 1, n))
self.form.pbar.setValue(i + 1)
ii, jj, dataset = data
for dof in Tools.DOFS:
rao_complex = dataset.sel(radiating_dof=dof).data[0]
plts[dof].rao[ii, jj + 1] = abs(rao_complex)
plts[dof].phase[ii, jj + 1] = cmath.phase(rao_complex)
plts[dof].update()
self.timer.start(0.0)
self.loop.exec_()
if (not self.running):
break
return True
def accept(self):
if not self.tank:
return False
self.form.group_pbar.show()
n = self.form.points.value()
self.form.pbar.setMinimum(0)
self.form.pbar.setMaximum(n - 1)
self.form.pbar.setValue(0)
# Start iterating
self.loop = QtCore.QEventLoop()
self.timer = QtCore.QTimer()
self.timer.setSingleShot(True)
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"),
self.loop, QtCore.SLOT("quit()"))
self.running = True
# Get the hydrostatics
msg = QtGui.QApplication.translate("ship_console",
"Computing capacity curve", None)
App.Console.PrintMessage(msg + '...\n')
l = [0.0]
z = [Units.parseQuantity("0 m")]
v = [Units.parseQuantity("0 m^3")]
plt = None
for i in range(1, n):
App.Console.PrintMessage("\t{} / {}\n".format(i, n - 1))
self.form.pbar.setValue(i)
level = i / (n - 1)
h, vol = Tools.compute_capacity(self.tank, level)
l.append(100 * level)
z.append(h)
v.append(vol)
if plt is None:
plt = PlotAux.Plot(l, z, v)
else:
plt.update(l, z, v)
self.timer.start(0.0)
self.loop.exec_()
if (not self.running):
break
return True
def accept(self):
if self.lc is None:
return False
self.form.group_pbar.show()
self.save()
roll = Units.parseQuantity(self.form.angle.text())
n_points = self.form.n_points.value()
var_trim = self.form.var_trim.isChecked()
self.form.pbar.setMinimum(0)
self.form.pbar.setMaximum(n_points)
self.form.pbar.setValue(0)
# Compute some constants
COG, W = Tools.weights_cog(self.weights)
TW = Units.parseQuantity("0 kg")
VOLS = []
for t in self.tanks:
# t[0] = tank object
# t[1] = load density
# t[2] = filling level
vol = t[0].Proxy.getVolume(t[0], t[2])
VOLS.append(vol)
TW += vol * t[1]
TW = TW * Tools.G
# Start traversing the queried angles
self.loop = QtCore.QEventLoop()
self.timer = QtCore.QTimer()
self.timer.setSingleShot(True)
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"),
self.loop, QtCore.SLOT("quit()"))
self.running = True
rolls = []
gzs = []
drafts = []
trims = []
plt = None
for i in range(n_points):
App.Console.PrintMessage("{0} / {1}\n".format(i + 1, n_points))
self.form.pbar.setValue(i + 1)
rolls.append(roll * i / float(n_points - 1))
point = Tools.solve_point(W, COG, TW, VOLS, self.ship, self.tanks,
rolls[-1], var_trim)
if point is None:
gzs.append(Units.Quantity(0, Units.Length))
drafts.append(Units.Quantity(0, Units.Length))
trims.append(Units.Quantity(0, Units.Angle))
else:
gzs.append(point[0])
drafts.append(point[1])
trims.append(point[2])
if plt is None:
plt = PlotAux.Plot(rolls, gzs, drafts, trims)
else:
plt.update(rolls, gzs, drafts, trims)
self.timer.start(0.0)
self.loop.exec_()
if (not self.running):
break
return True
def accept(self):
if not self.ship:
return False
if self.running:
return
self.form.group_pbar.show()
self.save()
trim = Units.parseQuantity(Locale.fromString(self.form.trim.text()))
min_draft = Units.parseQuantity(
Locale.fromString(self.form.min_draft.text()))
max_draft = Units.parseQuantity(
Locale.fromString(self.form.max_draft.text()))
n_draft = self.form.n_draft.value()
self.form.pbar.setMinimum(0)
self.form.pbar.setMaximum(n_draft)
self.form.pbar.setValue(0)
draft = min_draft
drafts = [draft]
dDraft = (max_draft - min_draft) / (n_draft - 1)
for i in range(1, n_draft):
draft = draft + dDraft
drafts.append(draft)
# Get external faces
self.loop = QtCore.QEventLoop()
self.timer = QtCore.QTimer()
self.timer.setSingleShot(True)
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"),
self.loop, QtCore.SLOT("quit()"))
self.running = True
faces = self.externalFaces(self.ship.Shape)
if not self.running:
return False
if len(faces) == 0:
msg = QtGui.QApplication.translate(
"ship_console",
"Failure detecting external faces from the ship object", None)
App.Console.PrintError(msg + '\n')
return False
faces = Part.makeShell(faces)
# Get the hydrostatics
msg = QtGui.QApplication.translate("ship_console",
"Computing hydrostatics", None)
App.Console.PrintMessage(msg + '...\n')
points = []
plt = None
for i in range(len(drafts)):
App.Console.PrintMessage("\t{} / {}\n".format(i + 1, len(drafts)))
self.form.pbar.setValue(i + 1)
draft = drafts[i]
point = Tools.Point(self.ship, faces, draft, trim)
points.append(point)
if plt is None:
plt = PlotAux.Plot(self.ship, points)
else:
plt.update(self.ship, points)
self.timer.start(0.0)
self.loop.exec_()
if (not self.running):
break
return True
# A floating toolbar for commonly used SOPs
import hou
from PySide import QtCore as qtc
from PySide import QtGui as qtg
from functools import partial
#-------------------------------------------------------------------
try:
app = qtg.QApplication(['houdini'])
except:
app = qtg.QApplication.instance()
eventLoop = qtc.QEventLoop()
def qt_callback():
if not ctl.isVisible():
try:
hou.ui.removeEventLoopCallback(qt_callback)
except:
pass
eventLoop.processEvents()
app.sendPostedEvents(None, 0)
#-------------------------------------------------------------------
ctl = None
def accept(self):
if not self.ship:
return False
if self.running:
return
self.save()
mw = self.getMainWindow()
form = mw.findChild(QtGui.QWidget, "TaskPanel")
form.trim = self.widget(QtGui.QLineEdit, "Trim")
form.minDraft = self.widget(QtGui.QLineEdit, "MinDraft")
form.maxDraft = self.widget(QtGui.QLineEdit, "MaxDraft")
form.nDraft = self.widget(QtGui.QSpinBox, "NDraft")
trim = Units.Quantity(Locale.fromString(
form.trim.text())).getValueAs('deg').Value
min_draft = Units.Quantity(Locale.fromString(
form.minDraft.text())).getValueAs('m').Value
max_draft = Units.Quantity(Locale.fromString(
form.maxDraft.text())).getValueAs('m').Value
n_draft = form.nDraft.value()
draft = min_draft
drafts = [draft]
dDraft = (max_draft - min_draft) / (n_draft - 1)
for i in range(1, n_draft):
draft = draft + dDraft
drafts.append(draft)
# Compute data
# Get external faces
self.loop = QtCore.QEventLoop()
self.timer = QtCore.QTimer()
self.timer.setSingleShot(True)
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"),
self.loop, QtCore.SLOT("quit()"))
self.running = True
faces = self.externalFaces(self.ship.Shape)
if not self.running:
return False
if len(faces) == 0:
msg = QtGui.QApplication.translate(
"ship_console",
"Failure detecting external faces from the ship object", None,
QtGui.QApplication.UnicodeUTF8)
App.Console.PrintError(msg + '\n')
return False
faces = Part.makeShell(faces)
# Get the hydrostatics
msg = QtGui.QApplication.translate("ship_console",
"Computing hydrostatics", None,
QtGui.QApplication.UnicodeUTF8)
App.Console.PrintMessage(msg + '...\n')
points = []
for i in range(len(drafts)):
App.Console.PrintMessage("\t{} / {}\n".format(i + 1, len(drafts)))
draft = drafts[i]
point = Tools.Point(self.ship, faces, draft, trim)
points.append(point)
self.timer.start(0.0)
self.loop.exec_()
if (not self.running):
break
PlotAux.Plot(self.ship, trim, points)
return True
def show(self):
self._ui.show()
q = QtCore.QEventLoop()
q.exec_()
def __init__(self, textEdit, initialPrompt, locals = None):
"""Constructor.
The optional 'locals' argument specifies the dictionary in
which code will be executed; it defaults to a newly created
dictionary with key "__name__" set to "__console__" and key
"__doc__" set to None.
"""
QtCore.QObject.__init__(self)
self.interpreter = Interpreter(textEdit, locals)
self.interpreter.locals['help'] = _Helper(self, self)
self.completer = _Completer(self.interpreter.locals)
# last line + last incomplete lines
self.lines = []
# flag: the interpreter needs more input to run the last lines.
self.more = 0
# history
self.history = []
self.historyPointer = None
self.historyInput = ''
# flag: readline() is being used for e.g. raw_input and input().
# We use a nested QEventloop here because we want to emulate
# modeless UI even though the readline protocol requires blocking calls.
self.readlineEventLoop = QtCore.QEventLoop(textEdit)
# interpreter prompt.
try:
sys.ps1
except AttributeError:
sys.ps1 = ">>> "
try:
sys.ps2
except AttributeError:
sys.ps2 = "... "
self.textEdit = textEdit
self.connect(self.textEdit, QtCore.SIGNAL('destroyed()'),
self._TextEditDestroyedSlot)
self.connect(self.textEdit, QtCore.SIGNAL("returnPressed()"),
self._ReturnPressedSlot)
self.connect(self.textEdit, QtCore.SIGNAL("requestComplete()"),
self._CompleteSlot)
self.connect(self.textEdit, QtCore.SIGNAL("requestNext()"),
self._NextSlot)
self.connect(self.textEdit, QtCore.SIGNAL("requestPrev()"),
self._PrevSlot)
appInstance = QtGui.QApplication.instance()
self.connect(appInstance,
QtCore.SIGNAL("appControllerQuit()"),
self._QuitSlot)
self.textEdit.setTabChangesFocus(False)
self.textEdit.setWordWrapMode(QtGui.QTextOption.WrapAnywhere)
self.textEdit.setWindowTitle('Interpreter')
self.textEdit.promptLength = len(sys.ps1)
# Do initial auto-import.
self._DoAutoImports()
# interpreter banner
self.write('Python %s on %s.\n' % (sys.version, sys.platform))
# Run $PYTHONSTARTUP startup script.
startupFile = os.getenv('PYTHONSTARTUP')
if startupFile:
path = os.path.realpath(os.path.expanduser(startupFile))
if os.path.isfile(path):
self.ExecStartupFile(path)
self.write(initialPrompt)
self.write(sys.ps1)
self.SetInputStart()
def prepareVideoSeries(sourceFolder, destinationFolder):
progress = QtGui.QProgressDialog("Scanning files...", "Abort Copy", 0, 100,
QtGui.QApplication.activeWindow())
progress.setWindowModality(QtCore.Qt.WindowModal)
progress.setValue(0)
progress.forceShow()
projects = []
project_cfg_path = os.path.join(destinationFolder, 'projects.yaml')
folderWalk = list(os.walk(sourceFolder))
progress.setRange(0, sum([len(f) for r, d, f in folderWalk]))
work_thread = QtCore.QThread()
cnt = 0
for root, dirs, filenames in folderWalk:
if progress.wasCanceled():
break
rel_folder = getRelativeFolder(sourceFolder, root)
for filename in filenames:
if progress.wasCanceled():
break
if filename.endswith(('.avi', '.mp4', '.mpeg')):
progress.setLabelText(
"Copying files...\n Processing {}\n({} / {})".format(
filename, cnt,
sum([len(f) for r, d, f in folderWalk])))
progress.setValue(cnt)
if len(filenames) > 1:
bn = os.path.basename(filename).split('.')[0]
tmp_dest = os.path.join(destinationFolder, rel_folder, bn)
projects += [os.path.join(rel_folder, bn)]
else:
tmp_dest = os.path.join(destinationFolder, rel_folder)
projects += [rel_folder]
tmp_project_cfg_path = ''.join(
['../' for x in range(rel_folder.count('/') + 1)])
tmp_project_cfg_path += 'projects.yaml'
if not os.path.exists(tmp_dest):
os.makedirs(tmp_dest)
work_thread = QtCore.QThread()
worker = Worker(root, filename, tmp_dest, tmp_project_cfg_path)
worker.moveToThread(work_thread)
work_thread.started.connect(worker.start_processing)
progress.canceled.connect(work_thread.quit)
eventloop = QtCore.QEventLoop()
worker.done_signal.connect(eventloop.exit)
work_thread.start()
eventloop.exec_()
# shutil.copy(os.path.join(root, filename), tmp_dest)
# PFFVP.prepareFolder(tmp_dest, projectCFGPath=tmp_project_cfg_path)
cnt += 1
progress.setValue(cnt)
work_thread.quit()
work_thread.wait()
if not progress.wasCanceled():
yamlString = yaml.dump(sorted(projects), default_flow_style=False)
with open(project_cfg_path, 'w') as f:
f.writelines(yamlString)
def __init__(self):
super(self.__class__, self).__init__()
self.eventLoop = QtCore.QEventLoop(self)
