Update app/materials_library.py

app/materials_library.py

@@ -1,5 +1,5 @@
 """
-BuildSustain - Material Library Module
+BuildSustain - Material Library Module (Restructured)
 
 This module handles the material library functionality of the BuildSustain application,
 allowing users to manage building materials and fenestrations (windows, doors, skylights).
@@ -17,16 +17,20 @@ import logging
 import uuid
 from typing import Dict, List, Any, Optional, Tuple, Union
 
+# Import default data from centralized module
+from app.m_c_data import SAMPLE_MATERIALS, SAMPLE_FENESTRATIONS
+
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 # Define constants
 MATERIAL_CATEGORIES = [
-    "Finishing Materials",
-    "Structural Materials",
-    "Sub-Structural Materials",
+    "Masonry",
     "Insulation",
+    "Metal",
+    "Wood",
+    "Finishing",
     "Custom"
 ]
 
@@ -37,265 +41,29 @@ FENESTRATION_TYPES = [
     "Custom"
 ]
 
-# Default library materials
-DEFAULT_MATERIALS = {
-    "Brick": {
-        "category": "Structural Materials",
-        "thermal_conductivity": 0.72,
-        "density": 1920.0,
-        "specific_heat": 840.0,
-        "thickness_range": [0.05, 0.3],
-        "default_thickness": 0.1,
-        "embodied_carbon": 240.0,  # kg CO2e/m³
-        "cost": 180.0  # USD/m³
-    },
-    "Concrete": {
-        "category": "Structural Materials",
-        "thermal_conductivity": 1.4,
-        "density": 2300.0,
-        "specific_heat": 880.0,
-        "thickness_range": [0.05, 0.5],
-        "default_thickness": 0.15,
-        "embodied_carbon": 320.0,
-        "cost": 120.0
-    },
-    "Gypsum Board": {
-        "category": "Finishing Materials",
-        "thermal_conductivity": 0.25,
-        "density": 900.0,
-        "specific_heat": 1000.0,
-        "thickness_range": [0.01, 0.05],
-        "default_thickness": 0.0125,
-        "embodied_carbon": 120.0,
-        "cost": 90.0
-    },
-    "Mineral Wool": {
-        "category": "Insulation",
-        "thermal_conductivity": 0.04,
-        "density": 30.0,
-        "specific_heat": 840.0,
-        "thickness_range": [0.025, 0.3],
-        "default_thickness": 0.1,
-        "embodied_carbon": 45.0,
-        "cost": 70.0
-    },
-    "EPS Insulation": {
-        "category": "Insulation",
-        "thermal_conductivity": 0.035,
-        "density": 25.0,
-        "specific_heat": 1400.0,
-        "thickness_range": [0.025, 0.3],
-        "default_thickness": 0.1,
-        "embodied_carbon": 88.0,
-        "cost": 65.0
-    },
-    "Wood (Pine)": {
-        "category": "Structural Materials",
-        "thermal_conductivity": 0.14,
-        "density": 550.0,
-        "specific_heat": 1600.0,
-        "thickness_range": [0.01, 0.3],
-        "default_thickness": 0.05,
-        "embodied_carbon": 110.0,
-        "cost": 250.0
-    },
-    "Steel": {
-        "category": "Structural Materials",
-        "thermal_conductivity": 50.0,
-        "density": 7800.0,
-        "specific_heat": 450.0,
-        "thickness_range": [0.001, 0.05],
-        "default_thickness": 0.005,
-        "embodied_carbon": 1750.0,
-        "cost": 800.0
-    },
-    "Aluminum": {
-        "category": "Structural Materials",
-        "thermal_conductivity": 230.0,
-        "density": 2700.0,
-        "specific_heat": 880.0,
-        "thickness_range": [0.001, 0.05],
-        "default_thickness": 0.003,
-        "embodied_carbon": 8500.0,
-        "cost": 1200.0
-    },
-    "Glass Fiber Insulation": {
-        "category": "Insulation",
-        "thermal_conductivity": 0.035,
-        "density": 12.0,
-        "specific_heat": 840.0,
-        "thickness_range": [0.025, 0.3],
-        "default_thickness": 0.1,
-        "embodied_carbon": 28.0,
-        "cost": 45.0
-    },
-    "Ceramic Tile": {
-        "category": "Finishing Materials",
-        "thermal_conductivity": 1.3,
-        "density": 2300.0,
-        "specific_heat": 840.0,
-        "thickness_range": [0.005, 0.025],
-        "default_thickness": 0.01,
-        "embodied_carbon": 650.0,
-        "cost": 280.0
-    },
-    "Carpet": {
-        "category": "Finishing Materials",
-        "thermal_conductivity": 0.06,
-        "density": 200.0,
-        "specific_heat": 1300.0,
-        "thickness_range": [0.005, 0.02],
-        "default_thickness": 0.01,
-        "embodied_carbon": 40.0,
-        "cost": 150.0
-    },
-    "Plywood": {
-        "category": "Sub-Structural Materials",
-        "thermal_conductivity": 0.13,
-        "density": 560.0,
-        "specific_heat": 1400.0,
-        "thickness_range": [0.006, 0.025],
-        "default_thickness": 0.012,
-        "embodied_carbon": 350.0,
-        "cost": 180.0
-    },
-    "Concrete Block": {
-        "category": "Structural Materials",
-        "thermal_conductivity": 0.51,
-        "density": 1400.0,
-        "specific_heat": 1000.0,
-        "thickness_range": [0.1, 0.3],
-        "default_thickness": 0.2,
-        "embodied_carbon": 260.0,
-        "cost": 140.0
-    },
-    "Stone (Granite)": {
-        "category": "Finishing Materials",
-        "thermal_conductivity": 2.8,
-        "density": 2600.0,
-        "specific_heat": 790.0,
-        "thickness_range": [0.01, 0.1],
-        "default_thickness": 0.03,
-        "embodied_carbon": 170.0,
-        "cost": 450.0
-    },
-    "Polyurethane Insulation": {
-        "category": "Insulation",
-        "thermal_conductivity": 0.025,
-        "density": 30.0,
-        "specific_heat": 1400.0,
-        "thickness_range": [0.025, 0.2],
-        "default_thickness": 0.075,
-        "embodied_carbon": 102.0,
-        "cost": 95.0
-    }
-}
-
-# Default library fenestrations
-DEFAULT_FENESTRATIONS = {
-    "Single Glazing": {
-        "type": "Window",
-        "u_value": 5.8,
-        "shgc": 0.86,
-        "visible_transmittance": 0.9,
-        "thickness": 0.006,
-        "embodied_carbon": 800.0,  # kg CO2e/m²
-        "cost": 120.0  # USD/m²
-    },
-    "Double Glazing (Air)": {
-        "type": "Window",
-        "u_value": 2.8,
-        "shgc": 0.72,
-        "visible_transmittance": 0.78,
-        "thickness": 0.024,
-        "embodied_carbon": 950.0,
-        "cost": 180.0
-    },
-    "Double Glazing (Argon)": {
-        "type": "Window",
-        "u_value": 1.4,
-        "shgc": 0.7,
-        "visible_transmittance": 0.76,
-        "thickness": 0.024,
-        "embodied_carbon": 980.0,
-        "cost": 220.0
-    },
-    "Triple Glazing": {
-        "type": "Window",
-        "u_value": 0.8,
-        "shgc": 0.5,
-        "visible_transmittance": 0.68,
-        "thickness": 0.036,
-        "embodied_carbon": 1100.0,
-        "cost": 320.0
-    },
-    "Low-E Double Glazing": {
-        "type": "Window",
-        "u_value": 1.8,
-        "shgc": 0.4,
-        "visible_transmittance": 0.74,
-        "thickness": 0.024,
-        "embodied_carbon": 1050.0,
-        "cost": 250.0
-    },
-    "Wooden Door": {
-        "type": "Door",
-        "u_value": 2.2,
-        "shgc": 0.0,
-        "visible_transmittance": 0.0,
-        "thickness": 0.04,
-        "embodied_carbon": 400.0,
-        "cost": 280.0
-    },
-    "Steel Door": {
-        "type": "Door",
-        "u_value": 3.1,
-        "shgc": 0.0,
-        "visible_transmittance": 0.0,
-        "thickness": 0.035,
-        "embodied_carbon": 1200.0,
-        "cost": 350.0
-    },
-    "Glass Door": {
-        "type": "Door",
-        "u_value": 3.8,
-        "shgc": 0.6,
-        "visible_transmittance": 0.7,
-        "thickness": 0.01,
-        "embodied_carbon": 900.0,
-        "cost": 420.0
-    },
-    "Skylight (Double Glazed)": {
-        "type": "Skylight",
-        "u_value": 3.0,
-        "shgc": 0.65,
-        "visible_transmittance": 0.75,
-        "thickness": 0.024,
-        "embodied_carbon": 1050.0,
-        "cost": 380.0
-    },
-    "Skylight (Low-E)": {
-        "type": "Skylight",
-        "u_value": 2.0,
-        "shgc": 0.35,
-        "visible_transmittance": 0.7,
-        "thickness": 0.024,
-        "embodied_carbon": 1150.0,
-        "cost": 450.0
-    }
-}
-
 def display_materials_page():
     """
     Display the material library page.
     This is the main function called by main.py when the Material Library page is selected.
     """
     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()
     
+    # 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:
+        st.session_state.materials_rerun_pending = False
+        st.rerun()
+    
     # Create tabs for materials and fenestrations
     tab1, tab2 = st.tabs(["Materials", "Fenestrations"])
     
@@ -320,896 +88,681 @@ def display_materials_page():
             st.session_state.current_page = "Construction"
             st.rerun()
 
-def display_materials_tab():
-    """Display the materials tab content."""
-    # Initialize materials in session state if not present
-    initialize_materials()
-    
-    # Create columns for library and project materials
-    col1, col2 = st.columns(2)
-    
-    # Library Materials
-    with col1:
-        st.subheader("Library Materials")
-        display_library_materials()
-    
-    # Project Materials
-    with col2:
-        st.subheader("Project Materials")
-        display_project_materials()
-    
-    # Material Editor
-    st.markdown("---")
-    st.subheader("Material Editor")
-    display_material_editor()
-
-def display_fenestrations_tab():
-    """Display the fenestrations tab content."""
-    # Initialize fenestrations in session state if not present
-    initialize_fenestrations()
-    
-    # Create columns for library and project fenestrations
-    col1, col2 = st.columns(2)
-    
-    # Library Fenestrations
-    with col1:
-        st.subheader("Library Fenestrations")
-        display_library_fenestrations()
-    
-    # Project Fenestrations
-    with col2:
-        st.subheader("Project Fenestrations")
-        display_project_fenestrations()
-    
-    # Fenestration Editor
-    st.markdown("---")
-    st.subheader("Fenestration Editor")
-    display_fenestration_editor()
-
-def initialize_materials():
-    """Initialize materials in session state if not present."""
+def initialize_materials_and_fenestrations():
+    """Initialize materials and fenestrations in session state if not present."""
+    # Initialize materials
     if "materials" not in st.session_state.project_data:
         st.session_state.project_data["materials"] = {
-            "library": {},
+            "library": dict(SAMPLE_MATERIALS),
             "project": {}
         }
     
-    # Initialize library materials if empty
-    if not st.session_state.project_data["materials"]["library"]:
-        st.session_state.project_data["materials"]["library"] = DEFAULT_MATERIALS.copy()
-    
-    # Initialize material editor state
-    if "material_editor" not in st.session_state:
-        st.session_state.material_editor = {
-            "name": "",
-            "category": MATERIAL_CATEGORIES[0],
-            "thermal_conductivity": 0.5,
-            "density": 1000.0,
-            "specific_heat": 1000.0,
-            "thickness_range": [0.01, 0.2],
-            "default_thickness": 0.05,
-            "embodied_carbon": 100.0,
-            "cost": 100.0,
-            "edit_mode": False,
-            "original_name": ""
-        }
-
-def initialize_fenestrations():
-    """Initialize fenestrations in session state if not present."""
+    # Initialize fenestrations
     if "fenestrations" not in st.session_state.project_data:
         st.session_state.project_data["fenestrations"] = {
-            "library": {},
+            "library": dict(SAMPLE_FENESTRATIONS),
             "project": {}
         }
-    
-    # Initialize library fenestrations if empty
-    if not st.session_state.project_data["fenestrations"]["library"]:
-        st.session_state.project_data["fenestrations"]["library"] = DEFAULT_FENESTRATIONS.copy()
-    
-    # Initialize fenestration editor state
-    if "fenestration_editor" not in st.session_state:
-        st.session_state.fenestration_editor = {
-            "name": "",
-            "type": FENESTRATION_TYPES[0],
-            "u_value": 2.8,
-            "shgc": 0.7,
-            "visible_transmittance": 0.8,
-            "thickness": 0.024,
-            "embodied_carbon": 900.0,
-            "cost": 200.0,
-            "edit_mode": False,
-            "original_name": ""
-        }
 
-def display_library_materials():
-    """Display the library materials section."""
-    # Filter options
-    category_filter = st.selectbox(
-        "Filter by Category",
-        ["All"] + MATERIAL_CATEGORIES,
-        key="library_material_category_filter"
-    )
-    
-    # Get library materials
-    library_materials = st.session_state.project_data["materials"]["library"]
-    
-    # Apply filter
-    if category_filter != "All":
-        filtered_materials = {
-            name: props for name, props in library_materials.items()
-            if props["category"] == category_filter
-        }
-    else:
-        filtered_materials = library_materials
+def display_materials_tab():
+    """Display the materials tab content with two-column layout."""
+    # Split the display into two columns
+    col1, col2 = st.columns([3, 2])
     
-    # Display materials in a table
-    if filtered_materials:
-        # Create a DataFrame for display
-        data = []
-        for name, props in filtered_materials.items():
-            data.append({
-                "Name": name,
-                "Category": props["category"],
-                "Thermal Conductivity (W/m·K)": props["thermal_conductivity"],
-                "Density (kg/m³)": props["density"],
-                "Specific Heat (J/kg·K)": props["specific_heat"]
-            })
+    with col1:
+        st.subheader("Saved Materials")
         
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
+        # Get materials from session state
+        materials_library = st.session_state.project_data["materials"]["library"]
+        materials_project = st.session_state.project_data["materials"]["project"]
         
-        # Add to project button
-        selected_material = st.selectbox(
-            "Select Material to Add to Project",
-            list(filtered_materials.keys()),
-            key="library_material_selector"
-        )
+        # Display library materials
+        if materials_library:
+            st.write("**Library Materials:**")
+            display_materials_table(materials_library, "library")
         
-        if st.button("Add to Project", key="add_library_material_to_project"):
-            # Check if material already exists in project
-            if selected_material in st.session_state.project_data["materials"]["project"]:
-                st.warning(f"Material '{selected_material}' already exists in your project.")
-            else:
-                # Add to project materials
-                st.session_state.project_data["materials"]["project"][selected_material] = \
-                    st.session_state.project_data["materials"]["library"][selected_material].copy()
-                st.success(f"Material '{selected_material}' added to your project.")
-                logger.info(f"Added library material '{selected_material}' to project")
-    else:
-        st.info("No materials found in the selected category.")
-
-def display_project_materials():
-    """Display the project materials section."""
-    # Get project materials
-    project_materials = st.session_state.project_data["materials"]["project"]
+        # 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.")
     
-    if project_materials:
-        # Create a DataFrame for display
-        data = []
-        for name, props in project_materials.items():
-            data.append({
-                "Name": name,
-                "Category": props["category"],
-                "Thermal Conductivity (W/m·K)": props["thermal_conductivity"],
-                "Density (kg/m³)": props["density"],
-                "Specific Heat (J/kg·K)": props["specific_heat"]
-            })
+    with col2:
+        st.subheader("Material Editor/Creator")
         
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
+        # Check if we have an editor state for materials
+        if "material_editor" not in st.session_state:
+            st.session_state.material_editor = {}
         
-        # Edit and delete options
-        col1, col2 = st.columns(2)
+        # 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}
         
-        with col1:
-            selected_material = st.selectbox(
-                "Select Material to Edit",
-                list(project_materials.keys()),
-                key="project_material_edit_selector"
-            )
+        # 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)
             
-            if st.button("Edit Material", key="edit_project_material"):
-                # Load material data into editor
-                material_data = project_materials[selected_material]
-                st.session_state.material_editor = {
-                    "name": selected_material,
-                    "category": material_data["category"],
-                    "thermal_conductivity": material_data["thermal_conductivity"],
-                    "density": material_data["density"],
-                    "specific_heat": material_data["specific_heat"],
-                    "thickness_range": material_data["thickness_range"],
-                    "default_thickness": material_data["default_thickness"],
-                    "embodied_carbon": material_data["embodied_carbon"],
-                    "cost": material_data["cost"],
-                    "edit_mode": True,
-                    "original_name": selected_material
-                }
-                st.success(f"Material '{selected_material}' loaded for editing.")
-        
-        with col2:
-            selected_material_delete = st.selectbox(
-                "Select Material to Delete",
-                list(project_materials.keys()),
-                key="project_material_delete_selector"
+            # Material name
+            name = st.text_input(
+                "Material Name",
+                value=editor_state.get("name", ""),
+                help="Enter a unique name for this material."
             )
             
-            if st.button("Delete Material", key="delete_project_material"):
-                # Check if material is in use
-                is_in_use = check_material_in_use(selected_material_delete)
-                
-                if is_in_use:
-                    st.error(f"Cannot delete material '{selected_material_delete}' because it is in use in constructions.")
-                else:
-                    # Delete material
-                    del st.session_state.project_data["materials"]["project"][selected_material_delete]
-                    st.success(f"Material '{selected_material_delete}' deleted from your project.")
-                    logger.info(f"Deleted material '{selected_material_delete}' from project")
-    else:
-        st.info("No materials in your project. Add materials from the library or create custom materials.")
-
-def display_material_editor():
-    """Display the material editor form."""
-    with st.form("material_editor_form"):
-        # Material name
-        name = st.text_input(
-            "Material Name",
-            value=st.session_state.material_editor["name"],
-            help="Enter a unique name for the material."
-        )
-        
-        # Create two columns for layout
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # Category
+            # Material category
             category = st.selectbox(
                 "Category",
                 MATERIAL_CATEGORIES,
-                index=MATERIAL_CATEGORIES.index(st.session_state.material_editor["category"]) if st.session_state.material_editor["category"] in MATERIAL_CATEGORIES else 0,
+                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 conductivity
+            # Thermal properties
+            st.write("**Thermal Properties:**")
             thermal_conductivity = st.number_input(
                 "Thermal Conductivity (W/m·K)",
                 min_value=0.001,
-                max_value=1000.0,
-                value=float(st.session_state.material_editor["thermal_conductivity"]),
+                max_value=500.0,
+                value=float(editor_state.get("thermal_conductivity", 0.1)),
                 format="%.3f",
-                help="Thermal conductivity in W/m·K. Lower values indicate better insulation."
+                help="Thermal conductivity of the material."
             )
             
-            # Density
             density = st.number_input(
                 "Density (kg/m³)",
                 min_value=1.0,
-                max_value=20000.0,
-                value=float(st.session_state.material_editor["density"]),
+                max_value=10000.0,
+                value=float(editor_state.get("density", 1000.0)),
                 format="%.1f",
-                help="Material density in kg/m³."
+                help="Density of the material."
             )
-        
-        with col2:
-            # Specific heat
+            
             specific_heat = st.number_input(
                 "Specific Heat (J/kg·K)",
                 min_value=100.0,
-                max_value=10000.0,
-                value=float(st.session_state.material_editor["specific_heat"]),
+                max_value=5000.0,
+                value=float(editor_state.get("specific_heat", 1000.0)),
                 format="%.1f",
-                help="Specific heat capacity in J/kg·K. Higher values indicate better thermal mass."
+                help="Specific heat capacity of the material."
             )
             
             # Thickness range
-            min_thickness, max_thickness = st.session_state.material_editor["thickness_range"]
-            thickness_range = st.slider(
-                "Thickness Range (m)",
-                min_value=0.001,
-                max_value=0.5,
-                value=(float(min_thickness), float(max_thickness)),
-                format="%.3f",
-                help="Minimum and maximum thickness range for this material in meters."
-            )
+            st.write("**Thickness Range:**")
+            col_min, col_max, col_default = st.columns(3)
             
-            # Default thickness
-            default_thickness = st.number_input(
-                "Default Thickness (m)",
-                min_value=float(thickness_range[0]),
-                max_value=float(thickness_range[1]),
-                value=min(max(float(st.session_state.material_editor["default_thickness"]), float(thickness_range[0])), float(thickness_range[1])),
-                format="%.3f",
-                help="Default thickness for this material in meters."
-            )
-        
-        # Additional properties for embodied carbon and cost
-        st.subheader("Additional Properties")
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # Embodied carbon
+            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 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."
+                )
+            
+            with col_default:
+                default_thickness = st.number_input(
+                    "Default (m)",
+                    min_value=0.001,
+                    max_value=1.0,
+                    value=float(editor_state.get("default_thickness", 0.1)),
+                    format="%.3f",
+                    help="Default thickness for this material."
+                )
+            
+            # Environmental and cost properties
+            st.write("**Environmental & Cost Properties:**")
             embodied_carbon = st.number_input(
-                "Embodied Carbon (kg CO₂e/m³)",
+                "Embodied Carbon (kgCO2e/kg)",
                 min_value=0.0,
-                max_value=10000.0,
-                value=float(st.session_state.material_editor["embodied_carbon"]),
-                format="%.1f",
-                help="Embodied carbon in kg CO₂e per cubic meter."
+                max_value=50.0,
+                value=float(editor_state.get("embodied_carbon", 0.5)),
+                format="%.3f",
+                help="Embodied carbon per unit mass of material."
             )
-        
-        with col2:
-            # Cost
-            cost = st.number_input(
-                "Cost (USD/m³)",
-                min_value=0.0,
-                max_value=10000.0,
-                value=float(st.session_state.material_editor["cost"]),
-                format="%.1f",
-                help="Material cost in USD per cubic meter."
+            
+            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=10000.0,
+                    value=float(editor_state.get("material_cost", 100.0)),
+                    format="%.2f",
+                    help="Material cost per cubic meter."
+                )
+            
+            with col_lab_cost:
+                labor_cost = st.number_input(
+                    "Labor Cost ($/m²)",
+                    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."
+                )
+            
+            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."
             )
-        
-        # Form submission buttons
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            submit_button = st.form_submit_button("Save Material")
-        
-        with col2:
-            clear_button = st.form_submit_button("Clear Form")
-    
-    # Handle form submission
-    if submit_button:
-        # Validate inputs
-        validation_errors = validate_material(
-            name, category, thermal_conductivity, density, specific_heat,
-            thickness_range, default_thickness, embodied_carbon, cost,
-            st.session_state.material_editor["edit_mode"], st.session_state.material_editor["original_name"]
-        )
-        
-        if validation_errors:
-            # Display validation errors
-            for error in validation_errors:
-                st.error(error)
-        else:
-            # Create material data
-            material_data = {
-                "category": category,
-                "thermal_conductivity": thermal_conductivity,
-                "density": density,
-                "specific_heat": specific_heat,
-                "thickness_range": list(thickness_range),
-                "default_thickness": default_thickness,
-                "embodied_carbon": embodied_carbon,
-                "cost": cost
-            }
             
-            # Handle edit mode
-            if st.session_state.material_editor["edit_mode"]:
-                original_name = st.session_state.material_editor["original_name"]
+            # 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"
+                }
                 
-                # If name changed, delete old entry and create new one
-                if original_name != name:
-                    del st.session_state.project_data["materials"]["project"][original_name]
+                # 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!")
                 
-                # Update material
-                st.session_state.project_data["materials"]["project"][name] = material_data
-                st.success(f"Material '{name}' updated successfully.")
-                logger.info(f"Updated material '{name}' in project")
-            else:
-                # Add new material
-                st.session_state.project_data["materials"]["project"][name] = material_data
-                st.success(f"Material '{name}' added to your project.")
-                logger.info(f"Added new material '{name}' to project")
-            
-            # Reset editor
-            reset_material_editor()
-    
-    # Handle clear button
-    if clear_button:
-        reset_material_editor()
-        st.rerun()
+                # 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_library_fenestrations():
-    """Display the library fenestrations section."""
-    # Filter options
-    type_filter = st.selectbox(
-        "Filter by Type",
-        ["All"] + FENESTRATION_TYPES,
-        key="library_fenestration_type_filter"
-    )
-    
-    # Get library fenestrations
-    library_fenestrations = st.session_state.project_data["fenestrations"]["library"]
-    
-    # Apply filter
-    if type_filter != "All":
-        filtered_fenestrations = {
-            name: props for name, props in library_fenestrations.items()
-            if props["type"] == type_filter
-        }
-    else:
-        filtered_fenestrations = library_fenestrations
+def display_fenestrations_tab():
+    """Display the fenestrations tab content with two-column layout."""
+    # Split the display into two columns
+    col1, col2 = st.columns([3, 2])
     
-    # Display fenestrations in a table
-    if filtered_fenestrations:
-        # Create a DataFrame for display
-        data = []
-        for name, props in filtered_fenestrations.items():
-            data.append({
-                "Name": name,
-                "Type": props["type"],
-                "U-Value (W/m²·K)": props["u_value"],
-                "SHGC": props["shgc"],
-                "Visible Transmittance": props["visible_transmittance"]
-            })
+    with col1:
+        st.subheader("Saved Fenestrations")
         
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
+        # Get fenestrations from session state
+        fenestrations_library = st.session_state.project_data["fenestrations"]["library"]
+        fenestrations_project = st.session_state.project_data["fenestrations"]["project"]
         
-        # Add to project button
-        selected_fenestration = st.selectbox(
-            "Select Fenestration to Add to Project",
-            list(filtered_fenestrations.keys()),
-            key="library_fenestration_selector"
-        )
+        # Display library fenestrations
+        if fenestrations_library:
+            st.write("**Library Fenestrations:**")
+            display_fenestrations_table(fenestrations_library, "library")
         
-        if st.button("Add to Project", key="add_library_fenestration_to_project"):
-            # Check if fenestration already exists in project
-            if selected_fenestration in st.session_state.project_data["fenestrations"]["project"]:
-                st.warning(f"Fenestration '{selected_fenestration}' already exists in your project.")
-            else:
-                # Add to project fenestrations
-                st.session_state.project_data["fenestrations"]["project"][selected_fenestration] = \
-                    st.session_state.project_data["fenestrations"]["library"][selected_fenestration].copy()
-                st.success(f"Fenestration '{selected_fenestration}' added to your project.")
-                logger.info(f"Added library fenestration '{selected_fenestration}' to project")
-    else:
-        st.info("No fenestrations found in the selected type.")
-
-def display_project_fenestrations():
-    """Display the project fenestrations section."""
-    # Get project fenestrations
-    project_fenestrations = st.session_state.project_data["fenestrations"]["project"]
+        # 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.")
     
-    if project_fenestrations:
-        # Create a DataFrame for display
-        data = []
-        for name, props in project_fenestrations.items():
-            data.append({
-                "Name": name,
-                "Type": props["type"],
-                "U-Value (W/m²·K)": props["u_value"],
-                "SHGC": props["shgc"],
-                "Visible Transmittance": props["visible_transmittance"]
-            })
+    with col2:
+        st.subheader("Fenestration Editor/Creator")
         
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
+        # Check if we have an editor state for fenestrations
+        if "fenestration_editor" not in st.session_state:
+            st.session_state.fenestration_editor = {}
         
-        # Edit and delete options
-        col1, col2 = st.columns(2)
+        # 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}
         
-        with col1:
-            selected_fenestration = st.selectbox(
-                "Select Fenestration to Edit",
-                list(project_fenestrations.keys()),
-                key="project_fenestration_edit_selector"
-            )
+        # 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)
             
-            if st.button("Edit Fenestration", key="edit_project_fenestration"):
-                # Load fenestration data into editor
-                fenestration_data = project_fenestrations[selected_fenestration]
-                st.session_state.fenestration_editor = {
-                    "name": selected_fenestration,
-                    "type": fenestration_data["type"],
-                    "u_value": fenestration_data["u_value"],
-                    "shgc": fenestration_data["shgc"],
-                    "visible_transmittance": fenestration_data["visible_transmittance"],
-                    "thickness": fenestration_data["thickness"],
-                    "embodied_carbon": fenestration_data["embodied_carbon"],
-                    "cost": fenestration_data["cost"],
-                    "edit_mode": True,
-                    "original_name": selected_fenestration
-                }
-                st.success(f"Fenestration '{selected_fenestration}' loaded for editing.")
-        
-        with col2:
-            selected_fenestration_delete = st.selectbox(
-                "Select Fenestration to Delete",
-                list(project_fenestrations.keys()),
-                key="project_fenestration_delete_selector"
+            # Fenestration name
+            name = st.text_input(
+                "Fenestration Name",
+                value=editor_state.get("name", ""),
+                help="Enter a unique name for this fenestration."
             )
             
-            if st.button("Delete Fenestration", key="delete_project_fenestration"):
-                # Check if fenestration is in use
-                is_in_use = check_fenestration_in_use(selected_fenestration_delete)
-                
-                if is_in_use:
-                    st.error(f"Cannot delete fenestration '{selected_fenestration_delete}' because it is in use in components.")
-                else:
-                    # Delete fenestration
-                    del st.session_state.project_data["fenestrations"]["project"][selected_fenestration_delete]
-                    st.success(f"Fenestration '{selected_fenestration_delete}' deleted from your project.")
-                    logger.info(f"Deleted fenestration '{selected_fenestration_delete}' from project")
-    else:
-        st.info("No fenestrations in your project. Add fenestrations from the library or create custom fenestrations.")
-
-def display_fenestration_editor():
-    """Display the fenestration editor form."""
-    with st.form("fenestration_editor_form"):
-        # Fenestration name
-        name = st.text_input(
-            "Fenestration Name",
-            value=st.session_state.fenestration_editor["name"],
-            help="Enter a unique name for the fenestration."
-        )
-        
-        # Create two columns for layout
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # Type
+            # Fenestration type
             fenestration_type = st.selectbox(
                 "Type",
                 FENESTRATION_TYPES,
-                index=FENESTRATION_TYPES.index(st.session_state.fenestration_editor["type"]) if st.session_state.fenestration_editor["type"] in FENESTRATION_TYPES else 0,
+                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."
             )
             
-            # U-value
+            # 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(st.session_state.fenestration_editor["u_value"]),
+                value=float(editor_state.get("u_value", 2.5)),
                 format="%.2f",
-                help="U-value in W/m²·K. Lower values indicate better insulation."
+                help="Overall heat transfer coefficient."
             )
             
-            # SHGC
-            shgc = st.number_input(
-                "Solar Heat Gain Coefficient (SHGC)",
-                min_value=0.0,
-                max_value=1.0,
-                value=float(st.session_state.fenestration_editor["shgc"]),
-                format="%.2f",
-                help="Solar Heat Gain Coefficient (0-1). Lower values indicate less solar heat transmission."
-            )
-        
-        with col2:
-            # Visible transmittance
-            visible_transmittance = st.number_input(
-                "Visible Transmittance",
-                min_value=0.0,
-                max_value=1.0,
-                value=float(st.session_state.fenestration_editor["visible_transmittance"]),
-                format="%.2f",
-                help="Visible Transmittance (0-1). Higher values indicate more visible light transmission."
-            )
+            # 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."
+                )
+                
+                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",
+                    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."
+                )
             
-            # Thickness
+            # Physical properties
+            st.write("**Physical Properties:**")
             thickness = st.number_input(
                 "Thickness (m)",
-                min_value=0.001,
+                min_value=0.003,
                 max_value=0.1,
-                value=float(st.session_state.fenestration_editor["thickness"]),
+                value=float(editor_state.get("thickness", 0.024)),
                 format="%.3f",
-                help="Thickness in meters."
+                help="Overall thickness of the fenestration."
             )
-        
-        # Additional properties for embodied carbon and cost
-        st.subheader("Additional Properties")
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # Embodied carbon
+            
+            # Environmental and cost properties
+            st.write("**Environmental & Cost Properties:**")
             embodied_carbon = st.number_input(
-                "Embodied Carbon (kg CO₂e/m²)",
+                "Embodied Carbon (kgCO2e/m²)",
                 min_value=0.0,
-                max_value=5000.0,
-                value=float(st.session_state.fenestration_editor["embodied_carbon"]),
+                max_value=2000.0,
+                value=float(editor_state.get("embodied_carbon", 500.0)),
                 format="%.1f",
-                help="Embodied carbon in kg CO₂e per square meter."
+                help="Embodied carbon per unit area."
             )
-        
-        with col2:
-            # Cost
-            cost = st.number_input(
-                "Cost (USD/m²)",
-                min_value=0.0,
-                max_value=5000.0,
-                value=float(st.session_state.fenestration_editor["cost"]),
-                format="%.1f",
-                help="Fenestration cost in USD per square meter."
+            
+            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."
+                )
+            
+            with col_lab_cost:
+                labor_cost = st.number_input(
+                    "Labor Cost ($/m²)",
+                    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."
+                )
+            
+            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."
             )
-        
-        # Form submission buttons
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            submit_button = st.form_submit_button("Save Fenestration")
-        
-        with col2:
-            clear_button = st.form_submit_button("Clear Form")
-    
-    # Handle form submission
-    if submit_button:
-        # Validate inputs
-        validation_errors = validate_fenestration(
-            name, fenestration_type, u_value, shgc, visible_transmittance, thickness,
-            embodied_carbon, cost, st.session_state.fenestration_editor["edit_mode"],
-            st.session_state.fenestration_editor["original_name"]
-        )
-        
-        if validation_errors:
-            # Display validation errors
-            for error in validation_errors:
-                st.error(error)
-        else:
-            # Create fenestration data
-            fenestration_data = {
-                "type": fenestration_type,
-                "u_value": u_value,
-                "shgc": shgc,
-                "visible_transmittance": visible_transmittance,
-                "thickness": thickness,
-                "embodied_carbon": embodied_carbon,
-                "cost": cost
-            }
             
-            # Handle edit mode
-            if st.session_state.fenestration_editor["edit_mode"]:
-                original_name = st.session_state.fenestration_editor["original_name"]
+            # 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()}"
+                }
                 
-                # If name changed, delete old entry and create new one
-                if original_name != name:
-                    del st.session_state.project_data["fenestrations"]["project"][original_name]
+                # 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
                 
-                # Update fenestration
-                st.session_state.project_data["fenestrations"]["project"][name] = fenestration_data
-                st.success(f"Fenestration '{name}' updated successfully.")
-                logger.info(f"Updated fenestration '{name}' in project")
-            else:
-                # Add new fenestration
-                st.session_state.project_data["fenestrations"]["project"][name] = fenestration_data
-                st.success(f"Fenestration '{name}' added to your project.")
-                logger.info(f"Added new fenestration '{name}' to project")
+                # 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"]
             
-            # Reset editor
-            reset_fenestration_editor()
-    
-    # Handle clear button
-    if clear_button:
-        reset_fenestration_editor()
-        st.rerun()
+            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 validate_material(
-    name: str, category: str, thermal_conductivity: float, density: float,
-    specific_heat: float, thickness_range: Tuple[float, float], default_thickness: float,
-    embodied_carbon: float, cost: float, edit_mode: bool, original_name: str
-) -> List[str]:
-    """
-    Validate material inputs.
-    
-    Args:
-        name: Material name
-        category: Material category
-        thermal_conductivity: Thermal conductivity in W/m·K
-        density: Density in kg/m³
-        specific_heat: Specific heat in J/kg·K
-        thickness_range: Tuple of (min_thickness, max_thickness) in meters
-        default_thickness: Default thickness in meters
-        embodied_carbon: Embodied carbon in kg CO₂e/m³
-        cost: Cost in USD/m³
-        edit_mode: Whether in edit mode
-        original_name: Original name if in edit mode
-        
-    Returns:
-        List of validation error messages, empty if all inputs are valid
-    """
-    errors = []
-    
-    # Validate name
-    if not name or name.strip() == "":
-        errors.append("Material name is required.")
-    
-    # Check for name uniqueness if not in edit mode or if name changed
-    if not edit_mode or (edit_mode and name != original_name):
-        if name in st.session_state.project_data["materials"]["project"]:
-            errors.append(f"Material name '{name}' already exists in your project.")
-    
-    # Validate category
-    if category not in MATERIAL_CATEGORIES:
-        errors.append("Please select a valid material category.")
-    
-    # Validate thermal conductivity
-    if thermal_conductivity <= 0:
-        errors.append("Thermal conductivity must be greater than zero.")
-    
-    # Validate density
-    if density <= 0:
-        errors.append("Density must be greater than zero.")
-    
-    # Validate specific heat
-    if specific_heat <= 0:
-        errors.append("Specific heat must be greater than zero.")
-    
-    # Validate thickness range
-    if thickness_range[0] <= 0:
-        errors.append("Minimum thickness must be greater than zero.")
-    if thickness_range[0] >= thickness_range[1]:
-        errors.append("Maximum thickness must be greater than minimum thickness.")
-    
-    # Validate default thickness
-    if default_thickness < thickness_range[0] or default_thickness > thickness_range[1]:
-        errors.append("Default thickness must be within the thickness range.")
-    
-    # Validate embodied carbon
-    if embodied_carbon < 0:
-        errors.append("Embodied carbon cannot be negative.")
-    
-    # Validate cost
-    if cost < 0:
-        errors.append("Cost cannot be negative.")
+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)
+                        }
+                        
+                        # 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)
+                        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()
+
+def display_materials_help():
+    """Display help information for the materials page."""
+    st.markdown("""
+    ### Material Library Help
     
