Create backup12.app.py

backup12.app.py

@@ -0,0 +1,663 @@
+import io
+import re
+import os
+import glob
+import asyncio
+import hashlib
+import unicodedata
+import streamlit as st
+from PIL import Image
+import fitz
+import edge_tts
+from reportlab.lib.pagesizes import A4
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib import colors
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+from reportlab.pdfgen import canvas
+from datetime import datetime
+import pytz
+from pypdf import PdfReader, PdfWriter
+from pypdf.annotations import Link
+from pypdf.generic import Fit
+
+st.set_page_config(layout="wide", initial_sidebar_state="expanded")
+
+# Existing functions (unchanged)
+def get_timestamp_prefix():
+    central = pytz.timezone("US/Central")
+    now = datetime.now(central)
+    return now.strftime("%a %m%d %I%M%p").upper()
+
+def clean_for_speech(text):
+    text = text.replace("#", "")
+    emoji_pattern = re.compile(
+        r"[\U0001F300-\U0001F5FF"
+        r"\U0001F600-\U0001F64F"
+        r"\U0001F680-\U0001F6FF"
+        r"\U0001F700-\U0001F77F"
+        r"\U0001F780-\U0001F7FF"
+        r"\U0001F800-\U0001F8FF"
+        r"\U0001F900-\U0001F9FF"
+        r"\U0001FA00-\U0001FA6F"
+        r"\U0001FA70-\U0001FAFF"
+        r"\u2600-\u26FF"
+        r"\u2700-\u27BF]+", flags=re.UNICODE)
+    text = emoji_pattern.sub('', text)
+    return text
+
+def trim_emojis_except_numbered(markdown_text):
+    emoji_pattern = re.compile(
+        r"[\U0001F300-\U0001F5FF"
+        r"\U0001F600-\U0001F64F"
+        r"\U0001F680-\U0001F6FF"
+        r"\U0001F700-\U0001F77F"
+        r"\U0001F780-\U0001F7FF"
+        r"\U0001F800-\U0001F8FF"
+        r"\U0001F900-\U0001F9FF"
+        r"\U0001FAD0-\U0001FAD9"
+        r"\U0001FA00-\U0001FA6F"
+        r"\U0001FA70-\U0001FAFF"
+        r"\u2600-\u26FF"
+        r"\u2700-\u27BF]+"
+    )
+    number_pattern = re.compile(r'^\d+\.\s')
+    lines = markdown_text.strip().split('\n')
+    processed_lines = []
+    
+    for line in lines:
+        if number_pattern.match(line):
+            processed_lines.append(line)
+        else:
+            processed_lines.append(emoji_pattern.sub('', line))
+    
+    return '\n'.join(processed_lines)
+
+async def generate_audio(text, voice, filename):
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(filename)
+    return filename
+
+def detect_and_convert_links(text):
+    # Convert Markdown links [text](url) to HTML <a> tags
+    md_link_pattern = re.compile(r'\[(.*?)\]\((https?://[^\s\[\]()<>{}]+)\)')
+    text = md_link_pattern.sub(r'<a href="\2" color="blue">\1</a>', text)
+    
+    # Convert plain URLs to HTML <a> tags, avoiding already tagged links
+    url_pattern = re.compile(
+        r'(?<!href=")(https?://[^\s<>{}]+)',
+        re.IGNORECASE
+    )
+    text = url_pattern.sub(r'<a href="\1" color="blue">\1</a>', text)
+    return text
+
+def apply_emoji_font(text, emoji_font):
+    # Protect existing tags
+    tag_pattern = re.compile(r'(<[^>]+>)')
+    segments = tag_pattern.split(text)
+    result = []
+    
+    # Apply emoji font only to emojis, use DejaVuSans for other text
+    emoji_pattern = re.compile(
+        r"([\U0001F300-\U0001F5FF"
+        r"\U0001F600-\U0001F64F"
+        r"\U0001F680-\U0001F6FF"
+        r"\U0001F700-\U0001F77F"
+        r"\U0001F780-\U0001F7FF"
+        r"\U0001F800-\U0001F8FF"
+        r"\U0001F900-\U0001F9FF"
+        r"\U0001FAD0-\U0001FAD9"
+        r"\U0001FA00-\U0001FA6F"
+        r"\U0001FA70-\U0001FAFF"
+        r"\u2600-\u26FF"
+        r"\u2700-\u27BF]+)"
+    )
+    
+    def replace_emoji(match):
+        emoji = match.group(1)
+        emoji = unicodedata.normalize('NFC', emoji)
+        return f'<font face="{emoji_font}">{emoji}</font>'
+    
+    for segment in segments:
+        if tag_pattern.match(segment):
+            # Keep tags unchanged
+            result.append(segment)
+        else:
+            # Apply DejaVuSans to non-emoji text, emoji_font to emojis
+            parts = []
+            last_pos = 0
+            for match in emoji_pattern.finditer(segment):
+                start, end = match.span()
+                if last_pos < start:
+                    parts.append(f'<font face="DejaVuSans">{segment[last_pos:start]}</font>')
+                parts.append(replace_emoji(match))
+                last_pos = end
+            if last_pos < len(segment):
+                parts.append(f'<font face="DejaVuSans">{segment[last_pos:]}</font>')
+            result.append(''.join(parts))
+    
+    return ''.join(result)
+
+def markdown_to_pdf_content(markdown_text, add_space_before_numbered, headings_to_fonts):
+    lines = markdown_text.strip().split('\n')
+    pdf_content = []
+    number_pattern = re.compile(r'^\d+(\.\d+)*\.\s')
+    heading_pattern = re.compile(r'^(#{1,4})\s+(.+)$')
+    first_numbered_seen = False
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        if headings_to_fonts and line.startswith('#'):
+            heading_match = heading_pattern.match(line)
+            if heading_match:
+                level = len(heading_match.group(1))
+                heading_text = heading_match.group(2).strip()
+                formatted_heading = f"<h{level}>{heading_text}</h{level}>"
+                pdf_content.append(formatted_heading)
+                continue
+                
+        is_numbered_line = number_pattern.match(line) is not None
+        
+        if add_space_before_numbered and is_numbered_line:
+            if first_numbered_seen and not line.startswith("1."):
+                pdf_content.append("")
+            if not first_numbered_seen:
+                first_numbered_seen = True
+        
+        line = detect_and_convert_links(line)
+        
+        # Preserve bold and emphasis formatting
+        line = re.sub(r'\*\*(.+?)\*\*', r'<b>\1</b>', line)
+        line = re.sub(r'\*([^*]+?)\*', r'<b>\1</b>', line)
+                
+        pdf_content.append(line)
+    total_lines = len(pdf_content)
+    return pdf_content, total_lines
+
+def create_pdf(markdown_text, base_font_size, num_columns, add_space_before_numbered, headings_to_fonts, doc_title, longest_line_words, total_lines):
+    if not markdown_text.strip():
+        return None  # Handle empty markdown gracefully
+    buffer = io.BytesIO()
+    page_width = A4[0] * 2
+    page_height = A4[1]
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=(page_width, page_height),
+        leftMargin=36,
+        rightMargin=36,
+        topMargin=36,
+        bottomMargin=36,
+        title=doc_title
+    )
+    styles = getSampleStyleSheet()
+    spacer_height = 10
+    pdf_content, total_lines = markdown_to_pdf_content(markdown_text, add_space_before_numbered, headings_to_fonts)
+    try:
+        available_font_files = glob.glob("*.ttf")
+        if not available_font_files:
+            st.error("No .ttf font files found.")
+            return None
+        selected_font_path = next((f for f in available_font_files if "NotoEmoji-Bold" in f), None)
+        if selected_font_path:
+            pdfmetrics.registerFont(TTFont("NotoEmoji-Bold", selected_font_path))
+        pdfmetrics.registerFont(TTFont("DejaVuSans", "DejaVuSans.ttf"))
+    except Exception as e:
+        st.error(f"Font registration error: {e}")
+        return None
+    total_chars = sum(len(line) for line in pdf_content)
+    hierarchy_weight = sum(1.5 if line.startswith("<b>") else 1 for line in pdf_content)
+    content_density = total_lines * hierarchy_weight + total_chars / 50
+    usable_height = page_height - 72 - spacer_height
+    usable_width = page_width - 72
+    avg_line_chars = total_chars / total_lines if total_lines > 0 else 50
+    ideal_lines_per_col = 20
+    suggested_columns = max(2, min(4, int(total_lines / ideal_lines_per_col) + 1))
+    num_columns = num_columns if num_columns != 0 else suggested_columns
+    col_width = usable_width / num_columns
+    min_font_size = 5  # Reduced to allow tighter fit
+    max_font_size = 16
+    lines_per_col = total_lines / num_columns if num_columns > 0 else total_lines
+    target_height_per_line = usable_height / lines_per_col if lines_per_col > 0 else usable_height
+    estimated_font_size = int(target_height_per_line / 1.5)
+    adjusted_font_size = max(min_font_size, min(max_font_size, estimated_font_size))
+    if avg_line_chars > col_width / adjusted_font_size * 10:
+        adjusted_font_size = int(col_width / (avg_line_chars / 10))
+        adjusted_font_size = max(min_font_size, adjusted_font_size)
+    
+    # Enhanced font size scaling for one-page fit
+    if longest_line_words > 17 or lines_per_col > 20:
+        font_scale = min(17 / max(longest_line_words, 17), 60 / max(lines_per_col, 20))
+        adjusted_font_size = max(min_font_size, int(base_font_size * font_scale))
+    
+    item_style = ParagraphStyle(
+        'ItemStyle', parent=styles['Normal'], fontName="DejaVuSans",
+        fontSize=adjusted_font_size, leading=adjusted_font_size * 1.15, spaceAfter=1,
+        linkUnderline=True
+    )
+    numbered_bold_style = ParagraphStyle(
+        'NumberedBoldStyle', parent=styles['Normal'], fontName="NotoEmoji-Bold",
+        fontSize=adjusted_font_size, leading=adjusted_font_size * 1.15, spaceAfter=1,
+        linkUnderline=True
+    )
+    section_style = ParagraphStyle(
+        'SectionStyle', parent=styles['Heading2'], fontName="DejaVuSans",
+        textColor=colors.darkblue, fontSize=adjusted_font_size * 1.1, leading=adjusted_font_size * 1.32, spaceAfter=2,
+        linkUnderline=True
+    )
+    columns = [[] for _ in range(num_columns)]
+    lines_per_column = total_lines / num_columns if num_columns > 0 else total_lines
+    current_line_count = 0
+    current_column = 0
+    number_pattern = re.compile(r'^\d+(\.\d+)*\.\s')
+    for item in pdf_content:
+        if current_line_count >= lines_per_column and current_column < num_columns - 1:
+            current_column += 1
+            current_line_count = 0
+        columns[current_column].append(item)
+        current_line_count += 1
+    column_cells = [[] for _ in range(num_columns)]
+    for col_idx, column in enumerate(columns):
+        for item in column:
+            if isinstance(item, str):
+                heading_match = re.match(r'<h(\d)>(.*?)</h\1>', item) if headings_to_fonts else None
+                if heading_match:
+                    level = int(heading_match.group(1))
+                    heading_text = heading_match.group(2)
+                    heading_style = ParagraphStyle(
+                        f'Heading{level}Style', 
+                        parent=styles['Heading1'],
+                        fontName="DejaVuSans",
+                        textColor=colors.darkblue if level == 1 else (colors.black if level > 2 else colors.blue),
+                        fontSize=adjusted_font_size * (1.6 - (level-1)*0.15),
+                        leading=adjusted_font_size * (1.8 - (level-1)*0.15),
+                        spaceAfter=4 - (level-1),
+                        spaceBefore=6 - (level-1),
+                        linkUnderline=True
+                    )
+                    column_cells[col_idx].append(Paragraph(apply_emoji_font(heading_text, "NotoEmoji-Bold"), heading_style))
+                elif item.startswith("<b>") and item.endswith("</b>"):
+                    content = item[3:-4].strip()
+                    if number_pattern.match(content):
+                        column_cells[col_idx].append(Paragraph(apply_emoji_font(content, "NotoEmoji-Bold"), numbered_bold_style))
+                    else:
+                        column_cells[col_idx].append(Paragraph(apply_emoji_font(content, "NotoEmoji-Bold"), section_style))
+                else:
+                    column_cells[col_idx].append(Paragraph(apply_emoji_font(item, "NotoEmoji-Bold"), item_style))
+            else:
+                column_cells[col_idx].append(Paragraph(apply_emoji_font(str(item), "NotoEmoji-Bold"), item_style))
+    max_cells = max(len(cells) for cells in column_cells) if column_cells else 0
+    for cells in column_cells:
+        cells.extend([Paragraph("", item_style)] * (max_cells - len(cells)))
+    table_data = list(zip(*column_cells)) if column_cells else [[]]
+    table = Table(table_data, colWidths=[col_width] * num_columns, hAlign='CENTER')
+    table.setStyle(TableStyle([
+        ('VALIGN', (0, 0), (-1, -1), 'TOP'),
+        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('BACKGROUND', (0, 0), (-1, -1), colors.white),
+        ('GRID', (0, 0), (-1, -1), 0, colors.white),
+        ('LINEAFTER', (0, 0), (num_columns-1, -1), 0.5, colors.grey),
+        ('LEFTPADDING', (0, 0), (-1, -1), 2),
+        ('RIGHTPADDING', (0, 0), (-1, -1), 2),
+        ('TOPPADDING', (0, 0), (-1, -1), 1),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 1),
+    ]))
+    story = [Spacer(1, spacer_height), table]
+    doc.build(story)
+    buffer.seek(0)
+    return buffer.getvalue()
+
+def pdf_to_image(pdf_bytes):
+    if pdf_bytes is None:
+        return None
+    try:
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+        images = []
+        for page in doc:
+            pix = page.get_pixmap(matrix=fitz.Matrix(2.0, 2.0))
+            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+            images.append(img)
+        doc.close()
+        return images
+    except Exception as e:
+        st.error(f"Failed to render PDF preview: {e}")
+        return None
+
+# PDF creation and linking functions
+WORDS_12 = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve"]
+WORDS_24 = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
+            "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen", "twenty",
+            "twenty-one", "twenty-two", "twenty-three", "twenty-four"]
+
+def create_crossfile_pdfs(source_pdf="TestSource.pdf", target_pdf="TestTarget.pdf"):
+    """Create two PDFs with cross-file linking."""
+    def create_base_pdf(filename):
+        buffer = io.BytesIO()
+        c = canvas.Canvas(buffer)
+        c.setFont("Helvetica", 12)
+        for i, word in enumerate(WORDS_12, 1):
+            y = 800 - (i * 20)
+            c.drawString(50, y, f"{i}. {word}")
+        c.showPage()
+        c.save()
+        buffer.seek(0)
+        with open(filename, "wb") as f:
+            f.write(buffer.getvalue())
+        buffer.close()
+
+    def add_bookmark_to_seven(pdf_file):
+        reader = PdfReader(pdf_file)
+        writer = PdfWriter()
+        for page in reader.pages:
+            writer.add_page(page)
+        page = writer.pages[0]
+        y_position = 800 - (7 * 20)
+        fit = Fit(fit_type="/XYZ", fit_args=[50, y_position, 0])
+        writer.add_outline_item("Seven Bookmark", 0, fit=fit)
+        with open(pdf_file, "wb") as f:
+            writer.write(f)
+
+    def modify_source_pdf(source, target):
+        reader = PdfReader(source)
+        writer = PdfWriter()
+        for page in reader.pages:
+            writer.add_page(page)
+        buffer = io.BytesIO()
+        c = canvas.Canvas(buffer)
+        c.setFont("Helvetica", 8)
+        seven_y = 800 - (7 * 20)
+        c.drawString(90, seven_y - 5, "link")
+        c.showPage()
+        c.save()
+        buffer.seek(0)
+        text_pdf = PdfReader(buffer)
+        page = writer.pages[0]
+        page.merge_page(text_pdf.pages[0])
+        link = Link(
+            rect=(90, seven_y - 10, 150, seven_y + 10),
+            url=f"file://{os.path.abspath(target)}#page=1"
+        )
+        writer.add_annotation(page_number=0, annotation=link)
+        with open(source, "wb") as f:
+            writer.write(f)
+        buffer.close()
+
+    def add_internal_link(pdf_file):
+        reader = PdfReader(pdf_file)
+        writer = PdfWriter()
+        for page in reader.pages:
+            writer.add_page(page)
+        one_y = 800 - (1 * 20)
+        ten_y = 800 - (10 * 20)
+        link = Link(
+            rect=(50, one_y - 10, 100, one_y + 10),
+            target_page_index=0,
+            fit=Fit(fit_type="/XYZ", fit_args=[50, ten_y, 0])
+        )
+        writer.add_annotation(page_number=0, annotation=link)
+        with open(pdf_file, "wb") as f:
+            writer.write(f)
+
+    create_base_pdf(source_pdf)
+    create_base_pdf(target_pdf)
+    add_bookmark_to_seven(target_pdf)
+    modify_source_pdf(source, target)
+    add_internal_link(source_pdf)
+    add_internal_link(target_pdf)
+    return source_pdf, target_pdf
+
+def create_selflinking_pdf(pdf_file="SelfLinking.pdf"):
+    """Create a PDF with a TOC on page 1 linking to a 1-24 list starting on page 2."""
+    buffer = io.BytesIO()
+    c = canvas.Canvas(buffer)
+    
+    # Page 1: Table of Contents
+    c.setFont("Helvetica", 14)
+    c.drawString(50, 800, "Table of Contents")
+    c.setFont("Helvetica", 12)
+    toc_y_positions = []
+    for i, word in enumerate(WORDS_12, 1):
+        y = 760 - (i * 20)
+        c.drawString(50, y, f"{word}")
+        toc_y_positions.append(y)
+    c.showPage()
+    
+    # Page 2: Numbered list 1-24
+    c.setFont("Helvetica", 12)
+    list_y_positions = []
+    for i, word in enumerate(WORDS_24, 1):
+        y = 800 - (i * 20)
+        c.drawString(50, y, f"{i}. {word}")
+        list_y_positions.append(y)
+    c.showPage()
+    
+    # Save the initial PDF
+    c.save()
+    buffer.seek(0)
+    with open(pdf_file, "wb") as f:
+        f.write(buffer.getvalue())
+    buffer.close()
+
+    # Add outlines and links
+    reader = PdfReader(pdf_file)
+    writer = PdfWriter()
+    for page in reader.pages:
+        writer.add_page(page)
+
+    # Add outline entries
+    toc_page = writer.pages[0]
+    list_page = writer.pages[1]
+    writer.add_outline_item("Table of Contents", 0, fit=Fit(fit_type="/Fit"))
+    for i, word in enumerate(WORDS_12, 1):
+        y = list_y_positions[i-1]
+        writer.add_outline_item(word, 1, fit=Fit(fit_type="/XYZ", fit_args=[50, y, 0]))
+
+    # Add TOC links from page 1 to page 2
+    for i, word in enumerate(WORDS_12):
+        toc_y = toc_y_positions[i]
+        list_y = list_y_positions[i]
+        link = Link(
+            rect=(50, toc_y - 10, 150, toc_y + 10),
+            target_page_index=1,
+            fit=Fit(fit_type="/XYZ", fit_args=[50, list_y, 0])
+        )
+        writer.add_annotation(page_number=0, annotation=link)
+
+    # Save the modified PDF
+    with open(pdf_file, "wb") as f:
+        writer.write(f)
+
+    return pdf_file
+
+# Streamlit UI
+md_files = [f for f in glob.glob("*.md") if os.path.basename(f) != "README.md"]
+md_options = [os.path.splitext(os.path.basename(f))[0] for f in md_files]
+
+with st.sidebar:
+    st.markdown("### 📄 PDF Options")
+    if md_options:
+        selected_md = st.selectbox("Select Markdown File", options=md_options, index=0)
+        with open(f"{selected_md}.md", "r", encoding="utf-8") as f:
+            st.session_state.markdown_content = f.read()
+    else:
+        st.warning("No markdown file found. Please add one to your folder.")
+        selected_md = None
+        st.session_state.markdown_content = ""
+    
+    available_font_files = {os.path.splitext(os.path.basename(f))[0]: f for f in glob.glob("*.ttf")}
+    selected_font_name = st.selectbox(
+        "Select Emoji Font",
+        options=list(available_font_files.keys()),
+        index=list(available_font_files.keys()).index("NotoEmoji-Bold") if "NotoEmoji-Bold" in available_font_files else 0
+    )
+    base_font_size = st.slider("Font Size (points)", min_value=6, max_value=16, value=8, step=1)
+    
+    add_space_before_numbered = st.checkbox("Add Space Ahead of Numbered Lines", value=True)
+    headings_to_fonts = st.checkbox(
+        "Headings to Fonts",
+        value=True,
+        help="Convert Markdown headings (# Heading) to styled fonts"
+    )
+    auto_columns = st.checkbox("AutoColumns", value=True)
+    
+    # Calculate document stats
+    longest_line_words = 0
+    total_lines = 0
+    adjusted_font_size_display = base_font_size
+    if 'markdown_content' in st.session_state and st.session_state.markdown_content.strip():
+        current_markdown = st.session_state.markdown_content
+        lines = current_markdown.strip().split('\n')
+        total_lines = len([line for line in lines if line.strip()])
+        for line in lines:
+            if line.strip():
+                word_count = len(line.split())
+                longest_line_words = max(longest_line_words, word_count)
+        if auto_columns:
+            if longest_line_words > 38:
+                recommended_columns = 2
+            elif longest_line_words < 18 and total_lines < 20:
+                recommended_columns = 4
+            else:
+                recommended_columns = 3
+        else:
+            recommended_columns = 3
+        # Adjust font size for one-page fit
+        if longest_line_words > 17 or total_lines / max(num_columns, 1) > 20:
+            font_scale = min(17 / max(longest_line_words, 17), 60 / max(total_lines / max(num_columns, 1), 20))
+            adjusted_font_size_display = max(5, int(base_font_size * font_scale))
+        st.markdown("**Document Stats**")
+        st.write(f"- Longest Line: {longest_line_words} words")
+        st.write(f"- Total Lines: {total_lines}")
+        st.write(f"- Recommended Columns: {recommended_columns}")
+        st.write(f"- Adjusted Font Size: {adjusted_font_size_display} points")
+    else:
+        st.markdown("**Document Stats**")
+        st.write("- Longest Line: 0 words")
+        st.write("- Total Lines: 0")
+        st.write("- Recommended Columns: 3")
+        st.write(f"- Adjusted Font Size: {base_font_size} points")
+    
+    column_options = [2, 3, 4]
+    num_columns = st.selectbox(
+        "Number of Columns",
+        options=column_options,
+        index=column_options.index(recommended_columns) if recommended_columns in column_options else 0
+    )
+    st.info("Font size and columns adjust to fit one page.")
+    
+    st.markdown("### ✍️ Edit Markdown")
+    edited_markdown = st.text_area(
+        "Input Markdown",
+        value=st.session_state.markdown_content,
+        height=200,
+        key=f"markdown_{selected_md}_{selected_font_name}_{num_columns}"
+    )
+    
+    st.markdown("### 💾 Actions")
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("🔄 Update PDF"):
+            st.session_state.markdown_content = edited_markdown
+            if selected_md:
+                with open(f"{selected_md}.md", "w", encoding="utf-8") as f:
+                    f.write(edited_markdown)
+            st.rerun()
+    
+    with col2:
+        if st.button("✂️ Trim Emojis"):
+            trimmed_content = trim_emojis_except_numbered(edited_markdown)
+            st.session_state.markdown_content = trimmed_content
+            if selected_md:
+                with open(f"{selected_md}.md", "w", encoding="utf-8") as f:
+                    f.write(trimmed_content)
+            st.rerun()
+    
+    prefix = get_timestamp_prefix()
+    st.download_button(
+        label="💾 Save Markdown",
+        data=st.session_state.markdown_content,
+        file_name=f"{prefix} {selected_md}.md" if selected_md else f"{prefix} default.md",
+        mime="text/markdown"
+    )
+    
+    st.markdown("### 🔊 Text-to-Speech")
+    VOICES = ["en-US-AriaNeural", "en-US-JennyNeural", "en-GB-SoniaNeural", "en-US-GuyNeural", "en-US-AnaNeural"]
+    selected_voice = st.selectbox("Select Voice for TTS", options=VOICES, index=0)
+    if st.button("Generate Audio"):
+        cleaned_text = clean_for_speech(st.session_state.markdown_content)
+        audio_filename = f"{prefix} {selected_md} {selected_voice}.mp3" if selected_md else f"{prefix} default {selected_voice}.mp3"
+        audio_file = asyncio.run(generate_audio(cleaned_text, selected_voice, audio_filename))
+        st.audio(audio_file)
+        with open(audio_file, "rb") as f:
+            audio_bytes = f.read()
+        st.download_button(
+            label="💾 Save Audio",
+            data=audio_bytes,
+            file_name=audio_filename,
+            mime="audio/mpeg"
+        )
+    
+    if st.button("📑 Create CrossFile PDFs"):
+        with st.spinner("Creating cross-file linked PDFs..."):
+            source_pdf, target_pdf = create_crossfile_pdfs()
+            st.success(f"Created {source_pdf} and {target_pdf}")
+            for pdf_file in [source_pdf, target_pdf]:
+                with open(pdf_file, "rb") as f:
+                    st.download_button(
+                        label=f"💾 Download {pdf_file}",
+                        data=f.read(),
+                        file_name=pdf_file,
+                        mime="application/pdf"
+                    )
+    
+    if st.button("🧪 Create SelfLinking PDF"):
+        with st.spinner("Generating self-linking PDF with TOC..."):
+            pdf_file = create_selflinking_pdf()
+            st.success(f"Generated {pdf_file}")
+            with open(pdf_file, "rb") as f:
+                pdf_bytes = f.read()
+            images = pdf_to_image(pdf_bytes)
+            if images:
+                st.subheader(f"Preview of {pdf_file}")
+                for i, img in enumerate(images):
+                    st.image(img, caption=f"{pdf_file} Page {i+1}", use_container_width=True)
+            with open(pdf_file, "rb") as f:
+                st.download_button(
+                    label=f"💾 Download {pdf_file}",
+                    data=f.read(),
+                    file_name=pdf_file,
+                    mime="application/pdf"
+                )
+
+with st.spinner("Generating PDF..."):
+    pdf_bytes = create_pdf(
+        st.session_state.markdown_content,
+        base_font_size,
+        num_columns,
+        add_space_before_numbered,
+        headings_to_fonts,
+        doc_title=selected_md if selected_md else "Untitled",
+        longest_line_words=longest_line_words,
+        total_lines=total_lines
+    )
+
+with st.container():
+    st.markdown("### 📊 PDF Preview")
+    pdf_images = pdf_to_image(pdf_bytes)
+    if pdf_images:
+        for img in pdf_images:
+            st.image(img, use_container_width=True)
+    else:
+        st.info("Download the PDF to view it locally.")
+
+with st.sidebar:
+    st.download_button(
+        label="💾 Save PDF",
+        data=pdf_bytes if pdf_bytes else "",
+        file_name=f"{prefix} {selected_md}.pdf" if selected_md else f"{prefix} output.pdf",
+        mime="application/pdf",
+        disabled=pdf_bytes is None
+    )