Update app/materials_library.py

app/materials_library.py

@@ -18,7 +18,7 @@ import uuid
 from typing import Dict, List, Any, Optional, Tuple, Union
 
 # Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 # Define constants
@@ -37,6 +37,17 @@ FENESTRATION_TYPES = [
     "Custom"
 ]
 
+COLOUR_CATEGORIES = [
+    "Light",      # Absorptivity: 0.30–0.50 (e.g., white paints, aluminium coatings)
+    "Medium",     # Absorptivity: 0.60–0.70 (e.g., beige, tan, concrete)
+    "Dark",       # Absorptivity: 0.85–0.95 (e.g., black surfaces, dark roofs)
+    "Reflective"  # Absorptivity: 0.10–0.20 (e.g., polished metals)
+]
+
+# Surface resistances
+R_SI = 0.12  # Internal surface resistance (m²·K/W)
+R_SE = 0.04  # External surface resistance (m²·K/W)
+
 # Default library materials
 DEFAULT_MATERIALS = {
     "Brick": {
@@ -44,150 +55,180 @@ DEFAULT_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³
+        "embodied_carbon": 240.0,
+        "cost": 180.0,
+        "absorptivity": 0.65,
+        "emissivity": 0.90,
+        "colour": "Medium"
     },
     "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
+        "cost": 120.0,
+        "absorptivity": 0.60,
+        "emissivity": 0.88,
+        "colour": "Medium"
     },
     "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
+        "cost": 90.0,
+        "absorptivity": 0.40,
+        "emissivity": 0.90,
+        "colour": "Light"
     },
     "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
+        "cost": 70.0,
+        "absorptivity": 0.50,
+        "emissivity": 0.95,
+        "colour": "Light"
     },
     "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
+        "cost": 65.0,
+        "absorptivity": 0.40,
+        "emissivity": 0.92,
+        "colour": "Light"
     },
     "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
+        "cost": 250.0,
+        "absorptivity": 0.65,
+        "emissivity": 0.90,
+        "colour": "Medium"
     },
     "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
+        "cost": 800.0,
+        "absorptivity": 0.15,
+        "emissivity": 0.20,
+        "colour": "Reflective"
     },
     "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
+        "cost": 1200.0,
+        "absorptivity": 0.10,
+        "emissivity": 0.05,
+        "colour": "Reflective"
     },
     "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
+        "cost": 45.0,
+        "absorptivity": 0.50,
+        "emissivity": 0.95,
+        "colour": "Light"
     },
     "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
+        "cost": 280.0,
+        "absorptivity": 0.60,
+        "emissivity": 0.90,
+        "colour": "Medium"
     },
     "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
+        "cost": 150.0,
+        "absorptivity": 0.70,
+        "emissivity": 0.95,
+        "colour": "Medium"
     },
     "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
+        "cost": 180.0,
+        "absorptivity": 0.65,
+        "emissivity": 0.90,
+        "colour": "Medium"
     },
     "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
+        "cost": 140.0,
+        "absorptivity": 0.60,
+        "emissivity": 0.88,
+        "colour": "Medium"
     },
     "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
+        "cost": 450.0,
+        "absorptivity": 0.85,
+        "emissivity": 0.90,
+        "colour": "Dark"
     },
     "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
+        "cost": 95.0,
+        "absorptivity": 0.40,
+        "emissivity": 0.92,
+        "colour": "Light"
     }
 }
 
@@ -199,8 +240,8 @@ DEFAULT_FENESTRATIONS = {
         "shgc": 0.86,
         "visible_transmittance": 0.9,
         "thickness": 0.006,
-        "embodied_carbon": 800.0,  # kg CO2e/m²
-        "cost": 120.0  # USD/m²
+        "embodied_carbon": 800.0,
+        "cost": 120.0
     },
     "Double Glazing (Air)": {
         "type": "Window",
@@ -285,29 +326,90 @@ DEFAULT_FENESTRATIONS = {
     }
 }
 
