Thank you

Hey,

so, I fixed this now, in the sense that the TOC is now back in these classic API type and module pages.

c2f5944c-90e4-49f9-a194-44f7be96b281-image.png

I renamed the old a bit wordily named "Functions Signatures" and "Functions Documentation" to Overview and Functions (or Methods for classes) . Opposed to the old pre 2024.3 TOCs (which were completely broken in many ways), these categories now also show up in the TOC:

adcc5c03-d5fd-4f97-b206-7d69cef2d81e-image.png
bc7bac63-8959-487a-8aa7-81e729fcc92a-image.png

The old Types and Inheritance section has been merged into root element as I do not see a good reason why it should appear in the middle of the page. The obvious thing would be to now add links to the individual elements on a page, so that you can quick-jump to a particular function. But that turned out to be not so easy with the mess we made there before and stubborn docutils. As evident by the C4DAtom example and other cases our TOC trees are very broken in this part of the docs and I now already almost spent two days with fixing things to this state.

This will be shipped in the current state with the next release of Cinema 4D. When I have some time to waste, I will try to add the function links.

⚠ The manual and maxon API TOCs are unaffected by this, they continue to work as intended. The classic API does its own thing here (as always 😄 ) which why this is such a mess.

Cheers,
Ferdinand

Hey @no1astrologer,

this will be fixed in the next release.

Thanks @ferdinand. I guess I'll have to skip on that idea 🙂 I was really hoping that there is something like .GetAllTextures or .GetAllAssets, but it seems I'm out of luck on this one.

@ferdinand you are amazing!
Thank you so much for your help, this is it. Now only remains the last step until my script to automatically recognize and replace duplicate objects with instances is complete: The UI. But that should be a quick one.

Thank you so much for your help again Ferdinand, you are a saint. Have a superb week and best wishes from Potsdam!

Jerome

Thanks for the response, that's what I was afraid of.

John Terenece

Thanks @m_adam,

I had to jump through a bunch of hoops with this one, because I put the queue process into a progress dialog so that for large file arrays there's an indicator of progress. Otherwise it just appears to hang and the user won't know why. But this made it tricky when the timer is also used because of the different thread contexts involved with the timer, the progress dialog and everything else on the main thread. But with a bit of care, it seems to work.

Thanks again,

WP.

Hi sadly the only way is to use c4d.CallCommand(1055347) which does not open the window but directly execute the command.
You can change the setting as you could in the windows, by editing the value in the BaseContainer of the document.
Finally it act on the selected polygon, so the best way would be to select them.

Find bellow a script that you can execute in the script manager that will select all polygon of an object and run the command.

from typing import Optional import c4d doc: c4d.documents.BaseDocument # The active document op: Optional[c4d.BaseObject] # The active object, None if unselected def main() -> None: # Enables UV Polygon Mode if not already in any UV mode (needed for GetActiveUVSet to works) if doc.GetMode() not in [c4d.Muvpoints, c4d.Muvpolygons]: doc.SetMode(c4d.Muvpolygons) # Retrieves active UVSet, The UV windows need to be opened at least one time handle = c4d.modules.bodypaint.GetActiveUVSet(doc, c4d.GETACTIVEUVSET_ALL) if handle is None: # If fail it may be because the Texture view is not open # Open A texture View c4d.CallCommand(170103) # In S22 you need to update the UV Mesh if c4d.API_VERSION >= 22000: c4d.modules.bodypaint.UpdateMeshUV(False) # Retrieves active UVSet, The UV windows need to be opened at least one time handle = c4d.modules.bodypaint.GetActiveUVSet(doc, c4d.GETACTIVEUVSET_ALL) if handle is None: raise RuntimeError("There is no Active UVSet") # Select the polygon you want to operate on currentSel = op.GetPolygonS() previousSel = currentSel.GetClone() # Will be used to restore the initial selection state at the end currentSel.SelectAll(op.GetPolygonCount() - 1 ) # Update the UV mesh to properly take into account the new selection c4d.modules.bodypaint.UpdateMeshUV(True) # Define the settings settings = doc.GetSettingsInstance(c4d.DOCUMENTSETTINGS_MODELING) settings[c4d.MDATA_UVRECTANGULARIZE_ALIGN] = True settings[c4d.MDATA_UVRECTANGULARIZE_EQUIDISTANT] = False # Execute the command c4d.CallCommand(1055347) # Restore the initial selection previousSel.CopyTo(currentSel) c4d.modules.bodypaint.UpdateMeshUV(True) c4d.EventAdd() if __name__ == '__main__': main()

