maya
Maya UI maken

parameters

Opmerkingen

Basis UI-voorbeeld [Python]

De Maya GUI-toolkit maakt een verscheidenheid aan UI-elementen in een eenvoudige, gebiedende vorm. Er zijn basisopdrachten om GUI-widgets te maken en te bewerken; de widgets worden geïdentificeerd door een unieke stringnaam.

Alle gui-opdrachten hebben dezelfde basisvorm: u geeft een opdrachttype en de tekenreeksnaam op van het object waaraan u wilt werken of maken, samen met vlaggen die het uiterlijk of gedrag van de widget specificeren. Dus om bijvoorbeeld een knop te maken die u gebruikt:

 cmds.button('my_button', label = 'my label')

Dit maakt een nieuwe gui-knop. Als u de knop wilt bewerken, gebruikt u dezelfde opdracht met de vlag edit (de korte versie is slechts e ). Dus je zou het label van de knop als volgt kunnen veranderen:

cmds.button('my_button', e=True, label = 'a different label')

en u kunt de huidige waarde van een eigenschap query met de query of q vlag:

cmds.button(`my button`, q=True, label=True)
# 'a different label'

Widgetnaamgeving

Wanneer u een nieuwe widget met een UI-opdracht maakt, kunt u de naam opgeven die u de nieuwe widget wilt laten krijgen. Het is echter niet gegarandeerd: Maya zal de knop de naam geven waarom je hebt gevraagd - als je het een personage hebt gegeven dat het niet herkent of als er al een widget met dezelfde naam is, krijg je misschien een andere naam terug. Het is altijd een goede gewoonte om de naam van een nieuwe widget vast te leggen wanneer deze wordt gemaakt om verrassingen te voorkomen:

 my_button = cmds.button('my_button') 
 cmds.button(my_button, e=True, label = "a new label")

Terugbel functies

Veel widgets bevatten gebeurtenissen die callback-functies kunnen activeren wanneer de gebruiker interactie heeft met de widget. Als u bijvoorbeeld op een knop drukt, een selectievakje aanvinkt of een vervolgkeuzelijst kiest, kunt u een functie activeren.

De exacte vlag die aan deze gebeurtenis is gekoppeld, is afhankelijk van de widget, maar een typische callback ziet er als volgt uit:

 def callback_fn(_ignore):
     print "button pressed"

 button = cmds.button(label='press me', command = callback_fn)

Als u op de knop drukt, wordt "knop ingedrukt" afgedrukt naar het luistervenster. De meeste widget activeren enkele argumenten wanneer hun callbacks worden geactiveerd - de button bevat bijvoorbeeld altijd een Booleaanse waarde - dus u moet ervoor zorgen dat de callback-handler de juiste handtekening heeft voor de widget die u gebruikt. Daarom neemt callback_fn() een argument aan, ook al heeft het dit niet nodig.

Terugbelopdracht

Maya ondersteunt twee verschillende manieren om callback-functies toe te voegen:

   # this works, but is not a great idea
   cmds.button(label = 'string reference', command = 'string_name_of_function')
   # use this form whenever possible
   cmds.button(label = 'direct function reference', command = callback_fn)

In het eerste voorbeeld wordt de callback toegewezen door een tekenreekswaarde. Maya vindt de callback in de wereldwijde Python-scope - die meestal moeilijk toegankelijk is wanneer ze goed georganiseerde code schrijft. Callback-namen met tekenreeksen zijn ook trager op te lossen. Het tweede voorbeeld geeft de daadwerkelijke Python-functie door aan de callback - dit formulier heeft de voorkeur omdat het sneller is en als u geen geldige functie voor de callback-functie hebt geleverd, weet u wanneer de gebruikersinterface is gemaakt in plaats van wanneer de UI-widgets worden daadwerkelijk gebruikt.

Wilt u een argument waarde te geven aan een call back functie kunt u gebruik maken van een lambda , een sluiting of een functools.partial binden argumenten om de callback.

partial :

 from functools import partial
 ....
 def callback_fn(myValue, _ignore):  # _ignore swallows the original button argument
     print myValue

 button = cmds.button(label='press me', command = partial(callback_fn, "fooo"))

lambda :

 def callback_fn(myValue):
     print myValue

 button = cmds.button(label='press me', command = lambda _ignore: callback_fn("fooo"))
 # here the lambda needs to handle the button argument

Sluitingen gebruiken

b = cmds.button(label = 'press me')
# by defining this function when `b` exists, we can use it later
# without storing it explicitly
def get_button_label(*_):
    print "label of button", b, " is ", cmds.button(b, q=True, l=True)
cmds.button(b, e=True, c=get_button_label)

Er is meer over touwtje callback namen vs. callback functie hier

Een venster maken

# create a window with a button that closes the window when clicked
window = cmds.window(title='example window')       # create the window
layout = cmds.columnLayout(adjustableColumn=True)  # add a vertical layout

def close_window(*_):
    cmds.deleteUI(window)                          # deletes the window above

button = cmds.button(label= 'press to close", command = close_window)

# show the window
cmds.showWindow(window)

Lambdas en lussen

Lambda's zijn een handige snelkoppeling voor het koppelen van gedrag aan GUI-elementen.

b = cmds.button("make a cube", command = lambda _: cmds.polyCube())

Vanwege de manier waarop Python variabelen in lambdas vastlegt, kunt u echter onverwachte resultaten krijgen als u opdrachten bindt met lambdas in een lus. Dit ziet er bijvoorbeeld uit alsof het knoppen moet produceren die bollen van verschillende groottes maken:

# warning: doesn't work like it looks!
for n in range(5):
    b = cmds.button("sphere size %i" % n, command = lambda _: cmds.polySphere(radius=n))

De knoppen worden correct gelabeld, maar gebruiken allemaal dezelfde straal (4) omdat de lambdas deze waarde allemaal zullen vastleggen wanneer de lus sluit. TLDR: Als u callbacks binnen een lus functools.partial , gebruikt u functools.partial of een andere methode om waarden vast te leggen - lambdas werkt niet voor deze toepassing. Zie hier voor meer details