closes #7249: for stairs, change the first/last tread lengths to less than the typical tread run. And even go to zero, whereby removing the tread altogether.

theoryshaw · theoryshaw · commit f52aafdd6ade · 2025-10-14T21:53:22.000-05:00
diff --git a/src/bonsai/bonsai/bim/module/model/prop.py b/src/bonsai/bonsai/bim/module/model/prop.py
@@ -373,7 +373,12 @@ def validate_nosing_value(self, context: bpy.types.Context) -> None:
         if self.stair_type != "WOOD/STEEL" and self.nosing_length < 0:
             self["nosing_length"] = 0
 
-    non_si_units_props = ("is_editing", "number_of_treads", "has_top_nib", "stair_type")
+    def update_custom_tread_lock(self, context: bpy.types.Context) -> None:
+        """When lock is enabled, sync custom treads with tread_run"""
+        if self.custom_tread_lock:
+            self["custom_first_last_tread_run"] = (self.tread_run, self.tread_run)
+
+    non_si_units_props = ("is_editing", "number_of_treads", "has_top_nib", "stair_type", "custom_tread_lock")
 
     is_editing: bpy.props.BoolProperty(default=False)
     width: bpy.props.FloatProperty(name="Width", default=1.2, soft_min=0.01, subtype="DISTANCE")
@@ -407,6 +412,12 @@ def validate_nosing_value(self, context: bpy.types.Context) -> None:
         default="CONCRETE",
         update=validate_nosing_value,
     )
+    custom_tread_lock: bpy.props.BoolProperty(
+        name="Lock First/Last Treads to Tread Run",
+        description="When enabled, first and last treads automatically use the Tread Run value",
+        default=True,
+        update=update_custom_tread_lock,
+    )
     custom_first_last_tread_run: bpy.props.FloatVectorProperty(
         name="Custom First / Last Treads Widths",
         description='Specify custom first / last treads widths, different from the general "Tread Run". Leave 0 to disable.',
@@ -442,6 +453,7 @@ def validate_nosing_value(self, context: bpy.types.Context) -> None:
         top_slab_depth: float
         has_top_nib: bool
         stair_type: str
+        custom_tread_lock: bool
         custom_first_last_tread_run: tuple[float, float]
         nosing_length: float
         nosing_depth: float
@@ -480,17 +492,38 @@ def get_props_kwargs(self, convert_to_project_units=False, stair_type=None):
             }
             stair_kwargs.update(generic_props)
 
-        # defined here to appear last in UI
-        stair_kwargs["custom_first_last_tread_run"] = self.custom_first_last_tread_run
+        # If locked, use tread_run for both first and last treads
+        if self.custom_tread_lock:
+            stair_kwargs["custom_first_last_tread_run"] = (self.tread_run, self.tread_run)
+        else:
+            stair_kwargs["custom_first_last_tread_run"] = self.custom_first_last_tread_run
 
         if not convert_to_project_units:
             return stair_kwargs
 
         stair_kwargs = tool.Model.convert_data_to_project_units(stair_kwargs, self.non_si_units_props)
         return stair_kwargs
+    
+    def get_props_kwargs_for_ifc_export(self, convert_to_project_units=False, stair_type=None):
+        """Get props including custom_tread_lock for saving to IFC"""
+        stair_kwargs = self.get_props_kwargs(convert_to_project_units, stair_type)
+        # Add the lock state for IFC storage (after getting base kwargs to avoid passing to generate function)
+        stair_kwargs["custom_tread_lock"] = self.custom_tread_lock
+        return stair_kwargs
 
     def set_props_kwargs_from_ifc_data(self, kwargs):
         kwargs = tool.Model.convert_data_to_si_units(kwargs, self.non_si_units_props)
+        
+        # Determine lock state based on whether custom treads match tread_run
+        # If custom_tread_lock wasn't saved (old files), infer it from the data
+        if "custom_tread_lock" not in kwargs:
+            custom_treads = kwargs.get("custom_first_last_tread_run", (0.0, 0.0))
+            tread_run = kwargs.get("tread_run", 0.3)
+            # Lock is off if either custom tread differs from tread_run and is not 0
+            kwargs["custom_tread_lock"] = not any(
+                ct != 0.0 and ct != tread_run for ct in custom_treads
+            )
+        
         for prop_name in kwargs:
             setattr(self, prop_name, kwargs[prop_name])
 
diff --git a/src/bonsai/bonsai/bim/module/model/stair.py b/src/bonsai/bonsai/bim/module/model/stair.py
@@ -188,7 +188,8 @@ def _execute(self, context):
         props = tool.Model.get_stair_props(obj)
         ifc_file = tool.Ifc.get()
 
