Top
FAQ
Some questions that might be frequently asked....
-
General
-
Why make this at all? Why not pyQt or similar?
Why? stylistic consitancey for starters --often it is known if an
interface will be exclusive to Houdini, and it allows pro consistancy
that is less diruptive by providing familiar interfaces. Less room for
problems by avoiding Python clashes with ui libs or dependants.
This project started in much more limited scope and unpolished for my
own use.It quickly became realized how advantageous having native ui
scripting in python would (plus being a Houdini user over a decade did
not like not having this feature which was provided by other DCC
packages.
-
What can it be used for now?
In short -- alot.
- While not yet providing access to every element,
most common ones are working including most of what you find in the
“edit parm interface” for nodes, ParmTemaples, and quite a bit more --
including MANY style variations (more than can be cleanly listed here
please consult the manual), detailed controls for formatting, and
additional container layouts i(ncluding, row, column, collapser,
scroller, icon[layer] and celll). There are also many additional gadget
variation for more complex design that are not accessible (or
appropriate) when dealing with a node parm ui, including… icon buttons,
icon and icon/text dropdowns, password fields, “?”(help), and much more.
-
What might I be missing compared to parm editing?
Tab folders, switchers, and multiparms are considerably complex and are
expected to be one of the upcoming 1.x releases. Although, used
frequently to organize large amount of node parms, there are many more
options for organizing a dialog/window.
-
What about gadget/widget/parm X?
There are many gadget available and a lot are intended to be added as
time goes on. Priority was implementing ones similar to the ‘edit Parm
Interface … ‘ to provide those which users are most accustomed to
having. The more common the use, the sooner it will likely be added,
super obscure gadgets while novel are low priority.
-
Gadgets uiscript objects
-
-
What are they?
In
general, they are the "look/feel" combo that determines how an element
of a dialog might be have. While the value entered after dialog
contruction might be ie an interger, it can be interacted with as
fields or a slider or the choice returned from a dropdown menu.
-
Containers and Layouts uiscript objects
-
-
Are containers gadgets?
Yes!
… but a special kind of gadget that can hold and organize other gadgets
(including other containers). To This end, containers have methods to
make this organization, finding, retrieving, simpler, along with
additional formatting options. Since container are Gadgets, all the
option you find on gadget will be available on Containers.
-
What Layouts are provided?
Layout
is primarily provided by Containers. Currently Row, Column, Collapser
(although somewhat uncommon in the main gui) are provided. Cell Layout
is in testing. Tabs will be available shortly as well.
-
What kind of formating options are there, how does it work?
There
a A LOT of options for formatting provided. Members of containers
inherit formatting but can override going inward. Most should be
adequate at default. When formatting adjustments are needed it is best
to keep it on containers, as to apply to all the gadgets held. Direct
formatting assignment to non-Container gadget is available, but should
be use sparingly in extreme circumstance, or a UI can quickly become
unwieldy with a constant need to ‘balance out’ a large number of gadget
to a finite level.
-
Windows/Dialogs uiscript objects
-
-
Are the dialogs dockable or placable in panes?
Dialogs
are not currently able to dock or live inside panes. We would love to
see this possible in a future version and are actively investigating.
-
Is Houdini or the Dialog object being altered in a non standard way?
No.Currently
instance methods are used. This results in instances being extended
with extra functionality that will only be useful for dialogs created
with uiSpy. There will be other options in upcoming releases, but to
avoid confussion and methods that will appear but nto work on vanilla
dialogs, it wil likely remain the default. see note on added dialog methods
-
Gadget and Gadget Tuples (for manipulating dialog after construction)
-
-
I am confused what is the differance between a gadget and gadget uiscript object?
Gadget
uiscript objects are pieces of a script that build a ui we interact
with. Gadgets (and gadgetTuples) are used to disable, enable, get, set
etc.. after dialog is constructed. This relationship is similar to
Houdini's parmTemplate and parm -- one construct the object and the
other is fo scripting interaction.
-
Are these parms?
No,
these are gadgets. Parms are typically providing a parameter to a
cook method. Dialogs are not nodes and while they can trigger
procedural event, do not contain a cook process. However, they are
visually similar, and a lot of effort has been made to make the
scripting interface familiar and similar in naming conventions to areas
of HOM that deals with Parms and ParmTemplates.
-
Can gadgets be hidden?
No.
not currently. This is a fairly recent feature in Houdini and it is not
yet obvious if this will be possible on dialogs, although the nature of
scripted dialogs allows some dynamic rebuilding.
-
Can the gadget be evaluated?
Not currently, but the raw string can be retrieved and evaluated with python.
-
Callbacks
-
-
Where can I add callbacks?
Pretty
much anywhere during design on uiscript gadgets (although some of them
may have undesirable or unpredictable results. ie adding a
callback to a row may not be a good idea as it is vague as to what is
being monitored for triggering.
-
Can I uses hscript callbacks?
No, currently only python can be used. However hscript can be used indirectly by calling it from python see hou.hscript()
-
Why are 2 callback mechanisms provided?
Callbacks can be set on uiscript gadgets and on specific instances
via gadgets/gadgetTuples. Callback on uiscript gadget is what is
ussually wanted and these appear on all instances of the dialog.
Instance callbacks should be used sparingly only in special cases by
advanced users, these are intended when information needed to complete
the script will not be availible untill after dialog creation. It is
hoped in the future this technique will be superceded, but currently
provides alot of flexability when it is neeeded.
-
Instance callback are intended for advanced user -- what else do i need to know?
You
can add instance callbacks on any Gadget or Gadget Tuple, but extra
care should be made when mixing the two as one component could have
multiple callbacks and it is STRONGLY RECOMMENDED to assign callbacks
only on Tuples, however there is no technical limitation where this is
imposed as in rare case it may be necessary.
-
What is the difference between callbacks and ‘sends’ mechanisms?
Although
there is some overlapping functionality, callback is ussually
what is needed. 'send' techniques push data to another gadget only
within the same dialog and is made availible primarily used for toggle
gadgets that may set a common value or need to alter the ui. Presumably
when tabs are introduced the latter use will be antiquated.
-
Misc.
-
-
Can I alter the main Interface window?
This is not currently possible.Only Dialogs/Windows can be created.
-
Are there known problems? What's not going to work?
DnD to the py shell
- expression evaluation via gadget (expressions can ber retrieved raw and processed)
- Tabs/switchers are not currently working and should not be imported
- Cell layout is available only via basic
container which performs no additional checks. All items must have cell
attribs set or cell layout will fail. This will be corrected in an
upcoming version.
- Gadget equality comparisons currently fail consistently, and probably are unusable
- rollover help is not currently working
- Included methods on Dialog will not work as expected and return the vanilla dialog without uispy_* mewthods. see note on added dialog methods
- index
.