Alinhar GET numérico à DIREITA

Mensagem por **janio** » 26 Out 2007 16:59

Pessoal,

Esse getsys.prg que estamos construindo não está levando em consideração o SET CONFIRM ON/OFF, ou seja, mesmo estando setado como SET CONFIRM OFF ele não está pulando pro próximo GET.

Eu particularmente gostaria que isso fosse controlado por esses SET's. Se SET CONFIRM estiver ON, será necessário <enter> pra prosseguir. Se SET CONFIRM estiver OFF, pula pro próximo get quando preenchido totalmente.

Jânio

clodoaldomonteiro · Mensagem por **clodoaldomonteiro** » 26 Out 2007 23:54

Jânio!

O getsys que eu alterei foi o que o Daniel postou aqui nesse tópico, se voce quiser em mando para você, pois ele tá perfeito.

Ten também o getsys da GAS que é melhor e tem todas as pictures dos outros getsys.

TerraSoftware · Mensagem por **TerraSoftware** » 27 Out 2007 08:22

Caros colegas.

Depois que este novo getsys estiver pronto, seria interessante coloca-lo na sessao de download deste forum, assim mais pessoas poderiam utilizar, visto que ele vai funcionar tanto para clipper como para (x)Harbour.

Mensagem por **janio** » 27 Out 2007 10:30

clodoaldomonteiro escreveu:Jânio!
O getsys que eu alterei foi o que o Daniel postou aqui nesse tópico, se voce quiser em mando para você, pois ele tá perfeito.

Se quero!??

manda! manda! manda! manda!

:% :% :% :% :% :% :%

Jânio

Mensagem por **asimoes** » 27 Out 2007 23:28

Clodoaldo,
Blz.

Você poderia mandar o getsys.prg que você otimizou para o meu email.
asimoesluz@gmail.com

[]´s

[
quote="clodoaldomonteiro"]Jânio!

O getsys que eu alterei foi o que o Daniel postou aqui nesse tópico, se voce quiser em mando para você, pois ele tá perfeito.

Ten também o getsys da GAS que é melhor e tem todas as pictures dos outros getsys.[/quote]

Mensagem por **asimoes** » 28 Out 2007 01:11

Alamino,

Fiz umas adaptações para o getcalc onde o usuário não precise digitar a virgula ou ponto decimal, por exemplo o valor 35,48 o getcalc que eu modifiquei já posiciona o 48 na casa decimal.

Estou disponibilizando para criticas e melhorias.

/***
* GetCalc.prg
*
* Calculator style input
*/

#include "Getexit.ch"
#include "Inkey.ch"
#include "Getcalc.ch"

PROCEDURE GetCalc( oGet )

// read the GET if the WHEN condition is satisfied
IF ( GetPreValidate(oGet) )
// activate the GET for reading
oGet:SetFocus()

// RS added this
// Start at last position
oGet:end()
// Just to here

DO WHILE ( oGet:exitState == GE_NOEXIT )
// check for initial typeout (no editable positions)
IF ( oGet:typeOut )
oGet:exitState := GE_ENTER
ENDIF

// apply keystrokes until exit
DO WHILE ( oGet:exitState == GE_NOEXIT )
GetCalcApplyKey(oGet, InKey(0))
ENDDO

// disallow exit if the VALID condition is not satisfied
IF ( !GetPostValidate(oGet) )
oGet:exitState := GE_NOEXIT
ENDIF
ENDDO
// de-activate the GET
oGet:KillFocus()
ENDIF

RETURN

/***
* GetCalcApplyKey()
* Apply a single Inkey() keystroke to a GET.
*
* NOTE: GET must have focus.
* Standard stuff. RS changed only BS and otherwise
*/

#define K_UNDO K_CTRL_U

proc GetCalcApplyKey(oGet, nKey)

local cKey
local bKeyBlock
local cTemp
local nTemp

// check for SET KEY first
IF (bKeyBlock := SetKey(nKey)) <> NIL
GetDoSetKey(bKeyBlock, oGet)
RETURN // NOTE
ENDIF

DO CASE
CASE nKey == K_UP
oGet:exitState := GE_UP

CASE nKey == K_SH_TAB
oGet:exitState := GE_UP

