Maya window adding a row dynamically with python

Question

I've been working on this for a while and I can't find any information about adding a row to a window. I seen it done with pyside2 and qt, witch would work but the users are using multiple versions of Maya (2016 = pyside, 2017=pyside2).

I want it like adding a widget in in pyside. I done it where adding a row is a function like add row 1, add row 2, and add row 3 but the script get to long. I need to parent to rowColumnLayout and make that unique in order to delete that later. Also I have to query the textfield in each row. Maybe a for loop that adds a number to the row? I really don't know but this is what I have so far:

from maya import cmds

def row(  ):
    global fed
    global info
    item=cmds.optionMenu(mygroup, q=True, sl=True)
    if item == 1:
        cam=cmds.optionMenu(mygroup, q=True, v=True)
        fed=cmds.rowColumnLayout(nc = 1)
        cmds.rowLayout(nc=7)
        cmds.text(l= cam )
        cmds.text(l=u'Frame Range  ')
        start = cmds.textField('textField3')
        cmds.text(l=u' to ')
        finish = cmds.textField('textField2')
        cmds.button(l=u'render',c='renderTedd()')
        cmds.button(l=u'delete',c='deleteRow()')
        cmds.setParent (fed)
        def deleteRow ():
                cmds.deleteUI(fed, layout=True)
    if item == 2:
        print item
        global red
        cam1=cmds.optionMenu(mygroup, q=True, v=True)
        red = cmds.rowColumnLayout()
        cmds.rowLayout(nc=7)
        cmds.text(l= cam1 )
        cmds.text(l=u'Frame Range  ')
        start = cmds.textField('textField3')
        cmds.text(l=u' to ')
        finish = cmds.textField('textField2')
        cmds.button(l=u'render',c='renderTedd()')
        cmds.button(l=u'delete',c='deleteRow2()')
        cmds.setParent (red)
def deleteRow2 ():
    cmds.deleteUI(red, control=True)
def cameraInfo():
    info=cmds.optionMenu(mygroup, q=True, sl=True)
    print info
def deleteRow ():
    cmds.deleteUI(fed, control=True)
def getCamera():
    layers=pm.ls(type="renderLayer")
    for layer in layers:
        pm.editRenderLayerGlobals(currentRenderLayer=layer)
        cameras=pm.ls(type='camera')
        for cam in cameras:
            if pm.getAttr(str(cam) + ".renderable"):
                relatives=pm.listRelatives(cam, parent=1)
                cam=relatives[0]
                cmds.menuItem(p=mygroup,label=str (cam) )
window = cmds.window()
cmds.rowColumnLayout(nr=10)
mygroup = cmds.optionMenu( label='Colors', changeCommand='cameraInfo()' )
getCamera()
cmds.button(l=u'create camera',aop=1,c='row ()')
cmds.showWindow( window )

Answer 1

This is totally doable with cmds. The trick is just to structure the code so that the buttons in each row know and can operate on the widgets in that row; once that works you can add rows all day long.

To make it work you want to do two things:

1. Don't use the string form of callbacks. It's never a good idea, for reasons detailed here
2. Do use closures to make sure your callbacks are referring to the right widgets. Done right you can do what you want without the overhead of a class.

Basically, this adds up to making a function which generates both the gui items for the row and also generates the callback functions -- the creator function will 'remember' the widgets and the callbacks it creates will have access to the widgets. Here's a minimal example:

def row_test():

    window = cmds.window(title='lotsa rows')
    column = cmds.columnLayout()

    def add_row(cameraname) :
        cmds.setParent(column)
        this_row = cmds.rowLayout(nc=6, cw6 = (72, 72, 72, 72, 48, 48) )
        cmds.text(l= cameraname )
        cmds.text(l=u'Frame Range')
        start = cmds.intField()
        finish = cmds.intField()

        # note: buttons always fire a useless
        # argument; the _ here just ignores
        # that in both of these callback functions
        def do_delete(_):
            cmds.deleteUI(this_row)

        def do_render(_):
            startframe = cmds.intField(start, q=True, v=True)
            endframe = cmds.intField(finish, q=True, v=True)
            print "rendering ", cameraname, "frames", startframe, endframe

        cmds.button(l=u'render',c=do_render)
        cmds.button(l=u'delete',c=do_delete)

    for cam in cmds.ls(type='camera'):
        add_row(cam)


    cmds.showWindow(window)


row_test()

By defining the callback functions inside of add_row(), they have access to the widgets which get stored as start and finish. Even though start and finish will be created over and over each time the function runs, the values they store are captured by the closures and are still available when you click a button. They also inherit the value of cameraname so the rendering script can get that information as well.

At the risk of self-advertising: if you need to do serious GUI work using cmds you should check out mGui -- a python module that makes working with cmds gui less painful for complex projects.