@m_magalhaes

This morning: uff more learning and work.
This Afternoon lets try this code ... mind blown ... thank you !

I'll mark this as solved hence I think ist a good way to close a thread with a working prototype for others to learn.

Thank You again, @zipit & @m_magalhaes
mogh

That's strange for me inverting the Matrix (using your posted script) does not fix the nut it flips still !
Why do we have different outcomes ? (R23 atm, R25 in the office not tested yet)

normal_examplev2.c4d

Thanks for the quick answer,

@ferdinand said in CAD Normal Tag flipped after Polyon merge (join) and axis repositioning - how realign?:

I think you have your axis inverted.

This was the first fix I tried, it seems to fix the nut, but not all parts, especially when they are tilted on all axis.
I guess I have to find better examples to get to the bottom of this.

kind regards
mogh

Hi Ferdinand,

sadly i have to resurect this topic hence I still have problem with the normals when the AXIS changes.

I boiled down a script which moves the axis of selected polygon object to the parent (which is a common task in deply nested cad data )

anyway the axis is not a problem but I still have wrong shading because the normals are not transformed corectly ...

I attached a simple exaple file where a nut is orientaded off axis and results in wrong normals when executed the script.

thanks in advance

normal_example.c4d

import c4d, array
#from c4d import Vector as V
#https://plugincafe.maxon.net/topic/13004/cad-normal-tag-flipped-after-polyon-merge-join-and-axis-repositioning-how-realign/6

#new Task:
#Corrects points and normals on a point object after placing the polygon axis to the same as the parent 

def adjust_point_node(node, transform):
    """Corrects points and normals on a point object after running the join
    command in the scenario specific to PC13004.

    Args:
        node (c4d.PointObject): The PointObject to transform.
        transform (c4d.Matrix): The transform to apply.

    Raises:
        TypeError: When either `node` or `transform` are not of expected type.
    """
    def read_normal_tag(tag):
        """`Reads a `c4d.NormalTag` to a list of c4d.Vector.

        Args:
            tag (c4d.NormalTag): The tag to read the normals from.

        Returns:
            list[c4d.Vector]: The red in normals. There are polygon_count * 4 
             normals, i.e. each vertex has a normal for each polygon it is
             attached to. The normals are stored in polygon groups.

        Raises:
            RuntimeError: When the memory of the tag cannot be red.
            TypeError: When `tag` is not a `c4d.NormalTag`.
        """
        if not (isinstance(tag, c4d.BaseTag) and tag.CheckType(c4d.Tnormal)):
            msg = f"Expected normal tag, received: {tag}."
            raise TypeError(tag)

        buffer = tag.GetLowlevelDataAddressR()
        if buffer is None:
            msg = "Failed to retrieve memory buffer for VariableTag."
            raise RuntimeError(msg)

        data = array.array('h')
        data.frombytes(buffer)
        # Convert the int16 representation of the normals to c4d.Vector.
        return [c4d.Vector(data[i-3] / 32000.0,
                           data[i-2] / 32000.0,
                           data[i-1] / 32000.0)
                for i in range(3, len(data) + 3, 3)]

    def write_normal_tag(tag, normals, do_normalize=True):
        """`Writes a list of c4d.Vector to a `c4d.NormalTag`.

        Args:
            tag (c4d.NormalTag): The tag to write the normals to.
            normals (list[c4d.Vector]): The normals to write.
            do_normalize (bool, optional): If to normalize the normals.
             Default to `True`.

        Note:
            Does not ensure that `normals` is only composed of c4d.Vector.

        Raises:
            IndexError: When `normals` does not match the size of `tag`.
            RuntimeError: When the memory of the tag cannot be red.
            TypeError: When `tag` is not a `c4d.NormalTag`.
        """
        if not (isinstance(tag, c4d.BaseTag) and tag.CheckType(c4d.Tnormal)):
            msg = f"Expected normal tag, received: {tag}."
            raise TypeError(tag)

        buffer = tag.GetLowlevelDataAddressW()
        if buffer is None:
            msg = "Failed to retrieve memory buffer for VariableTag."
            raise RuntimeError(msg)

        if do_normalize:
            normals = [n.GetNormalized() for n in normals]

        # Convert c4d.Vector normals to integer representation.
        raw_normals = [int(component * 32000.0)
                       for n in normals for component in (n.x, n.y, n.z)]

        # Catch input data of invalid length.
        count = tag.GetDataCount()
        if count * 12 != len(raw_normals):
            msg = (f"Invalid data size. Expected length of {count}. "
                   f"Received: {len(raw_normals)}")
            raise IndexError(msg)

        # Write the data back.
        data = array.array('h')
        data.fromlist(raw_normals)
        data = data.tobytes()
        buffer[:len(data)] = data

    # --- Start of outer function --------------------------------------------
    if (not isinstance(node, c4d.PointObject) or
            not isinstance(transform, c4d.Matrix)):
        msg = f"Illegal argument types: {type(node)}{type(transform)}"
        raise TypeError(msg)

    # Transform the points of the node.
    #points = [p * ~transform for p in node.GetAllPoints()]
    
    # This works the polygon object stays in place now
    
    mat = op.GetMg()
    points = op.GetAllPoints()
    for i,p in enumerate(points):
        points[i] = ~transform * mat * p #Note that the multiplication sequence needs to be read from the right to the left.
        
    node.SetAllPoints(points)
    node.Message(c4d.MSG_UPDATE)
    
    # these where my desperate efforts to fix it 
    #------------------------------------------------------------------------    
    node.SetMg(transform)
    nodelocalmatrix = node.GetMl()    
    nodematrix = node.GetMg()
    
    # Transform its baked normals.
    tag = node.GetTag(c4d.Tnormal)
    if isinstance(tag, c4d.NormalTag):
        # We just have to apply the same transform here (without the 
        # translation).
        
        # original Code
        #normals = [~transform.MulV(n) for n in read_normal_tag(tag)] 
        
        # my tests
        normals = [~transform.MulV(n) for n in read_normal_tag(tag)]
        
        write_normal_tag(tag, normals)
    else:
        msg = f"Could not find normal data to adjust for: {node}."
        print(f"Warning - {msg}")

