responds-forms 0.4__py3-none-any.whl

pyflutter_ui/__init__.py

@@ -0,0 +1,30 @@
+from pyflutter_ui.ui import (
+    BaseMaterialApp, BuildContext, ChangeNotifier, CommandNotifier,
+    Consumer, Element, FlutterWidget, ConsumerState, LayoutData,
+    Navigator, Provider, StatefulWidget, StatelessWidget, State,
+    ValueNotifier, ValueListenableBuilder, Provider, AlignElement,
+    Align, AppBar, BottomNavigationBar, Center, Card, Checkbox,
+    CircularProgress, Container, Divider, Drawer, Column, Row,
+    DropdownButton, ElevatedButton, Flexible, Expanded,
+    FloatingActionButton, Icon, IconButton, LinearProgress, Provider,
+    Padding, Image, ListBuilder, MainAxisAlignment, CrossAxisAlignment,
+    TableView, TkMaterialApp, Scaffold, Text, SizedBox, Alignment,
+    ScrollView,
+)
+
+from .theme import (
+    ColorScheme, CardTheme, InputDecorationTheme, TextStyle,
+    Theme, ThemeData, ThemeMode, ThemeProvider, TextTheme,
+    make_themed_app,
+)
+
+from .file_picker import (
+    FilePickerController, FilePickerResult, FilePickerType, PlatformFile,
+)
+
+from pyflutter_ui.ui.list_builder import (
+    ScrollableColumn, ScrollableColumnElement, ScrollableColumnOrProgress
+)
+
+from .navigator import NavigatorApp, PageRoute, Route
+from .app import run_app, SnackBar, SnackBarType

pyflutter_ui/app.py