+def calculate_u_value(thermal_conductivity: float, thickness: float) -> float:
+    """Calculate U-value for a material."""
+    r_material = thickness / thermal_conductivity if thermal_conductivity > 0 else float('inf')
+    r_total = R_SI + r_material + R_SE
+    return 1 / r_total if r_total > 0 else 0.0
+
+def calculate_thermal_mass(density: float, specific_heat: float, thickness: float) -> float:
+    """Calculate areal thermal mass for a material."""
+    return density * specific_heat * thickness
+
+def categorize_thermal_mass(thermal_mass: float) -> str:
+    """Categorize thermal mass based on given ranges."""
+    if thermal_mass < 30000:
+        return "Low"
+    elif 30000 <= thermal_mass <= 90000:
+        return "Medium"
+    else:
+        return "High"
+
+def get_stable_button_key(prefix: str, name: str, action: str, unique_id: str = None) -> str:
+    """Generate a stable button key based on prefix, name, action, and optional unique identifier."""
+    import hashlib
+    unique_id = unique_id or str(uuid.uuid4())[:8]
+    key_string = f"{prefix}_{name}_{action}_{unique_id}"
+    hash_key = hashlib.md5(key_string.encode()).hexdigest()[:8]
+    return f"{prefix}_{action}_{name}_{hash_key}"
+
+def initialize_session_state():
+    """Initialize all required session state variables."""
+    if "project_data" not in st.session_state:
+        st.session_state.project_data = {
+            "materials": {"library": DEFAULT_MATERIALS.copy(), "project": {}, "table": None},
+            "fenestrations": {"library": DEFAULT_FENESTRATIONS.copy(), "project": {}, "table": None}
+        }
+    if "material_editor" not in st.session_state:
+        reset_material_editor()
+    if "fenestration_editor" not in st.session_state:
+        reset_fenestration_editor()
+    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 "current_page" not in st.session_state:
+        st.session_state.current_page = "Material Library"
+    logger.debug("Session state initialized")
+    logger.debug(f"Project materials: {list(st.session_state.project_data['materials']['project'].keys())}")
+    logger.debug(f"Project fenestrations: {list(st.session_state.project_data['fenestrations']['project'].keys())}")
+
 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.
     """
+    initialize_session_state()
+
+    # Apply custom CSS for button styling
+    st.markdown("""
+    <style>
+    .stButton>button {
+        width: 100%;
+        font-size: 12px;
+        padding: 5px;
+        margin: 0;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
     st.title("Material Library")
     
-    # Display help information in an expandable section
     with st.expander("Help & Information"):
         display_materials_help()
     
-    # Create tabs for materials and fenestrations
     tab1, tab2 = st.tabs(["Materials", "Fenestrations"])
     
-    # Materials tab
     with tab1:
+        st.session_state.active_tab = "Materials"
         display_materials_tab()
     
-    # Fenestrations tab
     with tab2:
+        st.session_state.active_tab = "Fenestrations"
         display_fenestrations_tab()
     
-    # Navigation buttons
     col1, col2 = st.columns(2)
     
     with col1:
@@ -320,860 +422,974 @@ def display_materials_page():
             st.session_state.current_page = "Construction"
             st.rerun()
 
+def handle_material_action(action: Dict[str, Any]):
+    """Handle material-related actions."""
+    if action["action"] == "preview":
+        material = action["material"]
+        name = action["name"]
+        st.session_state.material_editor = {
+            "name": name,
+            "category": material["category"],
+            "thermal_conductivity": material["thermal_conductivity"],
+            "density": material["density"],
+            "specific_heat": material["specific_heat"],
+            "default_thickness": material["default_thickness"],
+            "embodied_carbon": material["embodied_carbon"],
+            "cost": material["cost"],
+            "absorptivity": material["absorptivity"],
+            "emissivity": material["emissivity"],
+            "colour": material["colour"],
+            "edit_mode": False,
+            "original_name": name,
+            "is_library": action["is_library"]
+        }
+        st.session_state.material_form_state = {
+            "name": name,
+            "category": material["category"],
+            "thermal_conductivity": float(material["thermal_conductivity"]),
+            "density": float(material["density"]),
+            "specific_heat": float(material["specific_heat"]),
+            "default_thickness": float(material["default_thickness"]),
+            "embodied_carbon": float(material["embodied_carbon"]),
+            "cost": float(material["cost"]),
+            "absorptivity": float(material["absorptivity"]),
+            "emissivity": float(material["emissivity"]),
+            "colour": material["colour"]
+        }
+        logger.info(f"Previewed material '{name}'")
+        st.rerun()
+    elif action["action"] == "copy":
+        name = action["name"]
+        material = action["material"]
+        new_name = f"{name}_Project"
+        counter = 1
+        library_materials = st.session_state.project_data["materials"]["library"]
+        while new_name in st.session_state.project_data["materials"]["project"] or new_name in library_materials:
+            new_name = f"{name}_Project_{counter}"
+            counter += 1
+        st.session_state.project_data["materials"]["project"][new_name] = material.copy()
+        st.success(f"Material '{new_name}' copied to project.")
+        logger.info(f"Copied library material '{name}' as '{new_name}' to project")
+        # Update project materials table
+        update_project_materials_table()
+        st.rerun()
+    elif action["action"] == "edit":
+        material = action["material"]
+        name = action["name"]
+        st.session_state.material_editor = {
+            "name": name,
+            "category": material["category"],
+            "thermal_conductivity": material["thermal_conductivity"],
+            "density": material["density"],
+            "specific_heat": material["specific_heat"],
+            "default_thickness": material["default_thickness"],
+            "embodied_carbon": material["embodied_carbon"],
+            "cost": material["cost"],
+            "absorptivity": material["absorptivity"],
+            "emissivity": material["emissivity"],
+            "colour": material["colour"],
+            "edit_mode": True,
+            "original_name": name,
+            "is_library": False
+        }
+        st.session_state.material_form_state = {
+            "name": name,
+            "category": material["category"],
+            "thermal_conductivity": float(material["thermal_conductivity"]),
+            "density": float(material["density"]),
+            "specific_heat": float(material["specific_heat"]),
+            "default_thickness": float(material["default_thickness"]),
+            "embodied_carbon": float(material["embodied_carbon"]),
+            "cost": float(material["cost"]),
+            "absorptivity": float(material["absorptivity"]),
+            "emissivity": float(material["emissivity"]),
+            "colour": material["colour"]
+        }
+        logger.info(f"Editing material '{name}'")
+        st.rerun()
+    elif action["action"] == "delete":
+        name = action["name"]
+        is_in_use = check_material_in_use(name)
+        if is_in_use:
+            st.error(f"Cannot delete material '{name}' because it is in use in constructions.")
+        else:
+            del st.session_state.project_data["materials"]["project"][name]
+            st.success(f"Material '{name}' deleted from project.")
+            logger.info(f"Deleted material '{name}' from project")
+            # Update project materials table
+            update_project_materials_table()
+            st.rerun()
+
+def handle_fenestration_action(action: Dict[str, Any]):
+    """Handle fenestration-related actions."""
+    if action["action"] == "preview":
+        fenestration = action["fenestration"]
+        name = action["name"]
+        st.session_state.fenestration_editor = {
+            "name": name,
+            "type": fenestration["type"],
+            "u_value": fenestration["u_value"],
+            "shgc": fenestration["shgc"],
+            "visible_trans": fenestration["visible_transmittance"],
+            "thickness": fenestration["thickness"],
+            "embodied_carbon": fenestration["embodied_carbon"],
+            "cost": fenestration["cost"],
+            "edit_mode": False,
+            "original_name": name,
+            "is_library": action["is_library"]
+        }
+        st.session_state.fenestration_form_state = {
+            "name": name,
+            "type": fenestration["type"],
+            "u_value": float(fenestration["u_value"]),
+            "shgc": float(fenestration["shgc"]),
+            "visible_trans": float(fenestration["visible_transmittance"]),
+            "thickness": float(fenestration["thickness"]),
+            "embodied_carbon": float(fenestration["embodied_carbon"]),
+            "cost": float(fenestration["cost"])
+        }
+        logger.info(f"Previewed fenestration '{name}'")
+        st.rerun()
+    elif action["action"] == "copy":
+        name = action["name"]
+        fenestration = action["fenestration"]
+        new_name = f"{name}_Project"
+        counter = 1
+        library_fenestrations = st.session_state.project_data["fenestrations"]["library"]
+        while new_name in st.session_state.project_data["fenestrations"]["project"] or new_name in library_fenestrations:
+            new_name = f"{name}_Project_{counter}"
+            counter += 1
+        st.session_state.project_data["fenestrations"]["project"][new_name] = fenestration.copy()
+        st.success(f"Fenestration '{new_name}' copied to project.")
+        logger.info(f"Copied library fenestration '{name}' as '{new_name}' to project")
+        # Update project fenestrations table
+        update_project_fenestrations_table()
+        st.rerun()
+    elif action["action"] == "edit":
+        fenestration = action["fenestration"]
+        name = action["name"]
+        st.session_state.fenestration_editor = {
+            "name": name,
+            "type": fenestration["type"],
+            "u_value": fenestration["u_value"],
+            "shgc": fenestration["shgc"],
+            "visible_trans": fenestration["visible_transmittance"],
+            "thickness": fenestration["thickness"],
+            "embodied_carbon": fenestration["embodied_carbon"],
+            "cost": fenestration["cost"],
+            "edit_mode": True,
+            "original_name": name,
+            "is_library": False
+        }
+        st.session_state.fenestration_form_state = {
+            "name": name,
+            "type": fenestration["type"],
+            "u_value": float(fenestration["u_value"]),
+            "shgc": float(fenestration["shgc"]),
+            "visible_trans": float(fenestration["visible_transmittance"]),
+            "thickness": float(fenestration["thickness"]),
+            "embodied_carbon": float(fenestration["embodied_carbon"]),
+            "cost": float(fenestration["cost"])
+        }
+        logger.info(f"Editing fenestration '{name}'")
+        st.rerun()
+    elif action["action"] == "delete":
+        name = action["name"]
+        is_in_use = check_fenestration_in_use(name)
+        if is_in_use:
+            st.error(f"Cannot delete fenestration '{name}' because it is in use in components.")
+        else:
+            del st.session_state.project_data["fenestrations"]["project"][name]
+            st.success(f"Fenestration '{name}' deleted from project.")
+            logger.info(f"Deleted fenestration '{name}' from project")
+            # Update project fenestrations table
+            update_project_fenestrations_table()
+            st.rerun()
+
+def update_project_materials_table():
+    """Update the project materials table in session state."""
+    project_materials = st.session_state.project_data["materials"]["project"]
+    data = []
+    for name, props in project_materials.items():
+        thermal_mass = calculate_thermal_mass(props["density"], props["specific_heat"], props["default_thickness"])
+        thermal_mass_category = categorize_thermal_mass(thermal_mass)
+        u_value = calculate_u_value(props["thermal_conductivity"], props["default_thickness"])
+        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"],
+            "Thickness (m)": props["default_thickness"],
+            "Embodied Carbon (kg CO₂e/m³)": props["embodied_carbon"],
+            "Cost (USD/m³)": props["cost"],
+            "Absorptivity": props["absorptivity"],
+            "Emissivity": props["emissivity"],
+            "Colour": props["colour"],
+            "Thermal Mass": thermal_mass_category,
+            "U-Value (W/m²·K)": u_value
+        })
+    st.session_state.project_data["materials"]["table"] = pd.DataFrame(data)
+    logger.debug(f"Updated project materials table with {len(data)} entries")
+
+def update_project_fenestrations_table():
+    """Update the project fenestrations table in session state."""
+    project_fenestrations = st.session_state.project_data["fenestrations"]["project"]
+    data = []
+    for name, props in sorted(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"],
+            "Thickness (m)": props["thickness"],
+            "Embodied Carbon (kg/m²)": props["embodied_carbon"],
+            "Cost (USD/m²)": props["cost"]
+        })
+    st.session_state.project_data["fenestrations"]["table"] = pd.DataFrame(data)
+    logger.debug(f"Updated project fenestrations table with {len(data)} entries")
+
 def display_materials_tab():
     """Display the materials tab content."""
