Nevermind. I am an idiot. I did manage to find some of what I was looking for.

For future reference in case anyone is as blind as I am, when you are doing a commandData plugin, when registering your plugin, you need to set c4d.PLUGINFLAG_COMMAND_OPTION_DIALOG in the info flag, and that will make it have the icon. Then I can go do some searching to sort the rest of it out.

I have a question that conceptually I don't know the best practices for doing and I was having trouble locating anything in the SDK about it.

Cinema has the concept of the gear icon which let's you open a little dialog for commands to change something that you maybe would only do occassionally. This is visible in a variety of areas such as the Mesh>Add>Subdivide for instance.

link

Is there any information about best practices for doing something like this? I am sorry this is a bit vague. Is it just a matter of having the script/command plugin, and then a second script/command plugin for the the settings dialog that maybe writes something that the first script references when running? Or is there some proper way to write a command with the setting icon option? I feel like there has to be some way, because if I were to do it as two separate scripts/plugins, they'd have two different entries, in the Extensions menu, right? Which is not what is desired.

Blah! Bummer. Seemed like a bug to me. I guess I will just convert this to a CommandData plugin and use GeDialog.

@ferdinand said in How to Undo Switching Between Modes?:

Well, just move the code which switches the mode to the end of your code when it is only cosmetic anyways. As I said above, a sensible way to use SetMode is when you want to leave the user in a state where he or she can continue working right away. But you can then just run all your code, check if everything went fine and then set your code. Otherwise you never set the mode, and therefore also have nothing to revert.

It's a matter of workflow. It's not simply for checking the code that it's working properly. It's about a workflow. The workflow in the example is Select some mesh components, run the command. It generates something for you and switches the mode for you. If you selected the wrong components, you'd undo and try it again. But the undo won't put you back in the component mode. The issue is that that part of the command is not undoable so it's does hinder the workflow just a bit. I'm not necessarily advocating that it should be undoable or anything like that, just explaining the reasoning in this example and the value if it were undoable.

I would do that, except the process for creating a plugin is not trivial and in no way intuitive anymore. There's no resEdit to generate all the necessary resource information and UI elements, so now I have to do that manually. That means to provide a meaningful and functional example, I need to now go through the several hoops of creating a plugin just for this test, despite giving reasonably clear indications of what is being done function and plugin-wise. And despite going through the process of getting a new plugin ID, and creating a new folder, .pyp file, res, strings_us, renaming my classes, using the correct, new, throwaway plugin ID, my plugin wont even initialize. Even though it's the same code as my actual plugin, just with renamed classes and file, and stripped down, the plugin would not initialize. So here's the code that had to hijack an existing toolData plugin SDK example to demonstrate the issue.

"""
Copyright: MAXON Computer GmbH
Author: XXX, Maxime Adam

Description:
    - Tool, Creates a liquid Painter Tool.
    - Consists of Metaball and Sphere.

Class/method highlighted:
    - c4d.plugins.ToolData
    - ToolData.GetState()
    - ToolData.MouseInput()
    - ToolData.Draw()
    - ToolData.GetCursorInfo()
    - ToolData.AllocSubDialog()
"""
import c4d
import os

# Be sure to use a unique ID obtained from www.plugincafe.com
PLUGIN_ID = 1025247

# Values must match with the header file, usd by c4d.plugins.GeLoadString
IDS_PRIMITIVETOOL = 50000


class SettingsDialog(c4d.gui.SubDialog):
    """Creates a Dialog to show the ToolData options.

    This dialog will be displayed in the Attribute Manager so this means the ToolDemoDialog
    will be instantiate each time the tool is activate and destruct when the AM change its mode.
    """
    def __init__(self, sharedDict):
        super(SettingsDialog, self).__init__()

    def CreateLayout(self):
        self.SetTitle("BB-Distribute Points")
        self.GroupBegin(id=100010, flags=c4d.BFH_SCALEFIT, cols=1, rows=5, title="BB-Distribute Points")

        self.GroupBegin(id=200010, flags=c4d.BFH_SCALEFIT, cols=2, rows=1)
        #bc=c4d.BaseContainer()
        self.AddCheckbox(id=8888,  flags = c4d.BFH_LEFT,  initw=10, inith= 10, name="")
        self.linkGadget = self.AddCustomGui(9898, c4d.CUSTOMGUI_LINKBOX, "Custom", c4d.BFH_SCALEFIT, minw=100, minh=10)
        self.GroupEnd()
        
        self.GroupEnd()

        return True
    
    def Command(self, commandID, msg):
        """This Method is called automatically when the user clicks on a gadget and/or changes its value this function will be called.

        It is also called when a string menu item is selected.

        Args:
            commandID (int): The ID of the gadget that triggered the event.
            msg (c4d.BaseContainer): The original message container

        Returns:
            bool: False if there was an error, otherwise True.
        """
        if commandID == 9898:
            print(self.linkGadget.GetLink())


