PC Toledo

Boa tarde

Preciso exibir uma campo memo da seguinte maneira:

Preciso que ele comece na linha 12 coluna 21 e termine na linha 13, sendo que o tamanho máximo em caracteres por linha tem que ser 50.

alguém pode me dar um exemplo?

Obrigado

Amigo...
É por aí, tem mais alguns parametros mas o basico é este.

MEMOEDIT()
Exibe ou edita cadeias de caracteres e campos memo
------------------------------------------------------------------------------

Sintaxe

MEMOEDIT([<cString>],
[<nTopo>], [<nEsquerda>],
[<nBase>], [<nDireita>],
[<lModoEdicao>],
[<cFuncaoControle>],
[<nTamanhoLinha>],
[<nTamanhoTab>],
[<nLinhaBufferTexto>],
[<nColunaBufferTexto>],
[<nLinhaJanela>],
[<nColunaJanela>]) --> cBufferTexto

Argumentos

<cString> é a cadeia de caracteres ou campo memo a ser copiado para o buffer de texto da MEMOEDIT(). Caso nao seja especificado, o buffer de texto fica vazio.

<nTopo>, <nEsquerda>, <nBase>, e <nDireita> sao as coordenadas superior esquerda e inferior direita da janela. Valores de linha podem variar de zero a MAXROW(), e posicoes de coluna podem variar de zero a MAXCOL(). Se nao forem especificadas, as coordenadas padrao sao 0, 0, MAXROW(), e MAXCOL().

<lModoEdicao> determina se o buffer de texto pode ser editado ou simplesmente exibido. Especificar verdadeiro (.T.) permite ao usuario fazer alteracoes no buffer de texto, enquanto que especificar falso (.F.) permite ao usu rio somente a leitura do buffer de texto. Caso nao seja especificado, o valor padrao é verdadeiro (.T.).

<cFuncaoControle> é o nome de uma funcao de usuario que é executada quando o usuario pressionar uma tecla nao reconhecida pela MEMOEDIT() e quando nao houver teclas pendentes no buffer de teclado.
<cFuncaoControle> é especificada como um valor caractere sem parenteses ou argumentos. Especificando-se falso (.F.) neste argumento, o <cString> é exibido, e a MEMOEDIT() é terminada. Caso este argumento seja especificado, o comportamento automatico da MEMOEDIT() é alterado.

<nTamanhoLinha> determina o tamanho das linhas exibidas na janela da MEMOEDIT(). Caso exista uma linha maior do que <nTamanhoLinha>, ela é transportada para a proxima linha na janela de MEMOEDIT(). Se <nTamanhoLinha> for maior do que o numero de colunas na janela de MEMOEDIT(), a janela de edicao ser  deslocada caso o cursor se mova para além do limite da janela. Se <nTamanhoLinha> nao for especificado, o tamanho de linha padrao é (<nDireita> - <nEsquerda>).

<nTamanhoTab> determina o tamanho de um caractere de tabulacao a ser inserido quando o usu rio pressionar Tab. Caso <nTamanhoTab> nao seja especificado, sao inseridos quatro espacos ao invés de um caractere de tabulacao.

<nLinhaBufferTexto> e <nColunaBufferTexto> definem a posicao de exibicao do cursor dentro do buffer de texto quando é invocada a MEMOEDIT(). <nLinhaBufferTexto> comeca com 1 e <nColunaBufferTexto> comeca com zero. Se estes argumentos nao forem especificados, o cursor é posicionado na linha 1 e coluna zero da janela de MEMOEDIT().

<nLinhaJanela> e <nColunaJanela> definem a posicao inicial do cursor dentro da janela da MEMOEDIT(). Posicoes de linha e coluna comecam com zero. Caso estes argumentos nao sejam especificados, a posicao inicial na janela é linha zero mais a posicao de coluna onde o cursor estiver.

Retorno

MEMOEDIT() retorna o buffer de texto caso o usu rio termine a edicao com Ctrl-W, ou uma copia de <cString> caso o usuario termine com Esc.

Descricao

MEMOEDIT() é uma funcao de interface com o usuario e de edicao de textos, que pode ser utilizada para editar campos memo e cadeias de caracteres longas. A edicao ocorre dentro de uma regiao de janela especificada, posicionada em qualquer lugar na tela. Da mesma forma que outras funcoes de interface com o usuario (ACHOICE(), DBEDIT()), MEMOEDIT() suporta uma série de modos distintos, e inclui uma funcao de usuario para permitir a reconfiguracao de teclas e outras atividades relevantes a programacao da tarefa de edicao de textos.

* O buffer de texto: Quando é invocada a MEMOEDIT() e é especificado <cString>, <cString> é copiado para o buffer de texto.
O buffer de texto é o que o usuario realmente edita. Caso nao seja especificado <cString>, é apresentado ao usuario um buffer de texto vazio para edicao.

