Update app/materials_library.py

app/materials_library.py

@@ -1,8 +1,8 @@
 """
-BuildSustain - Material Library Module (Restructured)
+BuildSustain - Material Library Module
 
 This module handles the material library functionality of the BuildSustain application,
-allowing users to manage building materials and fenestrations (windows, doors, skylights).
+allowing users to manage building materials and fenestrations (windows, skylights).
 It provides both predefined library materials and the ability to create custom materials.
 
 Developed by: Dr Majed Abuseif, Deakin University
@@ -16,6 +16,7 @@ import json
 import logging
 import uuid
 from typing import Dict, List, Any, Optional, Tuple, Union
+from enum import Enum
 
 # Import default data from centralized module
 from app.m_c_data import SAMPLE_MATERIALS, SAMPLE_FENESTRATIONS
@@ -36,11 +37,119 @@ MATERIAL_CATEGORIES = [
 
 FENESTRATION_TYPES = [
     "Window",
-    "Door",
     "Skylight",
     "Custom"
 ]
 
+class MaterialCategory(Enum):
+    MASONRY = "Masonry"
+    INSULATION = "Insulation"
+    METAL = "Metal"
+    WOOD = "Wood"
+    FINISHING = "Finishing"
+    CUSTOM = "Custom"
+
+class Material:
+    def __init__(self, name: str, category: MaterialCategory, conductivity: float, density: float,
+                 specific_heat: float, default_thickness: float, embodied_carbon: float,
+                 absorptivity: float, price: float, emissivity: float, is_library: bool = True):
+        self.name = name
+        self.category = category
+        self.conductivity = conductivity
+        self.density = density
+        self.specific_heat = specific_heat
+        self.default_thickness = default_thickness
+        self.embodied_carbon = embodied_carbon
+        self.absorptivity = absorptivity
+        self.price = price
+        self.emissivity = emissivity
+        self.is_library = is_library
+
+    def get_thermal_mass(self):
+        class ThermalMass:
+            def __init__(self, value): self.value = value
+        return ThermalMass(self.density * self.specific_heat * self.default_thickness)
+
+    def get_u_value(self):
+        return self.conductivity / self.default_thickness if self.default_thickness > 0 else 0.0
+
+class GlazingMaterial:
+    def __init__(self, name: str, shgc: float, u_value: float, h_o: float, is_library: bool = True):
+        self.name = name
+        self.shgc = shgc
+        self.u_value = u_value
+        self.h_o = h_o
+        self.is_library = is_library
+
+class MaterialLibrary:
+    def __init__(self):
+        self.library_materials = {}
+        self.library_glazing_materials = {}
+
+    def to_dataframe(self, material_type: str, **kwargs):
+        if material_type == "materials":
+            project_materials = kwargs.get("project_materials", {})
+            data = [
+                {
+                    "Name": m.name,
+                    "Category": m.category.value,
+                    "Thermal Conductivity (W/m·K)": m.conductivity,
+                    "Density (kg/m³)": m.density,
+                    "Specific Heat (J/kg·K)": m.specific_heat,
+                    "Default Thickness (m)": m.default_thickness,
+                    "Embodied Carbon (kgCO₂e/kg)": m.embodied_carbon,
+                    "absorptivity": m.absorptivity,
+                    "Price (USD/m²)": m.price,
+                    "Emissivity": m.emissivity
+                }
+                for m in project_materials.values()
+            ]
+            return pd.DataFrame(data)
+        elif material_type == "glazing":
+            project_glazing_materials = kwargs.get("project_glazing_materials", {})
+            data = [
+                {
+                    "Name": g.name,
+                    "SHGC": g.shgc,
+                    "U-Value (W/m²·K)": g.u_value,
+                    "Exterior Conductance (W/m²·K)": g.h_o
+                }
+                for g in project_glazing_materials.values()
+            ]
+            return pd.DataFrame(data)
+        return pd.DataFrame()
+
+    def add_project_material(self, material: Material, project_materials: Dict):
+        try:
+            if material.name in project_materials or material.name in self.library_materials:
+                return False, f"Material '{material.name}' already exists."
+            project_materials[material.name] = material
+            return True, f"Material '{material.name}' added successfully!"
+        except Exception as e:
+            return False, f"Error adding material: {str(e)}"
+
+    def edit_project_material(self, original_name: str, new_material: Material, project_materials: Dict, components: Dict):
+        try:
+            if original_name not in project_materials:
+                return False, f"Material '{original_name}' not found."
+            if new_material.name != original_name and (new_material.name in project_materials or new_material.name in self.library_materials):
+                return False, f"Material '{new_material.name}' already exists."
+            project_materials[new_material.name] = new_material
+            if new_material.name != original_name:
+                del project_materials[original_name]
+            return True, f"Material '{new_material.name}' updated successfully!"
+        except Exception as e:
+            return False, f"Error editing material: {str(e)}"
+
+    def delete_project_material(self, name: str, project_materials: Dict, components: Dict):
+        try:
+            if name not in project_materials:
+                return False, f"Material '{name}' not found."
+            del project_materials[name]
+            return True, f"Material '{name}' deleted successfully!"
+        except Exception as e:
+            return False, f"Error deleting material: {str(e)}"
+
 def display_materials_page():
     """
     Display the material library page.
