
TEXTO CODIFICADO DO PROGRAMA ACENTOS P/ MARCELO PIMENTEL

TEXTWIDTH - esta funo  bastante semelhante  anterior. A diferena  que
nesta o valor retornado  o da largura do texto em nmero de pixels. Esta fun-
o tambm leva em conta o tamanho da fonte de caracteres e o fator de multipli-
cao. Sua sintaxe:
TEXTWIDTH (<texto> : STRING) : WORD;
PROGRAM teste_textwidth;
USES GRAPH, CRT;
VAR
  gd, gm, alt : INTEGER;
  texto : STRING
BEGIN
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  texto := <---->;
  FOR alt := 1 TO 5 DO
    BEGIN
      SETTEXTSTYLE(DEFAULTFONT,HORIZDIR,alt);
      OUTTEXTXY(GETMAXX - TEXTWIDTH(texto) + 1,GETMAXY - TEXTHEIGHT(texto) +
1, texto);
      OUTTEXTXY (GETMAXX DIV 2) - (TEXTWIDTH(texto) DIV 2),(GETMAXY DIV 2) - 
            (TEXTHEIGHT(texto) DIV 2),texto);
      OUTTEXTXY(0,0,texto);
      READLN;
      CLEARDEVICE;
    END;
  CLOSEGRAPH;
END.

GETPIXEL - esta funo nos retorna a cor de um ponto nas coordenadas x, y. 
Sua sintaxe:
GETPIXEL (<x>, <y> : INTEGER) : WORD;

PUTPIXEL - este procedimento permite a colocao de um ponto nas coordenadas
x, y e na cor previamente definida. Sua sintaxe:
PUTPIXEL (<x>, <y> : INTEGER; <cor> : WORD);
Vejamos um exemplo com estes comandos:
PROGRAM teste_getpixel_putpixel;
USES GRAPH, CRT;
VAR
  x, y, gd, gm : INTEGER;
  cor : WORD;
BEGIN
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  RANDOMIZE;
  REPEAT
    x := RANDOM(GETMAXX - 1);
    y := RANDOM(GETMAXY - 1);
    IF GETPIXEL (x,y) = GETMAXCOLOR
      THEN
        PUTPIXEL(x,y,0)
      ELSE
        PUTPXEL(x,y,GETMAXCOLOR);
  UNTIL KEYPRESSED;
  READLN;
  CLOSEGRAPH;
END.

GETLINESETTINGS - este procedimento no retorna o estilo de linha corrente,
que  pode ser de 0 at 4, sendo 0 slido, 1 em pontos, 2 centralizado, 3 trace-
jado e 4 definido pelo usurio. Estes valores esto disponveis na UNIT GRAPH,
como constantes da seguinte forma:
CONST
  SOLIDLN = 0;
  DOTTEDLN = 1;
  CENTERLN = 2;
  DASHEDLN = 3;
  USERBITLN = 4;
  O procedimento tambm nos retorna o modelo de linha utilizado e ainda a 
espessura da linha. A varivel passada como parmetro  do tipo LINESETTTINGSTYPE,
que  um tipo predefinido na UNIT GRAPH, da seguinte forma:
TYPE
  LINESETTINSGSTYPE = RECORD
    LINESTYLE : WORD;
    PATTERN : WORD;
    THICKNESS : WORD;
  END;
A sintaxe deste procedimento :
GETTLEINESETTINGS(VAR <linha> : LINESETTINGSTYPE);
Vejamos um exemplo:
PROGRAM teste_getlinesettings;
USES GRAPH;
VAR
  gd, gm : INTEGER;
  linha : LINESETTINGSTYPE;
BEGIN
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  LINE(10,10,100,10);
  GETLINESETTINGS(linha);
  WITH linha DO
    BEGIN
      OUTTEXTXY(10,30,o tipo de linha  , + CHR(48 +LINESTYLE));
      OUTTEXTXY(10,40,o modelo(pattern)   + CHR(48 + pattern));
      OUTTEXTXY(10,50,a espessura da linha    + CHR(48 + thickness));
      END;
  READLN;
  CLOSEGRAPH;
END.