def main():
    c4d.CallCommand(13957)  # Konsole löschen
    if op is None or not op.CheckType(c4d.Opoint):
        return False

    doc.StartUndo()
    doc.AddUndo(c4d.UNDOTYPE_CHANGE, op)

    targetMat = op.GetUp().GetMg()
    
    adjust_point_node(op, targetMat)
    
    op.Message(c4d.MSG_UPDATE)
    c4d.EventAdd()
    doc.EndUndo()
    
if __name__=='__main__':
    main()

thank you for your help, I am trying to understand ...

am I right in the assumption that this is not "clean code" in a pythonic sense ?
kind regards

Dear Developpers,

the last days have been enlightening for me because I am getting more comfortable with this class thing Nevertheless beginner ??? are bound to happen ...

I have running plugin with a c4d.gui.TreeViewFunctions
in there def Select from which I would like to triger a GUI refresh inside the class TestDialog(c4d.gui.GeDialog): and therefore outside the class ListView(c4d.gui.TreeViewFunctions):

The manual calculation of the sum with self._CalcSum() works (by pressing a button) but I would like to have it interactive when the user selects something in the treeview.

I do not expext you to go through all my code a nice easy example would do I guess.

All the code should work besides some not usefull bookmarks

import c4d, os
from c4d import gui

# Be sure to use a unique ID obtained from http://www.plugincafe.com/.
PLUGIN_ID = 1000011 # TEST ID ONLY
PLUGIN_NAME = "Cad File Importer"
#TreeView Column IDs.
ID_CHECKBOX = 1
ID_NAME = 2
ID_OTHER = 3

ID_BOOKMARKLIST = ("C:\\Users\\admin\\Pictures", "E:\Bilder\Bilder Temp\Screenshots", "", "C:\\wrong path", "C:\\")

ID_FOLDERSELECTION_SYSTEM = 1111
ID_SCANCONTENT = 1112
ID_PATHSTRING = 1113
ID_INFOBOX = 201
ID_CLOSE = 1114
ID_SELECTALL = 1115
ID_SUMBOX = 1116
ID_COLOREDBORDER = 1117
ID_IMPORT = 1118

