„Język programowania”

AJS

Organizacja ekranu w trybie

tekstowym

Ekran podzielony jest na jednakowe

komórki.

W komórce może znaleźć się tylko

jeden znak

1 2 3 4 5 6 7 8 9

1
2
3
4
5

6
7
8

(left,to
p)

(right,bott
om)

współrzędne
względne (3,2)

okno
tekstowe

współrzędne
bezwzględne

kolumna
3

wiersz 2

AJS

Definiowanie okien tekstowych

void window (int left, int top, int right, int bottom);

(funkcja ta służy do określenia obszaru ekranu zajmowanego

przez okno tekstowe)

dla całego ekranu

window(1,1,80,25);

tryb 80-kolumnowy

window (1,1,40,25);

tryb 40-kolumnowy

Sterowanie trybem pracy ekranu

void textmode (int newmode);

textmode(C80);

C40

1 tryb kolorowy, 40

kolumn

C80

3 tryb kolorowy, 80

kolumn

MONO

7 tryb

monochromatyczny

80 kolumn

AJS

Sterowanie atrybutami znaków wysyłanymi na ekran

Bajt atrybutu znaków określa

kolor znaku,
podwyższoną jasność.
kolor jego tła,
migotanie

void textbackground(int newcolor);

kolor tła

textbackground(4);

czerwony kolor tła.

void textcolor(int newcolor);

kolor znaku

textcolor(2);

zielony kolor znaku.

void highvideo(void);

podwyższona jasność

void lowvideo(void);

normalna jasność

void normvideo(void);

przywraca stan

początkowy

AJS

stała

warto

ść

kolor

zastosowanie

BLACK

czarny

tło i znak

BLUE

niebieski

tło i znak

GREEN

zielony

tło i znak

CYAN

turkusowy

tło i znak

RED

czerwony

tło i znak

MAGENTA

karmazynowy

tło i znak

BROWN

brązowy

tło i znak

LIGHTGRAY

jasnoszary

tło i znak

DARKGRAY

ciemnoszary

znak

LIGHTBLUE

jasnoniebieski

znak

LIGHTGREEN

jasnozielony

znak

LIGHTCYAN

jasnoturkusowy

znak

LIGHTRED

jasnoczerwony

znak

LIGHTMAGENT
A

jasnokarmazyno

znak

YELLOW

żółty

znak

WHILE

biały

znak

BLINK

128

migotanie

znak

Stałe kolorów

AJS

Sterowanie pozycją i wyglądem kursora

void gotoxy(int x, int y);

umieszcza kursor w

pozycji x,y okna

gotoxy(20,3);

int wherex(void);

wartością jest

współrzędna x kursora

x=wherex;

int wherey(void);

wartością jest

współrzędna y kursora

y=wherey;

void setcursortype(int cur_t);

zmiana wyglądu

kursora

setcursortype(_NOCURSOR);

wyłącza kursor,

setcursortype(_SOLIDCURSOR);

kursor jako pełny prostokąt,

setcursortype(_NORMALCURSOR); normalny kursor w postaci podkreślenia,

AJS

Czyszczenie ekranu, usuwanie,

wstawienie wierszy,

void clreol(void);

usuwa wszystkie znaki od

pozycji kursora do

końca

wiersza

clreol();

void clrscr(void);

usuwa wszystkie znaki z

ekranu

clrscr();

void delline(void);

usuwa wiersz w pozycji

kursora

delline();

void insline(void);

wstawia pusty wiersz w

pozycji kursora

insline();

Operacje wejścia z konsoli (klawiatury)

int getch(void);

odczytuje znak z klawiatury

getch();

int getche(void);

odczytuje znak z klawiatury

i wysyła go na ekran

getche();

AJS

#include<iostream.h>
#include <conio.h>
main()
{
clrscr();
int i;
textmode(C40);
textbackground(15);
window(20,10,40,25);
   for (i=0; i<=15; i++)
   {
       textcolor(i);
       cout<<i<<"\t";
       cprintf("kolor \r\n");
   }
getch();
return 0;
}

Wydruk kolorów – od 0 do 15

kolor

AJS

Grafika tekstowa

obiektowe strumienie wyjścia na

ekran

Zarządzanie ekranem w trybie

tekstowym

Borland C++ - funkcje

Prototypy tych funkcji są umieszczone w bibliotece
constream.h

-umożliwiają

jednoczesną

obsługę

kilku

okien

tekstowych

Wyjście strumienia realizowane jest przez operator

a do formatowania danych wysyłanych na ekran służą

manipulatory

AJS

Manipulatory strumieni konsoli

constream.h

manipulator

