Merge pull request #1 from nelsonduarte/feature/converter-pdf

feat: adicionar ferramenta Converter (PDF para PNG/JPG/DOCX/TXT)

Author: nelsonduarte

app/tools/__init__.py

@@ -9,8 +9,10 @@
 from app.tools.marca_dagua import TabMarcaDagua
 from app.tools.info import TabInfo
 from app.tools.ocr import TabOCR
+from app.tools.converter import TabConverter
 
 __all__ = [
     "TabDividir", "TabJuntar", "TabRotar", "TabExtrair", "TabReordenar",
     "TabComprimir", "TabEncriptar", "TabMarcaDagua", "TabInfo", "TabOCR",
+    "TabConverter",
 ]

app/tools/converter.py

@@ -0,0 +1,263 @@
+"""PDFApps – TabConverter: converter PDF para imagens, DOCX ou TXT."""
+
+import os
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QGroupBox, QFormLayout, QComboBox, QLabel, QFileDialog,
+    QMessageBox, QApplication,
+)
+from pypdf import PdfReader
+
+from app.base import BasePage
+from app.utils import section, info_lbl, pick_folder
+from app.widgets import DropFileEdit
+
+
+class TabConverter(BasePage):
+    _DPI_VALUES = [72, 150, 300]
+
+    def __init__(self, status_fn):
+        super().__init__("fa5s.exchange-alt", "Converter PDF",
+                         "Converta PDF para imagens (PNG/JPG), Word (DOCX) ou texto simples (TXT).",
+                         "Converter", status_fn)
+        f = self._form
+
+        # -- Ficheiro de origem --
+        f.addWidget(section("Ficheiro de origem"))
+        self.drop_in = DropFileEdit()
+        self.drop_in.btn.clicked.disconnect()
+        self.drop_in.btn.clicked.connect(self._pick_input)
+        self.drop_in.path_changed.connect(self._load_input)
+        self.lbl_info = info_lbl()
+        f.addWidget(self.drop_in); f.addWidget(self.lbl_info)
+
+        # -- Formato de saída --
+        grp_fmt = QGroupBox("Formato de saída")
+        gf = QFormLayout(grp_fmt)
+        gf.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
+        self.cmb_format = QComboBox()
+        self.cmb_format.addItems([
+            "PNG (imagens)",
+            "JPG (imagens)",
+            "DOCX (Word)",
+            "TXT (texto simples)",
+        ])
+        self.cmb_format.currentIndexChanged.connect(self._on_format_changed)
+        gf.addRow("Formato:", self.cmb_format)
+        f.addWidget(grp_fmt)
+
+        # -- Opções de imagem (visível para PNG/JPG) --
+        self._grp_dpi = QGroupBox("Opções de imagem")
+        gd = QFormLayout(self._grp_dpi)
+        gd.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
+        self.cmb_dpi = QComboBox()
+        self.cmb_dpi.addItems([
+            "72 DPI (ecrã)",
+            "150 DPI (padrão)",
+            "300 DPI (qualidade de impressão)",
+        ])
+        self.cmb_dpi.setCurrentIndex(1)
+        gd.addRow("Resolução:", self.cmb_dpi)
+        f.addWidget(self._grp_dpi)
+
+        # -- Pasta de saída (imagens) --
+        f.addWidget(section("Pasta de saída"))
+        self._drop_folder = DropFileEdit(
+            placeholder="Pasta onde serão guardadas as imagens…")
+        self._drop_folder.btn.clicked.disconnect()
+        self._drop_folder.btn.clicked.connect(self._pick_folder)
+        f.addWidget(self._drop_folder)
+
+        # -- Ficheiro de saída (DOCX / TXT) --
+        self._section_file = section("Ficheiro de saída")
+        self._section_file.setVisible(False)
+        f.addWidget(self._section_file)
+        self._drop_file = DropFileEdit(save=True, default_name="convertido.docx")
+        self._drop_file.setVisible(False)
+        f.addWidget(self._drop_file)
+
+        self.lbl_result = QLabel("")
+        self.lbl_result.setStyleSheet(
+            "font-weight:600; font-size:11pt; color:#059669; "
+            "background:transparent; padding:10px 4px;")
+        f.addWidget(self.lbl_result)
+        f.addStretch()
+
+    # ── UI callbacks ──────────────────────────────────────────────────────
+
+    def _on_format_changed(self, index: int):
+        is_image = index <= 1
+        self._grp_dpi.setVisible(is_image)
+        self._drop_folder.setVisible(is_image)
+        for i in range(self._form.count()):
+            w = self._form.itemAt(i).widget()
+            if w is self._drop_folder:
+                prev = self._form.itemAt(i - 1).widget()
+                if prev:
+                    prev.setVisible(is_image)
+                break
+        self._section_file.setVisible(not is_image)
+        self._drop_file.setVisible(not is_image)
+        if not is_image:
+            ext = ".docx" if index == 2 else ".txt"
+            inp = self.drop_in.path()
+            if inp:
+                base = os.path.splitext(inp)[0]
+                self._drop_file.set_path(base + ext)
+
+    def _pick_input(self):
+        p, _ = QFileDialog.getOpenFileName(self, "Abrir PDF", "", "PDF (*.pdf)")
+        if p:
+            self._load_input(p)
+
+    def _load_input(self, p: str):
+        self.drop_in.blockSignals(True)
+        self.drop_in.set_path(p)
+        self.drop_in.blockSignals(False)
+        size = os.path.getsize(p)
+        try:
+            r = PdfReader(p)
+            self.lbl_info.setText(f"  {len(r.pages)} páginas  ·  {size / 1024:.1f} KB")
+        except Exception as e:
+            self.lbl_info.setText(f"  Erro: {e}")
+        base = os.path.splitext(p)[0]
+        if not self._drop_folder.path():
+            self._drop_folder.blockSignals(True)
+            self._drop_folder.set_path(os.path.dirname(p))
+            self._drop_folder.blockSignals(False)
+        fmt = self.cmb_format.currentIndex()
+        if fmt >= 2:
+            ext = ".docx" if fmt == 2 else ".txt"
+            self._drop_file.set_path(base + ext)
+
+    def _pick_folder(self):
+        d = pick_folder(self)
+        if d:
+            self._drop_folder.blockSignals(True)
+            self._drop_folder.set_path(d)
+            self._drop_folder.blockSignals(False)
+
+    def auto_load(self, path: str):
+        if path and not self.drop_in.path():
+            self._load_input(path)
+
+    # ── lógica de conversão ───────────────────────────────────────────────
+
+    def _run(self):
+        pdf_path = self.drop_in.path()
+        if not pdf_path or not os.path.isfile(pdf_path):
+            QMessageBox.warning(self, "Aviso", "Seleciona um PDF válido.")
+            return
+
+        fmt = self.cmb_format.currentIndex()
+        self.lbl_result.setText("")
+
+        if fmt <= 1:
+            self._convert_images(pdf_path, fmt)
+        elif fmt == 2:
+            self._convert_docx(pdf_path)
+        else:
+            self._convert_txt(pdf_path)
+
+    def _convert_images(self, pdf_path: str, fmt: int):
+        out_dir = self._drop_folder.path()
+        if not out_dir:
+            QMessageBox.warning(self, "Aviso", "Escolhe a pasta de saída.")
+            return
+        os.makedirs(out_dir, exist_ok=True)
+        ext = "png" if fmt == 0 else "jpg"
+        dpi = self._DPI_VALUES[self.cmb_dpi.currentIndex()]
+        self._status(f"A converter para {ext.upper()} a {dpi} DPI…")
+        QApplication.processEvents()
+        try:
+            import fitz
+            doc = fitz.open(pdf_path)
+            matrix = fitz.Matrix(dpi / 72, dpi / 72)
+            total = doc.page_count
+            for i, page in enumerate(doc):
+                pix = page.get_pixmap(matrix=matrix)
+                if pix.alpha:
+                    pix = fitz.Pixmap(pix, 0)
+                if pix.n == 4:
+                    pix = fitz.Pixmap(fitz.csRGB, pix)
+                out_file = os.path.join(out_dir, f"pagina_{i + 1:03d}.{ext}")
+                if ext == "png":
+                    pix.save(out_file)
+                else:
+                    try:
+                        from PIL import Image
+                        mode = "L" if pix.n == 1 else "RGB"
+                        img = Image.frombytes(mode, (pix.width, pix.height), pix.samples)
+                        img.save(out_file, "JPEG", quality=95)
+                    except ImportError:
+                        pix.save(out_file)
+                self._status(f"A converter… {i + 1}/{total}")
+                QApplication.processEvents()
+            doc.close()
+            self.lbl_result.setText(f"  {total} imagens guardadas em {out_dir}")
+            self._status(f"✔  {total} imagens exportadas")
+            QMessageBox.information(self, "Concluído",
+                                    f"{total} imagens guardadas em:\n{out_dir}")
+        except Exception as e:
+            QMessageBox.critical(self, "Erro", str(e))
+
+    def _convert_docx(self, pdf_path: str):
+        out_path = self._drop_file.path()
+        if not out_path:
+            QMessageBox.warning(self, "Aviso", "Escolhe o ficheiro de saída.")
+            return
+        self._status("A converter para DOCX…")
+        QApplication.processEvents()
+        try:
+            import fitz
+        except ImportError:
+            QMessageBox.critical(self, "Dependência em falta",
+                                 "Instala o PyMuPDF:\n  pip install pymupdf")
+            return
+        try:
+            from docx import Document
+        except ImportError:
+            QMessageBox.critical(self, "Dependência em falta",
+                                 "Instala o python-docx:\n  pip install python-docx")
+            return
+        try:
+            doc = fitz.open(pdf_path)
+            docx_doc = Document()
+            for i, page in enumerate(doc):
+                if i > 0:
+                    docx_doc.add_page_break()
+                text = page.get_text()
+                for paragraph in text.split('\n'):
+                    docx_doc.add_paragraph(paragraph)
+            docx_doc.save(out_path)
+            doc.close()
+            self.lbl_result.setText(f"  Guardado → {os.path.basename(out_path)}")
+            self._status(f"✔  DOCX guardado → {out_path}")
+            QMessageBox.information(self, "Concluído",
+                                    f"DOCX guardado em:\n{out_path}")
+        except Exception as e:
+            QMessageBox.critical(self, "Erro", str(e))
+
+    def _convert_txt(self, pdf_path: str):
+        out_path = self._drop_file.path()
+        if not out_path:
+            QMessageBox.warning(self, "Aviso", "Escolhe o ficheiro de saída.")
+            return
+        self._status("A converter para TXT…")
+        QApplication.processEvents()
+        try:
+            import fitz
+            doc = fitz.open(pdf_path)
+            with open(out_path, 'w', encoding='utf-8') as f:
+                for i, page in enumerate(doc):
+                    if i > 0:
+                        f.write(f'\n\n--- Página {i + 1} ---\n\n')
+                    f.write(page.get_text())
+            doc.close()
+            self.lbl_result.setText(f"  Guardado → {os.path.basename(out_path)}")
+            self._status(f"✔  TXT guardado → {out_path}")
+            QMessageBox.information(self, "Concluído",
+                                    f"TXT guardado em:\n{out_path}")
+        except Exception as e:
+            QMessageBox.critical(self, "Erro", str(e))

app/window.py

@@ -26,6 +26,7 @@
 from app.tools.encriptar import TabEncriptar
 from app.tools.marca_dagua import TabMarcaDagua
 from app.tools.ocr import TabOCR
+from app.tools.converter import TabConverter
 from app.editor.tab import TabEditar
 from app.tools.info import TabInfo
 
@@ -40,6 +41,7 @@
     ("Encriptar",       "fa5s.lock",                TabEncriptar),
     ("Marca d'água",    "fa5s.stamp",               TabMarcaDagua),
     ("OCR",             "fa5s.search",              TabOCR),
+    ("Converter",       "fa5s.exchange-alt",        TabConverter),
     ("Editar",          "fa5s.edit",                TabEditar),
     ("Informação",      "fa5s.info-circle",         TabInfo),
 ]

requirements.txt

@@ -4,4 +4,5 @@ qtawesome>=1.4.1
 pillow>=12.1.1
 pymupdf>=1.27.2
 pytesseract>=0.3.13
+python-docx>=1.2.0
 pyinstaller>=6.19.0