class TextureObject(object):
    """
    Class which represent a texture, aka an Item in our list
    """
    texturePath = "TexPath"
    otherData = "OtherData "
    _selected = False
    #filesize = 0

    def __init__(self, texturePath, otherData):
        self.texturePath = texturePath
        self.otherData = otherData
        #self.otherData = round(float(otherData) / 1024.0 / 1024.0, 1)
        #self.filesize = filesize

    @property
    def IsSelected(self):
        return self._selected

    def Select(self):
        self._selected = True

    def Deselect(self):
        self._selected = False

    def __repr__(self):
        return str(self)

    def __str__(self):
        return self.texturePath
        
    def NiceFileSize(self):
        return round(float(self.otherData) / 1024.0 / 1024.0, 1)
    
    
class ListView(c4d.gui.TreeViewFunctions):

    def __init__(self):
        self.listOfTexture = list() # Store all objects we need to display in this list
    
    """
    def _CalcSum(self):
        sumselected = 0
        
        for fileitem in self.listOfTexture:
            if fileitem.IsSelected == True:
                sumselected += fileitem.otherData
        
        print (round(float(sumselected) / 1024.0 / 1024.0, 1))
        return (round(float(sumselected) / 1024.0 / 1024.0, 1))
    """
    
    def IsResizeColAllowed(self, root, userdata, lColID):
        return True

    def IsTristate(self, root, userdata):
        return False

    def GetColumnWidth(self, root, userdata, obj, col, area):
        return 80  # All have the same initial width

    def IsMoveColAllowed(self, root, userdata, lColID):
        # The user is allowed to move all columns.
        # TREEVIEW_MOVE_COLUMN must be set in the container of AddCustomGui.
        return True

    def GetFirst(self, root, userdata):
        """
        Return the first element in the hierarchy, or None if there is no element.
        """
        rValue = None if not self.listOfTexture else self.listOfTexture[0]
        return rValue

    def GetDown(self, root, userdata, obj):
        """
        Return a child of a node, since we only want a list, we return None everytime
        """
        return None

    def GetNext(self, root, userdata, obj):
        """
        Returns the next Object to display after arg:'obj'
        """
        rValue = None
        currentObjIndex = self.listOfTexture.index(obj)
        nextIndex = currentObjIndex + 1
        if nextIndex < len(self.listOfTexture):
            rValue = self.listOfTexture[nextIndex]

        return rValue

    def GetPred(self, root, userdata, obj):
        """
        Returns the previous Object to display before arg:'obj'
        """
        rValue = None
        currentObjIndex = self.listOfTexture.index(obj)
        predIndex = currentObjIndex - 1
        if 0 <= predIndex < len(self.listOfTexture):
            rValue = self.listOfTexture[predIndex]

        return rValue

    def GetId(self, root, userdata, obj):
        """
        Return a unique ID for the element in the TreeView.
        """
        return hash(obj)

    def Select(self, root, userdata, obj, mode):
        """
        Called when the user selects an element.
        """
        if mode == c4d.SELECTION_NEW:
            # for tex in self.listOfTexture:
                # tex.Deselect()
            obj.Select()
        elif mode == c4d.SELECTION_ADD:
            obj.Select()
        elif mode == c4d.SELECTION_SUB:
            obj.Deselect()

        
        # i want to call _CalcSum here how ??? ------------------------------------------------------------------------------------------------------------------------------
        """
            MenuCommand ok
                dialog 
                    RestoreLayout
                        TestDialog ok
        """
        #sum = MenuCommand.dialog.RestoreLayout.TestDialog._CalcSum
        print (TestDialog._CalcSum)
        

    def IsSelected(self, root, userdata, obj):
        """
        Returns: True if *obj* is selected, False if not.
        """
        return obj.IsSelected

    def SetCheck(self, root, userdata, obj, column, checked, msg):
        """
        Called when the user clicks on a checkbox for an object in a
        `c4d.LV_CHECKBOX` column.
        """
        if checked:
            obj.Select()
        else:
            obj.Deselect()

    def IsChecked(self, root, userdata, obj, column):
        """
        Returns: (int): Status of the checkbox in the specified *column* for *obj*.
        """
        if obj.IsSelected:
            return c4d.LV_CHECKBOX_CHECKED | c4d.LV_CHECKBOX_ENABLED
        else:
            return c4d.LV_CHECKBOX_ENABLED

    def GetName(self, root, userdata, obj):
        """
        Returns the name to display for arg:'obj', only called for column of type LV_TREE
        """
        return str(obj) # Or obj.texturePath

    def DrawCell(self, root, userdata, obj, col, drawinfo, bgColor):
        """
        Draw into a Cell, only called for column of type LV_USER
        """
        if col == ID_OTHER:
            #name = obj.otherData
            name = obj.NiceFileSize()
            geUserArea = drawinfo["frame"]
            w = geUserArea.DrawGetTextWidth(name)
            h = geUserArea.DrawGetFontHeight()
            xpos = drawinfo["xpos"]
            ypos = drawinfo["ypos"] + drawinfo["height"]
            drawinfo["frame"].DrawText(name, xpos, ypos - h * 1.1)

    def DoubleClick(self, root, userdata, obj, col, mouseinfo):
        """
        Called when the user double-clicks on an entry in the TreeView.

        Returns:
          (bool): True if the double-click was handled, False if the
            default action should kick in. The default action will invoke
            the rename procedure for the object, causing `SetName()` to be
            called.
        """
        #c4d.gui.MessageDialog("You clicked on " + str(obj))
        return True

    def DeletePressed(self, root, userdata):        
        "Called when a delete event is received."
        for tex in reversed(self.listOfTexture):
            if tex.IsSelected:
                self.listOfTexture.remove(tex)
        