CASE nKey == K_DOWN
oGet:exitState := GE_DOWN

CASE nKey == K_TAB
oGet:exitState := GE_DOWN

CASE nKey == K_ENTER
oGet:exitState := GE_ENTER

CASE nKey == K_ESC
IF Set(_SET_ESCAPE)
oGet:undo()
oGet:exitState := GE_ESCAPE
ENDIF

CASE nKey == K_PGUP
oGet:exitState := GE_WRITE

CASE nKey == K_PGDN
oGet:exitState := GE_WRITE

CASE nKey == K_CTRL_HOME
oGet:exitState := GE_TOP

// both ^W and ^End terminate the READ (the default)
CASE nKey == K_CTRL_W
oGet:exitState := GE_WRITE

CASE nKey == K_UNDO
oGet:Undo()

CASE ( nKey = 32 ) // Barra de espaço para limpar o campo
IF oGet:type == "C"
cTemp := oGet:unTransform()
cTemp := ""
oGet:buffer := Transform(cTemp, oGet:picture)
ELSE
nTemp := oGet:unTransform()
nTemp := 0
oGet:buffer := Transform(nTemp, oGet:picture)
ENDIF
oGet:display()
oGet:SetFocus()
CASE nKey == K_BS .OR. nKey == K_DEL
oGet:delete()
IF oGet:type == "C"
cTemp := oGet:unTransform()
cTemp := " " + Substr(cTemp, 1, Len(cTemp) - 1)
oGet:buffer := Transform(cTemp, oGet:picture)
ELSE
nTemp := oGet:unTransform()
nLen:=LEN(LTRIM(STR(nTemp,30,2)))
cTemp := STR(nTemp,nLen,2)
cTemp := Substr(cTemp, 1, Len(cTemp)-1)
nTemp := VAL(cTemp) / 10
IF At(".", oGet:buffer) != 0
// There is a decimal point
//nTemp := nTemp / 10
ELSE
// No decimal point, division already taken place
// by deleting last character
ENDIF
oGet:buffer := Transform(nTemp, oGet:picture)
ENDIF
oGet:display()

OTHERWISE
IF (nKey >= Asc('0') .AND. nKey <= Asc('9')) .OR. ;
(nKey == Asc('.') .AND. ;
oGet:type == "C" .AND. At(".", oGet:buffer) == 0)

cKey := Chr(nKey)
IF oGet:type == "C"
cTemp := oGet:unTransform()
cTemp := SubStr(cTemp, 2) + " "
oGet:buffer := Transform(cTemp, oGet:picture)
ELSE
nTemp := oGet:unTransform()
nTemp := nTemp * 10
oGet:buffer := Transform(nTemp, oGet:picture)
ENDIF
// NOTE - important to use OverStrike here to set changed
// Alternative is to stuff key yourself. However, that does
// not set changed, therefore var is not updated.
oGet:overStrike(cKey)
oGet:end()
oGet:display()
ENDIF
ENDCASE

RETURN

alaminojunior escreveu:Desculpem a pequena demora, mas ta aí a danada ( a rotina e o header ), foi o Rick Spence quem escreveu.

Código: Selecionar todos

/***
* GetCalc.prg
*
* Calculator style input
*/

#include "Getexit.ch"
#include "Inkey.ch"
#include "Getcalc.ch"

FUNCTION GetCalcTest

LOCAL nVar1 := 0,  ;
      nVar2 := 0,  ;
      cVar2 := Space(12), ;
      nVar3 := 0

LOCAL GetList := {}

  CLEAR SCREEN
  @ 10, 10 SAY "Enter nVar1" GET nVar1 CALC
  @ 11, 10 SAY "Enter nVar2" GET nVar2 CALC
  @ 12, 10 SAY "Enter cVar2" GET cVar2 CALC
  @ 13, 10 SAY "Enter nVar3" GET nVar3

  READ

RETURN NIL