anlogiczna
funkcja
ze zbioru conio.h

zastosowanie

clreol

usuwa znaki do końca wiersza

delline

usuwa wiersz tekstu

highvideo

włącza podwyższoną jasność

insline

wstawia pusty wiersz

lowvideo

włącza normalną jasność

normvideo

włącza normalne atrybuty
znaków

setattr(int

)

textattr

ustala atrybuty znaków

setbk(int)

textbackground

ustala kolor tła znaków

setclr(int)

textcolor

ustala kolor znaków

setcrtype(i

nt)

_setcursortype

steruje rozmiarem kursora

setxy(int,i

nt)

gotoxy

ustawia kursor na zadanej
pozycji

AJS

Grafika punktowa

Zarządzanie ekranem w trybie

graficznym

Borland C++ - funkcje graficzne

Funkcje graficzne pozwalają na:

- obsługę kart graficznych różnych typów (m.in. EGA,
VGA,IBM8512),

rysowanie

różnych

figur

geometrycznych

zastosowaniem różnych linii,

- kreślenie okręgów, elips, oraz ich wycinków z
możliwością ich wypełnienia,

wypełnianie

obszarem

wzorcem

własnym

lub

standardowym,

- tworzenie napisów w trybie graficznym,
- obsługę błędów operacji graficznych.

-Prototypy tych funkcji są umieszczone w bibliotece

graphics.h

AJS

Organizacja i zarządzanie

ekranem w trybie graficznym

Zarządzanie w trybie graficznym zależy

od typu

zainstalowanej w komputerze karty

graficznej

Rozdzielczość

(liczba punktów w pionie i poziomie)

Liczba kolorów

W pakiecie kompilatora Borland C++ dostarczane są sterowniki

grafiki umożliwiające współpracę z różnymi typami kart

BORLANDC\BGI\*.bgi

Hercules

EGA
VGA

SVGA

AJS

Schemat programu działającego w trybie

graficznym

#include <graphics.h>
#include <iostream.h>
#include <conio.h>
int inicjuj_grafike(int gdriver, int gmode, char *pathgdriver);
int main()
{
int ster=DETECT, tryb;
if (!inicjuj_grafike(ster, tryb, "c:\\studenci\\cpp\\borlandc\\bgi"))
return 0;
line(0,0,200,200);
getch();
closegraph();
}
int inicjuj_grafike(int gdriver, int gmode, char *pathgdriver)
{
initgraph (&gdriver, &gmode, pathgdriver);
if (graphresult()!=grOk)
{

cout<<"Blad w czasie uruchomienia grafiki";
return 0; }

else

return 1;

}

Operacje w trybie
graficznym

Zamknięcie trybu
graficznego

Prototyp funkcji
inicjuj_grafike

Definicja funkcji
inicjuj_grafike ze
sprawdzeniem
poprawności uruchomienia
trybu graficznego

Wywołanie funkcji inicjuj_
grafike

AJS

Funkcje zarządzające trybem graficznym

initgraph(int *graphdriver, int *graphmode, const char

*pathtodriver);

Funkcja inicjująca obsługę grafiki

*graphdriver –

wskaźnik zmiennej zawierającej liczbę określającą typ

sterownika grafiki,

Jeżeli graphdriver=DETECT – funkcja sama określi jaki sterownik i jaki
tryb pracy jest najbardziej odpowiedni.

*graphmode –

wskaźnik do zmiennej zawierającej numer trybu

graficznego dla danego sterownika

Jeżeli graphdriver=DETECT – wówczas wartość zmiennej graphmode nie
jest brana pod uwagę.

*pathtodriver –

łańcuch zawierający ścieżkę do katalogu ze

sterownikami grafiki (pliki *.bgi)

closegraph(void);

Funkcja zamykająca obsługę grafiki, przywraca tryb pracy

przed inicjacją

graphdefaults(void);

Funkcja przywraca domyślne parametry pracy w

aktualnym trybie.

AJS

Wybrane stałe sterowników graficznych i trybów

graficznych

Karta

graficzn

Stała i wartość

sterownika

graficznego

Stała i

wartość trybu

graficznego

karty

Tryb pracy karty

DETECT 0

EGA

EGA 3

EGALO 0

EGAHI 1

640x200, 16 kolorów, 4

strony

640X350, 16 kolorów, 2

strony

VGA

VGA 9

VGALO 0

VGAMED 1

VGAHI 2

640x200, 16 kolorów, 4

strony

640x350, 16 kolorów, 2

strony

640x480, 16 kolorów, 1

strona

IBM851

IBM8514 6

IBM8514LO

IBM8514HI

640x480, 256 kolorów

