Update app/components.py

app/components.py

@@ -1,8 +1,8 @@
 """
-BuildSustain - Building Components Module
+HVAC Load Calculator - Building Components Module
 
 This module handles the definition of building envelope components (walls, roofs, floors,
-windows, doors, skylights) for the BuildSustain application. It allows users to
+windows, doors, skylights) for the HVAC Load Calculator application. It allows users to
 assign constructions and fenestrations to specific components, define their areas,
 orientations, and other relevant properties.
 
@@ -24,7 +24,8 @@ logger = logging.getLogger(__name__)
 
 # Define constants
 COMPONENT_TYPES = ["Wall", "Roof", "Floor", "Window", "Door", "Skylight"]
-ORIENTATION_OPTIONS = ["A (North)", "B (South)", "C (East)", "D (West)", "Horizontal"]
+ORIENTATION_OPTIONS = ["A (North)", "B (South)", "C (East)", "D (West)", "Custom"]
+ORIENTATION_MAP = {'A (North)': 0.0, 'B (South)': 180.0, 'C (East)': 90.0, 'D (West)': 270.0, 'Custom': None}
 
 def display_components_page():
     """
@@ -32,6 +33,7 @@ def display_components_page():
     This is the main function called by main.py when the Building Components page is selected.
     """
     st.title("Building Components")
+    st.write("Define walls, roofs, floors, windows, doors, and skylights based on ASHRAE 2005 Handbook of Fundamentals.")
     
     # Display help information in an expandable section
     with st.expander("Help & Information"):
@@ -40,12 +42,20 @@ def display_components_page():
     # Initialize components in session state if not present
     initialize_components()
     
+    # Check if rerun is pending
+    if 'components_rerun_pending' not in st.session_state:
+        st.session_state.components_rerun_pending = False
+    
+    if st.session_state.components_rerun_pending:
+        st.session_state.components_rerun_pending = False
+        st.rerun()
+    
     # Create tabs for different component types
     tabs = st.tabs(COMPONENT_TYPES)
     
     for i, component_type in enumerate(COMPONENT_TYPES):
         with tabs[i]:
-            display_component_tab(component_type)
+            display_component_tab(component_type.lower() + "s")
     
     # Navigation buttons
     col1, col2 = st.columns(2)
@@ -71,268 +81,428 @@ def initialize_components():
             "doors": [],
             "skylights": []
         }
-    
-    # Initialize component editor state
-    if "component_editor" not in st.session_state:
-        st.session_state.component_editor = {
-            "type": COMPONENT_TYPES[0],
-            "name": "",
-            "construction": "",
-            "fenestration": "",
-            "area": 10.0,
-            "orientation": ORIENTATION_OPTIONS[0],
-            "tilt": 90.0,
-            "parent_component": "",
-            "edit_mode": False,
-            "original_id": ""
-        }
 
-def display_component_tab(component_type: str):
+def display_component_tab(comp_type: str):
     """
     Display the content for a specific component type tab.
     
     Args:
-        component_type: The type of component (e.g., "Wall", "Window")
+        comp_type: The type of component (e.g., "walls", "windows")
     """
-    st.subheader(f"{component_type}s")
+    # Get singular form for display
+    comp_singular = comp_type[:-1].capitalize()
     
     # Get components of this type
-    component_key = component_type.lower() + "s"
-    components = st.session_state.project_data["components"].get(component_key, [])
-    
-    # Display existing components
-    if components:
-        display_component_list(component_type, components)
-    else:
-        st.info(f"No {component_type.lower()}s added yet. Use the editor below to add components.")
-    
-    # Component Editor
-    st.markdown("---")
-    st.subheader(f"{component_type} Editor")
-    display_component_editor(component_type)
-
-def display_component_list(component_type: str, components: List[Dict[str, Any]]):
-    """
-    Display the list of existing components for a given type.
+    components = st.session_state.project_data["components"].get(comp_type, [])
     