-    # Initialize materials in session state if not present
-    initialize_materials()
+    logger.debug("Rendering materials tab")
+    logger.debug(f"Project materials: {list(st.session_state.project_data['materials']['project'].keys())}")
     
-    # Create columns for library and project materials
-    col1, col2 = st.columns(2)
+    st.subheader("Materials")
+    col1, col2 = st.columns([3, 2])
     
-    # Library Materials
     with col1:
+        filter_options = ["All"] + MATERIAL_CATEGORIES
+        category = st.selectbox("Filter by Category", filter_options, key="material_filter")
+        
         st.subheader("Library Materials")
-        display_library_materials()
-    
-    # Project Materials
-    with col2:
+        with st.container():
+            library_materials = st.session_state.project_data["materials"]["library"]
+            filtered_materials = []
+            if category == "All":
+                filtered_materials = list(library_materials.values())
+            else:
+                filtered_materials = [m for m in library_materials.values() if m["category"] == category]
+            
+            if filtered_materials:
+                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 filtered_materials:
+                    cols = st.columns([2, 1, 1, 1, 1])
+                    name = [k for k, v in library_materials.items() if v == material][0]
+                    thermal_mass = calculate_thermal_mass(material["density"], material["specific_heat"], material["default_thickness"])
+                    thermal_mass_category = categorize_thermal_mass(thermal_mass)
+                    u_value = calculate_u_value(material["thermal_conductivity"], material["default_thickness"])
+                    cols[0].write(name)
+                    cols[1].write(thermal_mass_category)
+                    cols[2].write(f"{u_value:.3f}")
+                    
+                    preview_key = get_stable_button_key("lib_mat", name, "preview")
+                    copy_key = get_stable_button_key("lib_mat", name, "copy")
+                    
+                    cols[3].button("Preview", key=preview_key, on_click=handle_material_action, args=([{
+                        "action": "preview",
+                        "name": name,
+                        "material": material,
+                        "is_library": True
+                    }],))
+                    
+                    cols[4].button("Copy", key=copy_key, on_click=handle_material_action, args=([{
+                        "action": "copy",
+                        "name": name,
+                        "material": material
+                    }],))
+            
+            else:
+                st.info("No materials found in the selected category.")
+        
+        project_category = st.selectbox("Filter Project by Category", filter_options, key="project_material_filter")
         st.subheader("Project Materials")
