---

Universidade Metodista de Piracicaba
Centro de Ciências Exatas
 
 
 
 
 

TURBO PASCAL

GRÁFICO
 
 
 
 

 
 
 
 
 
 

         José Antonio D'Alkmin

---

1.0 - Introdução

        No início de todos os programas gráficos existirão certos passos que devem ser seguidos. Por exemplo, temos que ajustar o hardware de vídeo para o modo gráfico. Além disso, temos de restaurar a tela do computador para o modo normal de exibição no final de todos os programas gráficos. Na seção abaixo, veremos os componentes básicos necessários em um programa gráfico típico desenvolvido em Pascal.
 
 

1.1 - Inicialização da BGI

        O primeiro passo que todos os programas gráficos devem dar é inicializar o hardware gráfico. Por hardware entendemos a placa do adaptador de vídeo que deve estar presente no PC. Existem diversas placas gráficas diferentes disponíveis para o PC, cada qual com uma variedade de modos gráficos. A BGI (Borland Graphic Interface) oferece suporte a muitos destes "modos". Utilizaremos o modo default da rotina de inicialização da BGI, o que por sua vez nos permitirá ajustar o adaptador gráfico instalado no seu modo de maior resolução.
        A procedure da BGI usada para configurar o seu computador no modo gráfico chama-se InitGraph e possui a seguinte declaração:

procedure InitGraph(var GraphDriver, GraphMode: integer; DriverPath: string);

        A procedure InitGraph está definida na unidade Graph do Pascal que deve ser incluída na seção uses de todos os programas gráficos. Este arquivo contém as estruturas de dados, constantes, procedures e funções da BGI.
        Os dois primeiros parâmetros especificados em initgraph identificam a placa de vídeo instalada e o modo gráfico a ser utilizado. O terceiro parâmetro especifica o path onde se encontram os drivers para gráfico do Turbo Pascal. (Existe pelo menos um driver gráfico para cada adaptador gráfico). Os arquivos dos drivers são os que terminam todos com a extensão .BGI .
        No próximo exemplo, InitGraph pesquisa o diretório atual para encontrar os arquivos de drivers.:

                InitGraph(Gdriver, Gmode, ' ');
 
 

1.2 - Escrita de um Programa Básico usando a BGI

        O programa a seguir é provavelmente o menor programa gráfico que podemos escrever em Turbo Pascal. Este programa é apenas para enfatizar a estrutura básica de um programa gráfico típico em Pascal. Podemos usá-lo como esqueleto para nossos próprios programas gráficos.

            Program SmallestGraphicsProgram;
           Uses Graph;    { unidade gráfica do Turbo Pascal }
           Const
                Gdriver: integer = Detect;
           Var
                Gmode: integer;
           Begin
                InitGraph(Gdriver, Gmode, 'c:\bp\bgi');   { Inicializa o modo Gráfico }
                        { Coloque os comandos para desenho nesta área !! }
                CloseGraph;   { Finaliza o Modo Gráfico }
           End.
 
 

2.0 - Trabalhando com coordenadas

        Nos gráficos, acompanhamos as nossas posições usando coordenadas de pixels. Os pixels são pontos muitos pequenos que se vê na tela e que podem ser endereçados usando um sistema de coordenadas familiar à forma por que acessamos as linhas e colunas de uma estrutura de dados bidimensional.
         O Turbo Pascal apresenta duas funções que obtém o número máximo de pixels tanto no eixo x (GetMaxX) quanto no eixo y (GetMaxY).
        Endereçamento por linha e coluna da tela.
 
 