class LiquidTool(c4d.plugins.ToolData):
    """Inherit from ToolData to create your own tool"""

    def __init__(self):
        self.data = {'sphere_size':15}

    def AllocSubDialog(self, bc):
        """Called by Cinema 4D To allocate the Tool Dialog Option.

        Args:
            bc (c4d.BaseContainer): Currently not used.

        Returns:
            The allocated sub dialog.
        """
        return SettingsDialog(getattr(self, "data", {'sphere_size': 15}))


if __name__ == "__main__":
    # Retrieves the icon path
    directory, _ = os.path.split(__file__)
    fn = os.path.join(directory, "res", "liquid.tif")

    # Creates a BaseBitmap
    bmp = c4d.bitmaps.BaseBitmap()
    if bmp is None:
        raise MemoryError("Failed to create a BaseBitmap.")

    # Init the BaseBitmap with the icon
    if bmp.InitWith(fn)[0] != c4d.IMAGERESULT_OK:
        raise MemoryError("Failed to initialize the BaseBitmap.")

    # Registers the tool plugin
    c4d.plugins.RegisterToolPlugin(id=PLUGIN_ID,
                                   str="Py-Liquid PainterBB",
                                   info=0, icon=bmp,
                                   help="This string is shown in the statusbar",
                                   dat=LiquidTool())

This is a copy of an SDK example of a toolData plugin, it does the same thing I am doing in my plugin which is using and was as I described in my first post def AllocSubDialog(self, bc) in the toolData pluginto call a c4d.gui.SubDialog class that is calling CreateLayout(self) which inside there is using self.linkGadget = self.AddCustomGui(9898, c4d.CUSTOMGUI_LINKBOX, "Custom", c4d.BFH_SCALEFIT, minw=100, minh=10). I also added the Command bit from your example, and it will print the object, but the object does not get retained.

Open Cinema. Select Py-Liquid PainterBB. Drag any object into the link field of the AM and it should disappear immediately.

I think the idea is that when working with this and testing it, it becomes a thing that the user has to manage themselves.

Imagine you have a script that takes point selections, then creates a null, and then switches to object mode with the null selected so you can immediate move the null.

You hit undo, null is gone. Back to your point object selected, but you are still in model mode. So to run it again youd need to manually switch back to point mode, THEN run the script again.

Thats what I think the idea for the use case is.

Does it still work if you instead put it into a SubDialog and call that subDialog from a tooldata plugin? Because thats the only thing I can see from my code. As ive mentioned, I have used linkboxes successfully before, but it was always in CommandData plugins with GeDialog not ToolData plugins with SubDialog so it shows up in the Attribute Manager vs a pop up window. I wasn't sure if there is some sort of difference I need to account for there.

Howdy,
I found myself with some time to look at my plugin I was working on. It is a ToolData plugin that uses AllocSubDialog to call my subDialogClass. In my subDialog class, I am using createLayout to make a linkbox customGUI element via the following line in my CreateLayout function

self.linkGadget = self.AddCustomGui(9898, c4d.CUSTOMGUI_LINKBOX, "Custom", c4d.BFH_SCALEFIT, minw=100, minh=10)

In terms of drawing my UI, it all works. I see my link box no problemo. I began to try to do some GetLinkObject type functions to query the field and return it's value. That seems to be working, however I can't fully test it because I cannot seem to actually drag and drop my opject into the link field and have it stick.

I feel like this is something pertaining to the messaging and stuff of a toolData plugin? I have used link fields many times in CommandData plugins, but this is my first toolData plugin. Is there something special I need to do in order to make it stick?

I am working on a ToolData plugin , and it's going well enough at the moment. But I see various UI elements that I cannot seem to find any documentation on how to achieve. The best example I can give is the Extrude Tool(although there are many tools that work in this way).

How do you create the tabs like in the extrude tool where you can select 1 or multiple tabs and display all the UI elements? The tabGroupBegin was where I thought but it seems to be strictly tabs, radios, or drop down.

The other thing that is interesting is the foldable sections. Is that using BFV_BORDERGROUP_FOLD or is that something much more complex?

That title might be a bit confusing. Allow me to try and explain.

I have some ideas for a few different commandData plugins. The plugins pertain to extracting Joint Weight Data from certain deformers. For example extracting a skinned ffd deformer into joint weights. Extracting the effects of a delta mush deformer into joint weights, extracting a spline deformer to joint weights, etc.

My thought is to make X number of different commandData plugins for each instance, however all of these plugins use a lot of shared functions that I have written to do sort of generalized steps of each of these(Get the weight tag from an object, Creating weight maps from something, etc). So my question is how do I organize this in such a way so that I can have my shared libraries separate that each command data plugin could access without each plugin needing all the duplicate functions in there? I hope that makes some sense.

It's kind of like being able to do:

import myLib
myLib.myFunction()

But I am not sure how to manage that across multiple plugins that will be source protected, and how to go about distributing that.

I hope this make some sort of sense.