@@ -0,0 +1,289 @@
+# app.py
+from __future__ import annotations
+from enum import Enum, auto
+from tkinter import Tk
+import tkinter as tk
+from typing import Callable, Optional
+from pyflutter_ui.ui import BuildContext, TkMaterialApp, Expanded
+from pyflutter_ui.theme import ThemeData, ThemeMode, ThemeProvider,ColorScheme
+
+
+# ============================================================
+# SNACKBAR
+# ============================================================
+
+class SnackBarType(Enum):
+    INFO    = auto()
+    SUCCESS = auto()
+    WARNING = auto()
+    ERROR   = auto()
+
+
+class SnackBar:
+    """
+    Exibe uma mensagem temporária na parte inferior da janela,
+    similar ao SnackBar do Flutter.
+
+    Uso via contexto (recomendado):
+        SnackBar.of(context).show("Arquivo salvo!", type=SnackBarType.SUCCESS)
+
+    Uso direto com root Tk:
+        SnackBar.show_on(root, "Erro ao carregar", type=SnackBarType.ERROR)
+    """
+
+    # cores por tipo — funcionam tanto em tema claro quanto escuro
+    _COLORS = {
+        SnackBarType.INFO:    {"bg": "#323232", "fg": "#FFFFFF", "accent": "#90CAF9"},
+        SnackBarType.SUCCESS: {"bg": "#1B5E20", "fg": "#FFFFFF", "accent": "#A5D6A7"},
+        SnackBarType.WARNING: {"bg": "#E65100", "fg": "#FFFFFF", "accent": "#FFE082"},
+        SnackBarType.ERROR:   {"bg": "#B71C1C", "fg": "#FFFFFF", "accent": "#EF9A9A"},
+    }
+
+    _ICONS = {
+        SnackBarType.INFO:    "ℹ",
+        SnackBarType.SUCCESS: "✓",
+        SnackBarType.WARNING: "⚠",
+        SnackBarType.ERROR:   "✕",
+    }
+
+    def __init__(self, root: tk.Tk) -> None:
+        self._root = root
+        self._current: Optional[tk.Toplevel] = None
+        self._after_id: Optional[str] = None
+
+    @classmethod
+    def of(cls, context: BuildContext) -> SnackBar:
+        """Obtém o SnackBar a partir de um BuildContext."""
+        root = context.app.root
+        # reutiliza instância já anexada ao root
+        if not hasattr(root, "_snackbar"):
+            root._snackbar = cls(root)
+        return root._snackbar
+
+    @classmethod
+    def show_on(
+        cls,
+        root: tk.Tk,
+        message: str,
+        *,
+        type: SnackBarType = SnackBarType.INFO,
+        duration: int = 3000,
+        action_label: Optional[str] = None,
+        on_action: Optional[Callable[[], None]] = None,
+    ) -> None:
+        """Atalho estático: não precisa instanciar."""
+        if not hasattr(root, "_snackbar"):
+            root._snackbar = cls(root)
+        root._snackbar.show(
+            message,
+            type=type,
+            duration=duration,
+            action_label=action_label,
+            on_action=on_action,
+        )
+
+    def show(
+        self,
+        message: str,
+        *,
+        type: SnackBarType = SnackBarType.INFO,
+        duration: int = 3000,
+        action_label: Optional[str] = None,
+        on_action: Optional[Callable[[], None]] = None,
+    ) -> None:
+        """Exibe o SnackBar. Descarta o anterior se ainda estiver visível."""
+        self._dismiss()
+
+        colors = self._COLORS[type]
+        icon   = self._ICONS[type]
+
+        # ── janela sem borda flutuando sobre o root ──────────
+        popup = tk.Toplevel(self._root)
+        popup.title("Aviso")
+        popup.geometry('400x50')
+        popup.overrideredirect(True)   # sem barra de título
+        popup.attributes("-topmost", True)
+        popup.configure(bg=colors["bg"])
+
+        self._current = popup
+
+        # ── frame interno com padding ─────────────────────────
+        frame = tk.Frame(popup, bg=colors["bg"], padx=12, pady=10)
+        frame.pack(fill="both", expand=True)
+
+        # ícone
+        tk.Label(
+            frame,
+            text=icon,
+            bg=colors["bg"],
+            fg=colors["accent"],
+            font=("Helvetica", 14, "bold"),
+        ).pack(side="left", padx=(0, 8))
+
+        # mensagem
+        tk.Label(
+            frame,
+            text=message,
+            bg=colors["bg"],
+            fg=colors["fg"],
+            font=("Helvetica", 10),
+            wraplength=360,
+            justify="left",
+            anchor="w",
+        ).pack(side="left", fill="x", expand=True)
+
+        # botão de ação opcional (ex.: "DESFAZER")
+        if action_label and on_action:
+            def _action():
+                on_action()
+                self._dismiss()
+
+            tk.Button(
+                frame,
+                text=action_label.upper(),
+                bg=colors["bg"],
+                fg=colors["accent"],
+                font=("Helvetica", 9, "bold"),
+                relief="flat",
+                cursor="hand2",
+                bd=0,
+                highlightthickness=0,
+                command=_action,
+            ).pack(side="right", padx=(12, 0))
+
+        # botão X para fechar manualmente
+        tk.Button(
+            frame,
+            text="✕",
+            bg=colors["bg"],
+            fg=colors["fg"],
+            font=("Helvetica", 8),
+            relief="flat",
+            cursor="hand2",
+            bd=0,
+            highlightthickness=0,
+            command=self._dismiss,
+        ).pack(side="right", padx=(8, 0))
+
+        # ── posicionamento: canto inferior esquerdo do root ──
+        popup.update_idletasks()
+        self._reposition(popup)
+
+        # reposiciona se o root for movido ou redimensionado
+        self._root.bind("<Configure>", lambda e: self._reposition(popup), add="+")
+
+        # ── animação de entrada (slide up) ───────────────────
+        self._animate_in(popup)
+
+        # ── auto-dismiss ──────────────────────────────────────
+        if duration > 0:
+            self._after_id = self._root.after(duration, self._dismiss)
+
+    def _reposition(self, popup: tk.Toplevel) -> None:
+        if popup is None or not popup.winfo_exists():
+            return
+
+        root = self._root
+        rx = root.winfo_x()
+        ry = root.winfo_y()
+        rw = root.winfo_width()
+        rh = root.winfo_height()
+
+        pw = popup.winfo_width()
+        ph = popup.winfo_height()
+
+        margin = 16
+        x = rx + margin
+        y = ry + rh - ph - margin
+
+        popup.geometry(f"+{x}+{y}")
+
+    def _animate_in(self, popup: tk.Toplevel, steps: int = 8) -> None:
+        """Desliza o popup de baixo para cima em `steps` passos."""
+        if not popup.winfo_exists():
+            return
+
+        root = self._root
+        rh   = root.winfo_height()
+        ry   = root.winfo_y()
+        ph   = popup.winfo_reqheight()
+        margin = 16
+
+        target_y = ry + rh - ph - margin
+        start_y  = ry + rh  # começa fora da janela
+
+        def _step(current_y: int, step: int) -> None:
+            if not popup.winfo_exists():
+                return
+            if step >= steps:
+                popup.geometry(f"+{popup.winfo_x()}+{target_y}")
+                return
+            new_y = current_y + (target_y - current_y) // 2
+            popup.geometry(f"+{popup.winfo_x()}+{new_y}")
+            popup.after(16, lambda: _step(new_y, step + 1))
+
+        popup.geometry(f"+{popup.winfo_x()}+{start_y}")
+        _step(start_y, 0)
+
+    def _dismiss(self) -> None:
+        if self._after_id:
+            self._root.after_cancel(self._after_id)
+            self._after_id = None
+
+        if self._current and self._current.winfo_exists():
+            self._animate_out(self._current)
+        self._current = None
+
+    def _animate_out(self, popup: tk.Toplevel, steps: int = 6) -> None:
+        """Desliza o popup para baixo antes de destruir."""
+        if not popup.winfo_exists():
+            return
+
+        root   = self._root
+        rh     = root.winfo_height()
+        ry     = root.winfo_y()
+        target = ry + rh + 10  # fora da janela
+
+        def _step(current_y: int, step: int) -> None:
+            if not popup.winfo_exists():
+                return
+            if step >= steps:
+                popup.destroy()
+                return
+            new_y = current_y + (target - current_y) // 2 + 2
+            popup.geometry(f"+{popup.winfo_x()}+{new_y}")
+            popup.after(16, lambda: _step(new_y, step + 1))
+
+        _step(popup.winfo_y(), 0)
+
+
+def create_theme_provider(mode: ThemeMode = ThemeMode.DARK) -> ThemeProvider:
+    
+    return ThemeProvider(
+        light_theme=ThemeData.light(color_scheme=ColorScheme.light()),
+        dark_theme=ThemeData.dark(color_scheme=ColorScheme.dark()),
+        mode=ThemeMode.DARK,
+    )
+    
+    
+def include_theme_app(app: TkMaterialApp) -> TkMaterialApp:
+    
+    if app.root is None:
+        app.root = Tk()
+    
+    try:
+        notifier: ThemeProvider = app.read_state(ThemeProvider)
+        if notifier is not None:
+            notifier.attach_root(app.root)
+    except Exception as e:
+        print(e)
+    
+    app.get_navigator().push(app.home)
+    return app
+        
+    
+def run_app(app: TkMaterialApp):
+    theme = create_theme_provider()
+    app.register_notifier(theme)
+    
+    include_theme_app(app).run()

