Osnove Programiranja C++ Builder Enterprise

Primer 1:Napraviti aplikaciju koja se sastoji od dva dugmeta LATINICA i CIRILICA. Prilikom

startovanja aplikacije u zaglavlju forme nema teksta. Prilikom klika na dugme LATINICA u zaglavlju forme se ispisuje tekst Pismo je LATINICA a pritiskom na dugme CIRILICA u zaglavlju forme se ispisuje tekst Pismo je CIRILICA.

Rešenje:

1. Pokrenite Borland C++ Buillder tako što kliknete na Windows ikonicu kao na slici.

2. Snimanje projekta aplikacije

Formirajte novi folder pod imenom Dugmadi.U polje File Name umesto Unit 1 upišite

Dugmadi_o, što predstavlja fajl koji opisuje prozor aplikacije. Klikni na Save.

U novom prozoru upisati samo Dugmadi, čime je snimljen projekat aplikacije.

3. Starovanje aplikacijePrevođenje programa i startovanje programa vrši se klikom na zeleno dugme sa

strelicom. , ili opcija Run iz menija Run ili prečica F9.

1

Zatvorimo aolikaciju i pomoću MyComputera otvorite folder Dugmadi. Tu se vide više fajlova koji opisuju aplikaciju, a najvažniji su: Dugmadi.exe i Dugmadi.bpr. Duplim klikom na Dugmadi.bpr otvaramo projekat aplikacije.

4. Prokjektovanje aplikacijePravljenje programa prolazi kroz tri osnovne faze: projektovanje aplikacije, unos programskog koda i otklanjanje grešaka.Projektovanje aplikacije predstavlja formiranje izgleda aplikacije, tj postavljanje komponenti I podešavanje njihovih osobina ili svojstava.

Dugme upravvljčkog menija

Glavni meni

Speed Bar Paleta komponenti

Sve komponente nalaze se na paleti komponenti, kao na slici. Paleta komponenti sastoji se od kartica na kojima se komponente nalaze. Dugme je komponenta pod nazivom Button I nalazi se na kartici Standard.Klikni na komponentu Button a potom klikni na formu i na taj način se dugme nalazi na formi. Ponoviti postupak i sa drugim dugmetom.

5. Podešavanje svojstava ili osobina komponentiPodešavanje svojstava komponenti u toku projektovanja aplikacija vrši se pomoću ObjectInspectora.

ObjectInspector sa slike ima dve kartice: Properties i Events. Karticom Properties podešavaju se svojstva komponenti.

Podešavanje osnovnih svojstava Forme:Caption – Tekst u zaglavlju forme.

Po uslovu zadatka prazan tekst, te obrišite polje unosa.

BorderStyles – Podesite da je Single, a to znači da se prozor aplikacije ne može povećavati niti smanjivati. Imaće tri dugmeta u zaglavlju kao i svaki Windows prozor.

Width – Šitrina prozoraHeight – Visina prozora

2

Širina i visina prozora može se podešavati manipulacijom prozora tokom projektovanja ili direktnim upisivanjem brojčanih vrednosti.

Podešavanje osnovnih svojstava dugmeta ili komponente Button :Caption – Natpis dugmeta, kod prvog je LATINICA a kod drugog

CIRILICA.Font – Podešavanje fonta vrši se tako što se klikom na polje pojavljuje

kartica fonta gde se vrše podešavanja.

Podesite kod oba dugmeta da je Size 12 a Font style Bold i kliknite na OK.

6. Unošenje programskog kodaProgramski kod se sprovodi kroz događaje komponente. Na osnovu teksta zadatka ustanovi se koji događaj je u pitanju. U ovom primeru kaže se kada se klikne na dugme desiće se promena teksta u zaglavlju prozora aplikacije. Zaključili ste da je događaj dugmeta OnClick. Označimo dugme, pređemo na ObjectInspector i karticu Events i u polje napravimo dupli klik. U prozoru koda ugrađen je događaj i kursor se nalazi u telu događaja. Šta tu napišemo desiće se prilikom događaja klik na dugme. Uglavnom se dešavanja odvijaju pomoću operatora dodele a to je znak =.Sa leve strane je svojstvo a sa desne strane operatora dodele vrednost koju će to svojstvo imati.

Form1->Caption="Pismo je LATINICA";

U naredbi dodele prvo se navodi naziv komponente u ovom slučaju je to Form1 a nakon strelice svojstvo a to je Caption. Sa desne strane operatora dodele = je tekst koji će biti zapisan u zaglavlju forme.

3

Caption je svojstvo tipa string, a string predstavlja tekst koji se nalazi između znakova navoda.

Naredba se završava sa znakom tačka zarez.

Kod aplikacije ima sledeći izgled://---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "zaglavlje_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){

//Prvo se pise ime komponente, a nakon strelice svojstvo. Form1->Caption="Pismo je LATINICA";//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ //Caption je string ili tekst koji se nalayi izmedju ynakova navoda. Form1->Caption="Pismo je CIRILICA}";//---------------------------------------------------------------------------

Primer 2:Napraviti aplikaciju koja

omogućava promenu boje komponente Label čiji tekst je zapisan u ćiriličnom pismu fomta 24pt velikim slovima a tekst je POKAZNI TEKST. Boja teksta je crvena. Klikom na tekst boja se iz crvene menja u plavu. Ako je tekst bio plav boja se menja u zelenu, a ako je bio zelen boja se menja u crvenu itd.

Rešenje:

U zadatku se pojavljuje nova komponenta Label . Komponenta ima zadatak da prikaže neki tekst, bilo kao naslov ili opis šta se prikazuje ili koji podatak treba uneti. Komponenta se nalazi na kartici Standard.

Bitna osobina Labele je mogućnost prikaza latiničnih i ćiriličnih slova.Potrebno je kliknuti na plus sa leve strane svojstva Font u ObjectInspectoru, čime će se

pojaviti dodatna svojstva Nas ineresuje svojstvo Charset. Postoji više vrednosti Charseta a za nas

4

su bitne dve vrednosti: ESTAUROPE_CHARSET (za prikaz latiničnih slova) i RUSSIAN_CHARSET (za prikaz ćiriličnih slova). Potrebno je u ovom primeru podesiti RUSSIAN_CHARSET i u Widdowsu ćirilično pismo. Sada se može unositi tekst u polju Caption ObjectInspectora. Karakteri u polju ObjectInspektora nisu isti kao u Labeli na formi. Tačan ispis je u komponenti. Ako nam takav tekst treba u kodu izvršite kopiranje iz poja Caption ObjectInspectora.

Na osnovu teksta zadatka vidimo da nam je potreban događaj OnClik za Labelu. U ObjectInspectoru pređemo na karticu Events, izaberemo događaj OnClick i u polju duplo kliknete. Pojaviće se kod događaja. Ako ste slučajno izabrali pogrešan događaj, bitno je da je telo događaja prazno, a potom izvrimo snimanje SaveAll aplikacije i prazni događaji biće izbrisani.

Za rešavanje zadataka moramo znati sintaksu C++ jezika, tj naredbu selekcije if-else i relacione operatore.

if – else naredba:

if(uslov) naredba1; Ako je uslov zadovoljen izvršavaće se naredba1, a else naredba2; suprotnom naredba2.

U uslovu se nalaze relacioni i logički operatori. Sada su nam bitni samo relacioni operatori.

Relacioni operatori su: < (manje), > (veće), <= (manje ili jednako), >= (veće ili jednako), == (jednako) i != (različito).

Kao rezultat relacione operacije je vrednost: true (uslov je zadovoljen) ili false (uslov nije zadovoljen).

Ako je potrebno osim jedne naredbe, kada je uslov zadovoljen ili nije zadovoljen, izvršiti, potrebno je koristiti blokove ili sekvence. Sekvenca ili blok je niz naredbi koji se nalaze između zagrada { }.

if(uslov) Nemojte stavljati tačku zarez posle male zagrade, jer { tada kao I da niste napisali naredbu selekcije. Najčešće

Naredba1; greške su: u uslovu umesto operatora jednako == pišete Naredba2; operator dodele =, Naredbe ne pišete u bloku, I ne vršiti … nazubljivanje koda, da se vidi šta je u bloku, tako da

}else{ teško posle otklanjate kreške.Naredba 3;Naredba4;…

}

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "novi_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

5

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Label1Click(TObject *Sender){

//Ako je boja slova Labele crvena postavljamo da je plava if(Label1->Font->Color==clRed) Label1->Font->Color=clBlue; else{

//Ako nije crvena (u suprotnom) znaci da je plava ili zelena //Pitamo da li je boja slova plava, te ako jeste postavljamo da je zelena //u suprotnom znaci da je zelena te je postavljamo da je crvena.

if(Label1->Font->Color==clBlue) Label1->Font->Color=clGreen; else Label1->Font->Color=clRed; }}//---------------------------------------------------------------------------

Primer 3:Napraviti aplikaciju kosa se sastoji

od tri gumeta na formi kao na slici. Na formi se nalazi latinični tekst POKAZNI TEKST crne boje fonta 48. Kada se klikne na dugme sa natpisom PLAVA, boja teksta postaje plava, ako se klikne na dugme sa natpisom CRVENA, boja teksta postaje crvena, a ako se klikne na dugme ZELENA, boja teksta postaje zelena.

Rešenje:

Prilikom postavljanja dugmadi, prvo postavite jedno dugme i izvršite sva potrebna podešavanja. Sada označite komponentu, napravite desni klik, izaberete opciju Edit a iz nje Copy. Pojaviće se potpuno identično dugme samo sa novim nazibvom. Na ovaj način smo izbegli podešavanje svojstava. Kopiranje raditi kada niste podesili događaje, jer će nova kopirana komponenta posedovati i iste događaje kao I komponenta od koje je kopirana.

Kopirajte i trećw dugme te izvršite samo promenu natpisa kod trećeg i drugog dugmeta. Vrednosti boje slova Labele treba u kodu promeniti. To se radi tako što pišemo:

Label1->Font->Color=clBlue;

Prvo se navodi komponenta, nakon strelice bira opcija Font (boja slova je u pitanju), pa nakon strelice svojstvo Color. Svojstvo Font je složeno svojstvo i sastoji se

6

od podsvojstava. Kada smo u ObjectInspectoru birali Font pojavila se kartica a ona je sadržala u sebi više svojstava.

Boja počinje sa cl a potom se navodi odgovarajuća reč na Engleskom jeziku date boje koja počinje velikim slovom.

Za svako dugme treba pisati poseban događaj.Kako je OnClik osnovni događaj komponente Button, to se događaj može formirati

i duplim klikom na dugme sa forme za koji se događaj želi napisati.//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "za3_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Label1->Font->Color=clBlue; }//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Label1->Font->Color=clRed; }//---------------------------------------------------------------------------void __fastcall TForm1::Button3Click(TObject *Sender){ Label1->Font->Color=clGreen;}//---------------------------------------------------------------------------

Primer 4:Napraviti aplikaciju koja kada se

startuje u yaglavlju ni[tan e pi[e. Klikom na neko dugme sa slike, tekst pored dugmeta postaje plave boje a sve ostale ctne boje, a vrednost broja u tekstu se uve’ava ya jedan.

U zaglavlju forme piše koje dugme je kliknuto.

Rešenje:

7

Za rešavanje ovog zadatka potrebno je znati kako se u programu koriste brojači. Brojač je promenljiva koja ima neko svoje ime, u ovom slučaju reč br i simboliše vrednost

podatka u memoriji računara. Kada se spominje memorija misli se na RAM memoriju. Promenljiva omogućava da se pristupi nekom podatku, a programi se bave obradom podataka. Svaki podatak ima svoje osobine ili tip. Tip podatka određuje u kom opsegu vrednosti se podatak može nalaziti, kao i skup operacija koje se nad podakom mogu izvršiti. Podaci su u C++ -u podeljeni na osnovne i izvedene.

Osnovni tipovi podataka određeni su sa odgovarajućom rezervisanom rečju. Najvažniji tipovi podataka su:

int – Celobrojan tipchar – znakovni tipfloat – racionalni tipdouble4 – racionalni tip duple preciznostibool – logički tip, sa mogućim vrednostima true i falseAnsiSttring – Tekst, I predstavlja izvedeni tip koji se koristi kod svojstva Caption.

Brojačka promenljiva je tipa int. Svaka promenljiva se pre korišćenja mora deklarisati. Deklaraciom prevodiocu se saopštava da je neki indentifikator promenljiva i kog je on tipa, jer će u suprotnom prijavljivati grešku da je indentifikator nepoznat, a operativni system će odvojiti na osnovu tipa promenljive proctor u memoriji.

U ovom zadatku deklaracija promenljiv br je: int br;

Brojačka promenljiva funkcioniše tako što je njena početna vrednost nula, a kada se stekne uslov brojanja njena vrednost se naredbom dodele uvećava za jedan.

br=br+1;

Metode koje važe za sva svojstva koja su tipa AnsiString – a, su StrToInt(), IntToStr(), StrToFloat() i FloatToStr(). Funkcija StrToInt() konveruje string u celobrojni podatak, dok IntToStr() konvertuje celobrojni podatak u AnsiString. Slično je i sa funkcijama StrToFloat() i FloatToStr().

br = StrToInt(Label1->Caption);

Ovom naredbom konvertuje se string koji se nalazi u komponenti Label1 u tip int i kao takav dodeljuje promenljivoj br.

Label1->Caption = IntToStr(br);

Konvertuje se celobrojni podatak iz promenljive br I smešta kao tekst komponente Label1.

//---------------------------------------------------------------------------#include "za26_o.h"#include <vcl.h>#pragma hdrstop#include "za26_o.h"#pragma package(smart_init)

8

#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int br;

Label1->Font->Color=clBlue; Label4->Font->Color=clBlue; Label5->Font->Color=clBlue;

Label2->Font->Color=clBlack; Label3->Font->Color=clBlack; Label6->Font->Color=clBlack;


br=StrToInt(Label4->Caption); br=br+1; Label4->Caption=StrToInt(br);

Form1->Caption="KLIKNUTO JE PRVO DUGME";}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ int br;





9

Form1->Caption="KLIKNUTO JE DRUGO DUGME";}//---------------------------------------------------------------------------void __fastcall TForm1::Button3Click(TObject *Sender){ int br;





Form1->Caption="KLIKNUTO JE TTRECE DUGME";}//---------------------------------------------------------------------------

Primer 5:Napraviti aplikaciju koja sadrži dva dugmeta. Na prvom postoji natpis Serbian (Czrilic), a

na drugom Serbian (Latin). Kada se pritisne prvo dugme na ekranu se ispisuje tekst crvenom bojom ćiriličnim pismom, a kada se pritisne drugo dugme ispisujese isti tekst latiničnim pismom. Tekst je centrirano poravnat u okviru kontrole Label, i postoji samo jedna kontrola label u aplikaciji. Izgled aplikacije je:

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

10

#include "SvojstvaKontrola_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Button1->SetFocus(); //Metodom SetFocus() komponenta postaje aktivna //Podesavamo pismo gde se nalaze cirilicna slova. Label1->Font->Charset= RUSSIAN_CHARSET;

Label1->Font->Color=clRed; //Podesavamo boju slova.

//Ispisujemo tekst. Prilikom unosa teksta mora se kao i kod rada sa wordom podesiti //pismo sa tas bara na Serbian (Cyrilic.) Tekst je prekopiran iz polja Caption //ObjectInspectora, i bez obzira što su nam ovde čudna slova, na komponenti slova su u redu.

Label1->Caption="ÎÂÎ £Å £ÅÄÀÍ ÄÓÃÀ×ÀÊ ÒÅÊÑÒ\nÍÀÏÈÑÀÍ ŽÈÐÈËÈÖOM!!";}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Button2->SteFocus(); //Metodom SetFocus() komponenta postaje aktivna

//Podesavamo pismo gde se nalaze latinicna //slova Label1->Font->Charset= EASTEUROPE_CHARSET;. Label1->Font->Color=clBlue; //Podesavamo boju slova.

//Ispisujemo tekst. Prilikom unosa teksta mora se kao i kod rada sa wordom podesiti //pismo sa tas bara na Serbian (Latin.) Tekst je prekopiran iz polja Caption //ObjectInspectora, i bez obzira što su nam ovde čudna slova, na komponenti slova su u redu.

Label1->Caption="OVO JE JEDAN DUGAÈAK TEKST\nNAPISAN LATINICOM!!";}//---------------------------------------------------------------------------

Primer 6:Napraviti aplikaciju koja se sastoji od forme i miša oblika peščanog sata sa znakom pitanja.

U zaglavlju forme nalaze se trenutne koordinate miša.

11

Rešenje:

Događjaj OnMouseMove dešava se prilikom premeštanja miša nad komponentom.Događaj se u ovom primeru odnosi na formu. Kao argument događaja nalaze se i

koordinate miša X i Y koji su celobrojnog tipa int. Ispis stringa kada je potrebno to uraditi u nekom formatu radi se naredbom Format.

Naredba format sastoji se od dva dela: prvi deo je string koji se nalazi između znakova navoda i niza konstanti. U okviru stringa nalaze se I formati. Svaki format počinje sa karakterom % iza koga sledi slovo konverzije. Slovo d označava da će se izvršiti konverzija celobrojnog podatka, dok slovo f da se radi o konverziji celobrojnog podatka. Broj konstanti koji se nalaze u nizu konstanti mora odgovarati broju formata.


#include "mis_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift, int X, int Y){ Caption=Format("X = %d Y = %d",ARRAYOFCONST((X,Y)));}//---------------------------------------------------------------------------

Primer 7:Napraviti aplikaciju koja omogučava unos teksta u komponenti Edit a pritiskom na dugme

uradi tekst se kopira u novu Edit komponentu koja služi samo ya čitanje podataka. Pritiskom na dugme brisi sadržaji Edit komponenti se brišu.

12

Rešenje:

Unos podataka vrši se najčešće pomoću komponente Edit . Lomponenta Edit nalazi se na kartici Standard.

Komponenta Edit poseduje neka specifična svojstva:Text – Sadrži tekst u posmatranom okviru. Njegova vrednost može da se

postavlja za vreme projektovanja, da se promeni za vreme izvršavanja kako iz programa, tako i kao posledica onoga što korisnik otkuca sa tastature.

CharCase – Određuje kako će se slova predstavljati u tekstu prilikom unosa. Moguće vrednosti su: ecNormal (slova se prihvataju onako kako se unose sa tastature), ecUpperCase (sva slova se pretvaraju u velika) i ecLowerCase (sva slova se pretvaraju u mala).

PaswordChar – Predstavlja znak za lozinku. Podrazumevana vrednost #0 označava da se u okviru normalno prikazuje tekst koji se unosi preko tastature.

MaxLength – Određuje najveći broj znakova koji korisnik može da unese preko tastature u okvir za tekst. Podrazumevana vrednost 0 označava da ne postoji ograničenje.

ReadOnly – Svojstvo je tipa bool pri čemu vrednost true označava da korisnik u dati okvir za tekst korisnik ne može da unese podatke preko tastature.

Modified – Svojsto je tipa bool sa vrednošću true ako je sadržaj okvira za tekst menjan od stvaranja komponente, odnosno od poslednjeg postavljanja te vrednosti na false. Ovo svojstvo je raspoloživo samo za vreme izvršavanja aplikacije.

AutoSelect – Svojstvo je tipa bool sa vrednošću true ako se sadržaj teksta automatski obeleži kada komponenta dobije fokus.

HideSelection – Svojstvo je tipa bool sa vrednošću false ako obeleženi deo teksta unutar okvira ostaje obeležen i kada komponenta izgubi fokus.

SelectStart – Predstavlja indeks prvog znaka u obeleženom tekstu.SelTextt – Predstavlja obeleženi deo teksta unutar okvira za tekst.SelLength – Predstavlja broj znakova u obeleženom delu teksta.

Komponenta Edit poseduje sledeće metode:Clear – Briše sadržaj Text svojstva.ClearSelected – Briše samo sadržaj teksta koji je selektovan.CopyToClipboard – Kopira selektovani tekst u Clipboard.CutToClipboard – Briše selektovani tekst i kopira ga u Clipboard.PasteFromClipboard – Kopira sadržaj Clipboarda na mesto kursora. SelectAll – Selektuje kompletan tekst.GetSetTextBuf – Kopira selektovani tekst u zadatu promenljivu.SetSelTextBuf - Zamenjuje selektovani tekst tekstom iz zadate promenljive..

Osnovna svojstva komponente Button su:

Default – Svojstvo je tipa bool. Ako svojstvo ima vrednost true pritiskom na taster ENTER aktivira se dugme kao da smo ga kliknuli mišem bez obzira koja komponenta ima fokus. Podrazumevana vrednost ovog svojstva je false. Koristi se kada hoćemo da napravimo dugme OK.

13

Cancel – Svojstvo je tipa bool. Ako svojstvo ima vrednost true pritiskom na taster ESC aktivira se dugme kao da smo ga kliknuli mišem bez obzira koja komponenta ima fokus. Podrazumevana vrednost ovog svojstva je false. Koristi se kada hoćemo da napravimo dugme Cancel.

Podesiti prilikom projektovanja da oba dugmeta imaju svojstvo Default na vrednost true, dok prvo dugme ima svojstvo Enabled true a drugo false.//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "drugi_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Edit2->Text=Edit1->Text; //Kopira se tekst iy Edita1 u Edit2 dodelom vrednosti.

//Svojstvo Enabled odredjuje da li komponenta moye imati focus. Ako je vrednost false //nemoze //imati focus. i sive je boje. Prilikom projektovanja postavili smo da je prvo //dugme aktivno a drugo neaktivno.

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text=""; Edit2->Clear(); Button1->Enabled=true; Button2->Enabled=false; }//---------------------------------------------------------------------------


omogućaba unos imena korisnika aplikacije i nakon pritiska na taster POTVRDI predaje korisniku pozdravnu poruku. U slučaju da korisnik nije uneo svoje ime umesto pozdravne poruke dobija informaciju o grešci.

14

Rešenje:

#pragma hdrstop#include "Zadatak1_o.h" //Ukljucuje se heder fajl gde se nalazi klasa koja opisuje formu.//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1; //Form1 je obekat (nasa forma) koja je tipa klase TForm1.//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//Ovde se obradjuje dogadjaj misa kada se klikne na dugme Button1.// Do tela ove funkcije dolazi se duplim klikom na komponentu Button1 koja //je postavljena na formu.void __fastcall TForm1::Button1Click(TObject *Sender){

//Programer je imao zadatak da samo obradi ovaj dogadjaj. Sve komponente //su objekti kojima se pristupa pomocu operatora -> sto smo imali i kod//dinamickog programiranja. Komponenta Edit1 ima svojstvo Text koje nam daje//sadrzaj edita (da li je korisnik uneo nesto ili ne). Ako nije svojstvo Text bice//prazan string. Pozivanjem metode ShowMessage na ekranu ce se pojaviti poruka.//Sadrzaj koji se nalazi kao string zapisan u ovoj metodi bice prikazan.

if(Edit1->Text=="") ShowMessage("Greska!! Niste uneli svoje ime?"); else{

//Za razliku od C-a gde smo morali koristiti funkciju strcat da bi nadovezali// jedan string na kraj drugog stringa u programskom jeziku C++ koristi se// operator +, sto predstavlja pojednostavljenje

ShowMessage("Zdravo "+Edit1->Text+"!!"); Edit1->Text=""; }

//Nakon zatvaranja poruke potrebno je obezbediti da korisnik programa moze// ponovno unositi novo ime To se postize tako sto komponenta Edit1 postaje //ponovno aktivna, a programeri kazu da je ponovno dobila fokus.

Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 9: Napraviti aplikaciku koja omogućava samo nenjanje

podataka mreže (broja čvorova i broja grana) i automatsko menjanje broja jednačina po prvom (SKZ) i drugom (NKZ) zakonu. Menjanje CSpinEdita isključivo se vrši pomoću strelica gore i dole. Minimalni broj čvorova je 2, a maksimalni 10, korak je 1. Minimalni broj grana je 3, maksimalni 10, a

15

korak 1. Ako se desi da broj grana postane jednak sa brojem čvorova vrši se resetovanje oba CSpinEdita na minimalne vrednosti.

Rešenje:

Komponenta SpinEdit služi za unošenje celobrojnih podataka, čije vrednosti mogu da se menjaju i pritiskanjem dva mala dugmeta, koja se nalaze uz desnu ivicu okvira. Svakim pritiskom na dugme sa strelicom nagore, vrednost u okviru se povećava, a pritiskom na dugme nadole smanjuje, za određenu vrednost. Komponenta se nalazi na paleti komponenti na kartici Samples.

Bitnija svojstva koja nisu pomenuta su:Value – Označava vrednost broja u okviru za tekst. Podrazumevana vrednost je 0.

U object Inspectoru njegovim podešavanjem dobija se početna vrednost prilikom startovanja aplikacije.

Increment – Predstavlja iznos promene svojstva Value nakon pritiskanja malih dugmadi. Pritiskom na malo dugme sa strelicom nagore vrednost Value se povećava za vrednost Incrementa, a pritiskanjem na malo dugme sa strelicom nadole smanjuje za vrednost Incrementa.

MaxValue – Označava maksimalnu vrednost broja koja može da se nađe u okviru.MinValue – Označava minimalnu vrednost broja koja može da se nađe u okviru

Podrazumevana vrednost 0 označava da ne postoji ograničenje.

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "za24_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::CSpinEdit1Change(TObject *Sender){ int brc,brg;

brc=CSpinEdit1->Value; //brc je brij cvorova. brg=CSpinEdit2->Value; //brg je broj grana

if(brc>=brg) { ShowMessage("Broj grana mora biti ve'i od broja cvorova!!"); CSpinEdit1->Value=CSpinEdit1->MinValue; CSpinEdit2->Value=CSpinEdit2->MinValue; }else{

16

Label5->Caption=IntToStr(brc-1); Label6->Caption=IntToStr(brg-brc+1);}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){

//Doga]aj se desava prilikom kreiranja forme //Podesava se tekst yaglavlja ShowMessage dialoga.

Application->Title="GRESKA..."; }//---------------------------------------------------------------------------

Primer 10:Napisati aplikaciju koja omogućava unos dva operanda i izračunava njihov zbir. U polje

Edit komponente koja je žute boje treba upisati rezultat ili poruku da neki od operanada nije unesen i toj komponenti dati fokus.

Rešenje:

if naredba:

if(uslov) naredba; Ako je uslov zadovoljen izvršavaće se naredba

Ako je potrebno osim jedne naredbe, kada je uslov zadovoljen, izvršiti, potrebno je koristiti blokove ili sekvence. Sekvenca ili blok je niz naredbi koji se nalaze između zagrada { }.

if(uslov) { Naredba1; Naredba2; …

17

}

Aritmetičiki operatori su: + (sabiranje), - (oduzimanje), * (množenje), / (deljenje), % (ostatak prilikom celobrojnog deljenja).

Logički operatori su: && (Logičko I), || (Logičko ILI) i ! (negacija).

Naredba return predstavlja povratak iz funkcije ili događaja.


#include "kvadratna_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float a,b,c; //Na pocetku dogadjaja moraju se deklarisati sve promenljive.

//Na pocetku se mora izvrsiti zastita. Sadrzaj komponenti Edit su tipa Ansistring, odnosno //tekstovi. Do rezultata se moze doci jedino ako se iyvrsi konverzija podataka iz teksta u //broj. Ako teksta nema konverzija se nece uspesno izvrsiti i pojavice se greska. Iz tog //razloga moraju //se ti slucajevi ispitati i pomocu dijaloga prikazati kao upozorenje na //ekranu.

if(Edit1->Text=="" && Edit2->Text=="") { Edit3->Text="Niste uneli oba operanda!"; Edit1->SetFocus(); return; //Naredba return omogucava izlazak iz dogadjaja. } if(Edit1->Text=="") { Edit3->Text="Niste uneli prvi operand!"; Edit1->SetFocus(); return; }

if(Edit2->Text=="") { Edit3->Text="Niste uneli drugi operand!"; Edit2->SetFocus();

18

return; }

//Da neki od podataka nije unesen naredbom return bi se izaslo iz dogadjaja. Kako to nije //slucaj moze se izvrsiti konverzija podataka iz stringa u broj tipa float. Funkcija StrToFloat //vrsi konverziju stringa zapisanog kao parametar poziva funkcije u broj i dodelom se //prosledejuje odgovarajucoj //promenljivoj tipa float.

a=StrToFloat(Edit1->Text); b=StrToFloat(Edit2->Text);

c=a+b;

Edit3->ReadOnly=false; Edit3->Text=FloatToStr(c); //Konvertuje se broj u string i upisuje u Edit komponentu. Edit3->ReadOnly=true;

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text="";// Oznaka "" predstavlja prazan string, odnosno nema teksta. Edit2->Text=""; //Na taj nacin se brise sadrzaj Edit komponente. Edit3->ReadOnly=false; Edit3->Text=""; Edit3->ReadOnly=true; Button2->Enabled=false; Button1->Enabled=true; Edit1->SetFocus();}//--------------------------------------------------------------------------

Primer 11:Napraviti aplikaciju koja predstavlja demonstraciju Omovog zakona iy predmeta osnove

elektrotehnike. Realizacija zadatka je slična sa ptošlim zadatkom stim što je ovde posebnom Labelom crvene boje predstavljen Omov zakon. Na pon se unosi u voltima a struja u mili amperima. Rezultat se ispisuje u kilo oma.

19

Rešenje:


#include "Om_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="" && Edit2->Text=="") { ShowMessage("Niste uneli napon i struju!!"); Edit1->SetFocus(); return; }

if(Edit1->Text=="") { ShowMessage("Niste uneli napon!!"); Edit1->SetFocus(); return; }

if(Edit2->Text=="") { ShowMessage("Niste uneli struju!!"); Edit2->SetFocus(); return; }

float u,i,r; u=StrToFloat(Edit1->Text); i=StrToFloat(Edit2->Text);

if(u<=0) { ShowMessage("Podatak mora biti pozitivan!!"); Edit1->SetFocus();

20

return; }

if(i<=0) { ShowMessage("Podatak mora biti pozitivan!!"); Edit2->SetFocus(); return; }

r=u/i; Label6->Caption=Format("%.2f",ARRAYOFCONST((r)));

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text=""; Edit2->Text=""; Label6->Caption=""; Button1->Enabled=true; Button2->Enabled=false;}//-------------------------------------------------------------------

Primer 12: Prilikom startovanja aplikacija je bele boje.

Na njoj se nalazi dugme kao na slici sa natpisom Boja forme. Klikom na dugme menja se boja forme iz bele u zelenu i obrnuto. Na formi se nalazi tekst fonta; veličine 24, pocrnjen, kao na slici čija se veličina može menjati komponentom CSpinEdit u intervalu od 16 do 24 sa korakom 2.

Rešenje:

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "za2_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)

21

{}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Form1->Color==clGreen) Form1->Color=clWindow; else Form1->Color=clGreen;}//---------------------------------------------------------------------------void __fastcall TForm1::CSpinEdit1Change(TObject *Sender){ Label1->Font->Size=CSpinEdit1->Value; }//---------------------------------------------------------------------------

Primer 13:Napraviti aplikaciju koja kada se pokrene ima oblik dijaloškog prozora sa tri Edit

komponente u nizu između kojih se nalaze dve Labele crvene boje sa po jednim znakom pitanja. Klikom na dugme RADI koje je aktivno ili pritiskom na taster Enter umesto znakova pitanja pojavljuje se odgovarajući znak poređenja; =, > ili <.

U programu pistoji zaštita od ne unesenog podatka, tako što se orva komponenta gde ppodatak nije unesen oboji u crven u boju. Klikom na tu komponentu crvene boje nestaje.

Rešenje: //---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "Poredi_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

22

//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int a,b,c;

if(Edit1->Text=="") { Edit1->Text=""; Edit1->Color=clRed; Edit1->SetFocus(); return; } a=StrToInt(Edit1->Text);

if(Edit2->Text=="") { Edit2->Text=""; Edit2->Color=clRed; Edit2->SetFocus(); return; }

b=StrToInt(Edit2->Text);

if(Edit3->Text=="") { Edit3->Text=""; Edit3->Color=clRed; Edit3->SetFocus(); return; }

c=StrToInt(Edit3->Text);

if(a==b) Label1->Caption="="; if(a<b) Label1->Caption="<"; if(a>b) Label1->Caption=">";

if(b==c) Label2->Caption="="; if(b<c) Label2->Caption="<"; if(b>c) Label2->Caption=">";

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Label1->Caption="?"; Label2->Caption="?";

23

Edit1->Text=""; Edit2->Text=""; Edit3->Text=""; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Change(TObject *Sender){ Edit1->Color=clWhite;}//---------------------------------------------------------------------------void __fastcall TForm1::Edit2Change(TObject *Sender){ Edit2->Color=clWhite;}//---------------------------------------------------------------------------void __fastcall TForm1::Edit3Change(TObject *Sender){ Edit3->Color=clWhite;}//---------------------------------------------------------------------------

Primer 14: Napraviti aplikaciju koja predstavlja tablicu množenja. U

zaglavlju aplikacije stoji natpis TABLICA MNOZENJA. Aplikacija se sastoji od deset Labela i jednog CspinEdita. Na prvoj labeli čiji je font 18 crne boje, a preostalih devet Labela su fonta 14 zelene boje.

CspinEdit ima početnu vrednost 1, minimalnu vrednost 1, a maksimalnu 9, s’tim što je i korak uvećanja.

Prilikom startovanja aplikacije prikazana je tablica množenja za broj 1.

Za komponentu CspinEdit potrebno je obraditi i događaj OnClhange koji reaguje na promenu vrednosti u polju Edit komponente klikom na strelice..

Rešenje:


#include "Tablica.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

24

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::CSpinEdit1Change(TObject *Sender){ Label2->Caption="1 * "+IntToStr(CSpinEdit1->Value)+" = "+IntToStr(CSpinEdit1->Value); Label3->Caption="2 * "+IntToStr(CSpinEdit1->Value)+" = "+IntToStr(2*CSpinEdit1->Value); Label4->Caption="3 * "+IntToStr(CSpinEdit1->Value)+" = "+IntToStr(3*CSpinEdit1->Value); Label5->Caption="4 * "+IntToStr(CSpinEdit1->Value)+" = "+IntToStr(4*CSpinEdit1->Value); Label6->Caption="5 * "+IntToStr(CSpinEdit1->Value)+" = "+IntToStr(5*CSpinEdit1->Value); Label7->Caption="6 * "+IntToStr(CSpinEdit1->Value)+" = "+IntToStr(6*CSpinEdit1->Value); Label8->Caption="7 * "+IntToStr(CSpinEdit1->Value)+" = "+IntToStr(7*CSpinEdit1->Value); Label9->Caption="8 * "+IntToStr(CSpinEdit1->Value)+" = "+IntToStr(8*CSpinEdit1->Value); Label10->Caption="9 * "+IntToStr(CSpinEdit1->Value)+" = "+IntToStr(9*CSpinEdit1->Value);}//---------------------------------------------------------------------------

Primer 15:Napraviti aplikaciju koja omogućava unos dva

operanda pomoću komponenti Edit, a potom izračunava operacije sabiranja, oduzimanja, množenja, deljenja, ostatak prilikom celobrojnog deljenja i poređenja. Prilikom poređenja između operanada a i b potrebno je staviti odgovarajući znak: >,< ili =.

Rešenje:

#include <vcl.h>#pragma hdrstop

#include "ljubica.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int a,b,rez; float rez1; AnsiString s;

if(Edit1->Text==""&&Edit2->Text=="") {

25

ShowMessage("Niste uneli oba operanda!!"); Edit1->SetFocus(); return; }

if(Edit1->Text==""&&Edit2->Text!="") { ShowMessage("Niste uneli prvi operand!!"); Edit1->SetFocus(); return; } if(Edit1->Text!=""&&Edit2->Text=="") { ShowMessage("Niste uneli drugi operand!!"); Edit2->SetFocus(); return; }

a=StrToInt(Edit1->Text); b=StrToInt(Edit2->Text);

rez=a+b; Label9->Caption=IntToStr(rez);

rez=a-b; Label11->Caption=IntToStr(rez);

rez=a*b; Label10->Caption=IntToStr(rez);

if(b==0) Label12->Caption="Error"; //Deljenje sa nulom nije definisano. else{

//Rezultat deljenja je racionalan broj pa se koristi cast operator. rez1=(float)a/b;

//Rezultat se zaokruzuje na dve decimale. Label12->Caption=Format("%.2f",ARRAYOFCONST((rez1))); }

rez=a%b; //Operator % je ostatak prilikom celobrojnog deljenja. Label4->Caption=IntToStr(rez);

//Komponente rade sa stringovima a ne znakovima. Potrebno je u nekom stringu //izvrsiti formiranje odredjenog znaka, pa ga takvog formiranog upisati u odredjenu //komponentu.

if(a==b) s="="; else{ if(a<b) s="<"; else s=">"; }

26

Label15->Caption=s; Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Label9->Caption="???"; Label11->Caption="???"; Label10->Caption="???"; Label12->Caption="???"; Label4->Caption="???"; Label15->Caption="?"; Edit1->Text=""; Edit2->Text=""; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 16:Napraviti aplikaciju koja pokazuje kako se

pravi transparentnost. Na formi se nalaze dva dugmeta. Na jednom je natpis plus, a na drugom minus. Sa dugmetom plus Klikom na dugme plus providnost se smanjuje sve dok ne postane neprovidan i tada dugme postaje neaktivno. Klikom na dugme minus providnost se povećava sve dok ne postane totalno providan i tada dugme postaje neaktivno.

Rešenje:

Za rešavanje ovog zadatka potrebno je poznavati sledeća svojstva:AlphaBlend - Ako ima vrednost false forma je uvek neprovidna, a ako ima

vrednost true providnost forme se može promeniti.AlphaBlendValue - Ima vrednost od 0 do 255 pri čemu ako je 255 forma je

neprovidna.

Operatori za dodelu vrednosti

Opšti oblik operatora za dodelu vrednosti je: promenljiva = izrazpromenljiva op=izraz

Promenljiva predstavlja simboličko ime adrese memorijske lokacije. U slučaju proste operacije dodele promenljiva=izraz prvo se izračunava vrednost izraza pa se zatim direktnim

27

adresiranjem dobijeni podatak upisuje u memorijsku lokaciju. Memorijska lokacija odgovara adresi promenljive koja se nalazi sa desne strane operatora dodele. U slučaju da su tip promenljive i tip rezultata dobijenog izračunavanjem izraza različiti, tip rezultata se pretvara u tip promenljive.

Složeni operator dodele promenljiva op=izraz predstavlja skraćeni oblik izraza u kome se primenjuje operator dodele promenljiva = promenljiva op izraz. Za operator opmože se koristiti jedan od sledećih operatora: +, -, *, /, %, &, |, >>, <<.

Složeni operatori dodele su: +=, -=, *=, /=, %=, &=, |=, <<=, i >>=

Za razliku od većine drugih programskih jezika programski jezik C dodelu vrednosti tretira kao operator dok se u drugim jezicima tretira kao naredba. Tako se u programskom jeziku C mogu pisati izrazi u kojima se na više mesta nalazi operator dodele:

a=b=8;a = b+=2 - 3;Nakon ovih izraza vrednost promenljivih je: a = 7, a b = 10.

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "transparency_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;int i=0;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){ Form1->AlphaBlendValue=130;}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Button2->Enabled=true;

if(Form1->AlphaBlendValue==255) { Button1->Enabled=false; }else{ Form1->AlphaBlendValue+=25; Button1->Enabled=true; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Button1->Enabled=true; if(Form1->AlphaBlendValue==30)

28

{ Button2->Enabled=false; }else{ Form1->AlphaBlendValue-=25; Button2->Enabled=true; }}//---------------------------------------------------------------------------

Primer 17:Napraviti aplikaciju koja u zaglavlju forme nalazi

tekst KOORDINATE MISA. Forma je bele boje,. U gornjem levom ugu nalazi se Labela čiji je font 24 podebljan i plave boje, a predstavlja X koordinatu miša na formi. U donjem desnom uglu nalazi se Labela koja sadrži Y koordinatu miša na formi, a ima iste karakteristike gornje Labele. Na srednini nalazi se Labela sa fontom 48 crvene boje i teksta MIS. Labele koje sup lave boje uvek sadrže tri cifre, a ako je broj manji od stio prva cifra je nula, a ako je broj manji od deset prve dve cifre su nula. Svakim pomeranjem miša bilo gde na formi ili na nekoj od Labela moraju xse menjati coordinate miša, a time i ispisi na Labelama.

Rešenje

U ovoj aplikaciji koristiće se događaj OnMouseMove, koji predstavlja događaj premeštanja miša. Kako se isto ponašanje aplikacije ili prikazivanje koordinata miša očekuje ne samo prelaskom mišem nad formom već i prilikom prelaska mišem nad labelama, da bi se to desilo potrebnon je napisati isti kod i za događaje OnMouseMove nad formom.

Okruženje je omogućilo da se to ne mora raditi, već se labelama samo prosledi događaj OnMouseMove nad formom. Prosleđivanje se vrši tako što se u ObjectInspectoru kod događaja OnMouseMove kod labela upiše isto ime događaja kao i ime događaja OnMouseMove nad formom, koji ste predhodno realizovali.

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "za22_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift, int X, int Y){

29

if(X<10) Label1->Caption="00"+IntToStr(X); else{ if(X<100) Label1->Caption="0"+IntToStr(X); else Label1->Caption=IntToStr(X); }

if(Y<10) Label2->Caption="00"+IntToStr(Y); else{ if(Y<100) Label2->Caption="0"+IntToStr(Y); else Label2->Caption=IntToStr(Y); }}//---------------------------------------------------------------------------

Primer 18:Napraviti aplikaciju koja se sastoji od dve Edit

komponente. U prvoj se vrši samo unos teksta. Pritiskom na dugme Paste tekst se iz prvog Edita kopira u drugi Edit.

Na forni postoje sedam dugmadi: SelectAll selektuje tekst koji se nalazi u prvom Editu, UPLower pretvara tekst iz velikih u mala slova, LowerUp pretvara tekst iz malih u velika slova, Copz kopira tekst iz prvog Edita u Cliboard, Cut katuje tekst iz prvog Edita u Cliboard, Paste prebacuje tekst iz Cliboarda u drugi Edit i Clerar briše sadržaj prvog i drugog Edita.

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "RadEdit_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Modified==false) { ShowMessage("Nema se sta selektovati!!"); Edit1->SetFocus(); return;

30

} Edit1->SelectAll(); //Vrsi se selektovanje teksta u Edit komponenti.}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ if(Edit1->Modified==false) { ShowMessage("Nema se sta pretvarati u velika slova!!"); Edit1->SetFocus(); return; }

Edit1->CharCase=ecLowerCase; //Pretvaraju se sva slova Edit komponente u mala.}//---------------------------------------------------------------------------void __fastcall TForm1::Button3Click(TObject *Sender){ if(Edit1->Modified==false) { ShowMessage("Nema se sta pretvarati u mala slova!!"); Edit1->SetFocus(); return; }

Edit1->CharCase=ecUpperCase; //Pretvaraju se sva slova Edit komponente u velika.}//---------------------------------------------------------------------------void __fastcall TForm1::Button4Click(TObject *Sender){ if(Edit1->Modified==false) { ShowMessage("Nema se sta kopirati!!"); Edit1->SetFocus(); return; }

Edit1->CopyToClipboard(); //Vrsi se kopiranje sadrzaja Edit komponente u cliboard. Button6->Enabled=true; Button5->Enabled=false; Button4->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Button5Click(TObject *Sender){ if(Edit1->Modified==false) { ShowMessage("Nema se sta iseci!!"); Edit1->SetFocus(); return; }

31

Edit1->CutToClipboard();//Vrsi se premestanje sadrzaja Edit komponente u cliboard.

Button6->Enabled=true; Button5->Enabled=false; Button4->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Button6Click(TObject *Sender){ Edit2->ReadOnly=false; Edit2->SetFocus();

//Vrsi se upisivanje sadrzaja cliborda u |Edit komponentu. Edit2->PasteFromClipboard();

Edit2->ReadOnly=true;

Button6->Enabled=false; Button5->Enabled=true; Button4->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button7Click(TObject *Sender){ Edit1->Clear(); //Brise se sadrzaj Edit komponente. Edit2->Clear(); Edit1->SetFocus();}//--------------------------------------------------------------------------- void __fastcall TForm1::Edit1Change(TObject *Sender){ AnsiString s=Edit1->Text;

if(s.Length()==Edit1->MaxLength) ShowMessage("Tekst moze imati maksimalno "+IntToStr(Edit1->MaxLength)+"znakova!");

}//---------------------------------------------------------------------------

Primer 19:Napraviti aplikaciju koja omogućava unos vrednosti

novca za isplatu, a polazeći da postoji potreban broj svih novčanica za isplatu, vrši isplatu novca ali da se iskoristi što manje novčanica. Teži se isplata sa novčanicama sa većim apoenima.

Aplikacija se sastoji od Labele gde piše tekst VREDNOST, Edit komponente gde se vrši unos vrednosti za isplatu, Labele gde stoji tekst Isplata, Memo komponente gde će biti prikazan izveštaj o izvršenoj isplati i dva dugmeta ISPLATI i BRISI.

Pritiskom na dugme ISPLATI u komponenti Memo se prikazuje izveštaj o isplati tako da svaki red od većeg apoena ka

32

manjem, sadrži vrednost apoena novčanice i koliko je novčanica dato prilikom isplate. Ako apoen novčanice nije dat prilikom isplate neće ga biti u izveštaju.

Klikom na dugme BRISI vraća se sve u prvobitno stanje i brise se sadržaj Memo komponente. Postoji zaštita od neunosa vrednosti isplate i tada se komponenta za unos boji crvenom bojom. Klikom na komponentu za unos boja se ponovno vraća u belo. Komponenta Memo može služiti samo za prikaz izveštaja ali ne i za neko menjanje od strane korisnika aplikacije.

Rešenje

Komponenta Memo je slična komponenti Edit s tim što za razliku od komponente Edit služi za unos teksta u više linija. Glavna mana je što može prikazati samo jednu vrstu slova u jednom trenutku. Komponenta Memo nalazi se na paleti komponenti na kartici Standard.

Komponenta Memo za razliku od komponente Edit ne poseduje svojjstvo AutoSelect, ali poseduje sva ostala svojstva komponente Edit kao i svojstva:

Lines – Sadrži tekst komponente po redovima smešten u objekat tipa TStrings.Alignment – Određuje načine poravnavanja teksta u svakom redu komponente. Moguće

vrednosti su: taLeftJustify (tekst je levo poravnat), taCenter (tekst je centriran) i taRightJustify (tekst je desno poravnat).

WorWrap – Svojstvo je tipa bool i ako ima vrednost true tekst se automatski prenosi u sledeći red kada se dođe do kraja reda.

ScrollBars - Određuje da li komponenta poseduje ScrollBar. Moguće vrednosti su: ssNone (komponenta nema Scrol barova), ssHorizontal (pojavljuje se samo horizontalan Scroll bar na donjoj ivici komponente), ssVertical (pojavljuje se samo vertikalni Scroll bar na desnoj ivici komponente) i ssBoth (pojavljuju se oba Scroll bara).

Klasa Tstrings odnosi se na niz čiji su elementi tipa String. Vrednosti elemenata niza mogu da se uzimaju i neposredno menjaju u toku izvršavanja programa. Na primer komponenta Memo ima svojstvo Lines koje je tipa Tstrings. Pristup k-tom redu komponente Memo vrši se sa: s=Memo->Lines->Strings[k-1];

Broj elemenata niza nalazi se u svojstvu Count i raspoloživo je samo za vreme izvršavanja aplikacije i ne može se neposredno menjati iz programa. Stringovi (redovi) se mogu menjati iz programa. Najvažnije metode klase TStrings su:

Add Smešta se tekst kao novi red i vrednost Count-a se povećava za jedan. Ako je lista neuređena dodavanje se vrši na kraj liste, a u suprotnom na mesto da lista i dalje ostane sortirana u abecednom redosledu.

Insert Vrši se umetanje teksta u niz stringova na mesto gde je to određeno indeksom.

Move Vrši se pomeranje reda sa jedne na drugu poziciju. Može da se primenjuje samo za neuređene liste.

Delete Izbacuje se red iz niza stringova sa određenog indeksa. Clear Brišu se svi redovi iz niza stringova. LoadFromFile Čita se tekst iz tekstualne datoteke i smešta u niz stringova. SaveToFile Snima se niz stringova u tekstualni fajl.


33

#include "Isplata_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") { Edit1->Color=clRed; return; }

int novac=StrToInt(Edit1->Text); if(novac<=0) { ShowMessage("Podatak mora biti pozitivan!!"); Edit1->Clear(); Edit1->SetFocus(); return; }

int pom; pom=novac/5000; if(pom!=0) { Memo1->Lines->Add("5000din\t\t"+IntToStr(pom)); novac=novac%5000; }

pom=novac/1000; if(pom!=0) { Memo1->Lines->Add("1000din\t\t"+IntToStr(pom)); novac=novac%1000; }

pom=novac/500;

if(pom!=0) { Memo1->Lines->Add("500din\t\t"+IntToStr(pom)); novac=novac%500; }

34








35

pom=novac; if(pom!=0) { Memo1->Lines->Add("1din\t\t"+IntToStr(pom)); }

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Memo1->Lines->Clear(); Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//------------------------------------------------------------------------

Primer 20:Napraviti aplikaciju koja prilikom startovanja ima izgled kao

na slici..Kada se pritisne dugme UGASITI SVETLO pojavljuje se

slika gde je svetlo uašeno a na natpisu dugmeta pojavljuje se natpis UPALITI SVETLO i obrnuto.

Rešenje

Komponenta Image je komponenta bez prozora u koju mogu da se smeste slike. Komponenta Image nalazi se na paleti komponenti na kartici Additional. Mogu se koristiti četiri standardna formata za slike: *.ico, bitmapirana slika *.bmp, metadatoteke *.wmf i komprimovane slike u JPEG formatu *.jpg i *.jpeg.

Bitnija svojstva koja nisu pomenuta su:Center – Svojstvo je tipa bool i određuje način poravnavanja slike u odnosu na

komponentu. Podrazumevana vrednost je false označava poravnavanje prema gornjem levom uglu, a true podrazuumeva centrirano smeštanje.

AutoSize – Svojstvo je tipa bool pri čemu vrednost true označava da se veličina komponente automatski prilagođava veličini slike koja se u nju stavlja.

Stretch –Svojstvo je tipa bool, a vrednost true označava da se dimenzija slike prilagođava veličini komponente ako je vrednost svojstva AutoSize ima vrednost false. Slika će u celini biti vidljiva sa proporcionalno izmenjenim dimenzijama. Ako oba svojstva imaju vrednost false, deo komponente će ostati prazan ukoliko je slika manja od komponente, odnosno deo slike će biti odsečen ako je ako je ona veća od komponente. Podrazumevana

vrednost ovog svojstva je false.

36

Picture – Svojstvo je tipa TPicture. Slike se mogu smestiti tako što se otvori PictureEditor. Pritiskom na dugme Losd otvara se prozor za dialog za izbor datoteke koja sadrži potrebnu sliku. Kada se slika izabere, premešta se u urednik slike (gde je ranije bilo None), a pritiskom na dugme OK premešta se na komponentu

Prvi način:Ovaj način koristi mogućnost da se komponente mogu nalaziti jedna preko druge, s tim da

se svojstvom Visible kontrolise koja je komponenta vidljiva. Komponenta čije svojtvo Visible ima vrednost true biće vidljiva na ekranu. Morate voditi računa da se ne sme dogoditi situacija da obe komponente budu vidljive.

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Zadatak4_o.h"#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Image2->Visible=false; //Komponenta Image2 je nevidljiva. Image1->Visible=true; //Komponenta Image1 je vidljiva. Button2->Visible=false; //Komponenta Button2 je nevidljiva. Button1->Visible=true; //Komponenta Button1 je vidljiva.}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Image2->Visible=true; //Komponenta Image2 je vidljiva. Image1->Visible=false; //Komponenta Image1 je nevidljiva. Button2->Visible=true; //Komponenta Button2 je vidljiva Button1->Visible=false; //Komponenta Button1 je nevidljiva}//---------------------------------------------------------------------------

Drugi način:Ovaj način ima samo jednu komponentu Button i jednu komponentu Image. Problem se

ršava tako što se zna da ako je natpis dugmeta pre pritiska bio UGASITI SVETLO znači da je po pritisku dugmeta komponenti Image potrebno promeniti fajl sa bitmapiranom slikom gde će sijalica biti ugašenai ujedno promeniti natpis na dugmetu na UPALITI SVETLO, i obrnuto.


37

#include " Zadatak4_o.h "//---------------------------------------------------------------------------//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Button1->Caption=="UGASITI SVETLO") { Button1->Caption="UPALITI SVETLO";

//Louduje se novi fajl sa slikom Image1->Picture->LoadFromFile("UGASILO.BMP");. }else{ Button1->Caption="UGASITI SVETLO";

//Louduje se novi fajl sa slikom Image1->Picture->LoadFromFile("UPALILO.BMP"); }}//---------------------------------------------------------------------------

Primer 21:Napraviti aplikaciju koja vrši zamenu dve slike. Iznad prve slike nalazi se Labela sa

natpisom Prva slika a iznad druge Labela sa natpisom Druga slika. Klikom na dugme ZAMENA slike i Labele menjaju mesta.

Rešenje:

38

Najčešće korišćena svojstva zajednička za sve komponente:

Name – Ime komponente je string. Sve komponente unutar iste forme moraju imati različita imena. U različitim formama mogu da postoje istoimene komponente. Ime komponente ne treba menjati za vreme izvršavanja aplikacije.

Showing – Da bi se data komponenta u datom trenutku prikazuje na ekranu, može se doznati na osnovu svojstva Showing (prikazuje se), koje je tipa bool. Vrednost true označava da se komponenta trenutno vidi na ekranu, a false da se ne vidi. Ovo svojstvo je raspoloživo samo za vreme izvršavanja aplikacije i ne može neposredno da se menja iz programa.

Visible – Sa ovim svojstvom kontroliše se vidljivost komponente i tipa je bool. Ako svojstvo ima vrednost true komponentu treba prikazivati na ekranu, pod uslovom da je i njen roditelj vidljiv na ekranu. Ako svojstvo ima vrednost false komponentu ne treba prikazivati na ekranu. Ako se neka kontejnerska komponenta učini nevidljivom i sva njena deca biće nevidljiva.

Enabled – Svojstvo je tipa bool i označava da li komponenta može dobiti fokus. Ako je vrednost ovog svojstva true komponenta može imati fokus i upotrebljiva je. Kad su neupotrebljive komponente su bleđe boje u odnosu na upotrebljive. Ako se neka kontejnerska komponenta učini neupotrebljivom, sva njena deca postaju neupotrebljiva, ali se ne prikazuju bledo. Vrednost ovog svojstva može da se postavlja za vreme projektovanja i da se promeni za vreme izvršavanja aplikacije.

Top – Udaljenost gornjeg levog temena komponente u odnosu na gornju ivicu radnog prostora roditelja posmatrane komponente.

Left – Udaljenost gornjeg levog temena komponente u odnosu na levu ivicu radnog prostora roditelja posmatrane komponente.

Height – Visina komponente.Width – Širina komponente.ClientHeight – Visina radnog prostora komponente. Radni prostor predstavlja deo

prozora bez okvira, trake sa natpisom i trake menija.ClientWidth – Visina radnog prostora komponente.Constraints – Ovo svojstvo predstavlja ograničenja veličine, tj. graničene vrednosti

(visina i širina) u okviru kojih mora de se nađe komponenta. Constraints je objekat tipa klase TSizeConstraints.

MinHeight – Najmanja visina.MaxHeight – Najveća visina.MinWidth – Najmanja širina.MaxWidth – Najveća širina.

Align – Sa ovim svojstvom određuje se automatsko menjanje veličine komponente ako se promeni veličina njihovog roditelja..

alNone – Ovo je podrazumevana vrednost, gde komponenta zadržava trenutnu veličinu i položaj u odnosu na gornji levi ugao radnog prostora i svog roditelja.

alTop – Komponenta se uvek zadržava uz gornju ivicu radnog prostora, zadržava visinu i uvek zauzima celu širinu radnog prostora svog roditelja.

39

alBotton – Komponenta se uvek zadržava uz donju ivicu radnog prostora, zadržava visinu i uvek zauzima celu širinu radnog prostora svog roditelja.

alLeft – Komponenta se uvek zadržava uz levu ivicu radnog prostora, zadržava širinu i uvek zauzima celu širinu radnog prostora svog roditelja.

alRight – Komponenta se uvek zadržava uz desnu ivicu radnog prostora, zadržava širinu i uvek zauzima celu širinu radnog prostora svog roditelja.

alClient – Komponenta uvek popunjava ceo radni prostor svog roditelja.Anchors – Ovo svojstvo odnosi se na relativni položaj komponente u odnosu na

ivice njenog roditelja prilikom menjanja veličine roditelja. Moguće vrednosti od kojih može da se odabere jedna ili više, jesu: akTop (vrh), akBotton (dno), akLeft (levo) i akRight (desno). Obratite pažnju na činjenicu da ako se odabere istovremeno akTop i akBotton ili akRight i akLeft, promenom veličine roditelja promeniće se i veličina komponente.

Caption – Ovo svojstvo predstavlja natpis komponente, tj. tekst kojim se označava data komponenta. Podrazumevana vrednost svojstva poklapa se sa imenom komponente. Može da se postavlja za vreme projektovanja i da se promeni za vreme izvršavanja programa.

BorderStyle – Ovo svojstvo odnosi se na stil ivica okvira komponente. Moguće vrednosti su: bkNone (označava da nema ivica), bkTile (oštro iscrtane ivice), bkSoft (manje oštro iscrtane ivice) i bkFlat (ivice su iscrtane širokom linijom u ravni prozora).

TabOrder – Sa ovim svojstvom određuje se redosled pomeranja fokusa na komponente pomoću tastera TAB. Pritiskom tastera TAB fokus se pomera na komponente po rstućem redosledu, a sa SHIFT-TAB po opadajućem redosledu vrednosti svojstva TabOrder. Svaka komponenta unutar svog roditelja ima jedinstvenu vrednost ovog svojstva. Vrednost se dobija automatski po redosledu smeštanja na roditelja. Prvoj komponenti se dodeljuje vrednost 0, drugoj 1, itd.Promena vrednosti svojstva TabOrder najbolje je uraditi pomoću kartice EditTabOrder.

Pritiskom na dugme sa strelicom na dole, povećava se vrednost njenog svojstva za jedan i u editoru su izmenjena mesta (u ovom primeru Button1 i Edit1). Sličan postupak je i sa strelicom na gore. Redosled se može promeniti odvlačenjem imena komponente na drugo mesto. Po završetku uređivanja treba pritisnuti dugme OK ili taster ENTER. Pritiskom plave strelice na dole

40

TabStop - Ovo svojstvo je tipa bool. Ako je njegova vrednost false komponenta nema TabOrder i ne može dobiti fokus. Tokom pritiskanja tastera TAB komponete kod kojih je vrednost svojstva TabStop false se preskaču.

ShowHint – Svakoj komponenti može da se pridruži tekst koji će se prikazati na ekranu ako se pokazivač miša zadrži neko vreme (oko jedne sekunde) iznad te komponente. Taj tekst se koristi kao automatsko priručno uputstvo korisniku o nameni ili funkciji date komponente. Tekst priručnog upustva prikazuje se unutar pravougaonika sa žutom pozadinom, neposredno pomoću pokazivača miša. Ako ispod pokazivača nema dovoljno mesta, tekst će se prikazati iznad njega.Svojstvo je tipa bool i ako ima vrednost true priručno upustvo će se prikazati na ekranu, a u suprotnom ne. Vrednost ovog svojstva može da se postavi kako za vreme projektovanja tako i za vreme izvršavanja programa.

Hint – Ovo svojstvo je string koji predstavlja priručno upustvo. Vrednost ovog svojstva može da se postavi kako za vreme projektovanja tako i za vreme izvršavanja programa.

ParentShowHint – Svojstvo je tipa bool i ako je tipa true priručno upustvo se preuzima od komponente roditelja. Vrednost ovog svojstva može da se postavi kako za vreme projektovanja tako i za vreme izvršavanja programa.

ParentColor – Svojstvo je tipa bool i ako ima vrednost true komponenta će za pozadinu koristi boju svog roditelja.

Font - Sve osobine slova predstavljene su svojstvom Font tipa TFont. U Object Inspectoru izborom svojstva Font pojavljuje se kartica Font sledećeg izgleda.

Klasa TFont ima sledeća svojstva: Name je ime vrste slova kao što su Arial, Tahoma, Times New Roman, itd.

41

Charset označava alfabet čija slova se koriste u tekstu. Neke od mogućih vrednosti su: ANSI_CHARSET (engleski alfabet), EASTEUROPE_CHARSET (sadrži i slova srpske latinice) i RUSSIA_CHARSET (sadrži i slova srpske ćirilice).

Style označava način prikazivanja slova: fsUnderline (podvučeno), fsBold (polucrno), fsItalic (iskošeno) i fsStrikeout (precrtano).

Size predstavlja veličinu slova u tačkama (mera je points) Height predstavlja veličinu slova u tačkama ekrana (pixels). Color boja kojom se prikazuju slova.

ParentFont – Svojstvo je tipa bool i ako ima vrednost true komponenta će prilikom ispisivanja koristiti font svog roditelja.

Najčešće korišćene metode zajedničke za sve komponente:

SetFocus – Ovom metodom fokus se pomera na tekuću komponentu.CanFocus – Ovom metodom utvrđuje se da li komponenta može da primi fokus.

Ako može funkcija vraća true, a u suprotnom false.Focused – Ova metoda utvrđuje da li trenutna komponenta ima fokus.

Ako komponenta ima fokus funkcija vraća true.BringToFront – Ova metoda dovodi komponentu na koju se primenjuje u prvi plan

unutar roditelja. Kada je komponenta potpuno poklopljena ovo je jedini način da se stavi iznad svih ostalih komponenata.

SendToBack – Ova metoda dovodi komponentu na koju se primenjuje na začelje unutar roditelja.

SetBounds – Ovom metodom podešava se položaj i veličina komponente. Metoda ima četiri argumenta: Levo, Gore, Sirina i Visina. Vrednosti ovih argumenata direktno se upisuju u svojstva Left, Top, Width i Height komponente.

Kod aplikacije:

U događaju OnClivk dugmeta potrebno je izvriti promenu položaja slika, tj zamenu položaja slika. Položaj slika predstavlja položaj komponenti Image gde se slike nalaze. Položaj komponente određen je svojstvima Top i Left. Kako je svojstvo Top isto kod obe komponente u aplikaciji, to je potrebno izvršiti zamenu vrednosti samo svojstava Left.Ako bi koristili naredbe

Image1->Left=Image2->Left; Image2->Left=Image1->Left;Zamena se neće izvršiti. Ako je Image1->Left=100, a Image2->Lef=300, nakon prve

naredbe je Image1->Left=300 i Image2->Left=300. Ovim smo izgubili prethodni položaj prve komponente, te će nakon druge naredbe biti takođe Image1->Left=300 i Image2->Left=300.

Znači videće se samo jedna slika, jer su komponente postavljene jedna preko druge.Da bi se problem rešio potrebno je uvesti pomoćnu promenljivu koja će imati zadatak da

zapamti prvo vrednost položaja Left prve komponente pre nego što se izvrši naredba Image1->Left=Image2->Left;Kako je svojstvo Left tipa int to i pomoćna promenljiva mora biti tipa int.


42

#include "Zamena.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int pom;

pom=Label1->Left; //Pamti polozaj prve labele Label1->Left=Label2->Left; //Prva labela ima polozaj gde i druga labela Label2->Left=pom; //Polozaj druge labele je gde je ranije bila prva labela.

pom=Image1->Left; //Pamti polozaj prve slike Image1->Left=Image2->Left; //Prva slika ima polozaj gde i druga slika Image2->Left=pom; //Polozaj druge slike je gde je ranije bila prva slika.}//---------------------------------------------------------------------------

Primer 22:Napraviti aplikaciju koja omogućava

izračunavanje obima i površine kvadrata na osnovu unete dužine stranice. Program prijavljuje grešku ako je prilikom unosa stranice unesen negativan broj, ili se hoće izračunati obim i površina a da nije unesen podatak kolika je dužina stranice kvadrata i komponenta gde se vrši unos dobija fokus.

Kada se naiđe na dugme RACUNAJ ispisuje se titl. Klikom na dugme ili pritiskom na ENTER izračubnavaju se traženi podaci. Dugme RACUNAJ se aktivira i pritiskom na taster ENTER.

Rešenje


#include "Dugmadi_o.h"

43

#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//----------------------------------------------------------------------------//----------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ double a=0,o=0,p=0; AnsiString s;

if(Edit1->Text=="") {

//Podesavamo natpis u zaglavlju ShowMesage-a. Application->Title=" G R E S K A"; ShowMessage("Niste uneli podatak!!");

Edit1->SetFocus(); }else{ a=StrToFloat(Edit1->Text); //Konvertujemo string u podatak. if(a<0) { ShowMessage("Stranica ne moze biti negativna!!"); Edit1->Text=""; Edit1->SetFocus(); }else{ p=a*a;

o=4*a;

s=FloatToStr(o);

Label4->Caption=FloatToStr(o); //Konvertuje se double podatak u string. Label5->Caption=FloatToStr(p); //Konvertuje se double podatak u string.

//kako bi se mogao prikazati na ekranu. } }}//---------------------------------------------------------------------------

Primer 23:Napraviti aplikaciju koja omogućava pregled deset slika. Slike se nalaze u istom folderu

gde i projekat aplikacije. Slike su u JPG formatu a imena su numerisana brojevima od 1 do 10.Nakon prikaza desete slike pojavljuje se prva slika. Menjanje slike vrši se pritiskom na

taster ENTER ili klikom na sliku. Veličina slike je prilagođena komponenti Image.

44

Rešenje

Da bi se menjanje slike izvršilo potrebno je na formu postaviti dugme. Dugme se podesi da je svojstvo default na vrednosti true. Formu potom smanjimo i postavuimo svojstvo BordersStyl da je bsSingle što onemogućava širenje forme. Dugme se time neće videti. Sada realizujemo događaj klik na dugme. Ime ovog događaja upisujemo kao ime događaja klik komponente Image1, time se događaj klik od dugmeta prosleđuje na događaj klik od Image komponente. Znači kada se klikne na sliku poziva se događaj klik na dugme.


#include "Slike_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

int k=1; //Promenljiva kojom kontrolisemo koja je slika po redu.//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(k<10) k++; //Prelayimo na sledecu sliku. else k=1; //Posle desete slike prelazimo na prvu sliku.

//Povezivanje komponente sa slikom na osnovu imena fajla slike. Image1->Picture->LoadFromFile(IntToStr(k)+".jpg"); }//---------------------------------------------------------------------------

45

Primer 24:Napraviti aplikaciju koja na osnovu

unetog racionalnog broja x računa i prikazuje vrednost promenljive y po formuli:

Rešenje


#include "fun_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") { ShowMessage("Niste uneli podatak!!"); return; }

float x,y;

x=StrToFloat(Edit1->Text);

if(x<-2) y=-2*x+1; else{ if(x<=2)y=x-2; else y=x-1; }

Edit2->Text=FloatToStr(y);

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------

46

void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Button1->Enabled=true; Button2->Enabled=false;

Edit1->SetFocus(); }//---------------------------------------------------------------------------


unetog racionalnog broja x računa i prikazuje vrednost promenljive y, zaokruženu na tri decimale, po formuli:

Tamo gde se ne može izračunati vrednost y na osnovu vrednosti x napisati na izlazu da funkcija nije definisana. Ako podatak nije unesen polje unosa postaje crvene boje. Bilo kakva promena polja unosa uslovljava da polje unosa ponovo postaje bele boje.

Rešenje


#include "funkcija_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") {

47

Edit1->Color=clRed; return; }

float x,y; x=StrToFloat(Edit1->Text);

if(x==1 || (x>0&&x<1) || (x>=2&&x<=5)) { Edit2->Text="Funkcija nije definisana!!"; }else{ if(x<=0) y=-x+1; if(x>=1 && x<2) y=2/x-1/(x-1); if(x>5) y=x-1;

Edit2->Text=Format("%.3f",ARRAYOFCONST((y))); } Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Change(TObject *Sender){ Edit1->Color=clWhite; }//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Button1->Enabled=true; Button2->Enabled=false; Edit1->Clear(); Edit2->Clear(); Edit1->SetFocus(); }//--------------------------------------------------------------

Primer 26:Napraviti aplikaciju koja omogućava unos broja i

utvrđuje tip broja: PARAN ili NEPARAN.Odgovor prikazati u posebnom polju koji služi samo

za čitanje podataka. Ako se ne unese podatak u polju prikaza odgovora pisaće: Nema broja!! a polje unosa postaće crvene boje. Bilo kakva promena nad poljem unosa usloviće da ono postane ponovo bele boje.

Rešenje


48

#include "parnost_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") { Edit2->Text="Nema broja!!"; Edit1->Color=clRed; Edit1->SetFocus(); }else{ int broj;

broj=StrToInt(Edit1->Text);

if(broj%2) Edit2->Text="NEPARAN"; else Edit2->Text="PARAN"; }

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear();

Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Change(TObject *Sender){ Edit1->Color=clWhite;}//---------------------------------------------------------------------------

49

Primer 27:Napraviti aplikaciju koja demonstrira

operacije inkrementiranja i dekrementiranja u prefiksnoj i postfiksnoj notaciji. Kroz komponentu Memo prikazati nakon svakog izraza stanja dve promenljive nad kojima se operacije inkrementiranja i dekrementiranja primenjuju.

Rešenje

Operatori inkrementiranja i dekrementiranjaOperatori inkrementiranja i dekrementiranja predstavljaju unarne operatore. Operator

inkrementiranja je ++, dok je operator dekrementiranja --. Operator inkrementiranja vrši povećavanje vrednosti operanda za jedan, dok operator dekrementiranja vrši smanjivanje vrednosti operanda za jedan.

Ovi operatori su jedini koji mogu da budu u prefiksnoj ili infiksnoj notacijiPrefiksna notacija: ++promenljiva ili - - promenljivaInfiksna notacija: promenljiva++ ili promenljiva - -++k je ekvivalentno sa k = k + 1 --k je ekvivalentno sa k = k - 1k++ je ekvivalentno sa k = k + 1 k-- je ekvivalentno sa k = k - 1

Iz priloženog se može videti da su u slučaju samostalnih izraza prefiksne i infiksne notacije rezultati inkrementiranja jednaki, i u slučaju prefiksne i infiksne notacije rezultati dekrementiranja jednaki. Međutim u složenijin izrazima prefiksna i infiksna notacija nemaju isto značenje.

Na primer:a = c = 6;b = 7;a = b++ - 2;c = ++b - 2;

Nakon ovih operacija dobijaju se sledeće vrednosti. Prvo se izračuna izraz i rezultat se dodeli promenljivoj a tako da a sada ima vrednost 5. Tada se promenljiva b poveća za jedan pa ima sada vrednost 8. Kod sledećeg izraza prvo se vrednost promenljive b povećala za jedan i sada ima vrednost 9. Sa novonastalom vrednošću učestvuje u izrazu, te promenljiva c dobija vrednost 7.


#include "prefiks_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)

50

: TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="" || Edit2->Text=="") { ShowMessage("Niste uneli oba podatks!!"); if(Edit1->Text=="") Edit1->SetFocus(); else Edit2->SetFocus(); }else{ int a,b,rez; a=StrToInt(Edit1->Text); b=StrToInt(Edit2->Text);

Memo1->Lines->Add("a = "+IntToStr(a)); Memo1->Lines->Add("b = "+IntToStr(b)); Memo1->Lines->Add("*************");

rez=a++ + b++; Label7->Caption=IntToStr(rez); Memo1->Lines->Add("a = "+IntToStr(a)); Memo1->Lines->Add("b = "+IntToStr(b)); Memo1->Lines->Add("*************");

rez=++a + ++b; Label8->Caption=IntToStr(rez); Memo1->Lines->Add("a = "+IntToStr(a)); Memo1->Lines->Add("b = "+IntToStr(b)); Memo1->Lines->Add("*************");

rez=a-- + b--; Label9->Caption=IntToStr(rez); Memo1->Lines->Add("a = "+IntToStr(a)); Memo1->Lines->Add("b = "+IntToStr(b)); Memo1->Lines->Add("*************");

rez=--a + --b; Label10->Caption=IntToStr(rez); Memo1->Lines->Add("a = "+IntToStr(a)); Memo1->Lines->Add("b = "+IntToStr(b)); Memo1->Lines->Add("*************");

Button1->Enabled=false; Button2->Enabled=true; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){

51

Edit1->Clear(); Edit2->Clear(); Memo1->Lines->Clear(); Label7->Caption="????"; Label8->Caption="????"; Label9->Caption="????"; Label10->Caption="????"; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="GRESKA..."; }//---------------------------------------------------------------------------

Primer 28:Napraviti aplikaciju koja omogućava unos četiri

celobrojna podatka, a potom određuje sredbju vrednost pozitivnih među njima.

Rezultat je potrebno zaokružiti na četiri decimale.

Rešenje

Operator zarezOperator zarez omogućava da kod bude čitljiviji

jer se više izraza može pisati u istom redu.

Na primer:Niz izraza a = 3;b = 4;c = a + b;može se ekvivalentno napisati primenom operatora zarez u jednom redua = 3, b = 4, c = a + b;

Cast operatorCast operator se koristi za eksplicitno pretvaranje jednog tipa promenljive (ili izraza) u neki

drugi tip. To je unaran operator. Opšti oblik cast operatora je:

(tip) izraz

gde je tip neki od mogućih tipova podataka programskog jezika C.

Na primer:

52

Napisati deo C programa koji omogućava da se na osnovu dva uneta celobrojna parametra a i b, linearne jednačine , izračunava rešenje i rezultat upisuje u promenljivu x tipa double.

rešenjeint a,b;double x;

x = -b/a;

Napisano rešenje nije tačno, jer ako je vrednost promenljive a = 2, a promenljive b = 5, nakon ovog izraza vrednost promenljive x = -2. To je iz razloga što su a i b celobrojnog tipa te će i rezultat deljenja biti celobrojnog tipa i time se automatski izvršilo odsecanje decimalnog dela, te se takav dodelio promenljivoj x.

int a,b;double x;

x = -(double) (b/a);

Napisano rešenje nije tačno jer se zbog prioriteta zagrada izvršava prvo operacija celobrojnog deljenja, pa se tek tada rezultat (već sa odsečenim decimalnim delom) dodeljuje promenljivoj x. Dobili smo isto rešenje kao u prošlom slučaju.

int a,b;double x;

x = -(double) b/a;

Ovo rešenje je ispravno jer se primenom cast operatora promenljiva b eksplicitno konvertovala iz tipa int u tip double, na taj način će i rezultat deljenja biti double i promenljiva x će imati vrednost x = -2.5.


#include "maxcetiri_o.h"#include <string.h>//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){

53

if(Edit1->Text=="" || Edit2->Text=="" || Edit3->Text=="" || Edit4->Text=="") { ShowMessage("Niste uneli sve podatke!!");

if(Edit1->Text=="") Edit1->SetFocus(); else if(Edit2->Text=="") Edit2->SetFocus(); else if(Edit3->Text=="") Edit3->SetFocus(); else Edit4->SetFocus(); }else{ int a,b,c,d,s,br; float sr;

a=StrToInt(Edit1->Text); b=StrToInt(Edit2->Text); c=StrToInt(Edit3->Text); d=StrToInt(Edit4->Text);

s=0; br=0; if(a>0) s+=a, br++; if(b>0) s+=b, br++; if(c>0) s+=c, br++; if(d>0) s+=d, br++;

if(br==0) Label7->Caption="Srednja vrednost se ne moze iyracunati!!"; else{ sr=(float)s/br; Label7->Caption=Format("%.4f",ARRAYOFCONST((sr))); }

Button1->Enabled=false; Button2->Enabled=true; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Edit3->Clear(); Edit4->Clear();

Button1->Enabled=true; Button2->Enabled=false;

Label7->Caption="?????";

Edit1->SetFocus();} //---------------------------------------------------------------------------

54


demonstrira dodavanje teksta u određeni red Memo komponente.

Pritiskom na dugme DODAJ u komponentu memo upisuje se tekst iz polja unosa na indeks (red - 1) koji se nalazi u drugom polju unosa povezanim sa komponentom UpDown.

Pritiskom na dugme BRISANJE briše se celokupni sadržaj Memo komponente.

Rešenje

Komponenta UpDown nalazi se na kartici Win32 i predstavlja brojač. Pritiskom na gornje dugme vrednost brojača se uvećava, a pritiskom na donje umanjuje. Za prikazivanje vrednosti brojača, brojaču se pridružuje druga komponenta pomoću svojstva Associate.

Osnovna svojstva su:AlignButton – Određuje sa koje strane će se brojač nalaziti (udRight i udLeft).Orientation – Određuje kako su dugmadi poređani (udVertical i udHorisontal).Position – Vrednost ovog svojstva automatski se menja kad god se klikne na neko dugmeIncrement – Predstavlja korak povećanja. Podrazumevana vrednost je 1.Arrowkeys – je tipa bool pri čemu vrednost true označava da se vrednost može menjati i sa

strelicama na tastaturi.Min – Maksimalna vrednost brojača.Max – Minimalna vrednost brojača.Wrap – tipa je bool i sa vrednošću true dalji pokušaji sa gornjom strelicom neće

povećavati vrednost od Max, a takođe daljnim pritiskom na strelicom na dole neće smanjivati vrednost manje od Min-a.


#include "dodaj_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ UpDown1->Max=Memo1->Lines->Count;}//---------------------------------------------------------------------------

55

void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text!="") { Memo1->Lines->Insert(StrToInt(Edit2->Text),Edit1->Text); Edit1->Clear(); UpDown1->Max=Memo1->Lines->Count; Edit1->SetFocus(); }}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Memo1->Lines->Clear(); Edit1->Clear(); Edit1->SetFocus();

UpDown1->Max=0; Edit2->Text="0";}//---------------------------------------------------------------------------

Primer 30:Napraviti aplikaciju koja se sastoji

samo od dva poljna. Prvi je bele polje i pretstavlja polje unosa teksta, a drugi je sive boje i pretstavlja automatski prikaz koipije teksta. Polje prikaza ne dozvoljava unos teksta.

Prilikom unosa svakog slova u polje unosa, slovo se automatski prikazuje kao njegova kopija i u polju prikaza.

Rešenje


#include "Promena_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)

56

{}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Change(TObject *Sender){ Edit2->Text=Edit1->Text; }//---------------------------------------------------------------------------

Primer 31:U pogonima jednog preduzeća na više mernih mesta utvrđivan je radni učinak pojedinačnih

smena. Učinak je izražen u broju proizvoda koje je smena napravila tog dana. Radi zaštite podataka podaci su smešteni u šesnaestobitne reči sledećeg izgleda:

15 00 0 1 0 1 1 0 1 0 0 0 0 1 1 1 0

= Smena = Merno mesto = Broj proizvoda =

Šesnaestobitna reč podeljena je na tri dela: 0 – 7 bita smešten je podatak o broju proizvoda, 8 – 12 bita je podatak o mernom mestu, i13 – 15 bita je podatak o smeni.

Napisati C program koji omogućava unos prirodnog broja kojim su kodirani podaci u obliku šesnaestobitne reči i ispis podataka na osnovu tog broja: Smena, Merno mesto, i Broj proizvoda

Rešenje

Operaztori nad bitovimaOperatori nad bitovima omogućavaju izvođenje operacija na nivou bitova unutar

celobrojnih podataka. Operandi i rezultat su celobrojnog tipa. Najčešće se za operande uzimaju podaci koji su tipa unsigned.

U programskom jeziku C mogu se koristiti sledeći brojevni sistemi:

Dekadni (standardni)0 1 2 3 4 5 6 7 8 9

Binarni0 1

Oktalni0 1 2 3 4 5 6 7

Heksadecimalni0 1 2 3 4 5 6 7 8 9 A B C D E F

57

U memoriji računara svi podaci se predstavljaju u binarnom brojevnom sistemu.

Unarni operatori nad bitovima~ negacija

Binarni operatori nad bitovima

>> šiftovanje (pomeranje) u desno,<< šiftovanje (pomeranje) u levo, &vrši logičko I nad bitovima, i | vrši ligičko ILI nad bitovima

Binarni operatori >> i << vrše pomeranje levog operanda (udesno ili ulevo) za onoliko binarnih mesta kolika je vrednost desnog operanda. Desni operand mora da bude pozitivan, a tip rezultata jednak je tipu levog operanda. Rezultat je nedefinisan ako je vrednost desnog operanda negativna ili ima vrednost veću od vrednosti levog operanda.


#include "mrna_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ \ if(Edit1->Text=="") { Edit1->Color=clRed; Edit1->SetFocus(); }else{ unsigned pod,sm,mm,pro;

pod=StrToInt(Edit1->Text);

pro=pod & 0xff; //Oznaka 0x je za heksadecimalni brojevni sistem. mm=(pod >> 0x8) & 0x1f; sm=(pod >> 0xd) & 0x7;

Label5->Caption=IntToStr(pro); Label6->Caption=IntToStr(mm); Label7->Caption=IntToStr(sm);

Button1->Enabled=false;

58

Button2->Enabled=true; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Label5->Caption="????"; Label6->Caption="????"; Label7->Caption="????"; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 32:Napraviti aplikaciju koja omogućava unos stranica trougla i prikayuje tip trougla:

JEDNAKOKRAKI, JEDNAKOSTRANIČAN ili NEJEDNAKOSTRANIČAN.

Rešenje:

#include <vcl.h>#include <math.h>#pragma hdrstop

#include "trougao_o.h"#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float a=0,b=0,c=0,s=0,p=0;

59

if(Edit1->Text==""&&Edit2->Text==""&&Edit3->Text=="") { ShowMessage("NISTE UNELI SVE TRI STRANICE!!"); Edit1->SetFocus(); return; }

if(Edit1->Text==""&&Edit2->Text==""&&Edit3->Text!="") { ShowMessage("NISTE UNELI PRVU I DRUGU STRANICU!!"); Edit1->SetFocus(); return; }

if(Edit1->Text==""&&Edit2->Text!=""&&Edit3->Text=="") { ShowMessage("NISTE UNELI PRVU I TRECU STRANICU!!"); Edit1->SetFocus(); return; }

if(Edit1->Text!=""&&Edit2->Text==""&&Edit3->Text=="") { ShowMessage("NISTE UNELI DRUGU I TRECU STRANICU!!"); Edit2->SetFocus(); return; }

if(Edit1->Text==""&&Edit2->Text!=""&&Edit3->Text!="") { ShowMessage("NISTE UNELI PRVU STRANICU!!"); Edit1->SetFocus(); return; }

if(Edit1->Text!=""&&Edit2->Text==""&&Edit3->Text!="") { ShowMessage("NISTE UNELI DRUGU STRANICU!!"); Edit2->SetFocus(); return; }

if(Edit1->Text!=""&&Edit2->Text!=""&&Edit3->Text=="") { ShowMessage("NISTE UNELI TRECU STRANICU!!"); Edit3->SetFocus(); return; }

a=StrToFloat(Edit1->Text);

60

b=StrToFloat(Edit2->Text); c=StrToFloat(Edit3->Text);

if (a<0 || b<0 || c<0) Label6->Caption="NEKI OD UNOSA JE NEGATIVAN!"; else{

if((a+b)<=c || (a+c)<=b || (b+c)<=a) Label6->Caption="OVAKAV TROUGAO JE NEMOGUC!"; else{ if(a==b && b==c) Label6->Caption="TROUGAO JE JEDNAKOSTRANICAN!"; else{ if(a!=b && b!=c)

Label6->Caption="TROUGAO JE NEJEDNAKOSTRANICAN!"; else Label6->Caption="TROUGAO JE JEDNAKOKRAKI!"; } } }}//---------------------------------------------------------------------------

Primer 33:Napraviti aplikaciju koja se sastoji od

dva polja, prvi za unos teksta, a drugi za prikaz kopije teksta. Drugo polje je sive boje i iz njega se može samo čitati sadržaj. Na formi se nalaze i tri dugmeta koja su neaktivna prilikom startovanja aplikacije. Čim se promeni sadržaj prvog unosa (tj polje sadrži neki tekst) aktivira se dugme KOPIJA i dugme BRISANJE. Klikom na dugme KOPIJA tekst prvog polja se upisuje u drugo polje i dugme ZAMENA postaje aktivno. Klikom na dugme ZAMENA menja se sadržaj polja i to pod uslovom da polja nemaju isti sadržaj, dok se u suprotnom prijavljuje poruka o grešci.

Klikom na dugme BRISANJE briše se sadržaj oba polja i sva tri dugmeta postaju neaktivna.

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "za30_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

61

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Change(TObject *Sender){ if(Edit1->Text!="") //Ako se nesto unelo postaje aktivno kopiranje i brisanje. { Button1->Enabled=true; Button3->Enabled=true; if(Edit2->Text!="") Button2->Enabled=true; }else{ Button1->Enabled=false; Button2->Enabled=false; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Edit2->Text=Edit1->Text; Button2->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ AnsiString s; //Zamena se vrsi pomocu pomocnog stringa s.

s=Edit1->Text; Edit1->Text=Edit2->Text; Edit2->Text=s;}//---------------------------------------------------------------------------void __fastcall TForm1::Button3Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Button1->Enabled=false; Button2->Enabled=false; Button3->Enabled=false; Edit1->SetFocus(); }

//-------------------------------------------------

Primer 34:Napisati aplikaciju koja diskutuje

rešenja kvadratne jednačine na osnovu unesenih parametara.

62

Rešenje:

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "kvadratna_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float a,b,c,d;

if(Edit1->Text==""||Edit2->Text==""||Edit3->Text=="") { ShowMessage("Niste uneli sve podatke!!"); return; }

a=StrToFloat(Edit1->Text); b=StrToFloat(Edit2->Text); c=StrToFloat(Edit3->Text);

d=(b*b-4*a*c); //Racuna se diskriminanta jer se na osnovu nje vrsi yakljucivanje. if(d==0) Label6->Caption="Rešenja su realna i jednaka!"; if(d<0) Label6->Caption="Rešenja su konjugovano kompleksna!"; if(d>0) Label6->Caption="Rešenja su realna i razlicita!";

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Button1->Enabled=true; Button2->Enabled=false;

Edit1->Text=""; Edit2->Text=""; Edit3->Text=""; Label6->Caption="???????"; Edit1->SetFocus();}

63

//-------------------------------------------------

Primer 35:Napraviti aplikaciju koja omogućava unos kratkog

celog broja sa intervala 0-255 i prikazivanje broja u binarnom brojevnom sistemu, kao i proveru pretvaranjem broja iz binarnog u dekadni brojevni sistem.

Rešenje

Podaci u programu mogu biti predstavljeni kao konstante ili promenljive.

Konstante ne zauzimaju prostor u memoriji računara, već se neposredno ugrađuju u naredbe programa. U naredbi x = x + 3; broj 3 predstavlja konstantu. U programu se može koristiti i simboličke konstante. Simbolička konstanta predstavlja indentifikator koji ima samo velika slova i definiše se predprocesorskom naredbom.

Na primer:#define BROJ_POKUSAJA 10

Gde god se u programu bude koristila simbolička oznaka BROJ_POKUSAJA prevodilac će umesto nje koristi broj 10. Ako hoćemo da promenimo broj pokušaja u programu, umesto da po celom programu tražimo broj 10, izmenu vršite samo na jednom mestu, a to je upravo gore navedena naredba. Posebno je neugodno kada se u programu na više mesta koristi broj 10, a ne predstavlja svugde broj pokušaja, teško je znati gde promeniti vrednost.

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Binar_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

#define BIN 2TForm1 *Form1;//--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::btnBinClick(TObject *Sender){ if(Edit1->Text=="") ShowMessage("UNESI BROJ"); else{ broj = StrToInt(Edit1->Text); if(broj<256) { Label9->Caption = IntToStr(broj%BIN);

64

broj = broj/BIN; Label8->Caption = IntToStr(broj% BIN); broj = broj/ BIN; Label7->Caption = IntToStr(broj% BIN); broj = broj/ BIN; Label6->Caption = IntToStr(broj% BIN); broj = broj/ BIN; Label5->Caption = IntToStr(broj% BIN); broj = broj/ BIN; Label4->Caption = IntToStr(broj% BIN); broj = broj/ BIN; Label3->Caption = IntToStr(broj% BIN); broj = broj/ BIN; Label2->Caption = IntToStr(broj% BIN); btnBin->Default=false; btnProvera->Default=true; }else{ ShowMessage("Uneli ste broj veci od dozvoljenog"); btnProvera->Default=false; btnBin->Default=true; } } }//---------------------------------------------------------------------------void __fastcall TForm1::btnProveraClick(TObject *Sender){

int d=0;

d=128*StrToInt(Label2->Caption )+64* StrToInt(Label3->Caption )+32*StrToInt(Label4->Caption )+16*StrToInt(Label5->Caption )+8*StrToInt(Label6->Caption )+4*StrToInt(Label7->Caption )+2*StrToInt(Label8->Caption )+1*StrToInt(Label9->Caption );Label11->Caption="128*" + Label2->Caption +"+"+ " 64* " +Label3->Caption +"+"+" 32*"+ Label4->Caption +" +"+" 16*" + Label5->Caption +"+"+"8*"+Label6->Caption +"+"+"4*"+Label7->Caption +"+"+"2*"+ Label8->Caption +"+"+"1*"+Label9->Caption+" = " + IntToStr(d);Edit1->SetFocus();

}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Change(TObject *Sender){ btnProvera->Default=false; btnBin->Default=true;}//---------------------------------------------------------------------------

Primer 36:

65

Napraviti aplikaciju koja omogućava dodavanje natpisa na Panel. Prilikom startovanja aplikacije na formi dijaloškog oblika, nalazi se jedna Labela sa tekstom Natpis, jedna Edit komponenta za unošenje natpisa i šest jednakih Panela bele boje raspoređena u dva reda po tri Panela. Podešeno je da je font Panela 12 podebljan i iskošen. Ako se klikne na neki Pabnel korišćenjem operatora dynamic_cast sadržaj unosa iz Edit komponente se pojavljuje kao natpis na kliknutom Panelu. Ako nema teksta u komponenti Edit a kliknulo se na neki Panel, komponenta Edit se boji u crvenu boju. Ako se klikne na polje unosa boja komponente postaje ponovo bela.

Rešenje

U svim rukovaocima događaja pojavljuje se parametar Sender Kad god se pozove funkcija za obradu događaja, ta funkcija dobija informaciju koja potiče od objekta koji je izazvao događaj. Ova informacija se prosleđuje pomoću parametra Sender

Svaki put kada se pozove metod nekog objekta osim stvarnih parametara (svojstava) predaje se nevidljivi parametar this pokazivačkog tipa koji sadrži adresu tekućeg objekta kojim se može eksplicitno definisati pripadnost objekta

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Natpis_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::PanelClick(TObject *Sender){ if(Edit1->Text=="") { Edit1->Color=clRed; return; }

TPanel *pn = dynamic_cast <TPanel *> (Sender);

66

pn->Caption=Edit1->Text;}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Change(TObject *Sender){ Edit1->Color=clWhite;}//---------------------------------------------------------------------------

Primer 37:Napraviti aplikaciju

koja pritiskom na dugme KRECI pomera sliku za vrednost njene širine, po formi krećući se horizontalnom linijom. Prilikom startovanja aplikacije slika se nalazi u levom uglu I klikom se kreće sleva na desno, sve dok ne dođe do kraja forme, kada se klikom na dugme KRECI vraća sdesna na levo. Klikom na dugme KRECI pomeranje se vrši samo za jednu širinu slike.

Rešenje //---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "za32_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;int ras=1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(ras==1) { if(Image1->Left+Image1->Width<Form1->Width)

Image1->Left=Image1->Left+Image1->Width; else{ ras=0; Image1->Left=Image1->Left-Image1->Width; } }else{

67

if(Image1->Left-Image1->Width>=0) Image1->Left=Image1->Left-Image1->Width;

else{ ras=1; Image1->Left=Image1->Left+Image1->Width; } }}//----------------------------------------------------

Primer 38:Napraviti aplikaciju koja na sredini

forme ili jadan veliki Panal sa natpisom koji predstavlja jedan broj podebljani fonta 48. Sa leve strane Panela nalazi se deset malih Panela čiji natpisi su: -1, +1, -2, +2, -3, +3, -4, +4, -5 i +5. Ovi Paneli reaguju na jedinstveni događaj OnClick pri čemu se menja vrednost centralnog Panela i to za vrednost natpisa Kliknutog Panela. Sa desne strane nalazi se šest Panela koji reaguju na isti događaj OnClick pri čemu se menja boja broja natpisa glavnog Panela, dobijajući boju kliknutog Panela kao na slici.

Ispod glavnog Panela nalazi se Labela koja opisuje koliko je bilo izmena vrednosti broja natpisa glavnog Panela.

Rešenje

Komponenta Panel je kontejnerska komponenta čija je osnovna namena da grupiše druge komponente na svojoj radnoj površini.

Panel je komponenta tipa TPanel i nalazi se na paleti komponenti kartica Standard. Svojstvo AlignMent određuje poziciju natpisa panela. Moguće vrednosti su: taLeftJustyfy (tekst je pozicioniran uz leviu ivicu panela), taCenter (tekst je pozicioniran u centru panela) i tarightJustyfy (tekst je pozicioniran uz desnu ivicu panela).

Oblik okvira panela definiše se raznim kombinacijama njegovih specifičnih svojstava. Svaki panel poseduje dva okvira, spoljašnji i unutrašnji, koji su razdvojeni prostorom čija je veličina određena svojstvom BoredrWidth. Svojstva BevelInner i BevelOuter određuju oblik ova dva okvira. BevelWidth određuje stepen ulegnuća ili izdignuća okvira panela. Svojstvo BorderWith određuje rastojanje između spoljašnjeg i unutrašnjeg okvira panela u pixel-ima. Svojstvo BevelInner određuje stil unutrašnjeg okvira panela. Moguće vrednosti BorderInner-a su: bvNone (ne postoji unutrašnji okvir), bvLowered (unutrašnji okvir je ulegnut u odnosu na okolinu) i bvaised (unutrašnji okvir je izdignut u odnosu na okolinu). BeveOuter određuje stil unutrašnjeg okvira panela. Moguće vrednosti BevelOuter-a su: bvNone (ne postoji spoljašnji okvir), bvLowered (spoljašnji okvir je ulegnut u odnosu na okolinu) i bvaised (spoljašnji okvir je izdignut u odnosu na okolinu)

Komponenti Panel može se desiti fdogađaj Resize kada se promeni veličina panela, kako bi se omogućilo ponovno raspoređivanje komponenti koje se na njoj nalaze.

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "za39_o.h"

68

//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::PanelIzmenaClick(TObject *Sender){ TPanel *pnx=dynamic_cast <TPanel *> (Sender);

Panel11->Caption=IntToStr(StrToInt(pnx->Caption)+StrToInt(Panel11->Caption)); Label4->Caption=IntToStr(1+StrToInt(Label4->Caption));}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::PanelBojeClick(TObject *Sender){ TPanel *pnx=dynamic_cast <TPanel *> (Sender);

Panel11->Font->Color=pnx->Color; }//---------------------------------------------------------------------------

Primer 39:Napraviti aplikaciju koja kada se pokrene prikazuje u zaglavlju teks SLIKE, i u jednom

redu prikazuje niz od pet slika (pravougaonici sive boje). Ispod svake slike nalazi se tekst koji opisuje koja slika je po redu (Slika 1, Slika 2,…Slika 5). Dugme Next je aktivno, a Back neaktivno.

U folder projekta aplikacije formirati šest slika. Prva je pravougaonik sive boje i imena 0.jpg, a ostalih pet na slučajan način pronađi u računaru i imenuj ih redom: 1.jpg, 2.jpg, 3.jpg, 4.jpg i 5.jpg.

Klikom na dugme Next ubacuje se nova slika. Klikom na dugme Back briše se poslednja slika. Ako nema slika dugme Back je neaktivno, a ako ima svih pet slika dugme Next je neaktivno. Ako se pritisne dugme Next dodaje se odgovarajuća slika (sa odgovarajućim rednim brojem), a ako se pritisne dugme Back briše se poslednja slika i umeće siva slika 0.jpg.

Rešenje

//---------------------------------------------------------------------------

69

#include <vcl.h>#pragma hdrstop#include "za12_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;int k=0; //Predstavlja redni broj aktivne slike.//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ k=k+1; if(k!=0) Button2->Enabled=true; //Ima vec slika pa se mogu i gasiti. if(k==5) Button1->Enabled=false; //Popunjena su mesta te se ne moze vise dodavati. //Utvrdjuje se na koju poyiciju slika dolazi. if(k==1) Image1->Picture->LoadFromFile(IntToStr(k)+".jpg"); if(k==2) Image2->Picture->LoadFromFile(IntToStr(k)+".jpg"); if(k==3) Image3->Picture->LoadFromFile(IntToStr(k)+".jpg"); if(k==4) Image4->Picture->LoadFromFile(IntToStr(k)+".jpg"); if(k==5) Image5->Picture->LoadFromFile(IntToStr(k)+".jpg");}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ //Postavimo da su polja prazne slike. if(k==1) Image1->Picture->LoadFromFile("0.jpg"); if(k==2) Image2->Picture->LoadFromFile("0.jpg"); if(k==3) Image3->Picture->LoadFromFile("0.jpg"); if(k==4) Image4->Picture->LoadFromFile("0.jpg"); if(k==5) Image5->Picture->LoadFromFile("0.jpg");

k=k-1; //Prelazimo na prethodnu sliku. if(k==0) //Utvrdjujemo da li se ima sta gasiti. { Button2->Enabled=false; Button1->Enabled=true; }

if(k!=0) Button1->Enabled=true;}//-----------------------------------------------------------

Primer 40:Napraviti aplikaciju koja se sastoji od

šesnaest Panel abele boje fonta 24 podebljano, grupisanih u četiri reda po četiri Panela. Svi Paneli

70

prilikom startovanja aplikacije imaju isti natpis a to je broj pet. Prvi Panel u prvom redu prilikom startovanja aplikacije je svetlo plave boje. U polju izmena vrši se podešavanje vrednosti izmene sa intervala od -5 do +5 koraka 1

Klikom na neki od Panela boja mu se menja u svetloplavu ako nije bila ranije svetloplava boja a vrednost uvećava za vrednost koja se nalazi u polju Izmena, pri čemu se automatski menja ispis prikaza trenutne vrednosti minimalnog i maksimalnog elementa.

Rešenje

Definicija pokazivača:Pokazivač je promenljiva koja sadrži adresu druge promenljive ili funkcije.

Kada se započne program operativni sistem priprema različita područja memorije, bazirajući se na zahtevima vašeg kompajlera. Program raspolaže sa sledećim područjima memorije: zona podataka, registarska memorija, zona za kod, stek i hip.

Deklaracija pokazivačke promenljive:

tip *pok;

Ovom deklaracijom pok je pokazivačka promenljiva koja je u stanju da pokazuje (sadrži adresu) promenljive tipa tip. U deklaraciji se vidi da je pok pokazivačka promenljiva jer se ispred nje nalazi operator *.

Inicijalizacija pokazivačke promenljive:Inicijalizacija pokazivačke promenljive vrši se operatorom dodele gde se pokazivačkoj

promenljivoj dodeljuje NULL.

pok = NULL;

NULL – je simbolička konstanta koja se nalazi u biblioteci stdio.h i ima vrednost 0.

Pokazivačka promenljiva pokazivaće na drugu promenljivu ako sadrži njenu adresu. To se postiže na sledeći način.

pok = &prom;

U ovom slučaju pokazivačka promenljiva pok mora prethodno biti deklarisana tako da pokazuje na promenljive tipa tip, a da je i promenljiva prom takođe tipa tip.


#include "za40_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;

71

TPanel *pre; //Pokazivacka promenljiva, a sluzi u zadatku da pamti adresu komponente koja je //poslednji put bila kliknuta.

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::PanelXClick(TObject *Sender){ TPanel *pnx=dynamic_cast <TPanel *> (Sender);

//Ako nije ista komponenta, novo kliknuta komponenta imace boju prethodno kliknute //komponente.

if(pnx->Tag != pre->Tag) { pnx->Color=pre->Color; pre->Color=clWindow; }

pnx->Caption=IntToStr(CSpinEdit1->Value + StrToInt(pnx->Caption)); if(StrToInt(pnx->Caption)<StrToInt(Label3->Caption)) Label3->Caption=pnx->Caption; if(StrToInt(pnx->Caption)>StrToInt(Label5->Caption)) Label5->Caption=pnx->Caption; pre=pnx;}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ pre=Panel1;}//--------------------------------------------------------------------------

Primer 41:Napraviti aplikaciju koja omogućava unos

stranica kvadra i izračunava: Obim ivica kvadra, površinu kvadra i dužinu dijagonale kvadra. Dužina dijagonale kvadra treba da je zaokružena na tri decimale.

Program sadrži zaštitu od neunesenog podatka, tako što se porukom opiše koje stranice nisu unesene i postavi kursor na prvo polje unosa gde podatak nije unesen.

Klikom na dugme RACUNAJ vrši se računanje podataka, dok se klikom na dugme BRISANJE brišu polja za unos i trenutni rezultati..

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#include <math.h> Ukljucuje se biblioteka matematickih funkcija.

72

#pragma hdrstop#include "Kvadar_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float a,b,c,d,o,p;

if(Edit1->Text==""&&Edit2->Text==""&&Edit3->Text=="") { ShowMessage("Niste uneli sve tri stranice!!"); Edit1->SetFocus(); return; }

if(Edit1->Text==""&&Edit2->Text=="") { ShowMessage("Niste uneli stranice a i b!!"); Edit1->SetFocus(); return; }

if(Edit1->Text==""&&Edit3->Text=="") { ShowMessage("Niste uneli stranice a i c!!"); Edit1->SetFocus(); return; }

if(Edit2->Text==""&&Edit3->Text=="") { ShowMessage("Niste uneli stranice b i c!!"); Edit2->SetFocus(); return; }

if(Edit1->Text=="") { ShowMessage("Niste uneli stranicu a!!"); Edit1->SetFocus(); return; }

73

if(Edit2->Text=="") { ShowMessage("Niste uneli stranicu b!!"); Edit2->SetFocus(); return; }

if(Edit3->Text=="") { ShowMessage("Niste uneli stranicu c!!"); Edit3->SetFocus(); return; }

a=StrToFloat(Edit1->Text); b=StrToFloat(Edit2->Text); c=StrToFloat(Edit3->Text);

if(a<=0||b<=0||c<=0) { ShowMessage("Stranice ne mogu biti negativne!!"); Edit1->Text=""; Edit2->Text=""; Edit3->Text=""; Edit1->SetFocus(); return; }

o=2*a+2*b+2*c; p=a*b*c; d=sqrt(a*a+b*b+c*c); //sqrt je funkcija koja racuna kvadratni koren.

Label7->Caption=FloatToStr(o); Label8->Caption=FloatToStr(p); Label9->Caption=Format("%.3f",ARRAYOFCONST((d)));

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text=""; Edit2->Text=""; Edit3->Text="";

Label7->Caption="????"; Label8->Caption="????"; Label9->Caption="????";

74


Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 42:Napraviti aplikaciju koja se sastoji od pet Panela sa natpisima crne

boje fonta veličine 24, podebljano, kao na slici.U zaglavlju forme je natpis DUGMICI. Prilikom startovanja

aplikacije samo je prvo dugme neaktivno. Klikom na neko dugme prethodno neaktivno dugme postaje aktivno, a kliknuto dugme neaktivno.

Rešenje


#include "za14_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ TButton *btnx=dynamic_cast <TButton *> (Sender);

//Utvrdjujemo koje je dugme bilo neaktivno i postavljamo ga da je aktivno. if(Button1->Enabled==false) Button1->Enabled=true; if(Button2->Enabled==false) Button2->Enabled=true; if(Button3->Enabled==false) Button3->Enabled=true; if(Button4->Enabled==false) Button4->Enabled=true; if(Button5->Enabled==false) Button5->Enabled=true;

btnx->Enabled=false; //Kliknuto dugme postaje neaktivno.}//---------------------------------------------------------------------------

75

Primer 43:Napraviti aplikaciju kao na slici. Potrebno je

prvo u programu Paint nacrtati prikazanu sliku i snimiti je u jpg formatu. Potrebno je sliku povezati sa Image komponentom ali tako da se slika neizobliči. Program treba da na osnovu unesene struje u mA izračuna i prikaže vrednost napona u V.

Podatak rešenja se dobija, pritiskom na taster ODREDI. Pritiskom na taster BRISI program se vraća u prvobitno stanje kao prilikom startovanja aplikacije.

Rešenje


#include "Kretanja_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float u,i;

if(Edit1->Text=="") { Edit1->Color=clRed; Edit1->SetFocus(); return; }

i=StrToFloat(Edit1->Text);

if(i<=0) u=0; else{ if(i<=15) u=0.4*i; else{ if(i<=20) u=0.8*(i-15)+6; else u=2*(i-15); } }

Label4->Caption=Format("%.2f",ARRAYOFCONST((u)));

76

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Label4->Caption="???"; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Click(TObject *Sender){ Edit1->Color=clWhite;}//---------------------------------------------------------------------------

Primer 44:Napraviti aplikaciju koja predstavlja kalkulator sa četiri osnovne aritmetičke operacije:

sabiranje, oduzimanje, množenje i deljenje. Prvo se moraju uneti oba operanda pa se tek tada bira operacija pritiskom na odgovarajuće dugme. Tada ako su operandi ispravno uneseni na ekranu će se prikazati rešenje ili poruka o grešci. Aplikacija poseduje i dugme POMOC čijim aktiviranjem pojavljuje se tekst sa opisom šta program radi, pri čemu se tekst ne može menjati niti kopirati deo teksta. Sa dugmetom POVRATAK vraća se na aktivni deo. Koristeći komponente GroupBox formirati dve logičke celine (grupu gde se vrši računanje i grupu gde se predstavlja upustvo).

Rešenje:

Okvir za grupu je komponenta tipa TGroupBox i nalazi se na paleti komponenti na kartici

Standard. Komponenta GroupBox je kontejnerska komponenta i služi za grupisanje komponenti, tako da komponente postaju povezane logički i fizički. Kada se komponenta smesti na komponentu GroupBox tada ta komponenta postaje dete, a GroupBox roditelj te komponente. Nakon smeštanja komponenta se ne može mišem premestiti izvan roditelja. Komponente se mogu premeštati sa jednog roditelja na drugi samo isecanjem i ponovnim umetanjem. Ako se neka komponenta prevlačenjem sa forme premesti na komponentu GroupBox, ona i dalje ostaje komponenta forme, i neće postati dete komponente GroupBox. Kada GroupBox dobije fokus dete komponente koje ima najmanji TabOrder dobiće fokus.

77


#include "Memo_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"


//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ GroupBox2->BringToFront();}//---------------------------------------------------------------------------void __fastcall TForm1::Button6Click(TObject *Sender){ GroupBox1->BringToFront();}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title=" G R E S K A !!";}//---------------------------------------------------------------------------void __fastcall TForm1::ButtonxClick(TObject *Sender){ double a,b,rez; unsigned k;

TButton* btnx = dynamic_cast<TButton*>(Sender);

if(Edit1->Text=="" && Edit2->Text=="") { ShowMessage("Niste uneli oba podatka!!"); Edit1->Text=""; Edit2->Text=""; Edit1->SetFocus(); return; }

78

if(Edit1->Text=="") { ShowMessage("Niste uneli prvi podatak!!"); Edit1->Text=""; Edit1->SetFocus(); return; }

if(Edit2->Text=="") { ShowMessage("Niste uneli drugi podatak!!"); Edit2->Text=""; Edit2->SetFocus(); return; }


//Utvrdjuje se koje je dugme kliknuto na osnovu imena dugmeta. if(btnx==Button2) rez=a+b; if(btnx==Button3) rez=a-b; if(btnx==Button4) rez=a*b;

if(btnx==Button5) { if(b==0) { ShowMessage("Greska!! Deljenje sa nulom!!"); Edit1->Text=""; Edit2->Text=""; Edit1->SetFocus(); return; } rez=a/b; }

Label4->Caption=FloatToStr(rez);}//---------------------------------------------------------------------------void __fastcall TForm1::FormAktivate(TObject *Sender){ GroupBox2->BringToFront();}//---------------------------------------------------------------------------

Primer 45:

79

Napraviti aplikaciju koja omogućava unos binarnog broja i njegov prikaz u dekadnom brojevnom sistemu.

Binarni broj se zadaje pomoću pomoću komponenti CheckBox smeštenih u komponenti GroupBox sa nazivom Binarni broj. Ako je odgovarajući CheckBox čekiran na toj težini nalazi se broj 1, a u suprotnom broj 0. Binarni broj je osmobitni. Promenom stanja čekiranja, menja se automatski i vrednost ekvivaletnog dekadnog broja koji je smepšten u komponenti Edit. Komponenta Edit je boje forme, služi samo za čitanje i maksimalne dužine je od tri karaktera. Za svih osam CheckBox-ova važi isti događaj OnClick.

Rešenje:

Okvir za potvrdu je komponenta tipa TCheckBox i nalazi se na paleti komponenata na kartici Standard. Ako okvir za potvrdu poseduje znak za potvrdu, znači da je opcija potvrđena, a ako nema znaka za potvrdu opcija nije potvrđena. Korisnik može da promeni stanje opcije klikom na sam okvir ili na natpis pored njega, ili pritiskom na znak Space sa tastature ako ima fokus.

Svojstvo Aligment određuje položaj natpisa za potvrdu: taRightJustify (natpis je sa desne strane i to je podrazumevana vrednost) i taLeftJustify (natpis je sa leve strane).

Svojstvo Checked je tipa bool s vrednošću true ako je polje potvrđeno ili false u suprotnom. Promena svojstva Chacked u toku izvršavanja aplikacije izazvaće događaj OnClick.


#include "Binarni_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::CheckBoxClick(TObject *Sender){ int broj=0; //Broj je na pocetku nula, a po definiciji veze dekadnog i binarnog broja.

if(CheckBox1->Checked==true) broj+=1; if(CheckBox2->Checked==true) broj+=2; if(CheckBox3->Checked==true) broj+=8; if(CheckBox4->Checked==true) broj+=4; if(CheckBox8->Checked==true) broj+=16; if(CheckBox7->Checked==true) broj+=32; if(CheckBox6->Checked==true) broj+=128; if(CheckBox5->Checked==true) broj+=64;

Edit1->Text=IntToStr(broj);}

80

//---------------------------------------------------------------------------

Primer 46:Napraviti aplikaciju koja pomoću promene vrednosti u komponenti CspinEdit, a menja se

pritiskom na strelice gore i dole, ispisuje u labeli dan u nedelji.

Rešenje Naredba višestrukog grananja switch ima sleći opšti oblik:

switch(izraz){

case k_1: niz_ naredbi_1; break;

case k_2: niz_ naredbi_2; break;...

case k_N: niz_naredbi_N; break;default: niz_naredbi_0;

}

Konstante k_1, k_2,...,k_N su celobrojne konstante i međusobno su različite. Izračunava se vrednost celobrojnog izraza izraz (sve promenljive u izrazu moraju biti

celobrojnog tipa) i poredi redom sa konstantama k_1, k_2, ...,k_N koje se nalaze posle rezervisane reči case. Ako vrednost izraza nije jednaka ni sa jednom konstantom izvršavaće se naredba_0. Ukoliko je vrednost izraza jednaka sa nekom konstantom k_i, i [1..N], program će se izvršavati počev od niza_naredbi_i pa do kraja naredbe switch.

U naredbi switch ne mora se koristiti mogućnost default ako to za rešavanje problema nije potrebno.

Najčešće se naredba switch koristi u kombinaciji sa naredbom break tako da ukoliko je vrednost izraza jednaka sa nekom konstantom k_i izvršavaće se samo niz_naredbi_i i posle toga će se iskočiti iz switcha (na prvu naredbu koja se nalazi posle naredbe switch).

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "dan_o.h"//---------------------------------------------------------------------------

81

#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::CSpinEdit1Change(TObject *Sender){ switch(CSpinEdit1->Value) { case 1: Label3->Caption="Ponedeljak"; break; case 2: Label3->Caption="Utorak"; break; case 3: Label3->Caption="Sreda"; break; case 4: Label3->Caption="Cetvrtak"; break; case 5: Label3->Caption="Petak"; break; case 6: Label3->Caption="Subota"; break; case 7: Label3->Caption="Nedelja"; }

if(CSpinEdit1->Value==6 || CSpinEdit1->Value==7) Label3->Font->Color=clRed; else Label3->Font->Color=clBlack;}//---------------------------------------------------------------------------

Primer 47:Napraviti aplikaciju koja se sastoji od pet Panela u jednom redu istih veličina i svi

bele boje. Boja natpisa na Panelima je crna, a veličina fonta 24 podvučeno. Ispod se nalaze Labele sa brojem belih i brojem crvenih Panela. Prilikom pokretanja aplikacije broj belih Panela je pet, a crvenih Panela nema. Komponenta CSpinEdit ima minimalnu vrednost 1, a maksimalnu 5. Izborom nekog broja sa intervala 1..5 iz CSpinEdita I pritiskom na dugmer OK, Panel čiji natpis sadrži broj izabran pomoću CSpinEdita, menja boju iz bele u crvenu i obrnuto, a time se automatski menja broj belih i crvenih Panela.

82

Rešenje:


#include "za15_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;

int brbelih=5,brcrvenih=0;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ switch(CSpinEdit1->Value) { case 1: if(Panel1->Color==clWindow) //Ako je bio bele boje postace crvene i obrnuto. { Panel1->Color=clRed; //Postaje crvene boje. brbelih=brbelih-1; //Broj belih se smanjio za jedan.. brcrvenih=brcrvenih+1; //Broj crvenih se smanjio za jedan. }else{ Panel1->Color=clWindow; //Postaje bele boje. brbelih=brbelih+1; //Broj belih se povecava za jedan. brcrvenih=brcrvenih-1; //Broj crvenih se smanjuje za jedan. } break;

case 2: if(Panel2->Color==clWindow) { Panel2->Color=clRed;

83

brbelih=brbelih-1; brcrvenih=brcrvenih+1; }else{ Panel2->Color=clWindow; brbelih=brbelih+1; brcrvenih=brcrvenih-1; } break;

case 3: if(Panel3->Color==clWindow) { Panel3->Color=clRed; brbelih=brbelih-1; brcrvenih=brcrvenih+1; }else{ Panel3->Color=clWindow; brbelih=brbelih+1; brcrvenih=brcrvenih-1; } break;

case 4: if(Panel4->Color==clWindow) { Panel4->Color=clRed; brbelih=brbelih-1; brcrvenih=brcrvenih+1; }else{ Panel4->Color=clWindow; brbelih=brbelih+1; brcrvenih=brcrvenih-1; } break;

case 5: if(Panel5->Color==clWindow) { Panel5->Color=clRed; brbelih=brbelih-1; brcrvenih=brcrvenih+1; }else{ Panel5->Color=clWindow; brbelih=brbelih+1; brcrvenih=brcrvenih-1; } }

Label2->Caption=IntToStr(brbelih); Label4->Caption=IntToStr(brcrvenih);}//---------------------------------------------------------------------------

84


unesenog vremena u sekundama, korišćenjem grafika sa slike prikazuje koje je sve vrste kretanja tela iz fizike telo napravilo do tog vremena.

Kretanja mogu biti: ravnomerno ubrzano, ravnomerno usporeno, ravnomerno i zaustavilo se.

Program poseduje zaštitu unosa pozitivnog celobrojnog podatka.

Rešenje:


#include "Kretanja_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int t;

if(Edit1->Text=="") { Edit1->Color=clRed; Edit1->SetFocus(); return; }

t=StrToInt(Edit1->Text);

if(t>0 && t<10) Label3->Caption="Ravnomerno ubrzano."; if(t>=10 && t<20) Label3->Caption="Ravnomerno ubrzano - Ravnomerno.";

if(t>=20 && t<50) Label3->Caption="Ravnomerno ubrzano - Ravnomerno -\n- Ravnomerno usporeno.";

85

if(t>=50) Label3->Caption="Ravnomerno ubrzano - Ravnomerno -\n- Ravnomerno usporeno - Zaustavilo se.";

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear();

Label3->Caption="???";


Edit1->SetFocus(); }//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Click(TObject *Sender){ Edit1->Color=clWhite;}//--------------------------------------------------------------


otpornosti dva otpornika i izračunava njegovu ekvivaletnu otpornost. Aplikacija omogućava izbor boje rešenja (crna ili crvena).

Rešenje:

Komponenta RadioGroup sadrži više radio dugmadi koji čine jednu celinu.

U okviru grupe u jednom trenutku može biti odabrano samo jedno dugme. Dugmadi su uokvireni linijom pri čemu gornja ivica sadrži natpis cele grupe. Fokus može da poseduje samo grupa kao celina. Ako grupa ima fokus biranje dugmeta može se vršiti i sa strelicma. Radio dugme je komponenta tipa TRadioGroup i nalazi se na paleti komponenti na kartici Standard. Grupa radio dugmadi ne može biti roditelj drugim komponentama.

Svojstvo ItemIndex određuje koje dugme u grupi je u pritisnutom stanju. Ako ima vrednost -1 znak je da ni jedno dugme nije pritisnuto.

Radio dugmadi se prilikom projektovanja ubacuju u grupu pomoću svojstva Items. Prilikom izbora ovog svojstva iz Object Inspectora pojavljuje se sledeći dijalog gde se u svakom redu upisuje naziv sledećeg radio dugmeta Pritiskom na

86

dugme OK u grupu će sačinjavati radio dugmadi sa nazivima koje ste u ovom svojstvu postavili i sa redosledom koji se poklapa sa redosledom koji je u stavkama po redovima naznačen u ovom svojstvu.

Svojstvo Items->Count određuje broj radio dugmadi u radio grupi. Nije praktično da se na grupi radio dugmadi postavi novo radio dugme koje toj grupi ne pripada, jer će kod korisnika aplikacije izazivati veliku zabunu.

Na gustinu dugmadi može da se utiče jedino pomoću visine i širine komponente (Height i Width).


#include "Vezaotpornika_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;int kon;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float r1,r2,rekv;

if(Edit1->Text=="" || Edit2->Text=="") return;

r1=StrToFloat(Edit1->Text); r2=StrToFloat(Edit2->Text);

switch(RadioGroup1->ItemIndex) { case 0: rekv=r1+r2; break; case 1: rekv=r1*r2/(r1+r2); }

Label4->Caption=FloatToStr(rekv);

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text="";

87

Edit2->Text="";


Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::CheckBox1Click(TObject *Sender){ if(CheckBox1->Checked==true) Label4->Font->Color=clRed; else Label4->Font->Color=clBlack; }//---------------------------------------------------------------------------

Primer 50:Napisati aplikaciju koja omogućava demonstraciju

zvuka. Postoje dva wav fajla. Jedan sadrži zvuk psa, a drugi mačke. Korišćenjem RadioGroup obezbediti da korisnik bira šta hoće da čuje, a pritiskom na na dugme OK čuće odgovarajući zvučni zapis.

RešenjePomoću API funkcije PlaySound možete uključiti

i zvuk u vašu aplikaciju. Zvuk je zapisan u fajlu u wav formatu. Prvi argument funkcije PlaySaund je ime zvučnog fajla. Za drugi parametar uvek se podtavlja broj nula, dok se treći parametar odnosi na način interpretacije zvuka. Moguće vrednosti trećeg parametra su:

SND_FILENAME - Biće aktiviram zvuk iz fajla.SND_ALIAS – Prvi parametar predstavlja sada alijas za sistemski zvuk, dok

treći parametar govori da ako se ne može pronaći sistemski zvuk koji odgovara ovom alijasu, aktiviraće se zvuk ding.

SND_MODEFAULT – Ako želimo da se u slučaju da se ne pronađe sistemski zvuk ne aktivira zvuk ding.

SND_ASYNC – Zvuk će se reprodukovati u oku rada apčikacije.SND_SYNC – Kada se zvučni fajl izvrši do kraja kontrola se vraća aplikaciji.SND_LOOP – Obezbeđuje ponavljanje reprodukcije fajla dok se ponovo ne

pozove.SND_PURGE – Prekida reprodukovanje tekućeg zvučnog fajla.

//---------------------------------------------------------------------------#include <vcl.h>#include <MmSystem>#pragma hdrstop

#include "PasiMacka_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

88

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(RadioButton1->Checked==true) PlaySound("pas.wav",0,SND_FILENAME); if(RadioButton2->Checked==true) PlaySound("macka.wav",0,SND_FILENAME);}//--------------------------------------------------------------

Primer 51:Napraviti aplikaciju koja na osnovu izabranog rednog

broja karte i vrste karte, prikazuje sliku odabrane karte.Brojevi karata su sa intervala 1..14, a vrste karte su:

karo, pik, tref i herc.Potrebno je sa interneta pronaći slike karata, a potom

ih preimenovati da bi se što lakše zadatak rešio.Slika se prikazuje pomoću komponente Image pri

čemu se mora podesiti da se slika prilagođava komponenti.

Rešenje


#include "zad1za3_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::RadioGroup1Click(TObject *Sender){ int k;

//Imena fajlova gde su slike karata su redni broj karte sa intervala 1-52.bmp //karte su grupisane na nacin: cetiri jedinice, cetiri dvojke,...,cetiri kralja. //Promenljiva k utvrdjuje redni broj karte po formuli. k=RadioGroup1->ItemIndex * 14 +CSpinEdit1->Value;

89

Image1->Picture->LoadFromFile(IntToStr(k)+".bmp"); }//---------------------------------------------------------------------------

Primer 52:

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "zad3za2_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ //Prilikom kreiranja Panel se centrira u udnosu na sirinu forme I svoju sirinu. Panel1->Left=(Form1->Width-Panel1->Width)/2;}//---------------------------------------------------------------------------void __fastcall TForm1::RadioGroup2Click(TObject *Sender){ //Odredjuje se pozicija Panela. switch(RadioGroup2->ItemIndex) { case 0: Panel1->Left=RadioGroup1->Left;

90

Napraviti aplikaciju koja na sredinu forme postavlja Panel oblika kvadrata bele boje. Ispod Panela nalaze se dve RadioButton komponente pomoću kojih se biraju: boja Panela i položaj Panela.

Boja Panela može biti: crna, crvena, bela ili plava.

Položaj Panela može biti: levo, centrirano ili desno.

break; case 1: Panel1->Left=(Form1->Width-Panel1->Width)/2; break; case 2: Panel1->Left=RadioGroup2->Left+RadioGroup2->Width-Panel1->Width; break; }}//---------------------------------------------------------------------------void __fastcall TForm1::RadioGroup1Click(TObject *Sender){ //Odredjuje se boja Panela. switch(RadioGroup1->ItemIndex) { case 0: Panel1->Color=clBlack; break; case 1: Panel1->Color=clRed; break; case 2: Panel1->Color= clWhite; break; case 3: Panel1->Color=clBlue; break; }}//---------------------------------------------------------------------------

Primer 53:

Napraviti aplikaciju koja pmogućava unos teksta u komponentu Edit a označavanjem odgovarajuće

opcije u GroupBox-su automatski se menja stil fonta unesenog teksta.Iz komponente RadioGroup može se izabrati odgovarajuća boja teksta. Na raspolaganju su tri boje: crna, plava i crvena.Pritiskom na dugme brisanje vrši se brisanje sadržaja konponente Edit.

Rešenje


#include "font_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

91

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Edit1->Clear(); Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::CheckBoxXClick(TObject *Sender){ if(CheckBox1->Checked==true&&CheckBox2->Checked==true&&

CheckBox3->Checked==true) { Edit1->Font->Style=TFontStyles()<<fsBold<<fsUnderline<<fsItalic; }

if(CheckBox1->Checked==true&&CheckBox2->Checked==true&&CheckBox3->Checked==false)

{ Edit1->Font->Style=TFontStyles()<<fsBold<<fsItalic; }

if(CheckBox1->Checked==true&&CheckBox2->Checked==false&&CheckBox3->Checked==true)

{ Edit1->Font->Style=TFontStyles()<<fsBold<<fsUnderline; }

if(CheckBox1->Checked==false&&CheckBox2->Checked==true&&CheckBox3->Checked==true)

{ Edit1->Font->Style=TFontStyles()<<fsUnderline<<fsItalic; }

if(CheckBox1->Checked==true&&CheckBox2->Checked==false&&CheckBox3->Checked==false)

{ Edit1->Font->Style=TFontStyles()<<fsBold; }

if(CheckBox1->Checked==false&&CheckBox2->Checked==true&&CheckBox3->Checked==false)

{ Edit1->Font->Style=TFontStyles()<<fsItalic; }

if(CheckBox1->Checked==false&&CheckBox2->Checked==false&&CheckBox3->Checked==true)

92

{ Edit1->Font->Style=TFontStyles()<<fsUnderline; }

if(CheckBox1->Checked==false&&CheckBox2->Checked==false&&CheckBox3->Checked==false)

{ Edit1->Font->Style=TFontStyles(); }}//---------------------------------------------------------------------------void __fastcall TForm1::RadioGroup1Click(TObject *Sender){ switch(RadioGroup1->ItemIndex) { case 0: Edit1->Font->Color=clBlack; break; case 1: Edit1->Font->Color=clBlue; break; case 2: Edit1->Font->Color=clRed; }}//---------------------------------------------------------------------------

Primer 54:

Napraviti aplikaciju koja izračunava vrednost izraza zadat formulom F(X,Y,Z) = 5XYZ + 2Z pri čemu se vrednosti promenljivih x, y i z zadaju pomoću komponenti ScrollBar. Vrednost promenljivih se kreće sa intervala 0..30. Iznad svake trake sa Labelom je opisana osa, a sa desne strane trenutna vrednost odgovarajuće promenljive.

Sa posebnom Labelom crvene boje predstavljen je rezultat vrednoti funkcije F(X,Y,Z).

Pomoću zajedničkog događaja OnChange odrediti vrednost vrednost promenljivih x,y i z, kao i vrednost funkcije F(X,Y,Z).

Rešenje

Komponenta ScrollBar predstavlja klizač, koji sadrži dva dugmeta na krajevima koja su obeležena strelicama i jednu ručku koja se može pomerati u prostoru između ta dva dugmeta. Kada je klizač u žiži površina ručke trepće. Klizač može biti postavljen horizontalno ili vertikalno. Komponenta ScrollBar je tipa TscrollBar i nalazi se na paleti komponenti kartica Standard.

Svojstva:Kind – Označava vrstu klizača. Moguće vrednosti su: ssHorizontal (horizontalan

položaj klizača) i ssVertical (vertikalan položaj klizača)Min – Najmanja vrednost koja može da se predstavi pomoću klizača.

93

Max – Najveća vrednost koja može da se predtavi pomoću klizača.Posicion – Predstavlja trenutni položaj ručke.

Metoda SetParams postavlja svojstva Posicion, Min i Max odjednom.Događaj OnScroll dešava se prilikom pomeranja klizača.


#include "Izraz_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::ScrollBarChange(TObject *Sender){ int x,y,z,f;

x=ScrollBar1->Position; Label5->Caption="X = "+IntToStr(x);

y=ScrollBar2->Position; Label9->Caption="X = "+IntToStr(y);

z=ScrollBar3->Position; Label13->Caption="X = "+IntToStr(z);

f=5*x*y*z+2*z;

Label15->Caption=IntToStr(f);}//---------------------------------------------------------------------------

Primer 55: Napraviti aplikaciju koja korišćenjem ScrollBar-ova za tri osnovne bije (crvena, plava i zelena) omogućava mešanje boja i prikazivanje određene boje nastale mešanjem na paleti.Iznad klizača potrebno je prikazati

94

procentualni učinak odgovarajuće boje.

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Mesanjeboja_o.h"#pragma package(smart_init)

#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::ScrollBarChange(TObject *Sender){ int crvena, plava, zelena;

crvena=ScrollBar1->Position; //Utvrdjuje se vrednost crvene boje. zelena=ScrollBar2->Position; //Utvrdjuje se vrednost plave boje. plava=ScrollBar3->Position; //Utvrdjuje se vrednost zelene boje.

Label5->Caption=IntToStr(crvena*100/255)+" %"; //Procentualni ispis crvene boje. Label6->Caption=IntToStr(zelena*100/255)+" %"; //Procentualni ispis plave boje. Label7->Caption=IntToStr(plava*100/255)+" %"; //Procentualni ispis zelene boje.

//Funkcijom RGB vrsi se mesanje crvene, plave i zelene boje. Panel1->Color=RGB(crvena,plava,zelena); }//---------------------------------------------------------------------------void __fastcall TForm1::fORMcREATE(TObject *Sender){ Panel1->Color=RGB(0,0,0); //Poceta boja na paleti je crna.}//---------------------------------------------------------------------------

Funkcija RGB obrazuje se boja komponente mešanjem crvene plave i zelene boje. Argumenti funkcije su inteziteti crvene, plave u zelene boje u nastaloj mešanoj složenoj boji. Intezitet osnovneboje kreće se u obsegu od 0-255.

Primer 56:Napraviti aplikaciju koja se sastoji od tri Panela kao na slici.

Na Panelima su redni brojevi: 1, 2 i 3. Svi Paneli su bele boje.U zaglavlju forme nalazi se tekst: KLIKNUTI: Klikom na neki

95

Panel boja tog Panela se manja u žuto i obrnuto, a zaglavlju je uvek aktivno zapisano koji Paneli su kliknuti, tj imaju žutu boju, i to u hronološkom redosledu.

Hronološki redosled se uvek mora prikazivati u zaglavlju forme.

Rešenje


#include "za23_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;int a,b,c;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Panel1Click(TObject *Sender){ TPanel *pnx=dynamic_cast <TPanel *> (Sender); if(pnx->Color==clWindow) { pnx->Color=clYellow;

if(pnx->Tag==1) { if(a==0 && b==0 && c==0) a=1; else if(a!=0 && b==0 && c==0) b=1; else if(a!=0 && b!=0 && c==0) c=1; }

if(pnx->Tag==2) { if(a==0 && b==0 && c==0) a=2; else if(a!=0 && b==0 && c==0) b=2; else if(a!=0 && b!=0 && c==0) c=2;

}

if(pnx->Tag==3) { if(a==0 && b==0 && c==0) a=3; else if(a!=0 && b==0 && c==0) b=3; else if(a!=0 && b!=0 && c==0) c=3; } }else{

96

if(pnx->Tag==1) { if(a==1 && b==0 && c==0) a=0; else if(a==1 && b!=0 && c==0) a=b, b=0; else if(a==1 && b!=0 && c!=0) a=b, b=c,c=0; else if(a!=1 && b==1 && c!=1) b=c,c=0; else if(a!=1 && b!=1 && c==1) c=0;

}


}


} pnx->Color=clWindow; }

AnsiString s="KLIKNUT: ";; if(a!=0) s+=IntToStr(a)+" ";; if(b!=0) s+=IntToStr(b)+" "; if(c!=0) s+=IntToStr(c)+" ";

if(s!="")Form1->Caption=s; }//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ a=b=c=0;}//---------------------------------------------------------------------------

Primer 57:Napisati C program koji predstavlja

igru pogađanja zamišljenog broja. Računar je zamislio broj a korisnik programa (igrač) ima pravo na šest pokušaja da broj pogodi.

97

Računar je zamislio broj iz intervala 1..99. Posle svakog pokušaja u STATUSNOJ LINIJI koja se nalazi pri kraju forme ispisuje se podatak:

> - ako je zamišljeni broj veći od onog kojeg je igrač odigrao,< - ako je zamišljeni broj manji od onog kojeg je igrač odigrao i= - ako je zamišljeni broj pogođen.Po završetku igre igrača iznenaditi nekom zanimljivom porukom pomoću ShowMessage

prozora.Program poseduje zaštitu unosa prirodnog broja sa intervala 1..99.

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "zad3za3_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;Int k, zbroj;//---------------------------------------------------------------------------

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ randomize(); k=6; //Broj pokusaja je na pocetku 6. zbroj=random(99)+1; //Pomocu generatora slucajnih brojeva racunar je zamislio broj. Application->Title="GRESKA...";}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int br;

AnsiString ss=Label5->Caption+" "; br=StrToInt(Edit1->Text);

k--; //Broj pokusaja se smanbjuje za jedan. Label2->Caption=IntToStr(k);

if(zbroj==br) //Utvrdjuje se da li je pogodjen zamisljeni broj. { Edit1->Enabled=false; ShowMessage("Bravo!! Pogodili ste trazeni broj!!");

98

//Sve vracamo na pocetak igre. Label2->Caption="6"; Label5->Caption=""; Edit1->Enabled=true; Edit1->Clear(); Edit1->SetFocus(); k=6;

return; }else{ if(zbroj>br) //Da li je zamisljeni broj veci od onog kojeg je korisnik uneo. { ss+="X>"+IntToStr(br)+" "; Label5->Caption=ss; }else{ ss+="X<"+IntToStr(br)+" "; Label5->Caption=ss; }

if(k==0) //Da li je iskoristio korisnik sve pokusaje. { Edit1->Enabled=false; ShowMessage("Niste pogodili trazeni broj!!");

//Sve vracamo na pocetak igre. Label2->Caption="6"; Label5->Caption=""; Edit1->Enabled=true; Edit1->Clear(); Edit1->SetFocus(); k=6;

return; } }

Edit1->Clear();}//---------------------------------------------------------------------------

Primer 58:Napraviti aplikaciju koja predstavlja poznatu igricu XOX

sa dva igrača. U zaglavlju forme piše tekst XOX . Na formi se nalale dve

Labele. Na prvoj piše tekst Sada igra, a na drugoj slovo O ili X. Ispod se nalaze devet Panela raspoređenih u tri reda po tri Panela a smeštenih na GroupBoxu. Paneli su istih dimenzija, istog fonta.

Na dnu se nalazi dugme sa natpisom NOVA IGRA. Na slučajan nači u OnCreate forme određuje se koji je igrač prvi na

99

potezu (O ili X) i upisuje u Labelu. Klikom na dugme NOVA IGRA brise se tekst sa svakog Panela i svaki Panel postaje aktivan.

Paneli prilikom pokretanja aplikacije nemaju nikakav natpis, a svojstva Tag im je različita i kreće se od 1 do 9.

Klikom na odgovarajući Panel na njemu se upisuje odgovarajući natpis (O ili X), Panel postaje neaktivan, u odgovarajućoj Labeli se upisuje ko je sledeći na potezu, a potom se korišćenjem svojstva Tag od komponente na koju je kliknuto i operatora dynamic_cast utvrđuje da li je poslednjim potezom dobijen pobednik. Ako je dobijen pobednik odgovarajućom porukom u obliku dijaloga saopštava pobednik.

Rešenje

#include <vcl.h>#pragma hdrstop#include "primer16a_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;int br; //Broj popunjenih ili odigranih polja.//---------------------------------------------------------------------------

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){

}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){

Application->Title="Kraj!!";randomize();

//Na slucajan nacin se utvrdjuje koji igrac je na potezu X ili O.int k=random (100);

if(k%2!=0)Label2->Caption="O"; else Label2->Caption="X";

br=0;}//---------------------------------------------------------------------------void __fastcall TForm1::Panel1Click(TObject *Sender){ TPanel *pan; pan=dynamic_cast<TPanel *> (Sender);

if(pan->Caption!="") return; //Nema igre ako je kliknuto na vec odigrano polje.

100

if(Label2->Caption=="O") Label2->Caption="X"; //Odredjuje se ko je sledeci na potezu. else Label2->Caption="O";

br=br+1; //Broj odigranih poteza sa povecava za jedan.

switch(pan->Tag) //Na osnovu svojstva Tag odredjuje se polozaj polja u igri. {

//Utvrdjuje se da li smo vec dobili pobednika. To se postize ispitivanjem svake moguce //kombinacije u odnosu na odigrano polje te ako smo dobili pobednika ispisujemo poruku I //onemogucavamo dalju igru.

case 1: if(pan->Caption==Panel2->Caption&&pan->Caption==Panel3->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel4->Caption&&pan->Caption==Panel7->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel5->Caption&&pan->Caption==Panel9->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } break;

case 2: if(pan->Caption==Panel1->Caption&&pan->Caption==Panel3->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel5->Caption&&pan->Caption==Panel8->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } break;

case 3: if(pan->Caption==Panel1->Caption&&pan->Caption==Panel2->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; }

101

if(pan->Caption==Panel6->Caption&&pan->Caption==Panel9->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel5->Caption&&pan->Caption==Panel7->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } break;


case 5: if(pan->Caption==Panel1->Caption&&pan->Caption==Panel9->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel3->Caption&&pan->Caption==Panel7->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel2->Caption&&pan->Caption==Panel8->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel4->Caption&&pan->Caption==Panel6->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return;

102

} break;


case 7: if(pan->Caption==Panel1->Caption&&pan->Caption==Panel4->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel8->Caption&&pan->Caption==Panel9->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel5->Caption&&pan->Caption==Panel3->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } break;


103

case 9: if(pan->Caption==Panel1->Caption&&pan->Caption==Panel5->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel7->Caption&&pan->Caption==Panel8->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } if(pan->Caption==Panel3->Caption&&pan->Caption==Panel6->Caption) { ShowMessage("Pobednik je "+pan->Caption); GroupBox1->Enabled=false; return; } break;} if(br==9) ShowMessage ("Nereseno!!"); Ako su popunjena sva polja rezultat igre je nereseno.}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ br=0; //Kliknuto je na dugme NOVA IGRA.

//Omogucava se ponovno igranje a sva polja su ponovno prazna I na potezu je igrac koji //je partiju izgubio ili nije bio poslednji na potezu pri rezultatu NERESENO.

GroupBox1->Enabled=true;

Panel1->Caption=""; Panel2->Caption=""; Panel3->Caption=""; Panel4->Caption=""; Panel5->Caption=""; Panel6->Caption=""; Panel7->Caption=""; Panel8->Caption=""; Panel9->Caption="";}//---------------------------------------------------------------------------

Primer 59:

Napraviti aplikaciju koji na osnovu parametara diskutuje rešenja kvadratnog izraza pri čemu parametar može imati za vrednost karaker: =, > ili <.

104

Beskonačnost se označava sa velikim slovom B.Prazan skup se označava sa {}.

Rešenje je u skupu realnih brojeva. Ako Izraz ima beskonačno rešenja oznaka je x = R.Sva ostala rešenja ako je nejednačina u pitanju prikazati u vidu intervala.Program poseduje zaštitu unosa racionalnih brojeva.

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#include <math.h>#pragma hdrstop#include "zad5za3_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="" && Edit2->Text==""&&Edit3->Text=="") { ShowMessage("Niste uneli sva tri podatka!!"); Edit1->SetFocus(); return; }

if(Edit1->Text=="" && Edit2->Text==""&&Edit3->Text!="") { ShowMessage("Niste prvi i drugi podatak!!"); Edit1->SetFocus(); return; }

if(Edit1->Text=="" && Edit2->Text!=""&&Edit3->Text=="") { ShowMessage("Niste uneli prvi i treci podatak!!"); Edit1->SetFocus(); return; }

if(Edit1->Text!="" && Edit2->Text==""&&Edit3->Text=="") {

105

ShowMessage("Niste uneli drugi i treci podatak!!"); Edit2->SetFocus(); return; }

if(Edit1->Text=="") { ShowMessage("Niste uneli prvi podatak!!"); Edit1->SetFocus(); return; }

if(Edit2->Text=="") { ShowMessage("Niste uneli drugi podatak!!"); Edit2->SetFocus(); return; }

if(Edit3->Text=="") { ShowMessage("Niste uneli treci podatak!!"); Edit3->SetFocus(); return; }

float a,b,c,d,x1,x2;


if(a==0) { ShowMessage("Parametar a mora biti razlicit od nule!!"); Edit1->SetFocus(); return; }

b=StrToFloat(Edit2->Text); c=StrToFloat(Edit3->Text);

d=b*b-4*a*c; //Odredjuje se vrednost diskriminante.

//Na osnovu znaka utvrdjuje se tip izraza. switch(RadioGroup1->ItemIndex) { case 0: if(d==0) { x1=-b/(2*a);

Label6->Caption=Format("X = %.2f",ARRAYOFCONST((x1)));

106

}else{ if(d<0) Label6->Caption="X = {}"; else{ x1=(-b+sqrt(d))/(2*a); x2=(-b-sqrt(d))/(2*a);

if(x1<x2) Label6->Caption=Format("X = {%.2f,%.2f}",ARRAYOFCONST((x1,x2)));

else Label6->Caption=Format("X = {%.2f,%.2f}",ARRAYOFCONST((x2,x1)));

} } break;

case 1: if(d==0) { x1=-b/(2*a);

if(a>0) Label6->Caption=Format("X = R\{%.2f}",ARRAYOFCONST((x1)));

else Label6->Caption="X = {}"; }else{ if(d<0) { if(a>0) Label6->Caption="X = R"; else Label6->Caption="X = {}"; }else{ x1=(-b+sqrt(d))/(2*a); x2=(-b-sqrt(d))/(2*a);

if(x1<x2) { if(a>0) Label6->Caption=Format("X = {-B,%.2f) U (%.2f,+B}",

ARRAYOFCONST((x1,x2))); else Label6->Caption=Format("X = {%.2f,%.2f)",

ARRAYOFCONST((x1,x2))); }else{ if(a>0) Label6->Caption=Format("X = {-B,%.2f) U (%.2f,+B}",


ARRAYOFCONST((x2,x1))); } } } break,

case 2: if(d==0) { x1=-b/(2*a);

if(a<0)

107

Label6->Caption=Format("X = R\{%.2f}",ARRAYOFCONST((x1))); else Label6->Caption="X = {}"; }else{ if(d<0) { if(a<0) Label6->Caption="X = R"; else Label6->Caption="X = {}"; }else{

x1=(-b+sqrt(d))/(2*a); x2=(-b-sqrt(d))/(2*a);

if(x1<x2) { if(a<0) Label6->Caption=Format("X = {-B,%.2f) U (%.2f,+B}",


ARRAYOFCONST((x1,x2))); }else{ if(a<0) Label6->Caption=Format("X = {-B,%.2f) U (%.2f,+B}",


ARRAYOFCONST((x2,x1))); } } } break; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Edit3->Clear();

Label6->Caption="";}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="GRESKA!!!";}//---------------------------------------------------------------------------void __fastcall TForm1::RadioGroup2Click(TObject *Sender){ switch(RadioGroup2->ItemIndex) { case 0: Label5->Font->Color=clBlack; Label6->Font->Color=clBlack; break; case 1: Label5->Font->Color=clBlue;

108

Label6->Font->Color=clBlue; break; case 2: Label5->Font->Color=clRed; Label6->Font->Color=clRed; break; case 3: Label5->Font->Color=clGreen; Label6->Font->Color=clGreen; break; }}//---------------------------------------------------------------------------

Primer 60:Napraviti aplikaciju koja omogućava ispis cifre 0 – 9 u

Labeli fonta boldovanog veličine 48.Pritiskom na taster cifre, cifra se prikazuje u Labeli.

Rešenje

Osnovni događaj koji može da se proizvede pomoću tastature jeste pritisak i otpuštanje nekog tastera na tastaturi, a to je događaj OnKeyPress Ovaj događaj nastaje samo ako je pritisnut neki taster sa znakom koji ima svoj ASCII kod. Ako se pritisne neki drugi taster (kao što su funkcijski tasteri), ne smatra se da se desio događaj pritiska i otpuštanja tastera. Vrednost pritisnutog tastera smešta se u argument Key. Ako se u rukovaocu događaja promeni vrednost promenljive Key, program se ponaša kao da je preko tastature unesen taj karakter, a ne karakter čiji je taster pritisnut. Ako u rukovaocu događaja vrednost promenljive Key postane 0, smatraće se da taster nije pritisnut.

Argument Key je znakovnog tipa. Promena se vrši tako što joj se dodeli neki drugi znak napisan između znakova apostrofa. Ako se dodeli broj u promenljivu Key se upisuje onaj karakter koji u ASCII tabeli ima taj ordinatni broj.

Događaji pomoću tastature uvek se dešavaju aktivnoj komponenti (onoj koja ima trenutno fokus). Kada za trenutno aktivnu komponentu nisu predviđeni događaji tastature, pritisci na tastere tastature tumače se kao tasteri prečice za odabiranje drugih komponenti.


#include "Tasteri_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key){

109

if(Key<'0' || Key>'9') Key=0; //Ako nije cifra nece se nista desiti jer kada Key //promenljiva dobije vrednost 0 kao da taster nije //pritisnut.

else{ int k=Key-48; //Pretvaramo karakter u broj. Label1->Caption=IntToStr(k); //Pretvaramo broj u string. }}//-----------------------------------------------------------

Primer 61:Napraviti aplikaciju koja na osnovu unesene

dužine stranice kocke izračunava površinu i zapreminu. Pre nego što se unese dužina stranice kocke mora se uneti šifra. Umesto karaktera iz šifre ispisuju se znaci #. Kada se unese šifra, pritiskom na dugme POTVRDI ustanovljava se da li je šifra ispravno unesena, te ako jeste polje za unos postaje bele boje i dobija fokus, a u suprotnom morate unositi ponovno šifru. U polje se može unositi onoliko karaktera koliko karaktera u to polje može da stane. Po završetku unosa šifre dugme POTVRDI postaje aktivno.

Prilikom unosa dužine stranice postoji zaštita: Ne dozvoljava se unos drugih karaktera osim brojeva od 0 do 9 i decimalne tačke; i Prva karakter ne može biti decimalna tačka ili 0

Nakon uspešno unesene dužine stranice dugme OK postaje aktivno i pritiskom na taster Enter ili klikom na dugme izračunava se i prikazuje na ekranu površina i zapremina kocke.

Rešenje

Možete da izaberete između dva tipa provere korisničkog unosa: provera na nivou obrasca i provera na nivou polja. Provera na nivou obrasca proverava podatke kada korisnik popuni polja na obrascu. Provera na nivou polja vam daje kontrolu nad korisničkim unosom u trenutku kada se on dešava.

Komponenta Edit poseduje svojstvo MaxLength koje onemogućava da korisnik unese više karaktera nego što je tim svojstvom dozvoljeno. Često se svojstvo MaxLength postavlja na vrednost koja predstavlja fizički broj karaktera koji se mogu upisati u Edit i da budu uvek vidljivi. Pored toga komponenta Edit poseduje i svojstvo PaswordChar koje omogućava da se prilikom unosa umesto karaktera koje korisnik unosi upisuje neki poseban karakter. Ovo svojstvo se koristi prilikom unosa šifri.


#include "Kocka_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

110

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ AnsiString s="prolazak"; //Sifra koju treba uneti.

if(Edit1->Text==s) //Ako je sifra pogodjena moze se dalje unositi podatak. { Button1->Enabled=true; Button2->Enabled=true; Edit2->Enabled=true; Edit2->Color= clBtnHighlight; Edit2->SetFocus(); }else{ Edit1->Text=""; Button2->Enabled=false; Edit1->SetFocus(); }}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Change(TObject *Sender){ AnsiString s;

//Ako unesete potreban broj znakova dugme za proveru sifre postaje aktivno. s=Edit1->Text;

if(s.Length()==Edit1->MaxLength) { Button1->Enabled=true; Button1->SetFocus(); }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ double a,v,p;


p=6*a*a; v=a*a*a;

Label6->Caption=FloatToStr(p); Label7->Caption=FloatToStr(v);}//---------------------------------------------------------------------------

111

void __fastcall TForm1::Edit2KeyPress(TObject *Sender, char &Key){ if(!((Key>='0'&&Key<='9')||Key=='.'))Key=0; else{ if(Edit2->Text==""&&(Key=='.'||Key=='0')) Key=0; }}//---------------------------------------------------------------------------

Primer 62:Napraviti aplikaciju koja predstavlja brojanje u dva

smera: od 0 do 9 i od 9 do 0. Pomoću logičke promenljive kontrolisati smer brojanja. Na formi se vidi jedna Labela fonta 30 crvene boje.Prilikom startovanja aplikacije vrednost broja je nula. Pritiskom na taster Enter vrednost broja se menja. Forma je dijaloškog oblika.

Rešenje //--------------------------------------------------------------------------- //---------------------------------------------------------------------------#include <vcl.h>#include <vcl.h>#pragma hdrstop#pragma hdrstop

#include "Daj_o.h"#include "Daj_o.h"//---------------------------------------------------------------------------//---------------------------------------------------------------------------#pragma package(smart_init)#pragma package(smart_init)#pragma resource "*.dfm"#pragma resource "*.dfm"TForm1 *Form1;TForm1 *Form1;bool kon=true; //Odredjuje da li je uvecanje ili umanjenje broja.bool kon=true; //Odredjuje da li je uvecanje ili umanjenje broja.int k=0; //Trenutna vrednost broja.int k=0; //Trenutna vrednost broja.//---------------------------------------------------------------------------//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) : TForm(Owner){{}}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key)void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key){{ if(Key!='\r') Key=0; //Desava se samo pritiskom na taster Enter. if(Key!='\r') Key=0; //Desava se samo pritiskom na taster Enter. else{ else{ if(kon==true) k++; //Uvecanje broja za jedan. if(kon==true) k++; //Uvecanje broja za jedan. else k--; //Smanjenje broja za jedan. else k--; //Smanjenje broja za jedan.

if(kon==true&&k==9) kon=false; //Iz rasta prelazi se u opadanje. if(kon==true&&k==9) kon=false; //Iz rasta prelazi se u opadanje. if(kon==false&&k==0) kon=true; //Iz opadanja prelazi se u rast. if(kon==false&&k==0) kon=true; //Iz opadanja prelazi se u rast.

Label1->Caption=IntToStr(k); Label1->Caption=IntToStr(k); } } }}//---------------------------------------------------------------------------//---------------------------------------------------------------------------

112

Primer 63:Napraviti aplikaciju koja se

sastoji od dva puta kojima se može kretati čikica. Postoje dve čikice kao na slici. Prvi se kreće horizontalno pritiskom tasterima Lea strelica i Desna strelica. Drugi se kreće vertikalno Gornja strelica i Donja strelica.

Put kretanja je ograničen i kod jednog i drugog puta.

Rešenje

//---------------------------------------------------------------------------//---------------------------------------------------------------------------#include <vcl.h>#include <vcl.h>#pragma hdrstop#pragma hdrstop

#include "Cika_o.h"#include "Cika_o.h"//---------------------------------------------------------------------------//---------------------------------------------------------------------------#pragma package(smart_init)#pragma package(smart_init)#pragma resource "*.dfm"#pragma resource "*.dfm"TForm1 *Form1;TForm1 *Form1;//---------------------------------------------------------------------------//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) : TForm(Owner){{}}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::FormKeyDown(TObject *Sender, WORD &Key,void __fastcall TForm1::FormKeyDown(TObject *Sender, WORD &Key, TShiftState Shift) TShiftState Shift){{ //Dogadjaj OnKeyDown poseduje mogucnost reagovanja na tastere strelice. //Dogadjaj OnKeyDown poseduje mogucnost reagovanja na tastere strelice. //37 – je redni broj strelice Desno. //37 – je redni broj strelice Desno. //39 – je redni broj strelice Levo. //39 – je redni broj strelice Levo. //38 – je redni broj strelice Gore. //38 – je redni broj strelice Gore. //37 – je redni broj strelice Dole. //37 – je redni broj strelice Dole.

if(Key!=37 && Key!=39 && Key!=38 && Key!=40) Key=0; if(Key!=37 && Key!=39 && Key!=38 && Key!=40) Key=0; else{ else{ if(Key==37 && Image1->Left>0) Image1->Left-=5; if(Key==37 && Image1->Left>0) Image1->Left-=5; if(Key==39&&Image1->Left+Image1->Width<Panel1->Width) if(Key==39&&Image1->Left+Image1->Width<Panel1->Width)

Image1->Left+=5; Image1->Left+=5; if(Key==40&&Image2->Top+Image2->Height<Panel2->Height) if(Key==40&&Image2->Top+Image2->Height<Panel2->Height)

Image2->Top+=5; Image2->Top+=5; if(Key==38 && Image2->Top>0) Image2->Top-=5; if(Key==38 && Image2->Top>0) Image2->Top-=5; } }

113

}}//---------------------------------------------------------------------------//---------------------------------------------------------------------------

Primer 64:Napraviti aplikaciju koja predstavlja funkciju sa

ScrollBarovima i CspinEditom. Funkcija ima izraz F(X,Y,Z) = 4XYZ + aY. Parametar a je celobrojni podatak sa intervala 0..20, a i x, y i z promenljive čije vrednoisti se dobijaju pomoću ScrollBarova su sa intervala 0..20.

Promenom vrednosti nekih od parametara funkcije menja se i vrednost funkcije, zapisana u Labeli crvene boje kao na slici.

Program mora imati zaštitu unosa broja a u CspinEditu tako da se mora omogućiti unos broja isključivo sa intervala 0..20.

Rešenje

//---------------------------------------------------------------------------//---------------------------------------------------------------------------#include <vcl.h>#include <vcl.h>#pragma hdrstop#pragma hdrstop

#include "zad2za2_o.h"#include "zad2za2_o.h"//---------------------------------------------------------------------------//---------------------------------------------------------------------------#pragma package(smart_init)#pragma package(smart_init)#pragma link "CSPIN"#pragma link "CSPIN"#pragma resource "*.dfm"#pragma resource "*.dfm"TForm1 *Form1;TForm1 *Form1;int x,y,z,a;int x,y,z,a;//---------------------------------------------------------------------------//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) : TForm(Owner){{}}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::ScrollBar1Change(TObject *Sender)void __fastcall TForm1::ScrollBar1Change(TObject *Sender){{ int rez; int rez;

x=ScrollBar1->Position; x=ScrollBar1->Position; y=ScrollBar2->Position; y=ScrollBar2->Position; z=ScrollBar3->Position; z=ScrollBar3->Position;

if(CSpinEdit1->Text=="") if(CSpinEdit1->Text=="") { { CSpinEdit1->Value=0; CSpinEdit1->Value=0; return; return; } } a=CSpinEdit1->Value; a=CSpinEdit1->Value;

if(CSpinEdit1->Value>20 || (CSpinEdit1->Value>10 && CSpinEdit1->Value%2!=0)) if(CSpinEdit1->Value>20 || (CSpinEdit1->Value>10 && CSpinEdit1->Value%2!=0)) { {

114

CSpinEdit1->Value=0; CSpinEdit1->Value=0; return; return; } }

rez=4*x*y*z+a*y; rez=4*x*y*z+a*y;

Label12->Caption=Format("F(%d,%d,%d) = %d",ARRAYOFCONST((x,y,z,rez))); Label12->Caption=Format("F(%d,%d,%d) = %d",ARRAYOFCONST((x,y,z,rez)));}}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::CSpinEdit1KeyPress(TObject *Sender, char &Key)void __fastcall TForm1::CSpinEdit1KeyPress(TObject *Sender, char &Key){{ if(!(Key>='0' && Key<='9') && Key!=8) Key=0; if(!(Key>='0' && Key<='9') && Key!=8) Key=0; else{ else{ if((CSpinEdit1->Text=="" || CSpinEdit1->Value<10) && Key==8) if((CSpinEdit1->Text=="" || CSpinEdit1->Value<10) && Key==8) { { CSpinEdit1->Value=0; CSpinEdit1->Value=0; Key=0; Key=0; return; return; } } if(CSpinEdit1->Text=="0") CSpinEdit1->Clear(); if(CSpinEdit1->Text=="0") CSpinEdit1->Clear(); } }}}//---------------------------------------------------------------------------//---------------------------------------------------------------------------

CIKLUSI (PETJE)

Ciklusi su upravljačke strukture koje omogućavaju ponovljeno izvršavanje neke naredbe. Po načinu zadavanja uslova koji treba da se ponavlja mogu da postoje:

ciklusi koji traju dok je uslov ispunjen, ciklusi koji traju dok uslov nije ispunjen, i brojački ciklusi.

U programskom jeziku C postoje tri upravljačke strukture za realizaciju ciklusa: while, do-while i for. Sve tri upravljačke strukture spadaju u cikluse koji traju dok je uslov ispunjen. To je na neki način loša strana C jezika.

Primer 65:Napisati aplikaciju koja na osnovu unetog prirodnog broja N izračunava zbir kvadrata prvih

N prirodnih brojeva.

Rešenje:

115

WHILE NAREDBA

Opšti oblik while ciklusa je: while(uslov) naredba;Osobine while ciklusa: While ciklus se izvršava sve dok je uslov logička

istina (različit od nule), Koristi se kada se nezna kojiko će se ciklus izvršavati, Uvek se prvo proverava da li je uslov logička istina, te

ako jeste naredba se izvršava, i Može se desiti da se uslov ne izvrši nijednom (na

početku uslov nije zadovoljen).

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Zbir.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key)) Key=0; //Karakter mora biti broj. else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(ed->Text=="" && Key=='0') Key=0; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ unsigned s,i,n;

if(Edit1->Text=="") { Edit1->SetFocus(); //Ako je Edit prazan znaci da nema broja i broj se mora uneti. return; }

n=StrToInt(Edit1->Text); //Broj postoji i pretvara se iz stringa u dekadni broj.

i=1; while(i<=n)

116

{ s=s+i*i; //Formula po kojoj se računa zbir. i++; }

Label3->Caption=IntToStr(s); //Ybir se upisuje u Labelu.

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text=""; kon=false;

Label3->Caption="????"; Button1->Enabled=true; Button2->Enabled=false;

Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 66:Napisati aplikaciju koja omogućava unos

racionalnog broja uz kompletnu kontrolu unosa, a potom utvrđuje koliko članova beskonačnog niza treba sabrati pa da zbir bude veći od tog unetog racionalnog broja. Beskonačni niz je oblika:

Rešenje:

DO-WHILE NAREDBA

Opšti oblik do-while naredbe je:do{

naredba;

}while(uslov);

Osobine do-while naredbe:

117

Koristi se kada se ne zna koliko će se puta ciklus ponavljati,

Prvo se izvršava naredba koja čini sadržaj ciklusa, a posle toga se izračunava vrednost logičkog izraza uslov, i ako se dobija logička istina naredba se ponovno izvršava.

Ciklus se završava kada uslov dobija vrednost logičke neistine, i

Ciklus se izvršava barem jednom.Ciklus do-while se može posmatrati kao specijalni oblik while ciklusa.

do{ naredba;naredba; = while(uslov) naredba;

}while(uslov);

//---------------------------------------------------------------------------#include <vcl.h>#include <string.h>#pragma hdrstop#include "Dknebude.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//----------------------------------------------------------------------------

//----------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float s=0,broj; int i;

if(Edit1->Text=="") return; broj=StrToFloat(Edit1->Text);

i=0; do{ i++; if(i==1) s=1; else s+=(float)i/((float)i-1); }while(s<=broj);

Label4->Caption=IntToStr(i);}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){

118

if(!isdigit(Key) && Key!=8 &&Key!='.') Key=0;}//---------------------------------------------------------------------------


na osnovu unetog prirodnog broja N izračunava i u polju za prikaz prikazuje zbir S.

Zbir S se računa po formuli sa slike.

Program poseduje zaštitu unosa od neunesenog broja, a u polju unosa mogu se unositi samo decimalne cifre.

Rešenje:

FOR NAREDBA

Najveća primena for ciklusa je u formiranju brojačkih ciklusa. Brojački cikllusi se koriste kada je poznato koliko puta će se ciklus izvršiti. Kod brojačkih ciklusa postoji uvek jedna kontrolna promenljiva čija se vrednost menja od neke početne pa do neke krajnje vrednosti. Na kraju svakog prolaska kroz ciklus vrednost kontrolne promenljive se promeni za neku stalnu vrednost, sve dok se ne stigne do krajnje vrednosti.

for(kontprom=pocvrednost;kontprom<=kranjavrednost;kontprom+=korak) naredba;

Najčešće se kontrolna promenljiva na početku postavlja na jedan, a korak za koji se kontrolna promenljiva povećava jednaka je jedan.

Najčešći oblik for cilkusa kao brojačkog ciklusa je:for(kontprom=1;kontprom<=krajnjavrednost;kontprom++) naredba;

Vrednost promenljive krajnjavrednost pokazuje nam koliko će se puta for ciklus izvršiti. Ako je vrednost promenljive krajnjavrednost manja od 1 for ciklus se neće nijednom izvršiti.


#include "Zbir_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

119

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") { ShowMessage("Niste uneli podatak!!"); return; }

int n,p,s; n=StrToInt(Edit1->Text);

s=0; p=1; for(int i=1;i<=n;i++) { p*=i; s+=p; }

Edit2->Text=IntToStr(s); Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Button1->Enabled=true; Button2->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key)) Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(ed->Text=="" && Key=='0') Key=0; }}//---------------------------------------------------------------------------

Primer 68:

120

Napraviti aplikaciju koja na osnovu unesenog prirodnog broja N izračunava N-ti član Fibonačijevog niza FIB(N) i zbir prvih N članova Fibonačijevog niza S(N).

Program poseduje zaštitu unosa prirodnog broja. Broj je unesen ako se pritisne taster SPACE.

Fibonačijev niza ima zakonitost takvu da mu prva dva člana niza imaju vrednost 1, a da se počev od trećeg člana svaki sledeći dobija kao zbir prethodna dva člana.

Rešenje:


#include "zad11za2_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=' ') Key=0; else{ if(Edit1->Text=="" && Key=='0') Key=0; else{ if(Key==' ') //Prihvata se da je broj unesen nakon pritiska tastera Space. { int i,n,s,fib,p,q;

n=StrToInt(Edit1->Text);

for(i=1;i<=n;i++) { if(i<3) //Zakonitost pocinje od treceg broja. { if(i==1) s=1,fib=1; //Prvi clan else s=2,fib=1,p=q=1; //Drugi clan. }else{

121

q=p+q; //Novi clan se dobija zbirom prethodna dva. p=q-p; //Prethodni clan. s=s+q; //Sabira se novi clan; fib=q; //Vrednost novog clana. } }

Label4->Caption= Format("FIB(%d) = %d",ARRAYOFCONST((n,fib))); Label5->Caption= Format("S(%d) = %d",ARRAYOFCONST((n,s))); Edit1->Enabled=false; } } }}//---------------------------------------------------------------------------

Primer 69:Napraviti aplikaciju koja će na formu

programski pravilno razbacati 30 dugmadi istih dimenzija (5 redova po 6 dugmadi). Dugmadi poseduju brojeve redom od 1 do 30. Kada se klikne na neko dugme, kliknuto dugme nestaje sa forme.

Rešenje://---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "fORMDUGME_O.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

unsigned pom;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ //Obradjuje se dogadjaj FormCreate za sve komponente koje se dodaju formi.

122

unsigned i,j;

//Zaglavlje poruke o greski. Application->Title="";

pom=1; for(i=0;i<6;i++){ for(j=0;j<5;j++){ TButton* btn = new TButton(this); //Ovde se zapravo kreira tih 6 dugmica

btn->Parent = this; //Kreiraju se u lokalnu promenljivu, i onda im dodelimo

//Parent-u i u konstruktoru ko mu je roditelj u hierarhiji objekata

btn->Height=50; //Visina dugmeta. btn->Width=50; //Sirina dugmeta. btn->Top = 20+j*(btn->Height+20); btn->Left = 20+i*(btn->Width+20);

btn->OnClick = ButtonXClick; //Svako dugme reagovace na dogadjaj Click //sa imenom ButtonXClick.

btn->Tag = 5*i+j; btn->Font->Size=12; btn->Caption = IntToStr(j*6+i+1); } }}//---------------------------------------------------------------------------void __fastcall TForm1::ButtonXClick(TObject *Sender){ TButton* btnx = dynamic_cast<TButton*>(Sender);

btnx->Visible=false; //Podesavanjem svojstva Visible na false komponente koja je //primila dogadjaj Click dugme se nece videti na formi.

pom++;

if(pom==31) ShowMessage("BRAVO MAJSORE!!");} //---------------------------------------------------------------------------

Primer 70:Napisati aplikaciju koja na

osnovu unetog prirodnog broja n formira inverzni broj kod koga su cifre napisane u inverznom poretku.

Rešenje:

//---------------------------------------------------------------------------

123


#include "Dekubin.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ unsigned i,n,broj;

if(Edit1->Text=="") { Edit1->SetFocus(); return; } n=StrToInt(Edit1->Text);

i=1; while(n>0) { if(i==1) broj=n%10; //Ako se dobija prva cifra. else broj=10*broj+n%10; //Formula po kojoj se dodaje nova cifra. n=n/10; i++; }

Label3->Caption=IntToStr(broj);

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text=""; Label3->Caption="????"; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){

124

if(!isdigit(Key)) Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(ed->Text=="" && Key=='0') Key=0; }}//---------------------------------------------------------------------------

Primer 71:Napraviti aplikaciju koja u toku formiranja Forme dinamički formira u jednom redu red od

15 panela bele boje fonta veličine 14, podebljan i iskošen. Širina i visina panela su jednaki i iznose 30, a razmak između panela je 10.

Natpisi na panelima su brojevi slučajni sa intervala 0 – 100. U zaglavlju programa ispisuje se vrednost minimalnog i maksimalnog broja među natpisima panela.

Rešenje:


#include "stviri_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ randomize(); int min,max;

//sa for ciklusom formiramo 15 Panela. for(int i=1;i<=15;i++) { TPanel *pn=new TPanel(this); pn->Parent=this;

pn->Width=30;

125

pn->Height=30;

pn->Left=20+(i-1)*(pn->Width+10); pn->Top=20;

pn->Font->Size=14; pn->Font->Style=TFontStyles()<<fsBold<<fsItalic; pn->Color=clWhite;

int br=random(100); //Na slucajan nacin se generise broj.

pn->Caption=IntToStr(br); //Upise se broj kao natpis Panela.

//Tehnika odredjivanja maksimuma i minimuma. if(i==1) min=max=br; else{ if(br<min) min=br; if(br>max) max=br; } }

Form1->Caption="Minimum = "+IntToStr(min)+" Maksimum = "+IntToStr(max);}//---------------------------------------------------------------------------

Primer 72:Naraviti aplikaciju koja na osnovu

unesenog prirodnog broja N izračunava zbir prvih N članova beskonačnog niza kao na slici. Program poseduje zaštitu unosa prirodnog broja. Prvi član beskonačnog niza je 1. Elementi sa neparnim rednim brojem dobijaju se tako što se vrednost predhodnog člana uveća za tri, a elementi sa parni rednim brojem tako što se vrednost prethodnog člana pomnoži sa dva.

Rešenje:


#include "zad10za2.h"//---------------------------------------------------------------------------

126

#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int n,i; long s=0,p; bool kon=true;

if(Edit1->Text=="") { ShowMessage("Niste uneli podatak!!"); Edit1->SetFocus(); return; }


//Ciklus pocinje tek od treceg clana, pa se posebno ispituje sta ako je n=1 ili je n=2. if(n==1) s=1; else{ if(n==2) s=3; else{ p=2; //Pocetne vrednosti promenljivih pre ulaska u ciklus. s=3; for(i=3;i<=n;i++) {

//Ako je kon=true grana je neparna a u suprotnom je parna. if(kon==true) { p+=3; kon=false; //Prelazimo u parnu granu. }else{ p*=2; kon=true; //Prelazimo u neparnu granu. }

s+=p; } } }

Label6->Caption=IntToStr(s);

Button1->Enabled=false;

127

Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Label6->Caption="????";


Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="GRESKA...";}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!(Key>='0'&&Key<='9') && Key!=8) Key=0;}//---------------------------------------------------------------------------


unos celobrojnog podatka,a potom utvrđuje da li je on član niza ili ne, te ako jeste ispisuje u rešenju koji je to član, a u suprotnom između koja dva člana niza se nalazi.

Prvi član beskonačnog niza ima vrednost 2, dok se ostali članovi dobijaju tako što se vrednost prethodnog člana sabira sa brojem 4.

Program poseduje zaštitu unosa pozitivnog celobrojnog podatka.

Rešenje:

//---------------------------------------------------------------------------#include <vcl.h>#include <string.h>#pragma hdrstop

#include "Dknebude.h"//---------------------------------------------------------------------------

128

#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//----------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float broj,p; int i=0;

if(Edit1->Text=="") return; broj=StrToFloat(Edit1->Text);

p=-2, i=0; //Sa promenljivom p se prolazi kroz beskonacni niz. do{ i++; p+=4; //Zakonitost prelaska sa jednog clana niza na drugi clan. }while(p<broj);

if(p==broj) Label4->Caption="To je "+IntToStr(i)+" clan niza."; else{ if(i>1) Label4->Caption="Izmedju "+IntToStr(i-1)+" i "+IntToStr(i)+" clana niza."; else Label4->Caption="Manji je od prvog clana niza."; }}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 &&Key!='.') Key=0;}//---------------------------------------------------------------------------

Primer 74:Napraviti aplikaciju koja na osnovu unetog broja N sa

intervala 1..9 i pritiskom na dugme CRTAJ iscrtava sliku zvezdica kao na slici.

Program poseduje zaštitu unosa podatka. Polje dozvoljava unos jednocifrenog pozitivnog broja.U slučaju prevelikog unosa pojavljuje se poruka o grešci u

vidu dijalog prozora. U polju za unos dozvoljeno je korišćenja tastera BackSpace.

Slika zvezdica je smeštena u jednu Labelu fonta 14 crne boje fonta. Forma je dijaloška i nemenja se ne samo od strane korisnika programa već se ne menja ni u kodu programa.

129

Rešenje:


#include "slika_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ AnsiString s=""; int i,j,n;

if(Edit1->Text=="") return; n=StrToInt(Edit1->Text);

if(n>9) { ShowMessage("Preveliko je N!!"); Edit1->Text=""; return; }

//Formira se string od zvezdica i praznina. for(i=1;i<=n;i++) { for(j=1;j<=i-1;j++) s+=" "; //Prvo se popunjavaju praznine. for(j=1;j<=n;j++) s+="* "; //Popubjavanje sa zvezdicama. s+="\n"; //Prelazak u novi red. }

Label2->Caption=s; }//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!(Key>='1'&&Key<='9')&&Key!=8) Key=0;}

130

//---------------------------------------------------------------------------


prirodnog broja Broj,a potom klikom na dugme PRETVORI izbacuje cifru koja je podešena da se izbaci izborom iz SpinEdita kao na slici.

Rezultat se prikazuje u obliku Labele crvene boje. Klikom na dugme RESETUJJ program se vraća u stanje pokretanja aplikacije.

Rešenje:


#include "Cifra_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") { Edit1->Color=clRed; Edit1->SetFocus(); return; }

long n,cif,cf,nov,pom;

n=StrToInt(Edit1->Text); cif=CSpinEdit1->Value;

nov=0, pom=1; while(n!=0) { cf=n%10;

131

if(cif!=cf) { nov+=cf*pom; pom*=10; } n/=10; }

Label3->Caption=IntToStr(nov);

Edit1->Enabled=false; CSpinEdit1->Enabled=false; Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Enabled=true; Edit1->Clear(); Label3->Caption="????"; CSpinEdit1->Enabled=true; CSpinEdit1->Value=0; Button1->Enabled=true; Button2->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Click(TObject *Sender){ Edit1->Color=clWhite; }//---------------------------------------------------------------------------

Primer 76:Napraviti aplikaciju koja prilikom formiranja

Forme dinamički formira matricu od 20 Panela.Paneli su oblika kvadrata bele boje, a natpisi

na Panelima su brojevi podebljani fonta 12.Brojevi se prilikom formiranja Panela tako

raspoređuju da na kraju imaju izgled kao na slici. Imamo utisak kao da su sortirani po reovima

naizmenično u rastućem ili opadajućem redosledu.

Rešenje:

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "zad6za3.h"//---------------------------------------------------------------------------

132

#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;int k=0,p;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ int i,j; for(i=0;i<4;i++) { for(j=0;j<5;j++) { TPanel *pn = new TPanel(this); pn->Parent=this;

pn->Color=clWhite; pn->Font->Style=TFontStyles()<<fsBold; pn->Caption=IntToStr(j+1+i*5); pn->Width=50; pn->Height=50; pn->Font->Size=12; pn->Top=30+i*80;

if(i%2==0) pn->Left=30+j*80; else pn->Left=30+(4-j)*80; } } this->Width=430; //Utvrdjuje se sirina forme. this->Height=380; //Utvrdjuje se visina forme.}//---------------------------------------------------------------------------

Primer 77:Naraviti aplikaciju koja na osnovu

unesenog prirodnog broja N izračunava zbir prvih N članova beskonačnog niza kao na slici. Program poseduje zaštitu unosa prirodnog broja.

Rešenje


133

#include "zad10za2.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int n,i; float s=0;

if(Edit1->Text=="") { ShowMessage("Niste uneli podatak!!"); Edit1->SetFocus(); return; } n=StrToInt(Edit1->Text);

for(i=1;i<=n;i++) { if(i==1)s=1; else s+=(((float)i-1.0)*((float)i-1.0))/((float)i * i); }

Label6->Caption=Format("%.3f",ARRAYOFCONST((s))); Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Label6->Caption="????"; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="GRESKA...";}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key)

134

{ if(!(Key>='0'&&Key<='9') && Key!=8) Key=0;}//---------------------------------------------------------------------------

Primer 78: Napraviti aplikaciju koja na osnovu zadatog

racionalnog broja utvrđuje koliko treba sabrati članova sume pa da zbir bude veći od unesenog broja. Zakonitost sume se vidi sa slike. Klikom na dugme RADI dobija se traženi odgovor. Program poseduje zaštitu unosa racionalnog pozitivnog broja.

Rešenje


#include "borka.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float s=0,p,q; int i,n,znak;


znak=1; p=q=0; for(i=1;i<=n;i++) { p+=znak*i; q+=i;

135

s+=p/q; znak=-znak; }

Label4->Caption=Format("%.3f",ARRAYOFCONST((s)));

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Label4->Caption="????"; Edit1->Text="";


Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key)&&Key!=8)Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(ed->Text=="" && Key=='0') Key=0; }}//---------------------------------------------------------------------------

Primer 9:

Napraviti aplikaciju koja na osnovu unesenog podatka o datumu rođenja ispisuje u Labeli većeg fonta crvene boje, dan u nedelji kada ste rođeni.

Program poseduje zaštitu unosa podataka: dana,meseca i godine.

Rešenje

136


#include "Dan_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") { Edit1->Color=clRed; Edit1->SetFocus(); return; } int dan=StrToInt(Edit1->Text);

if(Edit2->Text=="") { Edit2->Color=clRed; Edit2->SetFocus(); return; } int mesec=StrToInt(Edit2->Text);

if(Edit3->Text=="") { Edit3->Color=clRed; Edit3->SetFocus(); return; } int god=StrToInt(Edit3->Text);

if(god<1900) //Godina nema smisla da je pre proslog veka. { Edit1->Color=clRed; Edit1->Clear(); Edit1->SetFocus(); return; }

if(mesec>12) //Mesec mora biti od 1 do 12.

137

{ Edit2->Color=clRed; Edit2->Clear(); Edit2->SetFocus(); return; }

//Neki meseci moraju imati 31 dan.if((mesec==1||mesec==3||mesec==5||mesec==7||mesec==8||mesec==10||mesec==12)&&dan>31) { Edit1->Color=clRed; Edit1->Clear(); Edit1->SetFocus(); return; }

//Neki meseci imaju 30 dana. if((mesec==4||mesec==6||mesec==9||mesec==11)&&dan>30) { Edit1->Color=clRed; Edit1->Clear(); Edit1->SetFocus(); return; }

bool par; //Sa par se utvrdjuje da li godina prestupna ili ne. if(god%4==0 || god%400==0) par=true; else par=false;

//Februar ako je godina prestupna ima 29 dana a u suprotnom 28 dana. if((mesec==2 && par==true && dan>29) || (mesec==2 && par==false && dan>28)) { Edit1->Color=clRed; Edit1->Clear(); Edit1->SetFocus(); return; }

int i; long int k=0; //Sa k sabiramo ukupan broj dana od prve godine do datuma rodjenja..

for(i=1;i<=god-1;i++) { if(i%4==0 || i%400==0) k+=366; else k+=365; }

for(i=1;i<=mesec-1;i++) { switch(i) {

138

case 1: case 3: case 5: case 7: case 8: case 10: case 12: k+=31; break; case 4: case 6: case 9: case 11: k+=30; break; case 2: if(god%4==0 || god%400==0) k+=29; else k+=28; break; } }

k+=dan; //Promenljiva sadrzi ukupan broj dana od prve godine do datuma rodjenja.

k=k%7; //dana u nedelji ima 7, te dovodimo da sada priomenljiva k ima vrednost od 0 do 6. switch(k) { case 6: Label5->Caption="PETAK"; break; case 0: Label5->Caption="SUBOTA"; break; case 1: Label5->Caption="NEDELJA"; break; case 2: Label5->Caption="PONEDELJAK"; break; case 3: Label5->Caption="UTORAK"; break; case 4: Label5->Caption="SREDA"; break; case 5: Label5->Caption="CETVRTAK"; break; }

Button1->Enabled=false; Button2->Enabled=true; GroupBox1->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Label5->Caption="???????"; GroupBox1->Enabled=true; Edit1->Clear(); Edit2->Clear(); Edit3->Clear(); Button1->Enabled=true; Button2->Enabled=false;

Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Click(TObject *Sender){

139

TEdit *ed = dynamic_cast <TEdit *> (Sender); ed->Color=clWhite;}//---------------------------------------------------------------------------

Primer 80:Napraviti aplikaciju koja pretstavlja vođenje kontrole aktivne petorke na košarkaškoj

utakmici. Postoje dve GroupBox komponente. Prva je pod imenom Izbor petorke i sastoji se od 12 Panela u dva reda sa natpisima brojevima sa intervala 4 – 15. Klikom na neki od Panela menja mu se boja iz crvene u zelenu i obrnuto. Zelena boja je znak da je igrač sa rednim brojem koji odgovara rednom broju natpisa Panela u igri. Druga grupa je pod imenom Petorka u igri, a paneli su plave boje sa natpisima koji su brojevi igrača u igri.

Ispod ove dve grupe nalaze se tri Panela: ESC, ENTER i IZMENA. ESC je odustajanje od izmene, tj možda ste izabrali drugu petorku i niste kliknuli Enter već Esc, u tom slučaju pojavljuje se grupa sa petorkom u igri koja je ranije bila. ENTER je potvrda izabrane petorke. Ako nije selektovano tačno pet igrača prijaviće se poruka o greški, a u slučaju da je izabrana petorka pojaviće se petorka sa novim igračima u igri. IZMENA je vidljiva samo ako je grupa sa petorkom u igri, a klikom na taj panel pojaviće se grupa za izmenu sa sačuvanom trenutno aktivnom petorkom u igri.

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "petorka_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Panel9Click(TObject *Sender){ TPanel *pn=dynamic_cast <TPanel *> (Sender);

140

if(pn->Color==clRed) pn->Color=clGreen; //ako je Panel crven postaje zelen i obrnuto. else pn->Color=clMoneyGreen;}//---------------------------------------------------------------------------void __fastcall TForm1::Panel8Click(TObject *Sender){ int br=0;

//Prvo brojimo koliko ima Panela zelene boje. for(int i=0; i<12; i++) { TPanel *pn;

pn=(TPanel *)FindComponent("Panel"+IntToStr(i+9)); if(pn->Color==clGreen) br++; }

if(br==5) //Ako je je br jednako sa 5 imamo pet igraca i sve je u redu. { int k=1; //Sa promenljivom k prolazimo kroz Panele gde treba upisati novu petorku.

for(int i=0;i<12;i++) //Prolayimo kroz grupu od 12 Panela. { TPanel *pn; pn=(TPanel *)FindComponent("Panel"+IntToStr(i+9));

if(pn->Color==clGreen) //Ako je Panel zelene boje. { TPanel *gde; gde=(TPanel *)FindComponent("Panel"+IntToStr(k));

gde->Caption=pn->Caption; //Novi igrac. k++; //Na sledeci Panel. } }

GroupBox1->BringToFront(); //Prikazuje se grupa izabrane petorke.. Panel6->Visible=true; //Postaje vidljiv panel izmene. }else{ if(Panel6->Visible==false) { Application->Title="GRESKA..."; ShowMessage("Niste uneli pet igraca!!"); } }}//---------------------------------------------------------------------------void __fastcall TForm1::Panel7Click(TObject *Sender){ if(Panel6->Visible==true) return;

141

//prolayimo kroy panele od 12 igra;a i poredimo sa panelima iy iyabrane petorke, te ako su //im natpisi isti bojimo panel iy grupe od 12 zelenom bojom, a u suprotnom crvenom //bojom. Paneli iz grupe od pet igraca u igri plave boje sadrze prethodno izabranu petorku u //odnosu na trenutnu od 12 panela zelene boje od koje odustajemo.

for(int i=0;i<12;i++) { TPanel *pn; pn=(TPanel *) FindComponent("Panel"+IntToStr(i+9));

bool kon=false; int j=0; while(j<=5) { TPanel *gde; gde=(TPanel *) FindComponent("Panel"+IntToStr(j));

if(pn->Caption==gde->Caption) { kon=true; break; } j++; }

if(kon) pn->Color=clGreen; else pn->Color=clMoneyGreen; }

GroupBox2->BringToFront(); Panel6->Visible=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Panel6Click(TObject *Sender){ GroupBox2->BringToFront(); Panel6->Visible=false;}//---------------------------------------------------------------------------


unos niza brojeva od n elemenata n<31 i izračunava zbir elemenata niza.

Niz x je niz celih brojeva koji se unose pomoću polja za unos uz kontrolu unosa. Kada se klikne taster Enter broj se upisuje u Memo komponentu pod uslovom da polje unosa nije prazno.

142

Klikom na dugme ODREDI određuje se zbir i upisuje u Labelu za prikaz rezultata zbira. Ako je Memo prazan u Memo upisati da Nema niza!!

Klikom na dugme BRISI vrši se brisanje polja za unos i Memo komponente i ponovo se u Labelu upisuju četiri znaka pitanja.

Rešenje

JEDNODIMENZIONALNI NIZ ILI VEKTOR

Definicija niza

Niz je izvedeni (struktuirani) tip podatka koji predstavlja strukturu (niz podataka) u kojoj su svi objekti istog tipa.

Karakteristike nizovaU programskom jeziku C svi nizovi, bez obzira na tip i veličinu, imaju sledeće zajedničke

karakteristike:

Pojedini članovi niza se nazivaju elementi niza i oni moraju biti istog tipa;

Tip elementa niza je proizvoljne složenosti, tako da čak i izvedeni tipovi podataka predstavljaju legalne tipove za nizove,

Elementima niza se pristupa preko indeksa niza. Vrednost indeksa prvog člana je 0, a ne 1.

Naziv niza jednoznačno indentifikuje niz. On je konstantna vrednost (ne može se menjati operatorima dodele) koja predstavlja memorijsku adresu prvog člana niza

Predstavljanje jednodimenzionalnog niza (vektora) u memorijiNiz se u memoriji implementira kao kontinualni skup susednih memorijskih lokacija . Niz

se u memoriju smešta tehnikom dopunjavanja. Kod ove tehnike za smeštanje jednog elementa niza potrebno je memorijskih reči. Tako se, pri smeštanju jednog elementa, preostali prostor u poslednjoj memorijskoj reči koju element zauzima do početka naredne reči ostavlja neiskorišćenim, pa sledeći element uvek počinje od sledeće memorijske reči. Ovim se postiže efikasan pristup elementima niza, što se pčaća slabijoj iskorišćenju memorijskog prostora.

Deklaracija vektoratip naziv[veličina];

Preko naziv-a niza se pristupa nizu, a veličina mora da bude konstanta ili konstantni izraz.

Na primer:

int x[10];U memoriji se rezerviše prostor (kao na slici).

X A0 A1 A2 A3 A4 A5 A6 A7 A8 A9

143

U nazivu niza x upisana je adresa A0. Kako je veličina niza 10 to je u memoriji odvojeno toliko prostora.

Adresa elementa niza sa indeksom i dobija se po formuli:

Ova tehnika adresiranja dobila je naziv indeksno adresiranje, jer se na osnovu indeksa dolazi do adrese elementa niza.

Pristup elementu vektoraElementima niza se pristupa pomoću indeksa. Indeks elemenata niza predstavlja u stvari

rastojanje između naziva i elementa niza, tako da prvi indeks niza ima vrednost 0 a ne 1 jer se nalazi na nultom rastojanju od naziva niza.

primer:

Neka je niz x deklarisan kao int x[10];

Sa x[3]=4; četvrti član niza dobija vrednost 4. U ovom slučaju broj 3 predstavlja indeks niza. Redni broj člana niza ima vrednost za 1 veću od indeksa niza.

Indeks niza može biti i celobrojna promenljiva ili celobrojni izraz. Indeks niza je promenljiva ili izraz koji se nalazi između zagrada [ ].

Na primer:

int x[10];unsigned i;

i=3, x[i]=5;Ne sme se pisati x[11]=4; jer prilikom deklaracije niza nije rezervisano toliko memorijskog

prostora (prekoračenje opsega). Ovo je fatalna greška.


#include "Zbir_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"#define MAX_NIZ 30

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key)

144

{ //Mogu se unet samo decimalne cifre, znak minus, backspace i Enter. if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{

//Znak minus mo\e biti samo na pocetku broja. if(Key=='-' && Edit1->Text!="") Key=0;

//Posle nule na prvom mestu ne moze se unositi nista. if(Edit1->Text=="0" && Key!=8 && Key!=’\r’) Key=0; if(Key=='0' && Edit1->Text=="-") Key=0;

//Ako smo pritisli Enter kraj je sa unosom broja i on se upisuje u Memo. if(Key=='\r') {

//Nema broja te se nema sta ni upisati u Memo. if(Edit1->Text=="") Key=0; else{

//Niz je ogranicen statickom memorijom vec pri deklaraciji niza //i bila bi fatalna greska ako bi se pokusao uneti broj u niz a //nema prostora za to.

if(Memo1->Lines->Count<MAX_NIZ) Memo1->Lines->Add(Edit1->Text);

else{ //Zabranjujemo unos vise brojeva u polju unosa.

Edit1->Enabled=false; ShowMessage("Prekoracenje memorije niza!!");

//Jedino sto moze je da klikne na dugme ODREDI //te se zato na njega i fokusiramo.

Button2->SetFocus(); return; }

Edit1->Clear(); } } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!"); }else{

//Deklaracija niza int x[MAX_NIZ],i,s,n;

//Prebacujemo brojeve iz Memo komponente u niz. for(i=0;i<Memo1->Lines->Count;i++) x[i]=StrToInt(Memo1->Lines->Strings[i]);

145

//Utvrdjujemo koliko niz ima elemenata. n=Memo1->Lines->Count; Edit1->ReadOnly=true;

//Kroz niz se prolazi sa ciklusom. Ako se prolazi kroz ceo niz koristiti for ciklus, a //ako se prolazi kroz deo niza koristiti while ciklus. s=0; for(i=0;i<n;i++) s+=x[i];

Label4->Caption=IntToStr(s); }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Enabled=true; Memo1->Lines->Clear(); Edit1->ReadOnly=false; Label4->Caption="????"; Edit1->Clear(); Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="GRESKA...";}//---------------------------------------------------------------------------


formiranje niza X od n (n<31) elementa i utvrđuje minimum, broj minimalnih, maksimum i broj maksimalnih elemenata.

Niz se smešta u jedan Memo, a izveštaj o rezultatima u drugi Memo.

Program poseduje i kontrolu unosa celobrojnog podatka.

Rešenje

//------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "minmax_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"#define MAX_NIZ 30TForm1 *Form1;

146

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ if(Key=='-' && Edit1->Text!="") Key=0; if(Edit1->Text=="0" && Key!=8 && Key!=’\r’) Key=0; if(Key=='0' && Edit1->Text=="-") Key=0; if(Key=='\r') { if(Edit1->Text=="") Key=0; else{ if(Memo1->Lines->Count<MAX_NIZ)

Memo1->Lines->Add(Edit1->Text); else{ Edit1->Enabled=false; ShowMessage("Prekoracenje memorije niza!!"); Button2->SetFocus(); return; } Edit1->Clear(); } } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ //Prvo izbrisati podatke od prethodnog startovanja. Memo2->Lines->Clear();

if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!"); }else{ int x[MAX_NIZ],i,n,min,max,brmin,brmax;

for(i=0;i<Memo1->Lines->Count;i++) x[i]=StrToInt(Memo1->Lines->Strings[i]); n=Memo1->Lines->Count;

//Prvo se odredi maksimum i minimum. Postupak odredjivanja minimuma je da se prvi //element niza proglasi da je minimalan, a potom se prolazi kroz ostale elemente niza i //poredi se svaki element sa trenutnom vrednoscu minimuma. Ako je vrednost manja //od trenutnog minimuma, znak ja da je on novi minimum te promenljiva min dobija //njegovu vrednost. Nakon zavrsetka ciklusa promenljiva min ima vrednost minimuma.

147

//Slican postupak je i sa trazenjem maksimuma niza.

min=max=x[0]; for(i=1;i<n;i++) { if(x[i]<min) min=x[i]; if(x[i]>max) max=x[i]; }

//Sada se utvrdi broj minimuma i maksimuma, a to je moguce ako je poznata vrednost //minimuma i maksimuma niza.

brmin=brmax=0; for(i=0;i<n;i++) { if(x[i]==min) brmin++; if(x[i]==max) brmax++; }

//U komponentu Memo2 upisujemo resenja. Memo2->Lines->Clear(); Memo2->Lines->Add("Minimum = "+IntToStr(min)); Memo2->Lines->Add("Broj miinimuma = "+IntToStr(brmin)); Memo2->Lines->Add(""); Memo2->Lines->Add("Maksimum = "+IntToStr(max)); Memo2->Lines->Add("Broj maksimuma = "+IntToStr(brmax)); }}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Enabled=true; Edit1->ReadOnly=false; Memo1->Lines->Clear(); Memo2->Lines->Clear();

Edit1->Clear(); Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender)

148

{ Application->Title="GRESKA...";}//---------------------------------------------------------


formiranje niza X od n (n<31) elementa i prikazuje ga u inverznom poretku u drugoj Memo komponenti.

Niz se smešta u jedan Memo, a inverzni niz u drugi Memo.

Program poseduje i kon trolu unosa celobrojnog podatka.

Rešenje

//--------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "minmax_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ if(Key=='-' && Edit1->Text!="") Key=0; if(Edit1->Text=="0" && Key!=8 && Key!=’\r’) Key=0; if(Key=='0' && Edit1->Text=="-") Key=0; if(Key=='\r') { if(Edit1->Text=="") Key=0; else{

//Komponenta Memo pretstavlja niz a ne neki celobrojni niz //sa ogranicenjem memorije kao u proslim zadacima.

Memo1->Lines->Add(Edit1->Text); Edit1->Clear(); } } }

149

}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!"); }else{ int i,n;

n=Memo1->Lines->Count;

//Same Memo komponente su nizovi. Prolazimo kroz Memo1 od zanje linije prema//prvoj liniji upisujemo tako liniju po liniju u Memo2 komponentu i tako nastaje i

//nverzan n iz. Memo2->Lines->Clear(); for(i=n-1;i>=0;i--) Memo2->Lines->Add(Memo1->Lines->Strings[i]); }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->ReadOnly=false; Memo1->Lines->Clear(); Memo2->Lines->Clear();

Edit1->SetFocus();}//------------------------------------------


omogućava formiranje niza X od n (n<31) elementa, a potom određuje broj pozitivnih, minimum među negativnim, maksimum i zbir svih elemenata niza do prvog maksimuma.

Niz se smešta u jedan Memo, a izveštaj u drugi Memo. Program poseduje i kontrolu unosa celobrojnog podatka.

Rešenje


#include "minmax_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

150

#define MAX_NIZ 30

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ if(Key=='-' && Edit1->Text!="") Key=0; if(Edit1->Text=="0" && Key!=8 && Key!=’\r’) Key=0; if(Key=='0' && Edit1->Text=="-") Key=0; if(Key=='\r') { if(Edit1->Text=="") Key=0; else{ if(Memo1->Lines->Count<MAX_NIZ)

Memo1->Lines->Add(Edit1->Text); else{ Edit1->Enabled=false; ShowMessage("Prekoracenje memorije niza!!"); Button2->SetFocus(); return; }

Edit1->Clear(); } } }}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!"); }else{ int x[MAX_NIZ],i,n,min,max,s,brp; bool kon;


151

//Logicka promenljiva kon bice false sve dok se ne pojavi prvi negativan broj. Ako //negativnih brojeva nema, promenljiva ce imati posle ciklusa i dalje vrednost false.

kon=false; brp=0;

max=x[0]; for(i=0;i<n;i++) { if(x[i]>0) brp++; if(x[i]>max) max=x[i];

if(x[i]<0) {

//Pojavio se negativan broj, Prilikom trazenja minimuma mora se prvi broj //proglasiti da je minimum, a da li je prvi negativan znamo po vrednosti //logicke promenljive kon. Ako promenljiva kon ima vrednost false znak je //da je to prvi negativan broj.

if(kon==false) {

//Logicka prommenljiva kon sada ima vrednost kon jer smo pronasli prvi //negativan broj, a svi ostali i ako su mozda negativni nisu prvi.

kon=true; min=x[i];

}else{ if(x[i]<min) min=x[i]; } } }

//Trazi se prolazak kroz deo niza ili ceo niz, a tada se koristi while ciklus. U uslovu //while ciklusa mora postojati uslov prekida cikl;usa. Prolazimo kroz niz dok ne //dodjemo do kraja niza ili ne nadjemo prvi maksimum.

s=0; i=0; while(i<n && x[i]!=max) s+=x[i],i++;

//Prvo prikazujemo broj pozitivnih jer tu nema nikakvih uslova. Memo2->Lines->Clear(); Memo2->Lines->Add("Broj pozitivnih = "+IntToStr(brp)); Memo2->Lines->Add("");

//Sada nam logicka promenljiva kon sluzi da utvrdimo da li je bilo negativnih brojeva u //nizu ili ne. Ako promenljiva kon ima vrednost true bilo je negativnih brojeva.

if(kon==true) Memo2->Lines->Add("Minimim medju negativnim = "+IntToStr(min)); else Memo2->Lines->Add("Niz nema negativnih brojeva!!"); Memo2->Lines->Add("");

//Sada se prikazuje maksimum i zbir do prvog maksimuma.

152

Memo2->Lines->Add("Maksimum = "+IntToStr(max)); Memo2->Lines->Add("Zbir do prvog maksimuma = "+IntToStr(s)); }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Enabled=true; Edit1->ReadOnly=false; Memo1->Lines->Clear(); Memo2->Lines->Clear();

Edit1->Clear(); Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="GRESKA...";}//---------------------------------------------------------


formiranje niza A od n (n<31) elementa i na osnovu njega formira novi niz B koga pretstavljaju pozitivni elementi niza A.

Niz A se smešta u jedan Memo, a niz B u drugi Memo.

Program poseduje i kontrolu unosa celobrojnog podatka.

Rešenje

//--------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "minmax_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"#define MAX_NIZ 30


153

void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ if(Key=='-' && Edit1->Text!="") Key=0; if(Edit1->Text=="0" && Key!=8 && Key!=’\r’) Key=0; if(Key=='0' && Edit1->Text=="-") Key=0; if(Key=='\r') { if(Edit1->Text=="") Key=0; else{ if(Memo1->Lines->Count<MAX_NIZ)

Memo1->Lines->Add(Edit1->Text); else{ Edit1->Enabled=false;

Application->Title="GRESKA..."; ShowMessage("Prekoracenje memorije niza!!"); Button2->SetFocus(); return; }

Edit1->Clear(); } } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!"); }else{ int a[MAX_NIZ],b[MAX_NIZ],i,n,k;

for(i=0;i<Memo1->Lines->Count;i++) a[i]=StrToInt(Memo1->Lines->Strings[i]); n=Memo1->Lines->Count;

//Kada forirate novi niz koji mozda nece imati isti broj elemenata u odnosu na niz od //koga nastaje, potrebno je novi niz formirati sa jednim indeksom, a kroz stari niz sa //drugim indeksom. Novi niz ce imati nakon formiranja onoliko elemenata kolika je //vrednost indeksa sa kojim si ga formirao.

k=0; for(i=0;i<n;i++) { if(a[i]>0) { b[k]=a[i]; k++; }

154

}

Memo2->Lines->Clear(); if(k==0) Memo2->Lines->Add("Nema niza!!"); else{ for(i=0;i<k;i++) Memo2->Lines->Add(IntToStr(b[i])); } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Enabled=true; Edit1->ReadOnly=false; Memo1->Lines->Clear(); Memo2->Lines->Clear();

Edit1->Clear(); Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 86:Napisati deo C koda koji vrši:

a) cirkularnu rotaciju niza X od n elemenata za jedno mesto u desno,b) cirkularnu rotaciju niza X od n elemenata za jedno mesto u levo,c) izbacivanje iz niza X od n elemenata, sve one elemente koje imaju određenu

vrednost, d) sortira niz X od n elemenata u rastućem redosledu, ie) proširivanje niza X od n elemenata umetanjem elementa kljuc na poziciju k..

Rešenje:

a) pom=x[n-1];i=n-1;while(i>0) x[i]=x[i-1],i--;x[0]=pom;

b) pom=x[0];i=1;while(i<n-1) x[i]=x[i+1],i++;x[n-1]=pom;

c) Sazimanje niza izbacivanjem onih elemenata koji imaju istu vrednost kao promenljiva izbaci.

/*Veliki problemi nastaju ako bi se u ovom primeru koristio for ciklus kao brojacki ciklus za prolazak kroz niz. Kako for ciklus najcesce povecava brojac za 1 to u slucaju da se u nizu jedan do drugog nalazi vise elemenata koji imaju vrednost izbaci, nece svi biti izbaceni iz niza, jer se prilikom zavrsetka iteracije brojac poveca za jedan a nama se nakon pomeranja (sazimanja niza za jedno

155

mesto) sledeci element niza koji ima vrednost izbaci pomerio na mesto gde smo izbacili prethodni element, tada se brojac pomeri za jedan i nama ostane ne izbaceni element. */

i=0;while(i<n){

while(x[i]!=izbaci) i++;if(i<n-1){

/*Pomeranje niza u levo za jedno mesto. */for(k=i+1;k<n;k++) x[k-1]=x[k];x[n-1]=0;n--; /*Obaveyno smanjiti n za jedan jer niz nakon izbacivanja

ima jedan element manje. */} else{

if(i==n-1) x[n-1]=-0,n--; /*U slucaju da je izbaci poslednji element niza. */

}}

d) Sortiranje niza u rastucem redosledu.

for(i=0;i<n-1;i++){

for(j=i+1;j<n;j++){

if(x[j]<x[i]){

pom=x[j];x[i]=x[j];x[j]=pom;

}}

}

e) Prosirivanje niza.

j=n;while(j>k) x[j]=x[j-1],j--;

x[k]=kljuc;n++;

//---------------------------------------------------------------------------

Primer 87:

156

Napraviti aplikaciju koja omogućava unos celobrojnog niza A od N (N<30) elemenata, a potom vrši rotaciju niza A ulevo do prvog maksimalnog elementa niza, kao na slici.

Rešenje:


#include "pravo_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

AnsiString ss;int a[30],n,i;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ int j;

i=0; ss=""; //Inicijalizacija stringa. for(j=0;j<30;j++) a[j]=0; //Inicijalizacija niza. Niz se inicijalizuje pomocu ciklusa.}//---------------------------------------------------------------------------void __fastcall TForm1::Button3Click(TObject *Sender){ if(Edit1->Text=="") return;


if(n>30) { ShowMessage("Pogresno unet N!!"); return; }

//Dugmadi Button3 i Button4 su sakriveni, a kako su po Default-u true, to reaguju na taster //Ender kao da ste na njega kliknuli iako ga na formi ne vidite. Sa svojstvom Enabled //podesavamo da samo jedan od dugmadi bude aktivan kako bi pravi reagovao na taster Enter.

157

Button3->Enabled=false; //Button3 sluzi za potvrdu unosa n. Button4->Enabled=true; //Button4 sluzi za potvrdu unosa elementa niza.

Edit1->Enabled=false; Edit2->Enabled=true; Edit2->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Button4Click(TObject *Sender){ if(Edit2->Text=="") return;

a[i]=StrToInt(Edit2->Text); //Niz se formira sa indeksom i. i++; //Nakon upisa prelazimo na sledecu poziciju za upis.

ss+=Edit2->Text+" "; //Dadajemo brojeve u string ss jer ne mozemo direktno u Labelu. Label4->Caption=ss; //Upisujemo sada string ss u Labelu i tako se vidi trenutno uneseni niz.

Edit2->Clear(); //Izbrisali smo prethodno uneseni podatak Edit2->SetFocus(); //Fokusiramo se na novi unos.

//Ako smo uneli n brojeva mora postati kraj unosa niza. if(i==n) { Button4->Enabled=false; //Elementi niza se ne mogu vise unositi. Button1->Enabled=true; //Fokusiramo se na dume RADI. Edit2->Enabled=false; //Polje unosa je blokirano. }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int i,j,max,imax,pom;

//Prvo se odredjuje maksimum i indeks prvog maksimuma. max=a[0]; imax=0;

for(i=0;i<n;i++) { if(a[i]>max) { max=a[i]; imax=i; } }

//Sada se vrsi rotacija naza u Levo do prvog maksimuma. for(i=0;i<imax;i++) {

158

pom=a[0]; j=0; while(j<n-1) { a[j]=a[j+1]; j++; } a[n-1]=pom; }

ss=""; for(i=0;i<n;i++) { ss+=IntToStr(a[i])+" "; Label6->Caption=ss; //Ispis niza nakon izvrsene rotacije. }

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Button2->Enabled=false; Button3->Enabled=true; Edit1->Enabled=true;

Edit1->Clear(); Edit1->SetFocus(); Label4->Caption=""; Label6->Caption="";

for(i=0;i<n;i++) a[i]=0; //Brisu se elementi prethodnog niza. i=0; //Indeks formiranja niza je na nuli. ss=""; //Inicijalizacija stringa.}//------------------------------------------

Primer 88:Napraviti aplikaciju koja omogučava

unos celobrojnog niza A od N (N<30) elemenata, a potom u Memo komponenti prikazuje izveštaj o ekstremima niza.

Prvi red Memo komponente sadrži tekstove VREDNOST i TIP razdvojenih tabulatorom. Ostale redove čine vrednost elementa niza koji je ekstrem i tip ekstrema. Tip ekstrema može biti: MINIMUM (ako je

159

element niza manji od svog sledbenika i prethodnika) i MAKSIMUM (ako je element niza veći od svog prethodnika i sledbenika).

Postoji poseban unos broja N, a pos eban gde se unose elementi niza. Program poseduje zaštitu unosa celobrojnog podatka sa jednim događajem OnKeyPress, kao i zaštitu da broj N bude prirodan broj i ne veći od 29.

Rešenje:


#include "pravo_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

AnsiString ss;int a[30],n,i;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ int j;

i=0; ss=""; for(j=0;j<30;j++) a[j]=0; Memo1->Lines->Clear(); Memo1->Lines->Add("VREDNOST TIP");}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::Button3Click(TObject *Sender){ if(Edit1->Text=="") return;


if(n>30) { ShowMessage("Pogresno unet N!!"); return; }

160

Button3->Enabled=false; Button4->Enabled=true;

Edit1->Enabled=false; Edit2->Enabled=true; Edit2->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Button4Click(TObject *Sender){ if(Edit2->Text=="") return;

a[i]=StrToInt(Edit2->Text); i++; ss+=Edit2->Text+" "; Label4->Caption=ss; Edit2->Clear(); Edit2->SetFocus();

if(i==n) { Button4->Enabled=false; Button1->Enabled=true; Edit2->Enabled=false; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int i;

for(i=1;i<n-1;i++) { if(a[i]>a[i-1] && a[i]>a[i+1]) Memo1->Lines->Add(" "+

IntToStr(a[i])+" MAKSIMUM"); if(a[i]<a[i-1] && a[i]<a[i+1]) Memo1->Lines->Add(" "+

IntToStr(+a[i])+" MINIMUM"); } Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Button2->Enabled=false; Button3->Enabled=true; Edit1->Enabled=true; Edit1->Clear(); Edit1->SetFocus(); Label4->Caption="";

161

for(i=0;i<n;i++) a[i]=0; i=0; ss=""; Memo1->Lines->Clear();}//---------------------------------------------------------------------------


koja omogućava formiranje niza X od n (n<31) elementa i potom vrši transformaciju niza tako što prvo odredite vrednosti minimuma i maksimuma, sažimate niz izbacivanjem svih minimalnih i maksimalnih, a potom minimalne dodajete na početak niza proširivanjem niza i na kraju dodajete maksimalne na kraj niza.

Niz X se smešta u jedan Memo, a nakon transformacija u drugi Memo. Program poseduje i kontrolu unosa celobrojnog podatka.

Rešenje:



TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{

162

if(Key=='-' && Edit1->Text!="") Key=0; if(Edit1->Text=="0" && Key!=8 && Key!='\r') Key=0; if(Key=='0' && Edit1->Text=="-") Key=0; if(Key=='\r') { if(Edit1->Text=="") Key=0; else{ if(Memo1->Lines->Count<MAX_NIZ)

Memo1->Lines->Add(Edit1->Text); else{ Edit1->Enabled=false; ShowMessage("Prekoracenje memorije niza!!"); Button2->SetFocus(); return; } Edit1->Clear(); } } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!"); }else{ int x[MAX_NIZ],i,j,n,min,max,brmin,brmax;


//Odredjivanje vrednosti minimuma i maksimuma. min=max=x[0]; for(i=1;i<n;i++) { if(x[i]<min) min=x[i]; if(x[i]>max) max=x[i]; }

//Odredjivanje broja minimuma i broja maksimuma. brmin=brmax=0; for(i=0;i<n;i++) { if(x[i]==min) brmin++; if(x[i]==max) brmax++; }

//Sazimanje niza izbacivanjem svih minimuma i maksimuma. i=0; while(i<n) {

163

if(x[i]!=min && x[i]!=max) i++; else{ j=i; while(j<n-1) x[j]=x[j+1],j++; x[n-1]=0; n--; } }

//Prosirivanje niza dodavanjem svih minimuma na pocetak niza. for(i=1;i<=brmin;i++) { j=n; while(j>0) x[j]=x[j-1],j--; x[0]=min; n++; }

//Prosirivanje niza dodavanjem svih maksimuma na kraj niza. for(i=0;i<brmax;i++) x[n+i]=max; n=n+brmax;

//Ispis niza u komponentu Memo. Memo2->Lines->Clear(); for(i=0;i<n;i++) Memo2->Lines->Add(IntToStr(x[i])); }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Enabled=true; Edit1->ReadOnly=false; Memo1->Lines->Clear(); Memo2->Lines->Clear();

Edit1->Clear(); Edit1->SetFocus();}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="GRESKA...";}//---------------------------------------------------------------------------

Primer 90:Napraviti aplikaciju koja omogućava unos visina osoba. Razlika između dečaka i devojčica

je u tome što se visina dečaka unosi kao pozitivan celobrojni podatak, a visina devojčica kao negativan celobrojni podatak. Program poseduje zaštitu unosa celobrojnog podatka, kao i uslov da se visina mora kretati iz intervala: 141 – 250 cm.

164

Visine devojčica upisuje se u prvi memo, a visine dečaka u drugi Memo. Klikom na dugme UTVRDI utvrđuje se prosečna visina dečaka i prosečna visina devojčica i kao posebni podatak upisuju kao poslednji red Memo komponenti.

Rešenje:


#include "Zbir_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ if(Key=='-' && Edit1->Text!="") Key=0; if(Edit1->Text=="0" && Key!=8 && Key!='\r') Key=0; if(Key=='0' && Edit1->Text=="-") Key=0;

if(Key=='\r') { if(Edit1->Text=="" || StrToInt(Edit1->Text)==0) Key=0;

165

else{ int k=StrToInt(Edit1->Text);

//Utvrdjujemo da li je visina u granicama od 141 do 250. if(abs(k)>250 || abs(k)<140) Key=0; else{

//Utvrdjujemo da li je unesena visina decaka ili devojcice //i upisujemo podatak u odgovarajucu Memo //komponentu.

if(k>0)Memo1->Lines->Add(Edit1->Text); else{ int k=StrToInt(Edit1->Text); k=-k; Memo2->Lines->Add(IntToStr(k)); } }

Edit1->Clear(); } } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){

//Onemogucava se unos podataka ako je sracunata srednja visina i vizuelno se bojom //prikazuje da je unos nemoguc.

Edit1->ReadOnly=true; Edit1->Color=clActiveBorder;

//Sracunava se srednja visina decaka. if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema decaka!!"); }else{

int s=0; for(int i=0;i<Memo1->Lines->Count;i++) { s+=StrToInt(Memo1->Lines->Strings[i]); }

float sr=(float)s/Memo1->Lines->Count; Memo1->Lines->Add("********************"); Memo1->Lines->Add("Srednja visina: "+Format("%.1f",ARRAYOFCONST((sr)))); }

//Izracunava se srednja visina devojcica.

166

if(Memo2->Lines->Count==0) { Memo2->Lines->Add("Nema devojcica!!"); }else{ int s=0; for(int i=0;i<Memo2->Lines->Count;i++) { s+=StrToInt(Memo2->Lines->Strings[i]); }

float sr=(float)s/Memo2->Lines->Count; Memo2->Lines->Add("********************"); Memo2->Lines->Add("Srednja visina: "+Format("%.1f",ARRAYOFCONST((sr)))); }

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Memo1->Lines->Clear(); Memo2->Clear(); Edit1->ReadOnly=false; Edit1->Color=clWhite;


Edit1->SetFocus();}//---------------------------------------------------------


unos niza brojeva i smešta ga u komponentu Memo. Potrebno je bez korišćenja pomoćnih niozova osim komponenti Memo1 i Memo2, u komponentu Memo2 upisati samo brojeve iz komponente Memo1 bez ponavljanja. Program poseduje i kontrolu unosa celobrojnog podatka.

Rešenje:


#include "minmax_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)

167

#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ if(Key=='-' && Edit1->Text!="") Key=0; if(Edit1->Text=="0" && Key!=8 && Key!='\r') Key=0; if(Key=='0' && Edit1->Text=="-") Key=0;

if(Key=='\r') { if(Edit1->Text=="") Key=0; else{ Memo1->Lines->Add(Edit1->Text); Edit1->Clear(); } } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Memo2->Lines->Clear();

if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!"); }else{ int i,j;

for(i=0;i<Memo1->Lines->Count;i++) { j=0; while(StrToInt(Memo1->Lines->Strings[j])!=

StrToInt(Memo1->Lines->Strings[i])) j++;

if(i==j) Memo2->Lines->Add(Memo1->Lines->Strings[i]); } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->ReadOnly=false;

168

Memo1->Lines->Clear(); Memo2->Lines->Clear();

Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 92:Napraviti aplikaciju koja se sastoji od niza od 15 Panela bele boje u jednom redu.

Paneli su sa natpisima koji pretstavljaju brojeve dobijene na slučajan način. Ispod Panela nalaze se dve Labele, sa tekstovima i i j.

Program pravi simulaciju ortiranja niza u rastućem redosledu. Panel gde se nalazi indeks i je crvene boje, a panel gde se nalazi indeks j je plave boje.

Jedna iteracija prilikom sortiranja ekvivalentna je jednom pritisnutom tasteru Enter.

Rešenje


#include "stviri_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;TPanel *np[15]; //Niz Panela.TLabel *lb[2]; //Niz Labela.int i,j,n; //Indeksi sortiranja ’i’ i ’j’ a ’n’ je broj Panela koji se sortira.//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ n=15; //Inicijalizujemo broj Panela. randomize();

169

//Formiramo red od 15 Panela sa natpisima koji su slucajni brojevi. for(int i=0;i<n;i++) { TPanel *pn=new TPanel(this); pn->Parent=this;

pn->Width=30; pn->Height=30;

//Posto su svi Paneli u jednom redu sa jednim indeksom odredjujemo raspored Panela u //redu.

pn->Left=20+i*(pn->Width+10); pn->Top=20;

pn->Font->Size=14; pn->Font->Style=TFontStyles()<<fsBold<<fsItalic; pn->Color=clWhite;

int br=random(100); //Generisemo slucajan broj.

pn->Caption=IntToStr(br); //Upisujemo broj u natpis Panela. np[i]=pn; //Pokazivac na formirani Panel upisujemo u niz radi kasnijeg koriscenja }

i=0; //Pocetni indeksi sortiranja niza su i=0 i j=i +1, tj j=0. j=1;

np[0]->Color=clRed; //Boja Panela na koji se odnosi indeks i je crvena, a indeks j je plava. np[1]->Color=clBlue;

TLabel *pnp=new TLabel(this); //Formiramo Labelu za indeks i. pnp->Parent=this; lb[0]=pnp;

TLabel *pnpp=new TLabel(this); //Formiramo Labelu za indeks j. pnpp->Parent=this; lb[1]=pnpp;

lb[0]->Caption="I"; lb[0]->Font->Color=clRed; lb[0]->Left=30; lb[0]->Top=65; lb[0]->Font->Size=12; lb[0]->Font->Style=TFontStyles()<<fsBold;

lb[1]->Caption="J"; lb[1]->Font->Color=clBlue; lb[1]->Left=70; lb[1]->Top=65; lb[1]->Font->Size=12;

170

lb[1]->Font->Style=TFontStyles()<<fsBold;}//---------------------------------------------------------------------------void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key){

//Iteracija sortiranja niza se odvija pritiskom na taster Enter, te iz tog razloga koristimo //dogadjaj OnKeyPress.

if(Key!='\r') Key=0; else{

//Proveravamo uslov prilikom sortiranja brojeva u rastucem redosledu. if(StrToInt(np[j]->Caption)<StrToInt(np[i]->Caption)) { AnsiString pom;

//Vrsimo zamenu natpisa na Panelima. pom=np[i]->Caption; np[i]->Caption=np[j]->Caption; np[j]->Caption=pom; }

if(i==n-2) return; //Uslova kada je sortiranje zavrseno.

//Prilikom sortiranja niza indeks i je indeks spoljasnje petlje, dok je indeks j indeks //unutrasnje petlje. To znaci da indeks i stoji dok se indeks j menja. Indeks i se //menja tek kada indeks j dodje do kraja niza.

if(j==n-1) {

//Indeks j je stigao do kraja niza. np[n-1]->Color=clWhite; //Gde je bio postaje ponovo bele boje.

//Kada j dodje do kraja niza znak je da je unutrasnji ciklus zavrsen i prelazi se //na spoljasnji ciklus gde se indeks i povecava za jedan, a potom se ponovo //ulazi u unutrasnji ciklus gde indeks j postaje i+1.

i++; j=i+1; np[j]->Color=clBlue; //Panel gde se sada indeks j nalazi postaje plav. np[i-1]->Color=clWhite; //Prethodni Panel gde je i bio postaje beo. np[i]->Color=clRed; //Panel gde se sada indeks i nalazi postaje crven. }else{ j++; //Unutrasnji je ciklus te se samo j pomera. np[j]->Color=clBlue; //Panel gde se indeks j sada nalazi postaje plav. np[j-1]->Color=clWhite; //Panel gde je indeks j bio postaje beo. }

lb[0]->Left=30+i*40; //Pomeramo Labele koje prikazuju indekse i i j.

171

lb[1]->Left=30+j*40; }} //--------------------------------------------------------------------

Primer 93:Napraviti aplikaciju koja kada se pokrene dinamički

formira niz Panela, istih dimenzija, žute boje, crne boje fonta natpisa, font je boldovan i veličine 12.

Na formi se nalaze i dve RadioGroup komponente kojom se može birati boja fonta natpisa Panela i boja Panela. Paneli su raspoređeni po redovima i to u pet redova po pet Panela. Natpisi na Panelima su brojevi od 1..25 raspoređeni svi sa leva na desno.

Boja fonta natpisa Panela može biti: crna, crvena, plava i zelena. Boja pozadine može biti: žuta, siva i bela.

Rešenje


#include "Paneli_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

TPanel *niz[25];//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ int i,j;

for(i=0;i<5;i++) { for(j=0;j<5;j++) { TPanel *pn=new TPanel(this); pn->Parent=this;

pn->Color=clYellow; pn->Width=30;

172

pn->Height=30; pn->Font->Color=clBlack; pn->Caption=IntToStr(5*i+j+1);

pn->Left=RadioGroup1->Left+j*(pn->Width+20); pn->Top=150+i*(pn->Height+20); pn->Font->Style=TFontStyles()<<fsBold;

niz[5*i+j]=pn; } }}//---------------------------------------------------------------------------void __fastcall TForm1::RadioGroup1Click(TObject *Sender){ switch(RadioGroup1->ItemIndex) { case 0: niz[0]->Font->Color=clBlack; break; case 1: niz[0]->Font->Color=clRed; break; case 2: niz[0]->Font->Color=clBlue; break; case 3: niz[0]->Font->Color=clGreen; break; }

int i; for(i=1;i<25;i++) niz[i]->Font->Color=niz[0]->Font->Color;}//---------------------------------------------------------------------------void __fastcall TForm1::RadioGroup2Click(TObject *Sender){ switch(RadioGroup2->ItemIndex) { case 0: niz[0]->Color=clYellow; break; case 1: niz[0]->Color=clGray; break; case 2: niz[0]->Color=clWhite; break; }

int i; for(i=1;i<25;i++) niz[i]->Color=niz[0]->Color;}//----------------------------------------------------

Primer 94:

173

Napraviti aplikaciju koja omogućava unos prirodnog broja N, a unos je prihvaćen kada je pritisnut taster Enter, a potom u Memo komponenti prikazuje broj pojavljivanja odabranih cifara.

Nakon unosa broja polja za unos više nije aktivno a aktivna je komponenta GroupBox sa komponentama CheckBox. Ako je čekiran CheckBox ta cifra se pojavljuje u Memo izveštaju a u suprotnom ne.

U Memo izveštaju cifre i ako se dodaju za posmatranje uvek je uređen po rastućem redosledu u odnosu na cifre koje se posmatraju.

Klikom na dugme PONISTI nestaje izveštaj i aplikacija se vraća u početno stanje.

Rešenje

#include <vcl.h>#pragma hdrstop#include "Unit1.h"#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

int x[10];TCheckBox *niz[10];//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ int i;

Edit1->Clear(); Memo1->Enabled=false; GroupBox1->Enabled=false;

for(i=0;i<10;i++) { TCheckBox *bx=new TCheckBox(this); bx->Parent=GroupBox1; //Svi CheckBox-ovi pripadaju grupi GroupBox1 niz[i]=bx;

bx->Checked=false; bx->OnClick=Klik; //Svaki CheckBox reaguje na dogadjaj OnClick pod imenom

//Klik. bx->Height=15; bx->Width=150; bx->Left=10; bx->Top=20+i*(10+bx->Height);

switch(i) { case 0: bx->Caption="Pojava broja 0";

174

break; case 1: bx->Caption="Pojava broja 1"; break; case 2: bx->Caption="Pojava broja 2"; break; case 3: bx->Caption="Pojava broja 3"; break; case 4: bx->Caption="Pojava broja 4"; break; case 5: bx->Caption="Pojava broja 5"; break; case 6: bx->Caption="Pojava broja 6"; break; case 7: bx->Caption="Pojava broja 7"; break; case 8: bx->Caption="Pojava broja 8"; break; case 9: bx->Caption="Pojava broja 9"; break; } }}//---------------------------------------------------------------------------void __fastcall TForm1::Klik(TObject *Sender){ int i;

//Brisemo prethodni izvestaj iz komponente Memo. Memo1->Lines->Clear();

//Prolazimo kroz sve CheckBox-ove i utvrdjujemo ko je kliknut. Moramo to raditi da //bi prikaz pojave cifara bio po redu.

for(i=0;i<10;i++) { if(niz[i]->Checked==true) {

//Resenje se svodi u tome da vrednost indeksa niza X predtstavlja `//odgovarajucu cifru. Znaci indeks i je cifra a z[i] je broj pojave te cifre.

Memo1->Lines->Add("Broj "+IntToStr(i)+" pojavio se "+IntToStr(x[i])+" puta.");

} }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); for(int i=0;i<10;i++) niz[i]->Checked=false; //Nista nije cekirano.

175

GroupBox1->Enabled=false; Memo1->Lines->Clear(); Memo1->Enabled=false;


Edit1->Enabled=true; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int i,pom;

if(Edit1->Text=="") { ShowMessage("Niste uneli broj!!"); return; }

//Promenl;jiva pom je vrednost unesenog broja. Izdvajamo cifru po cifru. pom=StrToInt(Edit1->Text); while(pom!=0) { x[pom%10]++; //pom%10 je cifra, a x[pom%10] je broj pojave te cifre. pom/=10; }

Edit1->Enabled=false; Button1->Enabled=false; Button2->Enabled=true;

Memo1->Enabled=true; GroupBox1->Enabled=true;}//---------------------------------------------------------------------------


omogućava premeštanje Labele. Labela je plave boje pozadine i nema nikakav tekst.

. Premeštanjem Labele, Labela ostaje plave boje. Pritiskom na desni taster miša onemogućava se dalje premeštanje Labele, a pri vrhu forme pojavljuje se centrirani tekst u odnosu na širinu forme sa sadržajem LABEL SE VISE NEMOZE POMERATI

Prilikom realizacije programa koristiti događaje OnDragDrop i OnDragOwer.

176

Rešenje

Odvlačenje Drag&Drop dešava se kada se miš dovede iznad određene komponente I pritisne se levi taster miša. Dok je taster miša pritisnut pokazivač miša se pomeri na drugo mesto, često iynad neke komponente. Koponenta iznad koje je započeto odvlačenje naziva se izvorište, a komponenta iznad koje se završava odvlačenje naziva se odredište.

Svojtvo DragMode predstavlja način odvlačenja. Vrednosti su dmAutomatic (komponenta je stalno spremna za odvlačenje) i dmManual (komponenta nijec stalno spremna za odvlačenje već se mora prvo pripremiti podešavanjem).

Događaj OnDragOver dešava se u toku odvlačenja. Sender je komponenta iznad koje se nalazi pokazivač miša. Source je komponenta koja se odvlači. X i Y su koordinate miša iznad tekuće komonente. Aceppt određuje da operacija sme da se završi iznad tekuće komponente ako je njena vrednost true.Ako se iznad komponente desilo odvlačenje a Accept ima vrednost true desiće se događaj OnDragDrop.

Događaj OndragDrop dešava se komponenti iznad koje je odvlačenje neke druge komponente završeno. Sender je komponenta iznad koje se nalazi pokazivač miša. Source je komponenta koja se odvlači. X i Y su koordinate miša iznad odredišne komponente.


#include "Vuci_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

bool kon=true;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::FormDragOver(TObject *Sender, TObject *Source, int X, int Y, TDragState State, bool &Accept){ Accept = Source->ClassNameIs("TLabel");}//---------------------------------------------------------------------------void __fastcall TForm1::FormDragDrop(TObject *Sender, TObject *Source, int X, int Y){ int k,m;

//Promenljive k i m pretstavljaju koordinate granica premestanja Labele. k=Form1->Width-Label1->Width;

177

m=Form1->Height-2*Label1->Height;

//Ako se proba preci van granica postavljamo ispravan polozaj Labele. if((X>k)||(Y>m)||(X<0)||(Y<0)) { if(X<0) X=0; if(Y<0) Y=0; if(X>k) X=k; if(Y>m) Y=m; }

//Labela se moze pustiti bilo gde na formu. TForm *DestList = (TForm *)Sender; DestList->Font = ((TLabel *)Source)->Font;

//Labela koja se premesta dobija svoje koordinate. ((TLabel *)Source)->Left=X; ((TLabel *)Source)->Top=Y;}//---------------------------------------------------------------------------void __fastcall TForm1::Label1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y){ switch(Button) {

case mbLeft: if(kon==true) Label1->DragMode=dmAutomatic; //Moze se premestati ako ranije nije kliknut desi taster misa jer ce tada

//logicka promenljiva kon imati vrednost false. break;

case mbRight: Label1->DragMode=dmManual; //Ne moze se premestati. kon=false; Label2->Visible=true; Label2->Caption="LABEL SE VISE NEMOZE POMERATI"; Label2->Left=(this->Width-Label2->Width)/2; break; }}//---------------------------------------------------------------------------void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key){

//Aplikacija se zatvara i ako se pritisne taster Esc.if(Key==27) Application->Terminate();

}//---------------------------------------------------------------------------


formira dva reda Panela sa brojevima

178

kao natpisi od 1 do 5. Moguće je izvršiti premeštanje Panela tako što Panel premeštamo na Panel koji ima isti natpis.

Mogu se premeštati samo Paneli iz donjeg reda. Kada naiđe nad Panelom koji ima isti natpis moguće je završiti sa prevlačenjem i tada Panel iz gornjeg reda postaje crvene boje.

Rešenje


#include "formiranje_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ for(int i=0;i<5;i++) { TPanel *pn=new TPanel(this); pn->Parent=this;

pn->Height=50; pn->Width=50;

pn->Top=20; pn->Left=20+i*60; pn->Caption=IntToStr(i+1); pn->Tag=i; pn->Font->Size=12; pn->Color=clWindow;

pn->DragMode=dmManual; pn->OnDragDrop=DragDrop; pn->OnDragOver=DragOver; }

for(int i=0;i<5;i++) { TPanel *pn=new TPanel(this); pn->Parent=this;

pn->Height=50; pn->Width=50;

179

pn->Top=100; pn->Left=20+i*60;

pn->Caption=IntToStr(i+1); pn->Tag=i; pn->Font->Size=12; pn->DragMode=dmAutomatic; pn->OnDragDrop=DragDrop; pn->OnDragOver=DragOver; }}//---------------------------------------------------------------------------void __fastcall TForm1::DragDrop(TObject *Sender, TObject *Source, int X,int Y){ TPanel *pn1=dynamic_cast <TPanel *> (Sender); TPanel *pn2=dynamic_cast <TPanel *> (Source);

if((pn1->Caption)==(pn2->Caption)) { pn2->Visible=false; pn1->Color=clRed; }}//---------------------------------------------------------------------------void __fastcall TForm1::DragOver(TObject *Sender, TObject *Source, int X, int Y, TDragState State, bool &Accept){ TPanel *pn=dynamic_cast <TPanel *> (Source);

if(pn) Accept=true; else Accept=false;}//---------------------------------------------------------------------------


prilikom startovanja ima izgled kao slika sa leve strane, kao da je stao jedan Panel kvadratnog oblika sa slike sa desne strane.

U zaglavlju forme nema teksta. Aplikacija reaguje samo na taster decimalne cifre 1 – 9. Pritiskom na neki od tih tastera forma se širi i omogućava formiranje matrice Panela nnn pravilnog rasporeda, gde n pretstavlja broj Panela po redu i ujedno broj redova, a vrednost mu je jednaka vrednosti pritisnutog tastera. Natpisi na Panelima su slučajni brojevi.

180

Rešenje


#include "PANEL_O.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key){ if(Key>'9' || Key<'1') Key=0; //Mora biti pritisnut taster sa intervala 1 -9 else{

int n=Key-48; //ASSCII kod broja 0 je 48, tj redni broj karaktera '0' je 48.

//Prilikom projektovanja ili dinamičkog formiranja komponente, programsko //okruyrnje Borland C++ Builder automatski adrese komponenti upisuje u svoj niz //pokazivaca na komponente Components, koji ima ComponentCount elemenata. //Takodje prilikom brisanja komponente sa metodom Free(), brise se element iz //niza Components automatski i automatski se menja vrednost svojstva //ComponentCount. Ako nema brisanja komponenti vec samo formiranja moglo bi //doci do blokiranja programa zbog zauzetosti memorije. Iz tog razloga u ovom //primeru prvo se vrsi brisanje svih komponenti sa forme koriscenjem while //ciklusa.

while(ComponentCount!=0) { Components[0]->Free(); //Metodom Free brise se komponenta. }

//Formiramo matricu Panela. for(int i=0;i<n;i++) { for(int j=0;j<n;j++) { TPanel *pn = new TPanel(Sender); pn->Parent=this;

pn->Width=30; pn->Height=30;

pn->Caption=IntToStr(random(100));

181

pn->Color=clWhite; pn->Font->Size=14; pn->Font->Style=TFontStyles()<<fsBold; pn->Left=10+j*(pn->Width+10); pn->Top=10+i*(pn->Height+10); } }

//Menjamo velicinu forme sobzirom na broj komponenti na njoj. this->Width=(n+1)*40-25; this->Height=(n+1)*40; }}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ randomize();

this->Height=80; //Minimalna visina forme. this->Width=55; //Minimalna sirina forme.}//-------------------------------------------------

Primer 98:Napraviti aplikaciju koja se sastoji

od jedne komponente ListBox i više Memo komponenti. Kroz LisBox se krećemo strelicama ili klikom na naku od stavki. Prilikom kretanja samo jedna stavka je aktivna. Stavke ListBoxa su tipovi podataka u C++ jeziku. U odgovarajućoj Memo komponenti prikazane su osobine izabranog tipa podatka.

Rešenje

Komponenta ListBox (okvir sa listom) sadrži listu iz koje korisnik može da izabere jednu ili više stavki. Okvir sa listom je komponenta tipa TlistBox i nalazi se na kartici Standard, na paleti komponenti.

Svojstva:

Items – Predstavljaju listu stavki koje se nalaze u okviru sa listom. Tipa je TStrings.

Sorted – Svojstvo je tipa bool sa vrednošću true ako je lista svakog trenutka uređena po abecednom redosledu. Podrazumevana vrednost false označava da lista nije uređena po abecednom redosledu i da se sve stavke prikazuju u redosledu kako su dodavane u listu.

Columns – Određuje broj kolona za prikazivanje stavki. Tipa je int. Podrazumevana vrednost 0 označava jednu kolonu sa vertikalnim klizačem po potrebi.

182

MultiSelect – Svojstvo je tipa bool sa vrednošću true ako se iz liste može odabrati više od jedne stavke. Podrazumevana vrednost false određuje mogućnost odabiranja samo jedne stavke.

ExtendedSelect – Određuje režim višestrukog odabiranja kada je vrednost svojstva MultiSelect jednaka true. Podrazumevana vrednost ovog svojstva je true i omogućava biranje više uzastopnih stavki jednim potezom. Vrednost false označava da sve stavke mogu da se biraju samo jedan po jedan.

ItemIndex – Ovo svojstvo predstavlja indeks izabrane stavke. Tipa je int.AutoComplete – Ako ovo svojstvo ima vrednost true znak je da korisnik može izabrati

stavku unošenjem početnog znaka teksta stavke preko tastature. Biće odabrana prva stavko koja počinje tim znakom. Vrednost false označava da se stavka ne može biati unošenjem početnog slova sa tastature.

SelCount – Tipa je int i predstavlja broj odabranih stavki u listi.Selected – Predstavlja niz sa elementima tipa bool. Vrednost true označava da je

odgovarajuća stavka u listi odabrana, a vrednost false da nije.


#include "Prikaz_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ ListBox1->ItemIndex=0; //Selektovana prva opcija.

//Postoji pet Memo komponenti iste velicine. Sa metodom BringToFront() //komponenta se premesta na vrh. Prilikom starovanja aplikacije na vrhu mora biti //komponenta Memo1.

Memo1->BringToFront(); }//---------------------------------------------------------------------------void __fastcall TForm1::ListBox1Click(TObject *Sender){

//Stavku iListBox komponente biramo pomocu svojstva ItemIndeks, a pomocu //metode BringToFront() povezujemo sa odgovarajucom Memo komponentom koja //sadrzi opis izabrane stavke.

183

switch(ListBox1->ItemIndex) { case 0: Memo1->BringToFront(); break; case 1: Memo2->BringToFront(); break; case 2: Memo3->BringToFront(); break; case 3: Memo4->BringToFront(); break; case 4: Memo5->BringToFront(); break; }}//---------------------------------------------------------------------------

Primer 99:Našraviti aplikaciju koja omogućava

učitavanje liste od 12 igrača iz tekstualne datoteke i njeno smeštanje u ListBox komponentu prilikom startovanja programa iz

tekstualne datoteke SPISAK.TXT. Automatski je izvršeno i sortiranje po abecednom redosledu. Prva stavka ListBox komponente je aktivna. Sa njene desne strane nalazi se druga ListBox komponenta gde nema imena igrača. Između ove dve komponente nalaye se dva dugmeta. Dugme sa natpisom >> premešta selektovanog igrača sa levog na desni ListBox, pri čemu desni ListBox može imati najviše pet imena. Drugo dugme sa natpisom << premešta imena igrača sa desnog na levi ListBox.

Rešenje


#include "Levodesno_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender)

184

{ ListBox1->Items->LoadFromFile("Spisak.txt"); //Ucitava se datoteka u ListBox ListBox1->ItemIndex=0;}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int poz; if(ListBox2->Items->Count<5) {

//Premestamo stavku iz prvog ListBox-a u drugi. poz=ListBox1->ItemIndex; ListBox2->Items->Add(ListBox1->Items->Strings[poz]); ListBox1->Items->Delete(poz); ListBox1->ItemIndex=poz; }else ShowMessage("Ne moze vise od 5 igraca!!");}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ int poz; if(ListBox2->Items->Count>0) {

//Premestamo stavku iz drugog ListBox-a u prvi. poz=ListBox2->ItemIndex; ListBox1->Items->Add(ListBox2->Items->Strings[poz]); ListBox2->Items->Delete(poz); }else ShowMessage("Nema se sta prebaciti!!");}//---------------------------------------------------------------------------


koja pomoću ComboBox komponente menja veličinu fonta Labele.Stavke ComboBox-sa su: 8, 9, 10, 11, 12, 14, 16, 18, 20, 22,24, 26, 28, 36, 48 I 72.

Prilikom starovanja aplikacije tekst u ComboBox-u je 12, a I veličina fonta Labele je 12. Klikom na jezičak komponente ComboBox pojavljuje se spisak opcija a označena je samo jedna opcija sa brojem 12.

Program poseduje kontrolu unosa prirodnog broja. Izborom neke opcije veličina fonta Labele se automatski menja.

185

Rešenje

Komponenta ComboBox je kombinovani okvir za tekst sa listom. Omogućava unošenje jednog reda teksta sa tastature (kao kod komponente Edit), ili izbor jedne od stavki sa liste, kao kod okvira sa listom.

Kada je kombinovani okvir za tekst sa listom u žiži, u prikazani okvir za tekst može da se unese proizvoljan tekst. Pritiskom na dugme sa strelicom nadole, otvara se padajuća lista iz koje može da se odabere jedna stavka.

Kombinovani okvir za tekst sa listom je tipa TcomboBox nalazi se na kartici Standard na paleti komponenti.

Svojstva:

Text – Tipa je String i predstavlja kao i kod edita sadržaj okvira za tekst.Items – Tipa je TStrings I sadrži listu stavki od kojih može da se odabere jedna. Odabrana

stavka će se pojaviti kao novi sadržaj svojstva Text. ItemIndex – Predstavlja indeks odabrane stavke. Tipa je int. Podrazumevana vrednost -1

označava da nijedna stavka nije odabrana.Sorted – Svojstvo je tipa bool sa podrazumevanom vrednošću false što označava da lista

nije uređena po abecednom redosledu. DropDownCount – Svojstvo je tipa int i određuje najveći broj stavki kiji se prikazuje u

padajućoj listi. Ako je broj stavki u celoj listi veći, korisnik će morati prelistavati deo po deo liste. U tom slučaju mora postojati i uspravni klizač. Podrazumevana vrednost ovog svojstva je 8.

AutoDropDown – Svojstvo je tipa bool sa podrazumevanom vrednošću false što označava da se lista otvara kada korisnik pritisne strelicu nadole na desnom kraju komponente ili kombinacijom tastera alt+strelica nadole. Vrednost true označava da se lista automatski otvara čim korisnik počne sa unosom teksta.


#include "Opcija_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::ComboBox1Click(TObject *Sender){ int poz=ComboBox1->ItemIndex;

186

Label2->Font->Size=StrToInt(ComboBox1->Items->Strings[poz]);}//---------------------------------------------------------------------------void __fastcall TForm1::ComboBox1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8) Key=0; else{ if(Key=='0' && ComboBox1->Text=="") Key=0; }}//---------------------------------------------------------------------------

Primer 101:Napraviti aplikaciju koja omogućava prikaz izabrane stavke ComboBox-a, kao na

slici.

Rešenje//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "Stavke_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::ComboBox1Click(TObject *Sender){ Label2->Caption=ComboBox1->Items->Strings[ComboBox1->ItemIndex];

187

}//---------------------------------------------------------------------------


formiranje niza koji se smešta u Memo komponentu. Aplikacija pomoću ComboBox komponente omogućava izbor jedne od tri akcije: rotiranje niza u desno, rotiranje niza u levo i povratak na početno stanje uz ponovni unos niza.

Rešenje


#include "Niz_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

int n,br,brt,a[30];bool kon;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ int i; br=0; for(i=0;i<30;i++) a[i]=0;}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key)&&Key!=8)Key=0; else{ if(Edit1->Text==""&&Key=='0') Key=0; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){

188

if(Edit1->Text=="") return;



Edit1->ReadOnly=true; Edit2->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit2KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='.') Key=0,br--;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ if(Edit2->Text=="") return;

Memo1->Lines->Add(Edit2->Text); Edit2->Text="";

if(Memo1->Lines->Count==n) { Button2->Enabled=false; Edit2->Enabled=false; ComboBox1->Enabled=true; }}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::ComboBox1Click(TObject *Sender){ int i; AnsiString p;

switch(ComboBox1->ItemIndex) { case 0: p = Memo1->Lines->Strings[n-1]; for(i=n-1;i>0;i--) Memo1->Lines->Move(i-1, i); break; case 1: p = Memo1->Lines->Strings[0]; for(i=0;i<n;i++) Memo1->Lines->Move(i, i+1); Memo1->Lines->Add(p); break; case 2: Memo1->Lines->Clear(); Edit1->Enabled=true; Edit2->Enabled=true;

189

Button1->Enabled=true; ComboBox1->Enabled=true; Edit1->ReadOnly=false; Edit1->SetFocus(); Edit1->Text=""; }}//---------------------------------------------------------------------------

Primer 103:Napraviti aplikaciju koja omogućava prikaz vremena štoperice u obliku hh:mm:ss. Vreme

počinje od oblika 00:00 i menja se sa pokretanjem aplikacije.

Rešenje

Timer je nevizuelna komponenta pomoću koje može da se meri vreme. Timer periodično izvršava događaj OnTimer nakon svakog isteka vremenskog intervala Interval. Komponenta Timer je tipa TTimer i nalazi se na paleti komponenti kartica System.

Svojstva:

Enabled – Određuje da li vreme radi. Tipa je bool sa podrazumevanom vrednošću true. Ako je Timer uključen periodično će se generisati događaj OnTimer. Nakon završetka obrade događaja izvršavaju se naredbe gde je timerom izvršen prekid. Ako je vrednost Enabled u projektovanju true, nakon intervala Interval generisaće se događaj OnTimer.

Interval – Određuje koliko često će se generisati događaj OnTimer izraženo u ms (milisekundama).


#include "vreme_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

int k=0;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){

190

}//---------------------------------------------------------------------------void __fastcall TForm1::Timer1Timer(TObject *Sender){ int min,sec;

k++; min=k/60; //Koliko je minuta proteklo sec=k%60; //Koliko je sekundi proteklo

//Prilikom ispisa bitno je da li je potrebno ispred pisati cifru nula ili ne, jer je po logici //zadatka potrebno minute i sekunde zapisati kao dvocifren broj. Dopisivaće se nula ako je //podatak jednocifreni, tj vrednost mu je manja od 10.

if(min<10&&sec<10) Label1->Caption=Format("0%d:0%d",ARRAYOFCONST((min,sec)));

if(min<10&&sec>=10) Label1->Caption=Format("0%d:%d",ARRAYOFCONST((min,sec)));

if(min>010&&sec<10) Label1->Caption=Format("%d:0%d",ARRAYOFCONST((min,sec)));

if(min>=10&&sec>=10) Label1->Caption=Format("%d:%d",ARRAYOFCONST((min,sec)));

}//---------------------------------------------------------------------------

Primer 104:Napraviti aplikaciju, kao na slici,

koja se sastoji od tri Panela koji obrazuju sto.Na Panelu koji pretstavlja ploču stola nalazi se kvadrat sa brojem 60 kao natpisom. Širina pčoče stola je deljiva sa širinom Panela.

Pri startovanju aplikacija Panel se kreće sa levog kraja stola prema desnom. Prilikom pomeranja vrednost broja natpisa Panela se umanjuje za jedan. Kada kvadrat stigne u desni ugao Panela vrednost natpisa Panela je broj 00.

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>

191

#pragma hdrstop

#include "kreci_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Timer1Timer(TObject *Sender){ int br;

br=StrToInt(Panel4->Caption); br--; //Posle svake sekunde Panel se pomera a vrednost broja se smanjuje za jedan.

//Ako je broj jednocifren ispred se dodaje nula. if(br>9) Panel4->Caption=IntToStr(br); else Panel4->Caption="0"+IntToStr(br);

//Pomeranje se vrsi u levo tako što se svojstvo Left Panela povecava za broj pet. Panel4->Left+=5;

//Kada broj postane nula prestaje se sa kretanjem tako što se isključi Timer, jer se pomeranje //desava u dogadjaju Timera.

if(br==0)Timer1->Enabled=false;}//---------------------------------------------------------------------------


događajem OnCreate forme formiranje niza Panela u četiri reda po pet Panela. Paneli su iste veličine bele boje, fonta 12, boldovanog i sadrži za natpise brojeve 1..20.

U neparnim redovima brojevi se povećavaju i upisuju u Panele sa leva na desno, a u parnim brojevi se povećavaju i upisuju u Panele sa desna na levo.

U zaglavlju forme postoji vreme u sekundama formata ispisa VREME: 00.

Nakon pokretanja aplikacije vreme stoji sve dok se ne pritisne taster Enter. Tada kreće vreme. Prve sekunde Panel se boji u plavo, druge sekunde u crveno, a treće sekunde nestaje, prelazi se na sledeći Panel koji ima broj za natpis za jedan veći od natpisa broja prethodnog Panela koji je nestao.

Rešenje

192


#include "zad6za3.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

int k=0,p;TPanel *niz[20];//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ int i,j;

//Formiramo i rasporedjujemo matricu Panela for(i=0;i<4;i++) { for(j=0;j<5;j++) { niz[i*5+j]= new TPanel(this); niz[i*5+j]->Parent=this;

niz[i*5+j]->Color=clWhite; niz[i*5+j]->Font->Style=TFontStyles()<<fsBold; niz[i*5+j]->Caption=IntToStr(j+1+i*5); niz[i*5+j]->Width=50; niz[i*5+j]->Height=50; niz[i*5+j]->Font->Size=12; niz[i*5+j]->Top=30+i*(niz[i*5+j]->Height + 30);

//U zavisnosti od reda, da li je paran ili neparan zavisi smer stvaranja Panela. Ako //je red neparan formiranje je sa leva na deso, a ako je paran sa desna na levo.

if(i%2==0) niz[i*5+j]->Left=30+j*(niz[i*5+j]->Width +30); else niz[i*5+j]->Left=30+(4-j)*(30+niz[i*4+j]->Width); } } this->Width=430; this->Height=380;}//---------------------------------------------------------------------------void __fastcall TForm1::Timer1Timer(TObject *Sender){

193

k++;

if(k<10) this->Caption="VREME: 0"+Format("%d",ARRAYOFCONST((k))); else this->Caption="VREME: "+Format("%d",ARRAYOFCONST((k)));

//Svake sekunde se menja boja. switch(k%3) { case 1: niz[p]->Color=clBlue; //Prve sekunde u plavu boju. break; case 2: niz[p]->Color=clRed; //Druge sekunde u crvenu boju. break; case 0: niz[p]->Visible=false; //Trece sekunde nestaje p++; //Povecavamo indeks niza radi prelaska na sledeci Panel. break; } if(k==60) Timer1->Enabled=false; //Nakon 60 sekundi svi Paneli su pogaseni.}//---------------------------------------------------------------------------

void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key){

//Nema desavanja dok se ne pritisne taster Enter. Tada se ukljucuje Timer i postavlja indeks //niza na nulu, jer se sva desavanja desavaju u dogadjaju Timera.

if(Key!='\r') Key=0; else{ Timer1->Enabled=true; p=0; }}//---------------------------------------------------------------------------

Primer 106:Napraviti aplikaciju koja u gornjem levom uglu

forme stalno prikazuje aktivni časovnik u obliku HH:MM:SS, a donjem levom uglu trenutni dan u nedelji.

Rešenje


#include "DAN_O.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

194

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Timer1Timer(TObject *Sender){ AnsiString sh,sm,ss; Word h,m,sek,msec,dan;

TDateTime datum=Date(); //Funkcijom Date utvrdjuje se datum u obliku TDateTime dan=DayOfWeek(datum)-1; //Izdvajamo redni broj dana u nedelji.

switch(dan) { case 1: Label2->Caption="PONEDELJAK"; break; case 2: Label2->Caption="UTORAK"; break; case 3: Label2->Caption="SREDA"; break; case 4: Label2->Caption="ÈETVRTAK"; break; case 5: Label2->Caption="PETAK"; break; case 6: Label2->Caption="SUBOTA"; break; case 7: Label2->Caption="NEDELJA"; break; }

DecodeTime(Time(),h,m,sek,msec); //Dekodiramo sat od funkcije Time() u cas h, //minuti m, sekundi sek i milisekundi msec.

if(h<10) sh="0"+IntToStr(h); else sh=IntToStr(h); if(m<10) sm="0"+IntToStr(m); else sm=IntToStr(m); if(sek<10) ss="0"+IntToStr(sek); else ss=IntToStr(sek);

Label1->Caption=sh+":"+sm+":"+ss;}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Timer1->Enabled=true;

195

}//-----------------------------------------------


omogućava korišćenjem komponente Timer simulaciju kretanja brodića po jezeru.

Potrebno je prvo u Windowsu pronaći sluku jezera, a potom u programu Paint nacrtati sliku brodića sa tekstom, kao na slici.

Rešenje


#include "Unit1.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

int pom = 0;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Image1->Picture->LoadFromFile("Sunset.bmp"); Image2->Picture->LoadFromFile("brod.bmp");

Form1->Left = Screen->Width/2 - Form1->Width/2; Form1->Top = Screen->Height/2 - Form1->Height/2;}//---------------------------------------------------------------------------void __fastcall TForm1::Timer1Timer(TObject *Sender){

//Brodic se prilikom udaljavanja smanjuje. Image2->Width = Image2->Width - 1; Image2->Height = Image2->Height - 1;

196

//Brodic se udaljava. if (pom==4) { Image2->Top = Image2->Top + 1; pom=0; }

//Ako je komponenta, slika brodica jako mala, nema svrhe dalje komponentu //smanjivati, vec gasimo Timer i ispisujemo poruku da je brodic nestao.

if(Image2->Width == 10) { Timer1->Enabled = false; ShowMessage ("brod otisao :)"); }

pom++; //Regulisemo pomeranje brodica.}//-----------------------------------------------

Primer 108:Napraviti aplikaciju koja pretstavlja

košarkaški semafor. Vreme prilikom startovanja aplikacije je 10:00. Postojie tri dugmeta za rukovanje semaforom: START, STOP i RESET, kao i dva dugmeta za korekciju vremena: + i –

Klikom na dugme START dugme je neaktivno a semafor radi i u tada se ne može korigovati vreme. Klikom na dugme STOP semafor se zaustavlja, dugme STOP postaje neaktivno a START aktivno, i tada je moguće korigovati vreme. Klikom na dugme RESTART vreme se vraća na početno 10:00, a dugmadi START i RESTART su neaktivni. Prilikom startovanja aplikacije samo je dugme START aktivno. Korekcija vremena vrsi se u sekundama, pri čemu se klikom na taster + vreme uvećava za sekundu, a klikom na taster – vreme smanjuje za jednu sekundu..

Rešenje


#include "VREME_O.h"//---------------------------------------------------------------------------

197

#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

int vr=600;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Timer1Timer(TObject *Sender){ if(vr>0) { vr--;

if(vr/60>9 && vr%60>9) Label1->Caption=Format("%d:%d",ARRAYOFCONST((vr/60,vr%60)));

if(vr/60>9 && vr%60<10) Label1->Caption=Format("%d:0%d",ARRAYOFCONST((vr/60,vr%60)));

if(vr/60<10 && vr%60>9) Label1->Caption=Format("0%d:%d",ARRAYOFCONST((vr/60,vr%60)));

if(vr/60<10 && vr%60<10) Label1->Caption=Format("0%d:0%d",ARRAYOFCONST((vr/60,vr%60)));

}}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Timer1->Enabled=true; Button1->Enabled=false; Button2->Enabled=true; Button3->Enabled=true; GroupBox2->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Timer1->Enabled=false; Button1->Enabled=true; Button2->Enabled=false; GroupBox2->Enabled=true;

198

}//---------------------------------------------------------------------------void __fastcall TForm1::Button3Click(TObject *Sender){ vr=600;

Label1->Caption="10:00"; Button1->Enabled=true; Button2->Enabled=false; Button3->Enabled=false; GroupBox2->Enabled=false; Timer1->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Button4Click(TObject *Sender){ if(vr<600) { vr++;


if(vr/60>9 && vr%60<10) Label1->Caption=Format("%d:0%d",ARRAYOFCONST((vr/60,vr%60)));



}}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::Button5Click(TObject *Sender){ if(vr>00) { vr--;


if(vr/60>9 && vr%60<10)

199

Label1->Caption=Format("%d:0%d",ARRAYOFCONST((vr/60,vr%60)));



}}//---------------------------------------------------------------------------

Primer 109:Napraviti aplikaciju koja pretstavlja

igricu Kliktanje redom na brojeve. Dinamički formirati na Formi pet redova po pet dugmadi, pri čemu se na slučajan način na svakom dugmetu pojavljuje natpis sa slučajno izabranim brojem sa intervala od 1 do 25.

Za svako dugme važi događaj OnClick. Ako broj nije po redeu na koji kliknemo potrebno ja da dugme ostane vidljivo, a ako je po redu dugme će biti nevidljivo.

Kada nestanu svi dugmadi sa fornme pojaviće se poruka Bravo, Dobro je, Moze i bolje ili Lose.

U zaglavlju tokom igre ispisuje se trenutno vreme. Nakon pročitane poruke, potrebno je sve dugmadi fizički izbrisati i pozvati ponovo događaj za stvaranje forme OnCreate.

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include <stdlib.h>#include "primer17_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

TButton *comp[25];int k=0,t=0;

200

int niz[25];//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ int br=0; k=0; t=0;

randomize(); for(int i=0;i<5;i++) { for(int j=0;j<5;j++) { TButton *bn = new TButton(this); bn->Parent=this;

bn->Width=50; bn->Height=50; bn->Left=10+j*(bn->Width+10); bn->Top=10+i*(bn->Height+10); niz[br]=random(24)+1; bn->Caption=IntToStr(niz[br]); comp[k]=bn; br++; bn->Font->Style=TFontStyles()<<fsBold; bn->OnClick=ButtonClick; } }

//Sortiranje niza u rastucem redosledu, kako bi kasnije mogli kontrolisati da li //igrac redom klikce po panelima, tj po brojevima.

int pom; for (int i=0; i<24; i++) { for (int j=i+1; j<25; j++) { if (niz[j]<niz[i]) { pom=niz[i]; niz[i]=niz[j];

201

niz[j]=pom; } } }

Form1->Width=315; Form1->Height=340; Application->Title="Kraj igre!!!"; Timer1->Enabled=true; //Startujemo igricu.}//---------------------------------------------------------------------------void __fastcall TForm1::ButtonClick(TObject *Sender){

//Promenljiva k je indeks niza, a vrednost niza sa tom vrednosti indeksa je broj koji //je po redu. Ako se vrednosti kliknutog natpisa i vrednosti niza poklope kliknuti //panel nestaje.

TButton *bn=dynamic_cast<TButton *>(Sender); if(niz[k]==StrToInt(bn->Caption)) { bn->Visible=false; k=k+1; }

if(k==25) { bn->Visible=false; Timer1->Enabled=false; if (t<=20) ShowMessage("Prolazno vreme je "+IntToStr(t)+", Bravo"); if (t>20 && t<=40) ShowMessage("Prolazno vreme je "+

IntToStr(t)+", Dobro je"); if (t>40 && t<=60) ShowMessage("Prolazno vreme je "+

IntToStr(t)+", Moze i bolje"); if (t>60) ShowMessage("Prolazno vreme je "+IntToStr(t)+", Lose!!"); for(int i=0; i<25; i++) comp[i]->Free(); Form1->FormCreate(Sender); }}//---------------------------------------------------------------------------void __fastcall TForm1::Timer1Timer(TObject *Sender){ t++; Form1->Caption="Trenutino vreme: "+IntToStr(t)+" sec";}//---------------------------------------------------------------------------

Primer 110:

202

Napisati aplikaciju koja predstavlja poznatu igricu Memorija sa jednim igračem. Na tabli se nalazi 30 SpeedButton-a koji na samom pocetku aplikacije imaju istu sliku. Klikom na dugme na dugmetu se pojavljuje nova slika. U jednom trenutku na tabli mogu biti otvorene dve slike ili jedna slika. Ako su slike indentične oba dugmeta nestaju sa table. Na panelu kao na slici nalaze se trenutno proteklo vreme i broj otvaranja. Pod otvaranjem podrazumeva se otvaranje dve slike. Igrica se završava kada se pogode svi parovi i vreme se zaustavlja.

Rešenje SpeedButton je dugme sa slikom nad kojim se mogu desiti samo događaji sa mišem.

Odnosno dugme nikada ne može dobiti fokus. SpeddButton obično ima sliku a ne i natpis, tipa je TspeedButton i nalazi se na paleti komponenti kartica Additional.


#include "Memorija_o.h"#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;int x[30];int pom1;int pom2,brpokusaja=0;int brsec=0,brmin=0;TSpeedButton *btnx1=NULL;TSpeedButton *btnx2=NULL;int pogodjenih;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender)

203

{ unsigned i,j; int m;

Application->Title="Memorija..."; Label2->Caption = "00:00"; Timer2->Enabled=true; randomize(); pom1=pom2=pogodjenih=0; Label4->Caption = "0";

//Formiraju se dugmadi ravnomerno rasporedjeni po formi. Svi dugmadi dobijaju istu pocetnu //sliku i reaguju na dogadjaj ButtonClick. Svojstvo Tag dobija vrednost rednog broja //dugmeta.

for(i=0;i<6;i++) { for(j=0;j<5;j++) { TSpeedButton *pok=new TSpeedButton(this); pok->Parent=this; pok->Height=80; pok->Width=80; pok->Top=20+j*(pok->Height+20); pok->Left=20+i*(pok->Width+20); pok->OnClick=ButtonxClick; pok->Tag=(i+1)+(j*6); pok->Glyph->LoadFromFile("x.bmp"); //Loaduje se pocetna slika. } }

for(i=0;i<30;i++) x[i]=0; //Inicijalizuje se pomocni niz.

//Formira se par sa istim slikama (u nizu x dva clana niza imace jednake vrednosti). Par //clanova niza bira se na slucajan nacin, medju onim clanovima koji do tada nisu izabrani, a //to se vidi po tome sto je vrednost tih clanova niza jednaka nuli.

for(i=1;i<16;i++) { m=random(30); while(x[m]!=0) m=random(30); x[m]=i;

m=random(30); while(x[m]!=0) m=random(30); x[m]=i; }}//---------------------------------------------------------------------------void __fastcall TForm1::ButtonxClick(TObject *Sender){

204

TSpeedButton *btnx=dynamic_cast<TSpeedButton*>(Sender);

//Promenljivama pom1 i pom2 predstavljaju brojeve dugmadi iz niza koji su kliknuti. Ako //je vrednost pom1 jednaka sa vrednosti opom2 i ujedno su razliciti od nule, znak je da su //otvorena dva dugmeta koja su indenticna. Ukoliko su razlicita od nule i medjusobno nisu //jednaka znak je da ih treba vratiti na stare slike, jer je u pitanju promasaj.

if(pom1!=pom2&&pom1!=0&&pom2!=0) { btnx1->Glyph->LoadFromFile("x.bmp"); btnx2->Glyph->LoadFromFile("x.bmp"); pom1=pom2=0; }

int br=0; br=btnx->Tag; br=br-1;

//Ako je pom1 jednak nuli trenutno treba otvoriti jedno dugme, te pom1 dobija redni broj tog //dugmeta. Ako je pom1 razlicit od nule znak je da treba otvoriti drugo dugme te pom2 dobija //redni broj drugog dugmeta.

if(pom1==0) pom1=x[br],btnx1=btnx; else pom2=x[br],btnx2=btnx;

//Sada se na osnovu rednog broja dugmeta dugmetu pridruzuje odgovarajuca slika. if(x[br]==1) btnx->Glyph->LoadFromFile("1.bmp"); if(x[br]==2) btnx->Glyph->LoadFromFile("2.bmp"); if(x[br]==3) btnx->Glyph->LoadFromFile("3.bmp"); if(x[br]==4) btnx->Glyph->LoadFromFile("4.bmp"); if(x[br]==5) btnx->Glyph->LoadFromFile("5.bmp"); if(x[br]==6) btnx->Glyph->LoadFromFile("6.bmp"); if(x[br]==7) btnx->Glyph->LoadFromFile("7.bmp"); if(x[br]==8) btnx->Glyph->LoadFromFile("8.bmp"); if(x[br]==9) btnx->Glyph->LoadFromFile("9.bmp"); if(x[br]==10) btnx->Glyph->LoadFromFile("10.bmp"); if(x[br]==11) btnx->Glyph->LoadFromFile("11.bmp"); if(x[br]==12) btnx->Glyph->LoadFromFile("12.bmp"); if(x[br]==13) btnx->Glyph->LoadFromFile("13.bmp"); if(x[br]==14) btnx->Glyph->LoadFromFile("14.bmp"); if(x[br]==15) btnx->Glyph->LoadFromFile("15.bmp");

//Ako su promenljive pom1 i pom2 indenticni i dugmadi indenticni znak je da je otvoreni par //pogodjen, te dugmadi nestaju sa forme a broj pogodaka se povecava za jeda,

if(pom1==pom2&&btnx1!=btnx2) { btnx->Visible=false; btnx1->Visible=false; pom1=pom2=0; pogodjenih++;

205

Timer2->Enabled=true; }

//Ako je broj pogodaka jednak 15, znak je da su svi parovi pogodjeni, te je nastupio kraj //igrice, a vreme se zaustavlja.

if(pogodjenih==15) { Timer2->Enabled=false; ShowMessage("Vreme: "+Label2->Caption+" Broj pokusaja: "+Label4->Caption); }

brpokusaja++; if(brpokusaja%2==0) {

//Broj pokusaja jednak je polovini broja otvorenih dugmadi. Label4->Caption = IntToStr(brpokusaja/2); }}//---------------------------------------------------------------------------void __fastcall TForm1::Timer2Timer(TObject *Sender){

brsec++; //Kako se istekom 1000ms sto odgovara vremenu od jedne sekunde desava //dogadjaj tajmera, to ako postavimo neki brojac da se svaki put kada se dogadjaj desi //povecava za jedan, taj brojac ce predstavljati vreme koje je proteklo od pocetka //igrice.

brmin=brsec/60; if(brmin<10&&brsec<10) { Label2->Caption="0"+IntToStr(brmin)+":0"+IntToStr(brsec-brmin*60); }else if(brmin<10){ Label2->Caption="0"+IntToStr(brmin)+":"+IntToStr(brsec-brmin*60); }else if(brsec<10){ Label2->Caption=IntToStr(brmin)+":0"+IntToStr(brsec-brmin*60); }}//---------------------------------------------------------------------------


omogućava unos stringa i pritiskom na dugme BROJ utvrđuje koliko string sadrži samoglasnika a koliko suglasnika.

Dugme BRISI omogućava brisanje teksta iz polja za unos, a na mestima gde se prikazuje broj suglasnika i broj samoglasnika prikazuje se četiri znaka pitanja.

206

Rešenje

STRINGOVI

Definicija stringa:

String je niz znakova. Služi za pretstavljanje tekstova. Borland C++ Builder koristi dve vrste stringova: AnsiString i string koji se završava znakom '\0'.

Funkcije za prervaranje iz jednog stringa u drugi su:

Pretvaranje AnsiString-a u string koji se završava znakom '\0': s=StrPCopy(s,ss); //ss je AnsiString

Pretvaranje string koji se završava znakom '\0' u AnsiString: ss=StrPas(s); //ss je AnsiString

String koji se završava znakom '\0'

String koji se završava znakom '\0'\ omogućava da se kroz string prolazi pomoću indeksa i pri tome se najčešće koristi while ciklus. Dozvoljene su manipulacije sa stringom kao sa običnim nizom stim što se mora voditi računa da se string mora završavati sa znakom '\0'. Prvi karakter stringa ima indeks nula.

Deklaracija stringa koji se završava znakom '\0':

char *s=new char[MAX];

Inicijalizacija stringa koji se završava znakom '\0':

s[0]= '\0';

AnsiString:

Svojstvo Caption ili Text su tipa AnsiString-a a nalaze se kao svojstva većine komponenti.

U definiciji stringa naznačeno je da je string niz. To znači da se kroz string prolazi kao i kroz niz sa indeksom. Indeks prvog znaka stringa je 1 kod AnsiString-a, a kod stringa koji se završava znakom '\0' indeks prvof znaka stringa je 0.

Kod AnsiString-a koristi se operator + koji omogućava spajanje stringova. Tip podatka AnsiString ne dozvoljava da se u string upisuje karakter po karakter

pomocu dodele. Svi poslovi se rade pomoću funkcija.

207

Deklaracija i inicijalizacija stringa:AnsiString s=””:

Najvaznije funkcije za rad sa AnsiString-om:

int Length(void); Dužina stringa utvrđuje se vunkcijom Length i predstavlja broj karaktera

koji se nalazi u stringu.

int Pos(AnsiString sub);Funkcija određuje pozicije od koje se prvi put pojavljuje string sub u

ispitivanom stringu. Ako string sub nije podstring ispitivanog stringa funkcija vraća broj 0.

AnsiString Insert(AnsiString s, int index);Umeće string s od pozicije index u posmatrani string.

AnsiString Delete(int pocindex, int krajindex);Briše podstring koji se nalzi između poziocija pocindex i krajindex.

AnsiString SubString(int pocindex, int krajindex);Omogućava stvaranje novog stringa koji je deo podstringa isptivanog stringa

između pozicija pocindex i krajindex.

AnsiString UpperCase(void);Vraća novi string koji se dobija pretvaranjam svih karaktera izvorišnog

stringa u velika slova.

AnsiString LowerCase(void);Vraća novi string koji se dobija pretvaranjam svih karaktera izvorišnog

stringa u mala slova.

AnsiString StringOfChar(char ch, int br);Formira i vraća AnsiString koji se sastoji od br ynakova ch.int StrToInt(AnsiString s); //Konvertuje string s u broj tipa int.AnsiString IntToStr(int broj ); //Konvertuje broj tipa int u string;float StrToFloat(AnsiString s); //Konvertuje string s u broj tipa floatAnsiString FlatToStr(float broj); //Konvertuje broj tipa float u string


#include "Brojsamisugl_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

208

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int i,brsam=0, brsugl=0; char *s=new char[30]; //Promenljiva s je raspakovani dinamicki string.

s=StrPCopy(s,Edit1->Text); //Pretvaranje iz pakovanog u raspakovani string.

//Kroz raspakovani string se uvek prolazi kao i kroz niz, sa ciklusom, stim da je logicno //koristiti while ciklus jer se raspakovani string zavrsava sa znakom \0'.

i=0; while(s[i]!='\0') { if(isalpha(s[i])) { if(s[i]=='A'||s[i]=='a'||s[i]=='E'||s[i]=='e'||s[i]=='O'|

|s[i]=='o'||s[i]=='I'||s[i]=='i'||s[i]=='U'||s[i]=='u') brsam++; else brsugl++; }

i++; //Cesto se zaboravi uvecati indeks pa cilus postane beskonacan. }

delete []s; //Svakom new mora odgovarati jedan delete.

Label5->Caption=IntToStr(brsam); Label3->Caption=IntToStr(brsugl);

Button2->Enabled=true; Button1->Enabled=false;}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text=""; Button2->Enabled=false; Button1->Enabled=true; Label3->Caption="????"; Label5->Caption="????"; Edit1->SetFocus();}//---------------------------------------------------------------------------

209


omogućava unos stringa, a potom ptitiskom na taster UTVRDI utvrđuje da li uneseni string predstavlja palindrom. Ako je polindrom u Labeli gde je odgovor upisaće se reč DA, a u suprotnom reč NE.

Kada se klikne na dugme BRISI vrši se brisanje stringa i aplikacija se vraća u početno stanje.

Rešenje


#include "Brojsamisugl_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ AnsiString s; int i,j;

s=Edit1->Text; s=s.UpperCase();

char *ss=new char[30]; ss=StrPCopy(ss,s); //Iz stringa brisemo sve praznine. i=0; while(ss[i]!='\0') { if(ss[i]==' ') { j=i; while(ss[j]!='\0') ss[j]=ss[j+1],j++; ss[j]='\0'; }else i++; }

210

//Da bi string bio palindrom, prva polovina stringa mora biti indenticna sa inverznom //drugom polovinom stringa. Znaci jednim indeksom prolazicemo od pocetka stringa, a //drugim od kraja stringa, sve dok se indeksi ne poklope ili mimoidju.

i=0; j=strlen(ss)-1; while(ss[i]==ss[j] && i<=j) i++,j--;

if(j<=i)Label3->Caption="DA"; else Label3->Caption="NE";

delete []ss;

Button2->Enabled=true; Button1->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text=""; Button2->Enabled=false; Button1->Enabled=true; Label3->Caption="????"; Edit1->SetFocus();} //---------------------------------------------------------------------------


omogućava unos stringa, a potom vrši izbor formatiranja stringa..

Izbor je: sva slova postaju mala, sva slova postaju velika, inverzna slova (mala u velika i obrnuto) i vraćanje prvobitnog stringa.

Prilikom startovanja aplikacije nijedna stavka komponente RadioGroup nije aktivna.

Rešenje


#include "Brojsamisugl_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;AnsiString pom;

211

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::RadioGroup1Click(TObject *Sender){ if(Edit1->Text==" ") return;

AnsiString s=Edit1->Text;

char *p= new char[30]; p=StrPCopy(p,s);

switch(RadioGroup1->ItemIndex) { case 0: s=s.UpperCase(); break; case 1: s=s.LowerCase(); break; case 2: int i=0; while(p[i]!='\0') {

//Ako je malo slovo postaje veliko i obrnuto. if(p[i]>='a'&&p[i]<='z') p[i]='A'+p[i]-'a'; else if(p[i]>='A'&&p[i]<='Z') p[i]='a'+p[i]-'A' i++; } s=StrPas(p); break; case 3: s=pom; break; }

delete p[]; Edit1->Text=s;}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Exit(TObject *Sender){ if(Edit1->Text=="") return;

pom=Edit1->Text; //Nakon napustanja komponente pamtim string u pomocnoj //promenljivoj.

}//---------------------------------------------------------------------------

212


omogućava unos stringa, a potom svako malo slovo pretvarac u velika slova, u stringu nema tabulatora i svaki višestruki niz praznina zamenjuje sa jednom prazninom.

Izmenjeni string prikazati u posebnom polju za prikaz rezultantnog stringa.

Aplikacija poseduje dva dugmeta: RADI i BRISI.

Rešenje


#include "praznine_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ AnsiString s;

char *p= new char[300];

s=Edit1->Text; s=s.UpperCase(); p=StrPCopy(p,s);

//Prvo sve tabulatore zamenjujemo sa prazninama. int i=0; while(p[i]!='\0') { if(p[i]=='\t') p[i]=' '; i++; }

//Niz uzastopnih praznina zamenjujemo sa jednom prazninom.

213

i=1; while(p[i]!='\0') { if(p[i]==' ' && p[i-1]==' ') { int j=i; while(p[j]!='\0') p[j]=p[j+1],j++; p[j]='\0'; }else i++; }

s=StrPas(p); Edit2->Text=s;

delete []p;

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//-------------------------------------------------

Primer 115:Napraviti aplikaciju koja na

osnovu prirodnog broja N i racionalnog broja X ra;una sumu S po dole navedoj formuli. Program poseduje zaštitu unosa prirodnog i racionalnog broja.

Rešenje


#include "Zbir_o.h"//---------------------------------------------------------------------------

214

#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Edit2KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='+' && Key!='-' && Key!='.') Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); AnsiString s=ed->Text;

if((Key!='.' && Key!=8) && (s=="0" || s=="+0" || s=="-0")) Key=0;

switch(Key) { case '+': case '-': if(s!="") Key=0; break; case '.': int k=s.Pos("."); if(k!=0 || s=="" || s=="+" || s=="-") Key=0; break; } }}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8) Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); AnsiString s=ed->Text;

if(s=="" && Key=='0') Key=0; }}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="" || Edit2->Text=="") { ShowMessage("Niste uneli oba podatka!!"); if(Edit1->Text=="") Edit1->SetFocus(); else Edit2->SetFocus(); }else{

215

float s,x,pre,p; int t,z,n;

n=StrToInt(Edit1->Text); x=StrToFloat(Edit2->Text);

for(int i=1;i<=n;i++) { if(i==1) s=x, z=-1, p=x, t=1; else t+=i, pre=p, p*=x, s=s+z*p/(pre+t),z=-z; }

Edit3->Text=Format("%.3f",ARRAYOFCONST((s)));

Button1->Enabled=false; Button2->Enabled=true; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Button1->Enabled=true; Button2->Enabled=false;

Edit1->Clear(); Edit2->Clear(); Edit3->Clear();

Edit1->SetFocus();}//---------------------------------------------------------------------------


omogućava unos stringa, a potom ptitiskom na taster RADI vrši sažimanje stringa tako što se uzastopni niz istih znakova zamenjuje samo sa jednim znakom.

Kada se klikne na dugme BRISI vrši se brisanje stringa i aplikacija se vraća u početno stanje.

Rešenje


#include "Brojsamisugl_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)

216

#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int i,j; AnsiString s; char *ss=new char[30];;

s=Edit1->Text; ss=StrPCopy(ss,s);

i=0; while(ss[i]!='\0') { if(ss[i]==ss[i+1]) { j=i; while(ss[j]!='\0') ss[j]=ss[j+1],j++; ss[j]='\0'; }else i++; }

Label3->Caption=StrPas(ss); Button2->Enabled=true; Button1->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text=""; Button2->Enabled=false; Button1->Enabled=true; Label3->Caption="????"; Edit1->SetFocus();}//---------------------------------------------------------------------------

217

Primer 117:Napraviti aplikaciju koja pravi

statistički prikaz pojave slova u unesenom stringu. Program ne razlikuje prilikom brojanja mala i velika slova.

Program se sastoji od polja za unos stringa, GroupBox-a sa natpisom Pojava slova u kojoj se nalaze dve Memo komponente. Prva Memo komponenta je sive boje i u njoj se nalaze sva velika slova Engleske azbuke. Drugi Memo sadrži prilikom startovanja aplikacije sve nule. Niti jedan Memo ne sadrži ukljucen ScrollBar jer redovi prve Memo komponente moraju pratiti redove druge Memo komponente.

Klikom na dugme URADI u Memo komponenti Pojava menjaju se vrednosti, tako da one odgovaraju broju pojava određenog slova u stringu. Klikom na dugme BRISI stanje se vraća na slučaaj kada smo startovali aplikaciju.

Rešenje


#include "pojava_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ for(int i=0;i<26;i++) { AnsiString s;

218

char c='A'+i; //Dobijamo odgovarajuce veliko slovo.

s=s.StringOfChar(c,1); //Formiramo string s koji sadrzi jedno to slovo. Memo1->Lines->Add(s); //Dodajemo slovo u pri Memo. Memo2->Lines->Add("0"); //U drugi Memo upisujemo nulu. }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ AnsiString s=Edit1->Text;

s=s.UpperCase(); //Pretvaramo sva slova u velika jer program ne razlikuje velika slova od malih.

char c; for(int j=0;j<Memo1->Lines->Count;j++) { c='A'+j; //Formiramo odgovarajuce veliko slovo.

//Formiramo string radi pretrage koji sadrzi samo to veliko slovo. AnsiString sss,ss=ss.StringOfChar(c,1);

sss=s; while(sss.Pos(ss)) //Dokle god postoji takvog slova u stringu radi. { int i=sss.Pos(ss); //Utvrdi poziciju gde je slovo. if(i!=0) //Ako je pozicija razlicita od nule slova postoji. { int k=StrToInt(Memo2->Lines->Strings[j]); k++; //Uvecavamo brojac pojava slova za jedan.

//Upisujemo novo stanje brojaca u Memo komponentu. Memo2->Lines->Strings[j]=IntToStr(k);

//Brisemo deo stringa, od pocetka stringa zakljucno sa slovom koje je //pronadjeno.

sss=sss.Delete(1,i); } } }

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------//---------------------------------------------------------------------------

219

void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Memo2->Lines->Clear();

//Potrebno je samo Memo pojava slova menjati vracanjem svih redova na nulu. for(int i=0;i<Memo1->Lines->Count;i++) { Memo2->Lines->Add("0 "); }


Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 118:Napraviti aplikaciju koja omogućava unos izvornog stringa u obliku AnsiString-a i

šifrovanog stringa. Šifrovani AnsiString je oblika broj#string. Nakon unosa stringova potrebno je formirati i ispisati novi string koji na poziciju broj u izvornom stringu umeće substring string kao deo šifrovanog stringa ali pretvaranjem svih slova u velika slova.

Rešenje


#include "korrdic_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)

220

: TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){

AnsiString s1,s2,p="#",p1,p2; int a,br;

s1=Edit1->Text; //Izvorni string. s2=Edit2->Text; //Sifrovani string.

a=s2.Pos(p); //Trazi se pozicija karaktera # u sifrovanom stringu. p1=s2; //Pamtim sifrovani string. p2=s2.SubString(1,a-1); //Izdvajam prvi deo sifrovanog stringa.. br=StrToInt(p2); //Dobijamo podatak broj iz sifre. p1.Delete(1,a); //Brisemo prvi deo stringa. p1=p1.UpperCase(); //Pretvaramo drugi deo stringa string u velika slova. p1+=" "; //Dodajemo prazno mesto u string. s1.Insert(p1,br); //Umescemo sifrovani string na odredjenu poziciju.

Label1->Caption=s1; //Upisujemo string u Labelu.

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Button1->Enabled=true; Button2->Enabled=false; Edit1->Text=""; Edit2->Text=""; Label1->Caption="??????????";}//-----------------------------------------------


omogućava unos dekadnog broja, a potom po izboru vrši njegovo pretvaranje u drugi brojevni sistem.

Na raspolaganju su četiri brojevna sistema: dekadni, binarni, oktalni i heksadecimalni.

Klikom na dugme PRETVORI vrši se pretvaranje iz dekadnog u neki drugi izabrani brojevni sistem, a klikom na dugme RESETUJ vrši se podstavljanje aplikacije na početno stanje.

221

Rešenje


#include "Broj_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") {

//Ako se ne unese string greska je i polje unosa se boji u crveno. Edit1->Color=clRed; Edit1->SetFocus(); return; }

//Izdvajamo broj iz polja unosa ogranicenog na maksimalno osam cifara. int broj=StrToInt(Edit1->Text); AnsiString s; int pom;

//Utvrdjujemo u koji sistem treba pretvarati uneseni broj. switch(RadioGroup1->ItemIndex) { case 0: Edit2->Text=Edit1->Text; //Vec je dekadni i treba ga samo prepisati. break;

case 1: pom=broj; //Pamtim broj u pomocnu promenljivu. s=""; //Broj se formira dodavanjem u pomocni string s nule i jedinice.

//Ciklus se odvija sve dok postoji broj.. while(pom!=0) {

//Osnova binarnog sistema je broj dva. To je razlog sto se cifra //izdvaja deljenjem sa brojem dva.

222

if(pom%2==0) s.Insert("0",1); //Ubacije se jedinica. else s.Insert("1",1); //Ubacuje se nula.

pom/=2; //Smanjujemo binarni broj za polednju cifru. }

Edit2->Text=s; //Upisujemo binarni broj iz stringa s u polje prikaza. break;

case 2: pom=broj; s="";

while(pom!=0) {

//Ubacujemo oktalnu cifru. Osnova oktalne cifre je broj osam. s.Insert(IntToStr(pom%8),1); pom/=8; //Izbacujemo poslednju oktalnu cifru. }

Edit2->Text=s; //Upisujemo oktalni broj iz stringa s u polje prikaza. break;

case 3: pom=broj; while(pom!=0) {

//Osnova heksadecimalnog brojevnog sistema je 16, stim sto umesto //broja 10 je slovo A, broja 11 slovo B, broja 12 slovo C, 13 slovo D, //14 slovo E i 15 slovo F.

if(pom%16<10) s.Insert(IntToStr(pom%16),1); else{ switch(pom%16) { case 10: s.Insert("A",1); break;

case 11: s.Insert("B",1); break;

case 12: s.Insert("C",1); break;

case 13: s.Insert("D",1); break;

223

case 14: s.Insert("E",1); break;

case 15: s.Insert("F",1); break; } }

pom/=16; }

Edit2->Text=s; break; }

Edit1->Enabled=false; Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Enabled=true; Edit1->Clear(); Edit2->Clear();

RadioGroup1->ItemIndex=0;


Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Click(TObject *Sender){ Edit1->Color=clWhite;}//---------------------------------------------------------------------------

Primer 120:

224

Napraviti aplikaciju digitron kaja predstavlja digitron sa četiri osnovne aritmetičke operacije.Za prikaz brojeva koristiti komponentu Memo jer obezbeđuje poravnavanje sa desne strane. Prilikom startovanja aplikacije digitron je izgleda kao na slici sa brojem 0 i tačkom. Brojevi se unose isključivo pomoću tastera koji su crne boje i predstavljaju Panele, a natpisi na njima su bele boje. Operatori su Paneli bele boje a boja natpisa na njima su crvene boje.

Za sve Panele koji predstavljaju brojeve od 1..9 koristi se jedinstven događaj Onclick.

Rešenje


#include "Digitron_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

//Promenljiva smer odredjuje da li se unosi cifra celobrojnog dela broja (vrednost 1) ii cifra //decimalnog dela (vrednost 0). Promenljiva ops pretstavlja staru operaciju, a opn novu operaciju. //Promenljive ops i opn mogu imati vrednosti od 0 – 4. Vrednost 0 – nema operacije, 1 – //operacija sabiranja, 2 – operacija oduzimanja, 2 – operacija mnozenja i 4 – operacija deljenja.

int smer=1,ops=0,opn=0;

//Promenljiva rez pretstavlja trenutni rezultat, a no pocetku ima vrednost 0.//Promenljiva prvi ima vrednost false ako prilikom unosa operanda do tada nije unesena niti jedna //cifra, a true ako je vec unesena neka cifra.

225

Za sva četiri operatora postoji jedinstveni događaj OnClick. Svi ostali Paneli imaju poseban događaj OnClick. Sa tasterom +/- menja se znak, te ako je broj bio negativan znak – se briše iz broja, a ako je bio pozitivan znak – se dodaje broju. Sa tasterom . dodaje se decimalna tačka broju i kao takva može postojati samo na jednom mestu. Kada se doda decimalna tačka, nastaviće se sa unosom decimalnog dela broja. Ako je broj celobrojan takođe poseduje decimalnu tačku. Program dozvoljava korišćenje tastera BackSpace i time se briše cifra po cifra broja, ali nikako i decimalna tačka. Ako se izbrišu sve cigre broj postaje 0. kao i prilikom startovanja aplikacije. Broj je prihvaćen kao unet kada se klikne na Panel operatora.

Digitron sukcesivno izvršava unesene operacije, bez poštovanja prioriteta operatora, sve dok se ne klikne na dugme = kada se ispisuje rezultat. Taster C omogućava brisanje samo poslednjeg unesenog broja, dok se tasterom CE poništava i dosadašnji izračunati niz sukcesivnih operacija.

//Promenljiva bio ima vrednost true ako je bio zavrsen unos operanda (broja), a false u //suprotnom..

float rez=0;bool prvi=false, bio=false;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Panelx1Click(TObject *Sender) //Cifre 1 - 9{ AnsiString s=Memo1->Lines->Strings[0];

//Zavrsen je u prethodnom trenutku unos operanda ako je bio true. if(bio==true) { Memo1->Lines->Strings[0]="0."; //Postavlja se pocetak unosa novog operanda. bio=false; //Novi broj se unosi. s=Memo1->Lines->Strings[0]; }

if(prvi==false) s.Delete(1,1); //Ako se unosi prva cifra ostace broj 0 a unosi se cifra //celobrojnog dela.

TPanel *pn = dynamic_cast <TPanel *> (Sender);

//Ako je smer = 1 unosi se cifra celobrojnog dela a u suprotnom decimalnog dela. if(smer==1) s.Insert(pn->Caption,s.Length()); else s.Insert(pn->Caption,s.Length()+1);

prvi=true; //Unesena je cifra.

Memo1->Lines->Strings[0]=s;}//---------------------------------------------------------------------------void __fastcall TForm1::Panel14Click(TObject *Sender) //Decimalna tacka.{ //Uneta je decimalna tacka, te je znak da ce se cifre unositi u decimalnom delu broja. smer=0; }//---------------------------------------------------------------------------void __fastcall TForm1::Panel15Click(TObject *Sender) //Znak.{ AnsiString s=Memo1->Lines->Strings[0];

//Ako je broj pozitivan znak je da je broj pozitivan, te mu dodajemo znak minus. U //suprotnom broj je negativan, te sec znak mora iz broja izbrisati.

if(StrToFloat(Memo1->Lines->Strings[0])>0) s.Insert("-",1); else s.Delete(1,1);

226

Memo1->Lines->Strings[0]=s;}//---------------------------------------------------------------------------void __fastcall TForm1::Panel13Click(TObject *Sender) //Cifra 0.{ //Ne moze se uneti cifra 0 ako se unosi celobrojni deo, a trenutna vrednost broja je 0. if(smer==1 && StrToFloat(Memo1->Lines->Strings[0])==0) return;

AnsiString s=Memo1->Lines->Strings[0]; if(smer==1) s.Insert("0",s.Length()); else s.Insert("0",s.Length()+1);

Memo1->Lines->Strings[0]=s;}//---------------------------------------------------------------------------void __fastcall TForm1::Panel17Click(TObject *Sender) //C. Ponistava se sav niz operacija.{ //Pri novo nizu operacija sve je isto sa promenljivama kao i prilikom startovanja programa. smer=1;

Memo1->Lines->Strings[0]="0."; prvi=false;

rez=0;}//---------------------------------------------------------------------------void __fastcall TForm1::Panel18Click(TObject *Sender) //CE.{

//Ponistava se samo poslednje uneseni operand, ali je dosadasnji rezultat niza operacija //sacuvan.

prvi=false; smer=1; Memo1->Lines->Strings[0]="0.";}//---------------------------------------------------------------------------void __fastcall TForm1::Panelx2Click(TObject *Sender){ float pod=StrToFloat(Memo1->Lines->Strings[0]);

//Pamtimo prethodnu operaciju, jer uvek se izvrsava prethodna operacija ops, stim da kada //se klikne na = izvrsavace se poslednja operacija op.

ops=opn;

TPanel *pn = dynamic_cast <TPanel *> (Sender); opn=pn->Tag;

227

switch(ops) //Izvrsava se operacija. { case 1: rez+=pod; break; case 2: rez-=pod; break; case 3: rez*=pod; break; case 4: rez/=pod; break; }

//Ako nije bilo prethodne operacije, a to je slucaj kada se unese samo prvi operand. if(ops==0) rez=pod;

//Utvdjuje se da li je rezultat celobrojan ili racionalan, radi dopisivanja decimalne tacke. int pom=rez; if(pom!=rez) Memo1->Lines->Strings[0]=FloatToStr(rez); else Memo1->Lines->Strings[0]=IntToStr(pom)+".";

bio=true; smer=1; prvi=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Panel19Click(TObject *Sender){ float pod=StrToFloat(Memo1->Lines->Strings[0]);

switch(opn) //Izvrsavace se poslednja operacija. { case 1: rez+=pod; break; case 2: rez-=pod; break; case 3: rez*=pod; break; case 4: rez/=pod; break; }

smer=1; prvi=false; bio=false;

int pom=rez; ops=opn=0; if(pom!=rez) Memo1->Lines->Strings[0]=Format("%f",ARRAYOFCONST((rez))); else Memo1->Lines->Strings[0]=IntToStr(pom)+".";}//---------------------------------------------------------------------------

228

Primer 121:Napisati aplikaciju koja na osnovu unetog prirodnog broja n izračunava zbir kvadrata prvih

n prirodnih brojeva. Za izračunavanje zbira koristiti funkciju Zbir čiji je prototip: int Zbir(int n);Program poseduje zaštitu unosa prirodnog broja.

Rešenje

FUNKCIJE

Definicija funkcije:

Funkcije su potprogrami koji na osnovu izvesnog broja argumenata daju jedan rezultat koji se naziva vrednost funkcije.

Osobine funkcija:

Vrednost funkcije može da se koristi ugrađivanjem poziva funkcije u izraze. Poziv funkcije se, u stvari, smatra operatorom kao i svi ostali operatori.

Funkcije kontrolišu pristup do važnih podataka i čuvaju ih od neovlašćenih promena.

Funkcija skriva detalje načina obavljanja određenog zadatka. Ovaj princip se zasniva na ideji da onoga ko poziva funkciju ne mora interesovati kako određena funkcija rešava odabrani problem koji je rezultat funkcionalne dekompozici

Definisanje funkcijeFunkcija se definiše naredbom za definisanje funkcije:

tip naziv_funkcije(lista _argumenata){

telo_ funkcije}

tip - predstavlja osnovni tip vrednosti funkcije (svi standardni prosti tipovi). Vrednost funkcije može da bude samo jedan podatak. Za tip vrednosti funkcije ne može da bude niz. Za funkcije koje ne stvaraju vrednost funkcije

229

kao oznaka tipa treba da se koristi službena reč void. Ako se izostavi oznaka tipa podrazumeva se tip int.

naziv_funkcije - sastoji se od indentifikatora funkcije, koji je istovetan sa bilo kojom vrstom indentifikatora.

lista_argumenata - predstavljaju argumente funkcije pomoću kojih se vrši unošenje početnih vrednosti funkcije. Vrednost funkcije se izračunava na osnovu tih početnih podataka. Argumenti se u listi argumenata razdvajaju sa zarezom. Pojedini argumenti definišu se na isti način kao i podaci: tip naziv. Za razliku od naredbi za definisanje podataka ovde se za svaki argument mora zasebno navesti oznaka tipa. U slučaju vektora dovoljno je da se samo parom zagrada označi da se radi o vektoru. Argumenti koji se pominju prilikom definisanja funkcije nazivaju se i formalnim argumentima. Oni nisu stvarni podaci koji se obrađuju u toku izvršavanja funkcije.Formalni argumenti koji se pominju prilikom pozivanja funkcije zamenjuju vrednostima odgovarajućih stvarnih argumenata koje se onda obrađuju.

telo_funkcije - predstavlja sadržaj funkcije koja se definiše. Ona je po formi blok (nalazi se između vitičastih zagrada), što znači da može da sadrži deklarativne i izvršne naredbe. Ako funkcija kao rezultat svog rada vraća neku vrednost u okviru tela funkcije mora se nalaziti naredba return. Opšti oblik naredbe return je:

return izraz; ili return;Izraz mora da se po tipu slaže sa predviđenim tipom vrednosti funkcije.Naredba return se koristi kada je potrebno izvršiti povratak u glavni program (u okviru funkcije na više mesta se može nalaziti naredba return). Znači osim što može da vrati vrednost u glavni program, omogućava i prekidanje izvršavanja programskog toka u funkciji, bez obzira na kom mestu se nalazi u telu funkcije. Kod funkcija tipa void naredba return ne sme da sasdrži izraz.


#include "Zbir_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

230

//---------------------------------------------------------------------------int ZbirKvadrata(int n){ int i,s;

s=0; for(i=1;i<=n;i++) s+=i*i;

return s;}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ unsigned s,i,n;


s=ZbirKvadrata(n);

Label3->Caption=IntToStr(s); Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Text=""; Label3->Caption="????"; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key)) Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(ed->Text=="" && Key=='0') Key=0; }}//---------------------------------------------------------------------------

231

Primer 122:Napraviti aplikaciju koja na osnovu unesenog prirodnog broja N izračunava zbir prvih N

članova beskonačnog niza kao na slici. Prva dva člana beskonačnog niza imaju vrednost 1, a počev od trećeg člana elementi sa

neparnim rednim brojem dobijaju se sabiranjem prethodna dva člana, dok se elementi sa parnim rednim brojem dobijaju tako što se prethodi član pomnoži sa brojem 2. Program poseduje zaštitu unosa prirodnog broja. Prilikom realizacije programa obavezno koristiti funkciju Zbir koja izračunava zbir prvih N članova beskonačnog niza.

Rešenje

Jedna bitna akcija prilikom pozivanja funkcije je prosleđivanje vrednosti stvarnih argumenata formalnim argumentima funkcije, ili predaja parametara.

Vrednosti stvarnih argumenata funkcije služe za inicijalizaciju formalnih argumenata funkcije pre obrade tela funkcije.

Predaja parametara može se biti: predaja parametara po vrednost i predaja parametara po referenci.

Prilikom predaje parametara po vrednoasti kopija vrednosti promenljive se prosleđuje funkciji, odnosno formalnim parametrima funkcije. Vrednost promenljive koja je predala vrednost ostaje nepromenjena nakon završetka funkcije.


#include "zad10za2.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

232

//---------------------------------------------------------------------------int Zbir(int n){ int i,p,q,s;

s=0; for(i=1;i<=n;i++) { if(i>2) { if(i%2==1) q=p+q, p=q-p; else p=q, q*=2; s+=q; }else{ if(i==1) s=1; else s=2, p=q=1; } }

return s;}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ int n,i; float s=0;

if(Edit1->Text=="") { ShowMessage("Niste uneli podatak!!"); Edit1->SetFocus(); return; }


Label6->Caption=IntToStr(Zbir(n));

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Label6->Caption="????"; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------

233

//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="GRESKA...";}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key)) Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(ed->Text=="" && Key=='0') Key=0; }}//-----------------------------------------------

Primer 123:Napraviti aplikaciju koja demonstrira primenu prenosa parametara po vrednosti i prenos parametara po referenci. Program poseduje dve funkcije:

void ZamenaPoVred(int a, int b); gde se predaja parametara vrsi po vrednosti i

void ZamenaPoRef(int *a, int *b); gde se prenos parametara vrši po referenci.

Program omogućava unos dva cela broja uz postojanje zaštite unosa celobrojnog podatka.

Z adatak programa je da koristi ove dve funkcije čiji je zadatak da zameni vrednosti ova dva broja. Program u izveštaju iz Memo komponente treba da pokaže da se funkcijom gde se prenos parametara po vrednosti koristio zadatak nije uspešno obavio, već su promenljive ostale sa istom vrednošću, dok se prenosom parametara po vrednosti zadatak uspešno obavljen

Rešenje


#include "Zamena_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

234

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void ZamenaPoVred(int a, int b) //Prenos parametara po vrednosti.{

//Argument funkcije int a jasno govori da se za ovu promenljivu odvaja novi prostor u zoni //STEK memorije. Ona moze samo da primi vrednost. Prostor za promenljive a, b i pom //odvaja se prilikom poziva funkcije i prostor je rezervisan dok se funkcija izvrsava. //Po zavrsetku funkcije rezervisana memorija se gubi.

pom=a; a=b; b=pom;}//---------------------------------------------------------------------------void ZamenaPoRef(int *a, int *b) //Prenos parametara po referenci.{

//Argument funkcije int *a je pokazivacka promenljiva, zbog zvezdice. Prilikom pozivanja //funkcije njoj se ne prosledjuje vrednost vec adresa podatka koji sadrzi vrednost koja treba //da se obradjuje. Podatak menjamo na osnovu adrese ili reference, koju promenljiva sadrzi, //a pristupamo operatorom diferenciranja *.

int pom;

pom=*a; //Promenljiva pom je na steku, a pamti vrednost promenljive van steka, //korišćenjem operatora diferenciranja.

*a=*b; //Promenljiva na koju pokazuje pokazivac a, dobija vrednost //promenljive na koju pokazuje pokazivac b.

*b=pom; //Promenljiva na koju pokazuje pokazivac b dobija vrednost promenljive //pom sa steka.

}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="" || Edit2->Text=="") { Application->Title="GRESKA..."; if(Edit1->Text=="" && Edit2->Text!="") ShowMessage("Niste uneli prvi broj!!"); if(Edit1->Text!="" && Edit2->Text=="") ShowMessage("Niste uneli drugi broj!!"); if(Edit1->Text=="" && Edit2->Text=="") ShowMessage("Niste uneli oba broja!!");

if(Edit1->Text=="") Edit1->SetFocus(); else Edit2->SetFocus(); return; }

235

int prvi, drugi;

prvi=StrToInt(Edit1->Text); drugi=StrToInt(Edit2->Text);

ZamenaPoVred(prvi,drugi); Memo1->Lines->Add("Prenos parametara po vrednosti:"); Memo1->Lines->Add("Prvi broj = "+IntToStr(prvi)); Memo1->Lines->Add("Drugi broj = "+IntToStr(drugi)); Memo1->Lines->Add("");

ZamenaPoRef(&prvi,&drugi); Memo1->Lines->Add("Prenos parametara po referenci:"); Memo1->Lines->Add("Prvi broj = "+IntToStr(prvi)); Memo1->Lines->Add("Drugi broj = "+IntToStr(drugi));

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Memo1->Clear();

Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(Key=='-' && ed->Text!="") Key=0; if(Key=='0' && ed->Text=="") Key=0; if(Key=='0' && ed->Text=="-") Key=0; }}//---------------------------------------------------------------------------

Primer 124:Napraviti aplikaciju koja na osnovu unesenih stranica pravougaonika izračunava: površinu,

i obim pravougaonika. Rešenja prikazati u Labelama zaokružena na tri decimale. Aplikacija poseduje i zaštitu od ne unesenih podataka, tako što se u vidu dijalog prozora prikazuje poruka o grešci. Takođe se pojavljuje poruka o grešci u slučaju da se unese nepozitivan podatak za dužinu stranice pravougaonika. Pomoću komponente DroupBox može se birati boja fonta Labela gde se nalaze podaci koji predstavljaju rešenja programa.

236

Prilikom realizacije programa obavezno koristiti funkciju Pravougaonik koja vraća vrednost obima pravougaonika, a po referenci površinu pravougaonika.

Rešenje

//---------------------------------------------------------------------------#include <vcl.h>#include <math.h>#pragma hdrstop

#include "zad1za2_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------float Pravougaonik(float a, float b, float *p){

//U kodu funkcije pristu podatku pomocu pokazivaca vrsi se uvek operatorom //diferenciranja *

*p=a*b;

//Funkcija vraca obim, a to se radi koriscenjem rezervisanom reci return. return 2*a+2*b; }//---------------------------------------------------------------------------void __fastcall TForm1::RadioGroup1Click(TObject *Sender){ switch(RadioGroup1->ItemIndex) { case 0: Label6->Font->Color=clBlack;

237

Label7->Font->Color=clBlack; break; case 1: Label6->Font->Color=clBlue; Label7->Font->Color=clBlue; break; case 2: Label6->Font->Color=clRed; Label7->Font->Color=clRed; break; case 3: Label6->Font->Color=clGreen; Label7->Font->Color=clGreen; break; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ float a,b,p,o;

if(Edit1->Text=="" || Edit2->Text=="") { ShowMessage("Niste uneli podatke!!"); return; }


if(a<=0 || b<=0) { ShowMessage("Duzine stranica nemogu biti negativne!!"); if(a<0) { Edit1->Clear(); Edit1->SetFocus(); }else{ Edit2->Clear(); Edit2->SetFocus(); } return; }

‘ //Pokazivacu se uvek prenosi adresa adresnim operatorom & o=Pravougaonik(a,b,&p);

Label6->Caption=Format("%.3f",ARRAYOFCONST((p))); Label7->Caption=Format("%.3f",ARRAYOFCONST((o)));

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------

238

//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Label6->Caption="????"; Label7->Caption="????"; Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="GRESKA...";}//----------------------------------------


omogućava unos celobrojnog niza , a potom određuje vrednost minimuma i broj minimuma.

Program prilikom realizacije mora realizovati i koristiti funkciju Minimum koja vraća vrednost minimalnog elementa niza, a po referenci broj minimalnih elemenata niza.

Rešenje


#include "Zbir_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"#define MAX_NIZ 30


239

//---------------------------------------------------------------------------//Niz se uvek prenosi po referenci i nije potrebno u zagradama pisati dimenziju niza, //cak se umesto x[] moye pisati *x

int Minimum(int x[], int n, int *brmin) { int min,i;

min=x[0]; for(i=1;i<n;i++) { if(x[i]<min) min=x[i]; }

*brmin=0; for(i=0;i<n;i++) { if(x[i]==min) (*brmin)++; }

return min;}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ if(Key=='-' && Edit1->Text!="") Key=0;

if(Edit1->Text=="0" && Key!=8 && Key!=’\r’) Key=0; if(Key=='0' && Edit1->Text=="-") Key=0; if(Key=='\r') { if(Edit1->Text=="") Key=0; else{ if(Memo1->Lines->Count<MAX_NIZ)


Application->Title="GRESKA... "; ShowMessage("Prekoracenje memorije niza!!"); Button2->SetFocus(); return; }

Edit1->Clear(); } } }}//---------------------------------------------------------------------------

240

//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!'"); }else{ int i,s,n; n=Memo1->Lines->Count;

int x[MAX_NIZ]; for(i=0;i<Memo1->Lines->Count;i++)

x[i]=StrToInt(Memo1->Lines->Strings[i]);

Edit1->ReadOnly=true;

int min,brmin;

//Kod prosledjivanja adrese niza ne pise se adresni operator, jer je ime niza //adresa pocetka niza.

min=Minimum(x,n,&brmin);

Label4->Caption=IntToStr(min); Label5->Caption=IntToStr(brmin); }}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Memo1->Lines->Clear(); Edit1->Enabled=true; Edit1->ReadOnly=false; Label4->Caption="????"; Label5->Caption="????"; Edit1->SetFocus();}

//---------------------------------------------

241

Primer 126:Napraviti aplikaciju koja omogućava unos celobrojnog niza X od n (n<31) elementa.

Korišćenjem funkcije FormNiz na osnovu niza X formira niza A Elemente niza A čine po jedan elemenat niza X koji se u nizu X više puta ponavljaju.

Formirani niz se prikazuje u drugoj Memo komponenti. Program poseduje zaštitu unosa celobrojnog podatka.

Rešenje



TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void FormNiz(int x[],int n,int a[],int *m){ *m=0; for(int i=0;i<n;i++) { int j=0; while(j<*m && a[j]!=x[i]) j++;

if(j==*m) { int br=0; for(j=0;j<n;j++) { if(x[i]==x[j]) br++; }

if(br>1) { a[*m]=x[i]; (*m)++; } } }

242

}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ if(Key=='-' && Edit1->Text!="") Key=0;

if(Edit1->Text=="0" && Key!=8 && Key!=’\r’) Key=0; if(Key=='0' && Edit1->Text=="-") Key=0; if(Key=='\r') { if(Edit1->Text=="") Key=0; else{ if(Memo1->Lines->Count<MAX_NIZ)

Memo1->Lines->Add(Edit1->Text); else{ Edit1->Enabled=false; Application->Title="GRESKA..."; ShowMessage("Prekoracenje memorije niza!!"); Button2->SetFocus(); return; } Edit1->Clear(); } } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Memo2->Lines->Clear();

if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!"); }else{ int x[MAX_NIZ],i,n,a[MAX_NIZ],m;

n=Memo1->Lines->Count; for(i=0;i<n;i++) x[i]=StrToInt(Memo1->Lines->Strings[i]);

FormNiz(x,n,a,&m); //Poziv funkcije.

Memo2->Lines->Clear(); if(m!=0) { for(i=0;i<m;i++) Memo2->Lines->Add(IntToStr(a[i])); }else Memo2->Lines->Add("Nema niza!!"); }}//---------------------------------------------------------------------------

243

void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Enabled=true; Edit1->ReadOnly=false; Memo1->Lines->Clear(); Memo2->Lines->Clear(); Edit1->SetFocus(); }//---------------------------------------------------------------------------Primer 127:Napraviti aplikaciju koja omogućava unos stringa u polju za unos, a potom podešavanjem

intervala Pocetak i Kraj, klikom na dugme RADI pretvara deo stringa između pozicija Pocetak i Kraj u velika slova. Klikom na dugme BRISI vraća se sve na početno stanje.

Početak i kraj tokom unosa stringa mogu se kretati u intervalu od 1 do duzine stringa. Prilikom unosenja podatka Pocetak i Kraj koristiti zajednički događaj za kontrolu unosa prirodnog broja. Program obezbeđuje da broj koji se ručno unosi u polje Početak ili Kraj ne može imati vrednost veću od dužine stringa, automatski se to uvek kontroliše, te ako uslov nije zadovoljen string se brise i ponovo dobija vrednost 1.Prilikom realizacije programa za pretvaranje dela stringa iz malih slova u velika, mora se realizovati i koristiti funkcija AnsiString Uvecaj(AnsiString s, int poc, int kraj);

Rešenje


#include "Uvecati_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)

244

: TForm(Owner){}//---------------------------------------------------------------------------AnsiString Uvecaj(AnsiString s, int poc, int kraj){ AnsiString pom;

pom=s.SubString(poc,kraj-poc+1); //Izdvajamo deo stringa koji se transformise. pom=pom.UpperCase(); //Pretvorimo string u velika slova.

//Iz izvorisnog stringa izbacimo deo stringa koji ce se transformisati. s=s.Delete(poc,kraj-poc+1); s=s.Insert(pom,poc); //Transformisani string ubacujemo u izvorisni string.

return s; //Vraca se transformisani string.}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1Change(TObject *Sender){ AnsiString s=Edit1->Text;

if(s.Length()==0) GroupBox1->Enabled=false; //Ako nema stringa nema se sta podesavati. else{ GroupBox1->Enabled=true; //Moze se podesavati. UpDown1->Max=s.Length(); //Indeks se moze kretati od 1 do duzine stringa. UpDown2->Max=s.Length(); Button1->Enabled=true; }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Application->Title="GRESKA...";

if(Edit1->Text=="") { ShowMessage("Nema se sta raditi!!"); Edit1->SetFocus(); }else{ if(UpDown1->Position>=UpDown2->Position) { ShowMessage("Pogresan interval!!"); }else{ AnsiString s; s=Edit1->Text;

int poc,kraj; poc=UpDown1->Position; //Indeks pocetka. kraj=UpDown2->Position; //Indeks kraja.

245

s=Uvecaj(s,poc,kraj); //Poziv funkcije. Edit4->Text=s; //Prikaz rezultata transformacije.

Button1->Enabled=false; Button2->Enabled=true; } }}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit4->Clear();

Button1->Enabled=true; Button2->Enabled=false; GroupBox1->Enabled=false;

Edit2->Text="1"; Edit3->Text="1"; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit2KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8) Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(ed->Text=="" && Key=='0') Key=0; }}//---------------------------------------------------------------------------void __fastcall TForm1::Edit2Change(TObject *Sender){ TEdit *ed = dynamic_cast <TEdit *> (Sender);

if(ed->Text=="") return; //Ako nema broja, nema se sta proveravati. //Trenutna vrednost broja u svakonm trenutku ne moze biti veca od duzine stringa.

if(StrToInt(ed->Text)>UpDown1->Max) { ed->Text=="1"; return; }}//------------------------------------------------------

246

Primer 128:Napraviti aplikaciju koja omogućava unos celobrojnog niza X od n (n<31) elemenata, a

potom potvrđivanjem izabrane opcije sažimanja i klikom na dugme RADI sazižima niz izbacivanjem odgovarajućih elemenata iz izbora. Transformisani niz prikazati u novoj Memo komponenti. Klikom na dugme BRISI sve se vraća na početak. Prilikom realizacije programa potrebno je realizovati i pozivati funkcije: int TraziMinMax(int x[],int n,char c,int *rez); , void IzbaciIzNiza(int x[],int *n,int broj); ivoid Sazimanje(int x[],int *n,int odluka);

Funkcija TraziMinMax u nizu x od n elemenata, a na osnovu izbora c određuje minimum ili maksimum niza. Ako se argumentu funkcije c prosledi vrednost '<' funkcija po referenci određuje vrednost minimuma a vraća broj minimuma. Ako se argumentu funkcije c prosledi vrednost '>' funkcija po referenci određuje vrednost maksimuma a vraća broj maksimuma.

Funkcija IzbaciIzNiza iz niza x od n elemenata izbacuje sve elemente niza čija je vrednost jednaka vrednosti promenljive broj.

Funkcija Sazimanje u odnosu na izabranu odluku vrši sažimanje niza X od n elemenata. Promenljiva odluka može imati vrednosti od 1 do 4 jer je to broj kombinacija koje se mogu desiti prilikom čekiranja.

Program poseduje ui zaštitu unosa celobrojnog podatka.

Rešenje


#include "minmax_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"#define MAX_NIZ 30TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------int TraziMinMax(int x[],int n,char c,int *rez){ switch(c) { case '<': *rez=x[0]; for(int i=1;i<n;i++) { if(x[i]<*rez) *rez=x[i]; } break; case '>': *rez=x[0]; for(int i=1;i<n;i++)

247

{ if(x[i]>*rez) *rez=x[i]; } break; }

int br=0; for(int i=0;i<n;i++) { if(x[i]==*rez) br++; }

return br;}//---------------------------------------------------------------------------void IzbaciIzNiza(int x[],int *n,int broj){ int i,j;

i=0; while(i<*n) { if(x[i]!=broj) i++; else{ j=i; while(j<*n-1) x[j]=x[j+1],j++; x[*n-1]=0; (*n)--; } }}//---------------------------------------------------------------------------void Sazimanje(int x[],int *n,int odluka){ int br,min,max;

switch(odluka) { case 1: br=TraziMinMax(x,*n,'<',&min); IzbaciIzNiza(x,&(*n),min); break; case 2: br=TraziMinMax(x,*n,'>',&max); IzbaciIzNiza(x,&(*n),max); break; case 3: br=TraziMinMax(x,*n,'<',&min); IzbaciIzNiza(x,&(*n),min);

br=TraziMinMax(x,*n,'>',&max); IzbaciIzNiza(x,&(*n),max); break; }

248

}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-' && Key!='\r') Key=0; else{ if(Key=='-' && Edit1->Text!="") Key=0; if(Edit1->Text=="0" && Key!=8 && Key!=’\r’) Key=0; if(Key=='0' && Edit1->Text=="-") Key=0; if(Key=='\r') { if(Edit1->Text=="") Key=0; else{ if(Memo1->Lines->Count<MAX_NIZ)


Application->Title="GRESKA..."; ShowMessage("Prekoracenje memorije niza!!"); Button2->SetFocus(); return; } Edit1->Clear(); } } }}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Memo2->Lines->Clear();

if(Memo1->Lines->Count==0) { Memo1->Lines->Add("Nema niza!!"); }else{ int i,n; n=Memo1->Lines->Count; int x[MAX_NIZ]; for(i=0;i<Memo1->Lines->Count;i++) x[i]=StrToInt(Memo1->Lines->Strings[i]);

if(CheckBox1->Checked==true && CheckBox2->Checked==true) Sazimanje(x,&n,3);

if(CheckBox1->Checked==true && CheckBox2->Checked==false) Sazimanje(x,&n,1);

if(CheckBox1->Checked==false && CheckBox2->Checked==true) Sazimanje(x,&n,2);

Memo2->Lines->Clear(); if(n!=0)

249

{ for(i=0;i<n;i++) Memo2->Lines->Add(IntToStr(x[i])); }else Memo2->Lines->Add("Nema niza!!"); }}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Enabled=true; Edit1->ReadOnly=false; Memo1->Lines->Clear(); Memo2->Lines->Clear(); CheckBox1->Checked=false; CheckBox2->Checked=false; Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 129:Napraviti aplikaciju koja predstavlja kalkulator sa četiri osnovne aritmetičke operacije:

sabiranje, oduzimanje, množenje i deljenje. Prvo se moraju uneti oba operanda pa se tek tada bira operacija pritiskom na odgovarajuće dugme. Tada ako su operandi ispravno uneseni na ekranu će se prikazati rešenje ili poruka o grešci. Aplikacija poseduje i dugme POMOC čijim aktiviranjem pojavljuje se tekst sa opisom šta program radi, pri čemu se tekst ne može menjati niti kopirati deo teksta. Sa dugmetom POVRATAK vraća se na aktivni deo.

Prilikom izrade aplikacije koristiti funkciju provera koja utvrđuje da li je podatak u komponenti Edit za unos vrednosti operanada ispravan. U slučaju da jeste funkcija vraća vrednost true a u suprotnom false.

Rešenje://---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "Memo_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------

250

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ GroupBox2->BringToFront();}//---------------------------------------------------------------------------void __fastcall TForm1::Button6Click(TObject *Sender){ GroupBox1->BringToFront();}//---------------------------------------------------------------------------bool Provera(AnsiString s){ char *p=new char[30]; unsigned i=0; bool rezultat;

if(s=="") return false;

p=StrPCopy(p,s); if(p[0]=='-'||p[0]=='+') i++; if(p[i]=='.'||(p[i]=='0'&&p[i+1]!='.')) rezultat = false; while(p[i]!='\0') { if(!((p[i]>='0'&&p[i]<='9')||p[i]=='.')) return false; i++; }

rezultat = true; delete []p;

return rezultat;}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title=" G R E S K A !!";}//---------------------------------------------------------------------------void __fastcall TForm1::ButtonxClick(TObject *Sender){ bool p=false, q=false; double a, b, rez; unsigned k;

251

TButton* btnx = dynamic_cast<TButton*>(Sender);

p=Provera(Edit1->Text); q=Provera(Edit2->Text);

if(p==false && q==false) { ShowMessage("Uneli ste pogresna oba podatka!!"); Edit1->Text=""; Edit2->Text=""; Edit1->SetFocus(); return; }

if(p==false && q==true) { ShowMessage("Uneli ste pogresan prvi podatak!!"); Edit1->Text=""; Edit1->SetFocus(); return; }

if(p==true && q==false) { ShowMessage("Uneli ste pogresan drugi podatak!!"); Edit2->Text=""; Edit2->SetFocus(); return; }

a=StrToFloat(Edit1->Text); b=StrToFloat(Edit2->Text); if(btnx->Name=="Button2") rez=a+b; if(btnx->Name=="Button3") rez=a-b; if(btnx->Name=="Button4") rez=a*b;

if(btnx->Name=="Button5") { if(b==0) { ShowMessage("Greska!! Deljenje sa nulom!!"); Edit1->Text=""; Edit2->Text=""; Edit1->SetFocus(); return; } rez=a/b; } Label4->Caption=FloatToStr(rez);}//---------------------------------------------------------------------------

252

void __fastcall TForm1::FormAktivate(TObject *Sender){ GroupBox2->BringToFront();}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::Button7Click(TObject *Sender){ Edit1->Text=""; Edit2->Text=""; Label4->Caption="<Ovde ce biti rezultat>"; Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 130:Napisati C program koji predstavlja igru pogađanja zamišljenog broja. Računar je zamislio

broj a korisnik programa (igrač) ima pravo na šest pokušaja da broj pogodi. Računar je zamislio broj iz intervala 1..99. Posle svakog pokušaja u STATUSNOJ LINIJI koja se nalazi pri kraju forme ispisuje se podatak:

> - ako je zamišljeni broj veći od onog kojeg je igrač odigrao,< - ako je zamišljeni broj manji od onog kojeg je igrač odigrao i= - ako je zamišljeni broj pogođen.Po završetku igre igrača iznenaditi nekom zanimljivom porukom pomoću ShowMessage

prozora.

Rešenje:

MessageDlg i MessageDlgPos dijalzi

Za prikazivanje tekstualnih poruka i traženje odgovora od strane korisnika koriste se okviri za dijalog, koji se dobijaju pozivom funkcija MessageDlg, MessageDlgPos i MessageDlgPosHelp.

int __fastcall MessageDlg(constAnsiString Msg, TMsgDlgType DlgType,

TMsgDlgButtons Buttons, int HelpCtx);int __fastcall MessageDlgPos(constAnsiString Msg, TMsgDlgType DlgType,

TMsgDlgButtons Buttons, int HelpCtx, int X, int Y);

253

int __fastcall MessageDlgPosHelp(constAnsiString Msg, TMsgDlgType DlgType, TMsgDlgButtons Buttons, int HelpCtx, int X, int Y, const AnsiString FileName);

Msg – Poruka koja će se ispisati u dijalog prozoru. DlgType – Definiše natpis u naslovnoj liniji okvira i vrstu sličice. Moguće vrednosti su:

mtWarning – upozorenje, mtInformation – informacija, mtCustom – korisnički tip, mtConfirmation – potvrda i mtError – greška.Buttons – Definiše skup dugmadi koji se mogu pojaviti u dijalogu. Moguće vrednosti su:

mbYes, mbNo, mbOK, mbCancel, mbAbort, mbRetry, mbIgnore mbAll i mbHelp.

HelpCts – Odnosi se na priručnu pomoć koja se dobija pritiskom na dugme Help. Ako je vrednost ovog parametra 0 nepostoji priručna pomoć.

X i Y – Koordinate gornjeg levog ugla prozora dijaloga u odnosu na gornji levi ugao ekrana.

FileName – Naziv datoteke u kojoj treba tražiti tekst priručne pomoći.

Funkcija vraća vrednost koja ukazuje na dugme kojim je dijalog prozor zatvoren. Moguće vrednosti su: mrNone, mrOK, mrCancel, mrAbort, mrRetry, mrIgnore, mrYes, mrNo ili mrAll.


#include "zad3za3_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ randomize(); k=6; zbroj=random(99)+1;

Application->Title="GRESKA...";}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){

254

int br; AnsiString ss=Label5->Caption+" ";

br=StrToInt(Edit1->Text); k--; Label2->Caption=IntToStr(k);

if(zbroj==br) { Edit1->Enabled=false;

nt r=MessageDlg("Bravo majstore!!!\nAko hoceš novu igru klikni na dugme Yes.",mtConfirmation,TMsgDlgButtons() << mbYes << mbNo,0);

if(r==mrYes) priprema(); else this->Close(); return; }else{

if(zbroj>br) { ss+="X>"+IntToStr(br)+" "; Label5->Caption=ss; }else{ ss+="X<"+IntToStr(br)+" "; Label5->Caption=ss; }

if(k==0) { Edit1->Enabled=false;

int r=MessageDlg("Bravo majstore!!!\nAko hoceš novu igru klikni na dugme Yes.",mtConfirmation,TMsgDlgButtons() << mbYes << mbNo,0);

if(r==mrYes) priprema(); else this->Close();

return; } }

Edit1->Clear();}//---------------------------------------------------------------------------void TForm1:: priprema(void){ Label2->Caption="6"; Label5->Caption="";

Edit1->Enabled=true; Edit1->Clear(); Edit1->SetFocus();

255

k=6;}//---------------------------------------------------------------------------

Primer 131:Napraviti aplikaciju koja na formi poseduje

Labelu sa tekstom koji pretstavlja broj. Prilikom startovanja aplikacije broj je 20. Font Labele je: veličina 48, podebljano plave boje.

Program poseduje kontekst menisa opcijama: +2 (prečice F1) koja broj uvećava za dva, -2 (prečice F2) koja vrednost broja smanjuje za dva I Znak (prečice F3) koja menja znak broja.

Rešenje:

Komponenta PopupMenu omogućava kreiranje kontekstnog menija koji se pojavljuje kada se klikne desnim tasterom miša iznad komponente kojoj je priključena. Komponenta PopupMenu je tipa TpopupMenu i nalazi se na paleti komponenti kartica Standard.

Komponenta PopupMenu je nevizuelna komponenta. Sada je potrebno definnisati stavke PopUpMenu-ja. Postupak je da se na ikonicu PopupMenu-ja dvostruko klikne i pojaviće se prozor dizajner menija.

U dijalogu dizajnera menija se u svojstvu Caption unosi naziv stavke. Pritiskom na Enter otvara se nova stavka menija. Ako se ispred nekog slova stavke menija nalazi znak &, slovo će biti podvučeno. Ako se u svojstvu Caption stavi samo jedan znak crtica, stavka će

pretstavljati podvučena crta.Kada je stavka menija u dizajner meniju plave boje za datu stavku mogu se podesiti

svojstva koja se na datu stavku odnose. Obavezno se mora podesiti svojstvo PopupMenu komponente nad kojom će se pojaviti kontekst meni desnim klikom miša.

Svojtvo ShortCut omogućava postavljanje tastera prečice date stavke. Svojstvo Bitmap omogućava da se pored imena stavke nalazi sličica. Obavezno podfesiti

da svojstvo AutoPopUp ima vrednost true, što obezbeđuje da se kontekst meni automatski pojavljuje uvek kada se pritisne desni taster miša.

Svojstvo Aligment određuje poziciju pojavljivanja menija. Na visini kursora biće: paLeft (leva ivica menija), paRight (desna ivica menija) ili paCenter (centar gornje ivice menija).

Ako svojstvo Enabled ima vrednost true stavka je dostupna, a u suprotnom ako je false je nedostupna.

Ako je vrednost Visible true stavka je vidljiva, a u suprotnom ako je false je nevidljiva.Osnovni događaj stavke menija je OnClick i dobija se dvostrukim klikom na stavku menija

u dizajner meni prozoru.


256

#include "PopUp_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::N21Click(TObject *Sender){ int br;

br=StrToInt(Label1->Caption); br+=2; Label1->Caption=IntToStr(br);}//---------------------------------------------------------------------------void __fastcall TForm1::N22Click(TObject *Sender){ int br;

br=StrToInt(Label1->Caption); br-=2; Label1->Caption=IntToStr(br);}//---------------------------------------------------------------------------void __fastcall TForm1::Znak1Click(TObject *Sender){ int br;

br=StrToInt(Label1->Caption); br=-br; Label1->Caption=IntToStr(br);}//---------------------------------------------------------------------------

Primer 132:Napraviti aplikaciju koja podešava: boju teksta, font teksta i boju pozadine aplikacije.

Podešavanje fonta vrši se korišćenjem FontDijalog-a, podešavanje boje teksta i pozadine vrši se korišćenjem ColorDialog-a. Izbor podešavanja vrši se korišćenjem pomoćnog menija sa opcijama: Boja teksta(F1), Boja pozadine(F2), Font teksta(F3) i Izlaz(F4).

257

Rešenje:

Komponente FontDijalog i ColorDialog spadaju u standardne diaoške protore. To su nevizuelne komponente. Dijaloške komponente aktiviraju se aktiviranjem njihove metode Execute. Metoda vraća vrednost true ako je korisnik upotrebio prozor za dialog i da ga je zatvorio dugmetom OK. Metoda vraća vrednost false ako je prozor dijaloga zatvoren dugmetom Cancel, pritisnut taster Esc ili kliknuto dugme za zatvaranje prozora.

Font dialog Color dialog

Svojstvo MinFontSize je tipa int i određuje najmanju vrednost veličine slova koju će korisnik moći da odabere, Svojstvo MaxFontSize je tipa int i određuje najveću vrednost veličine slova koju će korisnik moći da odabere,

#include <vcl.h>#pragma hdrstop#include "Boje.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1:: Bojateksta(TObject *Sender){ if(ColorDialog1->Execute()==true) Label1->Font->Color=ColorDialog1->Color;}//---------------------------------------------------------------------------

258

//---------------------------------------------------------------------------void __fastcall TForm1::Bojapozadine1Click(TObject *Sender){ if(ColorDialog1->Execute()==true) Form1->Color=ColorDialog1->Color;}//---------------------------------------------------------------------------void __fastcall TForm1::Fontteksta1Click(TObject *Sender){ if(FontDialog1->Execute()==true) Label1->Font=FontDialog1->Font;}//---------------------------------------------------------------------------void __fastcall TForm1::Izlaz1Click(TObject *Sender){ Form1->Close();}//---------------------------------------------------------------------------

Primer 133:Napraviti aplikaciju koja formira

matricu Panela 5x5, pri čemu su Paneli bele boje, font: veličina 12 podebljano. Natpisi na Panelima su slučajni brojevi sa intervala od 1 do 99.

Program je realizovan tako da za svaki Panel važe opcije kontekst menija, a za Formz ne važi. Izborom opcije iz kontekst menija mogu se promeniti osobine samo Panela koji je prethodno kliknut.

Opcije kontekst menija su: Boja panela (prečica F1), Font panela (prečica F2) i Bojs pozadine (prečica cF3).

Rešenje:

//---------------------------------------------------------------------------#include <vcl.h>#include <stdlib.h>#pragma hdrstop#include "Za_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;TPanel *pom=NULL;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

259

//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ randomize(); for(int i=0;i<5;i++) { for(int j=0;j<5;j++) { TPanel *pn = new TPanel(this); pn->Parent=this;

pn->Width=50; pn->Height=50; pn->Left=10+j*(10+pn->Width); pn->Top=10+i*(10+pn->Height);

pn->Color=clWhite; pn->Caption=IntToStr(random(99)+1); pn->Font->Size=12; pn->Font->Style=TFontStyles()<<fsBold;

pn->PopupMenu=PopupMenu1; pn->OnClick=Klik; } }}//---------------------------------------------------------------------------void __fastcall TForm1::BojapanelaClick(TObject *Sender){ if(pom!=NULL && ColorDialog1->Execute()) { pom->Color=ColorDialog1->Color; pom=NULL; }}//---------------------------------------------------------------------------void __fastcall TForm1::Klik(TObject *Sender){ TPanel *pn=dynamic_cast <TPanel *> (Sender); pom=pn;}//---------------------------------------------------------------------------void __fastcall TForm1::FontpanelaClick(TObject *Sender){ if(pom!=NULL && FontDialog1->Execute()) { pom->Font=FontDialog1->Font; pom=NULL; }}//---------------------------------------------------------------------------

260

//---------------------------------------------------------------------------void __fastcall TForm1::BojapozadineClick(TObject *Sender){ if(pom!=NULL && ColorDialog1->Execute()) { this->Color=ColorDialog1->Color; pom=NULL; }}//---------------------------------------------------------------------------

Primer 134:Napraviti aplikaciju koja se sastoji od niza od 15 Panela svetloplave boje u jednom

redu. Paneli su sa natpisima koji pretstavljaju brojeve dobijene na slučajan način. Program pravi simulaciju ortiranja niza u rastućem redosledu. Klikom na dugme

Novi Niz na natpisima Panela upisuju se novi slučajni brojevi. Klikom na dugme Sortiraj počinje celokupna animacija sortiranja niza. Paneli ne menjaju vrednosti natpisa već se premeštaju animacijom kao na slici. Panel gde bi trebalo das se nalazi spoljašnji indeks sortiranja je plave boje, a Panel gde bi trebao da se nalazi unutrašnji indeks sortiranja je crvene boje. Dok se vrši animacija sortiranja dugmadi su neaktivni.

Akcije se mogu pokrenuti pomoću kontekst menija sa opcijama: Novi Niz (prečica Ctrl+N) i Sortiraj (prečica Ctrl+S). Tokom animacije sortiranja opcije su neaktivne.

Rešenje:


#include "Sopan_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

261

int i, j, n=15, L1, L2, L, k;int b, c;bool p,p1,ps;

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Randomize();

i=-1; //Promenljiva i retstavlja spoljasnji indeks prilikom sortiranja. p=true; //Kontrola kada treba uvecati spoljasnji indeks sortiranja i. p1=true; //Kontrola kada treba dozvoliti promenu vrednosti unutrasnjeg indeksa sortiranja j.}//---------------------------------------------------------------------------void __fastcall TForm1::FormActivate(TObject *Sender){ //Definisem i inicijalizujem niz Panela sa adresama nasih postavljenih Panele. TPanel *Pn[15]={P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15};

//Svim Panelima kao natpise uneti generisane slucajne brojeve. for(int i1=0;i1<15;i1++) { a[i1]=random(100)+random(i1); Pn[i1]->Caption=IntToStr(a[i1]); }}//---------------------------------------------------------------------------void __fastcall TForm1::Tmr1Timer(TObject *Sender){ //Definisem i inicijalizujem niz Panela sa adresama nasih postavljenih Panele. TPanel *Pn[15]={P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15};

if(p==true) { i++; //Uvecava se spoljasnji indeks. p=false; //Zabrana promene spoljasnjeg indeksa. ps=true; //Oznacava da je pocetak unutrasnje iteracije.. }

//Ako je dozvoljena promena unutrasnjeg indeksa j. if(p1==true) { if(ps==true) //Ako je pocetak nove iteracije. { j=i+1; b=StrToInt(Pn[i]->Caption);

262

c=StrToInt(Pn[j]->Caption);

ps=false; //Kraj pocetka iteracije. }else{ j++;

b=StrToInt(Pn[i]->Caption); c=StrToInt(Pn[j]->Caption); }

//Promenljiva n je broj Panela. Prvo podesimo sve Panele da su iste boje i fonta. for (int r=0;r<n;r++) { Pn[r]->Color=clInactiveCaptionText; Pn[r]->Font->Color=clBlack; }

//Menjamo boje i fonta onih Panela na koje pokazuju indeksi i i j. Pn[i]->Color=clBlue; Pn[j]->Color=clRed; Pn[i]->Font->Color=clWhite; Pn[j]->Font->Color=clWhite;

//Pamtim pozicije Panela pre nego sto pocne animacija pomeranja. L1=Pn[i]->Left; L2=Pn[j]->Left; L=Pn[j]->Left-Pn[i]->Left; //koliko je rastojanje koje treba preci animacijom.

k=0; //Brojac iteracija, a krece se od 0 do 10. }

//Uslovi sortiranja. if(j<=n-1) { if(b>c) //Ako je zadovoljeno potrebno je izvrsiti zamenu mesta animacijom. { p1=false; //Zabrana pomeranja i unutrasnjeg indeksa dok traje animacija

//pomeranja.

k++;//Povecavamo iteraciju. Pn[i]->Top=60; //Plavi Panel prilikom pomeranja krece se ispod niza Panela. Pn[j]->Top=180; //Crveni Panel prilikom pomeranja krece se iznad niza Panela.

//Svaki put pomeramo se za jednu desetinu puta, plavi Panel u desno, //a crveni u levo.

Pn[i]->Left=Pn[i]->Left+L/10; Pn[j]->Left=Pn[j]->Left-L/10; }

263

//Ako je proteklo deset koraka pomeranja, treba Panele vratiti u isti nivo.if(k==11)

{ Pn[i]->Caption=IntToStr(c); Pn[j]->Caption=IntToStr(b); Pn[i]->Left=L1; Pn[j]->Left=L2; Pn[i]->Top=120; Pn[j]->Top=120;

p1=true; //Dozvoljava se pomeranje unutrasnjeg brojaca j. k=0; //Resetuje se brojac koraka animacije. } }

//Ako je doslo do kraja unutrasnje iteracije i ne traje animacija, tj dozvoljeno je pomeranje //unutrasnjeg indeksa.

if((j==n-1)&&(p1)) { p=true; //Dozvoljava se promena spoljasnjeg ciklusa. if(i==n-2) { Tmr1->Enabled=false; //Isklucuje se Timer jer je sortiranje zavrseno. Label1->Visible=true; //Ispisuje se poruka da je sortiranje zavrseno. btnNovi->Enabled=true; //Moguce je ponovo starovati sortiranje. NoviNiz1->Enabled=false; //Moguce je generisati novi niz. } }}//---------------------------------------------------------------------------void __fastcall TForm1::btnSortClick(TObject *Sender){ Tmr1->Enabled=true; //Ukljucujemo Timer.

btnNovi->Enabled=false; btnSort->Enabled=false;

NoviNiz1->Enabled=false; Sortiranje1->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::btnNoviClick(TObject *Sender){ //Definisem i inicijalizujem niz Panela sa adresama nasih postavljenih Panele. TPanel *Pn[15]={P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15};

Randomize(); i=-1; p=p1=true;

264

Label1->Visible=false; btnSort->Enabled=true; Sortiranje1->Enabled=true;

for(int i1=0;i1<15;i1++) { a[i1]=random(100)+random(i1); Pn[i1]->Caption=IntToStr(a[i1]); }}//---------------------------------------------------------------------------void __fastcall TForm1::NoviNiz1Click(TObject *Sender){ if(btnNovi->Enabled==true) btnNoviClick(Sender);}//---------------------------------------------------------------------------void __fastcall TForm1::Sortiranje1Click(TObject *Sender){ if(btnSort->Enabled==true) btnSortClick(Sender);}//---------------------------------------------------------------------------

Primer 135:

Aktiviranjem stavke Kraj izlazi se iz programa. Stavka Operacije ima podmeni sa stavkama podeljene u dve grupe razdvojene crtom. Prvu grupu čine stavke: Sabiranje (prečica Ctrl+S), Oduzimanje (prečica Ctrl+O), Mnozenje (Ctrl+M) i Deljenje (prečica Ctrl+D). Drugu grupu čini stavka Brisanje (prečica Ctrl+B) koja briše sva polja Stavka Podesavanja iz glavnog menija sastoji se od stavki: Boja..., Font polja (prečica Ctrl+P) i Zaglavlje koje kada je čekirano u zaglavlju forme piše tekst DIGITRON SA SISTEMOM MENIJA, a u suprotnom nema teksta Stavka Boje... otvara podmeni sa stavkama: Pozadina, Polje Unosa i Polje Resenja.

Rešenje:

Glavni meni je nevizuelna komponenta. Roditelj glavnog menija uvek je forma u kome se on nalazi. Glavni meni je komponenta tipa TmainMenu i za njegovo umetanje za vreme

265

Napraviti aplikaciju koja pretstavlja digitron sa menijima. Digitron se sastoji od dva polja za unos operanada i polja prikaza rešenja. Operandi su racionalni brojevi ii za svako polje unosa postoji zaštita unosa racionalnog broja Polje prikaza rezultata je samo za čitanje. Digitron se sastoji od sistema menija. Glavna linija menija sastoji se od stavki: Operacije, Podesavanja, Abort i Kraj. Otvaranjem polja Abort pojaviće se poruka sa tekstom Posle unetih vrednotsti operanada, izaberite operaciju!!

projektovanja postoji dugme prečice MainMenu na kartici standard na paleti komponenti. Dvostrukim klikom na dugme MaimMenu u toku projektovanja pojaviće se dizajner menija.

Naziv stavke iz linije menija unosi se pomoću svojstva Caption. Pritiskom na taster Enter nakon unosa pojavljuje se nova stavka u liniji menija. Ako se klikne na stavku iz linije menija pojaviće se okvir za unos stavke podmenija. Nakon unosa stavke pritiskom na taster Enter pojaviće se sledeća stavka podmenija. Pritiskom na taster Insert vrši se ubacivanje nove stavke bilo u liniju menija ili kao stavku podmenija. Pritiskom na kombinaciju tastera Ctrl i desna strelica vrsi se obrazovanje potpodmenija. Pritiskom na taster Delete vrši se brisanje stavke menija. Ako se ispred nekog slova stavke menija nalazi znak &, slovo će biti podvučeno. Ako se u svojstvu Caption stavi samo jedan znak crtica, stavka će pretstavljati podvučena crta.

Svojstva:

ImageIndex – Označava indeks slika u listi slika u svojstvu Images.ShorCut – Omogućava izbor tastera prečice za datu stavku.Checked – Označava da li će ispred natpisa stavke stojati znak za potvrdu. Ako ima

vrednost true znak za potvrdu će se pojaviti.


#include "Unit1.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Kraj1Click(TObject *Sender){ this->Close();}//---------------------------------------------------------------------------

266

//---------------------------------------------------------------------------void __fastcall TForm1::Abort1Click(TObject *Sender){ ShowMessage("Posle unetih vrednotstioperanada,\nizaberite operaciju!!");}//---------------------------------------------------------------------------void __fastcall TForm1::OperacijaClick(TObject *Sender){ if(Edit1->Text=="" || Edit2->Text=="") { if(Edit1->Text=="") { ShowMessage("Niste unelo prvi operand!!"); Edit1->SetFocus(); }else{ ShowMessage("Niste unelo drugi operand!!"); Edit2->SetFocus(); } return; }

double a, b, rez;

TMenuItem *btnx = dynamic_cast<TMenuItem*>(Sender);


switch(btnx->Tag) { case 1: rez=a+b; Label1->Caption="+"; break; case 2: rez=a-b; Label1->Caption="-"; break; case 3: rez=a*b; Label1->Caption="*"; break; case 4: Label1->Caption="<"; if(b==0) { ShowMessage("Greska!! Deljenje sa nulom!!"); Edit1->Clear(); Edit2->Clear(); Edit1->SetFocus(); return; } rez=a/b; break; }

267

Edit3->Text=FloatToStr(rez); }//---------------------------------------------------------------------------void __fastcall TForm1::BojaPozadine1Click(TObject *Sender){ if(ColorDialog1->Execute()) this->Color=ColorDialog1->Color;}//---------------------------------------------------------------------------void __fastcall TForm1::BojapoljaUnosa1Click(TObject *Sender){ if(ColorDialog1->Execute()) { Edit1->Color=ColorDialog1->Color; Edit2->Color=ColorDialog1->Color; }}//---------------------------------------------------------------------------void __fastcall TForm1::BojapoljaResenja1Click(TObject *Sender){ if(ColorDialog1->Execute()) Edit3->Color=ColorDialog1->Color;

}//---------------------------------------------------------------------------void __fastcall TForm1::Fontpoljapodataka1Click(TObject *Sender){ if(FontDialog1->Execute()) { Edit1->Font=FontDialog1->Font; Edit2->Font=FontDialog1->Font; Edit3->Font=FontDialog1->Font; }}//---------------------------------------------------------------------------void __fastcall TForm1::Brisanje1Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Edit3->Clear();

Label1->Caption="?"; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='+' && Key!='-' && Key!='.') Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); AnsiString s=ed->Text;

if((Key!='.' && Key!=8) && (s=="0" || s=="+0" || s=="-0")) Key=0;

268

switch(Key) { case '+': case '-': if(s!="") Key=0; break; case '.': int k=s.Pos("."); if(k!=0 || s=="" || s=="+" || s=="-") Key=0; break; } }}//---------------------------------------------------------------------------void __fastcall TForm1::ZaglavljeClick(TObject *Sender){ if(Zaglavlje->Checked==false) { Zaglavlje->Checked=true; this->Caption="DIGITRON SA SISTEMOM MENIJA"; }else{ Zaglavlje->Checked=false; this->Caption=""; }}//--------------------------------


koja poseduje sistem menija za podešavanje fonta i boje Panela.

Na formi postojie dva Panela kao na slici. Glavi meni sastoji se od stavki: Prvi, Drugi i Obe. Stavka Prvi odnosi se na prvi Panel, stavka Drugi na drugi Panel i stavka Obe na oba Panela. Stavkama se aktivira podmeni sa stavkama Boja i Font. Program poseduje i kontekst meni sastavljen od dve grupe. Prva grupa sastoji se samo od jedne stavke čiji natpis može biti: Prvi Panel, Dtrugi Panel ili Oba Panela. Druga grupa sastoji se od dve stavke: Boja... i Font....

Aktiviranjem stavke Boja otvara se Color dialog, dok izborom stavke Font otvara se Font dialog. Program mora zadovoljiti sledeće uslove: Sve opcije iz glavnog menija stavke Prvi moći će se koristiti ako se kursor miša nalazi nad prvim Panelom. Sve opcija iz glavnog menija stavke Drugi moći će se koristiti ako se kursor miša nalazi nad drugim Panelom. Sve opcije iz glavnog menija stavke Obe moći će se koristiti ako se kursor miša nalazi nad formom a ne nad nekim Panelom. Ako se miš nalazi nad prvim Panelom aktiviranjem kontekst menija stavka iz prve grupe imaće natpis Prvi Panel. Ako se miš nalazi nad drugim Panelom aktiviranjem kontekst menija stavka iz prve grupe imaće natpis Drugi Panel. Ako se miš ne nalazi nad Panelima več formom aktiviranjem kontekst menija stavka iz prve grupe imaće natpis Oba Panela.

Rešenje:


269

#include "MenLab_o.h"


bool prvi, drugi; //---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::BojaPrviogClick(TObject *Sender){ if(cdBoja->Execute()) lblPrvi->Color=cdBoja->Color;}//---------------------------------------------------------------------------void __fastcall TForm1::FontPrvogClick(TObject *Sender){

if(FontDialog1->Execute()) lblPrvi->Font=FontDialog1->Font;}//---------------------------------------------------------------------------void __fastcall TForm1::BojaDrugogClick(TObject *Sender){

if(cdBoja->Execute()) lblDrugi->Color=cdBoja->Color;}//---------------------------------------------------------------------------void __fastcall TForm1::FontDrugogClick(TObject *Sender){ if(FontDialog1->Execute()) lblDrugi->Font=FontDialog1->Font;}//---------------------------------------------------------------------------void __fastcall TForm1::BojaObaClick(TObject *Sender){ if(cdBoja->Execute()) { lblPrvi->Color=cdBoja->Color; lblDrugi->Color=cdBoja->Color; }}//---------------------------------------------------------------------------void __fastcall TForm1::FontObaClick(TObject *Sender){ if(FontDialog1->Execute()) { lblPrvi->Font=FontDialog1->Font; lblDrugi->Font=FontDialog1->Font; }}//---------------------------------------------------------------------------

270

//---------------------------------------------------------------------------void __fastcall TForm1::BojaLab4Click(TObject *Sender){ if(cdBoja->Execute()) { if(B1) lblPrvi->Color=cdBoja->Color; if(B2) lblDrugi->Color=cdBoja->Color; }}//---------------------------------------------------------------------------void __fastcall TForm1::lblPrviMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y){ if(Button==mbRight) { prvi=true,, drugi=falseč; Prvi3->Caption="Prvi Panel"; }}//---------------------------------------------------------------------------void __fastcall TForm1::lblDrugiMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y){ prvi=false, drugi=true; Prvi3->Caption="Drugi Panel";}//---------------------------------------------------------------------------void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y){ prvi=true, drugi=true; Prvi3->Caption="Oba Panela";}//---------------------------------------------------------------------------void __fastcall TForm1::BojaSlova4Click(TObject *Sender){ if(FontDialog1->Execute()) { if(prvi) lblPrvi->Font=FontDialog1->Font; if(drugi) lblDrugi->Font=FontDialog1->Font; }}//---------------------------------------------------------------------------

Primer 137:Napraviti aplikaciju koja predstavlja igricu Pogađanje palete boja. U naslovu igrice

nalaze se krugovi različitih boja na kojima pišu brojevi od 1 do 5. Računar je generisao paletu boja (sastoji se od četiri boje). Paleta se formira pomoću tastature ili miša. Boja se pomoću tastature bira pritiskom na jedan od tastera sa brojevima od 1 do 5, dok se pomoću miša unosi klikom na odgovarajući kružić sa brojevima iz naslova. Nakon unesene palete boja računar sa

271

desne strane prikazuje koliko je bilo pogodaka na mestu (crveni kružić) i koliko pogodaka je bilo a da nisu na mestu (beli kružić).

Igrica se završava sa igrom ako se u toku 7 pokušaja (paleta) ne pogodi dobitna paleta, ili ako seun nekom od pokušaja pogodi paleta boja. Po završetku igre prikazuje sedobitna paleta boja i odgovarajuća poruka.

Igrica sadrži liniju menija sa poljima File i Help. Padajući meni File sadrži opcije New Game čija je prečica F2 (pokretanje nove igrice) i Exit (izlazak iz programa). Meni Help sadrži dva polja: Poodaci o igri i Pomoć.

R

Rešenje

Komponentom Shape može se prikazati jedna od nekoliko osnovnih oblika, kao što su kvadrat, pravougaonik, krug i elipsa. Veličina oblika je određena veličinom komponente, i može biti popunjen i uokviren popunama i linijama različite boje i vrste.

Komponenta Shape nalazi se na paleti komponenti kartica Addiotional i tipa je TShape.

Svojstva:

272

Brush – Ovim svojstvom definiše se boja pošpunjavanja oblika i način popune. Pen – Definiše se boja, vrsta i debljina okvira oblika.Shape - Definiše se vrsta oblika koji se iscrtava. Mogući oblici su: stEllipse (elipsa),

stRestangle (pravougaonik), stRoandRect (pravougaonik sa zaobljenim uglovima), stRoandSquare (kvadrat sa zaobljenim uglovima) stSquare (kvadrat) i stCircle (krug).

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Duga.h"


TShape *pok[61];int niz1[4],niz2[4];int i;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ randomize(); Application->Title="Duga";

//Ukupno se na paletama moze pojaviti 60 Shape-ova pok[1]=Shape1; pok[2]=Shape2; pok[3]=Shape3; pok[4]=Shape4; pok[5]=Shape5; pok[6]=Shape6; pok[7]=Shape7; pok[8]=Shape8; pok[9]=Shape9; pok[10]=Shape10; pok[11]=Shape11; pok[12]=Shape12; pok[13]=Shape13; pok[14]=Shape14; pok[15]=Shape15; pok[16]=Shape16; pok[17]=Shape17; pok[18]=Shape18; pok[19]=Shape19; pok[20]=Shape20; pok[21]=Shape21; pok[22]=Shape22; pok[23]=Shape23; pok[24]=Shape24; pok[25]=Shape25; pok[26]=Shape26; pok[27]=Shape27; pok[28]=Shape28; pok[29]=Shape29; pok[30]=Shape30; pok[31]=Shape31; pok[32]=Shape32; pok[33]=Shape33; pok[34]=Shape34; pok[35]=Shape35; pok[36]=Shape36; pok[37]=Shape37; pok[38]=Shape38; pok[39]=Shape39; pok[40]=Shape40; pok[41]=Shape41; pok[42]=Shape42; pok[43]=Shape43; pok[44]=Shape44; pok[45]=Shape45; pok[46]=Shape46; pok[47]=Shape47; pok[48]=Shape48; pok[49]=Shape49; pok[50]=Shape50; pok[51]=Shape51; pok[52]=Shape52; pok[53]=Shape53; pok[54]=Shape54;

273

pok[55]=Shape55; pok[56]=Shape56; pok[57]=Shape57; pok[58]=Shape58; pok[59]=Shape59; pok[60]=Shape60;

//Na slucajan nacin formira se dobitna kombinacija. int k = 0,m; while(k < 5) { do{ m=random(6); }while(m<1); niz1[k]=m; k++; } i=1;}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::boja(TObject *Sender, char &Key){ int m=0,n=0,j,k,l=0,p[4];

//Kombinacija se moze unositi pomocu tastature, pritiskom na tastere od 1 do 5. //Promenljiva m se moze kretati od 0 do 3. m=(i-1)%4; for(j=0;j<4;j++) p[j]=9;

//Ukupno ima 28 Shapeova na 7 paleta. Niz niz sadrzace cetiri izabrane boje. if(i<29) { if(Key=='1'){ pok[i]->Brush->Color=clRed,i++; niz2[m]=1; } if(Key=='2'){ pok[i]->Brush->Color=clBlue,i++; niz2[m]=2; } if(Key=='3'){ pok[i]->Brush->Color=clYellow,i++; niz2[m]=3; } if(Key=='4'){ pok[i]->Brush->Color=clGreen,i++; niz2[m]=4; } if(Key=='5'){ pok[i]->Brush->Color=clFuchsia,i++; niz2[m]=5; } }

274

//Ako promenljiva m ima vrednost 3, znak je da je odabrana ctvrta boja sa palete. //Utvrdjuje se koje su boje pogodjene i koje se nalaze na mestu, a koliko njih je //pogodjeno a da se ne nalazi na mestu. if(m==3){ n=0; for(j=0;j<4;j++) { //Ispituje se direktan pogodak i odredjeni krug ce se prikazati crvenom bojom. if(niz1[j]==niz2[j]) pok[i+n+24]->Brush->Color=clRed,n++;

//Sada se utvrdjuje da li postoje pogoci a da nisu na mestu. if(niz1[j]!=niz2[j]) { for(k=0;k<4;k++) { if(niz2[j]==niz1[k]&&niz2[k]!=niz1[k]&&

p[0]!=k&&p[1]!=k&&p[2]!=k&&p[3]!=k) { //Niz p sadrzace vrednost broja od 1 do 4, dok ce promenljiva l //saopstavati koliko ima pogodaka a da nisu na mestu. p[l]=k; k=4; l++; } } } } //Odredjeni krugovi postaju vidljivi. for(j=0;j<(l+n);j++) pok[i+j+24]->Visible=true; }

//Ako je i=29 znak je da je igra zavrsena, a ako je n=4 znak je da je paleta boja pogodjena. if(i==29||n==4) { i=29;

//Poslednja cetiri Shaepova odnose se na prikaz dobitne kombinacije. for(j=0;j<4;j++) { Shape57->Visible=true; Shape58->Visible=true; Shape59->Visible=true; Shape60->Visible=true; Panel9->Visible=true;

if(niz1[j]==1)pok[57+j]->Brush->Color=clRed; if(niz1[j]==2)pok[57+j]->Brush->Color=clBlue; if(niz1[j]==3)pok[57+j]->Brush->Color=clYellow; if(niz1[j]==4)pok[57+j]->Brush->Color=clGreen; if(niz1[j]==5)pok[57+j]->Brush->Color=clFuchsia; }

275

}}//---------------------------------------------------------------------------void __fastcall TForm1::Newgame1Click(TObject *Sender){ //Ako se iz menija izabere nova igra. randomize(); i=1; int k = 0,m; while(k < 5) { do{ m=random(6); }while(m<1); niz1[k]=m; k++; }

//Podese se da svi krugovi budu bele boje. for(int j=1;j<57;j++)pok[j]->Brush->Color=clWhite;

//Krugovi gde ce se prikazati rezultat se sakrivaju. for(int j=29;j<57;j++)pok[j]->Visible=false;; Shape57->Visible=false; Shape58->Visible=false; Shape59->Visible=false; Shape60->Visible=false; Panel9->Visible=false;}//---------------------------------------------------------------------------void __fastcall TForm1::Exit1Click(TObject *Sender){ exit(1);}//---------------------------------------------------------------------------void __fastcall TForm1::About1Click(TObject *Sender){ //Prikazuje se dijalog sa porukom ko je autor igrice. ShowMessage("CSoft Duga Version 1.0\n\nProduced by ChileSoftware\n\

nVeternik,Serbia and Montenegro\n04.02.2006");}//---------------------------------------------------------------------------void __fastcall TForm1::Pomoc1Click(TObject *Sender){ //Izborom stavke pomoc iz menija, bice prikazano upustvo //za koriscenje ove igrice. Memo1->Visible=true; Button1->Visible=true; Panel9->Visible=false;}

276

//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ Memo1->Visible=false; Button1->Visible=false;

//Ako se klikne na dugme za poratak u igru, potrebno je pokrenuti dogadjaj //za pocetak nove igre, koji je deo opcije iz menija. Newgame1Click(Sender);}//---------------------------------------------------------------------------void __fastcall TForm1::klik(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y){ int m=0,n=0,j,k,l=0,p[4];

//Igrica se moze igrati i pomocu misa, tako sto ce se kliknuti na //odredjeni krug sa brojem koji se nalazi umesto naslova igrice. m=(i-1)%4;

for(j=0;j<4;j++) p[j]=9;

//Na osnovu parametra Sender prosledjeno je sta je kliknuto, komponenta //Label ili komponenta Shape. if(i<29) { if(Sender==Label1||Sender==Shape64){ pok[i]->Brush->Color=clRed,i++; niz2[m]=1; } if(Sender==Label6||Sender==Shape63){ pok[i]->Brush->Color=clBlue,i++; niz2[m]=2; } if(Sender==Label2||Sender==Shape62){ pok[i]->Brush->Color=clYellow,i++; niz2[m]=3; } if(Sender==Label3||Sender==Shape61){ pok[i]->Brush->Color=clGreen,i++; niz2[m]=4; }

if(Sender==Label4||Sender==Shape65) {

pok[i]->Brush->Color=clFuchsia,i++; niz2[m]=5; } }

if(m==3){ n=0;

277

for(j=0;j<4;j++) { if(niz1[j]==niz2[j]) pok[i+n+24]->Brush->Color=clRed,n++; if(niz1[j]!=niz2[j]) { for(k=0;k<4;k++) { if(niz2[j]==niz1[k]&&niz2[k]!=niz1[k]&&

p[0]!=k&&p[1]!=k&&p[2]!=k&&p[3]!=k) { p[l]=k, k=4, l++; } } } } for(j=0;j<(l+n);j++) pok[i+j+24]->Visible=true; }

if(i==29||n==4) { i=29; for(j=0;j<4;j++) { Shape57->Visible=true; Shape58->Visible=true; Shape59->Visible=true; Shape60->Visible=true; Panel9->Visible=true;

if(niz1[j]==1)pok[57+j]->Brush->Color=clRed; if(niz1[j]==2)pok[57+j]->Brush->Color=clBlue; if(niz1[j]==3)pok[57+j]->Brush->Color=clYellow; if(niz1[j]==4)pok[57+j]->Brush->Color=clGreen; if(niz1[j]==5)pok[57+j]->Brush->Color=clFuchsia; } }}//---------------------------------------------------------------------------

Primer 138:Napraviti aplikaciju koja omogućaba

unos imena korisnika aplikacije i nakon pritiska na taster POTVRDI predaje korisniku pozdravnu poruku. U slučaju da korisnik nije uneo svoje ime umesto pozdravne poruke dobija informaciju o grešci.

Poruke predstaviti korišćenjem nove forme.

278

Rešenje

U dosadašnjim primerima koristili smo samo jednu formu. Ako se želi koristiti više formi potrebno je formirati novu formu izborom opcije File->New->Form. Formiraće se nova forma pod nazivom Form2. Ako se postupak ponovi formiraće se nova forma pod nazivom Form3, itd.

Izborom dijaloga ProjectOptions (Project->Options) možete izvršiti podešavanje parametara projekta. Prva kartica Forms, služi za određivanje načina korišćenja formi. Mi smo u ovom primeru formirali dve forme: Form1 i Form2. U polju Main Form upisuje se naziv glavnog obrasca, tj onog koji će se videti prilikom pokretanja aplikacije. Okvir sa listom Auto create forms sadrži imena obrazaca koji se kreiraju automatski.

Prvi u toj listi je glavni obrazac. Okvir sa listom Available forms sadrži nazive onih formi sadrži raspoložive obrasce koji se ne stvaraju automatski na početku izvršavanja aplikacije.

Metode forme:

Create – Omogućava kreiranje forme i pozivanje OnClose događaja.Release – Uništava se obrazac i oslobađa se memorija koju je on zauzeo. Za razliku od

metode Free Realese metoda čeka da se završe svi događaji forme i pripadajućih komponenti.

Show – Bez ikakvog uslova omogućava da forma za koji se pozove postane vidljiv, tj da je u žiži.

ShowModal – Prikazuje formu u modalnom stanju, odnosno iz forme se ne može izaći dok se ne zatvori.

Hide – Omogućava da prozor za koji se pozove postane nevidljiv.Close – Za glavnu formu predstavlja uništavanje, a za sekundarne forme njihovo skrivanje.CloseQuery – Ova metoda poziva događaj OnCloseQuery i vraća vrednost true ili false u

zavisnosti od dozvole za zatvaranje forme.CreateNew – Kreira novu formu istog tipa kao i forma čiji se CreateNew metod poziva.

Događaji forme:

OnActivate – Nastaje kada forma primi fokus.OnClose – Poziva se kada se forma zatvara. Pre ovog događaja uvek se automatski poziva

događaj OnCloseQuery.OnCloseQuery – U njemu se programski može onemogućiti izvršavanje događaja OnClose

u slučaju da se iz nekih razloga zabrani zatvaranje forme.OnCreate – Poziva se kada se forma prvi put kreira.OnHide – Poziva se kada forma postane nevidljiva pozivom metode Hide ili postavljanjem

Visible svojstva na false. Forma i dalje postoji i mogu joj se menjati svojstva i izvršavati metode, ali nije vidljiva na ekranu.

OnShow – Poziva se kada forma postane vidljiva.OnResize – Poziva se svaki put kada forma promeni veličinu.

Pozdravna_poruka_o.cpp//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

279

#include "Pozdravna_poruka_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") { s="Greska!!\nNiste uneli svoje ime?"; Form2->Label1->Caption=s; Form2->Left=Form1->Left+Form1->ClientWidth +10; Form2->ShowModal(); //Form2 postaje aktivna. Edit1->SetFocus(); }else{ s= "Zdravo "+Edit1->Text+"!!"; Form2->Label1->Caption=s; Form2->Left=Form1->Left+Form1->ClientWidth+10; Form2->ShowModal(); //Form2 postaje aktivna. Edit1->Text=""; Edit1->SetFocus(); }}//---------------------------------------------------------------------------

Pozdravna_poruka_o.h//---------------------------------------------------------------------------#ifndef Pozdravna_poruka_oH#define Pozdravna_poruka_oH//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <StdCtrls.hpp>#include <Forms.hpp>#include "Poruka.h" //Mora se ukljuciti zaglavlje druge forme ako pokazivac

//Form2 mislite koristiti u unitu koji opisuje prvu formu.//---------------------------------------------------------------------------class TForm1 : public TForm{

__published: // IDE-managed Components TLabel *Label1; TEdit *Edit1; TButton *Button1; void __fastcall Button1Click(TObject *Sender);

private: // User declarations

280

public: // User declarations AnsiString s; //Promenljiva s je javni atribut klase Tform1, te je kao takav dostupan i

//drugoj formi. __fastcall TForm1(TComponent* Owner);};//---------------------------------------------------------------------------extern PACKAGE TForm1 *Form1;//---------------------------------------------------------------------------#endif

Poruka.cpp//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm2 *Form2;//---------------------------------------------------------------------------__fastcall TForm2::TForm2(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm2::Button1Click(TObject *Sender){ Form2->Close(); //Obezbedjuje se zatvaranje druge forme.}//---------------------------------------------------------------------------

Primer 139:Napraviti aplikaciju koja radi sa dve forme. Prilikom klika na dugme Formiraj dinamički

se formira druga forma gde se izvrši poodešavanje parametara formiranja matrice Panela (Broj vrsta, Broj kolona, Boja klikom na beli Panel gde piše boja, čime se aktivira Color dialog) . Klikom na dugme Potvrdi forma se dinamički briše iz memorije, a potomm na osnovu parametara formira matrica Panela. Klikom na dugme odustani Paneli se neće formirati.

281

Rešemje:

Bitno svojstvo dugmeta Button je ModalRezult sa dve najvažnije vredmosti mrOK i mrCancel. Nakon klika na dugme forma se zatvara I vraća rezultat koji je u svojstvu ModalRezult podešen.

Forma 2//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "upustvo.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm2 *Form2;//---------------------------------------------------------------------------__fastcall TForm2::TForm2(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm2::Panel1Click(TObject *Sender){ if(ColorDialog1->Execute()) { Panel1->Color=ColorDialog1->Color; }}//---------------------------------------------------------------------------

Forma 1://---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "dinform_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender)

282

{Form2 = new TForm2(this);

if(Form2->ShowModal()==mrOk){

int brv,brk,vis,sir;

brv=StrToInt(Form2->Edit1->Text); brk=StrToInt(Form2->Edit2->Text);

sir=(Panel1->Width-10-brk*10)/brk; vis=(Panel1->Height-10-brv*10)/brv;

for(int i=1;i<=brv;i++) for(int j=1;j<=brk;j++) { TPanel *pan = new TPanel(Panel1); pan->Parent=Panel1;

pan->Width=sir; pan->Height=vis; pan->Left=10+(j-1)*(sir+10); pan->Top=10+(i-1)*(vis+10); pan->Color=Form2->Panel1->Color; } }

Form2->Free();}//----------------------------------------

Primer 140:Napraviti aplikaciju koja se

sastoji od dva polja, prvi za unos teksta, a drugi za prikaz kopije teksta. Drugo polje je sive boje i iz njega se može samo čitati sadržaj. Na formi se nalaze i tri dugmeta koja su neaktivna prilikom startovanja aplikacije. Čim se promeni sadržaj prvog unosa (tj polje sadrži neki tekst) aktivira se dugme KOPIJA i dugme BRISANJE. Klikom na dugme KOPIJA tekst prvog polja se upisuje u drugo polje i dugme ZAMENA postaje aktivno. Klikom na dugme ZAMENA menja se sadržaj polja i to pod uslovom da polja nemaju isti sadržaj, dok se u suprotnom prijavljuje poruka o grešci.

Klikom na dugme BRISANJE briše se sadržaj oba polja i sva tri dugmeta postaju neaktivna.

Program sadrži meni i kontekst meni sa potpuno istim stavkama: Kopiranje (prečica Ctrl+C), Zamena (prečica Ctrl+B) i Brisanje (prečica Del) Koje dugme se može koristiti je povezano sa menijima (ako je dugme Kopiranje neaktivno, sive boje, automatski je neaktivna i stavka iz menija Kopiranje). U realizaciji programa obavezno koristiti komponentu ActionList.

283

Rešemje:

Komponenta ActionList nalazi se na Standard traci sa alatkama. Komponenta sadrži spisak akcija koje se mogu desiti. Prednost korišćenja ove komponente je u tome što pre nego što se desi događaj akcije proveravaju se uslovi od svih akcija automatski tako da programmer ne mora da voidi računa o tome.

Akcije se u listu akcija dodaju tako što se duplo klikne na komponentu nakon čega se pojavljuje Edit prozor sa slike:

Klikom na dugme NewAction dodaje se akcija a sa DeleteAction briše se sa spiska odabrana akcija.

Nakon dodavanja akcija potrebno je svaku akciju povezati sa nekom komponentom, a to

se radi pomoću svojstva Action od komponente nad kojom će se akcija odvijati.

Dva osnovna događaja komponente ActionList su OnUpdate i OnExecute.Događajem OnUpdate kontroliše se uslov koji je potreban da komponenta postane

aktivna nad kojom da bi se uopšte akcija mogla sprovesti. Događaj OnExecute vrši sprovođenje akcije.

U ovom primeru svojstva Action dugmeta sa natpisom Kopiranje, stavke Kopiranje iz menija i stavke Kopiranje iz kontekst menija imaju ime Kopiranje, a stavka ActionListe je akcija sa imenom Kopiranje. Ovim smo povezali dugme, stavku iz menija i stavku iz kontekst menija, tako da će reagovati sve na istu akciju preko događaja OnExecute I biti istovremeno aktivne ili neaktivne na osnovu automatske provere putem događaja OnUpdate.


#include "za30_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::KopiranjeUpdate(TObject *Sender){ if(Edit1->Text!="" && Edit2->Text=="") Kopiranje->Enabled=true; else Kopiranje->Enabled=false;}

284

//---------------------------------------------------------------------------void __fastcall TForm1::KopiranjeExecute(TObject *Sender){ Edit2->Text=Edit1->Text;}//---------------------------------------------------------------------------void __fastcall TForm1::ZamenaExecute(TObject *Sender){ AnsiString pom;

pom=Edit1->Text; Edit1->Text=Edit2->Text; Edit2->Text=pom;}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::ZamenaUpdate(TObject *Sender){ if(Edit1->Text!="" && Edit2->Text!="" && Edit1->Text!=Edit2->Text)

Zamena->Enabled=true; else Zamena->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::BrisanjeExecute(TObject *Sender){ Edit1->Clear(); Edit2->Clear();}//---------------------------------------------------------------------------void __fastcall TForm1::BrisanjeUpdate(TObject *Sender){ if(Edit1->Text!="" || Edit2->Text!="") Brisanje->Enabled=true; else Brisanje->Enabled=false;}//---------------------------------------------------------------------------

Primer 141:

285

Napraviti aplikaciju koja pretstavlja digitron sa menijima. Digitron se sastoji od dva polja za unos operanada i polja prikaza rešenja. Operandi su racionalni brojevi i za svako polje unosa postoji zaštita unosa racionalnog broja Polje prikaza rezultata je samo za čitanje. Digitron se sastoji od sistema menija. Glavna linija menija sastoji se od stavki: Operacije, Podesavanja, Abort i Kraj. Otvaranjem polja Abort pojaviće se poruka sa tekstom Posle unetih vrednotsti operanada, izaberite operaciju!!

Aktiviranjem stavke Kraj izlazi se iz programa. Stavka Operacije ima podmeni sa stavkama podeljene u dve grupe razdvojene crtom. Prvu grupu čine stavke: Sabiranje (prečica Ctrl+S), Oduzimanje (prečica Ctrl+O), Mnozenje (Ctrl+M) i Deljenje (prečica Ctrl+D). Drugu grupu čini stavka Brisanje (prečica Ctrl+B) koja briše sva polja Stavka Podesavanja iz glavnog menija sastoji se od stavki: Boja..., Font polja (prečica Ctrl+P) i Zaglavlje koje kada je čekirano u zaglavlju forme piše tekst DIGITRON SA SISTEMOM MENIJA, a u suprotnom nema teksta Stavka Boje... otvara podmeni sa stavkama: Pozadina, Polje Unosa i Polje Resenja.

Aktiviranjem stavke Upustvo pojavljuje se novi prozor sa upustvom o koriščenju digitrona. Operacije Sabiranje, Oduzimanje, Množenje i Deljenje realizovati korišćenjem komponente ActionList.

Rešemje:

Komponenta BitBtn je dugme sa slikom I nalazi se na kartici Additional. Svojstvo Kind određuje vrstu dugmeta. Ako ima vrednost bkCustom označava da je

dugmetu sliku pridružio programer. Svojstvo Layout određuje položaj slike i teksta na dugmetu: blGlyphLeft (slika se nalazi

levo od natpisa), blGlyphRight (slika se nalazi desno od natpisa). Slika se podrazumevano nalazi levo od natpisa.

Svojstvo Margin je tipa int i određuje razmak između slike i ivice dugmeta.Svojstvo Spacing je tipa int i određuje razmak između slike i natpisa.


#include "Unit1.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Kraj1Click(TObject *Sender){ this->Close();}//---------------------------------------------------------------------------void __fastcall TForm1::Abort1Click(TObject *Sender){ Application->Title = "DIGITRON"; ShowMessage("Posle unetih vrednotstioperanada,\nizaberite operaciju!!");}//---------------------------------------------------------------------------

286

void __fastcall TForm1::BojaPozadine1Click(TObject *Sender){ if(ColorDialog1->Execute()) this->Color=ColorDialog1->Color;}//---------------------------------------------------------------------------void __fastcall TForm1::BojapoljaUnosa1Click(TObject *Sender){ if(ColorDialog1->Execute()) { Edit1->Color=ColorDialog1->Color; Edit2->Color=ColorDialog1->Color; }}//---------------------------------------------------------------------------void __fastcall TForm1::BojapoljaResenja1Click(TObject *Sender){ if(ColorDialog1->Execute()) Edit3->Color=ColorDialog1->Color;}//---------------------------------------------------------------------------void __fastcall TForm1::Fontpoljapodataka1Click(TObject *Sender){ if(FontDialog1->Execute()) { Edit1->Font=FontDialog1->Font; Edit2->Font=FontDialog1->Font; Edit3->Font=FontDialog1->Font; }}//---------------------------------------------------------------------------void __fastcall TForm1::Brisanje1Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Edit3->Clear(); Label1->Caption="?"; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='+' && Key!='-' && Key!='.') Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); AnsiString s=ed->Text;

if((Key!='.' && Key!=8) && (s=="0" || s=="+0" || s=="-0")) Key=0; switch(Key) { case '+': case '-': if(s!="") Key=0; break; case '.': int k=s.Pos(".");

287

if(k!=0 || s=="" || s=="+" || s=="-") Key=0; break; } }}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::ZaglavljeClick(TObject *Sender){ if(Zaglavlje->Checked==false) { Zaglavlje->Checked=true; this->Caption="DIGITRON SA SISTEMOM MENIJA"; }else{ Zaglavlje->Checked=false; this->Caption=""; }}//---------------------------------------------------------------------------void __fastcall TForm1::SaberiUpdate(TObject *Sender){ if(Edit1->Text=="" || Edit2->Text=="") { Saberi->Enabled=false; Oduzmi->Enabled=false; Mnozi->Enabled=false; Deli->Enabled=false; }else{ Saberi->Enabled=true; Oduzmi->Enabled=true; Mnozi->Enabled=true; Deli->Enabled=true; }}//---------------------------------------------------------------------------void __fastcall TForm1::SaberiExecute(TObject *Sender){ double a, b, rez;

a=StrToFloat(Edit1->Text); b=StrToFloat(Edit2->Text); rez=a+b; Label1->Caption="+"; Edit3->Text=FloatToStr(rez);}//---------------------------------------------------------------------------void __fastcall TForm1::OduzmiExecute(TObject *Sender)

288

{ double a, b, rez;

a=StrToFloat(Edit1->Text); b=StrToFloat(Edit2->Text); rez=a-b; Label1->Caption="-"; Edit3->Text=FloatToStr(rez);}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::MnoziExecute(TObject *Sender){ double a, b, rez;

a=StrToFloat(Edit1->Text); b=StrToFloat(Edit2->Text); rez=a*b; Label1->Caption="*"; Edit3->Text=FloatToStr(rez);}//---------------------------------------------------------------------------void __fastcall TForm1::DeliExecute(TObject *Sender){ double a, b, rez;


Label1->Caption=":"; if(b==0) { ShowMessage("Greska!! Deljenje sa nulom!!"); Edit1->Clear(); Edit2->Clear(); Edit1->SetFocus(); return; }

rez=a/b; Edit3->Text=FloatToStr(rez);}//---------------------------------------------------------------------------void __fastcall TForm1::Help1Click(TObject *Sender){ Form2 = new TForm2(this);

Form2->ShowModal(); Form2->Free();

289

}//---------------------------------------------

Primer 142:Napraviti aplikaciju koja prilikom startovanja aplikacije iz datoteke SPISAK.TXT učitava

redove i smešta ih kao stavke ComboBox-a, pri čemu se prva stavka vidi u polju unosa ComboBox-a..

Postoji polje za unos nove stavke, a to je Edit komponenta. Pritiskom na dugme UNESI, sadržaj Edit komponente ako nije prazan i nema ga već među stavkama ComBox-a, se prenosi među stavke ComboBox-a i prikazuje u polju C omboBox-a, a ako takve stavke ima prikazuje se poruka o greški.

Postoji i polje za unos stavke koja treba da se izbriše iz ComboBox-a. Pritiskom na dugme BRISI, ako stavka postoji u ComboBox-u, biće iz ComboBox-a izbrisana, a u suprotnom će se prijaviti poruka o greški.

Klikom na neku stavku, sadržaj stavke se upisuje u drugi Efdit.Zatvaranjem prozora aplikacije celokupni sadržaj stavki ComboBoxa se upisuju u datoteku

STAVKE.TXT.

Rešenje


#include "txt.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ ComboBox1->Items->LoadFromFile("SPISAK.TXT"); ComboBox1->ItemIndex=0; Application->Title="GRESKA...";}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="")ShowMessage("Greshka!'"); else{ int i=0; while(i<ComboBox1->Items->Count &&

Edit1->Text!=ComboBox1->Items->Strings[i]) i++;

if(i==ComboBox1->Items->Count)

290

{ ComboBox1->Items->Add(Edit1->Text); ComboBox1->Text=Edit1->Text; }else ShowMessage("Stavka "+Edit1->Text+" vec postoji u listi!!"); Edit1->Clear(); }}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action){ ComboBox1->Items->SaveToFile("SPISAK.TXT");}//---------------------------------------------------------------------------void __fastcall TForm1::ComboBox1Click(TObject *Sender){ Edit2->Text=ComboBox1->Text;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ int i=0; while(i<ComboBox1->Items->Count &&

Edit2->Text!=ComboBox1->Items->Strings[i]) i++;

if(i<ComboBox1->Items->Count) { ComboBox1->Items->Delete(ComboBox1->ItemIndex); Edit2->Clear(); }else ShowMessage("Stavka "+Edit1->Text+" ne postoji u listi!!");}//---------------------------------------------------------------------------

291


koja će predstavljati poznatu dečiju igru vešalica. Igrica se igra dok se ne pogodi odgovarajući predmet, biljka, životinja, grad ili država. Na slučajan način se bira šta će se pogađati iz tekstualne datoteke.

Svaki red tekstualne datoteke sastoji se od jednog pojma koga treba pogađati i to oblika slovo na šta se pogađanje odnosi zarez i šta se pogađa. Slovo može biti:P – predmet, Ž – životinja, G – grad, B – biljka i D – država.

Prvi red datoteke sadrži broj redova gore opisanog formata. Izgled igrice je kao na slici. Slova se zadaju klikom na panele na kojima piše odgovarajuće slovo. Samoglasnici su crv ene, a suglasnici crne boje slova. Na sivom panelu dinamički se kreira niz Edita gde će se prikazati pogođena slova. Edit gde treba prikazati prazninu, koja se ne pogađa, se sakriva.

TstringList je novi tip podatka, koji pretstavlja niz stringova. Poseduje u sebi metode LoadFromFile(AnsiString Files); i SaveToFile(AnsiString Files); Svojstvo Count određuje broj stringova u listi. Stringu iz liste se pristupa pomoću indeksa. Stringovi u listi su tipa AnsiString.

Rešenje


#include "chicha_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;

TStringList *ss; AnsiString zrec; //Zadata recbool bilapraz; //Da li u reci koja se trazi postoji praznina

292

int bro=0,brslova; //bro je promasaja, a brslova je broj slova u zadatoj reciTEdit *ned[20]; //---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)

{}//---------------------------------------------------------------------------int BrojDvoznaka(AnsiString pom) //Utvrdjuje broj dvoznaka u stringu pom.{ int j, brdvo=0;

while(pom.Pos("NJ") || pom.Pos("LJ") || pom.Pos("DŽ")) { j=pom.Pos("NJ"); if(j!=0) { brdvo++; pom.Delete(j,2); }

j=pom.Pos("LJ"); if(j!=0) { brdvo++; pom.Delete(j,2); }

j=pom.Pos("DŽ"); if(j!=0) { brdvo++; pom.Delete(j,2); } }

return brdvo;}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ ss=new TStringList(); //Niz stringova

ss->LoadFromFile("RECI.TXT"); //Ucitavamo datoteku int n=StrToInt(ss->Strings[0]); //Utvrdjujemo broj zadatih pojmova za pogadjanje

randomize(); int broj=random(n)+1;

AnsiString sta,pom=ss->Strings[broj];

293

pom=pom.UpperCase(); sta=pom.SubString(1,1); //Slovo pojma sta se pogadja. zrec=pom.Delete(1,2); //Zadata rec koja se pogadja

//Na osnovu slova ispisujemo u Labeli pojam koji se pogadja. if(sta=="P") Label2->Caption="PREDMET"; if(sta=="Ž") Label2->Caption="ŽIVOTINJA"; if(sta=="B") Label2->Caption="BILJKA"; if(sta=="D") Label2->Caption="DRŽAVA"; if(sta=="G") Label2->Caption="GRAD";

int brdvoz=0,br; pom=zrec; brdvoz=BrojDvoznaka(pom); //Utvrdjujemo broj dvoznaka.

int inde=zrec.Pos(" "); //Utvrdjujemo da li ima praznine u zadatoj reci. pom=zrec.SubString(1,inde); //Rec do praznine. br=BrojDvoznaka(pom); //Broj dvoznaka do praznine. int ind=inde-br; //Indeks gde se praznina nalazi.

int poz=Panel2->Width/2-(47*zrec.Length()-15)/2; brslova=zrec.Length()-brdvoz; //Moramo u zadatoj reci utvrditi broj slova, a kako je

//dvoznak slovo to se od broja slova mora izbaciti broj //dvoznaka.

for(int i=0;i<brslova;i++) //Formiramo niz Edita koliko ima slova u zadatoj reci. { TEdit *ed = new TEdit(Panel2); / ed->Parent=Panel2;

ed->Width=22; ed->Height=25; ed->Left=poz+i*(15+ed->Width); ed->Font->Size=12; ed->Font->Style=TFontStyles()<<fsBold; ed->Top=15; ed->ReadOnly=true; ed->Font->Color=clBlack;

ned[i]=ed; }

bilapraz=false; if(inde!=0) //Ako ima praznina u zadatoj reci. { ned[ind-1]->Visible=false; //Edit komponenta gde bi trebalo da pise praznina a

//sobzirom da se praznina ne pogadja to se praznina mora //sakriti.

brslova--; //U slova se ne racuna praznina. bilapraz=true; //Praznina je bila u zadatoj reci. }

294

}//---------------------------------------------------------------------------void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action){ ss->Free(); //Brise se lista jer smo je mi dinamički formirali.}//---------------------------------------------------------------------------void __fastcall TForm1::Panel3Click(TObject *Sender){ TPanel *pn=dynamic_cast <TPanel *> (Sender);

//Definisemo i inicijalizujemo niz slika. Prva slika sadrzi gredu za vesanje, na drugoj se //nalazi obesena glava, itd, Slika ima sedam. Nakon sest neuspesnih pokusaja telo je //obeseno.

TImage *im[7]={Image1,Image2,Image3,Image4,Image5,Image6,Image7};

int i=0; bool kon=false; AnsiString pom=zrec,pompre;

//Radi dok ima slova u zadatoj reci. while(pom.Pos(pn->Caption)) { kon=true; //Postoji slovo u zadatoj reci. int j=pom.Pos(pn->Caption);//Trazi poziciju slova u reci. if(j!=0) //Ako slova ima u reci. { pompre=pom.SubString(1,j); //Izdvajamo string do tog slova. int br=BrojDvoznaka(pompre); //Utvrdjujemo broj dvoznaka do njega. if(j<pom.Length()) //Ako slovo nije poslednje u reci. { if(pn->Caption.Length()>1) //Ako je slovo dvoznacno. { i+=j-br; //Sabiramo prethodni indeks jer brisemo deo po deo reci. ned[i-1]->Text=pn->Caption; //U pravi Edit upisujemo slovo.

//Brisemo deo reci zakljucno sa tim slovom. pom.Delete(1,j-1+pn->Caption.Length()); }else{

//Ako je slovo koje je uneto jednoznacno ne sme se porediti sa delom //dvoznacnog slova.

if(!(pom[j]=='N' && pom[j]=='j')&& !(pom[j]=='L' && pom[j]=='j')&& !(pom[j]=='D' && pom[j]=='Ž') )

{ //Slovo je jednoznacno a oduzimamo broj ranije dvoznacnih //slova..

i+=j-br; ned[i-1]->Text=pn->Caption;

295

pom.Delete(1,j-1+pn->Caption.Length()); } } }else{ //Slovo je poslednje u reci. i+=j-br; ned[i-1]->Text=pn->Caption; pom.Delete(1,j-1+pn->Caption.Length()); } } }

if(kon==false) //Ako nije bilo slova u reci, promasio je. { im[bro]->Visible=false; //Dosadasnja slika se sakriva. bro++; //Broj neuspelih pokusaja se uvecava. im[bro]->Visible=true; //Nova slika koja je po redu se prikazuje.

if(bro==6) //Ako je iskoristio svih sest pokusaja. { GroupBox1->Enabled=false; //Ne moze vise igrati potez izbora slova.

//Prikazuje se poruka da nije uspeo i rec koju je trebao pogoditi. ShowMessage("Obesen si!!\nResenje je> "+zrec); } }else{ int brojac=0,br;

//Moramo znati broj Edita a zeza nas praznina jer postoji skriveni Edit. Ako postoji //praznina.

if(bilapraz==true) br=brslova+1; else br=brslova;

for(int i=0;i<br;i++) { if(ned[i]->Enabled==true) //Samo vidljive Editec a ne skriveni. { if(ned[i]->Text!="") brojac++; //Brojimo pogotke, a time su polja puna. } }

if(brojac==brslova) //Ako je broj slova jednak broju pogodaka, pogodio ja pojam. { GroupBox1->Enabled=false; ShowMessage("Svaka cast!!"); //Prikazuje se poruka o uspehu. } }}//---------------------------------------------------------------------------void __fastcall TForm1::Igra1Click(TObject *Sender) Opcija menija,{ TImage *im[7]={Image1,Image2,Image3,Image4,Image5,Image6,Image7};

296

Image1->Visible=true; //Samo prva slika mora postati vidljiva a sve ostale skrivene. for(int i=1;i<7;i++) im[i]->Visible=false; GroupBox1->Enabled=true; //Moze otvarati slovo.

int br; if(bilapraz==true) br=brslova+1; else br=brslova;

//Unistavamo sve Edite jer cemo ih ponovo formirati pokretanjem nove igrice. for(int i=0;i<br;i++) ned[i]->Free(); bro=0;

FormCreate(Sender);}//---------------------------------------------------------------------------void __fastcall TForm1::Kraj1Click(TObject *Sender) //Opcija menija.{ int br; if(bilapraz==true) br=brslova+1; else br=brslova; for(int i=0;i<br;i++) ned[i]->Free(); this->Close();}//---------------------------------------------------------------------------


omogućava učitavanje tekstualne datoteke, na osnovu imena datoteke sa ekstenzijom. Pritiskom na taster OTVORI datoteka se otvara i smešta u Memo komponentu. Pojedine reči datoteke počinju i završavaju se znakom #. Druga komponenta Memo sadržaće sve reči bez ponavljanja koje se nalaze između znakova #. Reči su u Memo komponenti prikazuje pretvorene u velika slova. Reč koja počinje I završava se znakom # mora zadovoljiti osobinu da ne može početi u jednom redu a zvršavati i drugom redu.

Obe komponente Memo služe samo za prikazivanje datoteke i izveštaja i ne može im se sadržaj menjati.

Program poseduje zaštitu od pogrešno unesenog imena datoteke, tako što se u vidu poruke o grešci u vidu dijalog prozora pojavljuje upozorenje.

Klikom na dugme PONOVO aplikacija se vraća u prvobitno stanje.

Rešenje

297

DATOTEKA

Definicija:Datoteka je osnovna logička jedinica u pogledu zapisa informacija na

jedinicama masovne memorije.

Za unos velikog obima podataka u programu ne koristimo ulaz sa tastature već iz datoteke (što takođe važi i u slučaju izlaza).

Prema načinu smeštanja podataka, postoje dve vrste datoteka: tekstualne datoteke, i binarna datoteke.

Tekstualne datoteke sastoje se od niza znakova koji je znakovima za prelazak u novi red ('\n') podeljen u redove. Binarne datoteke sastoje se od niza bajtova čiji je sadržaj verna slika načina predstavljanja podataka u memoriji. U toku prenosa ne primenjuje se konverzija, već se vrši prosto prenošenje podataka bajt po bajt. Podela tekstualnih datoteka u redove je logička, a ne fizička organizacija. Tekstualne datoteke su samo dugački niz znakova (bajtova).

Za svaku datoteku koja se koristi u programu mora da postoji pokazivač na podatak tipa FILE. Neka je to pokazivač pod nazivom dat, njegova deklaracija je:

FILE *dat;Otvaranje datoteke

Datoteka pre bilo kakve obrade mora biti otvorena. To se postiže funkcijom fopen(). Funkcija fopen otvara navedenu datoteku i vraća pokazivač na tu datoteku (tip FILE), a ako dođe do greške funkcija vraća vrednost NULL. Prototip funkcije fopen je:

FILE fopen(const char *ime_staze, const char *access_mode);

ime_staze - je niz znakova koji sadrži konpletnu stazu do navedene datoteke.access_mode - određuje način pristupa datoteci. Dozvoljene vrednosti za

access_mode su:

"r" - otvara tekstualnu datoteku samo za čitanje."w" - otvara tekstualnu datoteku samo za pisanje, odbacujući postojeći sadržaj

ako postoji bez opomene, ili kreirajući datoteku ako ona ne postoji."a" - otvara tekstualnu datoteku za pisanje, dodajući nove elemente na njen

kraj, ili stvarajući potpuno novu datoteku ako je nema."r+" - otvara tekstualnu datoteku za ažuriranje, čitanje i pisanje, postavljajući

pokazivač na početak datoteke."w+" - otvara tekstualnu datoteku za ažuriranje, čitanje i pisanje, odbacujući

postojeći sadržaj ako postoji, ili kreira datoteku ako ona ne postoji."a+" - otvara tekstualnu datoteku za ažuriranje, čitanje i pisanje, dodajući nove

elemente na njen kraj, ili stvara novu datoteku ako je nema.

298

Režimi otvaranja datoteka: "rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b" imaju istu sematiku kao i prethodno opisani načini, sa jednom razlikom što oznaka b upućuje na binarni umesto tekstualnog režima pristupa datoteci.

Na primer:

FILE *dat;dat = fopen("primer.txt","r");

Zatvaranje datoteke

Zatvaranje datoteke vrši se funkcijom fclose(); čiji je prototip:

int fclose(FILE *dat);

//---------------------------------------------------------------------------#include <vcl.h>#include <stdio.h>

#pragma hdrstop#include "zad6za3_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){ if(Edit1->Text=="") { ShowMessage("Niste uneli ime fajla!!!"); Edit1->SetFocus(); return; }

FILE *dat; char *ss= new char[30]; AnsiString p=Edit1->Text; ss=StrPCopy(ss,p);

299

dat=fopen(ss,"r"); if(dat!=NULL) { Memo1->Lines->LoadFromFile(Edit1->Text); fclose(dat); }else{ ShowMessage("Nema takve datoteke!!"); Edit1->Clear(); Edit1->SetFocus(); return; }

AnsiString pom,s; int i,j,k; bool kon=false;

for(i=0;i<Memo1->Lines->Count;i++) //Posmatramo red po red. { s=Memo1->Lines->Strings[i]; //Uzimamo red. j=1; while(j<s.Length()) //Dok ne dpdjemo do kraja stringa. { while(s[j]!='#'&&j<s.Length()) j++; //Trazimo znak '#' if(j<s.Length()) //Ako smo ga nasli. { j++; k=j; while(s[j]!='#'&&j<s.Length()) j++; //Trazimo drugi znak '#' pom=s.SubString(k,j-k); //Uzimamo string izmedju znakova '#' j++;

//Posmatramo da li takve reci ima vec upisane te ako je nama //vrsimo upis.

kon=false; for(k=0;k<Memo2->Lines->Count&&kon!=true;k++) { if(Memo2->Lines->Strings[k].UpperCase()==

pom.UpperCase()) kon=true; }

if(kon==false) Memo2->Lines->Add(pom.UpperCase()); } } }

300

Button1->Enabled=false; Button2->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Memo1->Lines->Clear(); Memo2->Lines->Clear(); Button1->Enabled=true; Button2->Enabled=false; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Application->Title="Grerska!!"; Memo2->Lines->Clear();}//---------------------------------------------------------------------------


prikazuje izveštaj izabrane tekstualne datoteke. Klikom na dugme Open pojavljuje se Open dialog gde su prikazani samo tekstualni fajlovi, a korisnik bira i otvara jednu od njih. U posebnoj Labeli nalazi se naziv fajla sa ekstenzijom bez putanje.

Izveštaj sadrži podatke: Broj znakova u datoteci, Redni broj prvog najdužeg reda u datoteci i Broj samoglasnika u datoteci.

Klikom na dugme Clear program se vraća u početno stanje.

Rešenje

Komponenta OpenDialog

nalazi se na kartici Dialogs i

301

koristi se za otvaranje datoteke. Osnovna metoda je Execute() koja omogućava formiranje dialoškog prozora kao na slici.

Svojstvo Title je tipa AnsiString i određuje tekst koji će se pojaviti na traci sa natpisom prozora za dialog. U slučaju praznog stringa podrazumevana vrednost je Open.

Svojstvo FileName je tipa AnsiString i predstavlja naziv odabrane datoteke sa putanjom.Svojstvo DefaultExt je tipa AnsiString i označava tip datoteke koji će se dopisati iza imena

u svojstvu FileName ako ga korisnik sam ne unosi.Svojtvo Files je tipa Tstrings i sadrži listu imena datoteka u trenutnom radnom katalogu

koje je korisnik odabrao.

Svojstvo Filter je tipa AnsiString i služi za odabiranje fajlova iz trenutnog radnog kataloga.

FilterEditor služi za uređivanje fajlova.Sa leve strane je FileName i služi za

opis vrste, a sa desne strane je Filter sa džoker znakovima kojima će se vršiti filtriranje.


#include "Red_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::OpenUpdate(TObject *Sender){ if(Label8->Caption=="Nema fajla") Open->Enabled=true; else Open->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::OpenExecute(TObject *Sender){ if(OpenDialog1->Execute()) //Otvara se Open dialog, te ako je kliknuto na OK. { TStringList *s = new TStringList; s->LoadFromFile(OpenDialog1->FileName);//Otvaramo datoteku sa tom putanjom.

AnsiString ime=OpenDialog1->FileName;

302

//Izdvojicemo iz stringa samo ime datoteke sa ekstenzijom bez putanje i upisujemo ga//u Labelu.

int k; do{ k=ime.Pos("\\"); if(k!=0) ime=ime.Delete(1,k); }while(k!=0); Label8->Caption=ime;

Label2->Caption=IntToStr(s->Count); //Upisujemo broj redova u datoteci-

int max,red; AnsiString pom=s->Strings[0];//Proglasavamo prvog da je najduzi. max=pom.Length(); //Njegova duzina. red=1; //Prvi je red.

//Prolazimo kroz ostale redove datoteke. for(int i=1;i<s->Count;i++) { pom=s->Strings[i]; //Uzimamo red iz liste stringova. if(pom.Length()>max) { max=pom.Length(); red=i+1; //Redni broj reda trenutno najduzeg. } } Label3->Caption=IntToStr(red); //Upisujemo redni broj prvog najduzeg reda tekstualne //datoteke.

int brsa=0; //Brojac samoglasnika u datoteci. for(int i=0;i<s->Count;i++) { pom=s->Strings[i]; //Uzimam red iz liste stringova. pom=pom.UpperCase(); //Pretvaram sva slova u velika.

char *cpom = new char[80]; cpom=StrPCopy(cpom,pom); //Raspakujem string.

int j=0; //Prolazi se kroz raspakovani string i broje samoglasnici. while(cpom[j]!='\0') { char c=cpom[j]; if(isalpha(c)) { if(c=='A' || c=='O' || c=='E' || c=='I' || c=='U') brsa++; } j++; } delete cpom; }

303

Label5->Caption=IntToStr(brsa); //Upisuje se broj samoglasnika. }}//---------------------------------------------------------------------------void __fastcall TForm1::ClearUpdate(TObject *Sender){ //Nemamo sta brisati ako nismo otvorili fajl. if(Label8->Caption=="Nema fajla") Clear->Enabled=false; else Clear->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::ClearExecute(TObject *Sender){ Label3->Caption="???"; Label3->Caption="???"; Label5->Caption="???"; Label8->Caption="Nema fajla";}//---------------------------------------------------------------------------


izbor i otvaranje tekstualne datoteke pomoću Open dialoga i njeno smeštanje u Memo komponentu. U posebnoj Labeli upisuje se celohupna putanja izabrane datoteke.

Program poseduje jedan ComboBox sa velikim slovima Engleske abecede, pri čemu je trenutno aktivno slovo A, prilikom startovanja aplikacije.. U posebnom Editu prikazuje se broj pojavljivanja izabranog slova u datoteci.

Komponenta ComboBox može da prihvati unos samo jedanog karaktera. Slova se moraju automatski pretvarati u velika, a u polju ispisa, uvek je aktivan broj pojave slova u odnosu na stanje sadržaja polja ComboBoxa. Koristiti i ActionList komponentu, radi aktiviranju dugmadi Open i Clear, kao i uslova kada su dugmadi aktivna, a kada ne.

Rešenje


304

#include "Pojava_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1:: FormCreate( TObject *Sender){ //Upisuju se velika slova u ComboBox for(int i=0;i<25;i++) { char c='A'; //Karakter a prvo je A. AnsiString s;

c=c+i; //Prelazimo na sledeci karakter jer su oni slozeni u ASSCII tabeli po bbecedi. s=s.StringOfChar(c,1); //Na osnovu karaktera c formiram string od jednog karaktera.

ComboBox1->Items->Add(s); //Dodajem string u listu ComboBoxa }}//---------------------------------------------------------------------------void __fastcall TForm1::ComboBox1KeyPress(TObject *Sender, char &Key){ if(!isalpha(Key)) Key=0; //Mogu se unositi samo slova.}//---------------------------------------------------------------------------void __fastcall TForm1::ClearExecute(TObject *Sender) //Akcija brisanje.{ Memo1->Lines->Clear(); //Brisemo Memo prikaz datoteke. ComboBox1->Enabled=false; //Onemogucavamo bviranje slova. ComboBox1->Text="0"; //Brisemo polje prikaza ComboBoxa uz upis broja nula.

Label3->Caption="Nema Fajla"; //Upisujemo da Nema prikaza fajla. Edit1->Text="0"; //Trenutni zbir kao i na pocetku je nula.}//---------------------------------------------------------------------------void __fastcall TForm1::ClearUpdate(TObject *Sender){ //Ako je Memo prazan znak je da nije otvorena datoteka a to je znak da je akcija neaktivna, //a u suprotnom je aktivna. if(Memo1->Lines->Count!=0) Clear->Enabled=true; else Clear->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::OpenExecute(TObject *Sender) //Akcija Otvaranja datoteke.

305

{ ComboBox1->Enabled=true; //Mozemo birati slovo.

if(OpenDialog1->Execute()) {

//Otvaramo izabranu tekstualnu datoteku. Memo1->Lines->LoadFromFile(OpenDialog1->FileName);

Label3->Caption=OpenDialog1->FileName; //Upisujemo putanju datoteke.

//Brojimo pojavu izabranog slova u datoteci. Tako sto trazimo pojavu slova red po red //iz Memo komponente.

int br=0; for(int i=0;i<Memo1->Lines->Count;i++) { AnsiString t,s=Memo1->Lines->Strings[i]; s=s.UpperCase(); //Sva slova pretvaramo u velika radi poredjenja.

for(int j=1;j<s.Length();j++) //Prolazimo kroz string reda datoteke. { t=ComboBox1->Text; //Uzimamo slovo iz ComboBoxa

if(t[1]==s[j]) br++; //Vrsimo poredjenje slova, te ako su ista uvecavamo //brojac.

} }

Edit1->Text=" "+IntToStr(br); //Upisujemo broj slova u Edit. }}//---------------------------------------------------------------------------void __fastcall TForm1::OpenUpdate(TObject *Sender){ //Ima smisla otvarati novu datoteku ako je izbrisan sadrzaj prethodno otvorene datoteke, //a to je slucaj ako je Memo komponenta prazna.

if(Memo1->Lines->Count==0) Open->Enabled=true; else Open->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::ComboBox1Change(TObject *Sender) //Promena sadrzaja ComboBoxa{ AnsiString t=ComboBox1->Text; //Sta se u ComboBoxu nalazi.

t=t.UpperCase(); //Pretvaramo u veliko slovo.

//Upisujemo ga pretvorenog u veliko slovo natrag u polje ComboBoxa. ComboBox1->Text=t;

306

//Automatski posto je podesen MaxLength u komponenti ComboBox na 1 to se vec //nakon unesenog jednog znaka prikazuje broj slova u datoteci.

int br=0; for(int i=0;i<Memo1->Lines->Count;i++) { AnsiString s=Memo1->Lines->Strings[i]; s=s.UpperCase(); for(int j=1;j<s.Length();j++) { if(t[1]==s[j]) br++; } }

Edit1->Text=" "+IntToStr(br);}//---------------------------------------------------------------------------

Primer 147:Napraviti aplikaciju koja omogućava dodavanje imena izabranih datoteka u listu

komponente ComboBox. Klikom na dugme Odredi u Memo je prikazan izveštaj o datoteci iz liste koja je imala najveći zbir, pri čemu se ispisuje ime fajla sa ekstenzijom bez putanje. Spisak izabranih datoteka u komponenti ListBox takodje sadrži samo imena datoteka sa ekstenzijama bez putanja, kao i vrednost tog najvećeg zbira.

Niti jedna stavka prilikom dodavanja naziva fajla u ListBox komponentu nije aktivna, a time je i izveštaj GroupBox komponente prazan. Klikom na neku stavku iz ListBox komponente, stavka postaje aktivna, a u izveštaju GroupBox komponente upisana je celokupna putanja datoteke označene u ListBoxu, kao i zbir koji se nalazi u toj datoteci. Klikom na dugme Brisi stanje aplikacije se vraća kao da se nalazimo na početku.

Program poseduje meni i kontekst meni sa istim opcijama: Dodaj (prečica Ins), Brisi (prečica Del) i Odredi (prečica F10), stim što meni sadrži i stavku Izvestaj. Pomoću komponente ActionListe povezati dugmadi, oipcije menija i opcije kontekst menija.

Brojevi u datoteci moraju biti celobrojni i svaki red u datoteci sadrži samo jedan broj.

Ako je neka datoteka, u listti komponente ListBoxa, prazna, program je izbacuje iz List Boxa.

Meni glavni sadrži i stavku Izvestaj ispred koga ako je čekiran biće prikazan izveštaj u GroupBox komponenti, a u suprotnom i GroupBox komponente nema na formi.

307

Rešenje//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "Zbir_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;TStringList *list;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Izvestaj1Click(TObject *Sender){ if(Izvestaj1->Checked==true) { Izvestaj1->Checked=false; GroupBox1->Visible=false; }else{ Izvestaj1->Checked=true; GroupBox1->Visible=true; }

308

}//---------------------------------------------------------------------------void __fastcall TForm1::DodajUpdate(TObject *Sender){ Dodaj->Enabled=true; //Uvek se moze dodavati u listu.}//---------------------------------------------------------------------------void __fastcall TForm1::DodajExecute(TObject *Sender){ if(OpenDialog1->Execute()) //Biramo datoteku. { AnsiString s=OpenDialog1->FileName; list->Add(s);

int k; while((k=s.Pos("\\"))!=0) s=s.Delete(1,k); //Brisemo putanju. ListBox1->Items->Add(s); //Dodajemo u ListBox }}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ list = new TStringList; //Pravimo objekat liste stringova.}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::BrisiUpdate(TObject *Sender){ //Moze se brisati ako postoji lista u ComboBoxu if(ListBox1->Count!=0) Brisi->Enabled=true; else Brisi->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::BrisiExecute(TObject *Sender){ ListBox1->Clear(); Memo1->Clear();

Label2->Caption="???"; Label4->Caption="???";}//---------------------------------------------------------------------------void __fastcall TForm1::OdrediUpdate(TObject *Sender){ //Mozemo odrediti najveci zbir ako ima fajlova u ListBoxu if(ListBox1->Count!=0) Odredi->Enabled=true; else Odredi->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::OdrediExecute(TObject *Sender){

309

//Otvaramo fajl po fajl sa imenom iz ListBoxa, a putanja je u listi stringova. int max,ind; for(int i=0;i<ListBox1->Count;i++) { TStringList *p = new TStringList; p->LoadFromFile(list->Strings[i]); //Otvaramo fajl.

if(p->Count==0) { list->Delete(i); //Ako je prazna brisemo je iz liste.i ListBoxa ListBox1->Items->Delete(i); }else{ int s=0; //sabiramo brojeve iz datoteke. for(int j=0;j<p->Count;j++) s+=StrToInt(p->Strings[j]); if(i>0) //Utvrdjujemo maksimalni zbir. { if(s>max) max=s, ind=i; }else{ max=s; ind=0; } delete p; } } //Dodajemo u Memo naziv fajla sa najvecim zbirom, prazan red i vrednost zbira.

Memo1->Lines->Add("Ime fajla: "+ListBox1->Items->Strings[ind]); Memo1->Lines->Add(""); Memo1->Lines->Add("Zbir = "+IntToStr(max));}//---------------------------------------------------------------------------void __fastcall TForm1::ListBox1Click(TObject *Sender){ int ind=ListBox1->ItemIndex; //Utvrdjujemo indeks oznacene stavke ListBoxa. Label2->Caption=list->Strings[ind]; //Upisujemo putanju odabranog fajla.

TStringList *p = new TStringList; p->LoadFromFile(list->Strings[ind]); //Otvaramo fajl.

int s=0; //Odredjujemo zbir brojeva u tom fajlu. for(int j=0;j<p->Count;j++) s+=StrToFloat(p->Strings[j]); Label4->Caption=IntToStr(s); //Upisujemo zbir u Labelu.}//---------------------------------------------------------------------------

Primer 148:Napisati C program koji omogućava formiranje strukture radnik sa poljima:

310

1) Ime,2) Prezime,3) Koeficijen za dato radno mesto; i4) Godine radnog staža.

Poznato je da je vrednost boda k dinara, a da se na svaku godinu radnoga staža dohodak uvećava za 0.5%. Pripravnik je onaj radnik gde se za godine radnoga staža unese broj 0 i ima 80% dohodak u odnosu na radnika sa obavljenim pripravničkim stažom. Progam treba da ispiše koliki je dohodak radnika.

Rešenje

Definicija strukture:Struktura predstavlja izvedeni tip podatka koji sadrži promenljive istog ili

različitog tipa. Koristi se u slučajevima kada su podaci u međusobnoj vezi, jer se mogu grupisati pod istim imenom.

Definisanmje novog tipa podatka strukturnog tipa:

typedef struct ime_strukture {Niz_deklaracija

} ime_tipa;

Pristup članovima structure:Pristup članovima strukture vrši se pomoću operatora člana strukture (.).

Na primer:

/* Definicija strukture radnik. */struct radnik{

AnsiString prezime_i_ime;unsigned starost;unsigned staz;

311

} Tradnik;

/* Deklaracija strukturne promenljive a i b tipa Tradnik. */Tradnik a, b;

/* Inicijalizacija strukturne promenljive a. a.prezime_i_ime=””;a.starost = 0;a.staz = 0;

/* Naredbu dodele mozemo koristiti izmedju struktura. */ b = a;

Prilikom naredbe dodele vrši se automatsko kopiranje odgovarajućih polja jedne strukture u drugu. U ovom slučaju vrednosti polja strukture a su prekopirane u strukturu b. Ovim se skraćuje kod programa i ne mora se koristiti funkcija strcpy da bi se polje koje predstavlja string prekopirao iz polja strukture a u polje strukture b.

Strukturna promenljiva se može inicijalizovati i prilikom deklaracije.Tradnik a = {"", 0, 0};

Prilikom realizacije ovog zadatka struktura Tradnik definiše se u posebnom Uniti, koji se potom uključuje u Unit Forme aplikacije.Radnik.h//---------------------------------------------------------------------------#ifndef RadniciH#define RadniciH#include <System.hpp>//---------------------------------------------------------------------------typedef struct Radnik{ AnsiString ime; AnsiString prezime; float koeficijent; int staz; float dohodak;}TRadnik; //Definisan je novi tip podatka Tradnik.//---------------------------------------------------------------------------#endif

Glavni program//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "Radnik_o.h"//---------------------------------------------------------------------------

312

#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key){ if(!isalpha(Key) && Key!=8) Key=0;}//---------------------------------------------------------------------------void __fastcall TForm1::Edit4KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='.') Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); AnsiString s=ed->Text;

if((Key!='.' && Key!=8) && s=="0") Key=0;

if(Key=='.') { int k=s.Pos("."); if(k!=0 || s=="") Key=0; } }}//---------------------------------------------------------------------------void __fastcall TForm1::Edit3KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8) Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(ed->Text==""&&Key=='0') Key=0; }}//---------------------------------------------------------------------------void __fastcall TForm1::utvrdiExecute(TObject *Sender){ TRadnik rad; //Deklaracija strukturne promenljive rad. float bod;

//Unos podataka u strukturu.

313

rad.ime=Edit1->Text; rad.prezime=Edit2->Text; rad.koeficijent=StrToFloat(Edit4->Text); rad.staz=StrToInt(Edit3->Text);

bod=StrToFloat(Edit5->Text);

//Računanje dohotka radnika na osnovu teksta zadatka. if(rad.staz!=0) { rad.dohodak=rad.koeficijent * bod; rad.dohodak+=0.5*rad.staz*rad.dohodak; }else{ rad.dohodak=rad.koeficijent*bod; rad.dohodak=0.8*rad.dohodak; }

//Ispis rezultata, dohotka radnika. Label7->Caption=

Format("%.2f",ARRAYOFCONST((rad.dohodak)))+" dinara.";}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::utvrdiUpdate(TObject *Sender){ if(Edit1->Text==""||Edit2->Text==""||Edit3->Text==""||

Edit4->Text==""||Edit5->Text=="") utvrdi->Enabled=false; else utvrdi->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Edit3->Clear(); Edit4->Clear(); Edit5->Clear();

Label7->Caption="?????"; Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::Edit4Change(TObject *Sender){ if(Edit4->Text=="0") Edit4->Clear();

314

}//-------------------------

Primer 149:Napraviti

aplikaciju koja omogućava izvršavanje osnovnih aritmetičkih operacija nad skupom kompleksnih brojeva: Sabiranje, Oduzimanje, Množenje i Deljenje. Svaki kompleksni broj se sastoji od realnog i imaginarnog dela koji su oblika razlomka.

Formirati strukturne tipove podataka TRacBroj i TKompBroj. TRacBroj je tip koji se sastoji od dva celobrojna podatka: brojilac i imenilac, pri čemu imenilac mora biti pozitivan broj. Nad podatkom tipa TRacBroj mogu se izvršavati operacije: sabiranja, oduzimanja, množenja i deljenja, korišćenjem odgovarajućih funkcija. Strukturni tip podataka TKompBroj sastoji se od realnog i imaginarnog podatka tipa TRacBroj. Nad podatkom TKompBroj mogu se koristiti funkcije za sabiranje, množenje i deljenje dva kompleksna broja, pri čemu funkcije kao rezultat vraćaju kompleksni broj tipa TKompBroj..

Rešenje

Racionalni.h//---------------------------------------------------------------------------#ifndef RacionalniH#define RacionalniH//---------------------------------------------------------------------------typedef struct Rac{ int x; int y;}TRacBroj;

TRacBroj SabRac(TRacBroj a, TRacBroj b);TRacBroj OduRac(TRacBroj a, TRacBroj b);TRacBroj MnoRac(TRacBroj a, TRacBroj b);TRacBroj DelRac(TRacBroj a, TRacBroj b);TRacBroj Sredi(TRacBroj a);//---------------------------------------------------------------------------#endif

Racionalni.cpp//---------------------------------------------------------------------------

315

#pragma hdrstop

#include "Racionalni.h"#include <math.h>//---------------------------------------------------------------------------int nzd(int a, int b){ while(b!=0) { int c=a%b; a=b; b=c; }

return a;}//---------------------------------------------------------------------------TRacBroj SabRac(TRacBroj a, TRacBroj b){ TRacBroj rez;

rez.x=a.x*b.y + b.x*a.y; rez.y=a.y*b.y;

int z=nzd(abs(rez.x),rez.y); rez.x/=z; rez.y/=z;

return rez;}//---------------------------------------------------------------------------TRacBroj OduRac(TRacBroj a, TRacBroj b){ TRacBroj rez;

rez.x=a.x*b.y - b.x*a.y; rez.y=a.y*b.y;


return rez;}//---------------------------------------------------------------------------TRacBroj MnoRac(TRacBroj a, TRacBroj b)

316

{ TRacBroj rez;

rez.x=a.x*b.x; rez.y=a.y*b.y;


return rez;}//---------------------------------------------------------------------------TRacBroj DelRac(TRacBroj a, TRacBroj b){ TRacBroj rez;

rez.x=a.x*b.y; rez.y=a.y*b.x;

int z=nzd(abs(rez.x),rez.y);

if(z!=0) { rez.x/=z; rez.y/=z; }

return rez;}//---------------------------------------------------------------------------TRacBroj Sredi(TRacBroj a){ if(a.y<0) { a.x=-a.x; a.y=-a.y; }

int z=nzd(abs(a.x),a.y); a.x/=z; a.y/=z;

return a;}

317

//---------------------------------------------------------------------------#pragma package(smart_init)

Kompleksni.h//---------------------------------------------------------------------------#ifndef KompleksniH#define KompleksniH#include "Racionalni.h"//---------------------------------------------------------------------------typedef struct Komp{ TRacBroj real; TRacBroj imag;}TKompBroj;

TKompBroj SabKomp(TKompBroj a, TKompBroj b);TKompBroj OduKomp(TKompBroj a, TKompBroj b);TKompBroj MnoKomp(TKompBroj a, TKompBroj b);TKompBroj DelKomp(TKompBroj a, TKompBroj b);//---------------------------------------------------------------------------#endif

Kompleksni,cpp//---------------------------------------------------------------------------#pragma hdrstop#include "Kompleksni.h"//---------------------------------------------------------------------------TKompBroj SabKomp(TKompBroj a, TKompBroj b){ TKompBroj rez;

rez.real=SabRac(a.real,b.real); rez.imag=SabRac(a.imag,b.imag);

return rez;}//---------------------------------------------------------------------------TKompBroj OduKomp(TKompBroj a, TKompBroj b){ TKompBroj rez;

rez.real=OduRac(a.real,b.real); rez.imag=OduRac(a.imag,b.imag);

return rez;}//---------------------------------------------------------------------------TKompBroj MnoKomp(TKompBroj a, TKompBroj b)

318

{ TKompBroj rez;

rez.real=OduRac(MnoRac(a.real,b.real), MnoRac(a.imag,b.imag)); rez.imag=SabRac(MnoRac(a.real,b.imag),MnoRac(a.imag,b.real));

return rez;}//---------------------------------------------------------------------------TKompBroj DelKomp(TKompBroj a, TKompBroj b){ TKompBroj rez; TRacBroj imenilac,broilac;

imenilac=SabRac(MnoRac(b.real,b.real),MnoRac(b.imag,b.imag)); broilac=SabRac(MnoRac(a.real,b.real),MnoRac(a.imag,b.imag)); rez.real=DelRac(broilac,imenilac);

broilac=OduRac(MnoRac(a.imag,b.real),MnoRac(a.real,b.imag)); rez.imag=DelRac(broilac,imenilac);

return rez;}//---------------------------------------------------------------------------#pragma package(smart_init)Glavni program//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "Kompleksni_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key){ if(!isdigit(Key) && Key!=8 && Key!='-') Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender);

if(Key=='-' && ed->Text!="") Key=0; if(Edit1->Text=="0" && Key!=8) Key=0; if(Key=='0' && ed->Text=="-") Key=0; }

319

}//---------------------------------------------------------------------------void __fastcall TForm1::Edit2KeyPress(TObject *Sender, char &Key){ if(!isdigit(Key)) Key=0; else{ TEdit *ed = dynamic_cast <TEdit *> (Sender); if(ed->Text=="" && Key=='0') Key=0; }}//---------------------------------------------------------------------------void __fastcall TForm1::RacunajExecute(TObject *Sender){ TKompBroj prvi,drugi,rez;

prvi.real.x=StrToInt(Edit1->Text); prvi.real.y=StrToInt(Edit2->Text); prvi.imag.x=StrToInt(Edit3->Text); prvi.imag.y=StrToInt(Edit4->Text);

drugi.real.x=StrToInt(Edit5->Text); drugi.real.y=StrToInt(Edit6->Text); drugi.imag.x=StrToInt(Edit7->Text); drugi.imag.y=StrToInt(Edit8->Text);

switch(RadioGroup1->ItemIndex) { case 0: rez=SabKomp(prvi,drugi); break; case 1: rez=OduKomp(prvi,drugi); break; case 2: rez=MnoKomp(prvi,drugi); break; case 3: if(drugi.real.x==0 && drugi.imag.x==0) { Application->Title="GRESKA..."; ShowMessage("Deljenje sa nulom nije definisano!!"); Button2Click(Sender); return; } rez=DelKomp(prvi,drugi); break; case -1: return; }

Edit9->Text=IntToStr(rez.real.x); Edit10->Text=IntToStr(rez.real.y); Edit11->Text=IntToStr(rez.imag.x); Edit12->Text=IntToStr(rez.imag.y);}//---------------------------------------------------------------------------

320

void __fastcall TForm1::RacunajUpdate(TObject *Sender){ if(Edit1->Text=="" || Edit2->Text=="" ||Edit3->Text=="" ||Edit4->Text=="" ||

Edit5->Text=="" || Edit6->Text=="" ||Edit7->Text=="" ||Edit8->Text=="") Racunaj->Enabled=false;

else Racunaj->Enabled=true;}//---------------------------------------------------------------------------void __fastcall TForm1::Button2Click(TObject *Sender){ Edit1->Clear(); Edit2->Clear(); Edit3->Clear(); Edit4->Clear(); Edit5->Clear(); Edit6->Clear(); Edit7->Clear(); Edit8->Clear(); Edit9->Clear(); Edit10->Clear(); Edit11->Clear(); Edit12->Clear(); Edit1->SetFocus();}//---------------------------------------------------------------------------

Primer 150:Napraviti aplikaciju koja omogućava unos polinoma u nesređenom obliku i njegovo

sređivanje po stepenima, klikom na dugme Radi. Polinom se unosi tako što se unose članovi polinoma razdvojeni prazninom. Svaki

član polinoma sastoji se od koeficijenta i stepena, razdvojeni zarezom.Ako nakon sređivanja koeficijent nekog člana ima vrednost nula, taj član se ne piše

na izlazu.U realizaciji zadatka koristiti strukturni tip podataka TPolinom koji se sastoji od

podataka koeficijent i stepen. Prilikom realizacije koristiti niz struktura tipa Tpolinom. Na osnovu unetog polinoma u obliku AnsiStringa, kako je gore opisano, realizovati i koristiti funkcije: void Stvori(TPolinom p[],int *n,AnsiString s); koja stvara polinom na osnovu unesenog stringa, void Sredi(TPolinom p[],int *n); koja sređuje polinom sortiranjem i sažimanjem niza i AnsiString Stampa(TPolinom p[],int n); koja polinom sastavljen od niza struktura pretvara u AnsiString.

321

Rešenje

Polinom.h//---------------------------------------------------------------------------#ifndef PolinomH#define PolinomH#include <system.hpp>

typedef struct Polinom{ int koef; int step;}TPolinom;

void Stvori(TPolinom p[],int *n,AnsiString s);void Sredi(TPolinom p[],int *n);AnsiString Stampa(TPolinom p[],int n);//---------------------------------------------------------------------------#endif

Polinom.cpp//---------------------------------------------------------------------------#pragma hdrstop#include "Polinom.h"#include <system.hpp>#include <SysUtils.hpp>//---------------------------------------------------------------------------void Stvori(TPolinom p[],int *n,AnsiString s){ AnsiString t; int j;

*n=0; while(s!="") {

//Izdvoji koeficijent.

322

j=s.Pos(","); t=s.SubString(1,j-1); p[*n].koef=StrToInt(t); s=s.Delete(1,j);

//Izdvoji stepen. j=s.Pos(" "); if(j!=0) t=s.SubString(1,j-1); else t=s; p[*n].step=StrToInt(t);

if(j!=0) s=s.Delete(1,j); else s="";

(*n)++; //Predji na sledeci clan. }}//---------------------------------------------------------------------------void Sredi(TPolinom p[],int *n){ int i,j,k;

for(i=0;i<*n-1;i++) { j=i+1; while(j<*n) {

//Trazim clan koji ima isti stepen. if(p[i].step!=p[j].step) j++; else{

//Ako sam ga nasao sabiram im koeficijente, upisivanjem na mesto onog //clana koji je manjeg indeksa, tj i, a potom brisem onog koji ima veci //indeks, tj j.

p[i].koef+=p[j].koef; k=j; while(k<*n-1) p[k]=p[k+1],k++; p[*n-1].koef=0; p[*n-1].step=0; (*n)--; } } }

//Nakon sabiranja desice se da su vrednosti takvih koeficijenata nula, te ih treba izbaciti. i=0; while(i<*n) { if(p[i].koef!=0) i++; else{ k=i; while(k<*n-1) p[k]=p[k+1],k++;

323

p[*n-1].koef=0; p[*n-1].step=0; (*n)--; } }

//Da bi polinom bio sredjen po stepenima, mora se izvrsiti sortiranje niza u opadajucem //redosledu po stepenima.

for(i=0;i<*n-1;i++) { for(j=i+1;j<*n;j++) { if(p[j].step>p[i].step) { TPolinom pom=p[i]; p[i]=p[j]; p[j]=pom; } } }}//---------------------------------------------------------------------------AnsiString Stampa(TPolinom p[],int n){ AnsiString s; //Formira se AnsiString s, tako sto se prolazi kroz niz i clanovi u poznatom //formatu upisuju u string s.

for(int i=0;i<n-1;i++) s+=IntToStr(p[i].koef)+","+IntToStr(p[i].step)+" "; s+=IntToStr(p[n-1].koef)+","+IntToStr(p[n-1].step);

return s;}//---------------------------------------------------------------------------#pragma package(smart_init)Glavni program//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "Glavni_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

324

void __fastcall TForm1::RadiUpdate(TObject *Sender){ if(Edit1->Text!="") Radi->Enabled=true; //Kada se moze izvrsiti akcija nad //dugmetom Radi. else Radi->Enabled=false;}//---------------------------------------------------------------------------void __fastcall TForm1::RadiExecute(TObject *Sender) //Ako se klikne na dugme Radi.{ TPolinom p[30]; AnsiString s = Edit1->Text; int n = 0;

//Inicijalizacija niza struktura. for(int i=0;i<30;i++) p[i].koef=0, p[i].step=0;

Stvori(p,&n,s); Sredi(p,&n); s=Stampa(p,n);

Edit2->Text=s;}//---------------------------------------------------------------------------void __fastcall TForm1::BrisiExecute(TObject *Sender){ Edit1->Clear(); Edit2->Clear();}//---------------------------------------------------------------------------void __fastcall TForm1::BrisiUpdate(TObject *Sender){ if(Edit1->Text!="" && Edit2->Text!="") Brisi->Enabled=true; else Brisi->Enabled=false;}//---------------------------------------------------------------------------

Primer 151:Napraviti aplikaciju koja pretstavlja Adresar. Podaci se čuvaju u binarnoj datoteci.

Aplikacija akcije sprovodi preko dugmadi. Adresar jedne osobe sadrži podatke: Ime i prezime, Adresa stanovanja, Da li je profesor i Godine starosti. Ako je program u stanju unosa ili izmene podataka dugmad Potvrdi i Odustani su neaktivna, sve dok se ne unesu svi podaci osobe. Klikom na dugme Potvrdi podaci se upisuju u niz struktura, a po zatvaranju aplikacije u binarnu datoteku.

Pomoću dugmadi Prethodni i Sledeci lista se Adresar. Dugme Brisi vrši brisanje osobe čiji su podaci prikazani na ekranu. Dugme Izmeni omogućava pristup stanju Mmodifikacije podataka. Dugme Ubaci omogućava insertovanje osobe u Adresar, dok dugme Novii omogućava dodavanje nove osobe kao poslednje u listi.

Prilikom realizacije programa koristite komponentu ActionList.

325

Rešenje

Adresar.hpp//---------------------------------------------------------------------------#ifndef KonUnosa_oH#define KonUnosa_oH//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <StdCtrls.hpp>#include <Forms.hpp>#include "CSPIN.h"#include <ExtCtrls.hpp>#include <ActnList.hpp>//---------------------------------------------------------------------------typedef struct Osoba{ AnsiString Ime; AnsiString Adresa; bool od; unsigned god;}TOsoba;//---------------------------------------------------------------------------typedef struct RasOsoba{ char Ime[30]; char Adresa[30]; bool od; unsigned god;}TRasOsoba;

326

//---------------------------------------------------------------------------

class TForm1 : public TForm{__published: // IDE-managed Components TButton *Button2; TButton *Button3; TButton *Button4; TButton *Button6; TPanel *Panel1; TLabel *Label2; TLabel *Label3; TLabel *Label5; TEdit *Edit1; TMemo *Memo1; TButton *Button1; TCheckBox *CheckBox1; TCSpinEdit *CSpinEdit1; TBevel *Bevel1; TLabel *Label1; TButton *Button5; TActionList *ActionList1; TAction *OK; TAction *Odustani; TAction *Prethodni; TAction *Sledeci; TAction *Novi; TAction *Brisi; TButton *Button7; TAction *Izmeni; TAction *Ubaci; TButton *Button8; void __fastcall FormCreate(TObject *Sender); void __fastcall FormClose(TObject *Sender, TCloseAction &Action); void __fastcall NoviUpdate(TObject *Sender); void __fastcall NoviExecute(TObject *Sender); void __fastcall OKExecute(TObject *Sender); void __fastcall OKUpdate(TObject *Sender); void __fastcall PrethodniExecute(TObject *Sender); void __fastcall PrethodniUpdate(TObject *Sender); void __fastcall OdustaniUpdate(TObject *Sender); void __fastcall OdustaniExecute(TObject *Sender); void __fastcall SledeciUpdate(TObject *Sender); void __fastcall BrisiUpdate(TObject *Sender); void __fastcall BrisiExecute(TObject *Sender); void __fastcall SledeciExecute(TObject *Sender); void __fastcall IzmeniUpdate(TObject *Sender); void __fastcall IzmeniExecute(TObject *Sender); void __fastcall UbaciUpdate(TObject *Sender); void __fastcall UbaciExecute(TObject *Sender);private: // User declarations

327

int akt; int n; //Broj osoba u nizu osoba. bool Editing; //Ako je true moze se vrsiti Editovanje nove osobe. bool Inserting; //Ako je true moze se vrsiti Insertovanje nove osobe. bool Promena; //Ako je true moze se vrsiti Izmene podataka kod osobe.public: // User declarations bool Provera(); //Proverava se da li su polja unosa popunjena. __fastcall TForm1(TComponent* Owner);};//---------------------------------------------------------------------------extern PACKAGE TForm1 *Form1;//---------------------------------------------------------------------------#endif

Adresar.hpp

//---------------------------------------------------------------------------#include <vcl.h>#include <stdio.h>#include <fstream.h>#include <stdio.h>#pragma hdrstop

#include "KonUnosa_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma link "CSPIN"#pragma resource "*.dfm"TForm1 *Form1;

TOsoba *niz = new TOsoba[100]; //Definise se niz osoba.

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ TOsoba pom; //Niz sadrzi spakovane podatke osoba. TRasOsoba a; //Binarna datoteka sadrzi raspakovane podatke osoba.

n=0; akt=0; Memo1->Lines->Clear();

328

FILE *dat; //Podaci se nalaze u binarnoj datoteci UNOS.DAT if((dat=fopen("UNOS.DAT","rb"))!=NULL) { //Uzima se osoba po osoba iz binarne datoteke. while(fread(&a,sizeof(TRasOsoba),1,dat)) { pom.od=a.od; pom.god=a.god; pom.Ime=StrPas(a.Ime); pom.Adresa=StrPas(a.Adresa);

niz[n]=pom; //Upisuje se osoba u niz osoba. n++; //Prelazak na sledecu osobu. } fclose(dat); //Zatvaranje binarne datoteke, a adresar se nalazi u //nizustruktura osoba. }

if(n>0) //Ako je bilo osoba u datoteci. { akt=0; //Indeks osobe koja se prikazuje.

//Prikazuju se na ekranu podaci prve osobe. Edit1->Text=niz[akt].Ime; Memo1->Text=niz[akt].Adresa; CheckBox1->Checked=niz[akt].od; CSpinEdit1->Value=niz[akt].god;

Editing=false; //Nismo u fazi Editovanja ili –Modifikacije. Inserting=false; }else{

Editing=true; //Nema podataka u nizu podataka te smo u stanju Editovanja ili //Modifikacije.

Inserting=true; } Promena=false; //Nista se nece menjati kod osoba.}//---------------------------------------------------------------------------void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action){ TOsoba pom; TRasOsoba a;

FILE *dat;

dat=fopen("UNOS.DAT","wb"); //Otvara se datoteka za pisanje i prethodni sadrzaj //datoteke se brise.

//Prolazimo kroz niz osoba i podatke upisujemo u datoteku. for(int i=0;i<n;i++)

329

{ pom=niz[i]; StrPCopy(a.Ime,pom.Ime); StrPCopy(a.Adresa,pom.Adresa); a.od=pom.od; a.god=pom.god;

fwrite(&a,sizeof(TRasOsoba),1,dat); }

fclose(dat);}//---------------------------------------------------------------------------void __fastcall TForm1::NoviUpdate(TObject *Sender) //Uslov dodavanja nove osobe{ Novi->Enabled=(!Editing) && (!Inserting) && Provera();}//---------------------------------------------------------------------------void __fastcall TForm1::NoviExecute(TObject *Sender){ Editing=true; //U fazi smo Editovanja. Inserting=false; //Nismo u fazi insertovanja. Promena=false; //Nizmo u fazi izmene.

//Brisemo polja unosa i fokusiramo se na prvo polje. Edit1->Clear(); Memo1->Lines->Clear(); CheckBox1->Checked=false; CSpinEdit1->Value=0;

Edit1->SetFocus();}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::OKExecute(TObject *Sender){ if(Promena==false) //Ako se ne vrsi Izmena podataka osobe. { TOsoba pom; //Promenljiva gde ce se privremeno smestiti podaci o osobi pre umetanja

//u niz.

pom.Ime=Edit1->Text; pom.Adresa=Memo1->Text; pom.god=CSpinEdit1->Value; pom.od=CheckBox1->Checked;

if(Inserting==true) //Ako smo u fazi umetanja nove osobe. {

330

int j=n; //Ubacivanje se vrsi na trenutnu ili aktivnu poziciju u nizu. while(j>akt) niz[j]=niz[j-1],j--; //Prosirivanje niza u desno. niz[akt]=pom; //Umetanje podataka. n++; //Niz se uvecao za jednu osobu. }else{ niz[n]=pom; //Ynaci da je unos nove osobe, a ona se uvek dodaje na kraj niza. akt=n; //Nalazimo se na toj ubacenoj osobi, a to je kraj niza. n++; // Niz se uvecao za jednu osobu. } }else{ TOsoba pom;

//Samo ce se vrsiti izmene postojecih podataka, te nema prosirivanje niza. //Prikupljanje novih podataka osobe. pom.Ime=Edit1->Text; pom.Adresa=Memo1->Text; pom.god=CSpinEdit1->Value; pom.od=CheckBox1->Checked;

niz[n]=pom; //Upis novih podataka date osobe u niz osoba. }

Inserting=false; //Zavrseno je sa insertovanjem i Editovanjem osoba. Editing=false;}//---------------------------------------------------------------------------void __fastcall TForm1::OKUpdate(TObject *Sender) //Uslov potvrde unesenih podataka osobe.{ OK->Enabled=(Editing || Inserting) && Provera();}//---------------------------------------------------------------------------void __fastcall TForm1::PrethodniExecute(TObject *Sender){ akt--; //Prelazimo na prethodnu osobu u nizu.

//Upisujemo podatke osobe iz niza u polja na ekranu. Edit1->Text=niz[akt].Ime; Memo1->Text=niz[akt].Adresa; CSpinEdit1->Value=niz[akt].god; CheckBox1->Checked=niz[akt].od;}//---------------------------------------------------------------------------void __fastcall TForm1::PrethodniUpdate(TObject *Sender) //Uslov prelaska.{ Prethodni->Enabled=(akt>0) && (!Editing) && (!Inserting);}//---------------------------------------------------------------------------void __fastcall TForm1::OdustaniUpdate(TObject *Sender) //Uslov ne prihvatanja podataka.{ Odustani->Enabled=(Editing || Inserting) && Provera();

331

}//---------------------------------------------------------------------------void __fastcall TForm1::OdustaniExecute(TObject *Sender){ Editing=false; //Nismo vise u fazi Editovabnja. i ponovo upisujemo podatke do tada aktivne

//osobe, tj one ciji su podaci ranije prikazani, na ekranu.

Edit1->Text=niz[akt].Ime; Memo1->Text=niz[akt].Adresa; CSpinEdit1->Value=niz[akt].god; CheckBox1->Checked=niz[akt].od;}//---------------------------------------------------------------------------void __fastcall TForm1::SledeciUpdate(TObject *Sender) //Uslov prelaska.{ Sledeci->Enabled=(akt<n-1) && (!Editing) && (!Inserting);}//---------------------------------------------------------------------------void __fastcall TForm1::BrisiUpdate(TObject *Sender) //Kada se moze brisati osoba.{ Brisi->Enabled= n>0 && (!Editing) && (!Inserting);}//---------------------------------------------------------------------------void __fastcall TForm1::BrisiExecute(TObject *Sender){ int j;

//Sazimanje niza, tj izbacivanje aktivne osobe iz niza osoba i smanjivanje broja osoba u nizu //za jednu osobu. j=akt; while(j<n-1) { niz[j]=niz[j+1]; j++; } n--; if(n!=0) //Ako nakon izbacivanja osobe, moze se desiti da nema osoba u nizu osoba. { //Ako ima osoba, prikazuje se trenutno aktivna osoba.

Edit1->Text=niz[akt].Ime; Memo1->Text=niz[akt].Adresa; CSpinEdit1->Value=niz[akt].god; CheckBox1->Checked=niz[akt].od; }else{

//Ako nema osoba u nizu osoba, polja se moraju isprazniti.

Edit1->Clear(); CSpinEdit1->Value=0; CheckBox1->Checked=false; Memo1->Lines->Clear();

332

akt=0; }

Promena=true; }//---------------------------------------------------------------------------void __fastcall TForm1::SledeciExecute(TObject *Sender){ akt++; //Prelazak na novu osobu i prikaz njenih podataka na ekranu.

Edit1->Text=niz[akt].Ime; Memo1->Text=niz[akt].Adresa; CSpinEdit1->Value=niz[akt].god; CheckBox1->Checked=niz[akt].od;}//---------------------------------------------------------------------------void __fastcall TForm1::IzmeniUpdate(TObject *Sender) //Uslov izmene podataka osobe.{ Izmeni->Enabled=(n>0) && (!Editing) && (!Inserting);}//---------------------------------------------------------------------------void __fastcall TForm1::IzmeniExecute(TObject *Sender){ Editing=true; Inserting=false; Promena=true;

Edit1->SetFocus();}//---------------------------------------------------------------------------void __fastcall TForm1::UbaciUpdate(TObject *Sender) //Uslov Insertovanja nove osobe.{ Ubaci->Enabled=(!Editing) && (!Inserting) && Provera();}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::UbaciExecute(TObject *Sender){ Editing=false; Inserting=true; //Vrsi se samo Insertovanje nove osobe. Promena=false;

//Polja se prazne radi unosa podataka osobe i fokusira se prvo polje unosa. Edit1->Clear(); Memo1->Lines->Clear(); CheckBox1->Checked=false; CSpinEdit1->Value=0;

Edit1->SetFocus();}

333

//---------------------------------------------------------------------------bool TForm1::Provera() { //Proverava se da li su polja unosa popunjena, te ako jesu vraca se vrednost true, a u //suprotnom false. if(Memo1->Text=="" || Edit1->Text=="") return false; else return true;}//---------------------------------------------------------------------------

Primer 152:Napraviti aplikaciju kao na slici, koja pretstavlja interfejs programa za Slušanje muzike.

Program mora zadovoljiti osobinu da se prilikom maksimiziranja ili promene veličine forme, komponente na formi proporcionalno šire. Omogućiti korisniku programa mogućnost promene širine prozora prikaza stabla foldera i prikaza liste fajlova aktivnog foldera korišćenjem

komponente Splitter.

Rešenje

Aplikacija pretstavlja program ya slušanje muzike, koji mora sadržati listu pesama, mogućnost filtriranja pesama, izbor jedinice memorije i izbor foldera sa pesmama. Za realizaciju ovog problema potrebno je koristiti četiri komponente koje se nalaze na kartici Win31.

DriveComboBox FilterComboBox

334

DirectoryrListBox FileListBox

Moraju se podesiti pojedina svojstva komponenti da bi se između njih uspostavila veza.

U svojstu DirList komponente DriveComboBox upisuje se naziv komponente DirectoryrListBox. U svojstvu FileList komponente DirectoryrListBox upisuje se naziv komponente FileListBox. U svojstvu FileList komponente FilterComboBox upisuje se naziv komponente FileListBox.

Potrebno je podesiti svojstvo Filter komponente FilterComboBox da program

može puštati mp3 i wav fajlove. Podešavanje se vrši u FilterEditoru.

FileListBox komponenta služi isključivo za prikaz fajlova jednog foldera.

Svojstva:

Directory – Određuje folder čiji fajlovi se prikazuju kao stavke komponente.Drive – Slovo koje definiše tekući drajv.FileName –Sadrži naziv selektovanog fajla zajedno sa putanjom.Mask – Sadrži masku koja određuje koji fajlovi iz foldera se prikazuju.

DirectoryListBox prikazuje stablo foldera.

Svojstva:

Directory – Određuje selektovani folder.Drive – Slovo koje definiše tekući drajv.FileList – Odfređuje FileListBox komponentu u kojoj se prikazuju fajlovi selektovanog

foldera.

335

DriveComboBox komponenta sadrži nazive jedinica spoljašnje memorije.

DirList – Određuje DirectoryListBox koponentu u kojoj se pristupa folderu selektovanog Drajva.

Drive – Slovo koje definiše tekući drajv.TextCase – Određuje da li se naziv drajva prikazuje malim ili velikim slovima.

tcLowerCase – Mala slova.tcUpperCase – Velika slova.

FilterComboBox komponenta sadrži stavke koje koji su opisi filtera definisani Mask svojstvom.

Svojstva:

FileList – Određuje FileListBox komponentu u kojoj se primenjuje zadati filter.Filter – Odreeđuje trenutno izabranu Masku.Mask – Definiše moguće maske filtera.

Aplikacija poseduje mogućnost proporcionalnog širenja komponenti sa promenom veličine Forme. Problem se rešava pomoću dva svojstva: Align i Anchors.

Align – Sa ovim svojstvom određuje se automatsko menjanje veličine komponente ako se promeni veličina njihovog roditelja..

alNone – Ovo je podrazumevana vrednost, gde komponenta zadržava trenutnu veličinu i položaj u odnosu na gornji levi ugao radnog prostora i svog roditelja.

alTop – Komponenta se uvek zadržava uz gornju ivicu radnog prostora, zadržava visinu i uvek zauzima celu širinu radnog prostora svog roditelja.

alBotton – Komponenta se uvek zadržava uz donju ivicu radnog prostora, zadržava visinu i uvek zauzima celu širinu radnog prostora svog roditelja.

alLeft – Komponenta se uvek zadržava uz levu ivicu radnog prostora, zadržava širinu i uvek zauzima celu širinu radnog prostora svog roditelja.

alRight – Komponenta se uvek zadržava uz desnu ivicu radnog prostora, zadržava širinu i uvek zauzima celu širinu radnog prostora svog roditelja.

alClient – Komponenta uvek popunjava ceo radni prostor svog roditelja.

Anchors – Ovo svojstvo odnosi se na relativni položaj komponente u odnosu na ivice njenog roditelja prilikom menjanja veličine roditelja. Moguće vrednosti od kojih može da se odabere jedna ili više, jesu: akTop (vrh), akBotton (dno), akLeft (levo) i akRight (desno). Obratite pažnju na činjenicu da ako se odabere istovremeno akTop i akBotton

336

ili akRight i akLeft, promenom veličine roditelja promeniće se i veličina komponente.

U praksi, te i mi u ovom primeru, postavićemo na Formu tri Panela jedan ispod drugog. Panel na vrhu podešavamo svojstvo Align na vrednost alTop. Panel u sredini podešavamo svojstvo Align na alClient. Panel na dnu podešavamo svojstvo Align na alButton.

Na gornji Panel postaviti komponente DriveComboBox levo i FilterComboBox desno. Svojstvo Anchors komponente DriveComboBox je: alLeft je true, alTop je true, alRight je true i alButton je false. Svojstvo Anchors komponente FilterComboBox je: alLeft je false, alTop je true, alRight je true i alButton je false.

Na srednji Panel postaviti komponente DirectoryrListBox i FileListBox, a između njih postaviti komponentu Spliter. Kod komponente DirectoryrListBox svojstvo Align je alLeft, a Anchors je: alLeft je true, alTop je true, alRight je false i alButton je true. Kod komponente FileListBox svojstvo Align je alClient, a Anchors je: alLeft je true, alTop je true, alRight je true i alButton je true. Komponenta Spliter se postavi između ove dve komponente.

Na donji Panel postavljena je komponenta ProgressBar i podešeno svojstvo Smooth na true.

ProgressBar je komponenta tipa TprogressBar i predstavlja komponentu napredovanja. Nalazi se na paleti komponenti kartica Win32. Zadatak komponente je da prikaže koji deo zadatka je izvršen.

Svojstva:

Orientacion – Označava položaj kopmponente. Moguće vrednosti su: ttHorizontal (horizontalan položaj) i ttVertical (vertikalan položaj).

Min – Donja granična vrednost.Max – Gornja granična vrednost.Posicion – Predstavlja trenutni položaj.Step – Predstavlja vrednost koraka sa kojom se menja vrednost position.

Spliter je komponenta koja se postavlja između dve komponente koje popunjavaju radni prostor neke kontejnerske komponente. Spliter može da se postavi horizontalno ili vertikalno. Korisnik pomoču Splitera menja veličine komponenti između koji se Spliter nalazi.Komponenta Spliter nalazi se na kartici Additional.

Primer 153:Napraviti aplikaciju koja pretstavlja program za Slušanje muzike. Prilikom

startovanja programa aktivna je ona jedinica memorije, folder i lista fajlova koji su bili otvarani ranijim korišćenjem programa. Ako program nije u stanju da pronađe takvu putanju do foldera, ili se program prvi put startuje, prikazaće se poruka o greški i prazna lista.

Kada korisnik pronađe folder sa pedmama, potrebno je da klikne na odabranu pesmu sa liste. Tada počinje da se sluša ta pesma, ProgressBar prikazuje koji deo pesme se sluša, a na Panelu iznad piše puni naziv pesme i ime izvođača.

Nakon završetka jedne pesme program automatski prelazi na drugu pesmu. Kada završi poslednju pesmu iz liste, automatski prelazi i startuje prvu pesmu sa liste.

337

Rešenje

Za rad sa zvukom koristi se komponeta MediaPleyer koja se nalazi na kartici System. MediaPlayer je vizuelna komponenta izgleda kao na slici:

Play Stop Prev Back Eject

Record Next Step Pause

Tasteri komponente MediaPlayer su:Play – Započinje reprodukciju,Record – Započinje snimanje,Stop – Zaustavlja reprodukciju ili snimanje,Next – Prelazi na sledeću stazu,Prev – Prelazi na prethodnu stazu,Step – Prelazi na sledeći kadar,Back – Prelazi na prethodni kadar,Pause – Privremeno pauzira reprodukciju ili snimanje. Ponovni pritisak na Pausebt taster

nastavlja započetu akciju, iEject – Izbacuje medijum iz uređaja.

Aktiviranje tastera sa komponente je ekvivalentno pozivanju odgovarajuće metode programskim putem.

338

Svojstva:

FileName – Naziv datotekeLength – Ukupna dužina medijuma, izražena jedinicama određenim TimeFormat

svojstvom.Frames - Određuje za koliko frejmova se vrši pomeranje prilikom korišćenja metoda

Back i Next.Position – Izražava trenutnu poziciju medijuma u jedinicama podešenim TimeFormat

svojstvom.Start – Određuje početnu poziciju medijuma izraženu TimeFormat svojstvom.StartPos – Određuje poziciju od koje će se vršiti sledeća reprodukcija izraženo u

jedinicama podešenim TimeFormat svojstvom.TimeFormat – Određuje format u kome se određuju pojedine pozicije medijuma. Mogući

formati su:tfMilliseconds – Milisekunde.tfMSF – Minuti, sekundi i kadrovi.tfFrames – Kadrovi.tfBytes - Bajtovi.

Metode:

Back – Promena položaja medijuma unapred za vrednost definisanu Frames svojsvom.Close – Zatvara uređaj.Eject – Izbacuje uređaj iz medijuma.Next – Pomera položaj medijuma unapred za jednu stazu.Open – Otvara uređaj.Pause – Pauzira reprodukciju ili snimanje.Play – Započinje reprodukciju.Previous – Pomera položaj medijuma unapred za jednu stazu.Step – Pomera položaj medijuma unapred za vrednost definisanu Frames svojstvom.Stop – Zaustavlja reprodukciju ili snimanje.


#include "Muzi_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TfrmPesme *frmPesme;

AnsiString a[1000]; //Spisak pesama.int br=-1,kb+0; //Promenljiva br je redni broj pesme koja se slusa.bool kon=false; //Ako je u toku pesma vrednost je true, a u suprotnom false.//---------------------------------------------------------------------------__fastcall TfrmPesme::TfrmPesme(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------

339

void __fastcall TfrmPesme::FileListBox1Click(TObject *Sender){ Label1->Caption=""; //Naziv pesme i izvodjaca koja se trenutno slusa.

if(kon==true) //U toku je neka pesma, a biramo drugu, moramo prekinuti pesmu. { mepPl->Stop(); //Zaustavi pesmu. Timer1->Enabled=false; //Iskljuci Timer. kon=false; //Pesma se ne slusa. }

br=FileListBox1->ItemIndex; //Redni broj pesme. mepPl->FileName=a[br]; //Nayiv pesme se prosledjuje MediaPlayeru. mepPl->Open(); //Otvaranje. mepPl->Play(); //Pustanje pesme.

Timer1->Interval=mepPl->Length; //Duzina intervala Timera je duzina trajanja pesme. ProgressBar1->Max=mepPl->Length; //Maksimalna duzina ProgressBara je duzina pesme. ProgressBar1->Position=0; //Pocetak pesme te je pozicija ProgressBara jednaka nula. ProgressBar1->Min=0;

Timer1->Enabled=true; //Pustaju se oba Timera, prvi za pesmu, a drugi za prikaz promene //progressBara i procentualni prikaz kroz Labelu. Timer2->Enabled=true; kon=true; //Pustena je muzika.}//---------------------------------------------------------------------------void __fastcall TfrmPesme::FormKeyPress(TObject *Sender, char &Key){ if(Key==27) //Sa tasterom Esc prekida se pesma. { mepPl->Stop(); kon=false; }}//---------------------------------------------------------------------------void __fastcall TfrmPesme::Timer1Timer(TObject *Sender){ br++; //Predju na sledecu pesmu. if(br==FileListBox1->Items->Count) Ako je poslednja mora se preci na prvu pesmu u listi. { mepPl->Stop(); //Zaustavlja se prethodna pesma. kon=false; //Nije pustena pesma. br=0; //Pocetak liste pesama. Timer1->Enabled=false; //Svi Timeri iskljuceni. Timer2->Enabled=false; }

mepPl->FileName=a[br]; //Uzimamo naziv pesme sa putanjom. mepPl->Open(); mepPl->Play(); //Pustamo pesmu.

340

kon=true; //Pesma je pustena.

ProgressBar1->Min=0; Timer2->Enabled=true;

FileListBox1->ItemIndex=br;

Timer1->Interval=mepPl->Length; ProgressBar1->Max=mepPl->Length; ProgressBar1->Position=0;}//---------------------------------------------------------------------------void __fastcall TfrmPesme::FormActivate(TObject *Sender){ int i,n;

n=FileListBox1->Items->Count; for(i=0;i<n;i++) a[i]=FileListBox1->Items->Strings[i]; //Nayive pesama upisati u niz.}//---------------------------------------------------------------------------void __fastcall TfrmPesme::FilterComboBox1Change(TObject *Sender){ int i,n;

n=FileListBox1->Items->Count; for(i=0;i<n;i++) a[i]=FileListBox1->Items->Strings[i];}//---------------------------------------------------------------------------void __fastcall TfrmPesme::Timer2Timer(TObject *Sender){ int proc;

ProgressBar1->Position=mepPl->Position; proc=(100*ProgressBar1->Position)/ProgressBar1->Max; Label2->Caption=IntToStr(proc)+"%";

if((kb==FileListBox1->Items->Count-1)&&(br<0))Label1->Caption=a[kb]; else Label1->Caption=a[br];

if(proc==100) { Timer1->Enabled=false; //Istekla pesma. mepPl->Stop(); //Zaustavljamo pesmu. Timer1Timer(Sender); //Prvi tajmer sluzi za pustanje pesme, a drugi Timer za

//procentualni prikaz utosenog vremena od ukupne //duzine trajanja pesme.

}}//---------------------------------------------------------------------------void __fastcall TfrmPesme::FormCreate(TObject *Sender){

341

Label2->BringToFront();

Parametri = new TStringList();

//Sta je poslednje slusano, zapisano je u fajlu setings.dat koji se obavezno //nalazi gde i exe fajl nase aplikacije.

ParametriFile = IncludeTrailingPathDelimiter(ExtractFilePath(Application>ExeName))+

"settings.dat"; try{ //ovde pocinje blok koji je zasticen od Exception-a Parametri->LoadFromFile(ParametriFile); }catch(Exception* e){

//ovde pocinje blok koji kaze sta da se radi ako je Exception nastao ShowMessage("Nema foldera od proslog puta sa muzikom!!"); }}//---------------------------------------------------------------------------void __fastcall TfrmPesme::FormClose(TObject *Sender, TCloseAction &Action){ if(Timer1->Enabled)mepPl->Close();}//---------------------------------------------------------------------------void __fastcall TfrmPesme::FormDestroy(TObject *Sender){ Parametri->Values["STARTUP_PATH"] = DirectoryListBox1->Directory; try{ Parametri->SaveToFile(ParametriFile); }catch(Exception* e){ } Parametri->Free();}//---------------------------------------------------------------------------void __fastcall TfrmPesme::FormShow(TObject *Sender){ if(Parametri->Values["STARTUP_PATH"]!=""){ AnsiString path = Parametri->Values["STARTUP_PATH"]; DriveComboBox1->Drive = ExtractFileDrive(path)[1]; DirectoryListBox1->Directory = path; }}//---------------------------------------------------------------------------

Primer 154:Napraviti aplikaciju koja pretstavlja interfejs Tekst procesor-a. Aplikacija poseduje: glavni

meni, PopupMenu i paletu dugmadi, koje su povezane ActionList komponentom. Glavni meni sastoji se od stavki: File (New, Open, Save, SaveAs i Exit), Edit (Undo, Cut, Copy, Paste i SelectAll) i Format (Font i Colors). PopupMenu sastoji se od stavki: Undo, Cut, Copy, Paste, SelectAll , Font i Colors. Na traci sa alatkama nalaze se dugmadi New, Open, Save, Cut, Copy i Paste. Tekst se prikazuje u komponenti Memo. Stavke Edita automatski ugradite pomoću ActionList komponente.

342

Rešenje

ImageList komponenta je nevizuelna komponenta koja može sadržati veliki broj slika jednakih dimenzija. Najčešće se te slike koriste na paletama alatki ili menijima.Komponenta se nalazi na kartici Win32. Svojstvo Width i Height su tipa int i određuju dimenzije svih slika u listi. Prilikom promena vrednosti ovih svojstava, sadržaj liste se uništi, te ih zbog toga treba podesiti pre stavljanja prve slike u listi.Svojstvo Count je tipa int i označava broj slika u listi slika. Ovo svojstvo se ne može menjati tokom projektovanja.

Duplim klikom na sličicu ImageList u prozoru aplikacije pojaviće se ImageListEditor.

Pritiskom na dugme Add otvara se prozor za dialog u kome mogu da se odaberu slike tipa bmp ili ico.

Trenutni sadržaj liste prikazuju se unutra okvira Images, pri čemu se ispod slike nalazi i indeks slike u listi. Indeks slike u listi kreće od nule.Prenumeracija indeksa postiže se prevlačenjem slika pomoću miša.

Odabrana slika brise se sa dugmetom Delete ili tasterom Delete, a zamene slike vrši se sa dugmetom Replace.

Komponenta ToolBar e kontejnerska komponenta namenjena za izradu Palete komponenti. Komponenta se nalazi na kartici Win32. Sve komponente na traci sa alatkama imaju istu visinu. Svojstvo Images pretstavlja listu slika iz koje mogu da se biraju sličice za iscrtavanje na dugmadima za alatke. Svojstvo HotImages pretstavljaju listu slika iz koje mogu iz koje mogu da se biraju sličice za iscrtavanje na dugmadi za alatke iznad kojih se trenutno nalazi pokazivač miša. Svojstvo DisabledImages pretstavljaju listu slika iz koje mogu da se biraju sličice za iscrtavanje na neupotrebljenoj dugmadi za alatke.

343

Svojstvo Buttons pretstavljaju pojedinačni dugmadi na traci za alatke. Dugmadi se za vreme projektovanja dodaju izborom jedna od stavki NewButton (novo dugme) ili NewSeparator (novi razdvajač), u pomoćnom meniju koji se otvara kada se desnim tasterom miša pritisne traka sa alatkama. Na traku sa alatkama mogu se dodavati i druge komponente, kao i kod drugih kontejnerskih komponenti.

Najčešće se u praksi za sličice menija koristi jedna lista koja sadrži sličice formata 16x16, dok se za trake sa alatkama koriste tri liste (na slici jedne ispod drugih) koje su formata 24x24. Mora se voditi računa o tome da indeksi sličica u sve tri liste slika moraju da se poklapaju.

Kada dodamo novu Akciju u ActionList komponenti, desi klik na akciju i izaberemo opciju NewStandardAction iz kontekst menija, pojaviće se prozor kao na slici. Izvršimo prevlačenje cele grupe Edit u ActionListEditor i rešili smo svu potrebnu priču vezanu za programeranje akcija iz grupe Edit.

Primer 155:Napraviti aplikaciju koja pretstavlja Tekst procesor. Aplikacija poseduje: glavni meni,

PopupMenu i paletu dugmadi, koje su povezane ActionList komponentom. Glavni meni sastoji se od stavki: File (New, Open, Save, SaveAs i Exit), Edit (Undo, Cut, Copy, Paste i SelectAll) i Format (Font i Colors). PopupMenu sastoji se od stavki: Undo, Cut, Copy, Paste, SelectAll , Font i Colors. Na traci sa alatkama nalaze se dugmadi New, Open, Save, Cut, Copy i Paste. Tekst se

344

prikazuje u komponenti Memo. Stavke Edita automatski ugradite pomoću ActionList komponente. Na Paleti alatki nalazi se Panel na kome se prikazuje sistemsko vreme.

Rešenje

TeksProcesor.hpp

//---------------------------------------------------------------------------#ifndef Text_oH#define Text_oH//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <StdCtrls.hpp>#include <Forms.hpp>#include <ComCtrls.hpp>#include <Menus.hpp>#include <ToolWin.hpp>#include <ImgList.hpp>#include <ActnList.hpp>#include <Dialogs.hpp>#include <StdActns.hpp>#include <ExtCtrls.hpp>//---------------------------------------------------------------------------class TForm1 : public TForm{__published: // IDE-managed Components

345

TMainMenu *MainMenu1; TPopupMenu *PopupMenu1; TMenuItem *File1; TMenuItem *Edit1; TMenuItem *Format1; TMenuItem *new1; TMenuItem *Open1; TMenuItem *Save1; TMenuItem *SaveAs1; TMenuItem *N1; TMenuItem *Exit1; TMenuItem *Undo1; TMenuItem *N2; TMenuItem *Cut1; TMenuItem *Copy1; TMenuItem *Paste1; TMenuItem *N3; TMenuItem *SelectAll1; TMenuItem *Font1; TMenuItem *ChangeCase1; TMenuItem *Undo2; TMenuItem *N4; TMenuItem *Cut2; TMenuItem *Copy2; TMenuItem *Paste2; TMenuItem *N5; TMenuItem *SelectAll2; TMenuItem *N6; TMenuItem *Font2; TMenuItem *ChangeCase2; TMemo *Memo1; TToolBar *ToolBar1; TToolButton *ToolButton1; TToolButton *ToolButton2; TToolButton *ToolButton3; TToolButton *ToolButton4; TToolButton *ToolButton5; TToolButton *ToolButton6; TToolButton *ToolButton7; TImageList *TBIL; TImageList *TBHIL; TImageList *TBDIL; TImageList *Ikonice; TActionList *Akcije; TFontDialog *FontDialog1; TOpenDialog *OpenDialog1; TSaveDialog *SaveDialog1; TAction *New; TAction *Open; TAction *Save; TAction *SaveAs;

346

TAction *Exit; TEditCut *EditCut1; TEditCopy *EditCopy1; TEditPaste *EditPaste1; TEditSelectAll *EditSelectAll1; TEditUndo *EditUndo1; TAction *Font; TToolButton *ToolButton8; TPanel *Panel1; TTimer *Timer1; TAction *Colors; TColorDialog *ColorDialog1; void __fastcall Timer1Timer(TObject *Sender); void __fastcall FormCreate(TObject *Sender); void __fastcall ExitUpdate(TObject *Sender); void __fastcall ExitExecute(TObject *Sender); void __fastcall Memo1Change(TObject *Sender); void __fastcall NewUpdate(TObject *Sender); void __fastcall NewExecute(TObject *Sender); void __fastcall OpenUpdate(TObject *Sender); void __fastcall OpenExecute(TObject *Sender); void __fastcall SaveUpdate(TObject *Sender); void __fastcall SaveExecute(TObject *Sender); void __fastcall SaveAsUpdate(TObject *Sender); void __fastcall SaveAsExecute(TObject *Sender); void __fastcall FormCloseQuery(TObject *Sender, bool &CanClose); void __fastcall FontUpdate(TObject *Sender); void __fastcall FontExecute(TObject *Sender); void __fastcall ColorsUpdate(TObject *Sender); void __fastcall ColorsExecute(TObject *Sender);private: // User declarations AnsiString FileName; bool Modified;

public: // User declarations bool SaveChangess(); bool Savee(); bool SaveAss(); __fastcall TForm1(TComponent* Owner);};//---------------------------------------------------------------------------extern PACKAGE TForm1 *Form1;//---------------------------------------------------------------------------#endif

TeksProcesor.cpp


347

#include "Text_o.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TForm1 *Form1;//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::Timer1Timer(TObject *Sender){ String sh,sm,ss; Word h,m,sek,msec,dan;

DecodeTime(Time(),h,m,sek,msec);

if(h<10) sh="0"+IntToStr(h); else sh=IntToStr(h); if(m<10) sm="0"+IntToStr(m); else sm=IntToStr(m); if(sek<10) ss="0"+IntToStr(sek); else ss=IntToStr(sek);

Panel1->Caption=sh+":"+sm+":"+ss;}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){ Timer1Timer(Sender); Application->Title=this->Caption; NewExecute(Sender);}//-------------------------------------------------------------------bool TForm1::SaveChangess(){ bool Result;

//Prikaz poruke sa tri dugmeta kao na slici: switch(MessageDlg("Da li zelite snimiti dokument "+

FileName+"?",mtConfirmation,mbYesNoCancel,0)) {

case mrYes: Result=Savee(); //Snimaj. break; case mrNo: Result=true; //Prihvatam promene. break; case mrCancel: Result=false; //Odustajem od promena. break;

348

}

return Result;}//---------------------------------------------------------------------------bool TForm1::Savee(){ bool Result;

if(FileName=="") Result=SaveAss(); //Snimi pod novim imenom. else{ Memo1->Lines->SaveToFile(FileName); //Snimi fajl. Modified=false; Result=true; //Snimanje uspesno zavrseno. }

return Result; }//---------------------------------------------------------------------------bool TForm1::SaveAss(){ bool Result;

SaveDialog1->FileName=FileName; //Pomocu dialoga SaveDialog zadaje se ime fajla.

if(SaveDialog1->Execute()) { FileName=SaveDialog1->FileName; Savee();

Caption=Application->Title+" - "+FileName; Result=true; //Uspesno zavrseno snimanje. }else Result=false; //Odustalo se od snimanja.

return Result;}//---------------------------------------------------------------------------void __fastcall TForm1::ExitUpdate(TObject *Sender){ Exit->Enabled=true; //Uvek aktivna akcija.}//---------------------------------------------------------------------------

//---------------------------------------------------------------------------void __fastcall TForm1::ExitExecute(TObject *Sender){ this->Close(); //Zatvaranje forme.}//---------------------------------------------------------------------------

349

void __fastcall TForm1::Memo1Change(TObject *Sender){ Modified=true; //Desila se izmena teksta.}//---------------------------------------------------------------------------void __fastcall TForm1::NewUpdate(TObject *Sender){ New->Enabled=true; //Uvek je aktivna opcija novi fajl.}//---------------------------------------------------------------------------void __fastcall TForm1::NewExecute(TObject *Sender){ if(!Modified || SaveChangess()) { Memo1->Text=""; Modified=false; FileName=""; Caption=Application->Title+" - [Untitled]"; }}//---------------------------------------------------------------------------void __fastcall TForm1::OpenUpdate(TObject *Sender){ Open->Enabled=true; //Uvek aktivna opcija.}//---------------------------------------------------------------------------void __fastcall TForm1::OpenExecute(TObject *Sender){ if(!Modified || SaveChangess()) { if(OpenDialog1->Execute()) { FileName=OpenDialog1->FileName; Memo1->Lines->LoadFromFile(FileName); Modified=false; Caption=Application->Title+" - "+FileName; } }}//---------------------------------------------------------------------------void __fastcall TForm1::SaveUpdate(TObject *Sender){ Save->Enabled=Modified; //Ima smisla snimati ako je bilo promena teksta.}//---------------------------------------------------------------------------//---------------------------------------------------------------------------void __fastcall TForm1::SaveExecute(TObject *Sender){ if(Modified) Savee(); //Poziva se metoda koja vrši snimanje.}//---------------------------------------------------------------------------

350

void __fastcall TForm1::SaveAsUpdate(TObject *Sender){ SaveAs->Enabled=true; //Uvek aktivna akcija.}//---------------------------------------------------------------------------void __fastcall TForm1::SaveAsExecute(TObject *Sender){ SaveAss();}//---------------------------------------------------------------------------void __fastcall TForm1::FormCloseQuery(TObject *Sender, bool &CanClose){ CanClose = !Modified || SaveChangess();}//---------------------------------------------------------------------------void __fastcall TForm1::FontUpdate(TObject *Sender){ Font->Enabled=true; //Uvek aktivna akcija.}//---------------------------------------------------------------------------void __fastcall TForm1::FontExecute(TObject *Sender){ if(FontDialog1->Execute()) { Modified=true; Memo1->Font=FontDialog1->Font; //Menjamo font- }}//---------------------------------------------------------------------------void __fastcall TForm1::ColorsUpdate(TObject *Sender){ Colors->Enabled=true; //Uvek aktivna akcija.}//---------------------------------------------------------------------------void __fastcall TForm1::ColorsExecute(TObject *Sender){ if(ColorDialog1->Execute()) { Modified=true; Memo1->Color=ColorDialog1->Color; //Menjamo boju Memo komponente. }}//---------------------------------------------------------------------------

351

Documents

Osnove Programiranja C++ Builder Enterprise