Quando o usuario sai da MEMOEDIT() pressionando Ctrl-W, o conteudo do buffer de texto é retornado. Se o usuario sair pressionando Esc, o buffer de texto é descartado e o valor original de <cString> é retornado. De qualquer maneira, o valor retornado pode entao ser atribuido a uma vari vel ou campo memo, ou passado como um argumento para outra funcao.

* Modos de Edicao: MEMOEDIT() suporta dois modos de edicao, dependendo do valor de <lModoEdicao>. Quando <lModoEdicao> é verdadeiro (.T.), MEMOEDIT() entra no modo de edicao, e ao usuario é permitido alterar o conteudo do buffer de texto da MEMOEDIT().
Quando <lModoEdicao> é falso (.F.), MEMOEDIT() entra no modo visualizar, e ao usuario é permitido navegar pelo buffer de texto, mas sem editar ou inserir textos. Para facilitar a visualizacao para o usuario, é desabilitado a rolagem, fazendo com que as teclas Cursor para cima e Cursor para baixo naveguem uma linha para cima ou para baixo no buffer de texto dentro da janela de MEMOEDIT().

* Entrando e editando textos: Dentro da MEMOEDIT(), o usuario pode entrar e editar textos posicionando o cursor, adicionando, ou eliminando caracteres. Para facilitar a edicao de textos, ha uma série de teclas de navegacao e edicao:

Tabela 5-20: Teclas de Navegacao e Edicao em MEMOEDIT()
---------------------------------------------------------------------
Tecla Acao
---------------------------------------------------------------------
Cursor para cima/Ctrl-E Move para cima uma linha
Cursor para baixo/Ctrl-X Move para baixo uma linha
Cursor para esquerda/Ctrl-S Move para esquerda um caractere
Cursor para direita/Ctrl-D Move para direita um caractere
Ctrl-Cursor para esquerda/Ctrl-A Move para esquerda uma palavra
Ctrl-Cursor para direita/Ctrl-F Move para direita uma palavra
Home Move para o in¡cio da linha corrente
End Move para o final da linha corrente
Ctrl-Home Move para o in¡cio da janela corrente
Ctrl-End Move para o final da janela corrente
PgUp Move para janela anterior
PgDn Move para a pr¢xima janela
Ctrl-PgUp Move para o in¡cio do texto
Ctrl-PgDn Move para o final do texto
Return Move para o in¡cio da pr¢xima linha
Del Elimina caractere onde est  o cursor
Backspace Elimina caractere a esquerda do cursor
Tab Insere tab ou espacos
Caracteres Imprim¡veis Insere caractere
Ctrl-Y Elimina a linha corrente
Ctrl-T Elimina a palavra a direita
Ctrl-B Reformata par grafo
Ctrl-V/Ins Comuta modo de insercao
Ctrl-W Grava e finaliza a edicao
Esc Aborta edicao e retorna o original
---------------------------------------------------------------------

* A tela de edicao: Quando MEMOEDIT() exibe, ela sobreescreve a  rea especificada da tela e nao grava a tela original. Além disso, ela nao exibe bordas nem t¡tulos. Para fornecer estas ferramentas, voce deve criar uma rotina ou funcao de usuario que execute estas acoes e depois chame a MEMOEDIT(). Veja o exemplo abaixo.

* A funcao de controle: A funcao de controle é especificada no argumento <cFuncaoControle>, que manipula excecoes de tecla e reconfigura teclas especiais. A funcao de controle é chamada varias vezes pela MEMOEDIT(), muito frequentemente em resposta a teclas que ela nao reconhece. Teclas que causam uma excecao sao todas as teclas Alt, de funcao, e teclas de controle dispon¡veis. Como estas teclas nao sao processadas pela MEMOEDIT(), elas podem ser reconfiguradas. Algumas destas teclas tem uma acao padrao atribuida as mesmas. Na funcao de controle, voce executa varias acoes que dependem do modo corrente da MEMOEDIT() e depois Retorna um valor que diz a MEMOEDIT() o que fazer.

Quando o argumento funcao de controle é especificado, MEMOEDIT() define duas classes de teclas: nao configuraveis e excecoes de tecla. Quando é pressionada uma tecla nao configuravel, MEMOEDIT() a executa; caso contrario é gerada uma excecao de tecla e a funcao de controle é chamada. Quando nao houver mais nenhuma tecla pendente no buffer de teclado a ser processada pela MEMOEDIT(), a funcao de controle é chamada novamente.

Quando a MEMOEDIT() chama a funcao de controle, ela automaticamente passa parametros indicando o modo da MEMOEDIT(), a linha corrente no buffer de texto, e a coluna corrente no buffer de texto. O modo indica o estado atual da MEMOEDIT(), dependendo da ultima acao tomada antes da execucao da funcao de controle. Sao poss¡veis os seguintes modos:

Tabela 5-21: Modos de MEMOEDIT()
---------------------------------------------------------------------
Modo Memoedit.ch Descricao
---------------------------------------------------------------------
0 ME_IDLE Inativo, todas as teclas foram processadas
1 ME_UNKEY Tecla desconhecida, memo inalterado
2 ME_UNKEYX Tecla desconhecida, memo alterado
3 ME_INT Modo de inicializacao
---------------------------------------------------------------------

Um valor de modo 3 indica que a MEMOEDIT() est  em modo de inicializacao. Quando voce especifica a <cFuncaoControle>, MEMOEDIT() faz uma chamada a funcao de controle imediatamente apos ser invocada. Neste ponto, voce retorna uma solicitacao de configuracao dos v rios modos de formatacao de texto da MEMOEDIT(): transporte, rolagem, ou inserir. MEMOEDIT() chama a funcao de controle repetidamente, permanencendo no modo de inicializacao até que voce retorne 0. O buffer de texto é entao exibido, e o controle entra no modo de edicao configurado por <lModoEdicao>. Observe que se o transporte estiver ativo quando MEMOEDIT() mudar do modo de inicializacao para o de edicao, todo o buffer de texto é formatado com <nTamanhoLinha>. Para evitar esta formatacao inicial, desligue o transporte durante a inicializacao. Observe também que a ativacao ou nao de transporte e rolagem nao é atribuida a nenhuma tecla, porém isto pode ser feito a partir da funcao de controle.

Os modos 1 e 2 indicam que a MEMOEDIT() capturou uma tecla nao reconhecida ou configur vel do buffer de teclado. Teclas configuraveis sao processadas retornando-se 0 para que seja executada a acao padrao da MEMOEDIT(). O retorno de um valor diferente executa outra acao de tecla, desta forma redefinindo a tecla. Caso seja uma tecla nao reconhecida, voce pode definir uma acao para ela retornando um valor que solicita uma acao de tecla ou executa uma acao que voce mesmo definiu.

O modo 0 indica que a MEMOEDIT() encontra-se inativa, e nenhuma tecla falta ser processada. Sempre que isto acontecer, a MEMOEDIT() faz uma chamada a funcao de controle. Neste ponto, voce geralmente atualiza exibicoes de n£mero de linha e coluna.

Os outros dois parametros, linha corrente e coluna, indicam a posicao corrente do cursor no buffer de texto quando a funcao de controle é chamada. O parametro linha comeca com posicao 1, e coluna comeca com posicao zero.

Quando o modo é 1, 2 ou 3, voce pode retornar um valor que instrui a MEMOEDIT() qual a proxima acao a ser executada. A tabela a seguir resume os valores de retorno poss¡veis e suas consequencias:

Tabela 5-22: Valores de Retorno da Funcao de Controle de MEMOEDIT()
---------------------------------------------------------------------
Valor Memoedit.ch Acao
---------------------------------------------------------------------
0 ME_DEFAULT Executa acao padrao
1-31 ME_UNKEY Processa acao correspondente ao valor da tecla
32 ME_IGNORE Ignora tecla
33 ME_DATA Trata tecla como dado
34 ME_TOGGLEWRAP Comuta modo de transporte
35 ME_TOGGLESCROLL Comuta modo de rolagem
100 ME_WORDRIGHT Pr¢xima palavra
101 ME_BOTTOMRIGHT Base da tela
---------------------------------------------------------------------

* Arquivos header: Para que os valores de modo e solicitacao sejam mais f ceis de ser lembrados e utilizados, é fornecido o arquivo Memoedit.ch no \CLIPPER5\INCLUDE. Além disso, Inkey.ch ests localizado no mesmo diretorio, e contém constantes para todos os valores INKEY().

Notas

* Configurando teclas: Se a <cFuncoUsuario> for especificada, as teclas na tabela abaixo sao configuraveis. Se a tecla for reconfiguravel, retornar 0 executa a acao padrao da MEMOEDIT(). retornar um valor diferente, porém, executa outra acao de tecla, desta forma redefinindo a mesma. Caso a tecla nao seja do tipo configuravel reconhecido pela MEMOEDIT(), voce pode definir uma acao para ela também retornando um valor que pede uma acao de tecla da tabela abaixo.

Tabela 5-23: Teclas Configur veis em MEMOEDIT()
---------------------------------------------------------------------
Tecla Acao Padrao
---------------------------------------------------------------------
Ctrl-Y Elimina a linha corrente
Ctrl-T Elimina a palavra a direita
Ctrl-B Reformata par grafo
Ctrl-V/Ins Comuta modo de insercao
Ctrl-W Finaliza edicao e grava
Esc Aborta edicao e retorna original
---------------------------------------------------------------------