pyflutter_ui/file_picker.py

@@ -0,0 +1,274 @@
+# file_picker.py
+# Implementação de FilePicker para PyFlutter no padrão do Flutter real.
+#
+# No Flutter, FilePicker não é um widget — é um controller/serviço que
+# expõe um método pickFiles() e notifica os listeners com o resultado.
+# Este arquivo replica essa arquitetura usando os primitivos do PyFlutter.
+#
+# ─────────────────────────────────────────────────────────────
+# USO BÁSICO
+# ─────────────────────────────────────────────────────────────
+#
+#   picker = FilePickerController(
+#       type=FilePickerType.image,          # filtro de tipo
+#       allow_multiple=True,                # seleção múltipla
+#   )
+#
+#   # Abrir o diálogo e aguardar o resultado:
+#   result: FilePickerResult | None = picker.pick_files()
+#   if result:
+#       for f in result.files:
+#           print(f.name, f.path, f.size)
+#
+#   # Ou de forma reativa (integrado ao build do widget):
+#   ValueListenableBuilder(
+#       notifier=picker.result_notifier,
+#       builder=lambda ctx, result: Text(
+#           result.files[0].name if result else "Nenhum arquivo"
+#       ),
+#   )
+# ─────────────────────────────────────────────────────────────
+
+from __future__ import annotations
+import os
+from dataclasses import dataclass, field
+from enum import Enum
+from tkinter import filedialog
+from typing import Optional
+from pyflutter_ui.ui.core import ValueNotifier
+
+
+# ============================================================
+# TIPOS DE ARQUIVO — espelha o FileType do flutter_file_picker
+# ============================================================
+
+class FilePickerType(Enum):
+    """Filtro de tipo de arquivo para o diálogo."""
+    any    = "any"    # sem filtro
+    image  = "image"  # png, jpg, jpeg, gif, bmp, webp, svg
+    pdf    = "pdf"    # pdf
+    spreadsheet = "spreadsheet"  # xlsx, xls, csv, ods
+    video  = "video"  # mp4, mov, avi, mkv, webm
+    audio  = "audio"  # mp3, wav, ogg, flac, aac
+    custom = "custom" # usa allowed_extensions fornecido pelo dev
+
+
+# Mapeamento interno: tipo → lista de extensões tk-compatíveis
+_TYPE_FILTERS: dict[FilePickerType, list[tuple[str, str]]] = {
+    FilePickerType.any: [("Todos os arquivos", "*.*")],
+    FilePickerType.image: [
+        ("Imagens", "*.png *.jpg *.jpeg *.gif *.bmp *.webp *.svg"),
+        ("Todos os arquivos", "*.*"),
+    ],
+    FilePickerType.pdf: [
+        ("PDF", "*.pdf"),
+        ("Todos os arquivos", "*.*"),
+    ],
+    FilePickerType.spreadsheet: [
+        ("Planilhas", "*.xlsx *.xls *.csv *.ods"),
+        ("Todos os arquivos", "*.*"),
+    ],
+    FilePickerType.video: [
+        ("Vídeos", "*.mp4 *.mov *.avi *.mkv *.webm"),
+        ("Todos os arquivos", "*.*"),
+    ],
+    FilePickerType.audio: [
+        ("Áudios", "*.mp3 *.wav *.ogg *.flac *.aac"),
+        ("Todos os arquivos", "*.*"),
+    ],
+}
+
+
+# ============================================================
+# MODELO DE RESULTADO — espelha PlatformFile do Flutter
+# ============================================================
+
+@dataclass(frozen=True)
+class PlatformFile:
+    """Representa um arquivo selecionado pelo usuário."""
+    path: str                        # caminho absoluto no disco
+    name: str = field(init=False)    # nome do arquivo (sem diretório)
+    extension: str = field(init=False)  # extensão sem ponto, ex: "pdf"
+    size: int = field(init=False)    # tamanho em bytes (0 se inacessível)
+
+    def __post_init__(self) -> None:
+        # dataclass frozen=True exige object.__setattr__ para init tardio
+        object.__setattr__(self, "name", os.path.basename(self.path))
+        ext = os.path.splitext(self.path)[1].lstrip(".")
+        object.__setattr__(self, "extension", ext.lower())
+        try:
+            object.__setattr__(self, "size", os.path.getsize(self.path))
+        except OSError:
+            object.__setattr__(self, "size", 0)
+
+    @property
+    def size_readable(self) -> str:
+        """Tamanho formatado (bytes / KB / MB / GB)."""
+        n = self.size
+        for unit in ("B", "KB", "MB", "GB"):
+            if n < 1024:
+                return f"{n:.1f} {unit}" if unit != "B" else f"{n} {unit}"
+            n /= 1024
+        return f"{n:.1f} TB"
+
+
+@dataclass(frozen=True)
+class FilePickerResult:
+    """Resultado de uma seleção de arquivos. Equivale a FilePickerResult do Flutter."""
+    files: list[PlatformFile]
+
+    @property
+    def paths(self) -> list[str]:
+        """Atalho: lista de caminhos absolutos."""
+        return [f.path for f in self.files]
+
+    @property
+    def names(self) -> list[str]:
+        """Atalho: lista de nomes de arquivo."""
+        return [f.name for f in self.files]
+
+    @property
+    def is_single(self) -> bool:
+        return len(self.files) == 1
+
+    def single(self) -> PlatformFile | None:
+        """Retorna o único arquivo ou None se houver 0 ou mais de 1."""
+        return self.files[0] if self.is_single else None
+
+
+# ============================================================
+# CONTROLLER — o equivalente ao FilePicker.platform do Flutter
+# ============================================================
+
+class FilePickerController:
+    """
+    Controller que encapsula a lógica de seleção de arquivos.
+
+    Não é um widget — vive no State do seu widget pai, exatamente
+    como FilePickerController no Flutter.
+
+    Parâmetros
+    ----------
+    type : FilePickerType
+        Filtro de tipo de arquivo. Use FilePickerType.custom junto com
+        allowed_extensions para filtros personalizados.
+    allow_multiple : bool
+        Se True, permite selecionar vários arquivos de uma vez.
+    allowed_extensions : list[str] | None
+        Usado apenas quando type=FilePickerType.custom.
+        Ex.: ["json", "toml", "yaml"]
+    dialog_title : str
+        Título da janela de diálogo do SO.
+    initial_directory : str | None
+        Diretório inicial do diálogo. Padrão: pasta home do usuário.
+    """
+
+    def __init__(
+                self,
+                type: FilePickerType = FilePickerType.any,
+                allow_multiple: bool = False,
+                allowed_extensions: Optional[list[str]] = None,
+                dialog_title: str = "Selecionar arquivo",
+                initial_directory: Optional[str] = None,
+            ) -> None:
+                
+        self.type = type
+        self.allow_multiple = allow_multiple
+        self.allowed_extensions = allowed_extensions
+        self.dialog_title = dialog_title
+        self.initial_directory = initial_directory #or os.path.expanduser("~")
+        
+        if self.initial_directory is None:
+            self.initial_directory = os.path.join(f"{os.path.expanduser("~")}", "Downloads")
+
+        # Expõe o resultado de forma reativa — use em ValueListenableBuilder
+        self.result_notifier: ValueNotifier[FilePickerResult | None] = ValueNotifier(None)
+
+    # ── API pública ───────────────────────────────────────────
+
+    def pick_files(self) -> FilePickerResult | None:
+        """
+        Abre o diálogo de seleção de arquivos do SO.
+
+        Retorna FilePickerResult se o usuário confirmou, None se cancelou.
+        Também atualiza result_notifier para notificar widgets ouvintes.
+        """
+        filters = self._resolve_filters()
+
+        if self.allow_multiple:
+            paths = filedialog.askopenfilenames(
+                title=self.dialog_title,
+                filetypes=filters,
+                initialdir=self.initial_directory,
+            )
+            raw = list(paths) if paths else []
+        else:
+            path = filedialog.askopenfilename(
+                title=self.dialog_title,
+                filetypes=filters,
+                initialdir=self.initial_directory,
+            )
+            raw = [path] if path else []
+
+        result = FilePickerResult(files=[PlatformFile(p) for p in raw]) if raw else None
+        if raw is not None:
+            first = raw[0] if len(raw) > 0 else None
+            if first is not None:
+                self.initial_directory = os.path.dirname(first)
+                print(f'{__class__.__name__} [INITIAL_DIR] ... {self.initial_directory}')
+        
+        self.result_notifier.value = result
+        return result
+
+    def pick_directory(self) -> str | None:
+        """
+        Abre o diálogo para selecionar uma pasta.
+
+        Retorna o caminho absoluto ou None se cancelado.
+        """
+        path = filedialog.askdirectory(
+            title=self.dialog_title,
+            initialdir=self.initial_directory,
+            mustexist=True,
+        )
+        return path or None
+
+    def save_file(
+        self,
+        suggested_name: str = "",
+    ) -> str | None:
+        """
+        Abre o diálogo "Salvar como".
+
+        Retorna o caminho escolhido ou None se cancelado.
+        """
+        filters = self._resolve_filters()
+        default_ext = (
+            "." + self.allowed_extensions[0]
+            if self.allowed_extensions
+            else ""
+        )
+        path = filedialog.asksaveasfilename(
+            title=self.dialog_title,
+            filetypes=filters,
+            initialdir=self.initial_directory,
+            initialfile=suggested_name,
+            defaultextension=default_ext,
+        )
+        return path or None
+
+    def clear_result(self) -> None:
+        """Limpa o resultado atual e notifica os ouvintes."""
+        self.result_notifier.value = None
+
+    # ── privado ───────────────────────────────────────────────
+
+    def _resolve_filters(self) -> list[tuple[str, str]]:
+        if self.type == FilePickerType.custom:
+            if not self.allowed_extensions:
+                return [("Todos os arquivos", "*.*")]
+            pattern = " ".join(f"*.{ext}" for ext in self.allowed_extensions)
+            label = ", ".join(self.allowed_extensions).upper()
+            return [(label, pattern), ("Todos os arquivos", "*.*")]
+        return _TYPE_FILTERS.get(self.type, [("Todos os arquivos", "*.*")])
+