class TestDialog(c4d.gui.GeDialog):
    _treegui = None # Our CustomGui TreeView
    _listView = ListView() # Our Instance of c4d.gui.TreeViewFunctions
    
    
    def CreateLayout(self):
        #create the menu
        self.MenuFlushAll()
        #Bookmarks menu
        self.MenuSubBegin("Bookmarks")
        #self.MenuAddString(MNU_BOOKMARK_1["id"], MNU_BOOKMARK_1["name"])
        #self.MenuAddString(MNU_BOOKMARK_2["id"], MNU_BOOKMARK_2["name"])
        
        for addid, folderlink in enumerate(ID_BOOKMARKLIST):
            self.MenuAddString(addid+500, folderlink) # we add 500 to be out of range of common IDs we subtract 500 below in the comand section
        self.MenuSubEnd()    

        if self.GroupBegin(id=1, flags=c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, rows=5, cols=1, groupflags=c4d.BORDER_GROUP_IN):
            self.GroupBorderSpace(5, 5, 5, 5)
            self.GroupBorderNoTitle(borderstyle=c4d.BORDER_BLACK)

            # Folder Selection group with title
            #----------------------------------------------------------
            if self.GroupBegin(id=11, flags=c4d.BFH_SCALEFIT, rows=1, cols=1, title="Folderpath", groupflags=c4d.BORDER_GROUP_IN):
                self.GroupBorderSpace(5, 5, 5, 5)
                self.GroupBorder(c4d.BORDER_ROUND)
                
                # Colored Border group
                #----------------------------------------------------------
                if self.GroupBegin(id=ID_COLOREDBORDER, flags=c4d.BFH_SCALEFIT, rows=1, cols=3, groupflags=c4d.BORDER_GROUP_OUT):
                    self.GroupBorderNoTitle(c4d.BORDER_ACTIVE_2)
                    self.AddEditText(id=ID_PATHSTRING, flags=c4d.BFH_LEFT | c4d.BFH_SCALEFIT, initw=432, inith=0, editflags=c4d.EDITTEXT_HELPTEXT)
                    self.SetString(id=ID_PATHSTRING, value="Choose folder with dialog or paste the path here.", flags=c4d.EDITTEXT_HELPTEXT )
                    self.AddButton(id=ID_FOLDERSELECTION_SYSTEM, flags=c4d.BFV_FIT | c4d.BFH_FIT | c4d.BFH_RIGHT, name="Select Folder")
                    self.AddButton(id=ID_SCANCONTENT, flags=c4d.BFV_FIT | c4d.BFH_FIT | c4d.BFH_RIGHT, name="Load folder content")
                    self.GroupEnd()            
                self.GroupEnd()
                
        if self.GroupBegin(ID_INFOBOX, cols=1, flags=c4d.BFH_SCALEFIT, initw=0, inith=0 ,title=""):
            self.AddStaticText(212, flags=c4d.BFV_CENTER | c4d.BFV_SCALE | c4d.BFH_CENTER | c4d.BFH_SCALE, initw=0, inith=0, name="Info box")
            self.GroupEnd()

        if self.GroupBegin(999, cols=1, flags=c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, initw=0, inith=0 ,title="Files in Folder:"):
            self.GroupBorderSpace(5, 5, 5, 5)
            self.GroupBorder(c4d.BORDER_ROUND) 
            
            self.AddCheckbox( ID_SELECTALL, flags=c4d.BFH_LEFT, initw=0, inith=0 , name="Select All")
            
            # Create the TreeView GUI.
            #----------------------------------------------------------
            customgui = c4d.BaseContainer()
            #customgui.SetBool(c4d.TREEVIEW_BORDER, c4d.BORDER_THIN_IN )
            customgui.SetBool(c4d.TREEVIEW_BORDER, c4d.BORDER_NONE | c4d.BORDER_GROUP_IN)
            customgui.SetBool(c4d.TREEVIEW_HAS_HEADER, True) # True if the tree view may have a header line.
            customgui.SetBool(c4d.TREEVIEW_HIDE_LINES, True) # True if no lines should be drawn.
            customgui.SetBool(c4d.TREEVIEW_MOVE_COLUMN, False) # True if the user can move the columns.
            customgui.SetBool(c4d.TREEVIEW_RESIZE_HEADER, True) # True if the column width can be changed by the user.
            customgui.SetBool(c4d.TREEVIEW_FIXED_LAYOUT, True) # True if all lines have the same height.
            customgui.SetBool(c4d.TREEVIEW_ALTERNATE_BG, True) # Alternate background per line.
            customgui.SetBool(c4d.TREEVIEW_CURSORKEYS, True) # True if cursor keys should be processed.
            customgui.SetBool(c4d.TREEVIEW_NOENTERRENAME, True) # Suppresses the rename popup when the user presses enter.
            customgui.SetBool(c4d.TREEVIEW_NO_DELETE, True) # Disable Delete Message Callback completely for backspace and delete.
            #customgui.SetBool(c4d.TREEVIEW_ADDROW, True) # Show an add new column row at the bottom of the list.
            
            self._treegui = self.AddCustomGui( 1000, c4d.CUSTOMGUI_TREEVIEW, "", c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, 400, 100, customgui) # minw, minh 
            if not self._treegui:
                print ("[ERROR]: Could not create TreeView")
                return False
        
            self.GroupEnd()

        if self.GroupBegin(ID_SUMBOX, cols=2, flags=c4d.BFH_SCALEFIT, initw=0, inith=0, title="Filesizesum:"):
            self.GroupBorderSpace(5, 5, 5, 5)
            self.GroupBorderNoTitle(borderstyle=c4d.BORDER_BLACK)
            self.AddStaticText(332, flags=c4d.BFV_CENTER | c4d.BFV_SCALE | c4d.BFH_CENTER | c4d.BFH_SCALE, initw=0, inith=0, name="Selected: ")
            self.AddStaticText(333, flags=c4d.BFV_CENTER | c4d.BFV_SCALE | c4d.BFH_RIGHT | c4d.BFH_SCALE, initw=0, inith=0, name="Filesize Sum: ")
            self.GroupEnd()

        
        # OK Cancel
        #----------------------------------------------------------
        if self.GroupBegin(id=3, flags=c4d.BFV_BOTTOM | c4d.BFH_SCALEFIT, inith=25, rows=1, cols=2, title="", groupflags=c4d.BORDER_GROUP_IN):
            #self.GroupBorderSpace(5, 5, 5, 5)
            self.GroupBorderNoTitle(borderstyle=c4d.BORDER_NONE) # BORDER_NONE BORDER_BLACK
            self.AddButton(ID_CLOSE, flags=c4d.BFH_LEFT | c4d.BFV_SCALEFIT | c4d.BFH_SCALE | c4d.BFV_BOTTOM, name="Close")
            self.AddButton(ID_IMPORT, flags=c4d.BFH_RIGHT | c4d.BFV_SCALEFIT | c4d.BFH_SCALE | c4d.BFV_BOTTOM, name="Import")
            self.GroupEnd()
        
        self.GroupEnd() # main group end
        
        # self.AddButton(1001, c4d.BFH_CENTER, name="Add")

        return True

    def InitValues(self):        
        self.folderpath = None
    
        # Initialize the column layout for the TreeView.
        layout = c4d.BaseContainer()
        layout.SetLong(ID_CHECKBOX, c4d.LV_CHECKBOX)
        layout.SetLong(ID_NAME, c4d.LV_TREE)
        layout.SetLong(ID_OTHER, c4d.LV_USER)
        self._treegui.SetLayout(3, layout)

        # Set the header titles.
        self._treegui.SetHeaderText(ID_CHECKBOX, "Check")
        self._treegui.SetHeaderText(ID_NAME, "File Name")
        self._treegui.SetHeaderText(ID_OTHER, "Filesize (MB)")
        self._treegui.Refresh()

        # Set TreeViewFunctions instance used by our CUSTOMGUI_TREEVIEW
        self._treegui.SetRoot(self._treegui, self._listView, None)
        return True