1024x768, 256 kolorów

AJS

Okna graficzne i ich obsługa

wybrane funkcje

cleardevice(void);

Czyści cały ekran graficzny tzn. wypełnia go kolorem tła i ustala

położenie na (0,0)

clearviewport(void);

Czyści aktualne okno graficzne i ustala położenie na (0,0) w nim.

int getmaxx(void);
int getmaxy(void);

Zwracają max wartość ekranowej współrzędnej x oraz y dla aktualnego

sterownika i trybu pracy.

setviewport(int left, int top, int right, int bottom, int clip);

Ustala

parametry

nowego

okna

graficznego

(setviewport(10,10,200,200,0). Gdy parametr clip=0 operacje graficzne

są ograniczone do obszaru okna.

AJS

Kolory

Każdemu pikselowi odpowiada wartość, która nie

określa koloru w sposób bezpośredni, lecz stanowi

indeks palety kolorów zawierającej faktyczną

informację o kolorze punktu.
W ten sposób na ekranie może być jednocześnie

wyświetlanych tyle kolorów, ile wpisów znajduje

się w palecie.

Sterowanie kolorami

setbkcolor(int color) –

ustala

kolor tła obrazu

setbkcolor(1);

setcolor(int color) –

ustala kolor

rysowania

setcolor(60);

Zarządzanie paletami

kolorów

stała

warto

ść

kolor

BLACK

czarny

BLUE

niebieski

GREEN

zielony

CYAN

turkusowy

RED

czerwony

MAGENTA

karmazynowy

BROWN

brązowy

LIGHTGRAY

jasnoszary

DARKGRAY

ciemnoszary

LIGHTBLUE

jasnoniebieski

LIGHTGREEN

jasnozielony

LIGHTCYAN

jasnoturkusowy

LIGHTRED

jasnoczerwony

LIGHTMAGENT

jasnokarmazyno

YELLOW

żółty

WHILE

biały

łe

ró

AJS

Wzorzec i kolor wypełnienia

setfillstyle(int pattern, int color);–

ustala

aktualne

parametry wypełniania obszarów pattern – wzorzec, color –kolor
wypełnienia

setfillstyle(6,4);

setfillpattern(const char *upattern, int color);–

pozwala

na zdefiniowanie wzorca przez użytkownika upattern –tablica
wzorca, color –kolor wypełnienia

setfillpattern(tab,4);

floodfill(int x, int y, int border);–

wypełnianie obszarów

otoczonych konturem. Parametry x,y określają punkt wewnątrz
wypełnianego konturu.

floodfill(10,20,4);

AJS

Sterowanie pozycją wskaźnika ekranu

(aktualną pozycją)

int getx(void);
int gety(void); –

wartością są aktualne współrzędne

wskaźnika ekranu.

getx();

gety();

moverel(int dx, int dy); –

przesuwa wskaźnik ekranu o

wektor (dx,dy).

moverel(20,30);

moveto(int x, int y); –

przesuwa wskaźnik ekranu do

punktu (x,y).

moveto(100,214);

AJS

Sterowanie wyglądem i sposobem kreślenia

linii

setlinestyle(int

linestyle,

unsigned

upattern,

int

thickness); –

ustalenie aktualnego rodzaju linii (faktury) –linestyle i

jej grubości –thickness, gdy linia definiowana jest przez użytkownika
wartość parametru upattern określa wzór linii użytkownika.

setlinestyle(0,0,3) –linia ciągła pogrubiona.

Stałe rodzajów linii (line_style)

stała

wartość

znaczenie

SOLID_LINE

ciągła

DOTTED_LINE

kropkowana

CENTER_LINE

symetrii

DASHED_LINE

przerywana

USERBIT_LINE

definiowana przez

użytkownika

Stałe grubości linii

NORM_WIDTH

normalna grubość

THICK_WIDTH

pogrubiona

AJS

Rysowanie punktów i linii

putpixel(int x, int y, int color); –

rysuje punkt w miejscu

o współrzędnych (x,y) i kolorze color

putpixel(45,36,4);

line(int x1, int y1, int x2 ,int y2); –

rysuje linię od

punktu (x1,y1) do punktu (x2,y2)

line(45,36,4,5);

linerel(int dx, int dy); –

rysuje linię od punktu aktualnej

pozycji wskaźnika do punktu oddalonego o wektor (dx,dy).

linerel(5,36);

lineto(int x, int y); –

rysuje linię od punktu aktualnej

pozycji wskaźnika do punktu o współrzędnych (x,y).

lineto(25,36);

AJS

Rysowanie –

prostokąt, wielokąt,

łamane

rectangle(int left, int top, int right, int bottom); –

funkcja

rysuje prostokąt rozpięty między punktami (left,top) i (right,bottom)
używając aktualnego koloru, rodzaju i grubości linii)