pyflutter_ui/navigator.py

@@ -0,0 +1,93 @@
+# navigator.py
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Callable
+from pyflutter_ui.ui.core import (
+    BuildContext, Element, FlutterWidget,  BaseMaterialApp, Navigator
+)
+
+
+# ============================================================
+# NAVIGATOR
+# ============================================================
+class Route(ABC):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @abstractmethod
+    def build(self, context: BuildContext) -> FlutterWidget:
+        pass
+
+
+class PageRoute(Route):
+
+    def __init__(self, builder: Callable[
+        [BuildContext],
+        FlutterWidget
+    ]) -> None:
+        super().__init__()
+        self.builder = builder
+
+    def build(self, context: BuildContext) -> FlutterWidget:
+        return self.builder(context)
+
+
+class NavigatorApp(Navigator):
+
+    def __init__(self, app: BaseMaterialApp) -> None:
+        super().__init__(app)
+        self.stack: list[Element] = []
+
+    def push(self, page: FlutterWidget) -> None:
+        
+        if self.stack:
+            current = self.stack[-1]
+
+            if current.widget_tk is not None:
+                current.widget_tk.pack_forget()
+
+        element = page.create_element()
+        context = BuildContext(self.app, parent_widget=self.app.root)
+        element.mount(context)
+        self.stack.append(element)
+        self.current_element = element
+
+    def pop(self) -> None:
+
+        if len(self.stack) <= 1:
+            return
+
+        current = self.stack.pop()
+
+        current.unmount()
+
+        previous = self.stack[-1]
+
+        if previous.widget_tk is not None:
+            previous.widget_tk.pack(fill="both", expand=True)
+
+        self.current_element = previous
+
+    def replace(self, page: FlutterWidget) -> None:
+
+        if self.stack:
+            current = self.stack.pop()
+
+            current.unmount()
+
+        element = page.create_element()
+
+        context = BuildContext(
+            app=self.app,
+            parent_widget=self.app.root
+        )
+
+        element.mount(context)
+
+        self.stack.append(element)
+
+        self.current_element = element
+
+    def render(self) -> None:
+        pass