{--------------------------------------------------------}
{
{   Leitor de textos VOX
{
{   Autor:  Jose' Antonio Borges
{
{   Em 24/12/94
{
{--------------------------------------------------------}

{$M 16384,8192}
Program leVox;

Uses
    dvCrt, dvWin, dvWav, dvLenum, dvhora, strings, winprocs, wintypes;

const
    versao = '1.4';
    graveiVoz = true;

var
    processando: boolean;
    nomeArqLeit: string;
    posArq, tamArq: longint;
    arqLeit: file of char;
    clekFimLinha, pontuando: boolean;
    linhaAtual: integer;

    ecoando, parado, jaLido: boolean;
    ultLido: char;
    ultBusca: string;
    velocFala: integer;

{--------------------------------------------------------}
{                    constantes do teclado
{--------------------------------------------------------}

const
    F1    = #59;
    F2    = #60;
    F3    = #61;
    F4    = #62;
    F5    = #63;
    F6    = #64;
    F7    = #65;
    F8    = #66;
    F9    = #67;
    F10   = #68;

    INS   = #82;
    DEL   = #83;
    HOME  = #71;
    TEND  = #79;
    PGUP  = #73;
    PGDN  = #81;
    CIMA  = #72;
    BAIX  = #80;
    ESQ   = #75;
    DIR   = #77;

    CTLPGUP = #132;
    CTLPGDN = #118;
    CTLESQ  = #115;
    CTLDIR  = #116;

    CTLF1   =  #94;
    CTLF2   =  #95;
    CTLF4   =  #97;
    CTLF5   =  #98;
    CTLF9   =  #102;
    CTLF10  =  #103;

    CTLENTER = #10;

const
    NUMEROS: set of char = ['0'..'9'];
    CONTROL: set of char = [#$0..#$19];

var
    ALFA: set of char;

{--------------------------------------------------------}
{                  tratamento de mensagens
{--------------------------------------------------------}

const
    LVSEMTRD = 0;
    LVLEITOR = 1;
    LVFIM    = 2;
    LVERR    = 3;
    LVCOMFIM = 4;
    LVDIGNOM = 5;
    LVNAOEXI = 6;
    LVVOLTA  = 7;
    LVERRLEI = 8;
    LVPROCAN = 9;
    LVDESIS  = 10;
    LVTECF1  = 11;
    LVPLIM   = 12;
    LVOK     = 18;
    LVFIMARQ = 19;
    LVQAVAN  = 20;

    LVVELOC  = 21;
    LVINIPAR = 22;
    LVFIMPAR = 23;
    LVINITXT = 24;
    LVFIMTXT = 25;
    LVPARAM  = 26;
    LVCLKFIM = 27;
    LVPONTUA = 28;

    LVPROC   = 30;
    LVCONTIN = 31;
    LVOPBUSC = 32;
    LVACH    = 33;
    LVNACH   = 34;

    LVMRKIN  = 35;
    LVMRKOP  = 36;
    LVLINHA  = 37;

    LVAJUDA1 = 60;
    LVAJUDA2 = 61;
    LVAJUDA3 = 62;
    LVAJUDA5 = 63;
    LVAJUDA6 = 64;
    LVAJUDA7 = 65;
    LVAJUDA9 = 66;
    LVAJUD10 = 67;
    LVAJUDAn = LVAJUD10;


procedure mensagem (n, nlf: integer);
var
    s, nomearq: string;
    fonemas: string;
    i: integer;
begin
    case n of

    LVSEMTRD:  s := 'LVSEMTRD|Erro no diretorio do tradutor';
    LVLEITOR:  s := 'LVLEITOR@Leitor VOX - versão ';
    LVFIM   :  s := 'LVFIM   |Fim de leitura';
    LVERR   :  s := 'LVERR   |Opção errada.  ';
    LVCOMFIM:  s := 'LVCOMFIM|Confirma fim (s/n)? ';
    LVDIGNOM:  s := 'LVDIGNOM|Nome do arquivo: ';
    LVNAOEXI:  s := 'LVNAOEXI|Arquivo não existe';
    LVVOLTA :  s := 'LVVOLTA |Voltei ao texto que estava lendo';
    LVERRLEI:  s := 'LVERRLEI|Erro de leitura do arquivo';
    LVPROCAN:  s := 'LVPROCAN|Programa foi cancelado';
    LVDESIS :  s := 'LVDESIS |Desistiu';
    LVTECF1 :  s := 'LVTECF1 |Tecle F1 para ajuda';
    LVPLIM  :  s := 'LVPLIM  |';

    LVOK    :  s := 'LVOK    |OK';
    LVFIMARQ:  s := 'LVFIMARQ|Fim de arquivo';
    LVQAVAN :  s := 'LVQAVAN |Quantas linha avan‡o ?';

    LVINITXT:  s := 'LVINIPAR|Voltei ao início do texto';
    LVFIMTXT:  s := 'LVFIMPAR|Avancei para o fim do texto';

    LVVELOC :  s := 'LVVELOC |Qual a velocidade, de 1 a 4 ? ';
    LVPARAM :  s := 'LVPARAM |Modificando modo de fala.';
    LVCLKFIM:  s := 'LVCLKFIM|Poe clek ao fim da linha ? ';
    LVPONTUA:  s := 'LVPONTUA|Falo a pontuacao ? ';

    LVPROC  :  s := 'LVPROC  |Qual o texto a buscar ? ';
    LVCONTIN:  s := 'LVCONTIN@(O mesmo texto)';
    LVOPBUSC:  s := 'LVOPBUSC|Todo texto (T) ou proxima (P) ? ';
    LVACH   :  s := 'LVACH   |Achei';
    LVNACH  :  s := 'LVNACH  |Nao encontrei';
    LVLINHA :  s := 'LVLINHA |Linha ';

    LVAJUDA1:  s := 'LVAJUDA1|Use setas e controles para andar no texto';
    LVAJUDA2:  s := 'LVAJUDA2|Enter ou espaço continuam a leitura.     ';
    LVAJUDA3:  s := 'LVAJUDA3|F1  - ajuda                              ';
    LVAJUDA5:  s := 'LVAJUDA5|F3  - troca de arquivo                   ';
    LVAJUDA6:  s := 'LVAJUDA6|F4  - altera os parametros de sintese    ';
    LVAJUDA7:  s := 'LVAJUDA7|F5  - procura um texto                   ';
    LVAJUDA9:  s := 'LVAJUDA9|F7  - avanca varias linhas               ';
    LVAJUD10:  s := 'LVAJUD10|ESC - termina leitura                    ';

    end;

    nomearq := copy (s, 1, 8);
    while nomearq[length(nomearq)] = ' ' do
        nomearq := copy (nomearq, 1, length(nomearq)-1);

    if s[9] <> '@' then
        textBackground (BLUE);

    s := copy (s, 10, length (s)-9);

    write (s);
    textBackground (BLACK);

    for i := 1 to nlf do
        writeln;

    if graveiVoz then
        sintSom (nomearq)
    else
        sintetiza (s);
end;

{--------------------------------------------------------}
{                    abre arquivo
{--------------------------------------------------------}

const 
    NOVO     = 0;
    PEDENOME = 1;
    REABRE   = 2;

function abreArquivo (opcao: integer): boolean;
var
    c: char;

begin
    jaLido := false;

    nomeArqLeit := '';
    if (paramCount = 0) or (opcao = PEDENOME) then
        begin
            mensagem (LVDIGNOM, 0);
            sintReadln (nomeArqLeit);

            if (c = #$1b) or (nomeArqLeit = '') then
                begin
                    writeln;
                    mensagem (LVDESIS, 1);
                    abreArquivo := false;
                    exit;
                end;

            writeln;
        end
    else
        nomeArqLeit := paramStr(1);

    assign (arqleit, nomeArqLeit);
    {$I-} reset (arqleit); {$I+}
    if ioresult <> 0 then
        begin
            mensagem (LVNAOEXI, 1);
            abreArquivo := false;
        end
    else
        begin
            tamArq := fileSize (arqLeit);
            abreArquivo := true;
            linhaAtual := 1;
        end;
end;

{--------------------------------------------------------}
{                   pede arquivo novo
{--------------------------------------------------------}

procedure arquivoNovo;
var
    salva: string;
begin
    salva := nomeArqLeit;
    close (arqLeit);

    if not abreArquivo (PEDENOME) then
        begin
            mensagem (LVVOLTA, 1);
            nomeArqLeit := salva;
            if not abreArquivo (REABRE) then
                begin
                    mensagem (LVERRLEI, 1);
                    mensagem (LVPROCAN, 1);
                    delay (1000);
                    sintFim;
                    doneWinCrt;
                end;
        end
    else
        begin
            posArq := 0;
            linhaAtual := 1;
        end;
end;

{--------------------------------------------------------}
{                    inicializacao
{--------------------------------------------------------}

procedure inicializa;
var s: string;
    erro: integer;
    dir: string;
begin
    maxBufWaves := 2;    {controle grande sobre exibição na tela}
    dir := sintAmbiente ('LEVOX', 'DIRLEVOX');
    s := sintAmbiente   ('LEVOX', 'VELOCIDADE');
    if s = '' then
        velocFala := 0
    else
        val (s, velocFala, erro);

    sintInic (velocFala, dir);

    textBackground (BLACK);
    clrscr;
    textBackground (BLUE);
    writeln ('**      ******   **   **   *****   **   **');
    writeln ('**      **       **   **  **   **   ** ** ');
    writeln ('**      **       **   **  **   **    ***  ');
    writeln ('**      ****     **   **  **   **     *   ');
    writeln ('**      **        ** **   **   **    ***  ');
    writeln ('**      **         ***    **   **   ** ** ');
    writeln ('******  ******      *      *****   **   **');
    textBackground (BLACK);
    writeln;

    setWindowText (crtWindow, 'LEVOX');

    mensagem (LVLEITOR, 0);   { Leitor Vox }
    writeln (versao);
    writeln;
    while sintFalando do;

    if not abreArquivo (NOVO) then
        begin
            mensagem (LVPROCAN, 2);
            sintFim;
            doneWinCrt;
        end;

    writeln;
    ALFA := ['A'..'Z'] + ['a'..'z'] + [#128..#255];

    posArq := 0;
    pontuando := false;
    ecoando := true;
    clekFimLinha := true;
    ultBusca := '';

    linhaAtual := 1;
end;

{--------------------------------------------------------}
{                  opcao de fim do DOSVOX
{--------------------------------------------------------}

procedure fimLeVOX;
var c, c2: char;
begin
    close (arqLeit);
    mensagem (LVFIM, 2);
    sintFim;
end;

{--------------------------------------------------------}
{               modifica parametros da sintese
{--------------------------------------------------------}

procedure paramSintese;
var erro: integer;
    s: string;
    c: char;
    dir: string;

label 1, 2, 3, fim;

begin
    writeln;
    mensagem (LVPARAM, 1);   { modificando modo de fala }

    mensagem (LVCLKFIM, 0);  { Poe cleck ao fim da linha ? }
    c := readkey;
    if c = #$1b then goto fim;
    write (c); sintCarac (c);
    clekFimLinha := upcase(c) = 'S';

    writeln;
    mensagem (LVPONTUA, 0);  { Fala pontuacao ? }
    c := readkey;
    if c = #$1b then goto fim;
    write (c); sintCarac (c);
    pontuando := upcase(c) = 'S';

    writeln;
    mensagem (LVVELOC, 0);  { Qual a velocidade de 1 a 4 ? }
    c := sintReadkey;
    velocFala := ord(c) and $f;
    if (velocFala < 1) or (velocFala > 5) then
        velocFala := 2;

    sintFim;
    dir := sintAmbiente ('LEVOX', 'DIRLEVOX');
    sintInic (velocFala, dir);

fim:
    writeln;
    mensagem (LVOK, 1);
end;

{--------------------------------------------------------}
{                    leitura de caracteres
{--------------------------------------------------------}

procedure desleCarac (c: char);
begin
    jaLido := true;
    ultLido := c;
end;

function leCarac: char;
var c: char;
begin
    if jaLido then
        begin
            lecarac := ultLido;
            jaLido := false;
        end
    else
        begin
            if posArq < 0 then
                begin
                    posArq := 0;
                    linhaAtual := 1;
                    seek (arqleit, 0);
                end;
 
            if posArq >= tamArq then
                c := ' '
            else
                begin
                    read (arqleit, c);
                    posArq := posArq + 1;
                    if ecoando then
                        write (c);
                end;
            leCarac := c;
        end;
end;

{--------------------------------------------------------}
{                recua ate' certo caractere
{--------------------------------------------------------}

procedure recua (c: char);
var c2: char;
begin
    repeat
        if posArq <= 0 then
            begin
                posarq := 0;
                seek (arqLeit, 0);
                linhaAtual := 1;
                writeln;
                mensagem (LVINITXT, 1);
                exit;
            end;

        posArq := posArq - 1;
        seek (arqLeit, posArq);
        read (arqLeit, c2);
        if c2 = #$0a then
            linhaAtual := linhaAtual - 1;
        seek (arqLeit, posArq);
    until c = c2;

    write (#13); clreol;
end;

{--------------------------------------------------------}
{                 avanca ate certo caractere
{--------------------------------------------------------}

procedure avanca (c: char);
var cc: char;
begin
    if posArq >= TamArq then
        mensagem (LVFIMTXT, 1)
    else
        begin
            repeat
                 cc := leCarac;
                 if cc = #$0a then
                     linhaAtual := linhaAtual + 1;
            until (cc = c) or (posArq >= TamArq);

            if posArq >= TamArq then
                begin
                    writeln;
                    mensagem (LVFIMTXT, 1);
                end;
        end;
end;

{--------------------------------------------------------}
{                volta um caractere
{--------------------------------------------------------}

procedure voltaCarac (falando: boolean);
var c: char;
begin
    if not parado then writeln;

    if posarq <= 0 then
        mensagem (LVINITXT, 1)
    else
       begin
           posArq := posArq - 1;
           seek (arqLeit, posArq);
           read (arqLeit, c);
           if c = #$0a then
               linhaAtual := linhaAtual - 1;

           sintCarac (c);
           seek (arqLeit, posArq);
       end;
end;

{--------------------------------------------------------}
{                avanca um caractere
{--------------------------------------------------------}

procedure avancaCarac;
var c: char;
begin
    if posarq >= tamArq then
        mensagem (LVFIMTXT, 1)
    else
       begin
           c := leCarac;
           sintCarac (c);
           if c = #$0a then
               linhaAtual := linhaAtual + 1;
       end;
end;

{--------------------------------------------------------}
{               inicio ou fim da frase
{--------------------------------------------------------}

procedure inicioFrase;
begin
    sintClek;
    recua ('.');
end;

{--------------------------------------------------------}

procedure fimFrase;
begin
    sintClek;
    avanca ('.');
end;

{--------------------------------------------------------}
{                 sobe ou desce uma linha
{--------------------------------------------------------}

procedure sobeLinha;
var c: char;
begin
    sintClek;
    recua (#$0a);
end;

{--------------------------------------------------------}

procedure desceLinha;
begin
    avanca (#$0a);
end;

{--------------------------------------------------------}
{                 inicio ou fim do texto
{--------------------------------------------------------}

procedure inicioTexto;
var c: char;
begin
    posArq := 0;
    recua (#$0a);
    while keypressed do c := readkey;
    linhaAtual := 1;
end;

{--------------------------------------------------------}

procedure fimTexto;
var c: char;
    salva: boolean;
begin
    salva := ecoando;
    ecoando := false;
    avanca (#$ff);
    ecoando := salva;
    while keypressed do c := readkey;
end;

{--------------------------------------------------------}
{              volta ao inicio do paragrafo
{--------------------------------------------------------}

procedure inicioParagrafo;
var
    pos1, pos2: longint;
begin
    posarq := posarq - 2;
    if posarq < 0 then posarq := 0;

    pos1 := posarq;
    repeat
        pos2 := pos1;
        recua (#$0a);
        pos1 := posArq;
        if posArq = 0 then exit;
    until pos2 - pos1 <= 2;
end;

{--------------------------------------------------------}
{                    vai ao fim do paragrafo
{--------------------------------------------------------}

procedure fimParagrafo;
var 
    pos1, pos2: longint;
begin
    pos2 := posarq+2;
    repeat
        pos1 := pos2;
        avanca (#$0a);
        pos2 := posArq;
        if pos2 >= tamarq then exit;
    until pos2 - pos1 <= 2;
end;

{--------------------------------------------------------}
{                  volta ao ultimo branco
{--------------------------------------------------------}

procedure voltaPalavra;
begin
    voltaCarac (false);
    if posArq <> 0 then
        recua (' ');
end;

{--------------------------------------------------------}
{                    avanca linhas
{--------------------------------------------------------}

procedure avancaLinhas;
var 
    s: string;
    c: char;
    i, navan: longint;
    erro: integer;

label fim;

begin
    writeln;
    mensagem (LVQAVAN, 0);
    sintReadln (s);
    if s = '' then
        exit;
    writeln;

    val (s, navan, erro);
    if erro <> 0 then navan := 0;

    ecoando := false;
    for i := 1 to navan do
         begin
             repeat
                 c := lecarac;
                 if posArq >= tamArq then
                     begin
                         mensagem (LVFIMTXT, 1);
                         goto fim;
                     end;
             until c = #$0a;
             linhaAtual := linhaAtual + 1;
         end;
    mensagem (LVOK, 1);
fim:
    ecoando := true;
end;

{--------------------------------------------------------}
{                   procura um texto
{--------------------------------------------------------}

procedure procuraTexto;
var 
    s, lido: string;
    c, opcao: char;
    i, salvaPos, salvaLinha: longint;
    achou: boolean;

label fim;

begin
    salvaPos := posArq;
    salvaLinha := linhaAtual;

    writeln;
    mensagem (LVPROC, 0);
    sintReadln (s);
    if s = '' then
        exit;

    if s = '' then
        begin
             s := ultBusca;
             mensagem (LVCONTIN, 1);
             opcao := 'P';
        end
    else
        begin
            writeln;
            mensagem (LVOPBUSC, 0);
            c := readkey;
            if c = #$1b then goto fim;
            sintCarac (c);
            opcao := upcase(c);
        end;

    ultBusca := s;
    writeln;

    for i := 1 to length (s) do
        s[i] := upcase(s[i]);

    if opcao <> 'P' then
        begin
            seek (arqLeit, 0);
            posArq := 0;
            linhaAtual := 0;
        end;

    lido := '';
    achou := false;

    ecoando := false;
    repeat
         c := leCarac;
         if c = #$0a then
             linhaAtual := linhaAtual + 1;

         lido := lido + upcase(c);
         if length(lido) > length(s) then
             delete (lido, 1, 1);
         achou := lido = s;
    until (posArq >= tamArq) or achou;
    ecoando := true;

    if achou then
        begin
            for i := 1 to length(s) do
                voltaCarac (false);
            mensagem (LVACH, 1);
        end
    else
        begin
            mensagem (LVNACH, 1);
            posArq := salvaPos;
            linhaAtual := salvaLinha;
            seek (arqLeit, posArq);
        end;

fim:
end;

{--------------------------------------------------------}
{                        ajuda
{--------------------------------------------------------}

procedure ajuda;
var
    i: integer;
    c: char;

label fim;

begin
    writeln;
    for i := LVAJUDA1 to LVAJUDAn do
        begin
            mensagem (i, 1);
            if keypressed then goto fim;
        end;

fim:
    while keypressed do c := readkey;
end;

{--------------------------------------------------------}
{              pega proxima palavra no texto
{--------------------------------------------------------}

function pegaTrecho: string;
var s: string;
    c: char;


    procedure pegaLetras;
    begin
        s := c;
        c := leCarac;
        while (c in ALFA) or (c = '-') or (c = ' ') or
              ((c = ',') and (not pontuando)) do
            begin
                if c = '-' then
                    s := s + ' '
                else
                    s := s + c;
                c := leCarac;
            end;

        if c = #$0d then c := lecarac;

        if c <> ' ' then
            desleCarac (c);
    end;

{--------------------------------------------------------}

    procedure pegaNumero;
    var v, salvapos: longint;
        erro: integer;
        s2: string;
    begin
        s := c;
        c := leCarac;
        while c in ['0'..'9'] do
            begin
                s := s + c;
                c := leCarac;
            end;

        if (c = '.') and not pontuando then
           begin
               c := leCarac;
               if c in ['0'..'9'] then
                   s := s + ' . ';
               desleCarac (c);
           end
        else
        if (c = ',') and not pontuando then
           begin
               c := leCarac;
               if c in ['0'..'9'] then
                   s := s + ' , ';
               desleCarac (c);
           end
        else
        if c <> ' ' then
            desleCarac (c);
    end;

{--------------------------------------------------------}

    procedure trataControles;
    var i, espera: integer;
    begin
        s := ' ';
        case c of
            #$09: sintBip;

            #$0c: for i := 0 to 4 do
                      sintclek;

            #$0a:
                begin
                    linhaAtual := linhaAtual + 1;
                    if clekFimLinha then sintClek;
                    espera := 0;
                    repeat
                        c := leCarac;
                        if c = #$0a then 
                            begin
                                linhaAtual := linhaAtual + 1;
                                if clekFimLinha then sintClek;
                                espera := espera + 1;
                            end;

                    until not (c in [#$0d, #$0a]);
                    desleCarac (c);

                    if espera > 0 then
                        delay (200);
                end;
        end;
    end;

{--------------------------------------------------------}

begin
    s := '';

    c := leCarac;

    if c in NUMEROS then pegaNumero
    else
    if c in ALFA    then pegaLetras
    else
    if c in CONTROL then trataControles
    else
        s := c;

    pegaTrecho := s;
end;

{--------------------------------------------------------}
{                    trata os comandos
{--------------------------------------------------------}

procedure nada;
begin
    mensagem (LVERR, 0);
    mensagem (LVTECF1, 1);
end;

{--------------------------------------------------------}

procedure comandos (c: char);
begin
    case c of
        CTLF1: parado := false;

        F1   : ajuda;
        F2   : nada;
        F3   : arquivoNovo;
        F4   : paramSintese;
        F5   : procuraTexto;
        F6   : nada;
        F7   : avancaLinhas;
        F8   : falaHora;
        F9   : nada;
        F10  : nada;

        HOME : inicioFrase;
        TEND : fimFrase;
        PGUP : inicioParagrafo;
        PGDN : begin
                   sintBip;
                   fimParagrafo;
                   parado := false;
               end;
        CIMA : sobeLinha;
        BAIX : begin
                   desceLinha;
                   parado := false;
               end;
        ESQ  : voltaCarac (true);
        DIR  : avancaCarac;

        CTLPGUP: inicioTexto;
        CTLPGDN: fimTexto;
        CTLESQ:  voltaPalavra;
        CTLDIR:  avanca (' ');

    end;
end;

{--------------------------------------------------------}
{                    trata o teclado
{--------------------------------------------------------}

procedure trataTeclado;
var
    c, c2: char;
    s: string;
begin
    c := readkey;
    c2 := #$0;
    if c = #$0 then c2 := readkey;

    if (c2 <> BAIX) and (c2 <> PGDN) and (c2 <> CIMA) and (c2 <> DIR) and (c2 <> ESQ) then
        begin
            sintClek;
            sintClek;
        end;

    if (c2 <> BAIX) and (c2 <> PGDN) and (c2 <> DIR) and (c2 <> ESQ) then writeln;

    parado := true;
    jalido := false;

    case c of
        #$1b:  begin
                  mensagem (LVCOMFIM, 0);
                  c := readkey;
                  writeln (c);
                  sintCarac (c);

                  if upcase(c) = 'S' then
                      begin
                          processando := false;
                          parado := false;
                      end;
              end;

        #$0d, ' ':  parado := false;

        ^L:         begin
                        mensagem (LVLINHA, 0);
                        textBackground (blue);
                        str (linhaAtual, s);
                        sintWrite (s);
                        textBackground (black);
                        writeln;
                    end;

        #$08, #$09: comandos (c);

        #0:         comandos (c2);
    else
        nada;
    end;

    clreol;
end;

{--------------------------------------------------------}
{                    fala o arquivo
{--------------------------------------------------------}

procedure falaArquivo;
var
    palavras, fonemas: string;

    procedure meudelay (i: integer);
    begin
        while sintFalando do;
        delay (i);
    end;

begin
    while posArq < tamArq do
        begin
            if keypressed then
                begin
                    queueingWaves := false;
                    exit;
                end;

            queueingWaves := true;

            palavras := pegaTrecho;
            if pontuando then
                sintetiza (palavras)
            else
                begin
                    if (palavras = '.') or (palavras = ':') or
                       (palavras = ';') then  meudelay (500)
                    else
                    if palavras = ',' then  meudelay (200)
                    else
                        sintetiza (palavras);
                end;
        end;

    if posArq >= tamArq then
        begin
            writeln;
            mensagem (LVFIMARQ, 1);
            trataTeclado;
        end;

    queueingWaves := false;
end;

{--------------------------------------------------------}
{                    programa principal
{--------------------------------------------------------}

var tituloJan: array [0..144] of char;

begin
     inicializa;
     strPCopy (tituloJan, 'LEVOX ' + nomeArqLeit);
     setWindowText (crtWindow, tituloJan);

     processando := true;
     parado := false;
     while processando do
         begin
             if keypressed or parado then
                 trataTeclado
             else
                 falaArquivo;
         end;

     fimLeVOX;
     doneWinCrt;
end.