@@ -48,721 +157,679 @@ def display_materials_page():
     """
     st.title("Material Library")
     st.write("Manage building materials and fenestrations for thermal analysis.")
-    
-    # Display help information in an expandable section
-    with st.expander("Help & Information"):
-        display_materials_help()
-    
+
+    # CSS for box heights, scrolling, and visual appeal
+    st.markdown("""
+    <style>
+    .box-container {
+        border: 1px solid #e0e0e0;
+        border-radius: 8px;
+        padding: 10px;
+        background-color: #f9f9f9;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        overflow-y: auto;
+        scrollbar-width: thin;
+    }
+    .library-box {
+        max-height: 250px;
+    }
+    .project-box {
+        max-height: 250px;
+    }
+    .editor-box {
+        min-height: 540px;
+    }
+    .stButton>button {
+        width: 100%;
+        font-size: 12px;
+        padding: 5px;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
     # Initialize materials and fenestrations in session state if not present
     initialize_materials_and_fenestrations()
-    
-    # Check if rerun is pending
-    if 'materials_rerun_pending' not in st.session_state:
-        st.session_state.materials_rerun_pending = False
-    
-    if st.session_state.materials_rerun_pending:
+
+    # Check for rerun trigger
+    if st.session_state.get("materials_rerun_pending", False):
         st.session_state.materials_rerun_pending = False
         st.rerun()
-    
-    # Create tabs for materials and fenestrations
+
+    # Initialize session state
+    if 'active_tab' not in st.session_state:
+        st.session_state.active_tab = "Materials"
+    if 'material_action' not in st.session_state:
+        st.session_state.material_action = {"action": None, "id": None}
+    if 'fenestration_action' not in st.session_state:
+        st.session_state.fenestration_action = {"action": None, "id": None}
+    if 'materials_rerun_pending' not in st.session_state:
+        st.session_state.materials_rerun_pending = False
+    if 'material_form_state' not in st.session_state:
+        st.session_state.material_form_state = {}
+    if 'fenestration_form_state' not in st.session_state:
+        st.session_state.fenestration_form_state = {}
+
+    # Create tabs and set active tab
     tab1, tab2 = st.tabs(["Materials", "Fenestrations"])
-    
-    # Materials tab
+    active_tab = st.session_state.active_tab
     with tab1:
-        display_materials_tab()
-    
-    # Fenestrations tab
+        if active_tab == "Materials":
+            st.session_state.active_tab = "Materials"
     with tab2:
-        display_fenestrations_tab()
-    
+        if active_tab == "Fenestrations":
+            st.session_state.active_tab = "Fenestrations"
+
+    # Initialize material library
+    material_library = MaterialLibrary()
+    material_library.library_materials = {
+        k: Material(
+            name=m["name"],
+            category=MaterialCategory(m["category"]),
+            conductivity=m["thermal_conductivity"],
+            density=m["density"],
+            specific_heat=m["specific_heat"],
+            default_thickness=m["thickness_range"]["default"],
+            embodied_carbon=m["embodied_carbon"],
+            absorptivity=m.get("absorptivity", 0.6),
+            price=m["cost"]["material"],
+            emissivity=m.get("emissivity", 0.9),
+            is_library=True
+        ) for k, m in st.session_state.project_data["materials"]["library"].items()
+    }
+    material_library.library_glazing_materials = {
+        k: GlazingMaterial(
+            name=f["name"],
+            shgc=f["shgc"] if "shgc" in f else 0.7,
+            u_value=f["u_value"],
+            h_o=f.get("h_o", 23.0),
+            is_library=True
+        ) for k, f in st.session_state.project_data["fenestrations"]["library"].items()
+        if f["type"] in ["Window", "Skylight"]
+    }
+
+    with tab1:
+        display_materials_tab(material_library)
+    with tab2:
+        display_fenestrations_tab(material_library)
+
     # Navigation buttons
     col1, col2 = st.columns(2)
-    
     with col1:
-        if st.button("Back to Climate Data", key="back_to_climate"):
+        if st.button("Back to Climate Data", key="material_back_to_climate"):
             st.session_state.current_page = "Climate Data"
             st.rerun()
-    
     with col2:
-        if st.button("Continue to Construction", key="continue_to_construction"):
+        if st.button("Continue to Construction", key="material_to_components"):
             st.session_state.current_page = "Construction"
             st.rerun()
 
 def initialize_materials_and_fenestrations():
     """Initialize materials and fenestrations in session state if not present."""
-    # Initialize materials
+    if "project_data" not in st.session_state:
+        st.session_state.project_data = {}
     if "materials" not in st.session_state.project_data:
         st.session_state.project_data["materials"] = {
             "library": dict(SAMPLE_MATERIALS),
             "project": {}
         }
-    
-    # Initialize fenestrations
     if "fenestrations" not in st.session_state.project_data:
         st.session_state.project_data["fenestrations"] = {
             "library": dict(SAMPLE_FENESTRATIONS),
             "project": {}
         }
 
-def display_materials_tab():
+def display_materials_tab(material_library: MaterialLibrary):
     """Display the materials tab content with two-column layout."""
-    # Split the display into two columns
     col1, col2 = st.columns([3, 2])
-    
     with col1:
-        st.subheader("Saved Materials")
-        
-        # Get materials from session state
-        materials_library = st.session_state.project_data["materials"]["library"]
-        materials_project = st.session_state.project_data["materials"]["project"]
-        
-        # Display library materials
-        if materials_library:
-            st.write("**Library Materials:**")
-            display_materials_table(materials_library, "library")
-        
-        # Display project materials
-        if materials_project:
-            st.write("**Project Materials:**")
-            display_materials_table(materials_project, "project")
-        
-        if not materials_library and not materials_project:
-            st.write("No materials available.")
-    
+        st.subheader("Materials")
+        # Category filter
+        filter_options = ["All", "None"] + MATERIAL_CATEGORIES
+        category = st.selectbox("Filter by Category", filter_options, key="material_filter")
+
+        st.subheader("Library Materials")
+        with st.container():
+            library_materials = list(material_library.library_materials.values())
+            if category == "None":
+                library_materials = []
+            elif category != "All":
+                library_materials = [m for m in library_materials if m.category.value == category]
+            cols = st.columns([2, 1, 1, 1, 1])
+            cols[0].write("**Name**")
+            cols[1].write("**Thermal Mass**")
+            cols[2].write("**U-Value (W/m²·K)**")
+            cols[3].write("**Preview**")
+            cols[4].write("**Copy**")
+            for material in library_materials:
+                cols = st.columns([2, 1, 1, 1, 1])
+                cols[0].write(material.name)
+                cols[1].write(f"{material.get_thermal_mass().value:.0f}")
+                cols[2].write(f"{material.get_u_value():.3f}")
+                if cols[3].button("Preview", key=f"preview_lib_mat_{material.name}"):
+                    if st.session_state.get("rerun_trigger") != f"preview_mat_{material.name}":
+                        st.session_state.rerun_trigger = f"preview_mat_{material.name}"
+                        st.session_state.material_editor = {
+                            "name": material.name,
+                            "category": material.category.value,
+                            "conductivity": material.conductivity,
+                            "density": material.density,
+                            "specific_heat": material.specific_heat,
+                            "default_thickness": material.default_thickness,
+                            "embodied_carbon": material.embodied_carbon,
+                            "absorptivity": material.absorptivity,
+                            "price": material.price,
+                            "emissivity": material.emissivity,
+                            "is_edit": False,
+                            "edit_source": "library"
+                        }
+                        st.session_state.material_form_state = {
+                            "name": material.name,
+                            "category": material.category.value,
+                            "conductivity": material.conductivity,
+                            "density": material.density,
+                            "specific_heat": material.specific_heat,
+                            "default_thickness": material.default_thickness,
+                            "embodied_carbon": material.embodied_carbon,
+                            "absorptivity": material.absorptivity,
+                            "price": material.price,
+                            "emissivity": material.emissivity
+                        }
+                        st.session_state.active_tab = "Materials"
+                if cols[4].button("Copy", key=f"copy_lib_mat_{material.name}"):
+                    new_name = f"{material.name}_Project"
+                    counter = 1
+                    while new_name in st.session_state.project_data["materials"]["project"] or new_name in st.session_state.project_data["materials"]["library"]:
+                        new_name = f"{material.name}_Project_{counter}"
+                        counter += 1
+                    new_material = Material(
+                        name=new_name,
+                        category=material.category,
+                        conductivity=material.conductivity,
+                        density=material.density,
+                        specific_heat=material.specific_heat,
+                        default_thickness=material.default_thickness,
+                        embodied_carbon=material.embodied_carbon,
+                        absorptivity=material.absorptivity,
+                        price=material.price,
+                        emissivity=material.emissivity,
+                        is_library=False
+                    )
+                    success, message = material_library.add_project_material(new_material, st.session_state.project_data["materials"]["project"])
+                    if success:
+                        st.success(message)
+                        st.session_state.materials_rerun_pending = True
+                    else:
+                        st.error(message)
+
+        st.subheader("Project Materials")
+        with st.container():
+            if st.session_state.project_data["materials"]["project"]:
+                cols = st.columns([2, 1, 1, 1, 1])
+                cols[0].write("**Name**")
+                cols[1].write("**Thermal Mass**")
+                cols[2].write("**U-Value (W/m²·K)**")
+                cols[3].write("**Edit**")
+                cols[4].write("**Delete**")
+                for material in st.session_state.project_data["materials"]["project"].values():
+                    cols = st.columns([2, 1, 1, 1, 1])
+                    cols[0].write(material.name)
+                    cols[1].write(f"{material.get_thermal_mass().value:.0f}")
+                    cols[2].write(f"{material.get_u_value():.3f}")
+                    if cols[3].button("Edit", key=f"edit_proj_mat_{material.name}"):
+                        if st.session_state.get("rerun_trigger") != f"edit_mat_{material.name}"):
+                            st.session_state.rerun_trigger = f"edit_mat_{material.name}"
+                            st.session_state.material_editor = {
+                                "name": material.name,
+                                "category": material.category.value,
+                                "conductivity": material.conductivity,
+                                "density": material.density,
+                                "specific_heat": material.specific_heat,
+                                "default_thickness": material.default_thickness,
+                                "embodied_carbon": material.embodied_carbon,
+                                "absorptivity": material.absorptivity,
+                                "price": material.price,
+                                "emissivity": material.emissivity,
+                                "is_edit": True,
+                                "edit_source": "project",
+                                "original_name": material.name
+                            }
+                            st.session_state.material_form_state = {
+                                "name": material.name,
+                                "category": material.category.value,
+                                "conductivity": material.conductivity,
+                                "density": material.density,
+                                "specific_heat": material.specific_heat,
+                                "default_thickness": material.default_thickness,
+                                "embodied_carbon": material.embodied_carbon,
+                                "absorptivity": material.absorptivity,
+                                "price": material.price,
+                                "emissivity": material.emissivity
+                            }
+                            st.session_state.active_tab = "Materials"
+                    if cols[4].button("Delete", key=f"delete_proj_mat_{material.name}"):
+                        success, message = material_library.delete_project_material(
+                            material.name, st.session_state.project_data["materials"]["project"], st.session_state.get("components", {})
+                        )
+                        if success:
+                            st.success(message)
+                            st.session_state.materials_rerun_pending = True
+                        else:
+                            st.error(message)
+            else:
+                st.write("No project materials added.")
+
+        st.subheader("Project Materials")
+        try:
+            material_df = material_library.to_dataframe("materials", project_materials=st.session_state.project_data["materials"]["project"])
+            if not material_df.empty:
+                st.dataframe(material_df, use_container_width=True)
+            else:
+                st.write("No project materials to display.")
+        except Exception as e:
+            st.error(f"Error displaying project materials: {str(e)}")
+            st.write("No project materials to display.")
+
     with col2:
         st.subheader("Material Editor/Creator")