# Change GUI
# --------------------------------------------------------------------------------------------------------------------------
    def _DrawGroup(self):
        print ("_DrawGroup: ", self.folderpath)

        # Flush the content of the group that holds all ours SubDialogs
        self.LayoutFlushGroup(ID_COLOREDBORDER)        

        # new content
        if self.folderpath == None or self.folderpath == "":            
            self.GroupBorderNoTitle(c4d.BORDER_ACTIVE_4) # orange
            self.AddEditText(id=ID_PATHSTRING, flags=c4d.BFH_LEFT | c4d.BFH_SCALEFIT, initw=432, inith=0, editflags=c4d.EDITTEXT_HELPTEXT)
            self.SetString(id=ID_PATHSTRING, value="Choose folder with dialog or paste the path here.", flags=c4d.EDITTEXT_HELPTEXT )
            self.AddButton(id=ID_FOLDERSELECTION_SYSTEM, flags=c4d.BFV_FIT | c4d.BFH_FIT | c4d.BFH_RIGHT, name="Select Folder")
            self.AddButton(id=ID_SCANCONTENT, flags=c4d.BFV_FIT | c4d.BFH_FIT | c4d.BFH_RIGHT, name="Load folder content")  
            
            self.LayoutFlushGroup(ID_INFOBOX)
            self.AddStaticText(212, flags=c4d.BFV_CENTER | c4d.BFV_SCALE | c4d.BFH_CENTER | c4d.BFH_SCALE, initw=0, inith=0, name = "Select a path.")

        
        elif not os.path.exists(self.folderpath):
            self.GroupBorderNoTitle(c4d.BORDER_ACTIVE_3) # red
            self.AddEditText(id=ID_PATHSTRING, flags=c4d.BFH_LEFT | c4d.BFH_SCALEFIT, initw=432, inith=0, editflags=c4d.EDITTEXT_HELPTEXT)            
            self.SetString(id=ID_PATHSTRING, value=self.folderpath)
            self.AddButton(id=ID_FOLDERSELECTION_SYSTEM, flags=c4d.BFV_FIT | c4d.BFH_FIT | c4d.BFH_RIGHT, name="Select Folder")
            self.AddButton(id=ID_SCANCONTENT, flags=c4d.BFV_FIT | c4d.BFH_FIT | c4d.BFH_RIGHT, name="Load folder content")  

            self.LayoutFlushGroup(ID_INFOBOX)
            self.AddStaticText(212, flags=c4d.BFV_CENTER | c4d.BFV_SCALE | c4d.BFH_CENTER | c4d.BFH_SCALE, initw=0, inith=0, name = "Invalid path please check.")
            
        else:
            self.GroupBorderNoTitle(c4d.BORDER_ACTIVE_2)
            self.AddEditText(id=ID_PATHSTRING, flags=c4d.BFH_LEFT | c4d.BFH_SCALEFIT, initw=432, inith=0, editflags=c4d.EDITTEXT_HELPTEXT)            
            self.AddButton(id=ID_FOLDERSELECTION_SYSTEM, flags=c4d.BFV_FIT | c4d.BFH_FIT | c4d.BFH_RIGHT, name="Select Folder")
            self.AddButton(id=ID_SCANCONTENT, flags=c4d.BFV_FIT | c4d.BFH_FIT | c4d.BFH_RIGHT, name="Load folder content")  
            self.SetString(id=ID_PATHSTRING, value=self.folderpath) # flags=c4d.EDITTEXT_HELPTEXT            
            
            self.LayoutFlushGroup(ID_INFOBOX)
            self.AddStaticText(212, flags=c4d.BFV_CENTER | c4d.BFV_SCALE | c4d.BFH_CENTER | c4d.BFH_SCALE, initw=0, inith=0, name = "Good to go.")

        # Notifies the content of the Group has changed
        self.LayoutChanged(ID_INFOBOX)
        self.LayoutChanged(ID_COLOREDBORDER)
        