-        stair_data = props.get_props_kwargs(convert_to_project_units=True)
+        # Use the special method that includes custom_tread_lock for IFC storage
+        stair_data = props.get_props_kwargs_for_ifc_export(convert_to_project_units=True)
         pset = tool.Pset.get_element_pset(element, "BBIM_Stair")
         if not pset:
             pset = ifcopenshell.api.pset.add_pset(ifc_file, product=element, name="BBIM_Stair")
@@ -241,7 +242,8 @@ def _execute(self, context):
         assert element
         props = tool.Model.get_stair_props(obj)
 
-        data = props.get_props_kwargs(convert_to_project_units=True)
+        # Use the special method that includes custom_tread_lock for IFC storage
+        data = props.get_props_kwargs_for_ifc_export(convert_to_project_units=True)
         props.is_editing = False
         regenerate_stair_mesh(obj)
         tool.Model.add_body_representation(obj)
diff --git a/src/bonsai/bonsai/bim/module/model/ui.py b/src/bonsai/bonsai/bim/module/model/ui.py
@@ -302,13 +302,36 @@ def draw(self, context):
                 row.operator("bim.cancel_editing_stair", icon="CANCEL", text="")
                 row = self.layout.row(align=True)
                 for prop_name in props.get_props_kwargs():
+                    # Skip custom_tread_lock as it's handled with custom_first_last_tread_run
+                    if prop_name == "custom_tread_lock":
+                        continue
+                    
                     prop_value = getattr(props, prop_name)
-                    if isinstance(prop_value, Iterable) and not isinstance(prop_value, str):
+                    
+                    # Special handling for custom_first_last_tread_run
+                    if prop_name == "custom_first_last_tread_run":
+                        # Draw the lock toggle
+                        row_lock = self.layout.row(align=True)
+                        lock_text = "Lock First/Last Treads" if not props.custom_tread_lock else "Unlock First/Last Treads"
+                        row_lock.prop(
+                            props,
+                            "custom_tread_lock",
+                            text=lock_text,
+                            icon="LOCKED" if props.custom_tread_lock else "UNLOCKED",
+                        )
+                        
+                        # Only show the custom values input if unlocked
+                        if not props.custom_tread_lock:
+                            prop_readable_name = props.bl_rna.properties[prop_name].name
+                            self.layout.label(text=f"{prop_readable_name}:")
+                            self.layout.prop(props, prop_name, text="")
+                    elif isinstance(prop_value, Iterable) and not isinstance(prop_value, str):
                         prop_readable_name = props.bl_rna.properties[prop_name].name
                         self.layout.label(text=f"{prop_readable_name}:")
                         self.layout.prop(props, prop_name, text="")
                     else:
                         self.layout.prop(props, prop_name)
+                    
                     if prop_name == "height":  # Weak but we just want to insert this inside props drawing
                         row_length = self.layout.row(align=True)
                         row_length.prop(props, "total_length_target")