-    return errors
+    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
+    """)
 
-def validate_fenestration(
-    name: str, fenestration_type: str, u_value: float, shgc: float,
-    visible_transmittance: float, thickness: float, embodied_carbon: float,
-    cost: float, edit_mode: bool, original_name: str
-) -> List[str]:
-    """
-    Validate fenestration inputs.
+# Helper functions for backward compatibility
+def get_available_materials():
+    """Get all available materials (library + project) for use in other modules."""
+    materials = {}
     
-    Args:
-        name: Fenestration name
-        fenestration_type: Fenestration type
-        u_value: U-value in W/m²·K
-        shgc: Solar Heat Gain Coefficient (0-1)
-        visible_transmittance: Visible Transmittance (0-1)
-        thickness: Thickness in meters
-        embodied_carbon: Embodied carbon in kg CO₂e/m²
-        cost: Cost in USD/m²
-        edit_mode: Whether in edit mode
-        original_name: Original name if in edit mode
+    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"])
         
-    Returns:
-        List of validation error messages, empty if all inputs are valid
-    """
-    errors = []
-    
-    # Validate name
-    if not name or name.strip() == "":
-        errors.append("Fenestration name is required.")
-    
-    # Check for name uniqueness if not in edit mode or if name changed
-    if not edit_mode or (edit_mode and name != original_name):
-        if name in st.session_state.project_data["fenestrations"]["project"]:
-            errors.append(f"Fenestration name '{name}' already exists in your project.")
-    
-    # Validate type
-    if fenestration_type not in FENESTRATION_TYPES:
-        errors.append("Please select a valid fenestration type.")
-    
-    # Validate u_value
-    if u_value <= 0:
-        errors.append("U-value must be greater than zero.")
-    
-    # Validate shgc
-    if shgc < 0 or shgc > 1:
-        errors.append("SHGC must be between 0 and 1.")
+        # Add project materials
+        if "project" in st.session_state.project_data["materials"]:
+            materials.update(st.session_state.project_data["materials"]["project"])
     
-    # Validate visible transmittance
-    if visible_transmittance < 0 or visible_transmittance > 1:
-        errors.append("Visible transmittance must be between 0 and 1.")
-    
-    # Validate thickness
-    if thickness <= 0:
-        errors.append("Thickness must be greater than zero.")
-    
-    # Validate embodied carbon
-    if embodied_carbon < 0:
-        errors.append("Embodied carbon cannot be negative.")
-    
-    # Validate cost
-    if cost < 0:
-        errors.append("Cost cannot be negative.")
-    
-    return errors
+    return materials
 
-def reset_material_editor():
-    """Reset the material editor to default values."""
-    st.session_state.material_editor = {
-        "name": "",
-        "category": MATERIAL_CATEGORIES[0],
-        "thermal_conductivity": 0.5,
-        "density": 1000.0,
-        "specific_heat": 1000.0,
-        "thickness_range": [0.01, 0.2],
-        "default_thickness": 0.05,
-        "embodied_carbon": 100.0,
-        "cost": 100.0,
-        "edit_mode": False,
-        "original_name": ""
-    }
-
-def reset_fenestration_editor():
-    """Reset the fenestration editor to default values."""
-    st.session_state.fenestration_editor = {
-        "name": "",
-        "type": FENESTRATION_TYPES[0],
-        "u_value": 2.8,
-        "shgc": 0.7,
-        "visible_transmittance": 0.8,
-        "thickness": 0.024,
-        "embodied_carbon": 900.0,
-        "cost": 200.0,
-        "edit_mode": False,
-        "original_name": ""
-    }
-
-def check_material_in_use(material_name: str) -> bool:
-    """
-    Check if a material is in use in any constructions.
+def get_available_fenestrations():
+    """Get all available fenestrations (library + project) for use in other modules."""
+    fenestrations = {}
     