2.0 – Comandos para Desenhos

        Declaração
            Procedure Arc (X,Y; Integer; StAngle, EndAngle, Radius; Word);

        O Arco vai desde StAngle (ângulo de início) até EndAngle (ângulo final), com raio Radius usando (x,y) como ponto central.
 

        Declaração
            Procedure Bar(x1, y1, x2, y2: Integer);

        Bar desenha um retângulo preenchido. Usa o preenchimento e cores definidos por SetFillStyle ou SetFillPattern. Para desenhar uma barra sem preenchimento, utiliza 3D.
 

        Declaração
            Procedure Bar3D(x1, y1, x2, y2: Integer; Depth: Word; Top: Boolean);

        Bar3D desenha uma barra pintada e em três dimensões usando o preenchimento e cores definidos por SetFillStyle ou SetFillPattern. A linha 3d da barra é desenhada no estilo de linha corrente e cores como ajustados pelo SetLineStyle e SetColor. Depth é a largura em pixeis da linha 3-D. Se Top for Topon (constante que significa true), um topo 3-D é colocado na barra, se Top for Topoff (constange que significa false) o topo não é colocado na barra.
 

        Declaração
            Procedure Circle(X,Y: Integer; Radius: Word);

        Desenha um círculo na cor corrente estabelecida por SetColor. Cada Driver Gráfico contém um aspect raio usado por Circle, Arc e PieSlice.
 

        Declaração
            Procedure ClearDevice;

        ClearDevice move a posição corrente para (0, 0), apaga a tela usando a cor de fundo estabelecida por SetBkColor, e prepara para saída de dados.
 

        Declaração
            Procedure ClearViewPort;

        ClearViewPort aplica a cor de preenchimento para a cor de fundo (Palette[0]) e move a posição corrente para (0, 0).
 

        Declaração
            Procedure CloseGraph;

        CloseGraph  restaura o modo de vídeo utilizado antes da biblioteca gráfica ser inicializada.
 

        Declaração
            Procedure DetectGraph( Gdriver, Gmodo: integer);

        DetectGraph retorna o valor de driver e modo detectados que podem ser utilizados em InitGraph para inicializar o modo gráfico usando o driver e modo corretos detectados para o hardware gráfico instalado na máquina.
 

        Declaração
            Procedure DrawPoly(NumPoints: word; var PolyPoints)

        DrawPoly desenha as linhas de um polígono a cor e estilo correntes de linha.
        NumPoints: especifica o número de pontos contidos na variável PolyPoints.
        PolyPoints: uma variável do tipo PointType.
        PointType = Record
                                x, y: integer;
                            End;
 

        Declaração
            Procedure Ellipse(X,Y: integer; StAngle, EndAngle: Word; Xradius, Yradius: word);

        Desenha um arco elíptico.
        Desenha o arco iniciando em Stangle até EndAngle com Xradius de Raio X e Yradius de Raio Y.
 

        Declaração
            Procedure FillEllipse(x,y: integer; Xradius, Yradius: integer);

        Desenha uma elípse pintada.
        (x,y) é o ponto central;  Xradius e Yradius são os eixos horizontal e vertical respectivamente.
 

        Declaração
            Procedure FillPoly(NumPoints: Word; var PolyPoints);

        Desenha um polígono preenchido com a cor e o estilo de preenchimento correntes.
        NumPoints:  representa o número de pontos que formam o polígono.
        PolyPoints:  variável sem tipo que contém coordenadas de cada ponto. (Geralmente é utilizada uma variável do tipo PointType).
 

        Declaração
            Procedure FloodFill(x,y: integer; border: Word);

        Preenche uma área fechada iniciando em x,y e vai se alimentando até encontrar uma delimitação com cor diferente utilizando as configurações correntes de preenchimento e pintura.
 

        Declaração
            Function GetBkColor: Word;

        Retorna a cor de fundo de tela utilizada atualmente (Um valor de 0 a 15) no caso de um VGA.
 

        Declaração
            Function GetColor: Word;

        Retorna a cor do pincel utilizada para desenhar linhas, etc. (Um valor de 0 a 15) no caso de um VGA.
 

        Declaração
            Function GetDefaultPalette(var Palette: PaletteType);

        Retorna as cores originais da paleta de cores para a variável Palette do tipo PalleteType.

            Const
                Maxcolors = 15;
            PaletteType = Record
                                      Size: byte;
                                      Colors: array[0..MaxColors] of shortint;

        Declaração
            Function GetDriverName: String;

        Retorna uma string contendo o nome do driver atual utilizado para inicializar o modo gráfico.
 

        Declaração
            Function GetGraphMode: integer;

        Retorna um número que corresponde ao modo atual de vídeo utilizado pela biblioteca gráfica. (Verificar Lista Pág. 2).
 

        Declaração
            Procedure GetImage(x1, y1, x2, y2: integer; var BitMap);

        Salva a imagem bit a bit contida no espaço x1, y1, x2, y2 e salva para um buffer (BitMap).
        Ex.:

            Var
                Size: Word;
                BitMap: Pointer;
            Begin
                ...
                size:= ImageSize(100, 100, 150, 150);  { Retorna o nº de bytes necessários p/ guardar a imagem }
                getmem(BitMap, size);  { Aloca essa quantia de memória }
                getimage(100, 100, 150, 150, BitMap); { salva a imagem }
                ...
            End.
 

        Declaração
            Function GetLineSettings(var LineInfo: LineSettingsType);

        Retorna o estilo de linha corrente.
            LineSettingsType = Record
                                              LineStyle: Word;
                                              Pattern: Word;
                                              ThickNess: Word;
                                          End;
 

        Declaração
            Function GetMaxColor: word;

        Retorna o nº máximo de cores suportado pelo driver gráfico atualmente utilizado.
 

        Declaração
            Function GetMaxX: integer;

        Retorna o nº máximo de pixels suportado pela resolução X.
 

        Declaração
            Function GetMaxY: integer;

        Retorna o nº máximo de pixels suportado pela resolução Y.
 

        Declaração
            Function GetPalette(Palette: PaletteType);

        Retorna a paleta de cores utilizada atualmente e seu tamanho para uma variável do tipo PaletteType.
 

        Declaração
            Function GetPaletteSize: integer;

        Retorna o nº máximo de cores suportado pela paleta de cores do modo gráfico atual.
 

        Declaração
            Function GetPixel(x,y: integer): word;

        Retorna a cor atual do pixel de coordenada (x,y).
 

        Declaração
            Function GetTextSettings(var TextInfo: TextSettingsType);

        Retorna as configurações atuais de texto (fonte, tamanho, etc) para uma variável do tipo TextSettingsType.
            TextSettingsType = Record
                                               Font: Word;
                                               Direction: Word;
                                               CharSize: Word;
                                               Horiz: Word;
                                               Vert: Word;
                                          End;
 

        Declaração
            Function GetX;

        Retorna a coordenada X a ser utilizada. (Posição X do Cursor).
 

        Declaração
            Function GetY;

        Retorna a coordenada Y a ser utilizada. (Posição Y do Cursor).
 

        Declaração
            Function ImageSize(x1, y1, x2, y2: integer): Word;

        Retorna o nº de bytes necessários para armazenar uma região retangular delimitada por (x1, y1, x2, y2) na memória.
 

        Declaração
            Procedure InitGraph(var gDriver: Integer, var gMode: Integer, PathtoDriver: String);

        Inicializa o modo gráfico com o modo e driver especificados. É necessário também, especificar o caminho onde se encontram os drivers da BGI em PathtoDriver.
 

        Declaração
            Procedure Line(x1, y1, x2, y2: integer);

        Desenha uma linha com as configurações estabelecidas em SetLineStyle que vai do ponto 1(x1, y1) até o ponto 2(x2, y2).
 

        Declaração
            Procedure LineRel(x1,y1: integer);

        Desenha uma linha que vai desde a posição atual do cursor (x0, y0) até a posição (x0+x1), (y0+y1).
 

        Declaração
            Procedure LineTo(x, y: integer);

        Desenha uma linha que vai desde a posição atual do cursor (x0, y0) até o ponto especificado (x,y).
 

        Declaração
            MoveRel(Dx, Dy: integer);

        Move a posição atual do cursor (x0, y0) até a posição (x0+Dx, y0+Dy).
 
 

        Declaração
            Moveto(x, y: integer);

        Move a posição atual do cursor (x0, y0) para a posição especificada (x,y).
 

        Declaração
            OutText(TextString: String);

        Manda uma string para o dispositivo de Saída (Tela) na posição atual do cursor.
 

        Declaração
            OutTextXY(x,y: integer; TextString: String);

        Manda uma string para o dispositivo de Saída (Tela) na posição especificada (x, y).
 

        Declaração
            PieSlice(x, y: integer; StAngle, EndAngle, Radius: Word);

        Desenha e pinta uma “pedaço de torta” com as coordenadas especificadas.
            (x,y) – Ponto Central.
            Inicia com o ângulo StAngle e termina com o ângulo EndAngle.
 

        Declaração
            PutImage(x,y: integer; var Bitmap; Bitblt: Word);

        (x, y) – é o canto superior esquerdo o qual a figura será iniciada.
        Bitmap – é uma variável sem tipo que contém a imagem a ser colocada na tela.
        BitBlt – é uma operação booleana a ser realizada na plotagem de cada pixel da figura.
        BitBlt pode ser:
        NormalPut, OrPut, XorPut, NotPut ou AndPut.
 

        Declaração
            PutPixel(x,y: integer; pixel: word);

        Desenha um pixel na coordenada especificada (x, y) com a cor “pixel” que é uma word.
 

        Declaração
            Rectangle(x1, y1, x2, y2: integer);

        Desenha um retângulo na área retangular delimitada por (x1,y1) e (x2, y2) com os estilos de cor e linhas atuais.
 

        Declaração
        Procedure SetAllPalette(var Palette);

        Altera todas as cores da paleta de cores para as especificadas na variável Palette que pode ser do tipo PaletteType.
 

        Declaração
            Function SetAspectRatio(xAsp, yAsp: integer): Word;

        O Aspect Ratio é utilizado para desenhar círculos. Se diminuirmos o valor default, obteremos maior correção e precisão.
 

        Declaração
            Procedure SetBkColor(ColorNum: Word);

        Altera a cor do fundo da tela para a cor especificada em ColorNum.
 

        Declaração
            Procedure SetColor(Color: Word);

        Altera a cor de desenho usando a paleta de cores.
 

        Declaração
            Procedure SetFillPattern(Patern: FillPatternType; Color: Word);

        Altera o estilo de preenchimento para um estilo definido pelo usuário
            FillPatternType = Array[1..8] of byte;

        Declaração
            Procedure SetFillStyle(Pattern: Word; Color: Word);

        Altera a cor e estilo de preenchimento para um estilo já existente na BGI.
 

        Declaração
            Procedure SetLineStye(LineStyle: Word; Pattern: Word; ThickNess: Word);

        Altera o estilo de preenchimento da linha.

	NormalWidth	ThickWidth