-    Args:
-        component_type: The type of component
-        components: List of component dictionaries
-    """
-    # Create a DataFrame for display
-    data = []
-    for i, comp in enumerate(components):
-        record = {
-            "#": i + 1,
-            "Name": comp["name"],
-            "Area (m²)": comp["area"],
-            "Orientation": comp["orientation"],
-            "Tilt (°) ": comp["tilt"]
-        }
-        
-        if component_type in ["Wall", "Roof", "Floor"]:
-            record["Construction"] = comp["construction"]
-        else:
-            record["Fenestration"] = comp["fenestration"]
-            record["Parent Component"] = comp.get("parent_component", "N/A")
-        
-        data.append(record)
+    # Get available items for this component type
+    if comp_type in ["walls", "roofs", "floors"]:
+        available_items = get_available_constructions()
+    else:  # Windows, doors, skylights
+        available_items = get_available_fenestrations()
     
-    df = pd.DataFrame(data)
-    st.dataframe(df, use_container_width=True, hide_index=True)
-    
-    # Edit and delete options
-    col1, col2 = st.columns(2)
+    # Split the display into two columns
+    col1, col2 = st.columns([3, 2])
     
     with col1:
-        selected_index = st.selectbox(
-            f"Select {component_type} # to Edit",
-            range(1, len(components) + 1),
-            key=f"edit_{component_type}_selector"
-        )
+        st.subheader(f"Saved {comp_type.capitalize()}")
         
-        if st.button(f"Edit {component_type}", key=f"edit_{component_type}_button"):
-            # Load component data into editor
-            component_data = components[selected_index - 1]
-            st.session_state.component_editor = {
-                "type": component_type,
-                "name": component_data["name"],
-                "construction": component_data.get("construction", ""),
-                "fenestration": component_data.get("fenestration", ""),
-                "area": component_data["area"],
-                "orientation": component_data["orientation"],
-                "tilt": component_data["tilt"],
-                "parent_component": component_data.get("parent_component", ""),
-                "edit_mode": True,
-                "original_id": component_data["id"]
-            }
-            st.success(f"{component_type} 	\'{component_data['name']}\' loaded for editing.")
-            st.rerun()
+        if components:
+            # Display components in a table format based on component type
+            if comp_type in ["walls", "windows"]:
+                display_wall_window_table(comp_type, components)
+            elif comp_type in ["roofs", "skylights"]:
+                display_roof_skylight_table(comp_type, components)
+            elif comp_type == "floors":
+                display_floor_table(comp_type, components)
+            else:  # doors
+                display_door_table(comp_type, components)
+        else:
+            st.write(f"No {comp_type} defined.")
     
     with col2:
-        selected_index_delete = st.selectbox(
-            f"Select {component_type} # to Delete",
-            range(1, len(components) + 1),
-            key=f"delete_{component_type}_selector"
-        )
+        st.subheader(f"{comp_singular} Editor/Creator")
         
-        if st.button(f"Delete {component_type}", key=f"delete_{component_type}_button"):
-            # Delete component
-            component_key = component_type.lower() + "s"
-            deleted_component = st.session_state.project_data["components"][component_key].pop(selected_index_delete - 1)
-            st.success(f"{component_type} 	\'{deleted_component['name']}\' deleted.")
-            logger.info(f"Deleted {component_type} 	\'{deleted_component['name']}\'")
-            st.rerun()
-
-def display_component_editor(component_type: str):
-    """
-    Display the editor form for a specific component type.
-    
-    Args:
-        component_type: The type of component
-    """
-    # Get available constructions and fenestrations
-    available_constructions = get_available_constructions()
-    available_fenestrations = get_available_fenestrations()
-    available_walls = get_available_walls()
-    
-    # Check if the editor is currently set to this component type
-    if st.session_state.component_editor["type"] != component_type and not st.session_state.component_editor["edit_mode"]:
-        reset_component_editor(component_type)
-    
-    with st.form(f"{component_type}_editor_form"):
-        # Component name
-        name = st.text_input(
-            "Component Name",
-            value=st.session_state.component_editor["name"],
-            help="Enter a unique name for this component."
-        )
+        # Check if we have an editor state for this component type
+        editor_key = f"{comp_type}_editor"
+        if editor_key not in st.session_state:
+            st.session_state[editor_key] = {}
         
-        # Create two columns for layout
-        col1, col2 = st.columns(2)
+        # Check if we have an action state for this component type
+        action_key = f"{comp_type}_action"
+        if action_key not in st.session_state:
+            st.session_state[action_key] = {"action": None, "id": None}
         
-        with col1:
-            # Construction or Fenestration selection
-            if component_type in ["Wall", "Roof", "Floor"]:
-                construction = st.selectbox(
-                    "Construction",
-                    list(available_constructions.keys()),
-                    index=list(available_constructions.keys()).index(st.session_state.component_editor["construction"]) if st.session_state.component_editor["construction"] in available_constructions else 0,
-                    help="Select the construction assembly for this component."
-                )
-                fenestration = ""
-            else:
-                fenestration = st.selectbox(
-                    "Fenestration",
-                    list(available_fenestrations.keys()),
-                    index=list(available_fenestrations.keys()).index(st.session_state.component_editor["fenestration"]) if st.session_state.component_editor["fenestration"] in available_fenestrations else 0,
-                    help="Select the fenestration type for this component."
-                )
-                construction = ""
+        # Display the editor form
+        with st.form(f"{comp_type}_editor_form", clear_on_submit=True):
+            editor_state = st.session_state.get(editor_key, {})
+            is_edit = editor_state.get("is_edit", False)
+            
+            # Component name
+            name = st.text_input(
+                "Name",
+                value=editor_state.get("name", ""),
+                help="Enter a unique name for this component."
+            )
             
             # Area
             area = st.number_input(
                 "Area (m²)",
                 min_value=0.1,
                 max_value=10000.0,
-                value=float(st.session_state.component_editor["area"]),
+                value=float(editor_state.get("area", 10.0)),
                 format="%.2f",
                 help="Surface area of the component in square meters."
             )
-        
-        with col2:
-            # Orientation
-            orientation = st.selectbox(
-                "Orientation",
-                ORIENTATION_OPTIONS,
-                index=ORIENTATION_OPTIONS.index(st.session_state.component_editor["orientation"]) if st.session_state.component_editor["orientation"] in ORIENTATION_OPTIONS else 0,
-                help="Orientation of the component relative to the building orientation angle."
-            )
             
-            # Tilt
-            tilt = st.number_input(
-                "Tilt (°) ",
-                min_value=0.0,
-                max_value=180.0,
-                value=float(st.session_state.component_editor["tilt"]),
-                format="%.1f",
-                help="Tilt angle of the component relative to horizontal (0° = horizontal, 90° = vertical)."
-            )
-        
-        # Parent component (for windows, doors, skylights)
-        parent_component = ""
-        if component_type in ["Window", "Door", "Skylight"]:
-            parent_component = st.selectbox(
-                "Parent Component (Wall/Roof)",
-                list(available_walls.keys()),
-                index=list(available_walls.keys()).index(st.session_state.component_editor["parent_component"]) if st.session_state.component_editor["parent_component"] in available_walls else 0,
-                help="Select the wall or roof component this fenestration belongs to."
-            )
-        
-        # Form submission buttons
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            submit_button = st.form_submit_button("Save Component")
-        
-        with col2:
-            clear_button = st.form_submit_button("Clear Form")
-    
-    # Handle form submission
-    if submit_button:
-        # Validate inputs
-        validation_errors = validate_component(
-            component_type, name, construction, fenestration, area, orientation, tilt,
-            parent_component, st.session_state.component_editor["edit_mode"],
-            st.session_state.component_editor["original_id"]
-        )
+            # Component-specific inputs
+            if comp_type in ["walls", "windows", "doors"]:
+                # Elevation (orientation)
+                elevation = st.selectbox(
+                    "Elevation",
+                    ORIENTATION_OPTIONS,
+                    index=ORIENTATION_OPTIONS.index(editor_state.get("elevation", ORIENTATION_OPTIONS[0])) if editor_state.get("elevation") in ORIENTATION_OPTIONS else 0,
+                    help="Orientation of the component relative to the building orientation angle."
+                )
+                
+                # Custom rotation if elevation is custom
+                rotation = 0.0
+                if elevation == "Custom":
+                    rotation = st.number_input(
+                        "Rotation (°)",
+                        min_value=0.0,
+                        max_value=359.9,
+                        value=float(editor_state.get("rotation", 0.0)),
+                        format="%.1f",
+                        help="Custom rotation angle in degrees (0° = North, 90° = East, 180° = South, 270° = West)."
+                    )
+                else:
+                    rotation = ORIENTATION_MAP[elevation]
+                
+                # Tilt
+                tilt = st.number_input(
+                    "Tilt (°)",
+                    min_value=0.0,
+                    max_value=180.0,
+                    value=float(editor_state.get("tilt", 90.0)),
+                    format="%.1f",
+                    help="Tilt angle of the component relative to horizontal (0° = horizontal, 90° = vertical)."
+                )
+            
+            elif comp_type in ["roofs", "skylights"]:
+                # Orientation
+                orientation = st.number_input(
+                    "Orientation (°)",
+                    min_value=0.0,
+                    max_value=359.9,
+                    value=float(editor_state.get("orientation", 0.0)),
+                    format="%.1f",
+                    help="Orientation angle in degrees (0° = North, 90° = East, 180° = South, 270° = West)."
+                )
+                
+                # Tilt
+                tilt = st.number_input(
+                    "Tilt (°)",
+                    min_value=0.0,
+                    max_value=180.0,
+                    value=float(editor_state.get("tilt", 30.0)),
+                    format="%.1f",
+                    help="Tilt angle of the component relative to horizontal (0° = horizontal, 90° = vertical)."
+                )
+            
+            # Construction or fenestration selection
+            if comp_type in ["walls", "roofs", "floors"]:
+                construction = st.selectbox(
+                    "Construction",
+                    list(available_items.keys()),
+                    index=list(available_items.keys()).index(editor_state.get("construction", "")) if editor_state.get("construction", "") in available_items else 0,
+                    help="Select the construction assembly for this component."
+                )
+            else:  # Windows, doors, skylights
+                # For fenestrations, we need to select a parent component
+                parent_components = get_parent_components(comp_type)
+                
+                if not parent_components:
+                    st.error(f"No parent components available. Please create walls/roofs first.")
+                
+                parent_component = st.selectbox(
+                    "Parent Component",
+                    list(parent_components.keys()),
+                    index=list(parent_components.keys()).index(editor_state.get("parent_component", "")) if editor_state.get("parent_component", "") in parent_components else 0,
+                    help="Select the wall or roof component this fenestration belongs to."
+                )
+                
+                fenestration = st.selectbox(
+                    "Fenestration",
+                    list(available_items.keys()),
+                    index=list(available_items.keys()).index(editor_state.get("fenestration", "")) if editor_state.get("fenestration", "") in available_items else 0,
+                    help="Select the fenestration type for this component."
+                )
+            
+            # Submit buttons
+            col1, col2 = st.columns(2)
+            with col1:
+                submit_label = "Update" if is_edit else "Add"
+                submit = st.form_submit_button(f"{submit_label} {comp_singular}")
+            
+            with col2:
+                cancel = st.form_submit_button("Cancel")
         
-        if validation_errors:
-            # Display validation errors
-            for error in validation_errors:
-                st.error(error)
-        else:
+        # Handle form submission
+        if submit:
             # Create component data
             component_data = {
-                "id": st.session_state.component_editor["original_id"] if st.session_state.component_editor["edit_mode"] else str(uuid.uuid4()),
+                "id": str(uuid.uuid4()),
                 "name": name,
-                "type": component_type,
-                "area": area,
-                "orientation": orientation,
-                "tilt": tilt
+                "area": area
             }
             
-            if component_type in ["Wall", "Roof", "Floor"]:
+            if comp_type in ["walls", "windows", "doors"]:
+                component_data["elevation"] = elevation
+                component_data["rotation"] = rotation
+                component_data["tilt"] = tilt
+            
+            elif comp_type in ["roofs", "skylights"]:
+                component_data["orientation"] = orientation
+                component_data["tilt"] = tilt
+            
+            if comp_type in ["walls", "roofs", "floors"]:
                 component_data["construction"] = construction
+                # Get U-value from construction
+                component_data["u_value"] = available_items[construction].get("u_value", 0.0)
             else:
                 component_data["fenestration"] = fenestration
                 component_data["parent_component"] = parent_component
+                # Get U-value and other properties from fenestration
+                component_data["u_value"] = available_items[fenestration].get("u_value", 0.0)
+                if comp_type == "doors":
+                    component_data["solar_absorptivity"] = available_items[fenestration].get("solar_absorptivity", 0.7)
+                else:
+                    component_data["shgc"] = available_items[fenestration].get("shgc", 0.7)
+                    component_data["visible_transmittance"] = available_items[fenestration].get("visible_transmittance", 0.7)
             
             # Handle edit mode
-            component_key = component_type.lower() + "s"
-            if st.session_state.component_editor["edit_mode"]:
-                # Find and update the component
-                components = st.session_state.project_data["components"][component_key]
-                for i, comp in enumerate(components):
-                    if comp["id"] == st.session_state.component_editor["original_id"]:
-                        components[i] = component_data
-                        break
-                st.success(f"{component_type} 	\'{name}\' updated successfully.")
-                logger.info(f"Updated {component_type} 	\'{name}\'")
+            if is_edit:
+                index = editor_state.get("index", 0)
+                st.session_state.project_data["components"][comp_type][index] = component_data
+                st.success(f"{comp_singular} '{name}' updated!")
             else:
-                # Add new component
-                st.session_state.project_data["components"][component_key].append(component_data)
-                st.success(f"{component_type} 	\'{name}\' added successfully.")
-                logger.info(f"Added new {component_type} 	\'{name}\'")
+                st.session_state.project_data["components"][comp_type].append(component_data)
+                st.success(f"{comp_singular} '{name}' added!")
             
-            # Reset editor
-            reset_component_editor(component_type)
-            st.rerun()
-    
-    # Handle clear button
-    if clear_button:
-        reset_component_editor(component_type)
-        st.rerun()
+            # Clear editor state
+            st.session_state[editor_key] = {}
+            st.session_state[action_key] = {"action": "save", "id": str(uuid.uuid4())}
+            st.session_state.components_rerun_pending = True
+        
+        elif cancel:
+            # Clear editor state
+            st.session_state[editor_key] = {}
+            st.session_state[action_key] = {"action": "cancel", "id": str(uuid.uuid4())}
+            st.session_state.components_rerun_pending = True
+
+def display_wall_window_table(comp_type: str, components: List[Dict[str, Any]]):
+    """Display a table of walls or windows with appropriate columns."""
+    # Create column headers
+    cols = st.columns([2, 1, 1, 1, 1, 1, 1, 1])
+    cols[0].write("**Name**")
+    cols[1].write("**U-Value**")
+    cols[2].write("**Area (m²)**")
+    cols[3].write("**Elevation**")
+    cols[4].write("**Rotation (°)**")
+    cols[5].write("**Tilt (°)**")
+    cols[6].write("**Edit**")
+    cols[7].write("**Delete**")
+    
+    # Display each component
+    for idx, comp in enumerate(components):
+        cols = st.columns([2, 1, 1, 1, 1, 1, 1, 1])
+        cols[0].write(comp["name"])
+        cols[1].write(f"{comp.get('u_value', 0.0):.3f}")
+        cols[2].write(f"{comp['area']:.2f}")
+        cols[3].write(comp.get("elevation", "N/A"))
+        cols[4].write(f"{comp.get('rotation', 0.0):.1f}")
+        cols[5].write(f"{comp.get('tilt', 90.0):.1f}")
+        
+        # Edit button
+        edit_key = f"edit_{comp_type}_{comp['name']}_{idx}"
+        with cols[6].container():
+            if st.button("Edit", key=edit_key):
+                editor_data = {
+                    "index": idx,
+                    "name": comp["name"],
+                    "area": comp["area"],
+                    "elevation": comp.get("elevation", ORIENTATION_OPTIONS[0]),
+                    "rotation": comp.get("rotation", 0.0),
+                    "tilt": comp.get("tilt", 90.0),
+                    "is_edit": True
+                }
+                
+                if comp_type in ["walls", "roofs", "floors"]:
+                    editor_data["construction"] = comp.get("construction", "")
+                else:  # Windows, doors, skylights
+                    editor_data["fenestration"] = comp.get("fenestration", "")
+                    editor_data["parent_component"] = comp.get("parent_component", "")
+                
+                st.session_state[f"{comp_type}_editor"] = editor_data
+                st.session_state[f"{comp_type}_action"] = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.components_rerun_pending = True
+        
+        # Delete button
+        delete_key = f"delete_{comp_type}_{comp['name']}_{idx}"
+        with cols[7].container():
+            if st.button("Delete", key=delete_key):
+                st.session_state.project_data["components"][comp_type].pop(idx)
+                st.success(f"{comp_type[:-1].capitalize()} '{comp['name']}' deleted!")
+                st.session_state[f"{comp_type}_action"] = {"action": "delete", "id": str(uuid.uuid4())}
+                st.session_state.components_rerun_pending = True
+
+def display_roof_skylight_table(comp_type: str, components: List[Dict[str, Any]]):
+    """Display a table of roofs or skylights with appropriate columns."""
+    # Create column headers
+    cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+    cols[0].write("**Name**")
+    cols[1].write("**U-Value**")
+    cols[2].write("**Area (m²)**")
+    cols[3].write("**Orientation (°)**")
+    cols[4].write("**Tilt (°)**")
+    cols[5].write("**Edit**")
+    cols[6].write("**Delete**")
+    
+    # Display each component
+    for idx, comp in enumerate(components):
+        cols = st.columns([2, 1, 1, 1, 1, 1, 1])
+        cols[0].write(comp["name"])
+        cols[1].write(f"{comp.get('u_value', 0.0):.3f}")
+        cols[2].write(f"{comp['area']:.2f}")
+        cols[3].write(f"{comp.get('orientation', 0.0):.1f}")
+        cols[4].write(f"{comp.get('tilt', 0.0):.1f}")
+        
+        # Edit button
+        edit_key = f"edit_{comp_type}_{comp['name']}_{idx}"
+        with cols[5].container():
+            if st.button("Edit", key=edit_key):
+                editor_data = {
+                    "index": idx,
+                    "name": comp["name"],
+                    "area": comp["area"],
+                    "orientation": comp.get("orientation", 0.0),
+                    "tilt": comp.get("tilt", 0.0),
+                    "is_edit": True
+                }
+                
+                if comp_type in ["roofs"]:
+                    editor_data["construction"] = comp.get("construction", "")
+                else:  # skylights
+                    editor_data["fenestration"] = comp.get("fenestration", "")
+                    editor_data["parent_component"] = comp.get("parent_component", "")
+                
+                st.session_state[f"{comp_type}_editor"] = editor_data
+                st.session_state[f"{comp_type}_action"] = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.components_rerun_pending = True
+        
+        # Delete button
+        delete_key = f"delete_{comp_type}_{comp['name']}_{idx}"
+        with cols[6].container():
+            if st.button("Delete", key=delete_key):
+                st.session_state.project_data["components"][comp_type].pop(idx)
+                st.success(f"{comp_type[:-1].capitalize()} '{comp['name']}' deleted!")
+                st.session_state[f"{comp_type}_action"] = {"action": "delete", "id": str(uuid.uuid4())}
+                st.session_state.components_rerun_pending = True
+
+def display_floor_table(comp_type: str, components: List[Dict[str, Any]]):
+    """Display a table of floors with appropriate columns."""
+    # Create column headers
+    cols = st.columns([2, 1, 1, 1, 1])
+    cols[0].write("**Name**")
+    cols[1].write("**U-Value**")
+    cols[2].write("**Area (m²)**")
+    cols[3].write("**Edit**")
+    cols[4].write("**Delete**")
+    
+    # Display each component
+    for idx, comp in enumerate(components):
+        cols = st.columns([2, 1, 1, 1, 1])
+        cols[0].write(comp["name"])
+        cols[1].write(f"{comp.get('u_value', 0.0):.3f}")
+        cols[2].write(f"{comp['area']:.2f}")
+        
+        # Edit button
+        edit_key = f"edit_{comp_type}_{comp['name']}_{idx}"
+        with cols[3].container():
+            if st.button("Edit", key=edit_key):
+                editor_data = {
+                    "index": idx,
+                    "name": comp["name"],
+                    "area": comp["area"],
+                    "construction": comp.get("construction", ""),
+                    "is_edit": True
+                }
+                
+                st.session_state[f"{comp_type}_editor"] = editor_data
+                st.session_state[f"{comp_type}_action"] = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.components_rerun_pending = True
+        
+        # Delete button
+        delete_key = f"delete_{comp_type}_{comp['name']}_{idx}"
+        with cols[4].container():
+            if st.button("Delete", key=delete_key):
+                st.session_state.project_data["components"][comp_type].pop(idx)
+                st.success(f"{comp_type[:-1].capitalize()} '{comp['name']}' deleted!")
+                st.session_state[f"{comp_type}_action"] = {"action": "delete", "id": str(uuid.uuid4())}
+                st.session_state.components_rerun_pending = True
+
+def display_door_table(comp_type: str, components: List[Dict[str, Any]]):
+    """Display a table of doors with appropriate columns."""
+    # Create column headers
+    cols = st.columns([2, 1, 1, 1, 1, 1, 1, 1])
+    cols[0].write("**Name**")
+    cols[1].write("**U-Value**")
+    cols[2].write("**Solar Abs.**")
+    cols[3].write("**Elevation**")
+    cols[4].write("**Rotation (°)**")
+    cols[5].write("**Tilt (°)**")
+    cols[6].write("**Edit**")
+    cols[7].write("**Delete**")
+    
+    # Display each component
+    for idx, comp in enumerate(components):
+        cols = st.columns([2, 1, 1, 1, 1, 1, 1, 1])
+        cols[0].write(comp["name"])
+        cols[1].write(f"{comp.get('u_value', 0.0):.3f}")
+        cols[2].write(f"{comp.get('solar_absorptivity', 0.7):.2f}")
+        cols[3].write(comp.get("elevation", "N/A"))
+        cols[4].write(f"{comp.get('rotation', 0.0):.1f}")
+        cols[5].write(f"{comp.get('tilt', 90.0):.1f}")
+        
+        # Edit button
+        edit_key = f"edit_{comp_type}_{comp['name']}_{idx}"
+        with cols[6].container():
+            if st.button("Edit", key=edit_key):
+                editor_data = {
+                    "index": idx,
+                    "name": comp["name"],
+                    "area": comp["area"],
+                    "elevation": comp.get("elevation", ORIENTATION_OPTIONS[0]),
+                    "rotation": comp.get("rotation", 0.0),
+                    "tilt": comp.get("tilt", 90.0),
+                    "fenestration": comp.get("fenestration", ""),
+                    "parent_component": comp.get("parent_component", ""),
+                    "is_edit": True
+                }
+                
+                st.session_state[f"{comp_type}_editor"] = editor_data
+                st.session_state[f"{comp_type}_action"] = {"action": "edit", "id": str(uuid.uuid4())}
+                st.session_state.components_rerun_pending = True
+        
+        # Delete button
+        delete_key = f"delete_{comp_type}_{comp['name']}_{idx}"
+        with cols[7].container():
+            if st.button("Delete", key=delete_key):
+                st.session_state.project_data["components"][comp_type].pop(idx)
+                st.success(f"{comp_type[:-1].capitalize()} '{comp['name']}' deleted!")
+                st.session_state[f"{comp_type}_action"] = {"action": "delete", "id": str(uuid.uuid4())}
+                st.session_state.components_rerun_pending = True
 
 def get_available_constructions() -> Dict[str, Any]:
     """
