Update app.py

app.py

@@ -10,6 +10,11 @@ from collections import defaultdict
 import io
 from pypdf import PdfWriter
 
+# Imports for new formats
+from docx import Document
+from docx.shared import Inches
+import openpyxl
+
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, BaseDocTemplate, Frame, PageTemplate, Image as ReportLabImage
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.lib.pagesizes import letter, A4, legal, landscape
@@ -25,10 +30,8 @@ LAYOUTS = {
     "A4 Landscape": {"size": landscape(A4)},
     "Letter Portrait": {"size": letter},
     "Letter Landscape": {"size": landscape(letter)},
-    "Legal Portrait": {"size": legal},
-    "Legal Landscape": {"size": landscape(legal)},
 }
-OUTPUT_DIR = CWD / "generated_pdfs"
+OUTPUT_DIR = CWD / "generated_outputs"
 PREVIEW_DIR = CWD / "previews"
 FONT_DIR = CWD
 
@@ -37,15 +40,11 @@ OUTPUT_DIR.mkdir(exist_ok=True)
 PREVIEW_DIR.mkdir(exist_ok=True)
 
 
-# --- Font & Emoji Handling ---
+# --- Font & Emoji Handling (for PDF) ---
 
 def register_local_fonts():
     """Finds and registers all .ttf files from the application's base directory."""
-    print("--- Font Registration Process Starting ---")
-    text_font_names = []
-    emoji_font_name = None
-    
-    print(f"Scanning for fonts in: {FONT_DIR.absolute()}")
+    text_font_names, emoji_font_name = [], None
     font_files = list(FONT_DIR.glob("*.ttf"))
     print(f"Found {len(font_files)} .ttf files: {[f.name for f in font_files]}")
 
@@ -54,271 +53,196 @@ def register_local_fonts():
             font_name = font_path.stem
             pdfmetrics.registerFont(TTFont(font_name, str(font_path)))
             pdfmetrics.registerFont(TTFont(f"{font_name}-Bold", str(font_path)))
-            pdfmetrics.registerFont(TTFont(f"{font_name}-Italic", str(font_path)))
-            pdfmetrics.registerFont(TTFont(f"{font_name}-BoldItalic", str(font_path)))
-            pdfmetrics.registerFontFamily(font_name, normal=font_name, bold=f"{font_name}-Bold", italic=f"{font_name}-Italic", boldItalic=f"{font_name}-BoldItalic")
-
+            pdfmetrics.registerFontFamily(font_name, normal=font_name, bold=f"{font_name}-Bold")
             if "notocoloremoji-regular" in font_name.lower():
                 emoji_font_name = font_name
-            elif "notoemoji" not in font_name.lower(): # Exclude other symbol fonts from text selection
+            else:
                 text_font_names.append(font_name)
         except Exception as e:
             print(f"Could not register font {font_path.name}: {e}")
-
-    if not text_font_names:
-        print("WARNING: No text fonts found. Adding 'Helvetica' as a default.")
-        text_font_names.append('Helvetica')
-
-    print(f"Successfully registered user-selectable fonts: {text_font_names}")
-    print(f"Emoji font set to: {emoji_font_name}")
-    print("--- Font Registration Process Finished ---")
+    if not text_font_names: text_font_names.append('Helvetica')
     return sorted(text_font_names), emoji_font_name
 
 def apply_emoji_font(text: str, emoji_font_name: str) -> str:
-    """
-    Intelligently wraps emoji characters in a <font> tag, preserving existing HTML-like tags.
-    This prevents invalid nested tags like <b><font>...</font></b> which ReportLab handles poorly.
-    """
-    if not emoji_font_name:
-        return text
-
-    # Regex to find emojis
+    if not emoji_font_name: return text
     emoji_pattern = re.compile(f"([{re.escape(''.join(map(chr, range(0x1f600, 0x1f650))))}"
-                               f"{re.escape(''.join(map(chr, range(0x1f300, 0x1f5ff))))}"
-                               f"{re.escape(''.join(map(chr, range(0x1f900, 0x1f9ff))))}"
-                               f"{re.escape(''.join(map(chr, range(0x2600, 0x26ff))))}"
-                               f"{re.escape(''.join(map(chr, range(0x2700, 0x27bf))))}]+)")
-
-    # Regex to split the string by existing tags (<b>, <i>)
-    tag_pattern = re.compile(r"(<[^>]+>)")
-    parts = tag_pattern.split(text)
-    
-    result = []
-    for part in parts:
-        if tag_pattern.match(part):
-            # It's a tag, append it as is
-            result.append(part)
+                               f"{re.escape(''.join(map(chr, range(0x1f300, 0x1f5ff))))}]+)")
+    return emoji_pattern.sub(fr'<font name="{emoji_font_name}">\1</font>', text)
+
+
+# --- Document Generation Engines ---
+
+def create_pdf(md_content, font_name, emoji_font, pagesize, num_columns):
+    """Generates a PDF file from markdown content."""
+    md_buffer = io.BytesIO()
+    story = markdown_to_story(md_content, font_name, emoji_font)
+    if num_columns > 1:
+        doc = BaseDocTemplate(md_buffer, pagesize=pagesize, leftMargin=0.5*inch, rightMargin=0.5*inch)
+        frame_width = (doc.width / num_columns) - (num_columns - 1) * 0.1*inch
+        frames = [Frame(doc.leftMargin + i * (frame_width + 0.2*inch), doc.bottomMargin, frame_width, doc.height) for i in range(num_columns)]
+        doc.addPageTemplates([PageTemplate(id='MultiCol', frames=frames)])
+    else:
+        doc = SimpleDocTemplate(md_buffer, pagesize=pagesize)
+    doc.build(story)
+    return md_buffer
+
+def create_docx(md_content):
+    """Generates a DOCX file from markdown content."""
+    document = Document()
+    for line in md_content.split('\n'):
+        if line.startswith('# '):
+            document.add_heading(line[2:], level=1)
+        elif line.startswith('## '):
+            document.add_heading(line[3:], level=2)
+        elif line.strip().startswith(('- ','* ')):
+            document.add_paragraph(line.strip()[2:], style='List Bullet')
         else:
-            # It's text, apply emoji font to any emojis within this segment
-            result.append(emoji_pattern.sub(fr'<font name="{emoji_font_name}">\1</font>', part))
+            p = document.add_paragraph()
+            # Handle bold and italics with runs
+            parts = re.split(r'(\*\*.*?\*\*|_.*?_)', line)
+            for part in parts:
+                if part.startswith('**') and part.endswith('**'):
+                    p.add_run(part[2:-2]).bold = True
+                elif part.startswith('_') and part.endswith('_'):
+                    p.add_run(part[1:-1]).italic = True
+                else:
+                    p.add_run(part)
+    return document
+
+def create_xlsx(md_content):
+    """Generates an XLSX file, splitting content by H1 headers into columns."""
+    workbook = openpyxl.Workbook()
+    sheet = workbook.active
+    
+    # Split content by H1 headers
+    sections = re.split(r'\n# ', '\n' + md_content)
+    if sections[0] == '': sections.pop(0)
+
+    max_rows = 0
+    column_data = []
+
+    for section in sections:
+        lines = section.split('\n')
+        header = lines[0]
+        content = [l.strip() for l in lines[1:] if l.strip()]
+        column_data.append({'header': header, 'content': content})
+        if len(content) > max_rows:
+            max_rows = len(content)
+
+    for c_idx, col in enumerate(column_data, 1):
+        sheet.cell(row=1, column=c_idx, value=col['header'])
+        for r_idx, line_content in enumerate(col['content'], 2):
+            sheet.cell(row=r_idx, column=c_idx, value=line_content)
             
-    return "".join(result)
-
-
-# --- PDF Generation & Handling ---
+    return workbook
 
 def markdown_to_story(markdown_text: str, font_name: str, emoji_font: str):
-    """
-    Converts markdown to a ReportLab story, with enhanced styling and page breaks.
-    This version correctly separates structural parsing from content formatting.
-    """
+    """Converts markdown to a ReportLab story for PDF generation."""
     styles = getSampleStyleSheet()
