Looking at the doc in R19:

So I'm afraid there is no simple solution that will work on each version maxon::String being introduced in R20, you will need to adapt your code.

Cheers,
Maxime.

An express tag is a tag, and it evaluation takes place as any other tag, meaning it has the same limitation as a Python Scripting Tag.

@SolarPH said in Python NODES - Shouldn't really they can change the scene?:

I've set all of those outside Execute method to ensure that it wouldn't loop infinitely. I often connect it to an if/else statement (connected to a boolean/integer switch that switches itself off after the first cycle) to ensure that it wouldn't make Cinema4D crash.

I'm not sure to follow you here but since you modify the scene content while the scene execution (aka xpresso execution) then it can affect the stability, and it does not matter if it's executed once or 100 times, so you may run into a conflict with another part of the scene while this other part is accessed by something else, and you have a crash.

make sure to call StopAllThread, but you can even call EventAdd

I actually haven't tested StopAllThread line yet, but I can already use EventAdd() after any commands that changes the scene in terms of heirarchy and inserted objects. I haven't really tested doing a delete command, but I have some ways to let the code know what to delete after the cycle. Utilizng ports as a way to actually pass the correct object data on the code makes it easier for me to execute this kinds of codes on my python tags.

I was speaking if you are in the main thread, which is not the case here because you are in a tag execution, so if you call StopAllThread within your thread, your thread will be canceled (due to the nature of python, your python code may execute completely but not the other part of the xpresso evaluation)

Also, According to the online manual about python codes for cinema4d (official documentation), for example, I do

c4d.documents.MergeDocument(doc,Path,c4d.SCENEFILTER_OBJECTS|c4d.SCENEFILTER_MATERIALS,None)

will make it run on Main C4D Thread (i don't actually know if not putting the None at the end of the code makes it run on another thread, but when I tried, it doesn't actually crash C4D since the line only runs once because of the nature of the switch I used)

Passing None in the MergeDocument will not make it run into the main thread, you just pass the thread you are currently in, and it will be this thread that will be tested if you should leave or not, but it does not modify where the code is executed. So calling MergeDocument is not fine because, in the end, you modify the current document especially if there are some materials. And this could make Cinema 4D Crash since a lot of stuff happens during a merge.

Cheers,
Maxime.

Hi, I can confirm there is no way exposed to 3rd party developers to set manually the 2D/3D track Data.

Cheers,
Maxime.

This does not solve your initial issue since it requires the use of GetItemDim and it was introduced in R18 but here is how to avoid your second issue:

import c4d

class Dialog(c4d.gui.GeDialog):
    
    def CreateLayout(self):
        bc = c4d.BaseContainer()
        bc.SetBool(c4d.BITMAPBUTTON_BUTTON, True)
        bc.SetInt32(c4d.BITMAPBUTTON_ICONID1, c4d.Ocube)
        bc.SetInt32(c4d.BITMAPBUTTON_FORCE_SIZE, 32)
        button = self.AddCustomGui(10003, c4d.CUSTOMGUI_BITMAPBUTTON, "but", c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, 40, 40, bc)
        button.SetCommandDragId(c4d.Ocube)
        self.AddStaticText(10001, 0, 0, name="test")
        return True

    def IsPositionOnGadget(self, gadgetId, x, y):
        # Be sure that the windows is opened,
        # in our case since we call it in BFM_INTERACTSTART it's ok
        buttonData = self.GetItemDim(gadgetId)
        
        if not buttonData["x"] < x < buttonData["x"] + buttonData["w"]:
            return False

        if not buttonData["y"] < y < buttonData["y"] + buttonData["h"]:
            return False

        return True

    def Message(self, msg, result):
        # Main thread
        if msg.GetId() == c4d.BFM_INTERACTSTART:
            c4d.StopAllThreads()

            # Check the mouse is clicked
            state = c4d.BaseContainer()
            self.GetInputState(c4d.BFM_INPUT_MOUSE, c4d.BFM_INPUT_MOUSERIGHT, state)

            if state.GetInt32(c4d.BFM_INPUT_CHANNEL) != 0:

                # Get coordinates
                x = state.GetInt32(c4d.BFM_INPUT_X)
                y = state.GetInt32(c4d.BFM_INPUT_Y)
                g2l  = self.Global2Local() 
                x += g2l['x']  
                y += g2l['y']

                # Checks the coordinate is within the range of the BitmapButton
                if self.IsPositionOnGadget(10003, x, y):
                    print 'Icon clicked in the GeDialog.'

                    # Stop others event to be processed
                    self.KillEvents()
                    return True
                
        return c4d.gui.GeDialog.Message(self, msg, result)

# Main function
def main():
    global dlg
    dlg = Dialog()
    dlg.Open(c4d.DLG_TYPE_ASYNC)

# Execute main()
if __name__=='__main__':
    main()

Note that there is a very similar problem Disable default Right-Click Menu that you may found interesting about how to handle popup in your dialog.

