Grouping Execution Results Under Single Undo Item

[uiron]

is there a way to control which parts of script are grouped under single undo item?

i've created a gui for some tools i use for rigging, and whatever happens after i press a button doesn't get groupped into single undo.

here's an example of a button command function:

CODE
def executeAddBlend(self,args):
        setup = self.createSetupObject()
        setup.createBlend(cmds.textField(self.newBlendName,q=True,text=True),\
                          cmds.optionMenu(self.measureList,q=True,value=True))
        return

command "setup.createBlend" is very complicated and creates quite a few objects and connections. if i evaluate the code as shelf button or just simply from script editor, it undo's as single undo item. but if I do that from gui, my undo gets trashed with lots of unnamed items, and if something goes wrong and i want to undo it all, i got to mash ctrl+z quite a lot.

is there a way to tell maya that everything that's gonna happen in executeAddBlend() must be groupped together?

[joojaa]

In this case your actually seeinga bug of somekind. because maya automatically groups one bleck to one item. How does your gui execute it? That might explain the behaviour.

But basically theres no such mechanism if its on block it SHOULD undo as one thing. Offcourse what the gui calls is all saprate so if the gui calls many commands then you get many undo items if it calls one finction it should be one thing.

[uiron]

QUOTE(Joojaa @ 02/26/09, 09:15 AM) [snapback]301768[/snapback]
In this case your actually seeinga bug of somekind. because maya automatically groups one bleck to one item. How does your gui execute it? That might explain the behaviour.

well, there's nothing too fancy, i create a button when gui is constructed...

CODE
        cmds.button(label="Create Blend",command=self.executeAddBlend)

..and the command itself looks like this.

CODE
    def executeAddBlend(self,args):
        setup = self.createSetupObject()
        setup.createBlend(....)
        return

if i construct setup object and execute createBlend() from a script editor window (or create a shelf button), this all undo's in a single call:

CODE
# createSetupObject() from the above snippets does just like this,
#just reads parameters from gui
setup = bs.Setup()
setup.blendNode = "torsoMuscles_blends"
setup.neutralShape = "torso_muscles_neutral"
setup.skinnedShape = "torso_muscles"
setup.poseRoot = "|nal_skeleton_match|root"

setup.createBlend("L_upperArmDown","L_upperArm_measureYSolver")

so there should be nothing wrong with the executeAddBlend() itself, i guess.

[joojaa]

Ok,

i tghink ist caused by the fact that maya sees it all as one block and teh bloack has never any closure.

Try muving the executor to separate class/commandlist then yoru gui building.

Maya didn't get any smarter just ebcause of python all the same idicies of mel programming penetrate trough you know. Si just because you could possibly do things smarter in python maya doenst really leverage on that

[uiron]

QUOTE(Joojaa @ 02/26/09, 11:54 AM) [snapback]301778[/snapback]
Ok,

i tghink ist caused by the fact that maya sees it all as one block and teh bloack has never any closure.

Try muving the executor to separate class/commandlist then yoru gui building.
Maya didn't get any smarter just ebcause of python all the same idicies of mel programming penetrate trough you know. Si just because you could possibly do things smarter in python maya doenst really leverage on that

i fear that unless i separate that from the gui at executePythonCommand("") level, the problem will still persist. this means completely separate import list, variable context, etc etc. at the moment whole execution is done at completely different class, different file, different package - i keep logic and gui separate. still, maya might see that as a single python chunk (gui gets constructed, imports other objects, etc.).

i'll try to hack my code to wrap button commands into MGlobal.executePythonCommand() and see how it goes, tho this might need a few ugly tricks to achieve.

[joojaa]

The problem is mor eor less this:

if the command does not have a clear start end closure as maya sees it but exits back to your code then thet means maya will see your code as a server. Its perfectly posible to do this. For xample if you sue a external gui toolkit. But if the pipes point in to maya maya should be able to pick up the slack.

So what maya kindof waits for in my experience is closure of the block if theres some timeout in that it dies. So if you kill the object after call it should work ok.

But see maya doesent really necceserily respond well to classes, since they may persist after execution so they aren't closed. Ergo maya sees them as servers of some kind.

So maya has to executa and end the code. Maya still treats you as if your doing mel. The fact that your writing python is all the same to maya. This si why i dontreally see any point in using python for a substitution of mel, So i only ever use the c++ api to python interface for anythibng. If its cmds i might aswell write it in mel, then atleast i wont get tempted to try to out comnpute with inferior calls.