diff --git a/src/bonsai/bonsai/tool/model.py b/src/bonsai/bonsai/tool/model.py
@@ -1399,7 +1399,6 @@ def generate_stair_2d_profile(
 
         number_of_risers = number_of_treads + 1
         tread_rise = height / number_of_risers
-        custom_tread_run = any(run != 0 for run in custom_first_last_tread_run)
         nosing_overlap = max(nosing_length, 0)
         nosing_tread_gap = -min(nosing_length, 0)
         nosing_overlap_offset = -V_(nosing_overlap, 0)
@@ -1430,29 +1429,40 @@ def define_generic_stair_treads():
             default_tread_offset = Vector([tread_run, tread_rise])
 
             def get_tread_data(i):
-                if custom_tread_run:
-                    current_tread_run = None
-                    if i == 0:
-                        current_tread_run = custom_first_last_tread_run[0]
-                    elif i == number_of_risers - 1:
-                        current_tread_run = custom_first_last_tread_run[1]
-
-                    if current_tread_run:
-                        tread_offset = default_tread_offset.copy()
-                        tread_offset.x = current_tread_run
-                        tread_verts = deepcopy(default_tread_verts)
-                        tread_verts[-1].x = current_tread_run
-                        return tread_offset, tread_verts
+                # Check if this is first or last tread with custom run
+                current_tread_run = None
+                if i == 0 and custom_first_last_tread_run[0] is not None:
+                    current_tread_run = custom_first_last_tread_run[0]
+                elif i == number_of_risers - 1 and custom_first_last_tread_run[1] is not None:
+                    current_tread_run = custom_first_last_tread_run[1]
+
+                if current_tread_run is not None:
+                    tread_offset = default_tread_offset.copy()
+                    tread_offset.x = current_tread_run
+                    
+                    # Handle zero-width treads
+                    if current_tread_run == 0:
+                        # For zero width, just return vertical offset with no horizontal tread
+                        return tread_offset, ()
+                    
+                    tread_verts = deepcopy(default_tread_verts)
+                    tread_verts[-1].x = current_tread_run
+                    return tread_offset, tread_verts
+                    
                 return default_tread_offset, default_tread_verts
 
             # treads
             current_offset = V_(0, 0)
             for i in range(number_of_risers):
                 last_vert_i = len(vertices) - 1
                 tread_offset, tread_verts = get_tread_data(i)
-                current_tread_verts = [v + current_offset for v in tread_verts]
-                edges.extend(default_tread_edges + last_vert_i)
-                vertices.extend(current_tread_verts)
+                
+                # Skip adding vertices/edges for zero-width treads
+                if tread_verts:
+                    current_tread_verts = [v + current_offset for v in tread_verts]
+                    edges.extend(default_tread_edges + last_vert_i)
+                    vertices.extend(current_tread_verts)
+                
                 current_offset += tread_offset
 
         if stair_type == "WOOD/STEEL":
@@ -1467,35 +1477,47 @@ def get_tread_verts(*args, **kwargs):
             default_tread_offset = V_(tread_run + nosing_tread_gap, tread_rise)
 
             def get_tread_data(i):
-                if custom_tread_run:
-                    current_tread_run = None
-                    if i == 0 and custom_first_last_tread_run[0] != 0:
-                        current_tread_run = custom_first_last_tread_run[0]
-                    elif i == number_of_risers - 1 and custom_first_last_tread_run[1] != 0:
-                        current_tread_run = custom_first_last_tread_run[1]
-
-                    if current_tread_run:
-                        tread_offset = default_tread_offset.copy()
-                        tread_offset.x = current_tread_run + nosing_tread_gap
-                        tread_verts = get_tread_verts(size=V_(current_tread_run + nosing_overlap, tread_depth))
-                        return tread_offset, tread_verts
+                # Check if this is first or last tread with custom run
+                current_tread_run = None
+                if i == 0 and custom_first_last_tread_run[0] is not None:
+                    current_tread_run = custom_first_last_tread_run[0]
+                elif i == number_of_risers - 1 and custom_first_last_tread_run[1] is not None:
+                    current_tread_run = custom_first_last_tread_run[1]
+
+                if current_tread_run is not None:
+                    tread_offset = default_tread_offset.copy()
+                    tread_offset.x = current_tread_run + nosing_tread_gap
+                    
+                    # Handle zero-width treads
+                    if current_tread_run == 0:
+                        return tread_offset, ()
+                    
+                    tread_verts = get_tread_verts(size=V_(current_tread_run + nosing_overlap, tread_depth))
+                    return tread_offset, tread_verts
+                    
                 return default_tread_offset, default_tread_verts
 
             # each tread is a separate shape
             cur_offset = V_(0, 0)
+            tread_index = 0
             for i in range(number_of_risers):
                 tread_offset, tread_verts = get_tread_data(i)
-                cur_trade_shape = [v + cur_offset + nosing_overlap_offset for v in tread_verts]
-                vertices.extend(cur_trade_shape)
-
-                cur_vertex = i * 4
-                verts_to_add = (
-                    (cur_vertex, cur_vertex + 1),
-                    (cur_vertex + 1, cur_vertex + 2),
-                    (cur_vertex + 2, cur_vertex + 3),
-                    (cur_vertex + 3, cur_vertex),
-                )
-                edges.extend(verts_to_add)
+                
+                # Skip adding vertices/edges for zero-width treads
+                if tread_verts:
+                    cur_trade_shape = [v + cur_offset + nosing_overlap_offset for v in tread_verts]
+                    vertices.extend(cur_trade_shape)
+
+                    cur_vertex = tread_index * 4
+                    verts_to_add = (
+                        (cur_vertex, cur_vertex + 1),
+                        (cur_vertex + 1, cur_vertex + 2),
+                        (cur_vertex + 2, cur_vertex + 3),
+                        (cur_vertex + 3, cur_vertex),
+                    )
+                    edges.extend(verts_to_add)
+                    tread_index += 1
+                
                 cur_offset += tread_offset
 
         elif stair_type == "GENERIC":
diff --git a/src/bonsai/test/tool/test_model.py b/src/bonsai/test/tool/test_model.py