-        display_project_materials()
+        with st.container():
+            project_materials = st.session_state.project_data["materials"]["project"]
+            filtered_project_materials = []
+            if project_category == "All":
+                filtered_project_materials = list(project_materials.values())
+            else:
+                filtered_project_materials = [m for m in project_materials.values() if m["category"] == project_category]
+            
+            if filtered_project_materials:
+                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 filtered_project_materials:
+                    cols = st.columns([2, 1, 1, 1, 1])
+                    name = [k for k, v in project_materials.items() if v == material][0]
+                    thermal_mass = calculate_thermal_mass(material["density"], material["specific_heat"], material["default_thickness"])
+                    thermal_mass_category = categorize_thermal_mass(thermal_mass)
+                    u_value = calculate_u_value(material["thermal_conductivity"], material["default_thickness"])
+                    cols[0].write(name)
+                    cols[1].write(thermal_mass_category)
+                    cols[2].write(f"{u_value:.3f}")
+                    
+                    edit_key = get_stable_button_key("proj_mat", name, "edit")
+                    delete_key = get_stable_button_key("proj_mat", name, "delete")
+                    
+                    cols[3].button("Edit", key=edit_key, on_click=handle_material_action, args=([{
+                        "action": "edit",
+                        "name": name,
+                        "material": material
+                    }],))
+                    
+                    cols[4].button("Delete", key=delete_key, on_click=handle_material_action, args=([{
+                        "action": "delete",
+                        "name": name
+                    }],))
+            
+            else:
+                st.info("No project materials in the selected category.")
+        
+        st.subheader("All Project Materials")
+        if st.session_state.project_data["materials"]["table"] is not None:
+            st.dataframe(st.session_state.project_data["materials"]["table"], use_container_width=True, hide_index=True)
+        else:
+            st.info("No project materials to display.")
     
-    # Material Editor
-    st.markdown("---")
-    st.subheader("Material Editor")
-    display_material_editor()
+    with col2:
+        st.subheader("Material Editor/Creator")
+        display_material_editor()
 
 def display_fenestrations_tab():
     """Display the fenestrations tab content."""
-    # Initialize fenestrations in session state if not present
-    initialize_fenestrations()
+    logger.debug("Rendering fenestrations tab")
+    logger.debug(f"Project fenestrations: {list(st.session_state.project_data['fenestrations']['project'].keys())}")
     
-    # Create columns for library and project fenestrations
-    col1, col2 = st.columns(2)
+    st.subheader("Fenestrations")
+    col1, col2 = st.columns([3, 2])
     
-    # Library Fenestrations
     with col1:
+        filter_options = ["All"] + FENESTRATION_TYPES
+        fen_type = st.selectbox("Filter by Type", filter_options, key="fenestration_filter")
+        
         st.subheader("Library Fenestrations")
-        display_library_fenestrations()
-    
-    # Project Fenestrations
-    with col2:
+        with st.container():
+            library_fenestrations = st.session_state.project_data["fenestrations"]["library"]
+            filtered_fenestrations = []
+            if fen_type == "All":
+                filtered_fenestrations = list(library_fenestrations.values())
+            else:
+                filtered_fenestrations = [f for f in library_fenestrations.values() if f["type"] == fen_type]
+            
+            if filtered_fenestrations:
+                cols = st.columns([2, 1, 1, 1, 1])
+                cols[0].write("**Name**")
+                cols[1].write("**Type**")
+                cols[2].write("**U-Value (W/m²·K)**")
+                cols[3].write("**Preview**")
+                cols[4].write("**Copy**")
+                
+                for fenestration in filtered_fenestrations:
+                    cols = st.columns([2, 1, 1, 1, 1])
+                    name = [k for k, v in library_fenestrations.items() if v == fenestration][0]
+                    cols[0].write(name)
+                    cols[1].write(fenestration["type"])
+                    cols[2].write(f"{fenestration['u_value']:.2f}")
+                    
+                    preview_key = get_stable_button_key("lib_fen", name, "preview")
+                    copy_key = get_stable_button_key("lib_fen", name, "copy")
+                    
+                    cols[3].button("Preview", key=preview_key, on_click=handle_fenestration_action, args=([{
+                        "action": "preview",
+                        "name": name,
+                        "fenestration": fenestration,
+                        "is_library": True
+                    }],))
+                    
+                    cols[4].button("Copy", key=copy_key, on_click=handle_fenestration_action, args=([{
+                        "action": "copy",
+                        "name": name,
+                        "fenestration": fenestration
+                    }],))
+            
+            else:
+                st.info("No fenestrations found in the selected type.")
+        
+        project_fen_type = st.selectbox("Filter Project by Type", filter_options, key="project_fenestration_filter")
         st.subheader("Project Fenestrations")