SETLINESTYLE - este procedimento permite-nos alterar o estilo de linha, seu
molde e sua espessura. O molde ser ignorado quando o estilo de linha for dife-
rente de 4 (USERRBITLN), e a espessura poder apenas assumir valores 1 
(normwidth) ou 3 (thickwidth). Quando for utilizado o estilo de linha 4, deve-
mos estabelecer um valor de 16 bits para o parmetro do modelo (pattern) para
definirmos assim o molde, por exemplo, se fizermos pattern = $333, teremos o 
seguinte padro: 11001100 para espessura 1, 11001100, 11001100 para
espessura 3, 11001100. Caso haja um erro neste procedimento, ser acusado
na funo GRAPHRESULT que retornar o valor -11, e a linha corrente ser
mantida. Sua sintaxe:
SETLINESTYLE (<estilo> : WORD; < modelo> : WORD; <espessura> : WORD);
Vejamos agora um exemplo:
PROGRAM teste_setlinestyle;
USES GRAPH;
VAR
  gd, gm : INTEGER;
  linha_ant : LINESETTINGSTYPE;
  i : BYTE;
  modelo : WORD;
BEGIN  
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  GETLINESETTINGS(linha_ant);
  SETLINESTYLE(SOLIDLN,0,NORMWIDTH);
  RECTANGLE(0,10,40,140);
  SETLINESTYLE(SOLIDLN,0,THICKWIDTH);
  RECTANGLE(50,10,90,140);
  SETLINESTLE(DOTTEDLN,0,NORMWIDTH);
  RECTANGLE(100,10,140,140);
  SETLINESTYLE(DOTTEDLN,0,THICKWIDTH);
  RECTANGLE(150,10,190,140);
  SETLINESTYLE(CENTERLN,0,NORMWIDTH);
  RECTANGLE (200,10,240,140);
  SETLINESTYLE(CENTERLN,0,THICKWIDTH);
  RECTANGLE (250,10,290,140);
  SETLINESTYLE(DASHEDLN,0,NORMWIDTH);
  RECTANGLE(300,10,340,140);
  SETLINESTYLE(DASHEDLN,0,THICKWIDTH);
  RECTANGLE (350,10,390,140);
  modelo := $2121;
  SETLINESTYLE(USERBITLN,modelo,NORMWIDTH);
  RECTANGLE(400,10,440,140);
  SETLINESTYLE(USERBITLN,MODELO,THICKWIDTH);
  RECTANGLE (450,10,490,140);
  MODELO := $F7F7;
  SETLINESTYLE(USERBITLN,MODELO,NORMWIDTH);
  RECTANGLE(500,10,540,140);
  SETLINESTYLE(USERBITLN,MODELO,THICKWIDTH);
  RECTANGLE (550,10,590,140);
  WITH linha_ant DO
    SETLINESTYLE(LINESTYLE,PATTERN,THICKNESS);
  RECTANGLE(0,150,590,180);
  READLN;
  CLOSEGRAPH;
END.

PIESLICE - este procedimento permite que seja desenhada e preenchida uma 
tort ou um pedao de uma tort, com ponto central em coordenadas x,y,
ngulo inical, ngulo final e raio. Caso haja algum erro, este ser reportado
na funo GRAPHRESULT com o valor -6. Sua sintaxe :
PIESLICE(<x>, <y> : INTEGER; <angini>, <angfim>, <raio> : WORD);
Vamos a um exemplo:
PROGRAM teste_pieslice;
USES GRAPH, CRT;
VAR
  gd, gm : INTEGER;
BEGIN
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  REPEAT
    PIESLICE(RANDOM(GETMAXX),RANDOM(GETMAXY),RANDOM(360),RANDOM(360),
        RANDOM(GETMAXY DIV 2));
  UNTIL KEYPRESSED;
  READLN;
  CLOSEGRAPH;
END.

SETFILLPATTERN - este procedimento permite que se defina um novo modelo para
preenchimento de reas usadas nos procedimentos: FILLPOLY, FLOODFILL, BAR,
BAR3D e PIESLICE. Sendo definidos os moldes e cores para preenchimento, o esti-
lo  determinado por outro procedimento. Sua sintaxe:
SETFILLPATTERN(<molde> : FILLPATTERNTYPE; <cor> : WORD);
Vamos a um exemplo:
PROGRAM teste_setfillpattern;
USES GRAPH, CRT;
VAR
  gd, gm :INTEGER;
  molde : FILLPATTERNTYPE;
