Industrial Designer, Product Visualization, a slight itch for scripting.
@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
In my case setting this to true hides them.
customgui.SetBool(c4d.TREEVIEW_HIDE_LINES, True) # True if no lines should be drawn.
kind regards
mogh
Beginner solution:
If you do not need a certain layer you could also implement the call comand "Delete unused layers"
Its not pretty but beats any convulated self written code if it is not called to often.
c4d.CallCommand(100004760) # Remove unused layers
cheers
mogh
... while the Team probalby will ask you to provide more context / detail ... have you looked at the sdk examples ?
kind regards
EDIT:
Sorry this was not what I thought I have a dual Dialog example somewhere but not at hand ...
*This is an Subdialog Example from the SDK.
hope that is in line what you are searching.*
Cheers mogh
You probably still using the PuginID (chatGPT gibberisch) look at the above mentioned savedoc() and compare it to yours .... I testet it just now and it works for me ...
Even though my answer might not be as perfect as the C4D teams I 'll jump in here.
You are passing 5 arguments (noob speek 5 variables in the brakets ) to a function that only takes 4 -> SaveDocument ... as you can see here it needs only 4 the fbx settings are stored they re not passed as I understand.
Noob Gotcha: You can combine flags as a single argument with the pipe | symbol
# this is one argument
flags=c4d.SAVEDOCUMENTFLAGS_DONTADDTORECENTLIST | c4d.SAVEDOCUMENTFLAGS_EXPORTDIALOG
as a beginner i find it helpful to write the function with its parameters
# i did not test this ...
c4d.documents.SaveDocument(doc=doc, name=fbx_path, saveflags=c4d.SAVEDOCUMENTFLAGS_DONTADDTORECENTLIST,
format=c4d.FORMAT_FBX_EXPORT)
ChatGPT gives better results if you prompt it to give you a single python function. With C4D. specific stuff it often cobbles 10 year old code with new sdk stuff.... resulting in a weird code
hope this helps ----
cheers mogh
I am sorry, I do not want to come across as lacy but it is more or less the sdk example thats why I asked so sparse.
I numerated the IDS from top to bottom that solved the FFFFF unchecking but there is still GUI disintegration and the switch between CCCC and DDDD
The occasional supper and so is the prework for the link boxes I want to integrate (copied from ferdinands recent GUI example here in the forum)
kind regards mogh
"""
Copyright: MAXON Computer GmbH
Author: Maxime Adam
Description:
- Creates a Modal Dialog displaying a different SubDialog according to the selected entry of the QuickTab.
- Demonstrates how to add, flushes, remove tab interactively.
Class/method highlighted:
- c4d.gui.QuickTabCustomGui
- QuickTabCustomGui.ClearStrings()
- QuickTabCustomGui.AppendString()
- c4d.gui.GeDialog
- GeDialog.CreateLayout()
- GeDialog.InitValues()
- GeDialog.Command()
- GeDialog.HideElement()
- GeDialog.RemoveElement()
- c4d.gui.SubDialog
"""
import c4d # pyright: ignore[reportMissingImports]
import json
import os
DEBUG = True
# Ids used in our Dialog
ID_MAINGROUP = 1000 # ID used for the Group that holds all the other group representing the tab content
ID_QUICKTAB_BAR = 1001 # ID for the quicktab customGui
ID_QUICKTAB_BASE_GROUP = 1002 # Base ID for each SubDialog
ID_LOADDEFAULT_MAT_ASIGN = 1003
ID_CREATE_MATERIALS = 1004
BUTTON_PRINT_TEXT = 1005 # ID used for the Print text Button
BUTTON_PRINT_SELECTED = 1006 # ID used for the Print Selected Button
BUTTON_FLUSH_ALL = 1007 # ID used for the Flush All Button
BUTTON_ADD = 1008 # ID used for the Add Button
BUTTON_REMOVE = 1009 # ID used for the Remove Button
# Id used in our SubDialog
CUSTOM_GROUP_ID_TEXT_BASE = 4000 # Defines the ID for the string to be displayed
LAYOUT_DEBUG = True
DEFAULT_BORDER_STYLE =c4d.BORDER_NONE
if LAYOUT_DEBUG is True:
DEFAULT_BORDER_STYLE = c4d.BORDER_BLACK
GENERATOR_START_ID = 2000
def plusone_id():
n = GENERATOR_START_ID
while n < GENERATOR_START_ID+999:
yield n
n += 1
somne_json = '{"AAAAAAA 85": ["a part_number_1","a part_number_2","a part_number_3"],"BBBBB 40": ["b part_number_4","b part_number_5"],"CCCCCCC": ["c part_number_6","c part_number_7","c part_number_8","c part_number_9"],"DDDDDD": ["d part_number_6","d part_number_7","d part_number_8","d part_number_9"],"FFFFF": ["f Plane"],"GGGGGGG": ["g part_number_6","g part_number_7","g part_number_8","g part_number_9"],"HHHHHHHH": ["h part_number_6","h part_number_7","h part_number_8","h part_number_9"],"IIIIII": ["i part_number_6","i part_number_7","i part_number_8","i part_number_9"],"JJJJJJJJJ": ["j part_number_6","j part_number_7","j part_number_8","j part_number_9"],"KKKKKKKK": ["k part_number_6","k part_number_7","k part_number_8","k part_number_9"],"LLLLLLLLL": ["l part_number_6","l part_number_7","l part_number_8","l part_number_9"]}'
### Json
#####################################################################################
def read_parts_json(json_file_path):
#with open(json_file_path) as f: data = json.load(f)
data = json.loads(somne_json)
materials = {}
for material_id, part_numbers in data.items():
materials[material_id] = part_numbers
material_ids = list(data.keys())
return material_ids, materials
class CustomGroup(c4d.gui.SubDialog):
DEFAULT_FLAGS = c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT
DEFAULT_SPACE = (5, 5, 5, 5)
"""A SubDialog to display the passed string, its used as example for the actual content of a Tab"""
def __init__(self, material, parts):
self._material = material
self._parts = '\n'.join(parts)
def CreateLayout(self):
#self.GroupBorderNoTitle(borderstyle=DEFAULT_BORDER_STYLE)
self.AddStaticText(CUSTOM_GROUP_ID_TEXT_BASE + 1 , flags=c4d.BFH_LEFT | c4d.BFV_TOP | c4d.BFH_FIT | c4d.BFV_FIT, name=self._material)
self.AddStaticText(CUSTOM_GROUP_ID_TEXT_BASE + 2 , flags=c4d.BFH_LEFT | c4d.BFV_TOP | c4d.BFH_FIT | c4d.BFV_FIT, name=CUSTOM_GROUP_ID_TEXT_BASE)
self.AddMultiLineEditText(CUSTOM_GROUP_ID_TEXT_BASE + 3, flags=c4d.BFH_LEFT | c4d.BFV_TOP | c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, initw=0, inith=0, style=0)
self.SetString(CUSTOM_GROUP_ID_TEXT_BASE + 3, value=self._parts)
#for i, parts in enumerate(self._parts):
# self.AddStaticText(CUSTOM_GROUP_ID_TEXT_BASE + i, c4d.BFH_SCALEFIT, name=parts)
return True
class MyDialog(c4d.gui.GeDialog):
DEFAULT_FLAGS = c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT
DEFAULT_SPACE = (5, 5, 5, 5)
def __init__(self, items=[]):
# this is from the linkbox example from ferdinand
super(MyDialog, self).__init__()
# will be link box
self._items = []
self._doc = None
self._hasCreateLayout = False
self.Items = items
self._quickTab = None # Stores the quicktab custom GUI
self._tabList = {} # Stores the TabName and the SubDialog that represents each tab of the QuickTab
def _DrawQuickTabGroup(self):
"""Creates and draws all the SubDialog for each tab, take care it does not hide these according to a selection state.
Returns:
True if success otherwise False.
"""
# Checks if the quicktab is defined
if self._quickTab is None:
return False
# Flush the content of the group that holds all ours SubDialogs
self.LayoutFlushGroup(ID_MAINGROUP)
self.GroupBorderSpace(left=5, top=5, right=5, bottom=5)
# Iterates over the number of tab to create and attach the correct SubDialog
for tabId, (tabName, tabGui) in enumerate(self._tabList.items()):
self.AddSubDialog(ID_QUICKTAB_BASE_GROUP + tabId, c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, 0, 0)
self.AttachSubDialog(tabGui, ID_QUICKTAB_BASE_GROUP + tabId)
# Notifies the content of the MainGroup has changed
self.LayoutChanged(ID_MAINGROUP)
return True
def GetActiveTabs(self):
"""Retrieves two list of currently selected tabs from the self._quickTab.
Returns:
list(int), list(name): The first list, contains tabs Id (from self._quickTab the dict) and the second list contains all names of the selected tabs.
"""
# Checks if the quicktab is defined
if self._quickTab is None:
return False, False
returnIds = []
returnNames = []
for tabId, (tabName, tabGui) in enumerate(self._tabList.items()):
if self._quickTab.IsSelected(tabId):
returnIds.append(tabId)
returnNames.append(tabName)
return returnIds, returnNames
def DisplayCorrectGroup(self):
"""Hides all unused groups and display the correct one.
Returns:
True if success otherwise False.
"""
# Retrieves the selected tab
activeIds, activeNames = self.GetActiveTabs()
# Iterates each CustomGui and defines if they are hidden or not
for tabId in range(len(self._tabList)):
toDisplay = tabId in activeIds
self.HideElement(ID_QUICKTAB_BASE_GROUP + tabId, not toDisplay)
# Notifies the content of the MainGroup has changed
self.LayoutChanged(ID_MAINGROUP)
return True
def AppendTab(self, tabName, content, active=True):
"""Appends a tab to the current quicktab with the associated content to be displayed.
Args:
tabName (str): The name the tab should have.
content (c4d.gui.SubDialog): The SubDialog to be drawn/linked when the tab is selected.
active (bool, optional): If True, the inserted tab will be selected. Defaults to True.
Returns:
True if success otherwise False.
"""
# Checks if the quicktab is defined
if self._quickTab is None:
return False
# Adds the tab entry n the quicktab
self._quickTab.AppendString(len(self._tabList), tabName, False)
# Updates our current tabList with tabName and the Subdialog to be linked
self._tabList.update({tabName: content})
# Retrieves the current selected tab
previousActiveId, previousActiveName = self.GetActiveTabs()
# Draws the quicktab SubDialog (in order to have the new one drawn)
self._DrawQuickTabGroup()
# Defines the just added tab according state
self._quickTab.Select(len(self._tabList) - 1, active)
# Defines previous active tab
for tabId in previousActiveId:
self._quickTab.Select(tabId, True)
# Display only the selected tab and hides all others
self.DisplayCorrectGroup()
return True
def FlushAllTabs(self):
"""Removes all tabs and their content from the GUI.
Returns:
True if success otherwise False.
"""
# Checks if the quicktab is defined
if self._quickTab is None:
return False
# Removes all the tabs
self._quickTab.ClearStrings()
# Removes all the customGui
for tabId in range(len(self._tabList)):
self.RemoveElement(ID_QUICKTAB_BASE_GROUP + tabId)
# Reinitializes the stored tablist to an empty dict
self._tabList = {}
# Notifies the content of the MainGroup has changed
self.LayoutChanged(ID_MAINGROUP)
return True
def RemoveTab(self, tabNameToRemove):
"""Removes a tab by its name
Args:
tabNameToRemove (str): The tab to remove.
Returns:
True if success otherwise False.
"""
# Checks if the quicktab is defined
if self._quickTab is None:
return False
# Copies the tabList
newDict = dict(self._tabList)
# Checks if the entry exist
if tabNameToRemove not in newDict:
return True
# Removes the entry we want to delete
del newDict[tabNameToRemove]
# Removes all groups
self.FlushAllTabs()
# Re-adds all the one from our copy
for tabName, tabGui in newDict.items():
self.AppendTab(tabName, tabGui)
return True
def CreateLayout(self):
"""This Method is called automatically when Cinema 4D Create the Layout (display) of the Dialog."""
# Creates a QuickTab Custom Gui
bc = c4d.BaseContainer()
#bc.SetInt32(c4d.QUICKTAB_BAR, 0) # (0=off, 1=on, 2=non-bold, 3=special separator look)
bc.SetBool(c4d.QUICKTAB_BAR, False)
#bc.SetBool(c4d.QUICKTAB_SPRINGINGFOLDERS, True) # if we can get link fields usefull
bc.SetBool(c4d.QUICKTAB_SHOWSINGLE, True)
bc.SetBool(c4d.QUICKTAB_NOMULTISELECT, False)
self.GroupBegin(next(plusone_id()), c4d.BFH_SCALEFIT | c4d.BFV_TOP | c4d.BFV_FIT, 0, 0, '', 0)
self._quickTab = self.AddCustomGui(ID_QUICKTAB_BAR, c4d.CUSTOMGUI_QUICKTAB, '', c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, 0, 0, bc)
self.GroupBorderNoTitle(borderstyle=DEFAULT_BORDER_STYLE)
self.GroupBorderSpace(left=5, top=5, right=5, bottom=5)
self.GroupEnd()
# Creates a group that will contain all the group representing each tab
self.GroupBegin(ID_MAINGROUP, flags=c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, cols=10, rows=10, title='')
self.GroupBorderNoTitle(borderstyle=DEFAULT_BORDER_STYLE)
self.GroupBorderSpace(left=5, top=5, right=5, bottom=5)
self.GroupEnd()
# dummy group to spread vertically
if self.GroupBegin(id=next(plusone_id()), flags=c4d.BFH_FIT | c4d.BFV_FIT): #cols=1, rows=1,
self.GroupBorderSpace(left=0, top=0, right=0, bottom=0)
self.GroupBorderNoTitle(borderstyle=DEFAULT_BORDER_STYLE)
self.AddStaticText(id=next(plusone_id()), flags=c4d.BFV_CENTER | c4d.BFV_SCALE | c4d.BFH_CENTER | c4d.BFH_SCALE, name="")
self.GroupEnd()
# Creates a group with button in order to do some operation with the QuickTab CustomGUI
if self.GroupBegin(next(plusone_id()), c4d.BFH_SCALEFIT | c4d.BFV_BOTTOM, 6, 1, '', 0):
self.AddButton(ID_LOADDEFAULT_MAT_ASIGN, c4d.BFH_SCALEFIT, name="Populate")
self.AddButton(BUTTON_PRINT_TEXT, c4d.BFH_SCALEFIT, name="Print text")
self.AddButton(BUTTON_PRINT_SELECTED, c4d.BFH_SCALEFIT, name="Print Selected")
self.AddButton(BUTTON_FLUSH_ALL, c4d.BFH_SCALEFIT, name="Flush All")
self.AddButton(BUTTON_ADD, c4d.BFH_SCALEFIT, name="Add")
self.AddButton(BUTTON_REMOVE, c4d.BFH_SCALEFIT, name="Remove")
self.GroupEnd()
return True
def InitValues(self):
"""This Method is called automatically after the GUI is initialized."""
# Creates the first Tab
#cg1 = CustomGroup(["This is the first Tab", "Just dummy text here"])
#self.AppendTab("First Tab", cg1, True)
# Creates the second Tab
#cg2 = CustomGroup(["This is the second Tab", "Just another dummy text here"])
#self.AppendTab("Second Tab", cg2, False)
#return True
return super(MyDialog, self).InitValues()
def Command(self, id, 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:
id: The ID of the gadget that triggered the event.
msg: The original message container
Returns:
False if there was an error, otherwise True.
"""
# If the user interacts with the quicktab, we make sure to display the CustomGUI linked to the active one
if id == ID_QUICKTAB_BAR and self._quickTab:
self.DisplayCorrectGroup()
return True
# Displays all the Tab name
if id == BUTTON_PRINT_TEXT:
print([key for key in self._tabList])
return True
# Displays the ID and name of the selected tab
if id == BUTTON_PRINT_SELECTED:
print(self.GetActiveTabs())
# Removes all tabs
if id == BUTTON_FLUSH_ALL:
self.FlushAllTabs()
# Adds a new Tab to the quicktab
if id == BUTTON_ADD:
cg3 = CustomGroup(["This is the third Tab"])
self.AppendTab("Third Tab", cg3, True)
# Removes the first tab of the quicktab
if id == BUTTON_REMOVE:
self.RemoveTab("First Tab")
if id == ID_LOADDEFAULT_MAT_ASIGN:
self.Populate()
return True
def Populate(self):
doc = c4d.documents.GetActiveDocument()
directory, _ = os.path.split(__file__)
poart_json_file = os.path.join(directory, "default_asignment.json")
material_ids, materials_dict = read_parts_json(poart_json_file)
self.FlushAllTabs() # clear the GUI
print( str( material_ids))
print("-"*80)
for material_id in materials_dict:
part_list = materials_dict[material_id]
#print( str(material_id), str(part_list) )
### Tabs
##################################################
tab_Content = CustomGroup(str(material_id), part_list)
self.AppendTab(str(material_id), tab_Content, False)
print("-"*80)
c4d.EventAdd()
# Main function
def main():
if DEBUG:
c4d.CallCommand(13957) # clear console
# Initializes a QuickTabDialogExample Dialog
diag = MyDialog()
# Opens the Dialog in modal mode
diag.Open(dlgtype=c4d.DLG_TYPE_MODAL_RESIZEABLE, defaultw=400, defaulth=400)
# Execute main()
if __name__ == '__main__':
main()
Dear Developpers,
I am trying to implement a Quicktab Gui into my Plugin. While i get some User interface that is somehow usable, I see some content getting mixed up in the gui after multi selecting some tabs.
It might be a simple thing as an ID not matching, but I am a little bit lost hence its basically just the SDK example i use.
as you can see FFFF is deselected but shown
DDDD and CCCC are switched up ....
and no its not just a row shuffle .. deselecting DDD hides CCC
deselecting more result in more gui disintegration ...
Can you confirm that applying more content results in some weird stuff? Or what is your hunch .,... where to look ?
Thank you for your time.
cheers mogh
only little was added .... rest is basically the SDK example ....
class CustomGroup(c4d.gui.SubDialog):
"""A SubDialog to display the passed string, its used as example for the actual content of a Tab"""
def __init__(self, material, parts):
self._material = material
self._parts = '\n'.join(parts)
def CreateLayout(self):
self.AddStaticText(CUSTOM_GROUP_ID_TEXT_BASE + 1 , flags=c4d.BFH_LEFT | c4d.BFV_TOP | c4d.BFH_FIT | c4d.BFV_FIT, name=self._material)
self.AddStaticText(CUSTOM_GROUP_ID_TEXT_BASE + 2 , flags=c4d.BFH_LEFT | c4d.BFV_TOP | c4d.BFH_FIT | c4d.BFV_FIT, name=CUSTOM_GROUP_ID_TEXT_BASE)
self.AddMultiLineEditText(CUSTOM_GROUP_ID_TEXT_BASE + 3, flags=c4d.BFH_LEFT | c4d.BFV_TOP | c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, initw=0, inith=0, style=c4d.DR_MULTILINE_WORDWRAP)
self.SetString(CUSTOM_GROUP_ID_TEXT_BASE + 3, value=self._parts)
#for i, parts in enumerate(self._parts):
# self.AddStaticText(CUSTOM_GROUP_ID_TEXT_BASE + i, c4d.BFH_SCALEFIT, name=parts)
return True
def Populate(self):
doc = c4d.documents.GetActiveDocument()
directory, _ = os.path.split(__file__)
poart_json_file = os.path.join(directory, "default_asignment.json")
material_ids, materials_dict = read_parts_json(poart_json_file)
self.FlushAllTabs() # clear the GUI
print( str( material_ids))
print("-"*80)
for material_id in materials_dict:
part_list = materials_dict[material_id]
#print( str(material_id), str(part_list) )
### Tabs
##################################################
tab_Content = CustomGroup(str(material_id), part_list)
self.AppendTab(str(material_id), tab_Content, False)Oh my, this is horrible 
...
cheers mogh
Thanks, @ferdinand
Yes seems intended but could be troublesome if you use mograph / redshift object color to drive something ?
C4D Version : 2023.1.2
A solution to guide the user could be to disable the object color when set to "Render Instance" , but from a UX standpoint I am not a fan of taking away control from the user.
thanks for taking it to CS
kind regards mogh
Hi @ferdinand ,
I might not come up with a striped down code quickly, I can tell you that i render scenes without any materials just display color ... everything set to linear 32 bit as far as I could cobble together myself ... nothing special because I code R20 and 2023.
I suspected something like:
Render Instance is accessed in memory (and the shifted because of internals) and then rendered wrong with the color of the original polygon.
"Classic" Instance - Polygon is copied into place and inherits the correct color from the Classic Instance
Before fixing my code with changing all render instances to classic and back - I also could not reproduce the issue with generic cubes ....
from memory the color of one of the checked instances shifted from (0.016, 0.56, 0.4) to (0.016, 0.56, 0.8) pixel readout was 0.7999999999999999999324324 ... see picture
Edit:
here is a Picture with "Classic" Instance and Render instance Display Color renderings ...
kind regards
Hi again.
As mentioned in my other Post it seems Render Instances Produce "shifted" colors when measured as pixel value in Code as also in the Picture viewer.
Is this a limitation of render instances ?
When I switch the render Instances to "Classic" Instances the produce the correct color in the rendering and in pixel readout from code ...
kind regards
mogh
Thank you Ferdinand for your time,
and also providing a high / low level solution.
As far as I can tell it works all as intended - my code now results in clean colors "measured". (in lowlvl R20 and highlvl 2023)
I found a small discrepancy with render instances but that's another topic.
Cheers,
mogh
Yes a folding button would be cool,
... or another Code block option for the future where the responsible poster can dump lots of code and it will not show in searches ...
anyway I feel your pain even if its sometime good to see if its relevant to your search ...