-        display_project_fenestrations()
+        with st.container():
+            project_fenestrations = st.session_state.project_data["fenestrations"]["project"]
+            filtered_project_fenestrations = []
+            if project_fen_type == "All":
+                filtered_project_fenestrations = list(project_fenestrations.values())
+            else:
+                filtered_project_fenestrations = [f for f in project_fenestrations.values() if f["type"] == project_fen_type]
+            
+            if filtered_project_fenestrations:
+                cols = st.columns([2, 1, 1, 1, 1])
+                cols[0].write("**Name**")
+                cols[1].write("**Type**")
+                cols[2].write("**U-Value (W/m²·K)**")
+                cols[3].write("**Edit**")
+                cols[4].write("**Delete**")
+                
+                for fenestration in filtered_project_fenestrations:
+                    cols = st.columns([2, 1, 1, 1, 1])
+                    name = [k for k, v in project_fenestrations.items() if v == fenestration][0]
+                    cols[0].write(name)
+                    cols[1].write(fenestration["type"])
+                    cols[2].write(f"{fenestration['u_value']:.2f}")
+                    
+                    edit_key = get_stable_button_key("proj_fen", name, "edit")
+                    delete_key = get_stable_button_key("proj_fen", name, "delete")
+                    
+                    cols[3].button("Edit", key=edit_key, on_click=handle_fenestration_action, args=([{
+                        "action": "edit",
+                        "name": name,
+                        "fenestration": fenestration
+                    }],))
+                    
+                    cols[4].button("Delete", key=delete_key, on_click=handle_fenestration_action, args=([{
+                        "action": "delete",
+                        "name": name
+                    }],))
+            
+            else:
+                st.info("No project fenestrations in the selected type.")
+        
+        st.subheader("All Project Fenestrations")
+        if st.session_state.project_data["fenestrations"]["table"] is not None:
+            st.dataframe(st.session_state.project_data["fenestrations"]["table"], use_container_width=True, hide_index=True)
+        else:
+            st.info("No project fenestrations to display.")
     
-    # Fenestration Editor
-    st.markdown("---")
-    st.subheader("Fenestration Editor")
-    display_fenestration_editor()
+    with col2:
+        st.subheader("Fenestration Editor/Creator")
+        display_fenestration_editor()
 
 def initialize_materials():
     """Initialize materials in session state if not present."""
     if "materials" not in st.session_state.project_data:
         st.session_state.project_data["materials"] = {
-            "library": {},
-            "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": ""
+            "library": DEFAULT_MATERIALS.copy(),
+            "project": {},
+            "table": None
         }
+    logger.debug("Materials initialized")
 
 def initialize_fenestrations():
     """Initialize fenestrations in session state if not present."""
     if "fenestrations" not in st.session_state.project_data:
         st.session_state.project_data["fenestrations"] = {
-            "library": {},
-            "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
+            "library": DEFAULT_FENESTRATIONS.copy(),
+            "project": {},
+            "table": None
         }
-    else:
-        filtered_materials = library_materials
-    
-    # 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"]
-            })
-        
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
-        
-        # Add to project button
-        selected_material = st.selectbox(
-            "Select Material to Add to Project",
-            list(filtered_materials.keys()),
-            key="library_material_selector"
-        )
-        
-        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"]
-    
-    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"]
-            })
-        
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
-        
-        # Edit and delete options
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            selected_material = st.selectbox(
-                "Select Material to Edit",
-                list(project_materials.keys()),
-                key="project_material_edit_selector"
-            )
-            
-            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"
-            )
-            
-            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.")
+    logger.debug("Fenestrations initialized")
 
 def display_material_editor():
     """Display the material editor form."""
-    with st.form("material_editor_form"):
-        # Material name
+    with st.form("material_editor_form", clear_on_submit=True):
+        editor_state = st.session_state.material_editor
+        form_state = st.session_state.material_form_state
+        is_library = editor_state.get("is_library", False)
+        
         name = st.text_input(
             "Material Name",
-            value=st.session_state.material_editor["name"],
-            help="Enter a unique name for the material."
+            value=form_state.get("name", editor_state["name"]),
+            help="Enter a unique name for the material.",
+            disabled=is_library
         )
         
-        # Create two columns for layout
         col1, col2 = st.columns(2)
         
         with col1:
-            # Category
+            category_index = MATERIAL_CATEGORIES.index(form_state.get("category", editor_state.get("category", MATERIAL_CATEGORIES[0])))
             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,
-                help="Select the material category."
+                index=category_index,
+                help="Select the material category.",
+                disabled=is_library
             )
             
-            # Thermal conductivity
             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"]),
+                value=float(form_state.get("thermal_conductivity", editor_state.get("thermal_conductivity", 0.5))),
                 format="%.3f",
-                help="Thermal conductivity in W/m·K. Lower values indicate better insulation."
+                help="Thermal conductivity in W/m·K. Lower values indicate better insulation.",
+                disabled=is_library
             )
             
-            # Density
             density = st.number_input(
                 "Density (kg/m³)",
                 min_value=1.0,
                 max_value=20000.0,
-                value=float(st.session_state.material_editor["density"]),
+                value=float(form_state.get("density", editor_state.get("density", 1000.0))),
                 format="%.1f",
-                help="Material density in kg/m³."
+                help="Material density in kg/m³.",
+                disabled=is_library
             )
         
         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"]),