rectangle(4,5,34,56);

bar(int left, int top, int right, int bottom); –

funkcja wypełnia

prostokątny obszar rozpięty między punktami (left,top) i (right,bottom)
używając aktualnego koloru i wzorca)

bar(45,36,48,58);

drawpoly(int numpoints, const int *polypoints); –

funkcja

rysuje łamaną o liczbie wierzchołków określonych parametrem
numpoints używając aktualnego koloru, rodzaju i grubości linii.

drawpoly(45,*tab1);

fillpoly(int numpoints, const int *polypoints); –

funkcja

rysuje łamaną o liczbie wierzchołków określonych parametrem
numpoints używając aktualnego koloru, rodzaju i grubości linii a
następnie wypełnia zamkniętą łamaną.

fillpoly(45,*tab1);

AJS

Rysowanie –

okrąg, elipsa, łuk

arc(int x, int y, int stangle, int endangle, int radius); –

łuk o

środku w punkcie (x,y) i promieniu radius. Łuk ten kreślony jest od kąta
stangle

do kąta endangle

arc(4,5,34,0,90);

circle(int x, int y, int radius); –

okrąg o środku w punkcie (x,y) i

promieniu radius.

circle(100,150,90);

ellipse(int x, int y, int stangle, int endangle, int xradius, int
yradius); –

eliptyczny łuk o środku w punkcie (x,y) i półosiami poziomą

xradius i pionową yradius. Łuk ten kreślony jest od kąta stangle

do kąta

endangle

ellipse(4,5,0,90,20,10);

fillellipse(int x, int y, int xradius, int yradius); –

elipsa o środku w

punkcie (x,y) i półosiami xradius i yradius i wypełnia bieżącym wzorcem i
kolorem.

fillellipse(4,5,20,10);

pieslice(int x, int y, int stangle, int endangle, int radius); –

wycinek koła

sektor(int x, int y, int stangle, int endangle, int xradius,
yradius); –

wycinek elipsy.

AJS

Teksty w trybie graficznym

settextjustyfy(int horiz, int vert); –

tryb justowania tekstu dla

poziomego horiz ( LEFT_TEXT – 0) i pionowego vert (BOTTOM_TEXT – 0)

settextjustyfy(0,0);

settextstyle(int font, int direction, int charsize); –

krój pisma

–font (SMALL_FONT – 2), kierunek wysyłania znaków na ekran –direktion
(HORIZ_DIR), rozmiar znaków –charsize.

settextstyle(2,HORIZ_DIR,5);

outtext(const char *textstring); –

wyświetla w aktualnym oknie

łańcuch znaków wskazanych parametrem textstring od aktualnej wartości
wskaźnika ekranu.

outtext(*napis);

outtextxy(int x, int y, const char *textstring); –

wyświetla w

aktualnym oknie łańcuch znaków wskazanych parametrem textstring przy
zachowaniu aktualnych parametrów tekstowych począwszy od punktu
(x,y).

outtextxy(34,45,*napis);

AJS

#include <graphics.h>
#include <iostream.h>
#include <conio.h>
int inicjuj_grafike(int gdriver, int gmode, char *pathgdriver);
int main()
{
int ster=DETECT, tryb,tab[]={10,430,60,450,50,460,5,470};
if (!inicjuj_grafike(ster, tryb, "c:\\studenci\\cpp\\borlandc\\bgi"))
return 0;

Blok instrukcji do rysowania prostej grafiki

getch();
closegraph();
}
int inicjuj_grafike(int gdriver, int gmode, char *pathgdriver)
{
initgraph (&gdriver, &gmode, pathgdriver);
if (graphresult()!=grOk)
{

cout<<"Blad w czasie uruchomienia grafiki";
return 0; }

else

return 1;

}

Program graficzny do rysowania prostej
grafiki

graf-i.exe

AJS

setbkcolor(15);

//kolor tla - bialy

putpixel(100,5,4);

//rysowanie punktu (kolor czerwony)

setcolor(4);

//kolor rysowania - czerwony

settextstyle(10,HORIZ_DIR,0);

//ustawienie stylu tekstu

outtextxy(105,5,"- putpixel(100,5,4);- punkt");

//wyprowadzenie tekstu

moveto(20,40);

//ustalenie aktualnego polozenia wskaznika

setcolor(2);

lineto(100,40);

//rysowanie linii do punktu

setcolor(1);

setlinestyle(0,0,3);