QUOTE
executePythonCommand("")

No thats not the problem, it works just as longh as you can demostrate to maya what all belongs togeter. in other words make them more function like. You can easily test the feasability fo this.

PS: while python as a language is nice and easy, cosy and exeptionally fine. It does not extend to whatever api one calls. Even if the python part is elegant ist still not free from the unelegance of each modules interpretation. So just because one knows pyton does not eman one knows ALL python programming so the investment to learn how to do python for maya and learn mel is equal. And mayas not the worst of worst.

[joojaa]

Tested this atleats they work fine if they are global functions just like in mel.

[uiron]

QUOTE(Joojaa @ 02/26/09, 01:22 PM) [snapback]301783[/snapback]
Tested this atleats they work fine if they are global functions just like in mel.

didn't work for me. i've moved everything to parameterless global function and call that from a button - still, it's execution results aren't groupped in the undo.

MGlobal.executePythonCommand() with undo enabled worked fine, this however requires that whatever i want to execute must be build as a string first.

[joojaa]

try super, your files namespace might be the one that clashes. altough global should do it.

[uiron]

QUOTE(Joojaa @ 02/26/09, 03:58 PM) [snapback]301789[/snapback]
try super, your files namespace might be the one that clashes. altough global should do it.

not sure what you mean.

anyway, there's a small runnable example to recreate the problem:

CODE
import maya.cmds as cmds
import maya.OpenMaya as om

def globalHandler(*args):
    cmds.sphere()
    cmds.sphere()

class UndoGuiTest:

    def memberHandler(self,*args):
        cmds.sphere()
        cmds.sphere()

    def exePythonHandler(self,*args):
        cmd = "import maya.cmds as cmds\n"
        cmd += "cmds.sphere()\n"
        cmd += "cmds.sphere()\n"
        om.MGlobal.executePythonCommand(cmd,False,True)

    def show(self):
        cmds.window( width=150 )
        cmds.columnLayout( adjustableColumn=True )
        cmds.button( label='Member Handler', command=self.memberHandler)
        cmds.button( label='Global Handler', command=globalHandler)
        cmds.button( label='Exe Python Handler', command=self.exePythonHandler)
        cmds.showWindow()

UndoGuiTest().show()

each of the buttons creates two spheres in the scene. first one has it's handler defined as class member function, second as global function, third one as executePythonCommand().
as you can see, only third button's actions are undoable in one go, for first and second you have to undo twice.

[joojaa]

Ahh... trying to be too smart

CODE
try theese changes:

def globalHandler():
    cmds.sphere()
    cmds.sphere()

...
   cmds.button( label='Global Handler', command="globalHandler()")
...

Now it undoes one in go. Maya still works like mel no matter what you want.

Or actually you dont even need to kill *args.

[uiron]

QUOTE(Joojaa @ 02/26/09, 10:43 PM) [snapback]301816[/snapback]
Ahh... trying to be too smart

cmds.button( label='Global Handler', command="globalHandler()")

Now it undoes one in go.

...ofc it undo's in one go, because you've supplied handler as totally independed code (a string to be evaluated, not a pointer to the function).
now, not everything would be so simple if you had to write a gui where along with a "create spheres" button you've got an option to enter the amount of spheres you want to create. now what? how to parameterize (not sure if that word exists:) the handler? handler has to read the gui?

[joojaa]

Well yes see thing is you will have to program just like in mel. Like ive said maya didnt get smarter jsut because the programming language is smarter. You can find atleast 100 different explanations on how to do this in mel. You must work the same way. Since maya still thinks it is mel and treats you as such.

The interface does not just make mel python IT IS mel, with all the drawbacks and design idiocies of mel. And yes mel programmers have succeed doing this for 10 years so why shouldn't you be able to do it easily in sytem thats m,ore robust. You just need to rethink the strategy a bit.

Maya need sto be in your loop, or maya will just treat you like a server.

QUOTE
handler has to read the gui?

Well this is how i do it in mel, tough you can do several things, more on them later:

i make 3 global functions ():

GUI

a Gui parser function, that gets passed the root of my gui as a name

build function

The gui calls the parser which has insertted tha hardcoded name of the gui when its was created anbd this calls the build function. Usually i add one more inetrface function so that i get a better design pattern.

now you can mimic this esily in python ONLY you dont really need the parser just the split of build function that gets passed the values it needs.