@@ -343,13 +513,10 @@ def get_available_constructions() -> Dict[str, Any]:
     """
     available_constructions = {}
     
-    # Add library constructions
-    if "constructions" in st.session_state.project_data and "library" in st.session_state.project_data["constructions"]:
-        available_constructions.update(st.session_state.project_data["constructions"]["library"])
-    
-    # Add project constructions
-    if "constructions" in st.session_state.project_data and "project" in st.session_state.project_data["constructions"]:
-        available_constructions.update(st.session_state.project_data["constructions"]["project"])
+    # Add constructions from session state
+    if "constructions" in st.session_state.project_data:
+        for construction in st.session_state.project_data["constructions"]:
+            available_constructions[construction["name"]] = construction
     
     return available_constructions
 
@@ -362,109 +529,39 @@ def get_available_fenestrations() -> Dict[str, Any]:
     """
     available_fenestrations = {}
     
-    # Add library fenestrations
-    if "fenestrations" in st.session_state.project_data and "library" in st.session_state.project_data["fenestrations"]:
-        available_fenestrations.update(st.session_state.project_data["fenestrations"]["library"])
-    
-    # Add project fenestrations
-    if "fenestrations" in st.session_state.project_data and "project" in st.session_state.project_data["fenestrations"]:
-        available_fenestrations.update(st.session_state.project_data["fenestrations"]["project"])
+    # Add fenestrations from session state
+    if "materials" in st.session_state.project_data:
+        for material in st.session_state.project_data["materials"]:
+            if material.get("type") in ["window", "door", "skylight"]:
+                available_fenestrations[material["name"]] = material
     
     return available_fenestrations
 