And adding this constraint in mind, I'm afraid I don't see any solution to make it work before R18.
Cheers,
Maxime.

Hi @pyxelrigger thanks for reaching us, the main issue is to properly update you need to send the message MSG_DESCRIPTION_COMMAND and this is what the UI, it set the parameter then call this message.

But adding this call in the execute method of the python tag is not enough.
This message is processed by the constraint tag and add an Undo, and as said multiple time, this is not possible to add an undo in a threaded environment(see Python Tags - Shouldn't really they can change the scene? so this fail.

So the workaround is to not call the message during the scene execution of the scene but when the value is set in the user Data, so you react to a GUI interaction (main thread) so you are free to do what you want.

import c4d
#Welcome to the world of Python

def message(msgId, msgData):
    # React to the change within the UI, since it came from the UI, this is executed in the Main Thread, so you can add Undo or Add Event
    if msgId == c4d.MSG_DESCRIPTION_POSTSETPARAMETER:
        # Check if its an User Data ID
        if msgData['descid'].IsPartOf(c4d.DESCID_DYNAMICSUB):
            # Checks if its the User Data ID 1 that changed
            if msgData['descid'][-1].id == 1:
                constraintTag = op.GetObject().GetTag(1019364)

                # This will update the stuff and create an Undo
                constraintTag.Message(c4d.MSG_DESCRIPTION_COMMAND, {"id": c4d.ID_CA_CONSTRAINT_TAG_PARENT_LOCALTRANFORM_UPDATEBUTTON})
                c4d.EventAdd()
        return True

def main():
    option = op[c4d.ID_USERDATA,1]
    constraintTag = op.GetObject().GetTag(1019364)
    # Defines the new value (We could do it as well in the message method, but just to show you that Execute is called before)
    constraintTag[c4d.ID_CA_CONSTRAINT_TAG_PARENT_LOCALTRANFORM_UPDATEBUTTON] = option + 1

test_scene.c4d
Cheers,
Maxime.

Hi @SolarPH when you say -- Import Rig Parts > Arrange Parts > Modify UserData > Delete Importer --
it looks like these steps can come from a series of buttons pressed.
If its the case then you react to the message method and in this case, since the initial caller is a GUI interaction this comes from the main thread. And if you are in the main thread you are safe to do whatever you want (make sure to call StopAllThread, but you can even call EventAdd)

If you are doing all of that in the Execute method, then it's not ok and it could affect the c4d stability (we do have crash reports about that).
The main method of the python tag is just the method called during the Execute method of the C++ Python TagData. So that means this execution is done in a threaded environment, see Threading Information.
The whole scene execution is multithreaded, so if you modify this scene while you are in this scene execution the best case it will work because you modify something that will be evaluated after, in the wrong case you will make the change but nothing happens (because the object cache is already evaluated and you do your stuff afterward) or in the worst case, it will crash due to the threading environment you modify and object that is currently accessed in another thread.

Hi sorry to jump on this topic so late, and I agree that if you could do what you want in a Python Scripting tag its preferred, the mains issue with xpresso is that its a whole system that assumes certain things and was really not designed to be embedded within a generator.

So the issue about the AddNode, not working is because user data things, as an object xpresso node, is something dynamic (they will change according to the linked object) and I found no way except via the UI (by asking a UI Redraw or a whole scene execution) to refresh these data so the GvPort can be created.

But since you are in a Generator you don't have access to the GUI since all GUI operation should be done in the Main thread see Threading Information.

Cheers,
Maxime.

Just to add on top,
os.path.listdir and os.path.join in python 2 are context-specific, so if you input a Unicode string it will output a Unicode string, if you input a regular string it will output a regular string.
Now the culprit is on c4d.documents.MergeDocument because normally this method accepts a C++ Filename object (which is the Classic API that under the hood uses the new MaxonAPI maxon::Url). Unfortunately, the Python parser is not able to convert from a Python Unicode string to a C++ Filename, but only from a Python ASCII string to a filename.

So indeed casting from Unicode string to ASCII is the solution.
Cheers,
Maxime.

Hi the color used is:

So is it normal it's not the same on mac and windows, I guess yes, but I will ask design team.
And I can confirm except changing this value there is no way to apply another color.

Cheers,
Maxime.

While the method provided by Zipit Is fine, it is not 100% reliable.

here how to achieve, unfortunately, the ELEMENT_Count value is hardcoded and no way for you to retrieve it.

    constraintTag = doc.GetActiveTag()
    targetCount = constraintTag[c4d.ID_CA_CONSTRAINT_TAG_PARENT_TARGET_COUNT]
    for i in range(targetCount):
        CONSTRAINT_ELEMENT = 10  # This is hardcoded
        targetId = c4d.ID_CA_CONSTRAINT_TAG_PARENT_TARGET_COUNT + i * CONSTRAINT_ELEMENT + 1
        print(constraintTag[targetId])

Cheers,
Maxime.