# -------------------------------------------------------------------------------------------------------------------------- 
    def _ShowSum(self, valuetodisplay=0, selected=0):
        print ("_ShowSum: ")        
        howmanyselected = "Selected: " + str(selected)
        valuetodisplay = "Filesize Sum:  " + str(valuetodisplay) + " MB"
        
        self.LayoutFlushGroup(ID_SUMBOX)

        self.GroupBorderSpace(5, 5, 5, 5)
        self.GroupBorderNoTitle(borderstyle=c4d.BORDER_BLACK)
        self.AddStaticText(332, flags=c4d.BFV_CENTER | c4d.BFV_SCALE | c4d.BFH_CENTER | c4d.BFH_SCALE, initw=0, inith=0, name=howmanyselected)
        self.AddStaticText(333, flags=c4d.BFV_CENTER | c4d.BFV_SCALE | c4d.BFH_RIGHT | c4d.BFH_SCALE, initw=0, inith=0, name=valuetodisplay)
        self.LayoutChanged(ID_SUMBOX)

    def _CalcSum(self):
        sumselected = 0
        selected = 0
        
        for fileitem in self._listView.listOfTexture:
            if fileitem.IsSelected == True:
                sumselected += fileitem.otherData
                selected += 1
        
        self._ShowSum((round(float(sumselected) / 1024.0 / 1024.0, 1)), selected)
        #return (round(float(sumselected) / 1024.0 / 1024.0, 1))
        