proc GetCalc( oGet )

  // read the GET if the WHEN condition is satisfied
  IF ( GetPreValidate(oGet) )
    // activate the GET for reading
    oGet:SetFocus()

    // RS added this
    // Start at last position
    oGet:end()
    // Just to here

    DO WHILE ( oGet:exitState == GE_NOEXIT )
      // check for initial typeout (no editable positions)
      IF ( oGet:typeOut )
        oGet:exitState := GE_ENTER
      ENDIF

      // apply keystrokes until exit
      DO WHILE ( oGet:exitState == GE_NOEXIT )
        GetCalcApplyKey(oGet, InKey(0))
      ENDDO

      // disallow exit if the VALID condition is not satisfied
      IF ( !GetPostValidate(oGet) )
        oGet:exitState := GE_NOEXIT
      ENDIF
    ENDDO
    // de-activate the GET
    oGet:KillFocus()
  ENDIF

RETURN


/***
* GetCalcApplyKey()
* Apply a single Inkey() keystroke to a GET.
*
* NOTE: GET must have focus.
* Standard stuff. RS changed only BS and otherwise
*/

#define K_UNDO          K_CTRL_U

proc GetCalcApplyKey(oGet, nKey)

local cKey
local bKeyBlock
local cTemp
local nTemp

  // check for SET KEY first
  IF (bKeyBlock := SetKey(nKey)) <> NIL
    GetDoSetKey(bKeyBlock, oGet)
    RETURN                              // NOTE
  ENDIF

  DO CASE
    CASE nKey == K_UP
      oGet:exitState := GE_UP

    CASE nKey == K_SH_TAB
      oGet:exitState := GE_UP

    CASE nKey == K_DOWN
      oGet:exitState := GE_DOWN

    CASE nKey == K_TAB
      oGet:exitState := GE_DOWN

    CASE nKey == K_ENTER
      oGet:exitState := GE_ENTER

    CASE nKey == K_ESC
      IF Set(_SET_ESCAPE)
        oGet:undo()
        oGet:exitState := GE_ESCAPE
      ENDIF

    CASE nKey == K_PGUP
      oGet:exitState := GE_WRITE

    CASE nKey == K_PGDN
      oGet:exitState := GE_WRITE

    CASE nKey == K_CTRL_HOME
      oGet:exitState := GE_TOP

    // both ^W and ^End terminate the READ (the default)
    CASE nKey == K_CTRL_W
      oGet:exitState := GE_WRITE

    CASE nKey == K_UNDO
      oGet:Undo()

    CASE nKey == K_BS .OR. nKey == K_DEL
      oGet:delete()
      IF oGet:type == "C"
        cTemp := oGet:unTransform()
        cTemp := " " + Substr(cTemp, 1, Len(cTemp) - 1)
        oGet:buffer := Transform(cTemp, oGet:picture)
      ELSE
        nTemp := oGet:unTransform()
        IF At(".", oGet:buffer) != 0
          // There is a decimal point
          nTemp := nTemp / 10
        ELSE
          // No decimal point, division already taken place
          // by deleting last character
        ENDIF
        oGet:buffer := Transform(nTemp, oGet:picture)
      ENDIF
      oGet:display()

    OTHERWISE
      IF (nKey >= Asc('0') .AND. nKey <= Asc('9')) .OR. ;
          (nKey == Asc('.') .AND. ;
           oGet:type == "C" .AND. At(".", oGet:buffer) == 0)

        cKey := Chr(nKey)
        IF oGet:type == "C"
          cTemp := oGet:unTransform()
          cTemp := SubStr(cTemp, 2) + " "
          oGet:buffer := Transform(cTemp, oGet:picture)
        ELSE
          nTemp := oGet:unTransform()
          nTemp := nTemp * 10
          oGet:buffer := Transform(nTemp, oGet:picture)
        ENDIF
        // NOTE - important to use OverStrike here to set changed
        // Alternative is to stuff key yourself. However, that does
        // not set changed, therefore var is not updated.
        oGet:overStrike(cKey)
        oGet:end()
        oGet:display()
    ENDIF
  ENDCASE

RETURN

Código: Selecionar todos

/***
* Getcalc.ch
*
* Definition of GET CALCULATOR command.
*/

#command @ <row>, <col> GET <var>                             ;
                        [<clauses,...>]                       ;
                        CALCULATOR                            ;
                        [<moreClauses,...>]                   ;
                                                              ;
      => @ <row>, <col> GET <var>                             ;
                        [<clauses>]                           ;
                        SEND reader := {|oGet|                ;
                                        GetCalc(oGet) }       ;
                        [<moreClauses>]