BEGIN
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  REPEAT
    mode[(RANDOM(9) - 1)] :=RANDOM(255);
    SETFILLPATTERN(molde,RANDOM(GETMAXCOLOR));
    PIESLICE(RANDOM(GETMAXX),RANDOM(GETMAXY),RANDOM(360),RANDOM(360),
        RANDOM(GETMAXY DIV 2));
  UNTIL KEYPRESSED;
  CLOSEGRAPH;
END.

GETFILLPATTERN - este procedimento nos retorna os parmetros estabelecidos
no procedimento SETFILLPATTERN em uma varivel do tipo FILLPATTERNTYPE, pre-
definida na UNIT GRAPH da seguinte forma:
TYPE
  FILLPATTERNTYPE = ARRAY[1..8] OF BYTE;
  Caso no tenha sido utilizado o procedimento SETFILLPATTERN anteriormente a
chamada deste procedimento a matriz ser preenchida com $FF. Vejamos um exemplo:
PROGRAM teste_getfillpattern;
USES GRAPH;
VAR
  gd, gm, x : INTEGER;
  molde : FILLPATTERNTYPE;
BEGIN
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  GETFILLPATTERN(molde);
  CLOSEGRAPH;
  WRITELN (o molde atual est com os,seguintes valores:);
  FOR x := 1 TO 8 DO
    WRITELN (mold,x,=,molde[x]:3);
  READLN;
  INITGRAPH(gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  RANDOMIZE;
  FOR x := 1 TO 8 DO
    molde[x] := RANDOM(255);
  SETFILLPATTERN(molde,RANDOM(GETMAXCOLOR));
  BAR (0,0,GETMAXX,GETMAXY);
  GETFILLPATTERN(molde);
  CLOSEGRAPH;
  WRITELN (o molde atual est com os,seguintes valores: );
  FOR x := 1 TO 8 DO
    WRITELN (mold,x,=,molde[x]:3);
  READLN;
END.

SETFILLSTYLE - este procedimento permite alterar o estilo e a cor para preen-
chimento nos procedimentos: FILLPOLY, BAR, BAR3D, e PIESLICE. Os possveis 
estilos variam de 0 at 12. Existem constantes predefinidas na UNIT GRAPH,
da seguinte forma:
CONST
  EMPITYFILL = 0; {utiliza a cor do fundo}
  SOLIDFILL = 1; {usa a cor corrente}
  LINEFILL = 2; {--}
  LTSLASHFILL = 3; {///}
  SIASHFILL = 4; {///espesso}
  BKSLASHFILL = 5; {\\\espesso}
  LTBKSLASHFILL = 6; {\\\}
  HATCHFILL = 7; {linhas cruzadas perpendicularmente}
  XHATCHFILL = 8; {linhas cruzadas em x}
  INTERLEAVEFILL = 9; {intercalado}
  WIDEDOTFILL = 10; {pontos espaados}
  CCLSEDOTFILL = 11; {pontos agrupados}
  USERFILL = 12; {definido pelo usurio}
Sua sintaxe:
SETFILLSTYLE(<molde> : WORD, <cor> : WORD);
Vejamos um exemplo:
PROGRAM teste_setfillstyle;
USES GRAPH, CRT;
VAR
  gd, gm : INTEGER;
  molde : WORD;
BEGIN
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  FOR molde := 0 TO 11 DO
    BEGIN
      SETFILLSTYLE(molde,1);
      BAR(50,50,150,150);
      READLN;
      CLEARDEVICE;
    END;
  CLOSEGRAPH;
END.

GETFILLSETTINGS - este procedimento nos retorna os valores utilizados na 
ltima chamada de SETFILLSTYLE. Para tanto deve ser passada como parmetro
uma varivel do tipo FILLSETTINGSTYPE definida na UNIT GRAPH, da seguinte 
forma:
TYPE
  FILLSETTINGSTYPE = RECORD
    PATTERN : WORD;        
    COLOR : WORD;
  END;
Sua sintaxe:
GETFILLSETTINGS(VAR <estilo> : FILLSETTINGTYPE);
Vejamos um exemplo:
PROGRAM teste_getfillsettings;
USES GRAPH, CRT;
VAR
  gd, gm : INTEGER;
  molde : FILLSETTINGSTYPE;
BEGIN
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  GETFILLSETTINGS(molde);
  CLOSEGRAPH;
  WITH molde DO
    BEGIN
      WRITELN (o tipo atual  ,PATTERN);
      WRITELN (a cor atual  ,COLOR);
    END;
  READLN;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  SETFILLSTYLE(8,1);
  BAR(50,50,150,150);
  READLN;
  GETFILLSETTINGS(molde);
  CLOSEGRAPH;
  WITH molde DO
    BEGIN
      WRITELN(o tipo atual  ,PATTERN);
      WRITELN(a cor atual  ,COLOR);
    END;
  READLN;
  CLOSEGRAPH;
END.

REGISTERBGIDRIVER - esta funo nos retorna um valor menor que 0 em caso de 
erro, ou o nmero do arquivo de driver passando isto para uma alocao de 
memria. Quando o driver for instalado pelo procedimento INITGRAPH, somente
ento ser utilizado. Sua sintaxe:
REGISTERBGIDRIVER(<drv> : POINTER) : INTEGER;
PROGRAM teste_registerbgidriver;
USES GRAPH;
VAR
  gd, gm : INTEGER;
  arqgraf : FILE;
  ponteiro : POINTER;
BEGIN
  ASSIGN (arqgraf,CGA.BG);
  RESET(arqgraf,1);
  GETMEM(ponteiro,FILESIZE(arqgraf));
  BLOCKREAD(arqgraf,ponteir,FILESIZE(arqgraf));
  IF REGISTERBGIDRIVER(ponteiro) < 0
    THEN
      BEGIN
        WRITELN(erro no drive grfico nro:,GRAPHERRORMSG(GRAPHRESULT));
        HALT (1);
      END;
  gd := CGA;
  gm := CGAHI;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> 0
    THEN
      HALT (1);
  OUTTEXT(driver grfico carregado pelo program);
  READLN;
  CLOSEGRAPH;
END.

REGISTERBGIFONT - esta funo retorna um valor negativo, caso o arquivo de
fontes no tenha sido carregado na memria, ou o nmero interno da fonte 
e o registro passado para a memria dinmica. Desta forma a fonte  carregada
do disco para o HEAP. Sua sintaxe:
REGISTERBGIFONT(<fonte> : POINTER) : INTEGER;
Vejamos um exemplo:
PROGRAM teste_registerbgifont;
USES GRAPH;
VAR
  gd, gm : INTEGER;
  arqfont : FILE;
  ponteiro : POINTER;
BEGIN
  ASSIGN(arqfont,TRIP.CHR);
  RESET(arqfont,11);
  GETMEM(ponteiro,FILESIZE(arqfont));
  BLOCKREAD(arqfont,ponteir, FILESIZE(arqfont));
  IF REGISTERBGIFONT(ponteiro) < 0
    THEN
      BEGIN
        WRITELN(erro no arquivo grfico de fonte:,GRAPHERRORMSG(GRAPHRESULT));
        HALT (1);
      END;
gd := CGA;
  gm := CGAHI;
  INITGRAPH(gd,gm, );
  IF GRAPHRESULT <> 0
    THEN
      HALT (1);
  OUTTEXT(arquivo grfico de fonte carregad,pelo program);
  READLN;
  CLOSEGRAPH;
END.
  Uma observao deve ser feita: em alguns casos, temos a necessidade de gerar
um programa em memria sem que tenhamos que ficar carregando os arquivos de
drivers (.BGI) e os de fontes (.CHR), para isso devemos transform-los em
objetos para podermos link-los junto ao programa principal. Devemos ento
executar o programa BINOBJ, LINKAR o objeto resultante e utilizar as rotinas
REGISTERSBGIFONT Je REGISTERBGIDRIVER para ento podermos elevar os objetos
para a memria. 

INSTALLUSERDRIVER - esta funo permite que seja instalado um driver grfico
gerado pelo usurio. No caso de erro, este ser reportado na funo GRAPHRESULT.
Sua sintaxe:
INSTALLUSERDRIVER(<nome> : STRING; <autodet> : POINTER) : INTEGER;
Vejamos um exemplo:
PROGRAM teste_installuserdriver;
USES GRAPH;
VAR
  gd, gm, 
teste, erro : INTEGER;
{$F+}
FUNCTION testedetect : INTEGER;
BEGIN
  testedetect := 1;
END;
{$F-}
BEGIN
  teste := INSTALLUSERDRIVER(test@testedetect);
  IF GRAPHRESULT <> GROK
    THEN
      BEGIN
        WRITELN (erro instalando test);
        HALT (1);
      END;
  gd := DETECT;
  INITGRAPH(ge,gm, );
  erro := GRAPHRESULT;
  IF erro <> GROK
    THEN
      BEGIN
        WRITELN(erro durante INIT:,erro, ,GRAPHERRORMSG(erro));
        READLN;
        HALT (1);
      END;
  OUTTEXT(;instalado o driver de suporte grfic);
  READLN;
  CLOSEGRAPH;
END.

INSTALLUSERFONT - esta funo permite instalar uma nova fonte de caracteres,
e retorna o valor da nova fonte instalada. Caso no seja instalada correta-
mente, ser assumida a DEFAULTFONT (0). Sua sintaxe:
INSTALLUSERFONT(<nomearq> : STRING) : INTEGER;
Vamos a um exemplo:
PROGRAM teste_installuserfont;
USES GRAPH;
VAR
  gd, gm : INTEGER;
  font : INTEGER;
BEGIN  
  font := INSTALLUSERFONT(test);
  IF GRAPHRESULT <> GROK
    THEN
      BEGIN
        WRITELN(erro instalando fonte usand,DEFAULTFONT);
        READLN;
      END;
  gd := DETECT;
  INITGRAPH (gd,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  SETTEXTSTYLE(font,horizdir,2);
  OUTTEXT(instalado o suporte de font);
  READLN;
  CLOSEGRAPH;
END.

SETUSERCHARSIZE - este procedimento permite estabelecermos um novo fator para
a fonte de caracteres ativa, isto , feita pela seguinte relao, x : fator x
e y : fator y. Sua sintaxe:
SETUSERCHARSIZE(<multx>, <divx>, <multy>, <divy> : WORD);
Vamos a um exemplo:
PROGRAM teste_setusercharsize;
USES GRAPH;
VAR
  dg, gm : INTEGER;
BEGIN
  dg := DETECT
  INITGRAPH (dg,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  SETTEXTSTYLE(SANSSERIFFONT,HORIZDIR,1);
  OUTTEXTXY(10,0,normal);
  SETUSERCHARSIZE(4,1,1,1);
  OUTTEXTXY(10,50,larg);
  SETUSERCHARSIZE(2,1,7,1);
  OUTTEXTXY(0,0,alt);
  SETUSERCHARSIZE(1,3,1,4);
  OUTTEXTXY(100,0micr);
  READLN;
  CLOSEGRAPH;
END.

SETWRITEMODE - este procedimento estabelece como ser o modo desenho de linhas
ou desenhos que se utilizam de linhas. Permite 2 modos de operao, passando-se
o valor COPYPUT, predefinido nesta UNIT e equivale ao valor 0, que coloca
em situao de se desenhar uma linha, copiando-se o estilo corrente para o 
dispositivo de sada. A segunda forma  passando-se a constante predefinida
XORPUT equivalente ao valor 1, que executa uma operao XOR quando desenhada
uma linha, ou seja, se for encontrado um ponto onde deveria ser desenhado
um novo ponto, este ser apagado e vice-versa. Caso uma linha seja desenhada
2 vezes e o procedimento SETWRITEMODE estiver setado em XORPUT, uma vez esta
ser desenhada e outra apagada. Sua sintaxe:
SETWRITEMODE(<modo> : INTEGER);
Vejamos um exemplo:
PROGRAM teste_setwritemode;
USES GRAPH, CRT;
VAR
  gd, gm : INTEGER;
BEGIN
  gd := DETECT;
  INITGRAPH (dg,gm, );
  IF GRAPHRESULT <> GROK
    THEN
      HALT (1);
  RANDOMIZE;
  OUTTEXTXY(0,0,modo de escrita 0);
  REPEAT
    LINE (GETMAXX DIV 2,GETMAXY DIV 2,RANDOM(GETMAXX),RANDOM(GETMAXY));
  UNTIL KEYPRESSED;
  READLN;
  SETWRITEMODE(XORPUT);
  CLEARDEVICE;
  OUTTEXTXY(0,0,modo de escrita 1);
  REPEAT
    LINE(GETMAXX DIV 2,GETMAXY DIV 2,RANDOM(GETMAXX),RANDOM(GETMAXY));
  UNTIL KEYPRESSE