# --------------------------------------------------------------------------------------------------------------------------
    def loadfolder(self):
        self._listView.listOfTexture = list() # flush the list hence we want to load the content only once
    
        # Add data to our DataStructure (ListView)
        newID = len(self._listView.listOfTexture) 

        if self.folderpath != None and self.folderpath != ""  and os.path.exists(self.folderpath):                 
            filelist = os.listdir(self.folderpath.decode("utf-8", "strict"))
            filelist.sort()
            for fileid, img in enumerate ( filelist ):
                #print (img)
                img = img.encode("utf-8", "strict")
                #print (img)
                fullpath = self.folderpath + "\\" + img
                #print (fullpath)
                #texsize = round(float(os.path.getsize(fullpath)) / 1024.0 / 1024.0, 1)
                texsize = os.path.getsize(fullpath)
                #tex = TextureObject("T{}".format(newID + fileid))                
                tex = TextureObject(img.format(newID + fileid), texsize) # the object
                self._listView.listOfTexture.append(tex) # the big list
                
                #print (img)
        else:
            print (self.folderpath)

        # Refresh the TreeView
        self._treegui.Refresh()    
    
    
    def Command(self, id, msg):
    
        if id == ID_SELECTALL:
            print ("Checkbox Staus: ", self.GetBool(ID_SELECTALL))             

            if self.GetBool(ID_SELECTALL) == True:
                for fileitem in self._listView.listOfTexture:                    
                    fileitem.Select()
                    
            if self.GetBool(ID_SELECTALL) == False:
                for fileitem in self._listView.listOfTexture:                    
                    fileitem.Deselect()                

            self._treegui.Refresh() 
            return True
  
        if 500 <= id <= 550:            
            bigid = int(id-500)
            #print ("Dropdown ID: ", id, ID_BOOKMARKLIST[bigid])
            self.SetString(ID_PATHSTRING, ID_BOOKMARKLIST[bigid])
            self.folderpath = self.GetString(ID_PATHSTRING)
            self._DrawGroup()
            return True            
        
        if id == ID_FOLDERSELECTION_SYSTEM:            
            self.folderpath = c4d.storage.LoadDialog(type=c4d.FILESELECTTYPE_ANYTHING, title='Choose a Folder with the 3D Data to import.', flags=c4d.FILESELECT_DIRECTORY, force_suffix='', def_path='', def_file='')
            self.SetString(ID_PATHSTRING, str(self.folderpath))
            self._DrawGroup()
            return True
            
        if id == ID_SCANCONTENT:
            self.folderpath = self.GetString(ID_PATHSTRING)
            self._DrawGroup()
            self.loadfolder()        

        if id == ID_CLOSE:
            self.Close()
            return True
        
        if id == ID_IMPORT:
            self._CalcSum()
            return True

        return True

    def CoreMessage(self, id, msg):  
    
        if id == c4d.EVMSG_CHANGE:
            print "Scene was Changed"

        return gui.GeDialog.CoreMessage(self, id, msg)

    def Message(self, id, msg):
    
        if c4d.gui.GetInputState(c4d.BFM_INPUT_KEYBOARD, c4d.KEY_ESC, msg):
            if msg[c4d.BFM_INPUT_VALUE]:
                #print ("ESC Pressed - closing window.")
                self.Close()
                return True
        return gui.GeDialog.Message(self, id, msg)