-        
-        # Check if we have an editor state for materials
-        if "material_editor" not in st.session_state:
-            st.session_state.material_editor = {}
-        
-        # Check if we have an action state for materials
-        if "material_action" not in st.session_state:
-            st.session_state.material_action = {"action": None, "id": None}
-        
-        # Display the material editor form
-        with st.form("material_editor_form", clear_on_submit=True):
-            editor_state = st.session_state.get("material_editor", {})
-            is_edit = editor_state.get("is_edit", False)
-            
-            # Material name
-            name = st.text_input(
-                "Material Name",
-                value=editor_state.get("name", ""),
-                help="Enter a unique name for this material."
-            )
-            
-            # Material category
-            category = st.selectbox(
-                "Category",
-                MATERIAL_CATEGORIES,
-                index=MATERIAL_CATEGORIES.index(editor_state.get("category", MATERIAL_CATEGORIES[0])) if editor_state.get("category") in MATERIAL_CATEGORIES else 0,
-                help="Select the material category."
-            )
-            
-            # Thermal properties
-            st.write("**Thermal Properties:**")
-            thermal_conductivity = st.number_input(
-                "Thermal Conductivity (W/m·K)",
-                min_value=0.001,
-                max_value=500.0,
-                value=float(editor_state.get("thermal_conductivity", 0.1)),
-                format="%.3f",
-                help="Thermal conductivity of the material."
-            )
-            
-            density = st.number_input(
-                "Density (kg/m³)",
-                min_value=1.0,
-                max_value=10000.0,
-                value=float(editor_state.get("density", 1000.0)),
-                format="%.1f",
-                help="Density of the material."
-            )
-            
-            specific_heat = st.number_input(
-                "Specific Heat (J/kg·K)",
-                min_value=100.0,
-                max_value=5000.0,
-                value=float(editor_state.get("specific_heat", 1000.0)),
-                format="%.1f",
-                help="Specific heat capacity of the material."
-            )
-            
-            # Thickness range
-            st.write("**Thickness Range:**")
-            col_min, col_max, col_default = st.columns(3)
-            
-            with col_min:
-                min_thickness = st.number_input(
-                    "Min (m)",
-                    min_value=0.001,
-                    max_value=1.0,
-                    value=float(editor_state.get("min_thickness", 0.01)),
-                    format="%.3f",
-                    help="Minimum thickness for this material."
+        with st.container():
+            with st.form("material_editor_form", clear_on_submit=False):
+                editor_state = st.session_state.get("material_editor", {})
+                form_state = st.session_state.get("material_form_state", {
+                    "name": "",
+                    "category": "Insulation",
+                    "conductivity": 0.1,
+                    "density": 1000.0,
+                    "specific_heat": 1000.0,
+                    "default_thickness": 0.1,
+                    "embodied_carbon": 0.5,
+                    "absorptivity": 0.6,
+                    "price": 50.0,
+                    "emissivity": 0.925
+                })
+                is_edit = editor_state.get("is_edit", False)
+                original_name = editor_state.get("original_name", "")
+                name = st.text_input(
+                    "Material Name",
+                    value=form_state.get("name", editor_state.get("name", "")),
+                    help="Unique material identifier",
+                    key="material_name_input"
                 )
-            
-            with col_max:
-                max_thickness = st.number_input(
-                    "Max (m)",
-                    min_value=0.001,
-                    max_value=1.0,
-                    value=float(editor_state.get("max_thickness", 0.3)),
-                    format="%.3f",
-                    help="Maximum thickness for this material."
+                filter_category = st.session_state.get("material_filter", "All")
+                default_category = (filter_category if filter_category in MATERIAL_CATEGORIES
+                                  else editor_state.get("category", "Insulation"))
+                category_index = (MATERIAL_CATEGORIES.index(default_category)
+                                 if default_category in MATERIAL_CATEGORIES else 0)
+                category = st.selectbox(
+                    "Category",
+                    MATERIAL_CATEGORIES,
+                    index=category_index,
+                    help="Material type classification",
+                    key="material_category_input"
+                )
+                conductivity = st.number_input(
+                    "Thermal Conductivity (W/m·K)",
+                    min_value=0.01,
+                    value=form_state.get("conductivity", editor_state.get("conductivity", 0.1)),
+                    help="Heat flow ease",
+                    key="material_conductivity_input"
+                )
+                density = st.number_input(
+                    "Density (kg/m³)",
+                    min_value=1.0,
+                    value=form_state.get("density", editor_state.get("density", 1000.0)),
+                    help="Mass per volume",
+                    key="material_density_input"
+                )
+                specific_heat = st.number_input(
+                    "Specific Heat (J/kg·K)",
+                    min_value=100.0,
+                    value=form_state.get("specific_heat", editor_state.get("specific_heat", 1000.0)),
+                    help="Heat storage capacity",
+                    key="material_specific_heat_input"
                 )
-            
-            with col_default:
                 default_thickness = st.number_input(
-                    "Default (m)",
+                    "Default Thickness (m)",
                     min_value=0.001,
+                    value=form_state.get("default_thickness", editor_state.get("default_thickness", 0.1)),
+                    help="Typical layer thickness",
+                    key="material_default_thickness_input"
+                )
+                embodied_carbon = st.number_input(
+                    "Embodied Carbon (kgCO₂e/kg)",
+                    min_value=0.0,
+                    value=form_state.get("embodied_carbon", editor_state.get("embodied_carbon", 0.5)),
+                    help="Production carbon emissions",
+                    key="material_embodied_carbon_input"
+                )
+                absorptivity = st.number_input(
+                    "absorptivity",
+                    min_value=0.0,
                     max_value=1.0,
-                    value=float(editor_state.get("default_thickness", 0.1)),
-                    format="%.3f",
-                    help="Default thickness for this material."
+                    value=form_state.get("absorptivity", editor_state.get("absorptivity", 0.6)),
+                    help="Solar radiation absorbed",
+                    key="material_absorptivity_input"
                 )
-            
-            # Environmental and cost properties
-            st.write("**Environmental & Cost Properties:**")
-            embodied_carbon = st.number_input(
-                "Embodied Carbon (kgCO2e/kg)",
-                min_value=0.0,
-                max_value=50.0,
-                value=float(editor_state.get("embodied_carbon", 0.5)),
-                format="%.3f",
-                help="Embodied carbon per unit mass of material."
-            )
-            
-            col_mat_cost, col_lab_cost = st.columns(2)
-            
-            with col_mat_cost:
-                material_cost = st.number_input(
-                    "Material Cost ($/m³)",
+                price = st.number_input(
+                    "Price (USD/m²)",
                     min_value=0.0,
-                    max_value=10000.0,
-                    value=float(editor_state.get("material_cost", 100.0)),
-                    format="%.2f",
-                    help="Material cost per cubic meter."
+                    value=form_state.get("price", editor_state.get("price", 50.0)),
+                    help="Cost per area",
+                    key="material_price_input"
                 )
-            
-            with col_lab_cost:
-                labor_cost = st.number_input(
-                    "Labor Cost ($/m²)",
+                emissivity = st.number_input(
+                    "Emissivity",
                     min_value=0.0,
-                    max_value=1000.0,
-                    value=float(editor_state.get("labor_cost", 50.0)),
-                    format="%.2f",
-                    help="Labor cost per square meter."
+                    max_value=1.0,
+                    value=form_state.get("emissivity", editor_state.get("emissivity", 0.925)),
+                    help="Ratio of radiation emitted by the material (0.0 to 1.0)",
+                    key="material_emissivity_input"
                 )
-            
-            replacement_years = st.number_input(
-                "Replacement Years",
-                min_value=1,
-                max_value=100,
-                value=int(editor_state.get("replacement_years", 50)),
-                help="Expected lifespan before replacement."
-            )
-            
-            # Submit buttons
-            col1, col2 = st.columns(2)
-            with col1:
-                submit_label = "Update Material" if is_edit else "Add Material"
-                submit = st.form_submit_button(submit_label)
-            
-            with col2:
-                cancel = st.form_submit_button("Cancel")
-        
-        # Handle form submission
-        if submit:
-            # Validate inputs
-            if not name.strip():
-                st.error("Material name is required.")
-            elif min_thickness >= max_thickness:
-                st.error("Minimum thickness must be less than maximum thickness.")
-            elif default_thickness < min_thickness or default_thickness > max_thickness:
-                st.error("Default thickness must be between minimum and maximum thickness.")
-            else:
-                # Create material data
-                material_data = {
-                    "name": name.strip(),
-                    "type": "opaque",
-                    "category": category,
-                    "thermal_conductivity": thermal_conductivity,
-                    "density": density,
-                    "specific_heat": specific_heat,
-                    "thickness_range": {
-                        "min": min_thickness,
-                        "max": max_thickness,
-                        "default": default_thickness
-                    },
-                    "embodied_carbon": embodied_carbon,
-                    "cost": {
-                        "material": material_cost,
-                        "labor": labor_cost,
-                        "replacement_years": replacement_years
-                    },
-                    "description": f"Custom {category.lower()} material"
-                }
-                
-                # Check if editing or adding new
-                if is_edit and st.session_state.material_editor.get("edit_id"):
-                    # Update existing material
-                    edit_id = st.session_state.material_editor["edit_id"]
-                    edit_source = st.session_state.material_editor["edit_source"]
-                    
-                    if edit_source == "project":
-                        st.session_state.project_data["materials"]["project"][edit_id] = material_data
-                        st.success(f"Material '{name}' updated successfully!")
-                    else:
-                        st.error("Cannot edit library materials.")
-                else:
-                    # Add new material to project
-                    material_id = str(uuid.uuid4())
-                    st.session_state.project_data["materials"]["project"][material_id] = material_data
-                    st.success(f"Material '{name}' added successfully!")
-                
-                # Clear editor state
-                st.session_state.material_editor = {}
-                st.session_state.materials_rerun_pending = True
-                st.rerun()
-        
-        if cancel:
-            # Clear editor state
-            st.session_state.material_editor = {}
-            st.session_state.materials_rerun_pending = True
-            st.rerun()
 
-def display_fenestrations_tab():
+                if st.form_submit_button("Save Material"):
+                    action_id = str(uuid.uuid4())
+                    if st.session_state.material_action.get("id") != action_id:
+                        st.session_state.material_action = {"action": "save", "id": action_id}
+                        st.session_state.material_form_state = {
+                            "name": name,
+                            "category": category,
+                            "conductivity": conductivity,
+                            "density": density,
+                            "specific_heat": specific_heat,
+                            "default_thickness": default_thickness,
+                            "embodied_carbon": embodied_carbon,
+                            "absorptivity": absorptivity,
+                            "price": price,
+                            "emissivity": emissivity
+                        }
+                        if not name or not name.strip():
+                            st.error("Material name cannot be empty.")
+                        elif (name in st.session_state.project_data["materials"]["project"] or
+                              name in st.session_state.project_data["materials"]["library"]) and (not is_edit or name != original_name):
+                            st.error(f"Material '{name}' already exists.")
+                        else:
+                            try:
+                                new_material = Material(
+                                    name=name,
+                                    category=MaterialCategory(category),
+                                    conductivity=conductivity,
+                                    density=density,
+                                    specific_heat=specific_heat,
+                                    default_thickness=default_thickness,
+                                    embodied_carbon=embodied_carbon,
+                                    absorptivity=absorptivity,
+                                    price=price,
+                                    emissivity=emissivity,
+                                    is_library=False
+                                )
+                                if is_edit and editor_state.get("edit_source") == "project" and name == original_name:
+                                    success, message = material_library.edit_project_material(
+                                        original_name, new_material, st.session_state.project_data["materials"]["project"], st.session_state.get("components", {})
+                                    )
+                                else:
+                                    success, message = material_library.add_project_material(new_material, st.session_state.project_data["materials"]["project"])
+                                if success:
+                                    st.success(message)
+                                    st.session_state.material_editor = {}
+                                    st.session_state.material_form_state = {
+                                        "name": "",
+                                        "category": "Insulation",
+                                        "conductivity": 0.1,
+                                        "density": 1000.0,
+                                        "specific_heat": 1000.0,
+                                        "default_thickness": 0.1,
+                                        "embodied_carbon": 0.5,
+                                        "absorptivity": 0.6,
+                                        "price": 50.0,
+                                        "emissivity": 0.925
+                                    }
+                                    st.session_state.material_action = {"action": None, "id": None}
+                                    st.session_state.rerun_trigger = None
+                                    st.session_state.materials_rerun_pending = True
+                                else:
+                                    st.error(f"Failed to save material: {message}")
+                            except Exception as e:
+                                st.error(f"Error saving material: {str(e)}")
+
+def display_fenestrations_tab(material_library: MaterialLibrary):
     """Display the fenestrations tab content with two-column layout."""
-    # Split the display into two columns
     col1, col2 = st.columns([3, 2])
-    
     with col1:
-        st.subheader("Saved Fenestrations")
-        
-        # Get fenestrations from session state
-        fenestrations_library = st.session_state.project_data["fenestrations"]["library"]
-        fenestrations_project = st.session_state.project_data["fenestrations"]["project"]
-        
-        # Display library fenestrations
-        if fenestrations_library:
-            st.write("**Library Fenestrations:**")
-            display_fenestrations_table(fenestrations_library, "library")
-        
-        # Display project fenestrations
-        if fenestrations_project:
-            st.write("**Project Fenestrations:**")
-            display_fenestrations_table(fenestrations_project, "project")
-        
-        if not fenestrations_library and not fenestrations_project:
-            st.write("No fenestrations available.")
-    
+        st.subheader("Fenestrations")
+        filter_options = ["All", "None"] + FENESTRATION_TYPES
+        fenestration_filter = st.selectbox("Filter Fenestrations", filter_options, key="fenestration_filter")
+
+        st.subheader("Library Fenestrations")
+        with st.container():
+            library_fenestrations = list(material_library.library_glazing_materials.values())
+            if fenestration_filter == "None":
+                library_fenestrations = []
+            elif fenestration_filter != "All":
+                library_fenestrations = [f for f in library_fenestrations if f.__class__.__name__ == fenestration_filter]
+            cols = st.columns([2, 1, 1, 1, 1])
+            cols[0].write("**Name**")
+            cols[1].write("**SHGC**")
+            cols[2].write("**U-Value (W/m²·K)**")
+            cols[3].write("**Preview**")
+            cols[4].write("**Copy**")
+            for fenestration in library_fenestrations:
+                cols = st.columns([2, 1, 1, 1, 1])
+                cols[0].write(fenestration.name)
+                cols[1].write(f"{fenestration.shgc:.2f}")
+                cols[2].write(f"{fenestration.u_value:.3f}")
+                if cols[3].button("Preview", key=f"preview_lib_fen_{fenestration.name}"):
+                    if st.session_state.get("rerun_trigger") != f"preview_fen_{fenestration.name}"):
+                        st.session_state.rerun_trigger = f"preview_fen_{fenestration.name}"
+                        st.session_state.fenestration_editor = {
+                            "name": fenestration.name,
+                            "shgc": fenestration.shgc,
+                            "u_value": fenestration.u_value,
+                            "h_o": fenestration.h_o,
+                            "is_edit": False,
+                            "edit_source": "library"
+                        }
+                        st.session_state.fenestration_form_state = {
+                            "name": fenestration.name,
+                            "shgc": fenestration.shgc,
+                            "u_value": fenestration.u_value,
+                            "h_o": fenestration.h_o
+                        }
+                        st.session_state.active_tab = "Fenestrations"
+                if cols[4].button("Copy", key=f"copy_lib_fen_{fenestration.name}"):
+                    new_name = f"{fenestration.name}_Project"
+                    counter = 1
+                    while new_name in st.session_state.project_data["fenestrations"]["project"] or new_name in st.session_state.project_data["fenestrations"]["library"]:
+                        new_name = f"{fenestration.name}_Project_{counter}"
+                        counter += 1
+                    new_fenestration = GlazingMaterial(
+                        name=new_name,
+                        shgc=fenestration.shgc,
+                        u_value=fenestration.u_value,
+                        h_o=fenestration.h_o,
+                        is_library=False
+                    )
+                    st.session_state.project_data["fenestrations"]["project"][new_name] = new_fenestration
+                    st.success(f"Fenestration '{new_name}' copied!")
+                    st.session_state.materials_rerun_pending = True
+
+        st.subheader("Project Fenestrations")
+        with st.container():
+            if st.session_state.project_data["fenestrations"]["project"]:
+                cols = st.columns([2, 1, 1, 1, 1])
+                cols[0].write("**Name**")
+                cols[1].write("**SHGC**")
+                cols[2].write("**U-Value (W/m²·K)**")
+                cols[3].write("**Edit**")
+                cols[4].write("**Delete**")
+                for fenestration in st.session_state.project_data["fenestrations"]["project"].values():
+                    cols = st.columns([2, 1, 1, 1, 1])
+                    cols[0].write(fenestration.name)
+                    cols[1].write(f"{fenestration.shgc:.2f}")
+                    cols[2].write(f"{fenestration.u_value:.3f}")
+                    if cols[3].button("Edit", key=f"edit_proj_fen_{fenestration.name}"):
+                        if st.session_state.get("rerun_trigger") != f"edit_fen_{fenestration.name}"):
+                            st.session_state.rerun_trigger = f"edit_fen_{fenestration.name}"
+                            st.session_state.fenestration_editor = {
+                                "name": fenestration.name,
+                                "shgc": fenestration.shgc,
+                                "u_value": fenestration.u_value,
+                                "h_o": fenestration.h_o,
+                                "is_edit": True,
+                                "edit_source": "project",
+                                "original_name": fenestration.name
+                            }
+                            st.session_state.fenestration_form_state = {
+                                "name": fenestration.name,
+                                "shgc": fenestration.shgc,
+                                "u_value": fenestration.u_value,
+                                "h_o": fenestration.h_o
+                            }
+                            st.session_state.active_tab = "Fenestrations"
+                    if cols[4].button("Delete", key=f"delete_proj_fen_{fenestration.name}"):
+                        if any(comp.get("fenestration_material") and comp["fenestration_material"].name == fenestration.name
+                               for comp_list in st.session_state.get("components", {}).values() for comp in comp_list):
+                            st.error(f"Fenestration '{fenestration.name}' is used in components and cannot be deleted.")
+                        else:
+                            del st.session_state.project_data["fenestrations"]["project"][fenestration.name]
+                            st.success(f"Fenestration '{fenestration.name}' deleted!")
+                            st.session_state.materials_rerun_pending = True
+            else:
+                st.write("No project fenestrations added.")
+
+        st.subheader("Project Fenestrations")
+        if st.session_state.project_data["fenestrations"]["project"]:
+            try:
+                fenestration_df = material_library.to_dataframe("glazing", project_glazing_materials=st.session_state.project_data["fenestrations"]["project"])
+                if fenestration_df.empty:
+                    fenestration_data = [
+                        {
+                            "Name": f.name,
+                            "SHGC": f.shgc,
+                            "U-Value (W/m²·K)": f.u_value,
+                            "Exterior Conductance (W/m²·K)": f.h_o
+                        }
+                        for f in st.session_state.project_data["fenestrations"]["project"].values()
+                    ]
+                    fenestration_df = pd.DataFrame(fenestration_data)
+                if not fenestration_df.empty:
+                    st.dataframe(fenestration_df, use_container_width=True)
+                else:
+                    st.write("No project fenestrations to display.")
+            except Exception as e:
+                fenestration_data = [
+                    {
+                        "Name": f.name,
+                        "SHGC": f.shgc,
+                        "U-Value (W/m²·K)": f.u_value,
+                        "Exterior Conductance (W/m²·K)": f.h_o
+                    }
+                    for f in st.session_state.project_data["fenestrations"]["project"].values()
+                ]
+                fenestration_df = pd.DataFrame(fenestration_data)
+                if not fenestration_df.empty:
+                    st.dataframe(fenestration_df, use_container_width=True)
+                else:
+                    st.error(f"Error displaying project fenestrations: {str(e)}")
+                    st.write("No project fenestrations to display.")
+        else:
+            st.write("No project fenestrations to display.")
+
     with col2:
         st.subheader("Fenestration Editor/Creator")
-        
-        # Check if we have an editor state for fenestrations
-        if "fenestration_editor" not in st.session_state:
-            st.session_state.fenestration_editor = {}
-        
-        # Check if we have an action state for fenestrations
-        if "fenestration_action" not in st.session_state:
-            st.session_state.fenestration_action = {"action": None, "id": None}
-        
-        # Display the fenestration editor form
-        with st.form("fenestration_editor_form", clear_on_submit=True):
-            editor_state = st.session_state.get("fenestration_editor", {})
-            is_edit = editor_state.get("is_edit", False)
-            
-            # Fenestration name
-            name = st.text_input(
-                "Fenestration Name",
-                value=editor_state.get("name", ""),
-                help="Enter a unique name for this fenestration."
-            )
-            
-            # Fenestration type
-            fenestration_type = st.selectbox(
-                "Type",
-                FENESTRATION_TYPES,
-                index=FENESTRATION_TYPES.index(editor_state.get("type", FENESTRATION_TYPES[0])) if editor_state.get("type") in FENESTRATION_TYPES else 0,
-                help="Select the fenestration type."
-            )
-            
-            # Thermal properties
-            st.write("**Thermal Properties:**")
-            u_value = st.number_input(
-                "U-Value (W/m²·K)",
-                min_value=0.1,
-                max_value=10.0,
-                value=float(editor_state.get("u_value", 2.5)),
-                format="%.2f",
-                help="Overall heat transfer coefficient."
-            )
-            
-            # Solar properties (only for windows and skylights)
-            if fenestration_type in ["Window", "Skylight"]:
-                st.write("**Solar Properties:**")
-                shgc = st.number_input(
-                    "SHGC",
-                    min_value=0.0,
-                    max_value=1.0,
-                    value=float(editor_state.get("shgc", 0.7)),
-                    format="%.2f",
-                    help="Solar Heat Gain Coefficient."
+        with st.container():
+            with st.form("fenestration_editor_form", clear_on_submit=False):
+                editor_state = st.session_state.get("fenestration_editor", {})
+                form_state = st.session_state.get("fenestration_form_state", {
+                    "name": "",
+                    "shgc": 0.7,
+                    "u_value": 5.0,
+                    "h_o": 23.0
+                })
+                is_edit = editor_state.get("is_edit", False)
+                original_name = editor_state.get("original_name", "")
+                name = st.text_input(
+                    "Fenestration Name",
+                    value=form_state.get("name", editor_state.get("name", "")),
+                    help="Unique fenestration identifier",
+                    key="fenestration_name_input"
                 )
-                
-                visible_transmittance = st.number_input(
-                    "Visible Transmittance",
-                    min_value=0.0,
-                    max_value=1.0,
-                    value=float(editor_state.get("visible_transmittance", 0.8)),
-                    format="%.2f",
-                    help="Visible light transmittance."
-                )
-            else:
-                # For doors, use solar absorptivity instead
-                st.write("**Solar Properties:**")
-                solar_absorptivity = st.number_input(
-                    "Solar Absorptivity",
+                shgc = st.number_input(
+                    "Solar Heat Gain Coefficient (SHGC)",
                     min_value=0.0,
                     max_value=1.0,
-                    value=float(editor_state.get("solar_absorptivity", 0.7)),
-                    format="%.2f",
-                    help="Solar absorptivity of the door surface."
+                    value=form_state.get("shgc", editor_state.get("shgc", 0.7)),
+                    help="Fraction of solar radiation admitted",
+                    key="fenestration_shgc_input"
                 )
-            
-            # Physical properties
-            st.write("**Physical Properties:**")
-            thickness = st.number_input(
-                "Thickness (m)",
-                min_value=0.003,
-                max_value=0.1,
-                value=float(editor_state.get("thickness", 0.024)),
-                format="%.3f",
-                help="Overall thickness of the fenestration."
-            )
-            
-            # Environmental and cost properties
-            st.write("**Environmental & Cost Properties:**")
-            embodied_carbon = st.number_input(
-                "Embodied Carbon (kgCO2e/m²)",
-                min_value=0.0,
-                max_value=2000.0,
-                value=float(editor_state.get("embodied_carbon", 500.0)),
-                format="%.1f",
-                help="Embodied carbon per unit area."
-            )
-            
-            col_mat_cost, col_lab_cost = st.columns(2)
-            
-            with col_mat_cost:
-                material_cost = st.number_input(
-                    "Material Cost ($/m²)",
-                    min_value=0.0,
-                    max_value=2000.0,
-                    value=float(editor_state.get("material_cost", 200.0)),
-                    format="%.2f",
-                    help="Material cost per square meter."
+                u_value = st.number_input(
+                    "U-Value (W/m²·K)",
+                    min_value=0.1,
+                    value=form_state.get("u_value", editor_state.get("u_value", 5.0)),
+                    help="Thermal transmittance",
+                    key="fenestration_u_value_input"
                 )
-            
-            with col_lab_cost:
-                labor_cost = st.number_input(
-                    "Labor Cost ($/m²)",
+                h_o = st.number_input(
+                    "Exterior Surface Conductance (W/m²·K)",
                     min_value=0.0,
-                    max_value=500.0,
-                    value=float(editor_state.get("labor_cost", 80.0)),
-                    format="%.2f",
-                    help="Labor cost per square meter."
+                    value=form_state.get("h_o", editor_state.get("h_o", 23.0)),
+                    help="Exterior surface heat transfer coefficient",
+                    key="fenestration_h_o_input"
                 )
-            
-            replacement_years = st.number_input(
-                "Replacement Years",
-                min_value=1,
-                max_value=100,
-                value=int(editor_state.get("replacement_years", 25)),
-                help="Expected lifespan before replacement."
-            )
-            
-            # Submit buttons
-            col1, col2 = st.columns(2)
-            with col1:
-                submit_label = "Update Fenestration" if is_edit else "Add Fenestration"
-                submit = st.form_submit_button(submit_label)
-            
-            with col2:
-                cancel = st.form_submit_button("Cancel")
-        
-        # Handle form submission
-        if submit:
-            # Validate inputs
-            if not name.strip():
-                st.error("Fenestration name is required.")
-            else:
-                # Create fenestration data
-                fenestration_data = {
-                    "name": name.strip(),
-                    "type": fenestration_type,
-                    "u_value": u_value,
-                    "thickness": thickness,
-                    "embodied_carbon": embodied_carbon,
-                    "cost": {
-                        "material": material_cost,
-                        "labor": labor_cost,
-                        "replacement_years": replacement_years
-                    },
-                    "description": f"Custom {fenestration_type.lower()}"
-                }
-                
-                # Add type-specific properties
-                if fenestration_type in ["Window", "Skylight"]:
-                    fenestration_data["shgc"] = shgc
-                    fenestration_data["visible_transmittance"] = visible_transmittance
-                else:
-                    fenestration_data["solar_absorptivity"] = solar_absorptivity
-                
-                # Check if editing or adding new
-                if is_edit and st.session_state.fenestration_editor.get("edit_id"):
-                    # Update existing fenestration
-                    edit_id = st.session_state.fenestration_editor["edit_id"]
-                    edit_source = st.session_state.fenestration_editor["edit_source"]
-                    
-                    if edit_source == "project":
-                        st.session_state.project_data["fenestrations"]["project"][edit_id] = fenestration_data
-                        st.success(f"Fenestration '{name}' updated successfully!")
-                    else:
-                        st.error("Cannot edit library fenestrations.")
-                else:
-                    # Add new fenestration to project
-                    fenestration_id = str(uuid.uuid4())
-                    st.session_state.project_data["fenestrations"]["project"][fenestration_id] = fenestration_data
-                    st.success(f"Fenestration '{name}' added successfully!")
-                
-                # Clear editor state
-                st.session_state.fenestration_editor = {}
-                st.session_state.materials_rerun_pending = True
-                st.rerun()
-        
-        if cancel:
-            # Clear editor state
-            st.session_state.fenestration_editor = {}
-            st.session_state.materials_rerun_pending = True
-            st.rerun()
 
-def display_materials_table(materials: Dict[str, Any], source: str):
-    """Display materials in a table format with edit/delete buttons."""
-    if not materials:
-        return
-    
-    # Create table data
-    table_data = []
-    for material_id, material in materials.items():
-        table_data.append({
-            "Name": material.get("name", "Unknown"),
-            "Category": material.get("category", "Unknown"),
-            "k (W/m·K)": f"{material.get('thermal_conductivity', 0):.3f}",
-            "ρ (kg/m³)": f"{material.get('density', 0):.0f}",
-            "Cp (J/kg·K)": f"{material.get('specific_heat', 0):.0f}",
-            "Thickness (m)": f"{material.get('thickness_range', {}).get('default', 0):.3f}",
-            "Actions": material_id
-        })
-    
-    if table_data:
-        df = pd.DataFrame(table_data)
-        
-        # Display table
-        st.dataframe(df.drop('Actions', axis=1), use_container_width=True)
-        
-        # Display action buttons
-        st.write("**Actions:**")
-        for i, row in enumerate(table_data):
-            material_id = row["Actions"]
-            material_name = row["Name"]
-            
-            col1, col2, col3 = st.columns([2, 1, 1])
-            
-            with col1:
-                st.write(f"{i+1}. {material_name}")
-            
-            with col2:
-                if source == "library":
-                    if st.button("Add to Project", key=f"add_material_{material_id}_{i}"):
-                        # Add library material to project
-                        project_id = str(uuid.uuid4())
-                        st.session_state.project_data["materials"]["project"][project_id] = materials[material_id].copy()
-                        st.success(f"Material '{material_name}' added to project!")
-                        st.session_state.materials_rerun_pending = True
-                        st.rerun()
-                else:
-                    if st.button("Edit", key=f"edit_material_{material_id}_{i}"):
-                        # Set up editor for editing
-                        material = materials[material_id]
-                        st.session_state.material_editor = {
-                            "is_edit": True,
-                            "edit_id": material_id,
-                            "edit_source": source,
-                            "name": material.get("name", ""),
-                            "category": material.get("category", MATERIAL_CATEGORIES[0]),
-                            "thermal_conductivity": material.get("thermal_conductivity", 0.1),
-                            "density": material.get("density", 1000.0),
-                            "specific_heat": material.get("specific_heat", 1000.0),
-                            "min_thickness": material.get("thickness_range", {}).get("min", 0.01),
-                            "max_thickness": material.get("thickness_range", {}).get("max", 0.3),
-                            "default_thickness": material.get("thickness_range", {}).get("default", 0.1),
-                            "embodied_carbon": material.get("embodied_carbon", 0.5),
-                            "material_cost": material.get("cost", {}).get("material", 100.0),
-                            "labor_cost": material.get("cost", {}).get("labor", 50.0),
-                            "replacement_years": material.get("cost", {}).get("replacement_years", 50)
-                        }
-                        st.session_state.materials_rerun_pending = True
-                        st.rerun()
-            
-            with col3:
-                if source == "project":
-                    if st.button("Delete", key=f"delete_material_{material_id}_{i}"):
-                        # Delete project material
-                        del st.session_state.project_data["materials"]["project"][material_id]
-                        st.success(f"Material '{material_name}' deleted!")
-                        st.session_state.materials_rerun_pending = True
-                        st.rerun()
-
-def display_fenestrations_table(fenestrations: Dict[str, Any], source: str):
-    """Display fenestrations in a table format with edit/delete buttons."""
-    if not fenestrations:
-        return
-    
-    # Create table data
-    table_data = []
-    for fenestration_id, fenestration in fenestrations.items():
-        table_data.append({
-            "Name": fenestration.get("name", "Unknown"),
-            "Type": fenestration.get("type", "Unknown"),
-            "U-Value (W/m²·K)": f"{fenestration.get('u_value', 0):.2f}",
-            "SHGC": f"{fenestration.get('shgc', 0):.2f}" if fenestration.get('shgc') is not None else "N/A",
-            "VT": f"{fenestration.get('visible_transmittance', 0):.2f}" if fenestration.get('visible_transmittance') is not None else "N/A",
-            "Thickness (m)": f"{fenestration.get('thickness', 0):.3f}",
-            "Actions": fenestration_id
-        })
-    
-    if table_data:
-        df = pd.DataFrame(table_data)
-        
-        # Display table
-        st.dataframe(df.drop('Actions', axis=1), use_container_width=True)
-        
-        # Display action buttons
-        st.write("**Actions:**")
-        for i, row in enumerate(table_data):
-            fenestration_id = row["Actions"]
-            fenestration_name = row["Name"]
-            
-            col1, col2, col3 = st.columns([2, 1, 1])
-            
-            with col1:
-                st.write(f"{i+1}. {fenestration_name}")
-            
-            with col2:
-                if source == "library":
-                    if st.button("Add to Project", key=f"add_fenestration_{fenestration_id}_{i}"):
-                        # Add library fenestration to project
-                        project_id = str(uuid.uuid4())
-                        st.session_state.project_data["fenestrations"]["project"][project_id] = fenestrations[fenestration_id].copy()
-                        st.success(f"Fenestration '{fenestration_name}' added to project!")
-                        st.session_state.materials_rerun_pending = True
-                        st.rerun()
-                else:
-                    if st.button("Edit", key=f"edit_fenestration_{fenestration_id}_{i}"):
-                        # Set up editor for editing
-                        fenestration = fenestrations[fenestration_id]
-                        editor_data = {
-                            "is_edit": True,
-                            "edit_id": fenestration_id,
-                            "edit_source": source,
-                            "name": fenestration.get("name", ""),
-                            "type": fenestration.get("type", FENESTRATION_TYPES[0]),
-                            "u_value": fenestration.get("u_value", 2.5),
-                            "thickness": fenestration.get("thickness", 0.024),
-                            "embodied_carbon": fenestration.get("embodied_carbon", 500.0),
-                            "material_cost": fenestration.get("cost", {}).get("material", 200.0),
-                            "labor_cost": fenestration.get("cost", {}).get("labor", 80.0),
-                            "replacement_years": fenestration.get("cost", {}).get("replacement_years", 25)
+                if st.form_submit_button("Save Fenestration"):
+                    action_id = str(uuid.uuid4())
+                    if st.session_state.fenestration_action.get("id") != action_id:
+                        st.session_state.fenestration_action = {"action": "save", "id": action_id}
+                        st.session_state.fenestration_form_state = {
+                            "name": name,
+                            "shgc": shgc,
+                            "u_value": u_value,
+                            "h_o": h_o
                         }
-                        
-                        # Add type-specific properties
-                        if fenestration.get("type") in ["Window", "Skylight"]:
-                            editor_data["shgc"] = fenestration.get("shgc", 0.7)
-                            editor_data["visible_transmittance"] = fenestration.get("visible_transmittance", 0.8)
+                        if not name or not name.strip():
+                            st.error("Fenestration name cannot be empty.")
+                        elif (name in st.session_state.project_data["fenestrations"]["project"] or
+                              name in st.session_state.project_data["fenestrations"]["library"]) and (not is_edit or name != original_name):
+                            st.error(f"Fenestration '{name}' already exists.")
                         else:
-                            editor_data["solar_absorptivity"] = fenestration.get("solar_absorptivity", 0.7)
-                        
-                        st.session_state.fenestration_editor = editor_data
-                        st.session_state.materials_rerun_pending = True
-                        st.rerun()
-            
-            with col3:
-                if source == "project":
-                    if st.button("Delete", key=f"delete_fenestration_{fenestration_id}_{i}"):
-                        # Delete project fenestration
-                        del st.session_state.project_data["fenestrations"]["project"][fenestration_id]
-                        st.success(f"Fenestration '{fenestration_name}' deleted!")
-                        st.session_state.materials_rerun_pending = True
-                        st.rerun()
+                            try:
+                                new_fenestration = GlazingMaterial(
+                                    name=name,
+                                    shgc=shgc,
+                                    u_value=u_value,
+                                    h_o=h_o,
+                                    is_library=False
+                                )
+                                if is_edit and editor_state.get("edit_source") == "project" and name == original_name:
+                                    st.session_state.project_data["fenestrations"]["project"][original_name] = new_fenestration
+                                    st.success(f"Fenestration '{name}' updated!")
+                                else:
+                                    st.session_state.project_data["fenestrations"]["project"][name] = new_fenestration
+                                    st.success(f"Fenestration '{name}' added!")
+                                st.session_state.fenestration_editor = {}
+                                st.session_state.fenestration_form_state = {
+                                    "name": "",
+                                    "shgc": 0.7,
+                                    "u_value": 5.0,
+                                    "h_o": 23.0
+                                }
+                                st.session_state.fenestration_action = {"action": None, "id": None}
+                                st.session_state.rerun_trigger = None
+                                st.session_state.materials_rerun_pending = True
+                            except Exception as e:
+                                st.error(f"Error saving fenestration: {str(e)}")
 
-def display_materials_help():
-    """Display help information for the materials page."""
-    st.markdown("""
-    ### Material Library Help
-    
-    This page allows you to manage building materials and fenestrations for thermal analysis.
-    
-    #### Materials
-    - **Library Materials**: Pre-defined materials with standard thermal properties
-    - **Project Materials**: Custom materials created for your specific project
-    - **Thermal Properties**:
-        - **Thermal Conductivity (k)**: Rate of heat transfer through the material (W/m·K)
-        - **Density (ρ)**: Mass per unit volume (kg/m³)
-        - **Specific Heat (Cp)**: Heat capacity per unit mass (J/kg·K)
-    
-    #### Fenestrations
-    - **Windows/Skylights**: Include solar heat gain coefficient (SHGC) and visible transmittance
-    - **Doors**: Include solar absorptivity for opaque surfaces
-    - **U-Value**: Overall heat transfer coefficient (W/m²·K)
-    
-    #### Usage
-    1. Browse library materials/fenestrations and add them to your project
-    2. Create custom materials/fenestrations using the editor
-    3. Edit or delete project materials/fenestrations as needed
-    4. All materials will be available for use in construction assemblies
-    """)
-
-# Helper functions for backward compatibility
 def get_available_materials():
     """Get all available materials (library + project) for use in other modules."""
     materials = {}
-    
     if "materials" in st.session_state.project_data:
-        # Add library materials
-        if "library" in st.session_state.project_data["materials"]:
-            materials.update(st.session_state.project_data["materials"]["library"])
-        
-        # Add project materials
-        if "project" in st.session_state.project_data["materials"]:
-            materials.update(st.session_state.project_data["materials"]["project"])
-    
+        materials.update(st.session_state.project_data["materials"]["library"])
+        materials.update(st.session_state.project_data["materials"]["project"])
     return materials
 
 def get_available_fenestrations():
     """Get all available fenestrations (library + project) for use in other modules."""
     fenestrations = {}
-    
     if "fenestrations" in st.session_state.project_data:
-        # Add library fenestrations
-        if "library" in st.session_state.project_data["fenestrations"]:
-            fenestrations.update(st.session_state.project_data["fenestrations"]["library"])
-        
-        # Add project fenestrations
-        if "project" in st.session_state.project_data["fenestrations"]:
-            fenestrations.update(st.session_state.project_data["fenestrations"]["project"])
-    
-    return fenestrations
-
+        fenestrations.update(st.session_state.project_data["fenestrations"]["library"])
+        fenestrations.update(st.session_state.project_data["fenestrations"]["project"])
+    return fenestrations