Como criar menus em Python no TQS (EAG.PYMEN e EAGXXX.PYMEN)

A criação de menus Python no TQS é hoje um dos jeitos mais eficientes de transformar tarefas repetitivas em comandos de um clique dentro dos editores gráficos (EAG). Em vez de “rodar um script”, você passa a ter um item de menu nativo chamando sua rotina em Python.

Abaixo faço um passo a passo direto ao ponto, usando como base o manual oficial do TQS e exemplos reais (como os menus de alvenaria desenvolvidos pela BRGT).

1. Onde o TQS procura seus menus em Python

No TQS, os editores gráficos (EAGW.EXE) são configurados por menus do tipo .MEN, armazenados em TQSW\EXEC\EAGMENU. Eles apontam para comandos escritos em DLLs C++ – é o menu padrão que você já usa.

A interface Python entra como uma extensão desse menu:

Para cada EAGXXX.MEN carregado, o editor tenta carregar automaticamente um arquivo EAGXXX.PYMEN na pasta TQSW\EXEC\Python.
A partir da versão V24, sempre que um editor gráfico abre, ele tenta carregar antes o menu EAG.PYMEN, que é um menu Python comum a todos os editores (formas, ferros, alvenaria, modelador etc.).

Isso significa que você pode:

Ter comandos globais (em EAG.PYMEN, valendo em qualquer editor);
Ter comandos específicos de uma aplicação (por exemplo, EAGALV.PYMEN só para Alvenaria em planta).

2. Estrutura básica de um arquivo .PYMEN

Um menu Python segue praticamente a mesma lógica dos menus .MEN, mas trocando DLL por módulo Python. A estrutura típica é:

ini
[PYTHON]
EAGALV.PY

[CMD]
ID_EXEMPLO,EAGALV.PY,meu_comando
Texto de ajuda do comando

[MENU]
SUBMENU,&BRGT – Automação
MENUITEM,ID_EXEMPLO,Executar &exemplo
FIMSUBMENU

Pontos importantes:

[PYTHON] – lista os módulos .PY que o menu pode chamar (devem estar em TQSW\EXEC\Python).
[CMD] – para cada comando:
um ID (ID_EXEMPLO),
o nome do módulo (EAGALV.PY),
o nome da função Python (meu_comando),
e uma linha de ajuda que aparece em tooltip/rodapé.
[MENU] – monta o menu dropdown:
SUBMENU abre um menu,
MENUITEM associa um item ao ID,
SEPARADOR insere linhas de separação,
FIMSUBMENU fecha o submenu.

O & no texto do menu define o atalho de teclado (Alt + letra).

3. Assinatura das rotinas Python chamadas pelo menu

Toda função chamada por um .PYMEN tem sempre a mesma assinatura:

python
def seu_comando(eag, tqsjan):
…

Onde:

eag é um objeto TQSEag.Eag (controle do editor: menus, estados, entrada simulada, mensagens, execuções de comando etc.);
tqsjan é um objeto TQSJan.Window, que dá acesso à janela e ao desenho aberto;
o desenho em si é tqsjan.dwg, um TQSDwg.Dwg, permitindo ler e alterar elementos do DWG.

Exemplo simplificado baseado na lógica dos exemplos oficiais:

python
from TQS import TQSDwg, TQSEag

def meu_comando(eag, tqsjan):
dwg = tqsjan.dwg
# Exemplo bem simples: dar zoom total e avisar o usuário
tqsjan.ZoomTotal()
eag.msg.Print("Comando Python executado com sucesso!")

Nos menus avançados da BRGT (como EAGALV.PY), essa mesma assinatura é usada para tarefas mais pesadas, como: detectar blocos por layer, corrigir escala, inserir graute e armaduras verticais automaticamente, apagar blocos sob portas, etc.

4. Ligando o menu Python a uma aplicação específica

O fluxo típico para criar um menu de aplicação é:

Descobrir o menu do editor que você quer estender
- Ex.: planta de alvenaria usa o menu EAGALV.MEN.
Criar o arquivo EAGALV.PYMEN em TQSW\EXEC\Python
- Com as seções [PYTHON], [CMD], [MENU] explicadas acima.
Criar o módulo EAGALV.PY na mesma pasta
- Implementando as funções def comando_x(eag, tqsjan): para cada ID definido em [CMD].
Abrir um desenho correspondente (por exemplo, uma planta de alvenaria) e verificar se o novo submenu aparece no final da barra de menus.

5. Menus globais: usando o EAG.PYMEN

Se você quer comandos disponíveis em qualquer editor gráfico (formas, ferros, alvenaria, modelador, paredes, etc.), use o menu global:

Crie/edite o arquivo EAG.PYMEN em TQSW\EXEC\Python;
A estrutura é a mesma ([PYTHON], [CMD], [MENU]);
Esse menu é carregado antes do menu específico da aplicação, então os comandos ficam sempre visíveis.

Isso é útil para:

Ferramentas genéricas de revisão de desenho;
Rotinas de auditoria de layers, escalas, blocos;
Utilitários internos de escritório que você quer padronizar em toda a equipe.

6. Reaproveitando código de menu com INCLUIR

Se você tiver um conjunto de comandos comum a vários editores, o manual recomenda separar esse trecho em um arquivo .PYMEN “comum” e incluir nos demais com:

ini
INCLUIR,COMUM.PYMEN

Isso evita copiar/colar blocos gigantes de menu e facilita manter tudo padronizado.

7. Checklist rápido para começar

Python 3.x instalado, pacote TQSPythonInterface instalado (pasta TQSW\EXEC\Python).
Criar/editar EAG.PYMEN (global) ou EAGXXX.PYMEN (por aplicação).
Apontar, em [PYTHON], para o(s) módulo(s) .PY que você vai usar.
Criar IDs em [CMD], ligando cada um a uma função def … (eag, tqsjan) no seu .PY.
Montar o submenu em [MENU].
Abrir o editor correspondente no TQS e testar.

Material de Apoio:

https://drive.google.com/drive/folders/192wvOMPrOG6yG3w9w5Wb0Ge56-Olhwb6?usp=drive_link