class MenuCommand(c4d.plugins.CommandData):    
    dialog = None        

    def Execute(self, doc):
        if self.dialog is None:
            self.dialog = TestDialog()
        return self.dialog.Open(c4d.DLG_TYPE_ASYNC, PLUGIN_ID, defaulth=200, defaultw=600)

    def RestoreLayout(self, sec_ref):
        if self.dialog is None:
            self.dialog = TestDialog()
        return self.dialog.Restore(PLUGIN_ID, secret=sec_ref)

def main():    
    # Retrieves the icon path
    directory, _ = os.path.split(__file__)
    fn = os.path.join(directory, "res", "cadfile_importer_icon.tif")

    if os.path.isfile(fn) :
        # 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.")
            print ("Failed to initialize the BaseBitmap.")
    else:
        print ("Bitmap not Found.", PLUGIN_NAME)
        bmp = None    
        
    try:
        c4d.plugins.RegisterCommandPlugin(  id=PLUGIN_ID, 
                                            str=PLUGIN_NAME,  
                                            info=0, 
                                            icon=bmp, 
                                            help="Lists files of a folder.", 
                                            dat=MenuCommand()
                                            )
    except ValueError:
        print ("Following Plugin could not be registered: ",  PLUGIN_NAME)

if __name__ == "__main__":
    c4d.CallCommand(13957) # clear concole
    main()

PS: I never know in which subforum to put these broad questions ...

kind regards mogh

Thanks @mp5gosu

you pointed me in the right direction I have some working code for now, even though I fear that I don't know what I am doing with all these classes

this script example helped me a little bit even though its pretty rough

https://github.com/PluginCafe/cinema4d_py_sdk_extended/blob/master/scripts/03_application_development/gui/dialog/customgui_quicktab_r19.py

kind regards mogh

Dear developers,

I would like to change the appearance of a group with these nice border styles after the user interacted with the interface. (inserting a filepath)

self.GroupBorderNoTitle(c4d.BORDER_NONE) # filepath fine
self.GroupBorderNoTitle(c4d.BORDER_ACTIVE_4) # orange filepath empty
self.GroupBorderNoTitle(c4d.BORDER_ACTIVE_3) # red filepath does not exist

I have a def Command(self, id, msg): section which checks the inputs but I cannot "change" the interface cosmetically in this section - still self.SetString(1103, str(self.folder)) works as intended ...

how would this be feasible for changing elements where no dedicated "SET" is available.

thank you for your time.
mogh

yesterday I saw 2 small triangles which i didn't unfold .... today they are gone... addblocker at work ?

I just had time to check this hence the holidays.

This works with the correct ID (1036219 = Redshift) the nodes render my "cleaned" C4D file again.

Thank you very much @m_magalhaes

kind regards
mogh

Thanks you for your reply,

interesting never noticed that there is a post effekt called redshift in the standard renderer . will need to check that, I always swith from physical to redshift and back.

the id is probably just the post effect not the redshift plugin ID I posted. - anyway

if I could solve the problem by deleting the post effect i am happy also
will check

anyway thanks