-def get_available_walls() -> Dict[str, Any]:
+def get_parent_components(comp_type: str) -> Dict[str, Any]:
     """
-    Get all available wall components.
-    
-    Returns:
-        Dict of wall name to wall properties
-    """
-    available_walls = {}
-    if "components" in st.session_state.project_data and "walls" in st.session_state.project_data["components"]:
-        for wall in st.session_state.project_data["components"]["walls"]:
-            available_walls[wall["name"]] = wall
-    return available_walls
-
-def validate_component(
-    component_type: str, name: str, construction: str, fenestration: str, area: float,
-    orientation: str, tilt: float, parent_component: str, edit_mode: bool, original_id: str
-) -> List[str]:
-    """
-    Validate component inputs.
+    Get appropriate parent components for a fenestration type.
     
     Args:
-        component_type: Type of component
-        name: Component name
-        construction: Selected construction name
-        fenestration: Selected fenestration name
-        area: Component area
-        orientation: Component orientation
-        tilt: Component tilt angle
-        parent_component: Parent component name (for fenestrations)
-        edit_mode: Whether in edit mode
-        original_id: Original ID if in edit mode
-        
+        comp_type: The type of fenestration component
+    
     Returns:
-        List of validation error messages, empty if all inputs are valid
+        Dict of parent component name to parent component properties
     """