Solidln
DottedLn
CenterLn
DashedLn

        Declaração
            Procedure SetPalette(ColorNum: Word; Color: Shortint);

        Altera a entrada ColorNum da paleta de cores para a cor especificada em Color.
 

        Declaração
            Procedure SetRgbPalette(ColorNum, RedValue, GreenValue, BlueValue: integer);

        Altera a cor localizada em ColoNum na paleta de cores com as coordenadas RGB (Red, Green, Blue) que correspondem um valor de 0 a 63 cada uma. RedValue especifica a itensidade de Vermelho, GreenValue verde e BlueValue azul.
 

        Declaração
            Procedure SetTextJustify(Horiz, Vert: Word);

        Altera os valores de justificação de texto usados por OutText e OutTextxy.
 

        Declaração
            Procedure SetTextStyle(Font, Direction: Word; CharSize: Word);

        Altera o Estilo de Texto para saída no Dispositivo Gráfico.
(Isto inclui a Fonte e Tamanho das letras e se a Direção é Vertical ou Horizontal).
 

        Declaração
            Procedure SetViewPort(x1, y1, x2, y2: integer; Clip: Boolean);

        Altera os limites da área gráfica através de uma área retangular. Semelhante ao procedimento “Window” no modo texto, mas seu funcionamento só ocorre no modo gráfico.
        O parâmetro clip especifica se os comandos gráficos que desenham algo na tela obedecerão as coordenadas (x1, y1) como sendo (0,0) ou não.
Obs.:
        Caso não, tudo o que sair fora do limite de SetViewPort será cortado e não aparecerá na tela.
        Caso for True, o desenho será cortado, senão será transportado para as novas coordenadas
 

        Declaração
            Procedure SetVisualPage(Page: Word);

        Altera o nº de página utilizada atualmente no modo Gráfico. Múltiplas páginas são suportadas apenas de EGA com 256 Kb ou mais.
Obs.:
        Utilizada para criar animações gráficas.
 
 

        Declaração
            Procedure SetWriteMode(WriteMode: integer);

        Altera o modo de desenhar linhas na tela.
        Afeta as chamadas dos seguintes Procedimentos: DrawPoly, Line, LineRel, LineTo e Retângulo.
 

        Declaração
            Function TextHeight(TextString: String): Word;

        Retorna a altura de uma string em pixels (Leva em consideração o tamanho e estilo da fonte).
 

        Declaração
            Function TextWidth(TextString: String): Word;

        Retorna a largura de uma string em pixels (Leva em consideração o tamanho e estilo da fonte).