Help Me ,about Button`s Command In Class

[liuguanghui]

I have a code

import maya.cmds as cmds

class testC():
def printM(self,*args):
print "no args"

def printV(self,value):
    print value

def mainCom(self):
    word = "have args"
    cmds.window()
    cmds.columnLayout()
    cmds.button( l="No args",c=self.printM )
    cmds.button( l="have args",c=self.printV( word ) )
    cmds.showWindow()

tt = testC()
tt.mainCom()

Maya notice me: Invalid arguments for flag "c" Expected string or funciton got NoneType

thanks for tell me WHY

[uiron]

for second button, you're assigning None to c - because you're giving a RESULT of function self.printV(word). instead, you want a pointer to a function.

two possible solutions.

better one is just make a wrapper around printV and use it as button handler instead:

CODE
def printWord(self,*args):
   self.printV(self,self.word)

quickier, but dirtier is just passing a lambda function to a button:
CODE
cmds.button( l="have args",c=lambda: self.printV( word ) )

[liuguanghui]

for the second button,I just want to transfer a argument to che func,

I tried the lambda, can`t pass through

have any other way to resolve the problem?

[uiron]

depends HOW you want to pass the value. where do you get it? is that a constant value throughout the script? variable value read from gui?

[joojaa]

The problem is that the button exists far after your code has gone. You must pass maya objects that the global level can see. Wether or not they are in namespace makes no difference for maya. JUst as long as the objects are availeble by the time the code button is pressed, and it can be referced by the outermost scope.

[uiron]

not in the case of python, Joojaa. python accepts function pointers as well as strings as button handlers. function pointer can be of whatever scope, and only string version of the handler must contain a global-scope "compatible" code.

[uiron]

here's an example of two way passing a pointer to a function. i would not use lambda version, though.

CODE
import maya.cmds as cmds

class BtnHandlerTest:

    def __init__(self):
        self.valueToPass = 'it works'

    # some method with variable
    def printValue(self,value):
        print value

    # button press handler
    def buttonHandler(self,*args):
        self.printValue(self.valueToPass)

    def show(self):
        cmds.window( width=150 )
        cmds.columnLayout( adjustableColumn=True )
        cmds.button( label='Handler Version', command=self.buttonHandler)
        cmds.button( label='Lambda Version', command=lambda *args:self.printValue(self.valueToPass))
        cmds.showWindow()

s = BtnHandlerTest()
s.show()

[joojaa]

I am aware of this.

QUOTE(uiron @ 03/20/09, 01:13 PM) [snapback]303490[/snapback]
not in the case of python, Joojaa. python accepts function pointers as well as strings as button handlers. function pointer can be of whatever scope

Yes the pointer can be any scope, but the thing is maya doesnt 100% accurately track the pointer references*. So maya may indeed screw up the rebferencing and python would go and auto clean the data away. Thus you can have a pointer thet refeers to nothing at some point in the future.

Granted this works much better in maya 2009 but in 8.5 this was e reoccouring problem on certain fringe areas.

Now due to teh way mel expects things to work ist best to scope things down to main level as in some cases the references dont work out right. No matter what tyou claim yoru running mel with python hooks.

Now since python basically only has global and local variables make sure its one of the refence counted globals anywhere and it will work for sure.

PS: i grant you if you ise just 2009 its will work out well but you cant know what versions others are using.

*also if you rely on references maya may not be able to do proper undo because theres no way to retrieve a object thats allread dead.

PPS: i know pretty well how python works, and whan it just does not, i need to keep a python interpreter alive for a living amongst other things.

[liuguanghui]

thanks every one,UIRON`s answer is right,

cmds.button( label='My Version',command = lambda *args:self.printV(word)) it can be pass though

thanks a lot

[joojaa]

QUOTE(liuguanghui @ 03/20/09, 02:40 PM) [snapback]303498[/snapback]
thanks every one,UIRON`s answer is right,

I am not disputing that, but works and problem free are 2 separate things you know. A old usenet saying goes something like this:

the WRONG answer is the one that works, out of convenience, and seems easy and elegant. But is slightly off and causes more problems much down the line. And the right was the uncofortably long one that required you think, usually teh two are very close to each other with slight semantic difference.

Im just saying you should let maya know what the functions you declare are. Maya expects to know. Its far better practice as now maya also can call them. Yes it hurts your investment in private protection but you know what python doesn't have private functions. They are just grabled in way thet makesit harder to call, they are directly callable nonetheless. Also relying on fuction pointers can cause havoc to ad hoc development form the gui as you think you did something but you didnt, bacuse you now have 2 refernces to something thats allmost the same.

So yes it works except when it does not. Urion knows this as well as i do.

[uiron]

QUOTE(Joojaa @ 03/20/09, 02:16 PM) [snapback]303497[/snapback]
*also if you rely on references maya may not be able to do proper undo because theres no way to retrieve a object thats allread dead.