-    errors = []
-    
-    # Validate name
-    if not name or name.strip() == "":
-        errors.append("Component name is required.")
-    
-    # Check for name uniqueness within the same component type
-    component_key = component_type.lower() + "s"
-    components = st.session_state.project_data["components"].get(component_key, [])
-    
-    for comp in components:
-        if comp["name"] == name and (not edit_mode or comp["id"] != original_id):
-            errors.append(f"{component_type} name 	\'{name}\' already exists.")
-            break
-    
-    # Validate construction or fenestration selection
-    if component_type in ["Wall", "Roof", "Floor"] and not construction:
-        errors.append("Construction selection is required.")
-    elif component_type in ["Window", "Door", "Skylight"] and not fenestration:
-        errors.append("Fenestration selection is required.")
-    
-    # Validate area
-    if area <= 0:
-        errors.append("Area must be greater than zero.")
+    parent_components = {}
     
-    # Validate orientation
-    if orientation not in ORIENTATION_OPTIONS:
-        errors.append("Please select a valid orientation.")
+    if comp_type == "windows" or comp_type == "doors":
+        # Windows and doors can only be on walls
+        if "walls" in st.session_state.project_data["components"]:
+            for wall in st.session_state.project_data["components"]["walls"]:
+                parent_components[wall["name"]] = wall
     
