dex-framework 0.0.50__py3-none-any.whl

dex_framework/__init__.py

@@ -0,0 +1,22 @@
+"""
+DEx-Framework v3.0.0
+Biblioteca reutilizável que encapsula todos os componentes do Flet v0.84.0.
+
+Uso básico:
+    from dex_framework import DEx_ElevatedButton, DEx_TextField, DEx_Column
+"""
+
+from .layout import *
+from .navigation import *
+from .input import *
+from .buttons import *
+from .display import *
+from .feedback import *
+from .overlay import *
+from .media import *
+from .canvas import *
+from .maps import *
+from .charts import *
+from .scrolling import *
+from .interaction import *
+from .theming import *

dex_framework/buttons/DEx_ActionButtons.py

@@ -0,0 +1,212 @@
+"""DEx_ActionButtons — barra de botões de ação direita-para-esquerda."""
+
+from __future__ import annotations
+from typing import Callable
+import flet as ft
+from dex_framework.theming.DEx_BrandThemes import DEx_BrandTheme
+
+
+class DEx_ActionButton:
+    """
+    Define um botão individual para uso em DEx_ActionButtons.
+
+    Params
+    ------
+    icon        : ícone do botão (opcional se text fornecido; obrigatório se sem text)
+    text        : rótulo do botão (opcional)
+    tooltip     : dica de contexto
+    on_click    : callback de clique
+    disabled    : botão desabilitado
+    button_type : tipo pré-definido — "exit" | "theme" | "brightness" | "user"
+                  define ícone padrão e comportamento embutido quando page é fornecido
+
+    Ícones e comportamentos padrão por tipo
+    ----------------------------------------
+    exit       → ft.Icons.LOGOUT          — fecha a janela
+    theme      → ft.Icons.PALETTE         — cicla entre temas por nome de marca
+    brightness → ft.Icons.BRIGHTNESS_6    — alterna entre modo claro e escuro
+    user       → ft.Icons.ACCOUNT_CIRCLE  — nasce como readonly (disabled=True)
+    """
+
+    _DEFAULT_ICONS: dict = {
+        "exit":       ft.Icons.LOGOUT,
+        "theme":      ft.Icons.PALETTE,
+        "brightness": ft.Icons.BRIGHTNESS_6,
+        "user":       ft.Icons.ACCOUNT_CIRCLE,
+    }
+
+    def __init__(
+        self,
+        icon: ft.IconData | None = None,
+        text: str | None = None,
+        tooltip: str | None = None,
+        on_click: Callable | None = None,
+        disabled: bool = False,
+        visible: bool = True,
+        button_type: str | None = None,
+    ) -> None:
+        self.button_type = button_type
+        self.text = text
+        self.icon = icon if icon is not None else self._DEFAULT_ICONS.get(button_type)
+        self.tooltip = tooltip
+        self.on_click = on_click
+        self.visible = visible
+        # "user" nasce como readonly salvo on_click explícito
+        self.disabled = disabled or (button_type == "user" and on_click is None)
+
+
+class DEx_ActionButtons(ft.Container):
+    """
+    Barra de botões de ação alinhada à direita, com quebra automática de linha.
+
+    Os botões são apresentados da direita para a esquerda conforme a ordem de
+    criação: o primeiro botão da lista aparece mais à direita. Quando o total
+    de botões ultrapassa a largura disponível, uma segunda linha é criada com
+    o mesmo alinhamento.
+
+    O container_main (exposto publicamente) não é expansível — seu tamanho é
+    determinado pelo conteúdo.
+
+    Params
+    ------
+    buttons : lista de DEx_ActionButton
+    page    : referência à ft.Page (necessário para ações embutidas exit/theme)
+    dex_id, dex_theme, on_dex_ready : padrão DEx
+    """
+
+    # Ordem canônica de todas as marcas para o ciclo de temas
+    _ALL_BRANDS: list[str] = [
+        brand
+        for brands in DEx_BrandTheme.BRAND_GROUPS.values()
+        for brand in brands
+    ]
+
+    def __init__(
+        self,
+        buttons: list[DEx_ActionButton] | None = None,
+        page: ft.Page | None = None,
+        dex_id: str = "",
+        dex_theme: str = "dell",
+        on_dex_ready: Callable | None = None,
+        **kwargs,
+    ) -> None:
+        self.dex_id: str = dex_id
+        self.dex_theme: str = dex_theme
+        # Desembrulha _UCProxy (hub) para sempre guardar a ft.Page real.
+        # getattr(proxy, "_real", proxy) funciona porque _UCProxy armazena
+        # "_real" via super().__setattr__, logo __getattr__ não é chamado.
+        self._page = getattr(page, "_real", page) if page is not None else None
+        # -1 → primeira clicada vai sempre para índice 0 (bradesco, vermelho),
+        # garantindo contraste visual imediato independente do dex_theme inicial.
+        self._theme_idx: int = -1
+        self._theme_widget: ft.IconButton | None = None
+        self._brightness_widget: ft.IconButton | None = None
+
+        # Inverte a lista para que o 1º definido fique mais à direita
+        btn_list = list(buttons or [])
+        widgets = [self._build_widget(btn) for btn in reversed(btn_list)]
+
+        self.container_main = ft.Container(
+            content=ft.Row(
+                controls=widgets,
+                wrap=True,
+                alignment=ft.MainAxisAlignment.END,
+                tight=True,
+                spacing=4,
+                run_spacing=4,
+            ),
+            padding=ft.Padding.symmetric(horizontal=4, vertical=4),
+        )
+
+        super().__init__(content=self.container_main, **kwargs)
+
+        if on_dex_ready:
+            on_dex_ready(self)
+
+    # ── Resolução de clique ────────────────────────────────────────────
+
+    def _resolve_click(self, btn: DEx_ActionButton) -> Callable | None:
+        if btn.on_click:
+            return btn.on_click
+        if self._page is None:
+            return None
+        if btn.button_type == "exit":
+            return self._do_exit
+        if btn.button_type == "theme":
+            return self._next_theme
+        if btn.button_type == "brightness":
+            return self._toggle_brightness
+        return None
+
+    async def _do_exit(self, e) -> None:
+        if self._page:
+            await self._page.window.close()
+
+    def _toggle_brightness(self, e) -> None:
+        if self._page is None:
+            return
+        is_dark = self._page.theme_mode == ft.ThemeMode.DARK
+        self._page.theme_mode = ft.ThemeMode.LIGHT if is_dark else ft.ThemeMode.DARK
+        # Atualiza ícone e tooltip para refletir o novo estado
+        if self._brightness_widget is not None:
+            if self._page.theme_mode == ft.ThemeMode.DARK:
+                self._brightness_widget.icon = ft.Icons.BRIGHTNESS_2
+                self._brightness_widget.tooltip = "Modo escuro (clique para claro)"
+            else:
+                self._brightness_widget.icon = ft.Icons.BRIGHTNESS_HIGH
+                self._brightness_widget.tooltip = "Modo claro (clique para escuro)"
+            self._brightness_widget.update()
+        self._page.update()
+
+    def _next_theme(self, e) -> None:
+        self._theme_idx = (self._theme_idx + 1) % len(self._ALL_BRANDS)
+        brand = self._ALL_BRANDS[self._theme_idx]
+
+        # Atualiza tooltip com grupo e nome da marca
+        if self._theme_widget is not None:
+            group = next(
+                (g for g, brands in DEx_BrandTheme.BRAND_GROUPS.items() if brand in brands),
+                "",
+            )
+            group_label = DEx_BrandTheme.GROUP_META.get(group, {}).get("label", group)
+            brand_display = brand.replace("_", " ").title()
+            self._theme_widget.tooltip = f"{group_label} · {brand_display}"
+            self._theme_widget.update()
+
+        if self._page:
+            DEx_BrandTheme.apply(self._page, brand)
+
+    # ── Construção de widget por botão ─────────────────────────────────
+
+    def _build_widget(self, btn: DEx_ActionButton) -> ft.Control:
+        on_click = self._resolve_click(btn)
+
+        if btn.text:
+            if btn.icon:
+                content = ft.Row(
+                    [ft.Icon(btn.icon, size=16), ft.Text(btn.text, size=12)],
+                    spacing=4,
+                    tight=True,
+                )
+            else:
+                content = ft.Text(btn.text, size=12)
+            return ft.Button(
+                content=content,
+                tooltip=btn.tooltip,
+                on_click=on_click,
+                disabled=btn.disabled,
+            )
+
+        widget = ft.IconButton(
+            icon=btn.icon or ft.Icons.RADIO_BUTTON_UNCHECKED,
+            tooltip=btn.tooltip,
+            on_click=on_click,
+            disabled=btn.disabled,
+            visible=btn.visible,
+            icon_size=20,
+        )
+        if btn.button_type == "theme":
+            self._theme_widget = widget
+        if btn.button_type == "brightness":
+            self._brightness_widget = widget
+        return widget