-    Args:
-        material_name: Name of the material to check
+    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"])
         
-    Returns:
-        True if the material is in use, False otherwise
-    """
-    # This is a placeholder function that will be implemented when constructions are added
-    # For now, we'll assume materials are not in use
-    return False
-
-def check_fenestration_in_use(fenestration_name: str) -> bool:
-    """
-    Check if a fenestration is in use in any components.
+        # Add project fenestrations
+        if "project" in st.session_state.project_data["fenestrations"]:
+            fenestrations.update(st.session_state.project_data["fenestrations"]["project"])
     
-    Args:
-        fenestration_name: Name of the fenestration to check
-        
-    Returns:
-        True if the fenestration is in use, False otherwise
-    """
-    # This is a placeholder function that will be implemented when components are added
-    # For now, we'll assume fenestrations are not in use
-    return False
+    return fenestrations
 
-def display_materials_help():
-    """Display help information for the material library page."""
-    st.markdown("""
-    ### Material Library Help
-    
-    This section allows you to manage building materials and fenestrations for your project.
-    
-    **Materials Tab:**
-    
-    * **Library Materials**: Pre-defined materials with standard thermal properties.
-    * **Project Materials**: Materials you've added to your project from the library or created custom.
-    * **Material Editor**: Create new materials or edit existing ones in your project.
-    
-    **Fenestrations Tab:**
-    
-    * **Library Fenestrations**: Pre-defined windows, doors, and skylights with standard thermal properties.
-    * **Project Fenestrations**: Fenestrations you've added to your project from the library or created custom.
-    * **Fenestration Editor**: Create new fenestrations or edit existing ones in your project.
-    
-    **Key Properties:**
-    
-    * **Thermal Conductivity (W/m·K)**: Rate of heat transfer through a material. Lower values indicate better insulation.
-    * **Density (kg/m³)**: Mass per unit volume.
-    * **Specific Heat (J/kg·K)**: Energy required to raise the temperature of 1 kg by 1 K. Higher values indicate better thermal mass.
-    * **U-Value (W/m²·K)**: Overall heat transfer coefficient for fenestrations. Lower values indicate better insulation.
-    * **SHGC**: Solar Heat Gain Coefficient (0-1). Fraction of incident solar radiation that enters through a fenestration.
-    * **Visible Transmittance**: Fraction of visible light that passes through a fenestration.
-    * **Embodied Carbon**: Carbon emissions associated with material production, measured in kg CO₂e per unit volume or area.
-    * **Cost**: Material cost in USD per unit volume or area.
-    
-    **Workflow:**
-    
-    1. Browse the library materials and fenestrations
-    2. Add items to your project or create custom ones
-    3. Edit properties as needed for your specific project
-    4. Continue to the Construction page to create assemblies using these materials
-    """)