-    # Validate tilt
-    if tilt < 0 or tilt > 180:
-        errors.append("Tilt angle must be between 0° and 180°.")
+    elif comp_type == "skylights":
+        # Skylights can only be on roofs
+        if "roofs" in st.session_state.project_data["components"]:
+            for roof in st.session_state.project_data["components"]["roofs"]:
+                parent_components[roof["name"]] = roof
     
-    # Validate parent component for fenestrations
-    if component_type in ["Window", "Door", "Skylight"] and not parent_component:
-        errors.append("Parent component selection is required for fenestrations.")
-    
-    return errors
-
-def reset_component_editor(component_type: str):
-    """
-    Reset the component editor to default values for the given type.
-    
-    Args:
-        component_type: The type of component
-    """
-    st.session_state.component_editor = {
-        "type": component_type,
-        "name": "",
-        "construction": "",
-        "fenestration": "",
-        "area": 10.0,
-        "orientation": ORIENTATION_OPTIONS[0],
-        "tilt": 90.0 if component_type == "Wall" else 0.0,
-        "parent_component": "",
-        "edit_mode": False,
-        "original_id": ""
-    }
+    return parent_components
 
 def display_components_help():
     """
@@ -473,32 +570,26 @@ def display_components_help():
     st.markdown("""
     ### Building Components Help
     