+                value=float(form_state.get("specific_heat", 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 in J/kg·K. Higher values indicate better thermal mass.",
+                disabled=is_library
             )
             
-            # Thickness range
-            min_thickness, max_thickness = st.session_state.material_editor["thickness_range"]
-            thickness_range = st.slider(
-                "Thickness Range (m)",
+            default_thickness = st.number_input(
+                "Thickness (m)",
                 min_value=0.001,
                 max_value=0.5,
-                value=(float(min_thickness), float(max_thickness)),
+                value=float(form_state.get("default_thickness", editor_state.get("default_thickness", 0.05))),
                 format="%.3f",
-                help="Minimum and maximum thickness range for this material in meters."
+                help="Thickness for this material in meters.",
+                disabled=is_library
             )
             
-            # 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."
+            absorptivity = st.number_input(
+                "Absorptivity",
+                min_value=0.0,
+                max_value=1.0,
+                value=float(form_state.get("absorptivity", editor_state.get("absorptivity", 0.60))),
+                format="%.2f",
+                help="Solar radiation absorbed (0-1).",
+                disabled=is_library
+            )
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            emissivity = st.number_input(
+                "Emissivity",
+                min_value=0.0,
+                max_value=1.0,
+                value=float(form_state.get("emissivity", editor_state.get("emissivity", 0.90))),
+                format="%.2f",
+                help="Ratio of radiation emitted (0-1).",
+                disabled=is_library
+            )
+        
+        with col2:
+            colour_index = COLOUR_CATEGORIES.index(form_state.get("colour", editor_state.get("colour", "Medium"))) if form_state.get("colour", editor_state.get("colour", "Medium")) in COLOUR_CATEGORIES else 0
+            colour = st.selectbox(
+                "Colour Category",
+                COLOUR_CATEGORIES,
+                index=colour_index,
+                help="Colour category affecting absorptivity.",
+                disabled=is_library
             )
         
-        # Additional properties for embodied carbon and cost
         st.subheader("Additional Properties")
         col1, col2 = st.columns(2)
         
         with col1:
-            # Embodied carbon
             embodied_carbon = st.number_input(
                 "Embodied Carbon (kg CO₂e/m³)",
                 min_value=0.0,
                 max_value=10000.0,
-                value=float(st.session_state.material_editor["embodied_carbon"]),
+                value=float(form_state.get("embodied_carbon", editor_state.get("embodied_carbon", 100.0))),
                 format="%.1f",
-                help="Embodied carbon in kg CO₂e per cubic meter."
+                help="Embodied carbon in kg CO₂e per cubic meter.",
+                disabled=is_library
             )
         
         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"]),
+                value=float(form_state.get("cost", editor_state.get("cost", 100.0))),
                 format="%.1f",
-                help="Material cost in USD per cubic meter."
+                help="Material cost in USD per cubic meter.",
+                disabled=is_library
             )
         
-        # Form submission buttons
         col1, col2 = st.columns(2)
         
         with col1:
-            submit_button = st.form_submit_button("Save Material")
+            submit_button = st.form_submit_button("Save Material", disabled=is_library)
         
         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 = {
+        if submit_button and not is_library:
+            st.session_state.material_form_state = {
+                "name": name,
                 "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
+                "cost": cost,
+                "absorptivity": absorptivity,
+                "emissivity": emissivity,
+                "colour": colour
             }
-            
-            # Handle edit mode
-            if st.session_state.material_editor["edit_mode"]:
-                original_name = st.session_state.material_editor["original_name"]
-                
-                # If name changed, delete old entry and create new one
-                if original_name != name:
-                    del st.session_state.project_data["materials"]["project"][original_name]
-                
-                # 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()
-
-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
-    
-    # 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"]
-            })
-        
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
-        
-        # Add to project button
-        selected_fenestration = st.selectbox(
-            "Select Fenestration to Add to Project",
-            list(filtered_fenestrations.keys()),
-            key="library_fenestration_selector"
-        )
-        
-        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"]
-    
-    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"]
-            })
-        
-        df = pd.DataFrame(data)
-        st.dataframe(df, use_container_width=True, hide_index=True)
-        
-        # Edit and delete options
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            selected_fenestration = st.selectbox(
-                "Select Fenestration to Edit",
-                list(project_fenestrations.keys()),
-                key="project_fenestration_edit_selector"
+            success, message = validate_material(
+                name, category, thermal_conductivity, density, specific_heat,
+                default_thickness, embodied_carbon, cost,
+                editor_state["edit_mode"], editor_state["original_name"],
+                absorptivity, emissivity, colour
             )
-            
-            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
+            if not success:
+                st.error(message)
+            else:
+                material_data = {
+                    "category": category,
+                    "thermal_conductivity": thermal_conductivity,
+                    "density": density,
+                    "specific_heat": specific_heat,
+                    "default_thickness": default_thickness,
+                    "embodied_carbon": embodied_carbon,
+                    "cost": cost,
+                    "absorptivity": absorptivity,
+                    "emissivity": emissivity,
+                    "colour": colour
                 }
-                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"
-            )
-            
-            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.")
+                if editor_state["edit_mode"]:
+                    original_name = editor_state["original_name"]
+                    if original_name != name:
+                        del st.session_state.project_data["materials"]["project"][original_name]
+                    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:
-                    # 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.")
+                    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")
+                update_project_materials_table()
+                reset_material_editor()
+                st.rerun()
+        
+        if clear_button:
+            reset_material_editor()
 
 def display_fenestration_editor():
     """Display the fenestration editor form."""
-    with st.form("fenestration_editor_form"):
-        # Fenestration name
+    with st.form("fenestration_editor_form", clear_on_submit=True):
+        editor_state = st.session_state.fenestration_editor
+        form_state = st.session_state.fenestration_form_state
+        is_library = editor_state.get("is_library", False)
+        
         name = st.text_input(
             "Fenestration Name",
-            value=st.session_state.fenestration_editor["name"],
-            help="Enter a unique name for the fenestration."
+            value=form_state.get("name", editor_state["name"]),
+            help="Enter a unique name for the fenestration.",
+            disabled=is_library
         )
         
-        # Create two columns for layout
         col1, col2 = st.columns(2)
         
         with col1:
-            # Type
+            type_index = FENESTRATION_TYPES.index(form_state.get("type", editor_state["type"])) if form_state.get("type", editor_state["type"]) in FENESTRATION_TYPES else 0
             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,
-                help="Select the fenestration type."
+                index=type_index,
+                help="Select the fenestration type.",
+                disabled=is_library
             )
             
-            # U-value
             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(form_state.get("u_value", editor_state.get("u_value", 2.8))),
                 format="%.2f",
-                help="U-value in W/m²·K. Lower values indicate better insulation."
+                help="U-value in W/m²·K.",
+                disabled=is_library
             )
             
-            # SHGC
+        with col2:
             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"]),
+                value=float(form_state.get("shgc", editor_state.get("shgc", 0.7))),
                 format="%.2f",
-                help="Solar Heat Gain Coefficient (0-1). Lower values indicate less solar heat transmission."
+                help="Solar Heat Gain Coefficient (0-1).",
+                disabled=is_library
             )
