Metadata-Version: 2.4
Name: SimplesOS-Windows
Version: 1.0.0
Summary: Uma biblioteca leve para interagir com a API nativa do Windows usando ctypes.
Home-page: https://github.com/Zettinha/SimplesOS
Author: ZettaDev
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: Microsoft :: Windows
Requires-Python: >=3.6
Description-Content-Type: text/markdown
Dynamic: author
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: requires-python
Dynamic: summary

# 🛠️ SimplesOS

A **SimplesOS** é uma biblioteca Python leve desenvolvida para interagir diretamente com a API nativa do Windows (Win32 API) através de DLLs do sistema (`user32.dll`, `kernel32.dll`, `gdi32.dll`), sem depender de nenhuma instalação ou biblioteca externa de terceiros.

---

## 🚀 Como Importar no Projeto

Para começar a usar a biblioteca no seu script principal, basta importá-la assim:

```python
import SimplesOS
```
### 🪟 Gerenciamento de Janelas (`SimplesOS.janelas`)

Este módulo interage diretamente com a `user32.dll` para varrer, identificar e manipular o estado de qualquer janela de software aberta na interface gráfica do Windows.

#### Funções Disponíveis:

* **`listar_todas_as_janelas()`**
    * **O que faz:** Realiza uma varredura no sistema operacional e retorna uma lista contendo os títulos (strings) de todas as janelas visíveis e ativas no momento.
    * **Exemplo de uso:**
        ```python
        janelas = SimplesOS.listar_todas_as_janelas()
        for j in janelas:
            print(f"Janela encontrada: {j}")
        ```

* **`alterar_titulo_de_qualquer_janela(titulo_atual, novo_titulo)`**
    * **O que faz:** Localiza uma janela aberta usando o seu nome atual e altera o texto da barra de título dela para um novo nome personalizado.
    * **Exemplo de uso:**
        ```python
        SimplesOS.alterar_titulo_de_qualquer_janela("Bloco de Notas", "Meu Editor Super Secreto")
        ```

* **`fechar_janela(titulo_da_janela)`**
    * **O que faz:** Procura o processo visual da janela pelo título e envia uma ordem nativa do sistema (`WM_CLOSE`) para encerrá-la imediatamente.
    * **Exemplo de uso:**
        ```python
        SimplesOS.fechar_janela("Calculadora")
        ```

* **`minimizar_janela(titulo_da_janela)`**
    * **O que faz:** Envia o comando de ocultação visual, mandando a janela especificada diretamente para a barra de tarefas do Windows.
    * **Exemplo de uso:**
        ```python
        SimplesOS.minimizar_janela("Sem título - Bloco de Notas")
        ```

* **`maximizar_janela(titulo_da_janela)`**
    * **O que faz:** Força a janela alvo a entrar em modo de tela cheia.
    * **Exemplo de uso:**
        ```python
        SimplesOS.maximizar_janela("Meu Editor Super Secreto")
        ```

* **`restaurar_janela(titulo_da_janela)`**
    * **O que faz:** Retorna a janela minimizada ou maximizada de volta ao seu tamanho normal e posição original na tela.
    * **Exemplo de uso:**
        ```python
        SimplesOS.restaurar_janela("Calculadora")
        ```

### 🔊 Módulo de Som e Voz (`SimplesOS.som`)

Este módulo gerencia a saída de áudio nativa do computador, permitindo emitir frequências sonoras controlando diretamente a placa-mãe ou acionando o sintetizador de fala do Windows.

#### Funções Disponíveis:

* **`tocar_bip(frequencia, duracao_ms)`**
    * **O que faz:** Emite um bipe sonoro usando a `kernel32.dll`. É útil para alertas mecânicos, sinalização de processos finalizados ou até para criar sequências musicais simples por código.
    * **Parâmetros:**
        * `frequencia`: O tom do som em Hertz (Hz). Deve estar entre `37` e `32767`.
        * `duracao_ms`: O tempo que o som vai durar em milissegundos (ex: `1000` é igual a 1 segundo).
    * **Exemplo de uso:**
        ```python
        # Toca a nota Lá (440Hz) por meio segundo
        SimplesOS.tocar_bip(440, 500)
        ```

* **`falar(texto)`**
    * **O que faz:** Converte qualquer texto de string em fala usando o motor de síntese de voz nativo do Windows (SAPI via PowerShell). O computador lê a frase em voz alta usando o idioma padrão do sistema.
    * **Parâmetros:**
        * `texto`: A frase ou mensagem que o computador deve falar.
    * **Exemplo de uso:**
        ```python
        SimplesOS.falar("Processo de varredura concluído com sucesso!")
        ```     

       ### 🖱️ Módulo de Input (Mouse) (`SimplesOS.input`)

Este módulo permite simular ações físicas de hardware diretamente na tela do Windows, controlando as coordenadas do cursor e executando cliques de forma automatizada.

#### Funções Disponíveis:

* **`mover_mouse(x, y)`**
    * **O que faz:** Teleporta o cursor do mouse instantaneamente para as coordenadas pixel-a-pixel especificadas na tela.
    * **Parâmetros:**
        * `x`: Posição na linha horizontal (da esquerda para a direita).
        * `y`: Posição na linha vertical (de cima para baixo).
    * **Exemplo de uso:**
        ```python
        # Move o mouse para o canto superior esquerdo da tela
        SimplesOS.mover_mouse(100, 100)
        ```

* **`clicar()`**
    * **O que faz:** Dispara um evento de clique físico simulado (pressionar e soltar o botão esquerdo do mouse) exatamente na posição atual onde o ponteiro estiver parado.
    * **Exemplo de uso:**
        ```python
        # Clica onde o mouse estiver posicionado no momento
        SimplesOS.clicar()
        ```