Mensagem por **janio** » 29 Out 2007 09:35

Clodoaldo,

O seu getsys tá idêntico ao meu. E continua com o mesmo problema que relatei: Ele não tá pulando para o próximo get quando preenchido totalmente, isso em campos/variáveis NUMERICAS, pois em campos/variáveis CARACTERE tá sendo (como deve ser) obedecido o SET CONFIRM ON/OFF.

Jânio

clodoaldomonteiro · Mensagem por **clodoaldomonteiro** » 29 Out 2007 11:47

Janio!

Se quiser eu mando por email para você, pois aqui tá funcionando muito bem.

Teve um problema, se usar valid no get de senha e eu só consegui corrigir no getsys da GAS que é melhor e pode muito bem ser usado com qualquer sistema clipper.
Posso mandar prá você também.

Mensagem por **janio** » 02 Nov 2007 18:21

Clodoaldo,

O problema a que estou me referindo ocorre somente com variáveis NUMÉRICAS sem CASAS DECIMAIS.

Quando há casas decimais ele tá pulando para o próximo get quando preenchido totalmente, mas quando não tem casas decimais não pula.

Jânio

clodoaldomonteiro · Mensagem por **clodoaldomonteiro** » 02 Nov 2007 23:34

Janio!

A deficiência do getsys está nessa parte do código:

Código: Selecionar todos

IF ( oGet:typeOut )
   IF ( SET( _SET_BELL ) )
      ?? CHR(7)
   ENDIF

   IF ( !SET( _SET_CONFIRM ) )
      oGet:exitState := GE_ENTER
   ENDIF
ENDIF

... só num tô conseguindo fazer com que os gets numéricos sem casa decimal entrem aqui.

Mensagem por **janio** » 05 Nov 2007 15:32

Clodoaldo,

Fiz uma modificação na função GetApplyKey e FUNCIONOU como eu queria, veja:

Código: Selecionar todos

   ...
   ...
   OTHERWISE

      IF ( nKey >= 32 .AND. nKey <= 255 )

         cKey := CHR( nKey )

         IF !EMPTY(oGet:picture)
           IF AT("@M",oGet:picture)>0
             cKey := LOWER( cKey )
           ENDIF
         ENDIF

         IF ( oGet:type == "N" .AND. ( cKey == "." .OR. cKey == "," ) )
            oGet:toDecPos()
         ELSE

            IF ( oGet:type != "N" )

               IF ( SET( _SET_INSERT ) )
                  oGet:insert( cKey )
               ELSE
                  oGet:overstrike( cKey )
               ENDIF

            ELSE

               IF !Empty(cKey)

                  IF ( nKey < 48 .OR. nKey > 57 )
                     *
                     IF nKey <> 45
                        *
                        RETURN
                        *
                      ELSEIF Val( oGet:Buffer ) <> 0
                        *
                        RETURN
                        *
                     ENDIF
                     *
                   ENDIF
                  *
                  IF Len(oGet:buffer) > oGet:DecPos .And. oGet:pos < oGet:DecPos

                     valor  := oGet:buffer

                     If Len(Ltrim(valor)) < Len(original)

                        valor  := Substr(valor,2,oGet:Pos-1)
                        valor  := If( Val(valor) == 0 .AND. !("-"$valor),Substr(valor,1,Len(valor)-1)+' ',valor)
                        valor  += ' ' + Substr(oGet:buffer,oGet:DecPos,Len(oGet:buffer))

                     Endif

                     If !Len(valor) > Len(original)

                        oGet:buffer := valor

                     Endif

                     oGet:display()

                     IF Empty(SubStr(oGet:Buffer,oGet:pos,1))
                        oGet:overstrike(cKey)
                        oGet:left()
                     Else
                        ? Chr(7)
                     Endif

                     MostraValor(oGet)

                  ELSE

                     IF ( oGet:DecPos > Len( oGet:buffer )  )

                        valor  := oGet:buffer

                        If Len(Ltrim(valor)) < Len(original)
                           valor  := Substr(valor,2,oGet:Pos)
                           valor  := If(Val(valor) = 0,Substr(valor,1,Len(valor)-1)+' ',valor)
                           valor  += ' '
                        Endif

                        If !Len(valor) > Len(original)
                           oGet:buffer := valor
                        Endif

                        oGet:display()

                        oGet:overstrike(cKey)

                        MostraValor(oGet)

                        oGet:Pos := Len( oGet:buffer ) + 1
                        oGet:End()
                        
		                  ////////////////////////////////////////////////////
		                  ////////////////////////////////////////////////////
		                  // janio
		                  // ir para o prox. GET qndo preenchdo totalmente
			               If ( !SET( _SET_CONFIRM ) )
									If Len(Ltrim(valor)) = Len(original)
                              Keyboard Chr(13)
                  			Endif
                  		Endif

		                  ////////////////////////////////////////////////////
		                  ////////////////////////////////////////////////////

                     ELSE

                        oGet:overstrike(cKey)

                     ENDIF

                  ENDIF
                  
               ENDIF

            ENDIF

            IF ( oGet:typeOut )
               IF ( SET( _SET_BELL ) )
                  ?? CHR(7)
               ENDIF

               IF ( !SET( _SET_CONFIRM ) )
                  oGet:exitState := GE_ENTER
               ENDIF            
            ENDIF

         ENDIF

      ENDIF

   ENDCASE