-    This section allows you to define the individual components of your building envelope, such as walls, roofs, floors, windows, doors, and skylights.
+    This section allows you to define the building envelope components using the constructions and fenestrations you've created.
     
     **Key Concepts:**
     
-    * **Component**: A specific part of the building envelope (e.g., "North Wall", "Living Room Window").
-    * **Construction**: The multi-layer assembly assigned to opaque components (walls, roofs, floors).
-    * **Fenestration**: The glazing or door system assigned to transparent or operable components (windows, doors, skylights).
-    * **Area**: The surface area of the component in square meters.
-    * **Orientation**: The direction the component faces relative to the building orientation angle (A=North, B=South, C=East, D=West, Horizontal).
-    * **Tilt**: The angle of the component relative to horizontal (0° = horizontal, 90° = vertical).
-    * **Parent Component**: For fenestrations, the wall or roof component they are part of.
+    * **Walls, Roofs, Floors**: Opaque components that use constructions from the Construction section.
+    * **Windows, Doors, Skylights**: Transparent components that use fenestrations from the Material Library section.
+    * **Orientation**: Direction the component faces (A=North, B=South, C=East, D=West).
+    * **Tilt**: Angle of the component relative to horizontal (0° = horizontal, 90° = vertical).
+    * **Parent Component**: The wall or roof that contains a window, door, or skylight.
     
     **Workflow:**
     
-    1. Select the tab for the component type you want to define (e.g., "Walls").
-    2. Use the editor to add new components:
-        * Give the component a unique name.
-        * Select the appropriate construction (for walls, roofs, floors) or fenestration (for windows, doors, skylights) from your project library.
-        * Enter the area, orientation, and tilt.
-        * For fenestrations, select the parent wall or roof component.
-    3. Save the component.
-    4. Repeat for all building envelope components.
-    5. Edit or delete components as needed using the controls above the editor.
+    1. First define opaque components (walls, roofs, floors) using constructions.
+    2. Then define transparent components (windows, doors, skylights) and assign them to parent components.
+    3. Ensure all major building envelope components are included for accurate load calculations.
     
-    **Important:**
+    **Tips:**
     
-    * Ensure all constructions and fenestrations you need are defined in the Material Library and Construction pages before defining components.
-    * The accuracy of your load calculations depends heavily on the correct definition of these components.
+    * For walls, use the elevation options (A, B, C, D) to easily align with the building orientation.
+    * For roofs and skylights, specify the orientation angle directly.
+    * Ensure the total area of windows and doors doesn't exceed the area of their parent walls.
+    * Ensure the total area of skylights doesn't exceed the area of their parent roofs.
     """)