Cheers,
Maxime.

Hello @HerzogVonWiesel,

Thank you for reaching out to us. Using the message system could be possible here but seems a bit overkill. Since you own both implementations, it would be best if you simply tie together the dialog instances you want to exchange information between. E.g.:

import c4d class ConnectedDialog(c4d.gui.GeDialog): """Realizes a dialog type which has a binding to another dialog instance. Note that all methods in this example are not part of the GeDialog interface scheme, i.e., "custom" methods. """ def __init__(self) -> None: """ """ # The list of dialogs this dialog instance does exchange information with. self._connectedDialogs: list[ConnectedDialog] = [] super().__init__() def Bind(self, other: "ConnectedDialog", twoWay: bool = True) -> None: """Binds the dialog #other to #self and makes the connection optionally two-way. Also ensures that bindings are unique, i.e, two dialogs cannot be bound more than once in one direction. """ if not isinstance(other, ConnectedDialog): raise TypeError(f"{other = }") if other not in self._connectedDialogs: self._connectedDialogs.append(other) if twoWay and self not in other._connectedDialogs: other._connectedDialogs.append(self) def SpecialMessage(self, sender: "ConnectedDialog", *args) -> None: """Receives message stream from all connected dialogs. """ print (args) def Action(self, value: any, condition: any) -> None: """Exemplifies a method which informs all other dialog instances about an event. """ if condition: for dlg in self._connectedDialogs: dlg.SpecialMessage(self, value, condition) if __name__ == "__main__": # Instantiate five dialogs and creating bindings between all of them. dialogCollection: tuple[ConnectedDialog] = (ConnectedDialog() for _ in range(5)) for a in dialogCollection: for b in dialogCollection: a.Bind(b)

You could do three million and one thing differently here; this is just an example to illustrate a pattern. The crucial information might be here for you (since we just talked about threading and dialogs before) that:

ℹ The methods both of modal and async dialogs run on the main thread. Async in an async dialog are only the drawing routines which you do not have access to, even when you implement a dialog with a custom GeUserArea. That area only enqueues drawing instructions into a buffer and does not do the actual drawing. So, there is no danger of access violations, which Python of course does not know in the first place due to its GIL.

When tying dialogs together is not possible then you can use the message system of Cinema 4D. But tying objects together is always possible in Python even when the objects live in two modules which do not have access to each other. You can either use sockets (a bit overkill) or be lazy and just setup shop in a commonly accessible object, e.g., the sys module.

When you go for messages, I would recommend having a look at the Message Manual first as I gave there a rough overview. In short:

GeDialog.Message is for UI messages and just like its NodeData.Message counter part instance specific. It is not meant to establish a binding between two dialog instances but to let Cinema 4D or elements in a UI tree communicate with the dialog ("button to dialog: I have been pressed"). What you can do, is set off a core event with c4d.SpecialEventAddd to then catch that core message in all other dialogs using GeDialog.CoreMessage. Note that the Python API does filter message streams, and unlike in C++, you cannot just "invent" a new message type, except for using c4d.SpecialEventAdd. But there you are limited to sending three integers in Python (in C++ the p1 and p2 arguments are meant to be pointers to arbitrary data).

Cheers,
Ferdinand

PS: Yeah using the CPython API you can cast/wrap things (in order to use p1 and p2 actually in the manner they are intended to) but be aware that any C magic is not officially supported by us.

Thank you very much!

Hey @WickedP,

Thank you for pointing it out. There was a problem with how the CSS of the plugin providing the solved feature, the forum CSS, and our styling CSS did mesh in the light skin. I fixed it by putting even more CSS on top of things - because who doesn't love a solid mess in the CSS 😛

PS: I am aware that the search feature could also still use some work under the dark skin. It is just not the highest priority when things are ugly but readable.

Cheers,
Ferdinand

Hi @i_mazlov

The dialog/gui is open. It's a progress dialog that I use to run an export function.

I did some more digging, and I believe I've solved it. I had to put the SetTitle() into the dialog's Timer() function. So, something like this:

virtual void MyProgressDialog::Timer(const BaseContainer& msg) { // 'title' is a class-level string variable SetTitle(title); return ProgressDialog::Timer(msg); }

Seems to work as expected.

WP.