Mensagem por **janio** » 05 Nov 2007 16:00

Só falta agora incluirmos um TEMPORIZADOR para get's, não acham??

Jânio

Mensagem por **fladimir** » 27 Jan 2008 01:15

Olá Colegas... Eu peguei o GetSys inicial do tópico e compilei e linkei junto com meu software rodou blz qto a relação do alinhamento só q ta esquisito numa questão exemplo:

Código: Selecionar todos

Proc Main
cls
x:=0
@ 15,10 say "Teste...:" get x Pict "@E 99.99%"
read

Meu sistema tem muitas e muitas linhas com a máscara "@E 99.99%"

E se vcs compilarem e linkarem com o GetSys postado no iníco do tópico, digitem por exemplo 25 (como se fosse 25%) vcs verão que ao pressionar ENTER vai ficar 5,00%. Será que tenho que fazer mais alguma coisa....

Outra coisa qdo vc começa a digitar ele fica 0,000 (3 casas decimais) mas ao pressionar ENTER retorna para conforme a máscara 2 casas decimais, mas independente do valor inteiro ele corta o primeiro digito...

Só que se vc digitar 49,58% fica 49,58%. Aparentemente o problema ocorre qdo NÃO é utilizada a vírgula. Tô perdido.... não sei por onde começar.

Testei tirando da máscara o Símbolo de Percentual deixando a máscara assim: "@E 99.99" aí ele funciona, mas tenho muitas e muitas linhas de código com essa máscara sem contar q tenho outros prgs para outros tipos de segmentos do mercado então acredito q a melhor solução seria corrigir... ou implementar... no GETSYS algo q pudesse corrigir tal questão, mas como tentei e não consegui, resolvi apelar para os colegas que já tem mais horas de Vôo no GETSYS.

Grato

Fladimir

:)Pos

Mensagem por **Maligno** » 27 Jan 2008 06:53

fladimir escreveu:[Testei tirando da máscara o Símbolo de Percentual deixando a máscara assim: "@E 99.99" aí ele funciona, mas tenho muitas e muitas linhas de código com essa máscara

Parece certo pensar, então, que o problema está nesse símbolo %. Eu também tenho muita utilidade pra ele, em vários programas. Coloco cada % em um "SAY" separado. A solução realmente é alterar o GETSYS para quando for encontrado um "@E" com % já contar quantos dígitos o número tem e imprimir o % automaticamente no final do número e, claro, em seguida eliminar o % da máscara.

Mensagem por **fladimir** » 28 Jan 2008 01:12

Realmente Maligno pelo que analisei do simples exemplo que coloquei realmente o mais prático e vamos dizer assim o "X" da questão mora no GETSYS.PRG, só que dei uma olhada mas acredito que vou levar muito, mas muito tempo para resolver tal problema e como aki no fórum já tem alguns colegas EXPERT´s no GETSYS, pensei em recorrer aos mesmos....

Se algum desses colegas se canditar a resolver este problema se acharem que é algo que não venha tomar muito tempo dos colegas, agradecemos.

Grato

Fladimir

:)Pos