-        
-        with col2:
-            # Visible transmittance
-            visible_transmittance = st.number_input(
+            
+            visible_trans = st.number_input(
                 "Visible Transmittance",
                 min_value=0.0,
                 max_value=1.0,
-                value=float(st.session_state.fenestration_editor["visible_transmittance"]),
+                value=float(form_state.get("visible_trans", editor_state.get("visible_trans", 0.8))),
                 format="%.2f",
-                help="Visible Transmittance (0-1). Higher values indicate more visible light transmission."
+                help="Visible light transmission (0-1).",
+                disabled=is_library
             )
             
-            # Thickness
             thickness = st.number_input(
                 "Thickness (m)",
                 min_value=0.001,
                 max_value=0.1,
-                value=float(st.session_state.fenestration_editor["thickness"]),
+                value=float(form_state.get("thickness", editor_state.get("thickness", 0.024))),
                 format="%.3f",
-                help="Thickness in meters."
+                help="Thickness in meters.",
+                disabled=is_library
             )
         
-        # Additional properties for embodied carbon and cost
         st.subheader("Additional Properties")
+        
         col1, col2 = st.columns(2)
         
         with col1:
-            # Embodied carbon
             embodied_carbon = st.number_input(
                 "Embodied Carbon (kg CO₂e/m²)",
                 min_value=0.0,
                 max_value=5000.0,
-                value=float(st.session_state.fenestration_editor["embodied_carbon"]),
+                value=float(form_state.get("embodied_carbon", editor_state.get("embodied_carbon", 900.0))),
                 format="%.1f",
-                help="Embodied carbon in kg CO₂e per square meter."
+                help="Embodied carbon in kg CO₂e/m².",
+                disabled=is_library
             )
         
         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"]),
+                value=float(form_state.get("cost", editor_state.get("cost", 200.0))),
                 format="%.1f",
-                help="Fenestration cost in USD per square meter."
+                help="Fenestration cost in USD/m².",
+                disabled=is_library
             )
         
-        # Form submission buttons
         col1, col2 = st.columns(2)
         
         with col1:
-            submit_button = st.form_submit_button("Save Fenestration")
+            submit_button = st.form_submit_button("Save Fenestration", disabled=is_library)
         
         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 = {
+        if submit_button and not is_library:
+            st.session_state.fenestration_form_state = {
+                "name": name,
                 "type": fenestration_type,
                 "u_value": u_value,
                 "shgc": shgc,
-                "visible_transmittance": visible_transmittance,
+                "visible_trans": visible_trans,
                 "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"]
-                
-                # If name changed, delete old entry and create new one
-                if original_name != name:
-                    del st.session_state.project_data["fenestrations"]["project"][original_name]
-                
-                # 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")
+            success, message = validate_fenestration(
+                name, fenestration_type, u_value, shgc, visible_trans, thickness,
+                embodied_carbon, cost, editor_state["edit_mode"], editor_state["original_name"]
+            )
+            if not success:
+                st.error(message)
             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")
-            
-            # Reset editor
+                fenestration_data = {
+                    "type": fenestration_type,
+                    "u_value": u_value,
+                    "shgc": shgc,
+                    "visible_transmittance": visible_trans,
+                    "thickness": thickness,
+                    "embodied_carbon": embodied_carbon,
+                    "cost": cost
+                }
+                if editor_state["edit_mode"]:
+                    original_name = editor_state["original_name"]
+                    if original_name != name:
+                        del st.session_state.project_data["fenestrations"]["project"][original_name]
+                    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:
+                    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")
+                update_project_fenestrations_table()
+                reset_fenestration_editor()
+                st.rerun()
+        
+        if clear_button:
             reset_fenestration_editor()
-    
-    # Handle clear button
-    if clear_button:
-        reset_fenestration_editor()
-        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]:
+    specific_heat: float, default_thickness: float, embodied_carbon: float,
+    cost: float, edit_mode: bool, original_name: str,
+    absorptivity: float, emissivity: float, colour: str
+) -> Tuple[bool, 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
+    Returns (success, message) tuple.
     """
-    errors = []
-    
-    # Validate name
     if not name or name.strip() == "":
-        errors.append("Material name is required.")
+        return False, "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.")
+    if (not edit_mode or name != original_name) and name in st.session_state.project_data["materials"]["project"]:
+        return False, f"Material name '{name}' already exists in project materials."
     
-    # Validate category
     if category not in MATERIAL_CATEGORIES:
-        errors.append("Please select a valid material category.")
+        return False, "Invalid material category."
     
-    # Validate thermal conductivity
     if thermal_conductivity <= 0:
-        errors.append("Thermal conductivity must be greater than zero.")
+        return False, "Thermal conductivity must be greater than zero."
     
-    # Validate density
     if density <= 0:
-        errors.append("Density must be greater than zero.")
+        return False, "Density must be greater than zero."
     
-    # Validate specific heat
     if specific_heat <= 0:
-        errors.append("Specific heat must be greater than zero.")
+        return False, "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.")
+    if default_thickness <= 0:
+        return False, "Thickness must be greater than zero."
     
-    # 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.")
+        return False, "Embodied carbon cannot be negative."
     
-    # Validate cost
     if cost < 0:
-        errors.append("Cost cannot be negative.")
+        return False, "Cost cannot be negative."
+    
+    if absorptivity < 0 or absorptivity > 1:
+        return False, "Absorptivity must be between 0 and 1."
+    
+    if emissivity < 0 or emissivity > 1:
+        return False, "Emissivity must be between 0 and 1."
+    
+    if colour not in COLOUR_CATEGORIES:
+        return False, "Invalid colour category."
     
-    return errors
+    colour_ranges = {
+        "Light": (0.30, 0.50),
+        "Medium": (0.60, 0.70),
+        "Dark": (0.85, 0.95),
+        "Reflective": (0.10, 0.20)
+    }
+    min_abs, max_abs = colour_ranges[colour]
+    if not (min_abs <= absorptivity <= max_abs):
+        return False, f"Absorptivity for {colour} colour must be between {min_abs} and {max_abs}."
+    
+    return True, ""
 
 def validate_fenestration(
     name: str, fenestration_type: str, u_value: float, shgc: float,
-    visible_transmittance: float, thickness: float, embodied_carbon: float,
+    visible_trans: float, thickness: float, embodied_carbon: float,
     cost: float, edit_mode: bool, original_name: str
-) -> List[str]:
+) -> Tuple[bool, str]:
     """
     Validate fenestration inputs.
-    
-    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
-        
-    Returns:
-        List of validation error messages, empty if all inputs are valid
+    Returns (success, message) tuple.
     """
-    errors = []
-    
-    # Validate name
     if not name or name.strip() == "":
-        errors.append("Fenestration name is required.")
+        return False, "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.")
+    if (not edit_mode or name != original_name) and name in st.session_state.project_data["fenestrations"]["project"]:
+        return False, f"Fenestration name '{name}' already exists in project."
     
-    # Validate type
     if fenestration_type not in FENESTRATION_TYPES:
-        errors.append("Please select a valid fenestration type.")
+        return False, "Invalid fenestration type."
     
-    # Validate u_value
     if u_value <= 0:
-        errors.append("U-value must be greater than zero.")
+        return False, "U-value must be greater than zero."
     
-    # Validate shgc
     if shgc < 0 or shgc > 1:
-        errors.append("SHGC must be between 0 and 1.")
+        return False, "SHGC must be between 0 and 1."
     
-    # Validate visible transmittance
-    if visible_transmittance < 0 or visible_transmittance > 1:
-        errors.append("Visible transmittance must be between 0 and 1.")
+    if visible_trans < 0 or visible_trans > 1:
+        return False, "Visible transmittance must be between 0 and 1."
     
-    # Validate thickness
     if thickness <= 0:
-        errors.append("Thickness must be greater than zero.")
-    
-    # Validate embodied carbon
+        return False, "Thickness must be greater than zero."
+        
     if embodied_carbon < 0:
-        errors.append("Embodied carbon cannot be negative.")
+        return False, "Embodied carbon cannot be negative."
     
-    # Validate cost
     if cost < 0:
-        errors.append("Cost cannot be negative.")
+        return False, "Cost cannot be negative."
     
-    return errors
+    return True, ""
 
 def reset_material_editor():
-    """Reset the material editor to default values."""
+    """Reset the material editor and form state."""
+    st.session_state.material_form_state = {
+        "name": "",
+        "category": MATERIAL_CATEGORIES[0],
+        "thermal_conductivity": 0.5,
+        "density": 1000.0,
+        "specific_heat": 1000.0,
+        "default_thickness": 0.05,
+        "embodied_carbon": 100.0,
+        "cost": 100.0,
+        "absorptivity": 0.60,
+        "emissivity": 0.90,
+        "colour": "Medium"
+    }
     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,
+        "absorptivity": 0.60,
+        "emissivity": 0.90,
+        "colour": "Medium",
         "edit_mode": False,
-        "original_name": ""
+        "original_name": "",
+        "is_library": False
     }
+    st.session_state.material_action = {"action": None, "id": None}
+    logger.debug("Material editor reset")
 
 def reset_fenestration_editor():
-    """Reset the fenestration editor to default values."""
+    """Reset the fenestration editor and form state."""
+    st.session_state.fenestration_form_state = {
+        "name": "",
+        "type": FENESTRATION_TYPES[0],
+        "u_value": 2.8,
+        "shgc": 0.7,
+        "visible_trans": 0.8,
+        "thickness": 0.024,
+        "embodied_carbon": 900.0,
+        "cost": 200.0
+    }
     st.session_state.fenestration_editor = {
         "name": "",
         "type": FENESTRATION_TYPES[0],
         "u_value": 2.8,
         "shgc": 0.7,
-        "visible_transmittance": 0.8,
+        "visible_trans": 0.8,
         "thickness": 0.024,
         "embodied_carbon": 900.0,
         "cost": 200.0,
         "edit_mode": False,
-        "original_name": ""
+        "original_name": "",
+        "is_library": False
     }
+    st.session_state.fenestration_action = {"action": None, "id": None}
+    logger.debug("Fenestration editor reset")
 
 def check_material_in_use(material_name: str) -> bool:
     """
     Check if a material is in use in any constructions.
-    
-    Args:
-        material_name: Name of the material to check
-        
-    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:
+def check_fenestration_in_use(name: str) -> bool:
     """
     Check if a fenestration is in use in any components.
-    
-    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
 
 def display_materials_help():
@@ -1185,31 +1401,35 @@ def display_materials_help():
     
     **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.
+    - **Library Materials**: Pre-defined materials with standard thermal properties. Use 'Preview' to view details or 'Copy' to add to your project.
+    - **Project Materials**: Materials you've added to your project. Use 'Edit' to modify or 'Delete' to remove.
+    - **Material Editor/Creator**: Create new materials or edit existing project materials. Library materials can only be previewed.
     
     **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.
+    - **Library Fenestrations**: Pre-defined windows, doors, and skylights. Use 'Preview' to view details or 'Copy' to add to your project.
+    - **Project Fenestrations**: Fenestrations you've added to your project. Use 'Edit' to modify or 'Delete' to remove.
+    - **Fenestration Editor/Creator**: Create new fenestrations or edit existing project fenestrations. Library fenestrations can only be previewed.
     
     **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.
+    - **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.
+    - **Thermal Mass (J/m²·K)**: Areal heat capacity (density × specific heat × thickness).
+    - **U-Value (W/m²·K)**: Overall heat transfer coefficient, accounting for material and surfaces resistances. 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.
+    - **Absorptivity**: Fraction of solar radiation absorbed (0-1). Depends on colour category.
+    - **Emissivity**: Ratio of radiation emitted by the material (0-1).
+    - **Colour**: Category affecting absorptivity (Light, Medium, Dark, Reflective).
     
     **Workflow:**
     
     1. Browse the library materials and fenestrations
-    2. Add items to your project or create custom ones
+    2. Copy 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
-    """)
+    """)