well, yeah, this is another case when it's better to use the global scope version of handler, as we discussed in that other thread, but that's out of scope what original poster asked.

regarding clean ups... well, don't know, haven't seen that, but maybe that's down to how i build structure of my gui - usually objects that provide handlers for buttons are guaranteed to "live" while gui is open: i usually create a global (in imported module's space), and while main space holds imported module, and module holds it's global - object is guaranteed to live.

for what i actually like pointer version of handler is that it's NOT dependant on global scope, and any code refactoring errors (renaming button handler, etc) are resolved at compile time (no surprises like "no such method" when you're done halfway testing your gui).

[joojaa]

QUOTE(uiron @ 03/20/09, 02:49 PM) [snapback]303500[/snapback]
for what i actually like pointer version of handler is that it's NOT dependant on global scope, and any code refactoring errors (renaming button handler, etc) are resolved at compile time (no surprises like "no such method" when you're done halfway testing your gui).

Sure but even this method has its drawbacks, you loose some you win some. You should implement factories you know that.

IN general my problem is that i see too deep into the development landscape compared to others, because thet just what my brtain is VERY good at.

[joojaa]

Urion by the way if you ever need to use the srtring version and referencing is a problem for your refactoring efforts it IS possible to build the strings out of references so no matter what from your programming point of view its all the same. So you pass references even to the sring builders irrespective of what the code ends up doing.

[uiron]

could you comment then possible threats of writting gui like in the code below. it's best example i could give when function pointers work much better than global handlers. first class is a helper that builds a gui to select a node into gui, and provides handler methods for it's own buttons, second one runs multiple instances of it. how would this code would look like with global handler versions? i imagine, not very pretty.

CODE
import maya.cmds as cmds

# class that builds a node selection row with "select this" and "clear selection" buttons
class NodeSelectRow:

    def __init__(self,title,parent):

        row = cmds.rowLayout(parent=parent,nc=4, adjustableColumn=2,columnWidth4=[100,200,40,20], columnAttach4=["both","both","both","both"],columnAlign4=["left","left","center","center"])
        cmds.text(label=title)
        self.nameField = cmds.nameField(parent=row)
        select = cmds.button(label="<<",command=self.setSelectedNode,align="center",annotation='set selected node')
        select = cmds.button(label="X",command=self.clearNode,align="center",annotation='clear selection')
        self.clearNode()

    def getNode(self):
        return cmds.nameField(self.nameField,q=True,object=True)

    def setNode(self,node):
        cmds.nameField(self.nameField,e=True,object=node,annotation=node)

    def setSelectedNode(self,*args):
        self.setNode(cmds.ls(sl=True)[0])

    def clearNode(self,*args):
        self.setNode('')
        pass

class InstancedGuiTest:

    def printSelectedNodes(self,*args):
        print self.selectNode1.getNode()
        print self.selectNode2.getNode()
        print self.selectNode3.getNode()
        print self.selectOneMoreNode.getNode()

    def show(self):
        cmds.window( width=150 )
        layout = cmds.columnLayout( adjustableColumn=True )

        self.selectNode1 = NodeSelectRow('First Node: ',layout)
        self.selectNode2 = NodeSelectRow('Second Node: ',layout)
        self.selectNode3 = NodeSelectRow('Third Node: ',layout)
        self.selectOneMoreNode = NodeSelectRow('Another Node: ',layout)

        cmds.setParent(layout)
        cmds.button('Print Selected Stuff',command=self.printSelectedNodes)
        cmds.showWindow()

test = InstancedGuiTest()
test.show()

[joojaa]

You must wait till i can get my hands on maya. But the most typical threat is that you do double book keeping one is done in your python and one in maya. And these two might fall out of sync, as the bookkeeping done by maya is what counts it can be a bit problematic. Other threats do exist but this double bookkeeping one is something i try to avoid most, not because its terribly terminal just because it is possibly ugly convention for maya users point of view. Un maya like tough certainly the instancer editor does this. The natural way for maya users is to work on whatever triple selection they have at hand at command execute and allways work form there.

So what can happen is that between selection a maya user might delete the component, rename it or otherwise fumble about. And thi can cause your code to fail unexpextedly so you need to chek for it validity after the fact. Also if you code does something it might be hard to undo, andf return to same run again state at a later time. So going about repating thi step might provide problematic so no redo either. Because you work on the gui for pick mayas internal selection repetitions don't update states.

So while it is tempting to build guis that are very informative and nice the best gui is one you dont write. So while you see lot of people with guis that have buttons more than on my keyboard is relatively rare to see good gui with only the bare bone necessity of buttons, because all else has been eliminated. So the best gui is not the one that looks nicest or has most options but the one that does everything you could possibly want automatically without you doing anything, in other words not a gui at all. Offcourse you rarely see this as theres not many people who can do all thats needed automatically, if it even is remotely possible.

QUOTE
how would this code would look like with global handler versions?

I would simply highlight what selected in the gui and run down form that. And not have a pick object to list if possible.