{--------------------------------------------------------}
{                  Módulo de configuração
{--------------------------------------------------------}

unit brConfig;
interface
uses winDos, dvCrt, dvWin, winProcs, strings, brVars, brMsg;

procedure pedeParametros;
procedure assumeParamDefaults;

implementation

{--------------------------------------------------------}
{            processa arquivo de configuracao
{--------------------------------------------------------}

function pegaParam (nome: string): string;
var
    arq: text;
    linha: string;
    n: integer;
begin
    nome := nome + #$0;
    n := GetPrivateProfileString ('BRAIVOX', @nome[1], NIL, @linha[1], 80, 'DOSVOX.INI');
    if n = 0 then
        linha := ''
    else
        linha := strPas (@linha[1]);
    while (linha <> '') and (linha[1] = ' ') do
        delete (linha, 1, 1);

    pegaParam := linha;
end;

{--------------------------------------------------------}
{                  converte lido hexa
{--------------------------------------------------------}

function cnvhexa (c1, c2: char): byte;
var v1, v2, v: integer;
begin
    c1 := upcase (c1);
    c2 := upcase (c2);

    if c1 >= 'A' then
        v1 := ord (c1) - ord ('A') + 10
    else
        v1 := ord (c1) - ord ('0');

    if c2 >= 'A' then
        v2 := ord (c2) - ord ('A') + 10
    else
        v2 := ord (c2) - ord ('0');

    cnvhexa := (v1 shl 4) or v2;
end;

{--------------------------------------------------------}
{              processa um parametro
{--------------------------------------------------------}

function processaParam (s: string): boolean;
var p, i, erro: integer;
    param, valor: string;
    linhasPorMinuto: integer;
begin
    processaParam := true;

    p := pos ('=', s);
    param := copy (s, 1, p-1);
    for i := 1 to length (param) do
         param[i] := upcase (param[i]);
    valor := copy (s, p+1, length (s) - p);

    if param = 'COLUNAS' then
        begin
            val (valor, maxcarac, erro);
            if erro <> 0 then processaParam := false;
        end
    else
    if param = 'LINHAS' then
        begin
            val (valor, maxlin, erro);
            if erro <> 0 then processaParam := false;
        end
    else
    if param = 'FRENTEVERSO' then
        frenteVerso := upcase (valor[1]) = 'S'
    else
    if param = 'AUTOFORMATA' then
        autoJunta := upcase (valor[1]) = 'S'
    else
    if param = 'TEXTODOEDIT' then
        veioDoEdit := upcase (valor[1]) = 'S'
    else
    if param = 'TITULA' then
        comTitulo := upcase (valor[1]) = 'S'
    else
    if param = 'PAGINA' then
        paginando := upcase (valor[1]) = 'S'
    else
    if param = 'NUMERAORIG' then
        numeraOrig := upcase (valor[1]) = 'S'
    else
    if param = 'TITULOATRAS' then
        if upcase (valor[1]) = 'S' then tipoCabec := 2
                                   else tipoCabec := 1
    else
    if param = 'AFASTACABECPAR' then
        afastaCabecPar := upcase (valor[1]) = 'S'
    else
    if param = 'TEXTOINGLES' then
        textoIngles := upcase (valor[1]) = 'S'
    else
    if param = 'SEPARASILABAS' then
        separaSilabas := upcase (valor[1]) <> 'N'
    else
    if param = 'LINHASPORMINUTO' then
        begin
            val (valor, linhasPorMinuto, erro);
            if erro <> 0 then processaParam := false;
            if (linhasPorMinuto <> 0) and impressaoDireta then
                tempoLinha := trunc (60000.0 / linhasPorMinuto)
            else
                tempoLinha := 0;
        end
    else
        processaParam := false;
end;

{--------------------------------------------------------}
{         carrega configuracao da impressora
{--------------------------------------------------------}

procedure carregaConfigImpr;
var
    arqConfig: text;
    ambBraivox: string;
    linha, i: integer;
    c1, c2, x, p1, p2: char;
    s: string;

label proxima, erro;

begin
    for i := 0 to 255 do
        tabPrinter [chr(i)] := i;

    ambBraivox := pegaParam ('AMBBRAIVOX');
    if ambBraivox = '' then
        exit;

    assign (arqConfig, ambBraivox);
    {$I-} reset (arqConfig); {$I+}

    if ioresult <> 0 then
        begin
            mensagem ('BRCNFERR', 1);   {'Arquivo de configuracao inexistente, programa cancelado'}
            sintFim;
            doneWinCrt;
        end;

    linha := 0;
    while not eof (arqConfig) do
        begin
            linha := linha + 1;
            {$I-} readln (arqConfig, s); {$I+}

            if (s = '') or (s[1] = '*') then
                goto proxima;

            if s[3] <> '=' then
                begin
                    if not processaParam (s) then goto erro;
                    goto proxima;
                end;

            i := cnvhexa (s[1], s[2]);
            tabPrinter [chr(i)] := cnvHexa (s[4], s[5]);

            if (ioresult <> 0) or (s[3] <> '=') or (i < 0) or (i > 255) then
                goto erro;
proxima:
        end;

    close (arqConfig);
    exit;

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

erro:
    mensagem ('BRERRLIN', 0);   {'Erro no arquivo de configuracao na linha '}
    sintWriteInt (linha);
    writeln;
    sintFim;
    close (arqConfig);
    delay (2000);
    doneWinCrt;
end;

{--------------------------------------------------------}
{          pega defaults da codificacao Braille
{--------------------------------------------------------}

procedure carregaConfigMatricial;
var
    arqConfig: text;
    ambBraille, s: string;
    linha, l, i, valor: integer;
    bit: byte;

label proxima, erro;

begin
    for i := 0 to 255 do
        tabBraille [chr(i)] := 0;

    ambBraille := pegaParam ('AMBBRAILLE');
    if ambBraille = '' then
        ambBraille := 'C:\DOSVOX\BRAILLE.AMB';

    assign (arqConfig, ambBraille);
    {$I-} reset (arqConfig); {$I+}

    if ioresult <> 0 then
        begin
            mensagem ('BRCNFERR', 1);    {'Arquivo de configuracao inexistente, programa cancelado'}
            sintFim;
        end;

    linha := 0;
    while not eof (arqConfig) do
        begin
            {$I-} readln (arqConfig, s); {$I+}
            linha := linha + 1;
            if (s = '') or (s[1] = '*') then goto proxima;

            l := cnvhexa (s[1], s[2]);
            delete (s, 1, 2);
            while (s <> '') and ((s[1] = '=') or (s[1] = ' ')) do
                delete (s, 1, 1);

            if length (s) <> 6 then goto erro;

            valor := 0;
            for i := 1 to 6 do
                begin
                    if s[i] = '0' then bit := 0
                    else
                    if s[i] = '1' then bit := 1
                    else
                        goto erro;

                    valor := valor + (bit shl (i-1));
                end;

            tabBraille [chr(l)] := valor;
proxima:
        end;

        exit;

erro:
    close (arqConfig);
    mensagem ('BRERRBRL', 0);    {'Erro no arquivo BRAILLE.AMB perto da linha '}
    sintWriteInt ((linha-1) * 4);

    delay (2000);
    sintFim;
    doneWinCrt;
end;

{--------------------------------------------------------}
{                 pede parametros de impressao
{--------------------------------------------------------}

procedure pedeParametros;
var resp, c2: char;
    m: integer;
    defaultMatricial: boolean;
begin
    titulo := '';

    mensagem ('BRTIPIMP', 0);     {'Tipo de impressora: M - Matricial   B - Braille: '}
    sintLeTecla (resp, c2);
    writeln;
    defaultMatricial := imprMatricial;
    imprMatricial := upcase(resp) = 'M';

    if imprMatricial then
        begin
            maxlin := 15;
            maxcarac := 40;
            if not defaultMatricial then
                carregaConfigMatricial;
        end
    else
        begin
            maxlin := 28;
            maxcarac := 34;
            if defaultMatricial then
                carregaConfigImpr;
        end;

    mensagem ('BRAUTOJU', 0);    {'Deseja auto-reformatação para Braille (s/n) ? '}
    sintLeTecla (resp, c2);
    if resp <> ENTER then
        autoJunta := upcase (resp) = 'S';
    writeln;

    mensagem ('BRNCOP', 0);    {'Quantas cópias ? '}
    sintReadint (ncopias);
    if ncopias <= 0 then
        ncopias := 1;

    mensagem ('BRFREVER', 0);    {'Frente e verso (s/n) ? '}
    sintLeTecla (resp, c2);
    if resp <> ENTER then
        frenteVerso := upcase (resp) = 'S';
    writeln;

    mensagem ('BRDOEDIT', 0);    {'Texto foi digitado no EDIT do DOS ? '}
    sintLeTecla (resp, c2);
    if resp <> ENTER then
        veioDoEdit := upcase (resp) = 'S';
    writeln;

    mensagem ('BRFAZTIT', 0);    {'Deseja titulos e numeração ? '}
    sintLeTecla (resp, c2);
    if resp <> ENTER then
        comTitulo := upcase (resp) = 'S';
    writeln;

    titulo := '';
    if comTitulo then
        begin
            mensagem ('BRTIT', 1);    {Informe o título}
            writeln ('---------1---------2---------3---------4---------5');
            sintReadln (titulo);

            mensagem ('BRNUMORG', 0);   {Indica numeração do texto original no cabeçalho ?}
            sintLeTecla (resp, c2);
            if resp <> ENTER then
                numeraOrig := upcase (resp) = 'S';
            writeln;
        end;

    if frenteVerso and comTitulo then
        begin
            mensagem ('BRTITFV', 0);  {'Título em ambos os lados: '}
            sintLeTecla (resp, c2);
            if resp <> ENTER then
                if upcase (resp) = 'S' then tipoCabec := 2
                                       else tipoCabec := 1;
            writeln;

            mensagem ('BRAFASTA', 0); {Afasta para a direita os cabeçalhos pares ? }
            sintLeTecla (resp, c2);
            if resp <> ENTER then
                afastaCabecPar := upcase (resp) = 'S';
            writeln;
        end;

    mensagem ('BRSEPARA', 0);   {Separa sílabas ao fim da linha ?}
    sintLeTecla (resp, c2);
    if resp <> ENTER then
        separaSilabas := upcase (resp) <> 'N';
    writeln;

    mensagem ('BRINGLES', 0);   {Maiúsculas e grifo estilo inglês ?}
    sintLeTecla (resp, c2);
    if resp <> ENTER then
        textoIngles := upcase (resp) = 'S';
    writeln;

    mensagem ('BRLPPAG', 0);   {'Quantas linhas por pagina (0 para nao paginar) ? '}
    m := 0;
    sintReadint (m);
    if m <= 0 then
        begin
            paginando := false;
            maxlin := 32766;
        end
    else
        maxlin := m;

    mensagem ('BRCPLIN', 0);    {'Quantos caracteres por linha ? '}
    m := 0;
    sintReadint (m);
    if m > 0 then
        maxcarac := m;

    if paginando then
        begin
            mensagem ('BRPAGINI', 0);     {'Página inicial (sugiro 1): '}
            sintReadint (paginic);
            if paginic <= 0 then
                paginic := 1;

            mensagem ('BRPAGFIN', 0);     {'Página final (sugiro 9999): '}
            sintReadint (pagfinal);
            if pagfinal <= 0 then
                pagfinal := 9999;

            if comTitulo then
                begin
                    mensagem ('BRNUMINI', 0);   {'Numero a imprimir na pagina inicial: '}
                    sintReadint (numinic);
                    if numinic <= 0 then numinic := 1;
                end;
        end;
end;

{--------------------------------------------------------}
{              assume parametros default
{--------------------------------------------------------}

procedure assumeParamDefaults;
var s: string;
    erro: integer;
begin
    s := pegaParam ('IMPRESSORA');
    imprMatricial := (s <> '') and (upcase(s[1]) = 'M');

    if imprMatricial then
        begin
            maxlin := 15;
            maxcarac := 40;
            carregaConfigMatricial;
        end
    else
        begin
            maxlin := 28;
            maxcarac := 34;
            carregaConfigImpr;
        end;

    frenteVerso := false;
    paginando := true;
    autoJunta := true;
    comTitulo := true;
    veioDoEdit := false;

    numinic := 1;
    ncopias := 1;
    paginic := 1;
    pagfinal := 9999;
    titulo := '';
    tempoLinha := 0;
    pagOrig := 0;
    tiraBrancasInicioPag := true;
end;

end.