* **`pegar_posicao_mouse()`**
    * **O que faz:** Captura as coordenadas exatas de onde o usuário está com o mouse na tela em tempo real.
    * **Retorno:** Retorna um dicionário no formato `{"x": valor, "y": valor}`.
    * **Exemplo de uso:**
        ```python
        posicao = SimplesOS.pegar_posicao_mouse()
        print(f"O mouse está em X: {posicao['x']}, Y: {posicao['y']}")
        ```     

       ### ⚠️ Módulo de Alertas e Diálogos (`SimplesOS.alertas`)

Este módulo aciona as caixas de mensagem gráficas nativas do ecossistema Windows via `user32.dll`, ideais para dar avisos visuais ou colher decisões básicas de confirmação.

#### Funções Disponíveis:

* **`mostrar_mensagem(titulo, mensagem)`**
    * **O que faz:** Faz pular no meio da tela um pop-up cinza clássico contendo um ícone de informação e um único botão de "OK". O código Python fica pausado esperando o usuário fechar a janelinha.
    * **Parâmetros:**
        * `titulo`: O texto que vai aparecer na barra superior da caixa.
        * `mensagem`: O corpo do texto descritivo interno do alerta.
    * **Exemplo de uso:**
        ```python
        SimplesOS.mostrar_mensagem("Aviso", "O script terminou de rodar com sucesso!")
        ```

* **`perguntar_sim_nao(titulo, pergunta)`**
    * **O que faz:** Abre uma janelinha de interrogação oferecendo as opções clicáveis "Sim" e "Não". Útil para criar estruturas de decisão baseadas na escolha humana.
    * **Retorno:** Retorna `True` caso o usuário clique no botão "Sim", e `False` caso clique no "Não".
    * **Exemplo de uso:**
        ```python
        guardar = SimplesOS.perguntar_sim_nao("Confirmar", "Deseja salvar o relatório agora?")
        if guardar:
            print("O usuário escolheu continuar.")
        else:
            print("Ação cancelada pelo usuário.")
        ``` 
        
       ### 📸 Módulo de Captura de Tela (`SimplesOS.print`)

Este módulo utiliza as funções gráficas de baixo nível da `gdi32.dll` e `user32.dll` para clonar instantaneamente os pixels da tela inteira e salvá-los em um arquivo de imagem Bitmap (`.bmp`), operando de forma extremamente rápida.

#### Funções Disponíveis:

* **`tirar_print(nome_arquivo)`**
    * **O que faz:** Captura tudo o que está visível no monitor e cria um arquivo físico de imagem no diretório do seu projeto. Caso você esqueça de colocar a extensão `.bmp` no nome do arquivo, a função adiciona automaticamente.
    * **Parâmetros:**
        * `nome_arquivo` (Opcional): O nome do arquivo onde a imagem será salva (O padrão é `"print.bmp"`).
    * **Retorno:** Retorna `True` se a imagem foi gerada com sucesso.
    * **Exemplo de uso:**
        ```python
        # Tira o print e salva com um nome personalizado
        SimplesOS.tirar_print("captura_da_tela.bmp")
        ``` 

       ### 📋 Módulo da Área de Transferência (`SimplesOS.copiar`)

Este módulo permite interagir com o "Ctrl+C" e o "Ctrl+V" do Windows ao nível do sistema, alocando memória global compartilhada através da `kernel32.dll` e manipulando os dados com a `user32.dll`.

#### Funções Disponíveis:

* **`copiar_texto(texto)`**
    * **O que faz:** Injeta qualquer string diretamente na Área de Transferência do Windows. Depois de rodar esta função, o texto fica guardado no teu teclado e podes colá-lo (Ctrl+V) em qualquer programa ou editor do teu computador.
    * **Parâmetros:**
        * `texto`: A string/frase que desejas copiar para o sistema.
    * **Retorno:** Retorna `True` se o texto foi injetado com sucesso na memória.
    * **Exemplo de uso:**
        ```python
        SimplesOS.copiar_texto("Texto copiado automaticamente pelo Python! 🥷")
        ```

* **`colar_texto()`**
    * **O que faz:** Acede à Área de Transferência do Windows em tempo real, lê o texto que lá estiver guardado no momento (caso exista) e puxa-o para dentro de uma variável no Python.
    * **Retorno:** Retorna uma string com o conteúdo atualmente copiado no Windows.
    * **Exemplo de uso:**
        ```python
        texto_do_windows = SimplesOS.colar_texto()
        print(f"O conteúdo atual do Ctrl+C é: {texto_do_windows}")
        ``` 

      ### ⚙️ Módulo de Processos e Programas (`SimplesOS.processos`)

Este módulo gerencia a execução de softwares em segundo plano no Windows, permitindo abrir programas diretamente pelo código de forma independente, utilizando a função `CreateProcessW` da `kernel32.dll`.

#### Funções Disponíveis:

* **`iniciar_programa(comando)`**
    * **O que faz:** Solicita ao Windows a criação de um novo processo isolado para rodar um executável do sistema. Se o programa estiver nas variáveis de ambiente do Windows (como a calculadora ou o bloco de notas), basta passar o nome. Caso contrário, passa-se o caminho completo do arquivo `.exe`.
    * **Parâmetros:**
        * `comando`: O nome do executável ou o caminho do programa que desejas abrir.
    * **Retorno:** Retorna `True` se o processo foi criado e iniciado com sucesso.
    * **Exemplo de uso:**
        ```python
        # Abre a calculadora do Windows de forma nativa
        SimplesOS.iniciar_programa("calc.exe")
        ```  