//ustawienie stylu linii (ciagla pogrubiona)

line(20,60,100,60);

outtextxy(105,60,"- line(20,60,100,60);- ostatnia linia ");

setcolor(5);

circle(50,100,20);

//rysowanie okregu

outtextxy(105,100,"- circle(50,100,20);- okrag ");

setcolor(6);

ellipse(50,140,0,270,30,10);

//rysowanie elipsy

outtextxy(105,140,"- ellipse(50,140,0,270,30,10);- elipsa ");

setcolor(7);

arc(50,180,100,250,20);

//rysowanie luku

outtextxy(105,180,"- arc(50,180,100,250,20); -luk");

Blok instrukcji do rysowania prostej grafiki

AJS

setcolor(1);

setfillstyle(4,4);

//ustawienie stylu wypelnienia

fillellipse(50,230,40,15);

//rysowanie elipsy

wypelnionej

outtextxy(105,215,"- setfillstyle(4,4); - wypelnienie");

outtextxy(105,230,"- fillellipse(50,230,40,15);- elipsa wypelniona");

setfillstyle(1,12);

pieslice(50,280,150,270,35);

//rysowanie wycinka

kola

outtextxy(105,280,"- setfillstyle(1,12); - wypelnienie");

outtextxy(105,295,"- pieslice(50,280,150,270,35);- wycinek kola");

setfillstyle(5,4);

rectangle(10,320,100,350);

//rysowanie prostokata

bar(10,320,100,350);

//wypelnienie obszaru

prostokatnego

outtextxy(105,330,"- bar(10,320,100,350); - wypelnienie obszaru
prostokatnego");

outtextxy(105,345,"- rectangle(10,320,100,350);

- rysowanie

prostokata");

bar3d(10,380,60,410,20,1);

//trojwymiarowy

prostopadloscian

outtextxy(105,380,"- bar3d(10,380,60,410,20,1); -trojwymiarowy
prostopadloscian");

settextstyle(4,HORIZ_DIR,0);

setcolor(11);

drawpoly(4,tab);

//rysowanie lamanej

outtextxy(105,430,"-drawpoly(4,tab); -rysowanie lamanej");

Blok instrukcji do rysowania prostej grafiki
cd

AJS

#include <graphics.h>

#include <iostream.h>

#include <conio.h>

void main()

{

int gdriver=DETECT, gmode;

initgraph (&gdriver, &gmode, "c:\\studenci\\cpp\\borlandc\\bgi");

setbkcolor(0);

setcolor(4);

setlinestyle(0,0,3);

for(int j=0,t=1;j<100,t<10;j=j+25,t++)

{

setcolor(t);

for (int i=0;i<25;i++)

{

circle(320,240,j+i);

}

getch();

closegraph();

}

Tarcza

tarcza.exe

AJS

#include <graphics.h>

#include <iostream.h>

#include <conio.h>

void main()

{

int gdriver=DETECT, gmode;

initgraph (&gdriver, &gmode, "c:\\studenci\\cpp\\borlandc\\bgi");

setbkcolor(0);

setcolor(4);

setlinestyle(0,0,3);

for(int j=0,t=1;j<100,t<10;j=j+25,t++)

{

setcolor(t);

for (int i=0;i<25;i++)

{

circle(j+i,240,j+i);

}

getch();

closegraph();

}

Pawie oczko

pawie.exe

AJS

#include <graphics.h>

#include <iostream.h>

#include <conio.h>

const double alpha=20;

void spirala (double lg, double x, double y);

int inicjuj_grafike(int ster, int tryb, char *scster);

int main()

{

int gdriver=DETECT, gmode, errorcode;

if (!inicjuj_grafike(gdriver, gmode, "c:\\studenci\\cpp\\borlandc\\bgi"))

return 0;

setbkcolor(14);

setcolor(4);

setlinestyle(0,0,3);

moveto(150,100);

spirala (getmaxx()/2,getx(),gety());

getch();

closegraph();

}

Spirala – funkcja rekurencyjna

spirala.exe

AJS

int inicjuj_grafike(int ster, int tryb, char *scster) {

initgraph (&ster, &tryb, scster);

if (graphresult()!=grOk)

{ cout<<"Blad";

return 0; }

else

return 1;

}

void spirala (double lg, double x, double y)

{

if (lg>0)

{

lineto (x+lg,y);

lineto (x+lg,y+lg);

lineto (x+alpha, y+lg);

lineto (x+alpha, y+alpha);

spirala (lg-2*alpha, x+alpha, y+alpha);

}

Spirala – funkcja rekurencyjna cd.

funkcja

rekurencyjna

Document Outline