dex_framework/buttons/DEx_CupertinoButton.py

@@ -0,0 +1,52 @@
+"""
+DEx_CupertinoButton — DEx-Framework v3.0.0
+Encapsula flet.CupertinoButton com padrões DEx.
+
+Uso básico:
+    from dex_framework.buttons import DEx_CupertinoButton
+    componente = DEx_CupertinoButton(...)
+"""
+
+from __future__ import annotations
+import flet as ft
+from typing import Any, Callable, Optional
+
+
+class DEx_CupertinoButton(ft.CupertinoButton):
+    """
+    Encapsulamento DEx do controle flet.CupertinoButton.
+
+    Mantém 100% da API original do Flet e adiciona:
+      - Valores padrão opinados (brand defaults)
+      - Parâmetro `dex_id` para rastreamento
+      - Hook `on_dex_ready` disparado após montagem
+
+    Args:
+        dex_id: Identificador único do componente na aplicação.
+        on_dex_ready: Callback chamado quando o componente é montado.
+        **kwargs: Todos os parâmetros nativos de flet.CupertinoButton.
+
+    Example:
+        >>> btn = DEx_CupertinoButton(
+        ...     dex_id="exemplo",
+        ... )
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        dex_id: str = "",
+        dex_theme: str = "dell",
+        on_dex_ready: Optional[Callable[["DEx_CupertinoButton"], None]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.dex_id: str = dex_id
+        self.dex_theme: str = dex_theme
+        self._on_dex_ready = on_dex_ready
+
+    def did_mount(self) -> None:
+        """Chamado pelo Flet quando o controle é inserido na árvore."""
+        super().did_mount()
+        if self._on_dex_ready:
+            self._on_dex_ready(self)

dex_framework/buttons/DEx_CupertinoFilledButton.py

@@ -0,0 +1,52 @@
+"""
+DEx_CupertinoFilledButton — DEx-Framework v3.0.0
+Encapsula flet.CupertinoFilledButton com padrões DEx.
+
+Uso básico:
+    from dex_framework.buttons import DEx_CupertinoFilledButton
+    componente = DEx_CupertinoFilledButton(...)
+"""
+
+from __future__ import annotations
+import flet as ft
+from typing import Any, Callable, Optional
+
+
+class DEx_CupertinoFilledButton(ft.CupertinoFilledButton):
+    """
+    Encapsulamento DEx do controle flet.CupertinoFilledButton.
+
+    Mantém 100% da API original do Flet e adiciona:
+      - Valores padrão opinados (brand defaults)
+      - Parâmetro `dex_id` para rastreamento
+      - Hook `on_dex_ready` disparado após montagem
+
+    Args:
+        dex_id: Identificador único do componente na aplicação.
+        on_dex_ready: Callback chamado quando o componente é montado.
+        **kwargs: Todos os parâmetros nativos de flet.CupertinoFilledButton.
+
+    Example:
+        >>> btn = DEx_CupertinoFilledButton(
+        ...     dex_id="exemplo",
+        ... )
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        dex_id: str = "",
+        dex_theme: str = "dell",
+        on_dex_ready: Optional[Callable[["DEx_CupertinoFilledButton"], None]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.dex_id: str = dex_id
+        self.dex_theme: str = dex_theme
+        self._on_dex_ready = on_dex_ready
+
+    def did_mount(self) -> None:
+        """Chamado pelo Flet quando o controle é inserido na árvore."""
+        super().did_mount()
+        if self._on_dex_ready:
+            self._on_dex_ready(self)

dex_framework/buttons/DEx_ElevatedButton.py

@@ -0,0 +1,57 @@
+"""
+DEx_ElevatedButton — DEx-Framework v3.0.0
+Encapsula flet.Button com padrões DEx.
+(flet.ElevatedButton foi depreciado no 0.80.0; base atualizada para ft.Button)
+
+Uso básico:
+    from dex_framework.buttons import DEx_ElevatedButton
+    componente = DEx_ElevatedButton(content="Salvar", dex_id="btn")
+"""
+
+from __future__ import annotations
+import flet as ft
+from typing import Any, Callable, Optional
+
+
+class DEx_ElevatedButton(ft.Button):
+    """
+    Encapsulamento DEx do controle flet.Button (substituto do ElevatedButton).
+
+    flet.ElevatedButton foi depreciado no 0.80.0. Esta classe herda de
+    ft.Button, mantendo o nome DEx_ElevatedButton para compatibilidade.
+
+    Mantém 100% da API original do Flet e adiciona:
+      - Valores padrão opinados (brand defaults)
+      - Parâmetro `dex_id` para rastreamento
+      - Hook `on_dex_ready` disparado após montagem
+
+    Args:
+        dex_id: Identificador único do componente na aplicação.
+        on_dex_ready: Callback chamado quando o componente é montado.
+        **kwargs: Todos os parâmetros nativos de flet.Button.
+
+    Example:
+        >>> btn = DEx_ElevatedButton(
+        ...     content="Salvar",
+        ...     dex_id="btn_salvar",
+        ... )
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        dex_id: str = "",
+        dex_theme: str = "dell",
+        on_dex_ready: Optional[Callable[["DEx_ElevatedButton"], None]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.dex_id: str = dex_id
+        self.dex_theme: str = dex_theme
+        self._on_dex_ready = on_dex_ready
+
+    def did_mount(self) -> None:
+        """Chamado pelo Flet quando o controle é inserido na árvore."""
+        super().did_mount()
+        if self._on_dex_ready:
+            self._on_dex_ready(self)

dex_framework/buttons/DEx_FilledButton.py

@@ -0,0 +1,52 @@
+"""
+DEx_FilledButton — DEx-Framework v3.0.0
+Encapsula flet.FilledButton com padrões DEx.
+
+Uso básico:
+    from dex_framework.buttons import DEx_FilledButton
+    componente = DEx_FilledButton(...)
+"""
+
+from __future__ import annotations
+import flet as ft
+from typing import Any, Callable, Optional
+
+
+class DEx_FilledButton(ft.FilledButton):
+    """
+    Encapsulamento DEx do controle flet.FilledButton.
+
+    Mantém 100% da API original do Flet e adiciona:
+      - Valores padrão opinados (brand defaults)
+      - Parâmetro `dex_id` para rastreamento
+      - Hook `on_dex_ready` disparado após montagem
+
+    Args:
+        dex_id: Identificador único do componente na aplicação.
+        on_dex_ready: Callback chamado quando o componente é montado.
+        **kwargs: Todos os parâmetros nativos de flet.FilledButton.
+
+    Example:
+        >>> btn = DEx_FilledButton(
+        ...     dex_id="exemplo",
+        ... )
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        dex_id: str = "",
+        dex_theme: str = "dell",
+        on_dex_ready: Optional[Callable[["DEx_FilledButton"], None]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.dex_id: str = dex_id
+        self.dex_theme: str = dex_theme
+        self._on_dex_ready = on_dex_ready
+
+    def did_mount(self) -> None:
+        """Chamado pelo Flet quando o controle é inserido na árvore."""
+        super().did_mount()
+        if self._on_dex_ready:
+            self._on_dex_ready(self)

dex_framework/buttons/DEx_FilledTonalButton.py

@@ -0,0 +1,52 @@
+"""
+DEx_FilledTonalButton — DEx-Framework v3.0.0
+Encapsula flet.FilledTonalButton com padrões DEx.
+
+Uso básico:
+    from dex_framework.buttons import DEx_FilledTonalButton
+    componente = DEx_FilledTonalButton(...)
+"""
+
+from __future__ import annotations
+import flet as ft
+from typing import Any, Callable, Optional
+
+
+class DEx_FilledTonalButton(ft.FilledTonalButton):
+    """
+    Encapsulamento DEx do controle flet.FilledTonalButton.
+
+    Mantém 100% da API original do Flet e adiciona:
+      - Valores padrão opinados (brand defaults)
+      - Parâmetro `dex_id` para rastreamento
+      - Hook `on_dex_ready` disparado após montagem
+
+    Args:
+        dex_id: Identificador único do componente na aplicação.
+        on_dex_ready: Callback chamado quando o componente é montado.
+        **kwargs: Todos os parâmetros nativos de flet.FilledTonalButton.
+
+    Example:
+        >>> btn = DEx_FilledTonalButton(
+        ...     dex_id="exemplo",
+        ... )
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        dex_id: str = "",
+        dex_theme: str = "dell",
+        on_dex_ready: Optional[Callable[["DEx_FilledTonalButton"], None]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.dex_id: str = dex_id
+        self.dex_theme: str = dex_theme
+        self._on_dex_ready = on_dex_ready
+
+    def did_mount(self) -> None:
+        """Chamado pelo Flet quando o controle é inserido na árvore."""
+        super().did_mount()
+        if self._on_dex_ready:
+            self._on_dex_ready(self)

dex_framework/buttons/DEx_FloatingActionButton.py

@@ -0,0 +1,52 @@
+"""
+DEx_FloatingActionButton — DEx-Framework v3.0.0
+Encapsula flet.FloatingActionButton com padrões DEx.
+
+Uso básico:
+    from dex_framework.buttons import DEx_FloatingActionButton
+    componente = DEx_FloatingActionButton(...)
+"""
+
+from __future__ import annotations
+import flet as ft
+from typing import Any, Callable, Optional
+
+
+class DEx_FloatingActionButton(ft.FloatingActionButton):
+    """
+    Encapsulamento DEx do controle flet.FloatingActionButton.
+
+    Mantém 100% da API original do Flet e adiciona:
+      - Valores padrão opinados (brand defaults)
+      - Parâmetro `dex_id` para rastreamento
+      - Hook `on_dex_ready` disparado após montagem
+
+    Args:
+        dex_id: Identificador único do componente na aplicação.
+        on_dex_ready: Callback chamado quando o componente é montado.
+        **kwargs: Todos os parâmetros nativos de flet.FloatingActionButton.
+
+    Example:
+        >>> btn = DEx_FloatingActionButton(
+        ...     dex_id="exemplo",
+        ... )
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        dex_id: str = "",
+        dex_theme: str = "dell",
+        on_dex_ready: Optional[Callable[["DEx_FloatingActionButton"], None]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.dex_id: str = dex_id
+        self.dex_theme: str = dex_theme
+        self._on_dex_ready = on_dex_ready
+
+    def did_mount(self) -> None:
+        """Chamado pelo Flet quando o controle é inserido na árvore."""
+        super().did_mount()
+        if self._on_dex_ready:
+            self._on_dex_ready(self)

dex_framework/buttons/DEx_IconButton.py

@@ -0,0 +1,52 @@
+"""
+DEx_IconButton — DEx-Framework v3.0.0
+Encapsula flet.IconButton com padrões DEx.
+
+Uso básico:
+    from dex_framework.buttons import DEx_IconButton
+    componente = DEx_IconButton(...)
+"""
+
+from __future__ import annotations
+import flet as ft
+from typing import Any, Callable, Optional
+
+
+class DEx_IconButton(ft.IconButton):
+    """
+    Encapsulamento DEx do controle flet.IconButton.
+
+    Mantém 100% da API original do Flet e adiciona:
+      - Valores padrão opinados (brand defaults)
+      - Parâmetro `dex_id` para rastreamento
+      - Hook `on_dex_ready` disparado após montagem
+
+    Args:
+        dex_id: Identificador único do componente na aplicação.
+        on_dex_ready: Callback chamado quando o componente é montado.
+        **kwargs: Todos os parâmetros nativos de flet.IconButton.
+
+    Example:
+        >>> btn = DEx_IconButton(
+        ...     dex_id="exemplo",
+        ... )
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        dex_id: str = "",
+        dex_theme: str = "dell",
+        on_dex_ready: Optional[Callable[["DEx_IconButton"], None]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.dex_id: str = dex_id
+        self.dex_theme: str = dex_theme
+        self._on_dex_ready = on_dex_ready
+
+    def did_mount(self) -> None:
+        """Chamado pelo Flet quando o controle é inserido na árvore."""
+        super().did_mount()
+        if self._on_dex_ready:
+            self._on_dex_ready(self)

dex_framework/buttons/DEx_MenuItemButton.py

@@ -0,0 +1,52 @@
+"""
+DEx_MenuItemButton — DEx-Framework v3.0.0
+Encapsula flet.MenuItemButton com padrões DEx.
+
+Uso básico:
+    from dex_framework.buttons import DEx_MenuItemButton
+    componente = DEx_MenuItemButton(...)
+"""
+
+from __future__ import annotations
+import flet as ft
+from typing import Any, Callable, Optional
+
+
+class DEx_MenuItemButton(ft.MenuItemButton):
+    """
+    Encapsulamento DEx do controle flet.MenuItemButton.
+
+    Mantém 100% da API original do Flet e adiciona:
+      - Valores padrão opinados (brand defaults)
+      - Parâmetro `dex_id` para rastreamento
+      - Hook `on_dex_ready` disparado após montagem
+
+    Args:
+        dex_id: Identificador único do componente na aplicação.
+        on_dex_ready: Callback chamado quando o componente é montado.
+        **kwargs: Todos os parâmetros nativos de flet.MenuItemButton.
+
+    Example:
+        >>> btn = DEx_MenuItemButton(
+        ...     dex_id="exemplo",
+        ... )
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        dex_id: str = "",
+        dex_theme: str = "dell",
+        on_dex_ready: Optional[Callable[["DEx_MenuItemButton"], None]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.dex_id: str = dex_id
+        self.dex_theme: str = dex_theme
+        self._on_dex_ready = on_dex_ready
+
+    def did_mount(self) -> None:
+        """Chamado pelo Flet quando o controle é inserido na árvore."""
+        super().did_mount()
+        if self._on_dex_ready:
+            self._on_dex_ready(self)