DBEDIT()*
 Faz um browse em registros no formato de tabela
------------------------------------------------------------------------------

 Sintaxe

     DBEDIT([<nTopo>], [<nEsquerda>],
         [<nBase>], <nDireita>],
         [<acColunas>],
         [<cFunçaoUsuário>],
         [<acMáscarasColunas> | <cMáscaraColunas>],
         [<acCabeçalhosColunas> | <cCabeçalhoColunas>],
         [<acSeparadoresCabeçalhos> | <cSeparadorCabeçalhos>],
         [<acSeparadoresColunas> | <cSeparadorColunas>],
         [<acSeparadoresRodapés> | <cSeparadorRodapés>],
         [<acRodapésColunas> | <cRodapéColunas>]) --> NIL

 Argumentos

     <nTopo>, <nEsquerda> e <nBase>, <nDireita> definem as
     coordenadas do canto superior esquerdo e o canto inferior direito da
     janela da DBEDIT().  Os valores da linha podem variar de zero até
     MAXROW() e os posicionamentos de coluna podem variar de zero até
     MAXCOL().  Caso nao sejam especificados, as coordenadas assumidas sao
     0, 0, MAXROW(), e MAXCOL().

     <acColunas> é um vetor de expressoes caractere contendo os nomes de
     campos do arquivo de dados ou expressoes para utilizar como valores
     para cada linha exibida.  Se este argumento nao é especificado,
     DBEDIT() exibe todos os campos presentes na área corrente como sendo as
     colunas.

     <cFunçaoUsuário> é o nome de uma funçao definida pelo usuário que é
     executada quando uma tecla nao reconhecível é pressionada ou quando nao
     há nenhuma tecla pendente no buffer do teclado.  O nome da funçao é
     especificada como sendo uma expressao caractere sem os parênteses ou
     argumentos.  Note que o comportamento da funçao DBEDIT() é afetado pela
     presença desses argumentos.  Para maiores informaçoes veja os tópicos
     discutidos abaixo.

     <acMáscarasColunas> é um vetor paralelo contendo as máscaras de
     formataçao de cada coluna.  Especificando <cMáscaraColunas> em vez do
     vetor, este será assumido para a exibiçao de todas as colunas com o
     mesmo formato.  Consulte também TRANSFORM() ou @...SAY para maiores
     informaçoes sobre máscaras.

     <acCabeçalhosColunas> é um vetor paralelo contendo expressoes
     caractere que definem os cabeçalhos para cada coluna.  Se
     especificada <cCabeçalhoColuna> em vez do vetor de cabeçalhos, é
     assumido o mesmo cabeçalho para todas as colunas.  Para exibir
     cabeçalhos em mais de uma linha, inclua um ponto-e-vírgula dentro da
     expressao de cabeçalho onde você deseje que a cadeia seja separada.
     Caso nao seja especificado, os cabeçalhos das colunas sao tomados do
     vetor <acColunas>, ou sao assumidos os nomes dos campos presentes na
     área corrente se o argumento <acColunas> nao for mencionado.

     <acSeparadoresCabeçalhos> é um vetor paralelo contendo expressoes
     do tipo caractere que definem os caracteres que serao utilizados para
     desenhar as linhas horizontais separando os cabeçalhos das colunas da
     área de exibiçao dos campos.  Especificando a expressao
     <cSeparadorCabeçalhos> em vez do vetor é utilizado o mesmo separador
     para todas as colunas.  Caso este argumento nao seja mencionado, o
     separador assumido é uma linha gráfica dupla.

     <acSeparadoresColunas> é um vetor paralelo contendo expressoes
     caractere que definem os caracteres utilizados para desenhar as linhas
     verticais que separam as colunas.  Especificando a expressao
     <cSeparadorColunas> em vez do vetor é utilizado o mesmo separador para
     todas as colunas.  Caso este argumento nao seja mencionado, o separador
     assumido é uma linha gráfica simples.

     <acSeparadoresRodapés> é um vetor paralelo contendo expressoes
     caractere que definem os caracteres que serao utilizados para desenhar
     as linhas horizontais que separam os rodapés das colunas da área de
     exibiçao dos campos.  Especificando a expressao <cSeparadorRodapés> em
     vez do vetor é utilizado o mesmo separador de rodapé para todas as
     colunas.  Caso este argumento nao seja mencionado, nao é exibido nenhum
     separador para os rodapés.

     <acRodapésColunas> é um vetor paralelo contendo expressoes
     caractere que definem os rodapés para cada coluna. Especificando a
     expressao <cRodapéColunas> em vez do vetor é utilizado o mesmo rodapé
     para todas as colunas.  Para exibir rodapés em mais de uma linha,
     inclua um ponto-e-vírgula na expressao contendo o rodapé onde você
     deseje que a cadeia seja separada.  Caso este argumento nao seja
     mencionado, nao é exibido nenhum rodapé para as colunas.

 Retorno

     DBEDIT() sempre retorna NIL.

 Descriçao

     DBEDIT() além de ser uma funçao de interface com o usuário é também uma
     funçao de compatibilidade que exibe registros de uma ou mais áreas de
     trabalho na forma de tabela.  A janela de visualizaçao da DBEDIT() é
     uma área com células dividida em colunas e linhas.  As colunas
     correspondem aos campos do arquivo de dados e as linhas aos registros
     deste arquivo.  Cada coluna é definida por um elemento do vetor
     <acColunas>.  A largura assumida para a exibiçao de cada coluna é
     determinada pela avaliaçao da expressao da coluna contida no vetor
     <acColunas> ou pela máscara da coluna especificada no vetor
     <acMáscarasColunas>.

     Todas as teclas de movimentaçao do cursor sao manipuladas dentro
     da DBEDIT(), incluíndo PgUp, PgDn, Home, End, as quatro setas de
     navegaçao, e todas as combinaçoes válidas da tecla Ctrl que realizam a
     movimentaçao do cursor.  As teclas de navegaçao às quais a DBEDIT()
     responde quando o argumento da funçao do usuário nao é especificado
     estao mostradas na tabela Teclas Ativas na próxima página.

     Tabela 5-8: Teclas Ativas em DBEDIT()
     ------------------------------------------------------------------------
     Tecla                      Açao
     ------------------------------------------------------------------------
     Cursor para cima           Sobe uma linha
     Cursor para baixo          Desce uma linha
     Cursor para esquerda       Coluna à esquerda
     Cursor para direita        Coluna à direita
     Ctrl-Cursor para esquerda  Painel uma coluna para esquerda
     Ctrl-Cursor para direita   Painel uma coluna para direita
     Home                       Coluna mais à esquerda na tela
     End                        Coluna mais à direita na tela
     Ctrl-Home                  Coluna inicial
     Ctrl-End                   Coluna final
     PgUp                       Tela anterior
     PgDn                       Próxima tela
     Ctrl-PgUp                  Primeira linha da coluna corrente
     Ctrl-PgDn                  Ultima linha da coluna corrente
     Return                     Encerra DBEDIT()
     Esc                        Encerra DBEDIT()
     ------------------------------------------------------------------------

     Quando o argumento da funçao do usuário (<cFunçaoUsuário>) é
     especificado, todas as teclas indicadas na tabela Teclas Ativas estao
     ativas com exceçao do Esc e Return.  Quando a DBEDIT() chama a funçao
     do usuário, esta passa automaticamente dois argumentos:

       O modo corrente passado como um valor numérico

       O índice da coluna corrente com base no vetor <acColunas>
        passado como um valor numérico

     O parâmetro modo indica o estado corrente da DBEDIT() dependendo da
     última tecla que foi executada.  Os possíveis valores dos modos estao
     mostrados na tabela Modos da DBEDIT().

     Tabela 5-9: Modos de DBEDIT()
     ------------------------------------------------------------------------
     Status         Dbedit.ch         Descriçao
     ------------------------------------------------------------------------
     0              DE_IDLE           Inativa, todas teclas foram manipuladas
                                      e nao há teclas pendentes
     1              DE_HITTOP         Tentativa de passar início de arquivo
     2              DE_HITBOTTOM      Tentativa de passar final de arquivo
     3              DE_EMPTY          Arquivo vazio na área corrente
     4              DC_EXCEPT         Teclagem exceçao
     ------------------------------------------------------------------------

     O parâmetro índice aponta para a posiçao da coluna corrente definida no
     vetor <acColunas>.  Caso o vetor <acColunas> nao seja especificado, o
     parâmetro índice apontará para a posiçao do campo da estrutura do
     arquivo de dados corrente.  O nome do campo pode ser acessado
     utilizando a funçao FIELD().

     Quando a funçao do usuário tiver sido chamada, um valor deve ser
     retornado para instruir à DBEDIT() que açao realizar em seguida.  A
     tabela Valores de Retorno da Funçao do Usuário sumariza os possíveis
     valores de retorno e as açoes correspondentes:

     Tabela 5-10: Valores de Retorno da Funçao de Usuário de DBEDIT()
     ------------------------------------------------------------------------
     Valor          Dbedit.ch         Descriçao
     ------------------------------------------------------------------------
     0              DE_ABORT          Aborta DBEDIT()
     1              DE_CONT           Continua DBEDIT()
     2              DE_REFRESH        Força reler e reescrever a tela e
                                      continuar; após reescrever, processa
                                      teclas, e vai para inativa
     ------------------------------------------------------------------------

     A funçao do usuário é chamada nos seguintes casos:

       Ocorrência de uma tecla de exceçao.  Isto acontece quando a
        DBEDIT() captura uma tecla pressionada e esta nao é reconhecida.
        Quaisquer teclas pendentes permanecem no buffer do teclado até que
        seja capturada dentro da funçao do usuário ou até que a DBEDIT()
        continue.

       DBEDIT() entra no modo inativo (i.e., quando todas as teclas
        pendentes tenham sido executadas).  Isto acontece quando o buffer do
        teclado está vazio ou após ser efetuado um refresh da tela.  Nesta
        ocorrência, há uma chamada para a funçao do usuário e entao a
        DBEDIT() espera por uma tecla.

       Início ou final do arquivo é encontrado.  Esta ocorrência é a
        mesma que a inatividade da DBEDIT().  Todas as teclas pendentes sao
        executadas, e há uma chamada à funçao do usuário com a mensagem de
        status indicadora.

     Note que quando a DBEDIT() é executada pela primeira vez, todas as
     teclas pendentes no buffer do teclado sao executadas e logo após a
     DBEDIT() entra no modo inativo com a chamada à funçao do usuário.  Caso
     nao existam teclas pendentes, o modo inativo é imediato.

     A estrutura da funçao do usuário deve ser desenhada para manipular
     todos os modos e as mensagens de status recebidas da DBEDIT().

     DBEDIT() é completamente recursiva, isto significa que você pode
     realizar chamadas aninhadas a ela.  Utilizando esta característica,
     você pode ter múltiplas janelas de browse na tela ao mesmo tempo.

     DBEDIT() é uma funçao de compatibilidade e, portanto,  nao é
     recomendada sua utilizaçao como dispositivo de browse.  Para este
     propósito, ela está superada pela classe de objeto TBrowse.  Para
     maiores informaçoes, consulte o capítulo Classes Padrao presente neste
     livro.

 Exemplos

     Este exemplo demonstra como chamar a DBEDIT() com uma funçao do
     usuário:

     USE Customer INDEX Customer NEW
     USE Sales INDEX Sales NEW
     SET RELATION TO CustNum INTO Customer
     //
     acColumns = {"Branch", "Salesman", "Amount", "Customer->Customer"}
     DBEDIT(4, 0, 22, 79, acColumns, "UserFunc")

 Arquivos:  Biblioteca EXTEND.LIB, arquivos header Dbedit.ch e Inkey.ch.
 To download this example - click here.

See Also: ACHOICE() BROWSE() MEMOEDIT() TRANSFORM() @...GET