-    # Define styles for various markdown elements
-    style_normal = ParagraphStyle('BodyText', fontName=font_name, spaceAfter=6, leading=14, fontSize=10)
-    style_h1 = ParagraphStyle('h1', parent=styles['h1'], fontName=font_name, spaceBefore=12, fontSize=24, leading=28, textColor=colors.darkblue)
-    style_h2 = ParagraphStyle('h2', parent=styles['h2'], fontName=font_name, fontSize=18, leading=22, spaceBefore=10)
-    style_h3 = ParagraphStyle('h3', parent=styles['h3'], fontName=font_name, fontSize=14, leading=18, spaceBefore=8)
-    style_code = ParagraphStyle('Code', fontName='Courier', backColor=colors.whitesmoke, textColor=colors.darkred, borderWidth=1, borderColor=colors.lightgrey, padding=8, leading=12, fontSize=9)
-    style_table_header = ParagraphStyle('TableHeader', parent=style_normal, fontName=font_name + "-Bold" if font_name != 'Helvetica' else 'Helvetica-Bold')
-    
-    story = []
-    lines = markdown_text.split('\n')
-    
-    in_code_block, in_table = False, False
-    code_block_text, table_data = "", []
-    first_heading = True
-
-    for line in lines:
-        stripped_line = line.strip()
-
-        if stripped_line.startswith("```"):
-            if in_code_block:
-                story.append(Paragraph(code_block_text.replace('\n', '<br/>'), style_code)); story.append(Spacer(1, 0.1 * inch))
-                in_code_block = False; code_block_text = ""
-            else: in_code_block = True
-            continue
-        if in_code_block:
-            code_block_text += line.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;') + '\n'
-            continue
-        
-        if stripped_line.startswith('|'):
-            if not in_table: in_table = True
-            if all(c in '-|: ' for c in stripped_line): continue
-            cells = [cell.strip() for cell in stripped_line.strip('|').split('|')]
-            table_data.append(cells)
-            continue
-        if in_table:
-            in_table = False
-            if table_data:
-                header_content = [apply_emoji_font(re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', cell), emoji_font) for cell in table_data[0]]
-                header = [Paragraph(cell, style_table_header) for cell in header_content]
-                
-                formatted_rows = []
-                for row in table_data[1:]:
-                    formatted_cells = [apply_emoji_font(re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', cell), emoji_font) for cell in row]
-                    formatted_rows.append([Paragraph(cell, style_normal) for cell in formatted_cells])
-                
-                table = Table([header] + formatted_rows, hAlign='LEFT', repeatRows=1)
-                table.setStyle(TableStyle([('BACKGROUND', (0, 0), (-1, 0), colors.lightgrey), ('GRID', (0, 0), (-1, -1), 1, colors.darkgrey), ('VALIGN', (0,0), (-1,-1), 'MIDDLE')]))
-                story.append(table); story.append(Spacer(1, 0.2 * inch))
-            table_data = []
-
-        if not stripped_line:
-            story.append(Spacer(1, 0.1 * inch))
-            continue
-
-        # Default content is the whole stripped line
-        content = stripped_line
-        style = style_normal
-        extra_args = {}
-        
-        # Detect structural elements and extract the raw content
-        if stripped_line.startswith("# "):
+    style_normal = ParagraphStyle('BodyText', fontName=font_name, spaceAfter=6, fontSize=10)
+    style_h1 = ParagraphStyle('h1', fontName=font_name, spaceBefore=12, fontSize=24)
+    story, first_heading = [], True
+    for line in markdown_text.split('\n'):
+        content, style = line, style_normal
+        if line.startswith("# "):
             if not first_heading: story.append(PageBreak())
-            content = stripped_line.lstrip('# '); style = style_h1; first_heading = False
-        elif stripped_line.startswith("## "):
-            content = stripped_line.lstrip('## '); style = style_h2
-        elif stripped_line.startswith("### "):
-            content = stripped_line.lstrip('### '); style = style_h3
-        elif stripped_line.startswith(("- ", "* ")):
-            content = stripped_line[2:]; extra_args['bulletText'] = '•'
-        
-        # Now, format the extracted content
-        # Apply markdown formatting for bold/italic
-        formatted_content = re.sub(r'_(.*?)_', r'<i>\1</i>', re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', content))
-        # Then apply emoji font to the already formatted line
+            content, style, first_heading = line.lstrip('# '), style_h1, False
+        formatted_content = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', content)
         final_content = apply_emoji_font(formatted_content, emoji_font)
-        
-        story.append(Paragraph(final_content, style, **extra_args))
+        story.append(Paragraph(final_content, style))
     return story
 
-
 def create_pdf_preview(pdf_path: Path):
     preview_path = PREVIEW_DIR / f"{pdf_path.stem}.png"
     try:
         doc = fitz.open(pdf_path); page = doc.load_page(0); pix = page.get_pixmap()
         pix.save(str(preview_path)); doc.close()
         return str(preview_path)
-    except Exception as e:
-        print(f"Could not create preview for {pdf_path.name}: {e}"); return None
+    except: return None
 
 # --- Main API Function ---
-def generate_pdfs_api(files, layouts, fonts, num_columns, page_w_mult, page_h_mult, progress=gr.Progress(track_tqdm=True)):
-    if not files: raise gr.Error("Please upload at least one Markdown or Image file.")
-    if not layouts: raise gr.Error("Please select at least one page layout.")
-    if not fonts: raise gr.Error("Please select at least one font.")
+def generate_outputs_api(files, output_formats, layouts, fonts, num_columns, page_w_mult, page_h_mult, progress=gr.Progress(track_tqdm=True)):
+    if not files: raise gr.Error("Please upload at least one file.")
+    if not output_formats: raise gr.Error("Please select at least one output format.")
 
     shutil.rmtree(OUTPUT_DIR, ignore_errors=True); shutil.rmtree(PREVIEW_DIR, ignore_errors=True)
     OUTPUT_DIR.mkdir(); PREVIEW_DIR.mkdir()
 
-    grouped_files = defaultdict(lambda: {'md': [], 'img': []})
-    for f in files:
-        file_path = Path(f.name)
-        stem = file_path.stem.split('_')[0] if '_' in file_path.stem else file_path.stem
-        if file_path.suffix.lower() == '.md': grouped_files[stem]['md'].append(file_path)
-        elif file_path.suffix.lower() in ['.png', '.jpg', '.jpeg']: grouped_files[stem]['img'].append(file_path)
+    # Consolidate all markdown content
+    md_content = "\n\n# ".join([Path(f.name).read_text(encoding='utf-8') for f in files if Path(f.name).suffix.lower() == '.md'])
+    if not md_content.startswith("# "): md_content = "# " + md_content
 
-    log_updates, generated_pdf_paths = "", []
-
-    for stem, assets in progress.tqdm(grouped_files.items(), desc="Processing File Groups"):
-        for layout_name in layouts:
-            for font_name in fonts:
-                merger = PdfWriter()
-                
-                if assets['md']:
-                    md_content = "\n".join([p.read_text(encoding='utf-8') for p in assets['md']])
-                    md_buffer = io.BytesIO()
-                    story = markdown_to_story(md_content, font_name, EMOJI_FONT_NAME)
-                    
-                    base_w, base_h = LAYOUTS[layout_name]["size"]
-                    pagesize = (base_w * page_w_mult, base_h * page_h_mult)
+    log_updates, generated_files = "", []
+    
+    for format_choice in progress.tqdm(output_formats, desc="Generating Formats"):
+        time_str = datetime.datetime.now().strftime('%m-%d-%a_%I%M%p').upper()
+        
+        if format_choice == "PDF":
+            for layout_name in layouts:
+                for font_name in fonts:
+                    pagesize = LAYOUTS[layout_name]["size"]
+                    final_pagesize = (pagesize[0] * page_w_mult, pagesize[1] * page_h_mult)
+                    pdf_buffer = create_pdf(md_content, font_name, EMOJI_FONT_NAME, final_pagesize, num_columns)
                     
-                    if num_columns > 1:
-                        doc = BaseDocTemplate(md_buffer, pagesize=pagesize, leftMargin=0.5*inch, rightMargin=0.5*inch, topMargin=0.5*inch, bottomMargin=0.5*inch)
-                        frame_width = (doc.width / num_columns) - (num_columns - 1) * 0.1*inch
-                        frames = [Frame(doc.leftMargin + i * (frame_width + 0.2*inch), doc.bottomMargin, frame_width, doc.height) for i in range(num_columns)]
-                        doc.addPageTemplates([PageTemplate(id='MultiCol', frames=frames)])
-                    else:
-                        doc = SimpleDocTemplate(md_buffer, pagesize=pagesize)
-                    doc.build(story)
-                    merger.append(fileobj=md_buffer)
-
-                for img_path in assets['img']:
-                    with Image.open(img_path) as img: img_width, img_height = img.size
-                    img_buffer = io.BytesIO()
-                    doc = SimpleDocTemplate(img_buffer, pagesize=(img_width, img_height), leftMargin=0, rightMargin=0, topMargin=0, bottomMargin=0)
-                    doc.build([ReportLabImage(img_path, width=img_width, height=img_height)])
-                    merger.append(fileobj=img_buffer)
-                
-                if len(merger.pages) > 0:
-                    time_str = datetime.datetime.now().strftime('%m-%d-%a_%I%M%p').upper()
-                    filename = f"{stem}_{time_str}_{layout_name.replace(' ','-')}_{page_w_mult}x{page_h_mult}_{font_name}_Cols{num_columns}.pdf"
+                    filename = f"Document_{time_str}_{layout_name.replace(' ','-')}_{font_name}.pdf"
                     output_path = OUTPUT_DIR / filename
-                    with open(output_path, "wb") as f: merger.write(f)
-                    generated_pdf_paths.append(output_path)
-                    log_updates += f"Generated: {filename}\n"
-
-    gallery_previews = [create_pdf_preview(p) for p in generated_pdf_paths]
-    final_gallery = [g for g in gallery_previews if g is not None]
+                    with open(output_path, "wb") as f: f.write(pdf_buffer.getvalue())
+                    generated_files.append(output_path)
+        
+        elif format_choice == "DOCX":
+            docx_doc = create_docx(md_content)
+            filename = f"Document_{time_str}.docx"
+            output_path = OUTPUT_DIR / filename
+            docx_doc.save(output_path)
+            generated_files.append(output_path)
+        
+        elif format_choice == "XLSX":
+            xlsx_book = create_xlsx(md_content)
+            filename = f"Outline_{time_str}.xlsx"
+            output_path = OUTPUT_DIR / filename
+            xlsx_book.save(output_path)
+            generated_files.append(output_path)
+            
+    gallery_previews = [create_pdf_preview(p) for p in generated_files if p.suffix == '.pdf']
+    final_gallery = [g for g in gallery_previews if g]
     
-    return final_gallery, log_updates, [str(p) for p in generated_pdf_paths]
+    return final_gallery, f"Generated {len(generated_files)} files.", [str(p) for p in generated_files]
 
 # --- Gradio UI Definition ---
 AVAILABLE_FONTS, EMOJI_FONT_NAME = register_local_fonts()
-SAMPLE_MARKDOWN = """# Deities Guide: Mythology and Moral Lessons 
-
-1. 📜 **Introduction**
-   - **Purpose**: Explore deities, spirits, saints, and beings with their epic stories and morals!
-   - **Usage**: A guide for learning and storytelling across traditions. ️
-   - **Themes**: Justice ⚖️, faith 🙏, hubris 🏛️, redemption ✨, cosmic order 🌌.
-
-2. 🛠️ **Core Concepts of Divinity**
-   - **Powers**: Creation 🌍, omniscience 👁️‍🗨️, shapeshifting 🦋 across entities.
-   - **Life Cycle**: Mortality ⏳, immortality ♾️, transitions like saints and avatars 🌟.
-   - **Communication**: Omens 🕊️, visions 👁️, miracles ✨ from gods and spirits.
-
-# ⚔️ Arthurian Legends
- - **Merlin, Morgan le Fay, Arthur**: Mentor 🧙, rival 🧙‍♀️, son 👑.
- - **Relation**: Family tests loyalty 🤝.
- - **Lesson**: Honor 🎖️ vs. betrayal 🗡️.
-
-# 🏛️ Greek Mythology
- - **Zeus, Hera, Athena**: Father ⚡, mother 👑, daughter 🦉.
- - **Relation**: Family rules with tension 🌩️.
- - **Lesson**: Hubris  अहंकार meets wisdom 🧠.
-
-# 🕉️ Hindu Trimurti
- - **Brahma, Vishnu, Shiva**: Creator  Brahma, preserver  Vishnu, destroyer  Shiva.
- - **Relation**: Divine trio cycles existence 🔄.
- - **Lesson**: Balance ⚖️ sustains life 💖.
-"""
+SAMPLE_MARKDOWN = "# Deities Guide\n\n- **Purpose**: Explore deities and their morals! \n- **Themes**: Justice ⚖️, faith 🙏\n\n# Arthurian Legends\n\n - **Merlin, Arthur**: Mentor 🧙, son 👑.\n - **Lesson**: Honor 🎖️ vs. betrayal 🗡️."
 with open(CWD / "sample.md", "w", encoding="utf-8") as f: f.write(SAMPLE_MARKDOWN)
 
-with gr.Blocks(theme=gr.themes.Soft(), title="Advanced PDF Generator") as demo:
-    gr.Markdown("# 📄 Advanced PDF Layout Engine")
-    gr.Markdown("Upload Markdown/Image files. The app finds local `.ttf` fonts. Group assets with a common name (e.g., `Doc_part1.md`, `Doc_img1.png`) to combine them. `# Headers` create automatic page breaks.")
+with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Document Generator") as demo:
+    gr.Markdown("# 📄 Advanced Document Generator (PDF, DOCX, XLSX)")
+    gr.Markdown("Upload Markdown files to generate documents in multiple formats. `# Headers` create columns in XLSX and page breaks in multi-page PDFs.")
 
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### ⚙️ Generation Settings")
-            uploaded_files = gr.File(label="Upload Markdown & Image Files", file_count="multiple", file_types=[".md", ".png", ".jpg", ".jpeg"])
+            uploaded_files = gr.File(label="Upload Markdown & Image Files", file_count="multiple", file_types=[".md", ".png", ".jpg"])
+            
+            output_formats = gr.CheckboxGroup(choices=["PDF", "DOCX", "XLSX"], label="Select Output Formats", value=["PDF"])
             
-            with gr.Row():
-                page_w_mult_slider = gr.Slider(label="Page Width Multiplier", minimum=1, maximum=5, step=1, value=1)
-                page_h_mult_slider = gr.Slider(label="Page Height Multiplier", minimum=1, maximum=2, step=1, value=1)
+            with gr.Accordion("PDF Customization", open=True):
+                with gr.Row():
+                    page_w_mult_slider = gr.Slider(label="Page Width Multiplier", minimum=1, maximum=5, step=1, value=1)
+                    page_h_mult_slider = gr.Slider(label="Page Height Multiplier", minimum=1, maximum=2, step=1, value=1)
+                num_columns_slider = gr.Slider(label="Text Columns", minimum=1, maximum=4, step=1, value=1)
+                selected_layouts = gr.CheckboxGroup(choices=list(LAYOUTS.keys()), label="Base Page Layout", value=["A4 Portrait"])
+                selected_fonts = gr.CheckboxGroup(choices=AVAILABLE_FONTS, label="Text Font", value=[AVAILABLE_FONTS[0]] if AVAILABLE_FONTS else [])
             
-            num_columns_slider = gr.Slider(label="Number of Text Columns", minimum=1, maximum=4, step=1, value=1)
-            selected_layouts = gr.CheckboxGroup(choices=list(LAYOUTS.keys()), label="Select Base Page Layout", value=["A4 Portrait"])
-            selected_fonts = gr.CheckboxGroup(choices=AVAILABLE_FONTS, label="Select Text Font", value=[AVAILABLE_FONTS[0]] if AVAILABLE_FONTS else [])
-            generate_btn = gr.Button("🚀 Generate PDFs", variant="primary")
+            generate_btn = gr.Button("🚀 Generate Documents", variant="primary")
         
         with gr.Column(scale=2):
-            gr.Markdown("### 🖼️ PDF Preview Gallery")
-            gallery_output = gr.Gallery(label="Generated PDF Previews", show_label=False, elem_id="gallery", columns=3, height="auto", object_fit="contain")
-            log_output = gr.Markdown(label="Generation Log", value="Logs will appear here...")
-            downloadable_files_output = gr.Files(label="Download Generated PDFs")
+            gr.Markdown("### 🖼️ Output Files")
+            gallery_output = gr.Gallery(label="PDF Previews", show_label=False, elem_id="gallery", columns=3, height="auto", object_fit="contain")
+            log_output = gr.Markdown(label="Generation Log", value="Ready...")
+            downloadable_files_output = gr.Files(label="Download Generated Files")
             
-    generate_btn.click(fn=generate_pdfs_api, inputs=[uploaded_files, selected_layouts, selected_fonts, num_columns_slider, page_w_mult_slider, page_h_mult_slider], outputs=[gallery_output, log_output, downloadable_files_output])
+    generate_btn.click(fn=generate_outputs_api, 
+                       inputs=[uploaded_files, output_formats, selected_layouts, selected_fonts, num_columns_slider, page_w_mult_slider, page_h_mult_slider], 
+                       outputs=[gallery_output, log_output, downloadable_files_output])
 
 if __name__ == "__main__":
     demo.launch()