So just because you could do things smart in python DOES not eman may could even begin to leverage it the way you want. So either way, if you want to learn to script in maya you MUST know mel, you can jsut opt to wiorte things in python for the fun of it but mel si what sets the pace and desiggn. For now. So about 50% of everything you know of python DOES NOT APPLY in a maya setting.

Its not liek object passing IS iheritedlyy any fdiffferent form not passing them as object members. It just omits passing same variable block all the time. Unfortunately many object designers pass the object. even when not needed

[uiron]

i really appreciate the time you're spending to bear with me, Joojaa:]

the problem with me vs mel is that when it comes to programming, i just cannot degrade back to procedure&shell-like code structure, not just because i don't want, but also because i just have to change my whole logic of organizing the code - a scar from those years of delfi, c, java, php and the like.

when i started coding for maya (since 8.5, this makes me quite a maya newbie), i had to choose between learning python and learning mel. i went for python as this was like, "hey, if that's officially supported by software developer, why not?". i still don't regret the decision - having API at hand, scripted custom nodes, etc really paid off.

anyway, the solution I hoped to find when starting the topic was if there's a way to TELL maya where undo block starts and ends, rather than trying to trick it into guessing that automatically, something like:

CODE
hypotheticApi.pushUndoStack()
stuff()
otherStuff()
moreStuff()
hypotheticApi.popUndoStack()

but looks like the only way to manage undo is either wrapping everything in commands, or using tricks like evaluating code as string (that's true both for mel and python as far as i can see)

anyway, let's call that as problem solved, i feel like taking too much of your time already:] thanks for discussion.

[joojaa]

QUOTE(uiron @ 02/27/09, 03:41 PM) [snapback]301869[/snapback]
the problem with me vs mel is that when it comes to programming, i just cannot degrade back to procedure&shell-like code structure, not just because i don't want, but also because i just have to change my whole logic of organizing the code - a scar from those years of delfi, c, java, php and the like.

Yes, that is unfortunate yes. You allways get theese things no matter what code you do. Thats why you try to get on with a good design pattern that might attack the problem.

This said you might succeed in passing the maya shell a refenece to your object by declaring it global. Then just execute that. Its a ugly hack but should work.

so in essence

do you stuff...

global passMe
passMe=yourObject
om.MGlobal.executePythonCommand("global passMe;passMe.execute()",False,True)

Might work didnt test.

QUOTE
when i started coding for maya (since 8.5, this makes me quite a maya newbie), i had to choose between learning python and learning mel. i went for python as this was like, "hey, if that's officially supported by software developer, why not?". i still don't regret the decision - having API at hand, scripted custom nodes, etc really paid off.

Well yes i dont doubt that. But had you taken mel + python approach youd probably been even better off. It snot liek i ddnt say learn BOTH.

The problem with pure python approach is that you see a lot of people actually doing lot of code because they now can. Without much tough in what code they should do. Ive actually seen studios with a year worth of code on something ultimataly maya allready had, and it was better implemented in maya. Mel puts your thinking cap into how maya works, and not how coding is done. But for api its actually good, tough i only do stuff there to prototype my code it allways end s up being full c++ at the end of the day. Keeping things that are sepatrate separated keeps me better focused. As a result you sometimes see me doing things others would never even attempt, failure is always better than success. And extraordinary success comes at a price of not being afraid of failure.

Its allways easy to accept the piece of advice thet seems nicer. Than the longer better advice especially if it is sems good to begin with.

[uiron]

QUOTE(Joojaa @ 02/27/09, 04:24 PM) [snapback]301873[/snapback]
global passMe
passMe=yourObject
om.MGlobal.executePythonCommand("global passMe;passMe.execute()",False,True)

jesus that's so simple i want to bang my head into brick wall. here's a modified and even cleaner version of it, not too relying on global variables.

CODE
import maya.cmds as cmds

class UndoGuiTest:
    def __init__(self):
        UndoGuiTest.instance = self

    def hackHandler(self):
        cmds.sphere()
        cmds.sphere()

    def show(self):
        cmds.window( width=150 )
        cmds.columnLayout( adjustableColumn=True )
        cmds.button( label='Hack Handler', command="UndoGuiTest.instance.hackHandler()")
        cmds.showWindow()

UndoGuiTest().show()

nice and clean. wee!

[joojaa]

Yes it became so much easier in my test code too. But somehow the idea was easier expressed in copypaste way beacsue i had no python to test on.