Update pages/1_📊_Text_to_PPT.py

pages/1_📊_Text_to_PPT.py

@@ -1010,6 +1010,7 @@
 
 
 ###################################################################################################################################################################
+
 import streamlit as st
 import google.generativeai as genai
 from pptx import Presentation
@@ -1017,16 +1018,11 @@ from pptx.util import Inches, Pt
 from pptx.dml.color import RGBColor
 from pptx.enum.text import PP_ALIGN, PP_PARAGRAPH_ALIGNMENT
 from pptx.enum.text import MSO_AUTO_SIZE
-from pptx.enum.shapes import MSO_SHAPE
 from pptx.oxml.xmlchemy import OxmlElement
 import io
 import re
 import tempfile
 import os
-from PIL import Image
-import time
-import textwrap
-import math
 
 # Load the API key securely from environment variable
 api_key = os.getenv("GOOGLE_API_KEY")
@@ -1043,8 +1039,7 @@ DEFAULT_THEMES = {
         "text_color": RGBColor(200, 200, 200),
         "accent": RGBColor(0, 112, 192),
         "title_font": "Calibri",
-        "text_font": "Calibri",
-        "min_font_size": 14
+        "text_font": "Calibri"
     },
     "Modern Green": {
         "background": RGBColor(22, 82, 66),
@@ -1052,8 +1047,7 @@ DEFAULT_THEMES = {
         "text_color": RGBColor(220, 220, 220),
         "accent": RGBColor(76, 175, 80),
         "title_font": "Arial",
-        "text_font": "Arial",
-        "min_font_size": 14
+        "text_font": "Arial"
     },
     "Light Corporate": {
         "background": RGBColor(255, 255, 255),
@@ -1061,8 +1055,7 @@ DEFAULT_THEMES = {
         "text_color": RGBColor(33, 33, 33),
         "accent": RGBColor(25, 118, 210),
         "title_font": "Segoe UI",
-        "text_font": "Segoe UI",
-        "min_font_size": 14
+        "text_font": "Segoe UI"
     },
     "Dark Tech": {
         "background": RGBColor(33, 33, 33),
@@ -1070,18 +1063,10 @@ DEFAULT_THEMES = {
         "text_color": RGBColor(200, 200, 200),
         "accent": RGBColor(0, 150, 255),
         "title_font": "Consolas",
-        "text_font": "Consolas",
-        "min_font_size": 14
+        "text_font": "Consolas"
     }
 }
 
-# PowerPoint compatibility options
-PPT_VERSIONS = {
-    "Modern (2013+)": {"aspect_ratio": (13.33, 7.5)},
-    "Standard (2007-2013)": {"aspect_ratio": (10, 7.5)},
-    "Legacy (2003)": {"aspect_ratio": (10, 7.5)}
-}
-
 def hex_to_rgb(hex_color):
     """Convert hex color to RGBColor"""
     hex_color = hex_color.lstrip('#')
@@ -1101,7 +1086,6 @@ def extract_theme_from_pptx(uploaded_file):
         "accent": RGBColor(79, 129, 189),       # Default blue
         "title_font": "Calibri",
         "text_font": "Calibri",
-        "min_font_size": 14,
         "template_path": tmp_file_path  # Store the template path for later use
     }
     
@@ -1142,12 +1126,8 @@ def extract_theme_from_pptx(uploaded_file):
     
     return theme
 
-@st.cache_data(ttl=3600, show_spinner="Generating slide content...")
-def generate_slide_content(topic, slide_count, _model=None):
-    """Generate slide content with caching"""
-    if _model is None:
-        _model = genai.GenerativeModel('gemini-2.0-flash')
-    
+def generate_slide_content(topic, slide_count):
+    model = genai.GenerativeModel('gemini-2.0-flash')
     prompt = f"""Create a comprehensive presentation on '{topic}' with exactly {slide_count} slides. 
     For each slide, provide:
     1. A clear title in [Title:] format
@@ -1218,7 +1198,7 @@ def generate_slide_content(topic, slide_count, _model=None):
     Begin the content generation now.
     """
     
-    response = _model.generate_content(prompt)
+    response = model.generate_content(prompt)
     return response.text
 
 def parse_slide_content(slide_text):
@@ -1315,212 +1295,100 @@ def parse_slide_content(slide_text):
     
     return slides, questionnaire, answer_key
 
-def add_title_separator(slide, title_shape, accent_color):
-    """Add a decorative line under the title"""
-    line = slide.shapes.add_shape(
-        MSO_SHAPE.RECTANGLE, 
-        title_shape.left, 
-        title_shape.top + title_shape.height - Pt(5),
-        title_shape.width,
-        Pt(3)
-    )
-    fill = line.fill
-    fill.solid()
-    fill.fore_color.rgb = accent_color
-    line.line.fill.background()
-
-def smart_text_wrap(text, max_width=100):
-    """Wrap text intelligently at sentence boundaries when possible"""
-    if len(text) <= max_width:
-        return [text]
-    
-    # Try to split at sentence boundaries
-    sentences = re.split(r'(?<=[.!?]) +', text)
-    lines = []
-    current_line = ""
-    
-    for sentence in sentences:
-        if len(current_line) + len(sentence) + 1 <= max_width:
-            current_line += (sentence + " ") if current_line else sentence
-        else:
-            if current_line:
-                lines.append(current_line.strip())
-            current_line = sentence
-    
-    if current_line:
-        lines.append(current_line.strip())
-    
-    # If we didn't split into sentences, do regular word wrap
-    if len(lines) == 1 and len(text) > max_width:
-        return textwrap.wrap(text, max_width)
-    
-    return lines
-
-def calculate_optimal_font_size(text, max_width, max_height, initial_size=18):
-    """Calculate optimal font size to fit text in specified dimensions"""
-    # Estimate based on character count
-    char_count = len(text)
-    if char_count < 100:
-        return initial_size
-    elif char_count < 200:
-        return max(initial_size - 2, 14)
-    elif char_count < 300:
-        return max(initial_size - 4, 12)
-    else:
-        return max(initial_size - 6, 10)
-
 def create_question_slide(prs, question, question_num, theme):
-    """Create a slide for a single question with proper text wrapping"""
-    # Try to use Title + Content layout, fallback to blank if not available
-    try:
-        slide = prs.slides.add_slide(prs.slide_layouts[1])  # Title + Content layout
-    except IndexError:
-        slide = prs.slides.add_slide(prs.slide_layouts[6])  # Blank layout
-    
-    # Apply background if using custom theme
-    if "template_path" not in theme:
-        background = slide.background
-        fill = background.fill
-        fill.solid()
-        fill.fore_color.rgb = theme["background"]
-    
-    # Remove unused placeholders
-    for shape in slide.shapes:
-        if shape.has_text_frame and not shape.text.strip():
-            sp = shape._element
-            sp.getparent().remove(sp)
+    """Create a slide for a single question"""
+    slide = prs.slides.add_slide(prs.slide_layouts[1])  # Title + Content layout
     
     # Set title
-    title = slide.shapes.title if hasattr(slide.shapes, 'title') else None
-    if title:
-        title.text = f"Question {question_num}"
-        if "template_path" not in theme:
-            title.text_frame.paragraphs[0].font.color.rgb = theme["accent"]
-            title.text_frame.paragraphs[0].font.size = Pt(36)
-            title.text_frame.paragraphs[0].font.bold = True
-            if "title_font" in theme:
-                title.text_frame.paragraphs[0].font.name = theme["title_font"]
-            
-            # Add decorative line under title
-            add_title_separator(slide, title, theme["accent"])
-    
-    # Create content area with proper spacing
-    left = Inches(1)
-    top = Inches(2) if title else Inches(0.5)
-    width = prs.slide_width - Inches(2)
-    height = prs.slide_height - top - Inches(1)  # Leave 1 inch at bottom
-    
-    content_box = slide.shapes.add_textbox(left, top, width, height)
-    tf = content_box.text_frame
-    tf.word_wrap = True
+    title = slide.shapes.title
+    title.text = f"Question {question_num}"
     
-    # Add question text with smart wrapping
-    question_text = question['text']
-    wrapped_question = smart_text_wrap(question_text, 100)
-    
-    # Calculate optimal font size
-    font_size = calculate_optimal_font_size(question_text, width, height, 24)
-    
-    for line in wrapped_question:
-        p = tf.add_paragraph()
-        p.text = line
-        p.font.bold = True
-        p.space_after = Pt(12)
-        
-        # Apply text formatting
-        if "template_path" not in theme:
-            p.font.color.rgb = theme["text_color"]
-            p.font.size = Pt(font_size)
-            if "text_font" in theme:
-                p.font.name = theme["text_font"]
+    # Only apply custom formatting if not using a template
+    if "template_path" not in theme:
+        title.text_frame.paragraphs[0].font.color.rgb = theme["accent"]
+        title.text_frame.paragraphs[0].font.size = Pt(36)
+        title.text_frame.paragraphs[0].font.bold = True
+        if "title_font" in theme:
+            title.text_frame.paragraphs[0].font.name = theme["title_font"]
+    
+    # Create content
+    body = slide.placeholders[1]
+    tf = body.text_frame
+    tf.clear()
+    
+    # Add question text
+    p = tf.add_paragraph()
+    p.text = question['text']
+    p.level = 0
+    p.font.bold = True
+    p.space_after = Pt(24)
+    
+    # Only apply custom formatting if not using a template
+    if "template_path" not in theme:
+        p.font.color.rgb = theme["text_color"]
+        p.font.size = Pt(24)
+        if "text_font" in theme:
+            p.font.name = theme["text_font"]
     
-    # Add options with proper spacing
+    # Add options
     for j, opt in enumerate(question['options']):
         p = tf.add_paragraph()
         p.text = f"{chr(65+j)}. {opt}"
         p.level = 0
-        p.space_before = Pt(12)
         p.space_after = Pt(12)
         
-        # Apply text formatting
+        # Only apply custom formatting if not using a template
         if "template_path" not in theme:
             p.font.color.rgb = theme["text_color"]
-            p.font.size = Pt(font_size - 4)  # Slightly smaller for options
+            p.font.size = Pt(20)
             if "text_font" in theme:
                 p.font.name = theme["text_font"]
     
     # Add correct answer to speaker notes
-    if hasattr(slide, 'notes_slide'):
-        notes_slide = slide.notes_slide
-        notes_text = f"Correct Answer: {question['correct']}\n"
-        if hasattr(notes_slide, 'notes_text_frame'):
-            notes_slide.notes_text_frame.text = notes_text
+    notes_slide = slide.notes_slide
+    notes_text = f"Correct Answer: {question['correct']}\n"
+    notes_slide.notes_text_frame.text = notes_text
     
     return slide
 
 def create_answer_key_slide(prs, questions, theme):
-    """Create answer key slide with proper text wrapping"""
-    # Try to use Title + Content layout, fallback to blank if not available
-    try:
-        slide = prs.slides.add_slide(prs.slide_layouts[1])  # Title + Content layout
-    except IndexError:
-        slide = prs.slides.add_slide(prs.slide_layouts[6])  # Blank layout
-    
-    # Apply background if using custom theme
-    if "template_path" not in theme:
-        background = slide.background
-        fill = background.fill
-        fill.solid()
-        fill.fore_color.rgb = theme["background"]
-    
-    # Remove unused placeholders
-    for shape in slide.shapes:
-        if shape.has_text_frame and not shape.text.strip():
-            sp = shape._element
-            sp.getparent().remove(sp)
+    """Create answer key slide with all correct answers"""
+    slide = prs.slides.add_slide(prs.slide_layouts[1])  # Title + Content layout
     
     # Set title
-    title = slide.shapes.title if hasattr(slide.shapes, 'title') else None
-    if title:
-        title.text = "Answer Key"
-        if "template_path" not in theme:
-            title.text_frame.paragraphs[0].font.color.rgb = theme["accent"]
-            title.text_frame.paragraphs[0].font.size = Pt(36)
-            title.text_frame.paragraphs[0].font.bold = True
-            if "title_font" in theme:
-                title.text_frame.paragraphs[0].font.name = theme["title_font"]
-            
-            # Add decorative line under title
-            add_title_separator(slide, title, theme["accent"])
+    title = slide.shapes.title
+    title.text = "Answer Key"
     
-    # Create content area with proper spacing
-    left = Inches(1.5)
-    top = Inches(2) if title else Inches(0.5)
-    width = prs.slide_width - Inches(3)
-    height = prs.slide_height - top - Inches(1)  # Leave 1 inch at bottom
+    # Only apply custom formatting if not using a template
+    if "template_path" not in theme:
+        title.text_frame.paragraphs[0].font.color.rgb = theme["accent"]
+        title.text_frame.paragraphs[0].font.size = Pt(36)
+        title.text_frame.paragraphs[0].font.bold = True
+        if "title_font" in theme:
+            title.text_frame.paragraphs[0].font.name = theme["title_font"]
     
-    content_box = slide.shapes.add_textbox(left, top, width, height)
-    tf = content_box.text_frame
-    tf.word_wrap = True
+    # Create content
+    body = slide.placeholders[1]
+    tf = body.text_frame
+    tf.clear()
     
     # Add answer key
     for i, q in enumerate(questions):
         p = tf.add_paragraph()
         p.text = f"Question {i+1}: {q['correct']}"
         p.level = 0
-        p.space_after = Pt(18)
+        p.space_after = Pt(12)
         
-        # Apply text formatting
+        # Only apply custom formatting if not using a template
         if "template_path" not in theme:
             p.font.color.rgb = theme["text_color"]
             p.font.size = Pt(24)
-            p.font.bold = True
             if "text_font" in theme:
                 p.font.name = theme["text_font"]
     
     return slide
 
-def create_detailed_pptx(slides_data, questions, theme, branding_options=None, ppt_version="Modern (2013+)"):
+def create_detailed_pptx(slides_data, questions, theme, branding_options=None):
     """Create PowerPoint using the uploaded template"""
     # Use the template if one was uploaded
     if "template_path" in theme and os.path.exists(theme["template_path"]):
@@ -1528,10 +1396,9 @@ def create_detailed_pptx(slides_data, questions, theme, branding_options=None, p
     else:
         prs = Presentation()
     
-    # Set aspect ratio based on selected version
-    aspect_ratio = PPT_VERSIONS[ppt_version]["aspect_ratio"]
-    prs.slide_width = Inches(aspect_ratio[0])
-    prs.slide_height = Inches(aspect_ratio[1])
+    # Set widescreen layout (16:9 aspect ratio)
+    prs.slide_width = Inches(13.33)
+    prs.slide_height = Inches(7.5)
     
     # Layout mapping
     layout_indices = {
@@ -1549,7 +1416,7 @@ def create_detailed_pptx(slides_data, questions, theme, branding_options=None, p
     default_layout_idx = available_layouts.get('title-content', 0)
     
     # Create main slides
-    for i, slide_info in enumerate(slides_data, 1):
+    for slide_info in slides_data:
         layout = slide_info.get('layout', 'title-content').lower()
         layout_idx = available_layouts.get(layout, default_layout_idx)
         
@@ -1558,153 +1425,87 @@ def create_detailed_pptx(slides_data, questions, theme, branding_options=None, p
         except IndexError:
             slide = prs.slides.add_slide(prs.slide_layouts[default_layout_idx])
         
-        # Apply background if using custom theme
+        # Set title
+        title = slide.shapes.title
+        title.text = slide_info['title']
+        title.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER
+        
+        # Only apply custom formatting if not using a template
         if "template_path" not in theme:
+            # Apply background
             background = slide.background
             fill = background.fill
             fill.solid()
             fill.fore_color.rgb = theme["background"]
-        
-        # Remove unused placeholders
-        for shape in slide.shapes:
-            if shape.has_text_frame and not shape.text.strip():
-                sp = shape._element
-                sp.getparent().remove(sp)
-        
-        # Try to get the title placeholder
-        title_placeholder = slide.shapes.title if hasattr(slide.shapes, 'title') else None
-        
-        # Set title if placeholder exists
-        if title_placeholder is not None:
-            title_placeholder.text = slide_info['title']
-            title_placeholder.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER
             
-            # Only apply custom formatting if not using a template
-            if "template_path" not in theme:
-                # Format title
-                title_placeholder.text_frame.paragraphs[0].font.color.rgb = theme["title_color"]
-                title_placeholder.text_frame.paragraphs[0].font.size = Pt(36)
-                title_placeholder.text_frame.paragraphs[0].font.bold = True
-                if "title_font" in theme:
-                    title_placeholder.text_frame.paragraphs[0].font.name = theme["title_font"]
-                
-                # Add decorative line under title
-                add_title_separator(slide, title_placeholder, theme["accent"])
-        else:
-            # Add title manually if no placeholder
-            left = Inches(1)
-            top = Inches(0.5)
-            width = prs.slide_width - Inches(2)
-            height = Inches(1)
-            title_box = slide.shapes.add_textbox(left, top, width, height)
-            title_tf = title_box.text_frame
-            p = title_tf.add_paragraph()
-            p.text = slide_info['title']
-            p.alignment = PP_ALIGN.CENTER
-            p.font.bold = True
-            p.font.size = Pt(36)
+            # Format title
+            title.text_frame.paragraphs[0].font.color.rgb = theme["title_color"]
+            title.text_frame.paragraphs[0].font.size = Pt(36)
+            title.text_frame.paragraphs[0].font.bold = True
             if "title_font" in theme:
-                p.font.name = theme["title_font"]
-            if "title_color" in theme:
-                p.font.color.rgb = theme["title_color"]
+                title.text_frame.paragraphs[0].font.name = theme["title_font"]
+        
+        # Add logo if provided
+        if branding_options and branding_options.get('logo_path'):
+            add_logo_to_slide(slide, branding_options['logo_path'], 
+                            branding_options.get('logo_position', 'top-right'))
         
         # Set content based on layout
-        if layout == 'two-column':
+        if layout_idx == 3:  # Two column layout
             content = slide_info.get('content', [])
             mid_point = len(content) // 2
             left_content = content[:mid_point]
             right_content = content[mid_point:]
             
-            # Create left column
-            left = Inches(0.5)
-            top = Inches(1.8)  # Increased top margin
-            width = prs.slide_width / 2 - Inches(1)
-            height = prs.slide_height - top - Inches(1)  # Leave space at bottom
-            left_box = slide.shapes.add_textbox(left, top, width, height)
-            left_tf = left_box.text_frame
+            left_body = slide.placeholders[1]
+            left_tf = left_body.text_frame
+            left_tf.clear()
             
-            # Create right column
-            left = prs.slide_width / 2 + Inches(0.5)
-            right_box = slide.shapes.add_textbox(left, top, width, height)
-            right_tf = right_box.text_frame
+            right_body = slide.placeholders[2]
+            right_tf = right_body.text_frame
+            right_tf.clear()
             
             for content_part, tf in [(left_content, left_tf), (right_content, right_tf)]:
                 for point in content_part:
-                    # Wrap text to prevent overflow
-                    wrapped_text = smart_text_wrap(point, 100)
-                    
-                    # Calculate optimal font size
-                    font_size = calculate_optimal_font_size(point, width, height, 18)
-                    
-                    for line in wrapped_text:
-                        p = tf.add_paragraph()
-                        p.text = line
-                        p.level = 0
-                        p.alignment = PP_ALIGN.JUSTIFY
-                        p.space_after = Pt(8)  # Reduced space between lines
-                        if "template_path" not in theme:  # Only apply custom formatting if no template
-                            p.font.color.rgb = theme["text_color"]
-                            p.font.size = Pt(font_size)
-                            if "text_font" in theme:
-                                p.font.name = theme["text_font"]
-        
-        elif layout != 'title-only':  # Content slides
-            # Create content area
-            left = Inches(1)
-            top = Inches(1.8)  # Increased top margin
-            width = prs.slide_width - Inches(2)
-            height = prs.slide_height - top - Inches(1)  # Leave space at bottom
-            content_box = slide.shapes.add_textbox(left, top, width, height)
-            tf = content_box.text_frame
-            
-            for point in slide_info.get('content', []):
-                # Wrap text to prevent overflow
-                wrapped_text = smart_text_wrap(point, 100)
-                
-                # Calculate optimal font size
-                font_size = calculate_optimal_font_size(point, width, height, 18)
-                
-                for line in wrapped_text:
                     p = tf.add_paragraph()
-                    p.text = line
+                    point_text = point.replace('- ', '').strip()
+                    p.text = point_text
                     p.level = 0
-                    p.alignment = PP_ALIGN.JUSTIFY
-                    p.space_after = Pt(8)  # Reduced space between lines
+                    p.alignment = PP_ALIGN.JUSTIFY 
                     if "template_path" not in theme:  # Only apply custom formatting if no template
                         p.font.color.rgb = theme["text_color"]
-                        p.font.size = Pt(font_size)
+                        p.font.size = Pt(18)
                         if "text_font" in theme:
                             p.font.name = theme["text_font"]
         
+        elif layout_idx != 0:  # Not title-only
+            body = slide.placeholders[1]
+            tf = body.text_frame
+            tf.clear()
+            
+            for point in slide_info.get('content', []):
+                p = tf.add_paragraph()
+                point_text = point.replace('- ', '').strip()
+                p.text = point_text
+                p.level = 0
+                p.alignment = PP_ALIGN.JUSTIFY 
+                if "template_path" not in theme:  # Only apply custom formatting if no template
+                    p.font.color.rgb = theme["text_color"]
+                    p.font.size = Pt(18)
+                    if "text_font" in theme:
+                        p.font.name = theme["text_font"]
+        
         # Add notes if available
-        if slide_info.get('notes') and hasattr(slide, 'notes_slide'):
+        if slide_info.get('notes'):
             notes_slide = slide.notes_slide
-            if hasattr(notes_slide, 'notes_text_frame'):
-                notes_slide.notes_text_frame.text = slide_info['notes']
+            notes_slide.notes_text_frame.text = slide_info['notes']
     
-    # Add question slides (one per question) with consistent theme
+    # Add question slides (one per question)
     if questions:
-        # Add section header with consistent theme
-        try:
-            section_slide = prs.slides.add_slide(prs.slide_layouts[2])  # Section header layout
-        except IndexError:
-            section_slide = prs.slides.add_slide(prs.slide_layouts[0])  # Fallback to title slide
-        
-        # Apply background if using custom theme
-        if "template_path" not in theme:
-            background = section_slide.background
-            fill = background.fill
-            fill.solid()
-            fill.fore_color.rgb = theme["background"]
-        
-        title_placeholder = section_slide.shapes.title if hasattr(section_slide.shapes, 'title') else None
-        if title_placeholder is not None:
-            title_placeholder.text = "Knowledge Check"
-            
-            # Format section header
-            if "template_path" not in theme:
-                title_placeholder.text_frame.paragraphs[0].font.color.rgb = theme["accent"]
-                title_placeholder.text_frame.paragraphs[0].font.size = Pt(44)
+        # Add section header
+        section_slide = prs.slides.add_slide(prs.slide_layouts[2])  # Section header layout
+        section_title = section_slide.shapes.title
+        section_title.text = "Knowledge Check"
         
         # Add each question on a separate slide
         for i, question in enumerate(questions, 1):
@@ -1723,53 +1524,6 @@ def create_detailed_pptx(slides_data, questions, theme, branding_options=None, p
     
     return pptx_io
 
-def regenerate_slide(slide_index, topic, slide_count, theme, ppt_version):
-    """Regenerate a specific slide using AI"""
-    model = genai.GenerativeModel('gemini-2.0-flash')
-    prompt = f"""We are creating a presentation on '{topic}' with {slide_count} slides. 
-    Please regenerate only slide number {slide_index+1} with the same structure as the others.
-    The slide should have:
-    - A clear title in [Title:] format
-    - 3-5 detailed bullet points in [Content:] format (each point should be concise, 1-2 lines max)
-    - Optional speaker notes in [Notes:] format
-    - Layout suggestion in [Layout:] format
-    
-    Format:
-    [Title:] Slide Title
-    [Layout:] layout-type
-    [Content:]
-    - Point 1: Concise point
-    - Point 2: Another concise point
-    [Notes:] Optional notes
-    
-    Make sure the content is concise and fits on a single slide. Avoid long paragraphs.
-    """
-    
-    response = model.generate_content(prompt)
-    new_slide_text = response.text
-    
-    # Parse the new slide
-    new_slide = {'title': '', 'content': [], 'notes': '', 'layout': 'title-content'}
-    for line in new_slide_text.split('\n'):
-        line = line.strip()
-        if line.startswith('[Title:]'):
-            new_slide['title'] = line.replace('[Title:]', '').strip()
-        elif line.startswith('[Content:]'):
-            pass  # Content follows on subsequent lines
-        elif line.startswith('[Notes:]'):
-            new_slide['notes'] = line.replace('[Notes:]', '').strip()
-        elif line.startswith('[Layout:]'):
-            layout = line.replace('[Layout:]', '').strip().lower()
-            valid_layouts = ['title-only', 'title-content', 'two-column', 'section-header']
-            new_slide['layout'] = layout if layout in valid_layouts else 'title-content'
-        elif line.startswith('-'):
-            point = line[1:].strip()
-            if ':' in point:
-                point = point.split(':')[0].strip()
-            new_slide['content'].append(point)
-    
-    return new_slide
-
 def main():
     st.set_page_config(page_title="Advanced PPTX Generator", layout="wide")
     
@@ -1780,18 +1534,6 @@ def main():
     if 'custom_themes' not in st.session_state:
         st.session_state.custom_themes = {}
     
-    # Initialize session state for presentation data
-    if 'slides_data' not in st.session_state:
-        st.session_state.slides_data = []
-    if 'questionnaire' not in st.session_state:
-        st.session_state.questionnaire = []
-    if 'answer_key' not in st.session_state:
-        st.session_state.answer_key = []
-    if 'pptx_file' not in st.session_state:
-        st.session_state.pptx_file = None
-    if 'regenerate_map' not in st.session_state:
-        st.session_state.regenerate_map = {}
-    
     # Combine default and custom themes
     ALL_THEMES = {**DEFAULT_THEMES, **st.session_state.custom_themes}
     col1, col2 = st.columns([3, 1])
@@ -1826,7 +1568,6 @@ def main():
                         accent_color = st.color_picker("Accent Color", "#0070C0")
                         title_font = st.text_input("Title Font", "Calibri")
                         text_font = st.text_input("Text Font", "Calibri")
-                        min_font_size = st.slider("Minimum Font Size", 10, 18, 14)
                         
                         if st.form_submit_button("Save Custom Theme"):
                             if new_theme_name:
@@ -1836,8 +1577,7 @@ def main():
                                     "text_color": hex_to_rgb(text_color),
                                     "accent": hex_to_rgb(accent_color),
                                     "title_font": title_font,
-                                    "text_font": text_font,
-                                    "min_font_size": min_font_size
+                                    "text_font": text_font
                                 }
                                 st.success(f"Theme '{new_theme_name}' saved successfully!")
                             else:
@@ -1852,14 +1592,6 @@ def main():
                         st.success("Theme extracted from template!")
                 else:
                     st.info("Please upload a PowerPoint file to extract its theme")
-            
-            # PowerPoint version compatibility
-            ppt_version = st.selectbox(
-                "PowerPoint Version Compatibility:",
-                list(PPT_VERSIONS.keys()),
-                index=0
-            )
-            st.caption("Modern (2013+): Widescreen (16:9)\nStandard (2007-2013): Standard (4:3)\nLegacy (2003): Standard (4:3)")
     
     with col2:
         st.markdown("### Instructions")
@@ -1867,117 +1599,57 @@ def main():
         st.markdown("2. Select slide count and theme")
         st.markdown("3. Click 'Generate Presentation'")
         st.markdown("4. Download your PowerPoint file")
-        st.markdown("5. Use 'Regenerate' buttons to improve specific slides")
     
-    generate_btn = st.button("Generate Presentation", type="primary", key="generate_btn")
-    if generate_btn:
+    if st.button("Generate Presentation", type="primary", key="generate_btn"):
         if not topic:
             st.warning("Please enter a topic first!")
         elif theme_option == "Example-Based Theme" and not uploaded_file:
             st.warning("Please upload a PowerPoint template file first")
         else:
-            with st.spinner("Generating your presentation..."):
-                progress_bar = st.progress(0)
-                status_text = st.empty()
-                
-                # Generate slide content
-                status_text.text("Generating content with AI...")
-                progress_bar.progress(20)
-                model = genai.GenerativeModel('gemini-2.0-flash')
-                slide_text = generate_slide_content(topic, slide_count, _model=model)
-                
-                # Parse slide content
-                status_text.text("Parsing slide content...")
-                progress_bar.progress(40)
-                slides_data, questionnaire, answer_key = parse_slide_content(slide_text)
-                
-                # Store in session state
-                st.session_state.slides_data = slides_data
-                st.session_state.questionnaire = questionnaire
-                st.session_state.answer_key = answer_key
-                st.session_state.regenerate_map = {i: False for i in range(len(slides_data))}
-                
-                # Create PowerPoint
-                status_text.text("Creating PowerPoint file...")
-                progress_bar.progress(70)
-                pptx_file = create_detailed_pptx(slides_data, questionnaire, theme, ppt_version=ppt_version)
-                st.session_state.pptx_file = pptx_file
-                
-                progress_bar.progress(100)
-                status_text.text("Done!")
-                time.sleep(1)
-                progress_bar.empty()
-                status_text.empty()
-                
-                st.success("Presentation generated successfully!")
-    
-    # Show slide overview with regeneration options
-    if st.session_state.slides_data:
-        with st.expander("Slide Overview (Click to Expand)", expanded=True):
-            st.markdown(f"**Total Slides:** {len(st.session_state.slides_data)} content slides + "
-                        f"{len(st.session_state.questionnaire)} question slides + 1 answer key slide")
-            
-            for i, slide in enumerate(st.session_state.slides_data):
-                col1, col2 = st.columns([4, 1])
-                with col1:
-                    st.subheader(f"Slide {i+1}: {slide['title']}")
-                    st.markdown("**Content:**")
-                    for point in slide.get('content', []):
-                        st.markdown(f"- {point}")
-                    if slide.get('notes'):
-                        st.markdown(f"**Notes:** {slide['notes']}")
-                
-                with col2:
-                    if st.button(f"Regenerate", key=f"reg_{i}"):
-                        with st.spinner(f"Regenerating slide {i+1}..."):
-                            new_slide = regenerate_slide(i, topic, slide_count, theme, ppt_version)
-                            st.session_state.slides_data[i] = new_slide
-                            st.session_state.regenerate_map[i] = True
-                            st.rerun()
+            with st.spinner(f"Creating {slide_count}-slide presentation about '{topic}'..."):
+                try:
+                    slide_text = generate_slide_content(topic, slide_count)
+                    slides_data, questionnaire, answer_key = parse_slide_content(slide_text)
                     
-                    # Show regeneration status
-                    if st.session_state.regenerate_map.get(i, False):
-                        st.success("Regenerated!")
-                
-                st.markdown("---")
-            
-            if st.session_state.questionnaire:
-                st.subheader("Questionnaire")
-                st.markdown(f"**Total Questions:** {len(st.session_state.questionnaire)}")
-                for i, q in enumerate(st.session_state.questionnaire, 1):
-                    st.subheader(f"Question {i}")
-                    st.markdown(f"**{q['text']}**")
-                    for j, opt in enumerate(q['options']):
-                        st.markdown(f"{chr(65+j)}. {opt}")
-                    st.markdown(f"*Correct: {q['correct']}*")
-                    st.markdown("---")
-                
-                if st.session_state.answer_key:
-                    st.subheader("Answer Key")
-                    for i, ans in enumerate(st.session_state.answer_key, 1):
-                        st.markdown(f"{i}. {ans}")
-    
-    # Rebuild PPTX if any slides were regenerated
-    if any(st.session_state.regenerate_map.values()):
-        with st.spinner("Updating presentation with regenerated slides..."):
-            pptx_file = create_detailed_pptx(
-                st.session_state.slides_data,
-                st.session_state.questionnaire,
-                theme,
-                ppt_version=ppt_version
-            )
-            st.session_state.pptx_file = pptx_file
-            st.session_state.regenerate_map = {i: False for i in range(len(st.session_state.slides_data))}
-            st.success("Presentation updated with regenerated slides!")
-    
-    # Download button
-    if st.session_state.pptx_file:
-        st.download_button(
-            label="Download PowerPoint",
-            data=st.session_state.pptx_file,
-            file_name=f"{topic.replace(' ', '_') if topic else 'presentation'}_presentation.pptx",
-            mime="application/vnd.openxmlformats-officedocument.presentationml.presentation"
-        )
+                    # Show slide overview with detailed content
+                    with st.expander("Slide Overview (Detailed)"):
+                        for i, slide in enumerate(slides_data, 1):
+                            st.subheader(f"Slide {i}: {slide['title']}")
+                            st.markdown("**Content:**")
+                            for point in slide.get('content', []):
+                                st.markdown(f"- {point}")
+                            if slide.get('notes'):
+                                st.markdown(f"**Notes:** {slide['notes']}")
+                            st.markdown("---")
+                        
+                        if questionnaire:
+                            st.subheader("Questionnaire")
+                            for i, q in enumerate(questionnaire, 1):
+                                st.subheader(f"Question {i}")
+                                st.markdown(f"**{q['text']}**")
+                                for j, opt in enumerate(q['options']):
+                                    st.markdown(f"{chr(65+j)}. {opt}")
+                                st.markdown(f"*Correct: {q['correct']}*")
+                                st.markdown("---")
+                            
+                            if answer_key:
+                                st.subheader("Answer Key")
+                                for i, ans in enumerate(answer_key, 1):
+                                    st.markdown(f"{i}. {ans}")
+                    
+                    pptx_file = create_detailed_pptx(slides_data, questionnaire, theme)
+                    
+                    st.success("Presentation generated successfully!")
+                    
+                    st.download_button(
+                        label="Download PowerPoint",
+                        data=pptx_file,
+                        file_name=f"{topic.replace(' ', '_')}_presentation.pptx",
+                        mime="application/vnd.openxmlformats-officedocument.presentationml.presentation"
+                    )
+                    
+                except Exception as e:
+                    st.error(f"An error occurred: {str(e)}")
 
 if __name__ == "__main__":
     main()