* Transporte: Transporte é um modo de formatacao que voce pode alternar se retornar 34 da funcao de usuario. Quando esta on (o padrao), MEMOEDIT() insere um soft carriage return/line feed (retorno autom tico) ao final da palavra mais proxima da borda da janela ou tamanho de linha, valendo o que ocorrer primeiro. Quando transporte est  desligado, MEMOEDIT() rola o buffer de texto para além dos limites da janela até que o cursor atinja o final da linha. Neste ponto, o usuario deve pressionar Return (inserindo um hard carriage return/line feed) para avancar para a proxima linha.

* Alterando par grafos: Pressionar Ctrl-B ou retornar 2 de uma funcao de usuario causa a reformatacao do buffer de texto até que um hard carriage return (final de par grafo) ou o final do buffer de texto seja alcancado. Isto acontece sem importar se trabsporte esta ligado ou desligado.

* Carriage returns autom ticos: Carriage returns automaticos podem interferir na exibicao de comandos de console tais como ? e REPORT FORM, ou o processamento com outro processador de textos. Use HARDCR(), MEMOTRAN(), ou STRTRAN() para substituir estes caracteres, conforme sua necessidade.

* Editando arquivos texto: MEMOEDIT() pode ser utilizada para editar arquivos texto se o arquivo texto puder ser lido para uma variavel caractere Clipper. Isto pode ser feito com a funcao MEMOREAD(). Apos a edicao do conteudo do arquivo texto contido na variavel caractere, ele pode ser escrita no arquivo novamente com MEMOWRIT().

Exemplos

* O exemplo a seguir permite ao usu rio visualizar um campo memo, sem deixar que sejam feitas alteracoes no buffer de texto:

USE Customer NEW
SET CURSOR OFF
MEMOEDIT(CustNotes, 5, 10, 20, 69, .F.)
SET CURSOR ON

* Este exemplo ilustra como permitir ao usu rio editar um campo memo, sendo que depois estas alteracoes serao atribuidas ao campo memo:

USE Customer NEW
REPLACE CustNotes WITH MEMOEDIT(CustNotes, 5, 10, 20, 69)

* Este exemplo demonstra como criar uma cadeia de caracteres usando MEMOEDIT():

LOCAL cNotes
cNotes = MEMOEDIT()


* Este exemplo demonstra uma funcao definida pelo usuario que edita uma cadeia de caracteres em uma janela com moldura exibida com um t¡tulo:

FUNCTION MemoEdit( cString, cT¡tulo, nTop, nLeft, nBottom, nRight )
LOCAL cTela := SAVESCREEN(nTop, nLeft, nBottom, nRight)
@ nTop - 1, nLeft - 2 CLEAR TO nBottom + 1, nRight + 2
@ nTop - 1, nLeft - 2 TO nBottom + 1, nRight + 2
@ nTop - 1, nLeft SAY "[" + cTitle + "]"
cString = MEMOEDIT(cString, nTop, nLeft, nBottom, nRight)
RESTSCREEN(nTop, nLeft, nBottom, nRight, cTela)
RETURN (cString)

* O exemplo a seguir le o conte£do de um arquivo texto para uma variavel caractere, edita, e depois escreve o novo conteudo no disco:

LOCAL cString := MEMOREAD("Text.txt")
cString := MEMOEDIT(cString)
IF !MEMOWRIT("Text.txt", cString)
? "Erro de gravacao"
BREAK
ENDIF
RETURN

Arquivos: Biblioteca EXTEND.LIB, arquivos header Memoedit.ch, Inkey.ch.

Pessoal não estou conseguindo gravar campo memo e nem visualizar um que esteja gravado
Segue a rotina abaixo: O que tem de errado?

Obrigado

veja como usar o memoedit em:

https://pctoledo.org/forum/viewtopic.php?t=4708

Caro gvc,

Que mal lhe pergunte, onde você conseguiu todo este volume de informações? Tem algum manual ou algo do tipo? Eu até tenho alguns livros aqui, mas no PC não tenho toda esta documentação, só em NG... Aliás isso é NG descompilado?

Se você tiver algo teria como você me enviar?

Obrigado.

Isto é o help existente no NG mesmo uai.

Desculpem.
É o próprio NG.
Achei que não valia a pena reinventar a roda.
Já tem boa parte da explicação que o nosso amigo necessita.
O NG do 5.2e é mais completo, só que em inglês.
Veja nos download´s. Se não tiver, mande um e-mail, que eu mando-lhe todos os NG que eu tenho aqui.

Quanto ao PITERGALDIANO, gostaria de saber se a postagem ajudou a solucionar o problema.