SVEUČILIŠTE U RIJECI EKONOMSKI FAKULTET

VEDRAN MEDICA - VIOLA

PROGRAM ZA ANALIZU VALUTNIH TOKOVA GRAĐEN PROGRAMSKIM JEZIKOM C++

DIPLOMSKI RAD

Rijeka, 2015.

SVEUČILIŠTE U RIJECI EKONOMSKI FAKULTET

PROGRAM ZA ANALIZU VALUTNIH TOKOVA GRAĐEN PROGRAMSKIM JEZIKOM C++

DIPLOMSKI RAD

Kolegij: Objektno programiranje Mentor: Prof. dr. sc. Marina Čičin - Šain Student: Ime i prezime: Vedran Medica - Viola

Studijski smjer: Redovni studij Poslovne ekonomije - Informatičko poslovanje JMBAG: 0069045395

Rijeka, lipanj 2015.

SADRŽAJ

1. UVOD ......................................................................................................................................... 1

2. PROGRAMSKI JEZIK C++ .................................................................................................. 3

2.1. C++ - programski jezik niske razine ........................................................................... 3

2.2. Standardizacija programskog jezika C++ ................................................................... 3

2.3. Najčešći problemi uzrokovani korištenjem programskog jezika C++...................... 4

2.4. Uporaba programskog jezika C++ u informatičkim tehnologijama ......................... 5

2.5. Izvori znanja o programskom jeziku C++ .................................................................. 6

3. PROGRAMSKI PAKET Qt ................................................................................................... 7

3.1. Dozvole za korištenje programa Qt ............................................................................ 8

3.2. Statičko i dinamičko kompiliranje .............................................................................. 8

3.3. Prednosti programa Qt u odnosu na ostale programe za razvoj aplikacija ............... 9

3.4. Izvori znanja o programu Qt........................................................................................ 9

4. OBJEKTNO ORIJENTIRANO PROGRAMIRANJE..................................................... 11

4.1. Priprema za objektno orijentirano programiranje .................................................... 11

4.2. Principi objektno orijentiranog programiranja ......................................................... 12

4.2.1. Apstrakcija..................................................................................................... 12

4.2.2. Klasifikacija .................................................................................................. 12

4.3. Značajke objektno orijentiranog programiranja ....................................................... 13

5. RAČUNALNI PROGRAM "TESTNO1"........................................................................... 14

5.1. Izvori podataka o odnosima valutnih tečajeva ......................................................... 14

5.2. Shema računalnog programa "Testno1" ................................................................... 15

5.3. Funkcionalnost računalnog programa "Testno1" ..................................................... 16

5.3.1. "Main" ........................................................................................................... 17

5.3.2. "MainWindow" .............................................................................................. 18

5.3.3. "Grafikon" ..................................................................................................... 32

5.3.4. "Krivulje"....................................................................................................... 49

6. ZAKLJUČAK.......................................................................................................................... 60

LITERATURA .................................................................................................................................. 61

POPIS SLIKA ................................................................................................................................... 63

1

1. UVOD

Za potrebe svojeg diplomskog rada autor gradi jednostavan računalni program "Testno1".

Namjena program je analiza valutnih tečajeva.

Tijekom studija Informatičkog poslovanja na Ekonomskom fakultetu Sveučilišta u Rijeci autor

stječe znanja i iskustva o programiranju. Autor tada najčešće koristi programski jezik VBA (eng.

Visual Basic for Applications). Autor smatra da je VBA vrlo koristan jezik, jer omogućuje

značajno širenje mogućnosti programskog paketa Microsoft Office i prilagodbu korisniku.

VBA je interpreterski jezik. Zbog toga je izvođenje računalnih programa pisanih programskim

jezikom VBA poprilično dugotrajno. U potrazi za bržim programskim jezikom autor uzima u

obzir programske jezike Java, Python, Objektni C i C++. Programski jezik Java autor smatra

suviše jednostavnim. Jednostavnost je prednost programskog jezika, no ona istovremeno

ograničava mogućnosti programskog jezika. Programski jezici Python i Objektni C pokazuju

potencijal da u budućnosti zamijene C++. No intenzitet dosadašnje uporabe programskog jezika

C++ u informatičkim tehnologijama i činjenica da je to standardiziran programski jezik uvelike

su utjecale na autorovu odluku da počne učiti korištenje programskog jezika C++. U početku je

autor bio svjestan složenosti programskog jezika C++ i dugotrajnosti procesa učenja, no autor je

uvjeren da će mu poznavanje programskog jezika C++ u budućnosti biti vrlo korisno, a rad s

navedenim programskim jezikom izuzetno plodan.

Kada je bio odabran programski jezik, bilo je potrebno odabrati računalni program i kompilator

(eng. compiler), kojima će biti građen autorov program. U početku, za potrebe učenja

programskog jezika autor rabi računalni program Code::Blocks. To je vrlo rasprostranjen

programski jezik za razvoj C++ programa, no on ne sadrži napredne alate za razvoj grafičkog

sučelja.

Autor razmatra korištenje programa Microsoft Visual Studio i Qt. Postoje i drugi poznati

programi za razvoj grafičkog sučelja pomoću programskog jezika C++, no oni su vezani za

2

druge operativne sustave. Program Microsoft Visual Studio je najpoznatiji program za razvoj

grafičkog sučelja za programe namijenjene radu na operativnom sustavu Microsoft Windows.

Nažalost, on je ograničen na razvoj programa, koji se mogu pokretati samo operativnim

sustavom Microsoft Windows. Program Qt može pak vrlo jednostavno prenamijeniti građeni

program za različite operativne sustave. Korištenje besplatne inačice programa Microsoft Visual

Studio vremenski je ograničeno na 30 dana, dok je korištenje besplatne inačice programa Qt

ograničeno na dinamičko kompiliranje, o kojemu će više riječi biti u nastavku. Drugim riječima,

korištenje programa Qt besplatno je sve dok se distribuira program s otvorenim kodom, odnosno

dok autor programa ne zarađuje od programa. Sada se već može zaključiti da je autor odabrao

program Qt kao okruženje u kojemu će biti razvijen program "Testno1".

Prvim dijelom ovog diplomskog rada autor pobliže opisuje programski jezik C++ i program Qt

te uspoređuje linearno i objektno programiranje i ukazuje na česte probleme, koji nastaju tijekom

objektno orijentiranog programiranja. Drugim dijelom ovog diplomskog rada autor predstavlja i

opisuje važnije dijelove programskog koda programa "Testno1".

3

2. PROGRAMSKI JEZIK C++

C++ je objektno orijentiran, ANSI i ISO standardiziran programski jezik niske razine. (Davis

2004)

2.1. C++ - programski jezik niske razine

Računalni jezik nije hrvatski, engleski ili neki drugi ljudski jezik, već je to binarni jezik, odnosno

skup različitih permutacija nula i jedinica. Binarni jezik je jezik najniže razine. Programeri više

ne pišu programe u binarnom kodu. Programeri danas pišu programski kod u programskim

jezicima koji nalikuju (najčešće) engleskom jeziku. Programski kod je potrebno zatim prevesti u

binarni jezik, koji računalo razumije i može izvršiti.

Zbog jednostavnosti autor dijeli programske jezike u samo dvije skupine: interpreterske jezike i

programske jezike niske razine. Programski jezici niske razine se prije distribucije kompiliraju

(eng. compile), odnosno prevode u računalni, binarni jezik. Stoga ih računalo korisnika prilikom

izvršavanja ne mora prevoditi. Programi pisani interpreterskim jezicima se distribuiraju

neprevedeni. Računalo korisnika ih mora prevoditi (interpretirati) prilikom izvođenja, čime se

uočljivo usporava izvođenje programa. Treba imati na umu da se na računalu korisnika prije

izvođenja programa pisanog interpreterskim programskim jezikom mora nalaziti program, koji

služi kao interpreter, što dodatno otežava distribuciju takvih programa. (Davis 2004)

2.2. Standardizacija programskog jezika C++

ISO/IEC JTC1/SC22/WG21 je međunarodna grupa za standardizaciju, koja se bavi

standardizacijom programskog jezika C++. Prvi "International Standard ISO/IEC 14882

Programming Language C++", standard o programskom jeziku C++ objavljen je 1998. godine.

Posljednji standard (poznatiji kao c++14) objavljen je 2014. godine. (DTU 2014) (C++14 2015)

4

Standardizacija programskog jezika umanjuje mogućnost stvaranja različitih inačica

programskog jezika. Drugim riječima, ujednačava se korištenje standardiziranog programskog

jezika za sve korisnike. Stoga je distribucija programa građenih standardiziranim programskim

jezikom uvelike jednostavnija. (Davis 2004)

2.3. Najčešći problemi uzrokovani korištenjem programskog jezika C++

Programski jezik C++ omogućava programeru da izgradi program, koji može izvršavati širok

spektar zadataka na niskim i visokim razinama. Ostali programski jezici, poput programskog

jezika Java i VBA omogućuju izvršavanje samo pojedinih zadataka na visokim razinama. Stoga

je korištenjem programskoj jezika C++ mnogo lakše napraviti grešku, odnosno uzrokovati

neželjeno ponašanje programa. Autor programskog jezika Bjarne Stroustrup je izjavio: "C

olakšava da sami sebe upucate u stopalo; C++ to otežava, no kada to učinite on vam raznese

cijelu nogu." (Bjarne Stroustrup 2014) (Atwood 2007)

Najčešći problem s kojim se suočavaju programeri, koji koriste C++ je alokacija memorije (eng.

memory allocation). Programski jezik C++ mora pronaći dovoljno mjesta u memoriji računala,

na koju će se pohraniti vrijednost svake varijable. C++ koristi pokazivače (eng. pointer) koji

ukazuju na odgovarajuću adresu u memoriji računala. Program može promijeniti adresu na koju

pokazivač ukazuje. Ukoliko je pogreškom programera krivo definirana nova adresa, tada dolazi

do neželjenog ponašanja programa. Naime program mijenja vrijednost na adresi (krivo)

definiranoj pokazivačem i tako mijenja vrijednost, koja nije trebala biti promijenjena. To može

dovesti do brisanja podataka iz računala ili neoptimalnog rada ostalih programa. (Davis 2004)

(new(C++) 2014)

Česti problem vezan uz alokaciju memorije odnosi se na prikupljanje ostataka (eng. garbage

collection). Svaku varijablu za koju je alocirana memorija u računalu, potrebno je izbrisati nakon

korištenja, odnosno potrebno je osloboditi (dealocirati) memoriju u računalu za programe koji će

biti naknadno izvođeni. Ukoliko se to ne učini, dolazi do curenja memorije (eng. memory leak).

Pri svakom izvođenju programa se zauzima dio slobodne radne memorije računala. Po završetku

izvođenja očekuje se da se ista količina radne memorije oslobodi. Kod curenja memorije dio

5

radne memorije se ne oslobađa. Stoga bi se ponovljenim pokretanjem takvog programa iscrpila

sva radna memorija. (Davis 2004) (new(C++) 2014)

Većina programskih jezika na višim razinama automatski prikuplja ostatke i sprečava curenje

memorije, no C++ to ne čini automatski. Stoga je posebnu pozornost prilikom programiranja

potrebno posvetiti alokaciji memorije. Ipak, program Qt, opisan u nastavku pri kompiliranju

dodaje komande za automatsko oslobađanje memorije. (Davis 2004) (new(C++) 2014)

2.4. Uporaba programskog jezika C++ u informatičkim tehnologijama

Većina poznatih programa razvijeno je programskim jezikom C++. Poznatiji primjeri su:

− operativni sustavi (Microsoft Windows 95, 98, 2000, NT, XP, Vista, 7, 8, OS X, iOS,

Symbian OS),

− pretraživači Interneta (Google Chrome, Mozilla Firefox, Safari, Opera),

− Internet servisi (Google, YouTube, Facebook, Bloomberg, Amazon.com),

− programski paket Adobe (Photoshop, Illustrator, Acrobat, Lightroom, AfterEffects),

− CAD programi (Dassault Catia, većina programa proizvođača Autodesk).

Poduzeće Lockheed-Martin Aero gradi programe za vojne avione F-16 i F-35 u programskom

jeziku C++. Poduzeće MAN B&W Diesel A/S u programskom jeziku C++ gradi programe za

veća vozila i programe za upravljanje ubrizgavanjem goriva u motore snage veće od

100.000.kW. Poduzeće NASA je programskim jezikom C++ izgradila program kojime se

upravlja teleskopom James Webb, nasljednikom teleskopa Hubble. Poduzeće NASA također

programima razvijenim u programskom jeziku C++ upravlja vozilima na Marsu (Mars rover).

Poduzeće Siemens programskim jezikom C++ razvija programe za upravljanje medicinskom

opremom. U istraživačkom centru CERN programi za prikupljanje i analizu podataka razvijeni

su programskim jezikom C++. Većina sustava europskih telekomunikacijskih poduzeća

(Vodaphone, T-Mobile) razvijena je programskim jezikom C++. (Stanley 2015) (Shastri 2015)

6

Treba napomenuti da su i programski paket Microsoft Office i sâm programski jezik VBA,

odnosno Microsoft Visual Basic kompilator (eng. compiler) građeni programskim jezikom C++.

(Stanley 2015) (Shastri 2015)

2.5. Izvori znanja o programskom jeziku C++

Autor diplomskog rada je počeo stjecati znanje o programskom jeziku kroz skupinu video

udžbenika "Buckys C++ Programming Tutorials" dostupnih na Internet servisu The New Boston

(The New Boston 2011) i YouTube (Buckys C++ Programming Tutorials 2011). Navedeni video

udžbenici su vrlo osnovni i neozbiljni, no istovremeno vrlo zabavni i jednostavni za praćenje.

Autor smatra da su ovi video udžbenici savršen način za probiti debeli led savladavanja složenog

i teško savladivog programskog jezika C++.

Za autora su prilikom daljnjeg savladavanja programskog jezika C++ najkorisniji izvori znanja

bili knjiga "C++ for Dummies" (Davis 2004) te dokumentacija (C Plus Plus 2015) dostupna

putem Interneta.

Knjiga "C++ for Dummies" (Davis 2004) bila je autoru vrlo razumljiva nakon praćenja

navedenih video udžbenika. Autor diplomskog rada je veći dio knjige razumio i s lakoćom pratio

primjere. No posljednjih nekoliko poglavlja, koja opisuju složenije mogućnosti programskog

jezika C++ (poput šablona, eng. template) autor je morao preskočiti zbog nepotpunog

razumijevanja i nedostatka prakse u programiranju.

Dokumentacija (C Plus Plus 2015) sadrži reference i metodološki obrađen popis svih funkcija

programskih jezika C i C++. Osim toga sadrži korisne informacije i video udžbenike o

programskim jezicima C i C++ te vrlo koristan forum.

Osim navedene, autor je promatrao i druge knjige. jedna od njih je knjiga "Learn C++ for Game

Development" (Sutherland 2014). Ona je na prvi pogled bila zanimljiva autoru diplomskog rada,

no detaljnijim čitanjem autor zaključuje da knjiga ne dovodi značajnija nova saznanja u odnosu

na knjigu "C++ for Dummies" (Davis 2004).

7

3. PROGRAMSKI PAKET Qt

program Qt je sveobuhvatno okruženje za razvoj C++ računalnih programa s grafičkim sučeljem.

Programi se u programu Qt razvijaju po principu "pisati jednom, kompilirati (eng. compile) bilo

gdje". To znači da programeri mogu napisati jedan, zajednički izvorni kod (eng. source code) za

program koji će biti izvođen na različitim operativnim sustavima (Microsoft Windows, Mac OS,

Linux i mnogim drugim). Slika 1 predočava grafičko sučelje računalnog programa "Qt".

(Blanchette i Summerfeld 2008)

Slika 1. Grafičko sučelje računalnog programa "Qt"

8

3.1. Dozvole za korištenje programa Qt

Za razvoj i distribuciju komercijalnih programa potrebno je kupiti komercijalnu dozvolu za

korištenje programa Qt od poduzeća Trolltech. Za razvoj i distribuciju otvorenih (besplatnih)

programa može se koristiti besplatna dozvola GPL/LGPL. (Blanchette i Summerfeld 2008)

GPL/LGPL dozvola dozvoljava distribuciju programa, no on mora biti otvoren, odnosno uz

program se mora distribuirati i izvorni kod. Time se omogućuje korisniku da mijenja i

prilagođava program te ga osobno distribuira bez dodatnih naknada. (GNU General Public

License 2015) (GNU Lesser General Public License 2015)

Razlika između komercijalne i nekomercijalne inačice programa Qt očituje se u načinu

kompiliranja. U oba slučaja izvorni kod je isti. Statičko i dinamičko kompiliranje detaljnije su

opisani sljedećim poglavljem.

3.2. Statičko i dinamičko kompiliranje

Kompiliranje (eng. compile) je prevođenje izvornog koda pisanog programskim jezikom C++ (ili

nekim drugim) u binarni jezik, koji može računalo izvršavati. Svaki program sadrži izvorni kod,

a većina programa sadrži i DLL-ove (knjižnice dinamičkih poveznica, eng. Dynamic Link

Library), u kojima su već zapisane funkcije korištene u izvornom kodu. (Blanchette i

Summerfeld 2008)

Statičkim kompiliranjem gradi se program, koji sadrži sve dokumente u kojima je pohranjen

izvorni kod i DLL-ove u jednom zajedničkom izvršnom dokumentu (eng. executable file).

(Blanchette i Summerfeld 2008)

Dinamičkim kompiliranjem gradi se program, koji sadrži jedan izvršni dokument, no izvršni

kod i DLL-ovi pohranjeni su u ostalim dokumentima. Dokumenti u kojima je pohranjen izvorni

kod mogu se ponovo učitati u program Qt, gdje se mogu naknadno mijenjati i kompilirati.

(Blanchette i Summerfeld 2008)

9

Dozvola GPL/LGPL ne obuhvaća statičko kompiliranje. Za to je potrebno kupiti komercijalnu

dozvolu za korištenje programa Qt od poduzeća Trolltech.

3.3. Prednosti programa Qt u odnosu na ostale programe za razvoj aplikacija

Potrebno je istaknuti tri najznačajnije prednosti:

− Program Qt smije se besplatno koristiti u neograničenom vremenskom razdoblju za

razvoj otvorenih aplikacija.

− Program Qt omogućuje prenamjenu programa za izvođenje u različitim operativnim

sustavima. Dovoljno je napisati jedan izvorni kod, te se temeljem njega kompilira

program namijenjen za izvođenje u odgovarajućem operativnom sustavu.

− Dostupna kvalitetna podrška putem Interneta. Dostupna je vrlo opširna, detaljna i

metodološki obrađena dokumentacija (The Qt Company 2015) i knjižnice s mnogo

besplatnih korisnih dodataka građenih od strane poduzeća Trolltech i od strane drugih

korisnika.

3.4. Izvori znanja o programu Qt

Za autora su prilikom učenja korištenja programa Qt najkorisniji izvori znanja bili službena

knjiga poduzeća Trolltech "C++ GUI Programming with Qt" (Blanchette i Summerfeld 2008) i

već spomenuta dokumentacija (The Qt Company 2015) dostupna putem Interneta.

Knjiga "C++ GUI Programming with Qt" (Blanchette i Summerfeld 2008) opširno i detaljno

opisuje razvoj različitih programa u okruženju, koje donosi program Qt. Pritom se služi

praktičnim i korisnim primjerima. Za proučavanje knjige potrebno je osnovno poznavanje

programskog jezika C++, Java ili Objektni C. Ukoliko navedeno znanje čitatelj ne posjeduje,

knjiga donosi sažete osnove programskog jezika C++.

Dokumentacija (The Qt Company 2015) sadrži popis i opis svih modula i razreda, sadržanih u

programu Qt, u inačicama 4.8 i 5.4. Osim toga, sadrži i upute za korištenje programa Qt, upute

10

za licenciranje te različite primjere i video udžbenike (eng. tutorials). Dokumentacija se s

velikom lakoćom pretražuje i pruža vrlo detaljan uvid u sve mogućnosti programa Qt.

Autor diplomskog rada je tijekom stjecanja znanja o programu Qt i tijekom razvoja programa

"Testno1" odgovore na sva svoja pitanja i nedoumice pronalazio i na forumima poput Stack

Overflow (Stack Exchange, Inc. 2015) i cplusplus.com (C Plus Plus 2015).

kao i za programski jezik C++, tako i za program Qt postoje mnogobrojni video udžbenici

dostupni putem Interneta. Među njima autor ističe skupinu video udžbenika nazvanih

jednostavno "C++ Qt" dostupnih putem Internet servisa VoidRealms (VoidRealms, LLC 2015) i

YouTube (C++ Qt 2011). Iako nije isti autor, način objašnjavanja vrlo je sličan onome pri već

navedenim video udžbenicima za C++ "Buckys C++ Programming Tutorials" (The New Boston

2011). Autor nije počeo savladavati program Qt praćenjem ovih video udžbenika, no ipak su mu

uvelike pomogli pri savladavanju problema pri učenju.

11

4. OBJEKTNO ORIJENTIRANO PROGRAMIRANJE

OOP (objektno Orijentirano Programiranje, eng. Object Oriented Programming) u središtu

pozornosti ima objekte, a ne akcije, odnosno u središtu pozornosti se nalaze podaci, a ne logika

programa. Objekt može biti nešto kompleksno poput bića ili vozila ili pak nešto jednostavno

poput prozora na zaslonu računala. Objekt može biti sve što ima svojstva, na koja se može

utjecati i mijenjati ih. Suprotnost objektno orijentiranog programiranja je linearno programiranje.

(Rouse 2013)

4.1. Priprema za objektno orijentirano programiranje

Prvi korak u objektno orijentiranom programiranju je određivanje svih objekata kojima

programer želi upravljati te veza između njih. Ovaj korak često se naziva modeliranje podataka

(eng. data modelling). U linearnom programiranju ovaj korak je zamijenjen izradom dijagrama

toka (eng. flowchart). (Rouse 2013)

Kada su definirani objekti i veze među njima, potrebno je definirati razrede (eng. class) kojima

pripadaju objekti. Ovdje se može napomenuti Platonov koncept idealne stolice, koja predstavlja

sve stolice. Oba koraka prethode pisanju izvornog koda. (Rouse 2013)

Programi najčešće koriste grupe podataka. Primjerice materijal stolice, broj nogu, oblik

naslonjača i visina su svojstva stolice. Zasebni podaci nisu dovoljni za definiranje stolice.

Potreban je skup podataka kako bi se mogla definirati stolica. Drugim riječima objekt je

definiran skupom podataka. Razred je pak skup svojstava. (Davis 2004)

Sljedećim primjerom autor diplomskog rada nastoji objasniti vezu između razreda i objekta.

Može se reći da niski drveni tronožac (objekt) jest stolica (razred). Razred (stolica) sadrži

svojstva (materijal stolice, broj nogu i visina), a objekt sadrži podatke (materijal je drvo, broj

nogu je tri, visina stolice je niska). (Davis 2004)

12

4.2. Principi objektno orijentiranog programiranja

Objektno orijentirano programiranje ovisi o dva principa: apstrakcija i klasifikacija. Autor knjige

"C++ for Dummies" (Davis 2004) na primjeru mikrovalne pećnice opisuje srž objektno

orijentiranog programiranja.

4.2.1. Apstrakcija

Pri korištenju mikrovalne pećnice korisnik upravlja samo tipkama na prednjoj strani pećnice. On

ne mora voditi računa o električnom i elektroničkom sklopovlju pećnice, ne mora brinuti o

programiranju mikroprocesora, koji upravlja radom pećnice. Čak i da pećnicu koristi njen

proizvođač, on ne mora brinuti o ničemu, osim o tipkama na prednjoj strani pećnice. (Davis

2004)

Kada se korisniku spriječi utjecanje na unutrašnji rad pećnice, tada se sprečava nastanak grešaka

u radu. Razina detalja s kojom se suočava programer naziva se razina apstrakcije (eng. level of

apstraction). (Davis 2004)

4.2.2. Klasifikacija

Mikrovalna pećnica pripada razredu pećnica. pećnica pripada razredu kućanskih aparata itd.

Takvo sjedinjavanje podrazreda u zajedničke razrede naziva se klasifikacija. Moguće je izgraditi

mikrovalnu pećnicu za podgrijavanje rezanaca. Takva mikrovalna pećnica imala bi samo jedno

tipkalo ("Kreni"), jer bi ona bila već unaprijed optimalno postavljena i pripremljena samo za

podgrijavanje rezanaca. No takva mikrovalna pećnica ne bi se mogla koristiti za podgrijavanje

juhe. (Davis 2004)

U objektno orijentiranom programiranju vrlo je važno prije početka pisanja programa podijeliti

sve objekte u razrede i odrediti koje metode (funkcije) će biti sadržane u razredima te koje od

njih će biti dostupne izvan razreda, a koje samo unutar razreda. (Davis 2004)

13

4.3. Značajke objektno orijentiranog programiranja

Značajke objektno orijentiranog programiranja: (Object-oriented programming 2015) (Davis

2004)

− Objekti i razredi (eng. objects and classes): objekti sadrže podatke i procedure

(funkcije), a razredi sadrže definicije za oblike podataka i definicije dostupnih procedura.

Razredi mogu sadržavati i vlastite podatke i procedure (tada se one nazivaju metodama).

− Slanje poruka (eng. message passing): izvođenje pojedinih metoda, odnosno funkcija

vrši se slanjem poruka. Poruke se sastoje od naziva funkcije, naziva objekta ili razreda

kojemu ona pripada i ulaznih parametara za funkciju.

− Omatanje (eng. encapsulation): pojedine procedure se u razredu definiraju kao javne

(eng. public) i kao takve mogu biti pozivane od strane objekata, koji pripadaju drugim

razredima. Ostale procedure definiraju se kao privatne (eng. private) te se one ne mogu

pozivati od strane objekata, koji pripadaju drugim razredima.

− Nasljeđivanje (eng. inheritance): podrazredi mogu nasljeđivati varijable i funkcije od

razreda kojima oni pripadaju. Primjerice podrazred "mikrovalna pećnica" nasljeđuje sve

podatke i metode, koje sadrži razred "pećnica". Uz njih podrazred "mikrovalna pećnica"

sadrži i vlastite varijable i metode.

− Polimorfizam (eng. polymorphism): ukoliko objekt pripada podrazredu, a željena

funkcija razredu od kojega podrazred nasljeđuje, tada je moguće pozvati željenu funkciju

na jednak način kako bi ju se pozivalo da ona pripada podrazredu, kojemu pripada i

navedeni objekt.

14

5. RAČUNALNI PROGRAM "TESTNO1"

Ovim poglavljem detaljno je opisan razvoj i rad računalnog programa "Testno1". Autor je razvio

program "Testno1" za potrebe svog diplomskog rada. Program je namijenjen praćenju odnosa

valutnih tečajeva. Naziv programa je kratica za izraz "Test broj 1" (eng. Test no.1). Slika 2

predstavlja grafičko sučelje računalnog programa "Testno1".

Slika 2. Grafičko sučelje računalnog programa "Testno1"

5.1. Izvori podataka o odnosima valutnih tečajeva

Povijesni odnosi valutnih tečajeva preuzimaju se s Internet servisa EuroStat (European

Commission 2015). To je Internet servis putem kojega su dostupni različiti statistički podaci

Europske Unije. Između ostaloga, dostupni su i podaci ECB-a (Europska Centralna Banka) o

odnosima valutnih tečajeva. Podaci su dostupni za odnose eura i 36 valuta.

Podaci se preuzimaju u tekstualnom formatu. Podaci su međusobno odvojeni tabulatorom

(ASCII simbol "\t"), a redovi oznakom za "novi red" (ASCII simbol "\n"). Popis svih ASCII

15

(ASCII 2010) (eng. America Standard Code for Information interchange) simbola dostupan je

putem Interneta. Prvi red podataka sadrži datume u tekstualnom formatu, primjerice

"2015M05D29". Prvi stupac sadrži oznake valute, primjerice "AVG,NAC,HRK". Prvi dio

oznake, "AVG,NAC," jednak je za sve valute. Samo zadnja tri simbola se mijenjaju. Prema

njima program "Testno1" razlikuje valutne tečajeve.

5.2. Shema računalnog programa "Testno1"

Slika 3 predstavlja hijerarhiju računalnog programa "Testno1". Oblacima su predstavljeni razredi

(eng. classes). "Main" nije razred, već samo funkcija, koja se automatski poziva pokretanjem

programa građenog programskim jezikom C++.

Strelice označavaju nasljedne veze među razredima. Može se zaključiti da je "MainWindow"

osnovni razred. On nasljeđuje od razreda "IzborValuteDialog", "IzborRelativnoDialog" i

"Grafikon". Razred "Grafikon" nasljeđuje od razreda "Krivulje". Stoga su javne metode razreda

"Krivulje" dostupne i razredu "MainWindow".

Slika 3. Shema računalnog programa "Testno1"

Razred "Krivulje" učitava i pohranjuje podatke o povijesnim odnosima valutnih tečajeva.

Razredu "Grafikon" dostupni su podaci pohranjeni u razredu "Krivulje". On se bavi iscrtavanjem

grafikona, kojime se predočuju omjeri valutnih tečajeva. Razred "MainWindow" bavi se

iscrtavanjem alatnih traka i izbornika na zaslonu računala. On također njima pridodaje

16

funkcionalnost. Razred "MainWindow" povezuje korisnika i program. On omogućuje

interaktivnost.

Razredi "IzborValuteDialog" i "IzborRelativnoDialog" sadrže izvorni kod za gradnju prozora za

unos podataka (takvi prozori se nazivaju dijalozi, jer omogućuju komunikaciju korisnika i

računalnog programa).

5.3. Funkcionalnost računalnog programa "Testno1"

Ovim poglavljem su opisani svi razredi računalnog programa "Testno1". Opisana je i funkcija

"Main", iako je već navedeno da ona nije razred.

Svaki razred sastoji se od naslovnog dokumenta (eng. header file) i dokumenta, koji sadrži

izvorni kod (eng. source file). U programskom jeziku C++ funkcija se mora inicirati i definirati.

U nastavku je predočen primjer inicijalizacije i definicije funkcije "funk":

int funk (int x, int y) {return x + y;}

Riječ "int" definira da će funkcija "funk" vratiti cijeli broj (eng. integer, ili kraće int). Sljedeća

riječ "funk" je naziv funkcije. U oblim zagradama su definirani ulazni parametri. To su

varijable "x" i "y", koje sadrže cijele brojeve. Naposljetku je vitičastim zagradama opisana logika

funkcije. Ona definira da će funkcija "funk" pri izvođenju vratiti ("return") zbroj varijabli "x"

i "y" ("x+y").

Inicijalizacija funkcije sadrži prva tri elementa: oblik vrijednosti, koju funkcija vraća, naziv

funkcije i popis ulaznih parametara. Definicija sadrži sve elemente, koje sadrži inicijalizacija, ali

i definiciju funkcionalnosti u vitičastim zagradama. U programskom jeziku C++ svaka funkcija

mora biti definirana prije nego li se ona poziva. Stoga se često sve funkcije, koje razred sadrži

iniciraju u početnom dijelu izvornog koda. Inicijalizacije i definicije čest se ne pišu u istom

dokumentu, već se razdvajaju u dva dokumenta. Naslovni dokument sadrži inicijalizacije svih

funkcija i može služiti kao svojevrstan popis svih funkcija i varijabli, koje razred sadrži.

17

Dokument s izvornim kodom sadrži definicije svih funkcija. Dokument s izvornim kodom je

zbog opsega sadržaja poprilično nepregledan.

5.3.1. "Main"

Funkcija "Main" poprilično je kratka. Njen izvorni kod predstavljen je u nastavku.

1 #include "mainwindow.h" 2 #include <QApplication>

3 int main(int argc, char *argv[]) 4 { QApplication app(argc, argv); 5 MainWindow win; 6 win.show(); 7 return app.exec(); }

Prvi red uvjetuje da funkcija "main" nasljeđuje funkcije i varijable od razreda "MainWindow".

Drugi red uvjetuje da funkcija "main" nasljeđuje od razreda "QApplication". Ovaj razred je

sastavni dio računalnog programa "Qt". Razred "QApplication" upravlja grafičkim sučeljem

računalnog programa, koji se razvija.

Treći red predstavlja inicijalizaciju funkcije "main". U četvrtom redu se za razred

"QApplication" gradi objekt "app". Objekt "app" može se smatrati osnovom za program

"Testno1". U petom redu se za razred "MainWindow" gradi objekt "win". U šestom redu se nad

objektom "win" poziva funkcija "show", koja uzrokuje prikazivanje prozora na zaslonu računala.

Objekt "win" može se smatrati osnovnim prozorom (eng. window) programa "Testno1". Ostale

funkcije, koje korisnik definira popunjavaju osnovni prozor. U sedmom redu se nad objektom

"app" poziva funkcija "exec()" koja vraća cijeli broj 1 ukoliko je izvođenje programa bilo

uspješno.

18

5.3.2. "MainWindow"

Izvorni kod naslovnog dokumenta razreda "MainWindow" predočen je u nastavku.

1 #ifndef MAINWINDOW_H 2 #define MAINWINDOW_H

3 #include <QMainWindow> 4 #include <QScrollBar> 5 #include <QLabel> 6 #include <QComboBox> 7 #include <QSpinBox> 8 #include <QPushButton>

9 class Grafikon;

Prva dva reda sprečavaju višestruko definiranje razreda "MainWindow". Redovi 3-8 upućuju da

razred "MainWindow" nasljeđuje od različitih razreda već definiranih programom "Qt". Razred

"QMainWindow" sadrži funkcije potrebne za popunjavanje osnovnog prozora. On dijeli osnovni

prozor na traku za izbornike, alatnu traku, centralni prozor i statusnu traku. Računalni program

"Testno1" ne koristi statusnu traku. Ostali pozvani razredi sadrže funkcionalnosti različitih

alatnih blokova (eng. wdget). Oni će biti opisani u nastavku. Deveti red unaprijed objavljuje

(eng. forward declaration) razred "Grafikon". Time objekt "grafikon", koji se gradi za razred

"Grafikon" postaje dostupan svim funkcijama razreda "MainWindow".

10 class MainWindow : public QMainWindow 11 { Q_OBJECT

12 public: 13 MainWindow();

14 public slots: 15 void scrollBarUpdate(); 16 void izborValute(); 17 void movingAverage(); 18 void cBoxCheck(); 19 void toggleDrawCursor(bool checked); 20 void apsolutno(); 21 void relativno();

Deseti red inicira razred "MainWindow". Sa ": public QMainWindow" je definirano

nasljeđivanje svih javnih funkcija razreda "QMainWindow". "Q_OBJECT" je makro naredba,

19

koja omogućuje funkcionalnost različitih alatnih blokova. U redu 13 iniciran je graditelj (eng.

creator) za razred "MainWindow". Graditelj se poziva kada se gradi novi objekt, koji pripada

ovome razredu. Redovi 15-21 iniciraju javne funkcije, koje će biti pozivane kao reakcije na

odgovarajuće korisnikove akcije.

22 private: 23 Grafikon *grafikon;

24 QScrollBar *scrollBar; 25 QLabel *devizeLabel;

26 void resizeEvent(QResizeEvent *) {scrollBarUpdate();} 27 void createActions(); 28 void createWidgets(); 29 void createMenus(); 30 void createToolBars(); 31 void labelsUpdate();

32 QAction *act11; 33 QAction *act211; 34 QAction *act212; 35 QAction *act221; 36 QAction *act222; 37 QAction *act31; 38 QAction *act32; 39 QAction *act33;

40 QComboBox *cBox1; 41 QComboBox *cBox2;

42 QSpinBox *sBox1;

43 QMenu *menu1; 44 QMenu *menu2; 45 QMenu *menu21; 46 QMenu *menu22; 47 QMenu *menu3;

48 QToolBar *tBar1; 49 QToolBar *tBar2; 50 QToolBar *tBar3;

51 QStringList valute; 52 };

53 #endif // MAINWINDOW_H

20

U redu 23 inicira se pokazivač (eng. pointer) na objekt "Grafikon::grafikon" (dvostruka dvotočka

"::" označava pripadnost objekta, varijable ili funkcije razredu).

U redu 26 je preopterećena (eng. overloaded) funkcija "resizeEvent". Ona pripada razredu

"QResizeEvent" i poziva se automatski prilikom mijenjanja dimenzija prozora programa. Zbog

toga što je funkcija preopterećena, prilikom promjena dimenzija prozora neće se pozivati

funkcija "QResizeEvent::resizeEvent", već funkcija "MainWindow::resizeEvent". U redu 26 već

je definirana funkcija "resizeEvent". Pozivom ove funkcije biti će pozvana funkcija

"scrollBarUpdate". U ostalim redovima inicirane su ostale funkcije i pokazivači na različite

alatne blokove, koji će biti ugrađeni u prozor programa "Testno1".

Red 51 inicira varijablu "valute", koja je niz tekstualnih nizova (eng. string list). u nju se mogu

pohraniti različite riječi. U redu 52 završava inicijalizacija razreda "MainWindow". U redu 53

završava provjera, koja je započeta u redovima 1 i 2. Ovime završava opis naslovnog dokumenta

razreda "MainWindow". U nastavku će biti opisan dokument, koji sadrži izvorni kod.

1 #include "mainwindow.h" 2 #include "grafikon.h" 3 #include "krivulje.h" 4 #include "izborvalutedialog.h" 5 #include "izborrelativnodialog.h"

6 MainWindow::MainWindow() 7 { grafikon = new Grafikon; 8 grafikon->show();

9 scrollBar = new QScrollBar(Qt::Horizontal); 10

QObject::connect(scrollBar, SIGNAL(valueChanged(int)), grafikon, SLOT(setPrviKorak(int)));

11 scrollBarUpdate(); 12

scrollBar->setValue(scrollBar->maximum());

13 devizeLabel = new QLabel; 14

devizeLabel->setFixedWidth(60);

15 QHBoxLayout *horizLayout = new QHBoxLayout; 16 horizLayout->setSpacing(0); 17 horizLayout->setMargin(0); 18 horizLayout->addWidget(devizeLabel); 19

horizLayout->addWidget(scrollBar);

20 QVBoxLayout *vertLayout = new QVBoxLayout;

21

21 vertLayout->setSpacing(0); 22 vertLayout->setMargin(0); 23 vertLayout->addWidget(grafikon); 24

vertLayout->addLayout(horizLayout);

25 QWidget *window = new QWidget; 26 window->setLayout(vertLayout); 27

setCentralWidget(window);

28 valute <<"ARS" <<"AUD" <<"BGN" <<"BRL" <<"CAD" <<"CHF" <<"CNY" <<"CZK" <<"DKK" <<"EUR";

29 valute <<"GBP" <<"HKD" <<"HRK" <<"HUF" <<"IDR" <<"ILS" <<"INR" <<"ISK" <<"JPY" <<"KRW";

30 valute <<"MKD" <<"MXN" <<"MYR" <<"NOK" <<"NZD" <<"PHP" <<"PLN" <<"RON" <<"RSD" <<"RUB";

31

valute <<"SEK" <<"SGD" <<"THB" <<"TRY" <<"TWD" <<"USD" <<"ZAR";

32 createActions(); 33 createWidgets(); 34 createMenus(); 35

createToolBars();

36 labelsUpdate(); 37 setWindowIcon(QIcon(":/TestnoFiles/Testno.png")); 38 }

Prvi red povezuje naslovni dokument sa dokumentom s izvornim kodom. Redovi 2-5 definiraju

da razred "MainWindow" nasljeđuje od ostalih razreda, "Grafikon", "Krivulje",

"IzborValuteDialog" i "IzborRelativnoDialog".

Redovima 6-38 definira se graditelj za razred "MainWindow". U redu 7 definira se da pokazivač

"grafikon" pokazuje na objekt, koji pripada razredu "Grafikon".

U redu 9 definira se pokazivač "scrollBar", koji ukazuje na objekt razreda "QScrollBar". Drugim

riječima izgrađen je prvi alatni blok - horizontalni klizač. No trenutno program ne zna gdje se

klizač nalazi, koliko mu je raspon, niti koja je reakcija na pomicanje klizača. U redu 10

funkcijom "QObject::connect" povezuje se akcija - pomicanje klizača (eng. value changed) sa

reakcijom - zadavanje prvog koraka. Autor je definirao prvi korak kao datum, koji odgovara

prvom podatku, koji se prikazuje na grafikonu. Drugim riječima kada je klizač "scrollBar"

pomaknut, tada on odašilje signal "valueChanged". Objekt "grafikon" prepoznaje taj signal i

poziva povezanu funkciju "setPrviKorak". Takva funkcija mora u naslovnom dokumentu biti

22

smještena u kategoriji javnih proreza (eng. public slot). Mora biti smještena među javnim

prorezima kako bi se mogla pozivati iz drugog razreda. U redu 11 poziva se funkcija

""scrollBarUpdate", koja temeljem prikazanog raspona na grafikonu zadaje odgovarajući raspon

klizača. U redu 12 klizač se postavlja u krajnji desni položaj.

U redovima 13 gradi se novi alatni blok - oznaka (eng. label) "devizeLabel". Ona će prikazivati

nazive dviju valuta, čiji su povijesni odnosi trenutno predočeni grafikonom. Red 14 alatnom

bloku "devizeLabel" zadaje fiksnu širinu od 60 jedinica (eng. pixel).

U redovima 15-17 definira se horizontalni raspored alatnih blokova "horizLayout". U redovima

18 i 19 se u raspored s lijeva udesno svrstavaju alatni blokovi "devizeLabel" i "scrollBar". U

redovima 20-22 definira se vertikalni raspored alatnih blokova "vertLayout". U redovima 23 i 24

se u raspored odozgo prema dolje svrstavaju objekt "grafikon" i već definirani raspored

"horizLayout".

Red 25 definira novi prozor "window". To je pokazivač na objekt, koji pripada razredu

"QWidget". Red 26 postavlja raspored "vertLayout" kao osnovni raspored prozora "window".

Time svi alatni blokovi ranije definirani pripadaju prozoru "window". Red 27 postavlja prozor

"window" kao središnji prozor razreda "MainWindow", odnosno programa "Testno1". Čitatelj bi

se mogao zapitati zbog čega nije bilo moguće preskočiti stvaranje objekta "window" i kao

središnji prozor zadati raspored "vertLayout". To nije moguće jer funkcija

"MainWindow::setCentralWidget (QWidget *)" kao parametar očekuje alatni blok (eng. widget),

odnosno pokazivač na objekt, koji pripada razredu "QWidget", a rasporedi "horizLayout" i

"vertLayout" nisu alatni blokovi.

U redovima 28-31 popunjava se varijabla "valute", koja je unaprijed definirana u naslovnom

dokumentu. Varijabla "valute" je skup riječi. Riječi su kratice valuta čiji tečajevi su dostupni

putem Internet servisa "EuroStat".

23

Redovi 32-35 pozivaju funkcije "createActions", "createWidgets", "createMenus" i

"createToolbars". Sve funkcije pripadaju razredu "MainWindow" i detaljnije su opisane u

nastavku. One služe za gradnju akcija, alatnih blokova, izbornika i alatnih traka, respektivno.

Red 36 poziva funkciju "labelsUpdate", koja osvježava oznaku "devizeLabel". Red 37 definira

ikonu programa "Testno1". Slika 4 predstavlja ikonu programa "Testno1".

Slika 4. Ikona računalnog programa "Testno1"

U nastavku je predočen izvorni kod za funkciju "MainWindow::createActions".

39 void MainWindow::createActions() 40 { act11 = new QAction("&Izbor valuta", this); 41 QObject::connect(act11, SIGNAL(triggered()), this, SLOT(izborValute()));

42 act11->setIcon(QIcon(":/TestnoFiles/Valute.png"));

43 act211 = new QAction("Zoom &in", this); 44 QObject::connect(act211, SIGNAL(triggered()), grafikon, SLOT(zoomIn()));

45 QObject::connect(act211, SIGNAL(triggered()), this, SLOT(scrollBarUpdate()));

46 act211->setIcon(QIcon(":/TestnoFiles/ZoomIn.png")); 47 act212 = new QAction("Zoom &out", this); 48 QObject::connect(act212, SIGNAL(triggered()), grafikon, SLOT(zoomOut()));

49 QObject::connect(act212, SIGNAL(triggered()), this, SLOT(scrollBarUpdate()));

50 act212->setIcon(QIcon(":/TestnoFiles/ZoomOut.png"));

51 act221 = new QAction("&Apsolutno", this); 52 QObject::connect(act221, SIGNAL(triggered()), this, SLOT(apsolutno()));

53 act222 = new QAction("&Relativno", this); 54

QObject::connect(act222, SIGNAL(triggered()), this, SLOT(relativno()));

55 act31 = new QAction("Po&mični prosjeci", this); 56 QObject::connect(act31, SIGNAL(triggered()), this, SLOT(movingAverage()));

24

57 act31->setIcon(QIcon(":/TestnoFiles/MovingAvg.png")); 58 act32 = new QAction("&Trenutne vrijednosti", this); 59 QObject::connect(act32, SIGNAL(triggered(bool)), this, SLOT(toggleDrawCursor(bool)));

60 act32->setIcon(QIcon(":/TestnoFiles/DrawCursor.png")); 61 act32->setCheckable(true); 62 act33 = new QAction("Ugasi pomične prosjeke", this); 63 QObject::connect(act33, SIGNAL(triggered()), this, SLOT(movingAverage()));

64 act33->setIcon(QIcon(":/TestnoFiles/MovingAvgDel.png"));65 }

Funkcija "createActions" gradi akcije. Akcije će biti pridružene različitim alatnim blokovima,

primjerice tipkama. Akcije se definiraju kao pokazivači na objekte, koji pripadaju razredu

"QAction".

Definiranje akcije biti će opisano koristeći primjer akcije "act11". Red 40 inicira akciju. Pritom

se akciji pridružuje naziv "&Izbor valuta". Simbol "&" označava da će prvo slovo nakon simbola

biti prečica (eng. shortcut), koju se poziva kombinacijom tipki "Alt + odgovarajuće slovo". Gdje

se prikazuje puni naziv akcije "act11" (primjerice u izbornicima), ondje je to slovo podcrtano -

"Izbor valuta". Red 41 pridružuje akciji "act11" odgovarajuću reakciju. Kada je potaknuta akcija

"act11" (primjerice klikom na tipkalo), tada se poziva funkcija "izborValute", koja pripada

razredu "MainWindow", odnosno istome razredu kao i akcija "act11". Ključna riječ "this" je

pokazivač na razred kojemu pripada funkcija u kojoj je upotrijebljena ključna riječ "this".

Naposljetku red 42 pridružuje akciji "act11" odgovarajuću ikonu.

Slika 5 predočuje sve ikone alatnih blokova. S lijeva udesno njihovi nazivi glase "Valute",

"ZoomIn", "ZoomOut", "MovingAvg", "DrawCursor" i "MovingAvgDel". Sve ikone pohranjene

su u "png" formatu. On sadrži i podatke o prozirnosti pojedinih točaka slike. Stoga nije potrebno

uz ikonu pridruživati i zasebnu sliku, koja predstavlja prozirnost slike.

Slika 5. Ikone alatnih blokova računalnog programa "Testno1"

25

U nastavku je predočen izvorni kod za funkciju "MainWindow::createWidgets".

66 void MainWindow::createWidgets() 67 { cBox1 = new QComboBox(this); 68 cBox2 = new QComboBox(this); 69 cBox1->addItems(valute); 70 cBox2->addItems(valute); 71 QObject::connect(cBox1, SIGNAL(currentIndexChanged(int)), this, SLOT(cBoxCheck()));

72

QObject::connect(cBox2, SIGNAL(currentIndexChanged(int)), this, SLOT(cBoxCheck()));

73 sBox1 = new QSpinBox(this); 74 sBox1->setRange(2, 999); 75 sBox1->setValue(100); 76 QObject::connect(sBox1, SIGNAL(valueChanged(int)), grafikon, SLOT(movingAvgCalc(int)));

77 }

U redovima 67 i 68 grade se kombinirani okviri (eng. combo box). "cBox1" i "cBox2". U njih se

u redovima 69 i 70 iz varijable "valute" prepisuje popis svih kratica naziva valuta. U redovima

71 i 72 se pridružuju reakcije na promjenu odabrane kratice. Kada korisnik odabere novu karticu,

tada se poziva funkcija "MainWindow::cBoxCheck". Ona provjerava je li u oba kombinirana

okvira odabrana ista valuta. Ukoliko jest, tada se odabiru valute, koje su bile odabrane prije

promjene.

Red 73 definira alatni blok "sBox1". On služi za unos cijelog broja, o kojemu ovisi prikaz

pomičnih prosjeka. Red 74 zadaje raspon alatnog bloka između 2 i 999. Red 75 zadaje 200 kao

trenutnu vrijednost bloka. Funkcija "connect" u redu 76 povezuje promjenu vrijednosti alatnog

bloka s funkcijom "Grafikon::movingAvgCalc", koja preračunava pomične prosjeke. Slika 6 s

lijeva udesno predstavlja dva kombinirana okvira i alatni blok za unos cijelog broja.

Slika 6. Kombinirani okviri i alatni blok za unos broja

26

U nastavku je predočen izvorni kod za funkciju "MainWindow::createMenus",

78 void MainWindow::createMenus() 79 { menu1 = menuBar()->addMenu("&Podaci"); 80 menu1->addAction(act11);

81 menu2 = menuBar()->addMenu("Po&gled");

82 menu21 = menu2->addMenu("&Zoom"); 83 menu21->addAction(act211); 84 menu21->addAction(act212);

85 menu22 = menu2->addMenu("Prikaz &Forex-a"); 86 menu22->addAction(act221); 87 menu22->addAction(act222);

88 menu3 = menuBar()->addMenu("&Alati"); 89 menu3->addAction(act31); 90 menu3->addAction(act32); 91 }

Funkcija "MainWindow::createMenus" gradi izbornike, koji se ugrađuju u traku za izbornike.

Definiranje izbornika biti će opisano na primjeru izbornika "menu2". Red 81 dodaje u traku za

izbornike novi izbornik "menu1" i pridružuje mu tekst za prikaz "Po&gled". Redovi 82 i 85

dodaju u izbornik "menu2" podizbornike "menu21" i "menu22". Redovi 83 i 84 dodaju u

podizbornik "menu21" akcije "act211" i "act212". Redovi 86 i 87 dodaju u podizbornik

"menu22" akcije "act221" i "act222".

U nastavku je predočen izvorni kod za funkciju "MainWindow::createToolBars".

92 void MainWindow::createToolBars() 93 { QLabel *podaciL1 = new QLabel(" : "); 94 QLabel *podaciL2 = new QLabel(" ");

95 tBar1 = addToolBar("Podaci"); 96 tBar1->addAction(act11); 97 tBar1->addWidget(cBox1); 98 tBar1->addWidget(podaciL1); 99 tBar1->addWidget(cBox2); 100 tBar1->addWidget(podaciL2); 101 tBar1->addAction(act32); 102 tBar1->setMovable(false); 103

tBar1->setFixedHeight(34);

104 tBar2 = addToolBar("Pogled");

27

105 tBar2->addAction(act211); 106

tBar2->addAction(act212);

107 tBar3 = addToolBar("Pomični prosjeci"); 108 tBar3->addAction(act33); 109 tBar3->addWidget(sBox1); 110 tBar3->setVisible(false); 111 }

Funkcija "MainWindow::createToolBars" gradi alatne trake, koje korisnik može proizvoljno

micati unutar sučelja programa "Testno1". Red 95 definira alatnu traku "tBar1" i pridružuje joj

naziv "Podaci". Red 96 u alatnu traku dodaje akciju "act11". Red 97 u alatnu traku dodaje

kombinirani okvir "cBox1". Redovi 102 i 103 sprečavaju micanje alatne trake i zadaju fiksnu

veličinu alatne trake od 34 jedinice. Red 110 skriva alatnu traku "tBar3".

U nastavku je predočen izvorni kod funkcije "MainWindow::scrollBarUpdate".

112 void MainWindow::scrollBarUpdate() 113 { scrollBar->setMaximum(grafikon->getSize()); 114 scrollBar->setPageStep(grafikon->getPageStep()); 115 }

Funkcija "MainWindow::scrollBarUpdate" osvježava klizač "scrollBar". Red 113 poziva

funkciju "Grafikon::getSize". Funkcija vraća broj podataka dostupnih na servisu "EuroStat" za

odgovarajuće valutne tečajeve, umanjen za broj podataka trenutno prikazanih na zaslonu

računala. Podaci su dnevni. Funkcija "QScrollBar::setMaximum" zadaje gornju granicu raspona

za klizač. Gornja granica jednaka je cjelobrojnoj vrijednosti, koju vraća funkcija "getSize".

Donja granica nije mijenjana, te je stoga ona zadržala vrijednost 0. Red 114 poziva funkciju

"Grafikon::getPageStep". Ona vraća broj trenutno prikazanih podataka na grafikonu. Funkcija

"QScrollBar::setPageStep" postavlja širinu klizača na vrijednost, koju vraća funkcija

"getPageStep".

Može se zaključiti da se približavanjem podacima, odnosno zumiranjem (eng. zoom in) smanjuje

broj prikazanih podataka na zaslonu računala. Istovremenu se sužava klizač.

U nastavku je predočen izvorni kod funkcije "MainWindow::labelsUpdate".

28

116 void MainWindow::labelsUpdate() 117 { QString x = grafikon->getValuta(1); 118 QString y = grafikon->getValuta(2); 119 devizeLabel->setText(" " + x + " / " + y); 120 cBox1->setCurrentText(x); 121 cBox2->setCurrentText(y); 122 tBar3->setVisible(grafikon->getMovingAvg()); 123 }

Funkcija "MainWindow::labelsUpdate" osvježava oznaku "devizeLabel" i kombinirane okvire

"cBox1" i "cBox2", odnosno učitava odgovarajuće nazive valutnih tečajeva. Redovi 117 i 118

definiraju tekstualne varijable "x" i "y". U njih se učitava tekst, koji vraća funkcija

"Grafikon::getValue". Funkcija vraća kraticu naziva prve ili druge valute, koje se uspoređuju.

Red 119 zadaje novi tekst za oznaku "devizeLabel". Redovi 120 i 121 mijenjaju odabrane valute

u kombiniranim okvirima "cBox1" i "cBox2". U redu 122 se poziva funkcija "setVisible", koja

čini alatnu traku "tBar3" vidljivom, ukoliko funkcija "Grafikon::getMovingAvg" vraća istinitu

vrijednost (eng. true).

U nastavku je predočen izvorni kod funkcije "MainWindow::cBoxCheck".

124 void MainWindow::cBoxCheck() 125 { if (cBox1->currentIndex() != cBox2->currentIndex()) 126

{ scrollBar->setValue(scrollBar->minimum());

127 QStringList noveValute; 128

noveValute <<cBox1->currentText() <<cBox2->currentText();

129 grafikon->setNoveValute(noveValute); 130

grafikon->setMovingAvg(false);

131 scrollBarUpdate(); 132 scrollBar->setValue(scrollBar->maximum()); 133 } labelsUpdate(); 134 }

Red 125 provjerava je li u oba kombinirana okvira odabrana ista valuta. Ukoliko nije program

izvršava redove 126-133. Ukoliko je odabrana ista valuta, tada se izvršava samo red 133.

Red 126 postavlja klizač u krajnji lijevi položaj. Ukoliko novi skup podataka sadrži manje

podataka od starog skupa te ukoliko je klizač u krajnjem desnom položaju, tada se na zaslonu

29

programa ne bi mogao popuniti cijeli grafikon. Program bi pokušao zatražiti podatke, koji

nedostaju. U navedenom slučaju podaci nisu dostupni, što uzrokuje prestanak ispravnog rada

programa.

Red 127 definira novi skup tekstualnih varijabli "noveValute". Red 128 učitava u skup

vrijednosti iz kombiniranih okvira. Red 129 poziva funkciju "Grafikon::setNoveValute", koja

prepisuje nove nazive valuta. Funkcija "Grafikon::setMovingAvg" u redu 130 sprečava daljnje

iscrtavanje pomičnih prosjeka. Red 131 poziva funkciju "MainWindow::scrollBarUpdate", koja

osvježava klizač. Funkcija "QScrollBar"::setValue" vraća klizač u krajnji desni položaj.

Naposljetku funkcija u redu 133 osvježava oznaku, kombinirane okvire i klizač.

U nastavku je predočen izvorni kod funkcije "MainWindow::izborValute".

135 void MainWindow::izborValute() 136

{ IzborValuteDialog izborValuteDialog (grafikon->getValuta(1), grafikon->getValuta(2), valute);

137 izborValuteDialog.exec();

138 scrollBar->setValue(scrollBar->minimum()); 139 QStringList noveValute = izborValuteDialog.getValute(); 140 if (noveValute[0] != "0") 141 { grafikon->setNoveValute(noveValute); 142 grafikon->setMovingAvg(false); 143 } 144 scrollBarUpdate(); 145 scrollBar->setValue(scrollBar->maximum()); 146 labelsUpdate(); 147 }

Funkcija "MainWindow::izborValute" poziva se poticanjem akcije "act11". Funkcija gradi

prozor za izbor valutnih tečajeva, čiji odnosi će biti predočeni računalnim programom "Testno1".

Red 136 gradi objekt "izborValuteDialog", koji pripada istoimenom razredu. Graditelj razreda

gradi prozor za unos podataka. Red 137 poziva izvršenje objekta "izborValuteDialog". Sada se

na zaslonu računala pojavljuje izgrađeni prozor za unos podataka.

30

Iz već opisanih razloga red 138 pomiče klizač "scrollBar" u krajnji desni položaj. Red 139

definira novi skup tekstualnih varijabli "noveValute" i u njega učitava skup tekstualnih varijabli,

koje vraća funkcija "IzborValuteDialog::getValue", odnosno kratice naziva valuta, koje je

korisnik odabrao tijekom komunikacije s prozorom za unos podataka. Ukoliko je korisnik

tijekom komunikacije s prozorom odustao od odabira novih valutnih tečajeva, tada funkcija

"IzborValuteDialog::getValue" vraća samo jednu tekstualnu varijablu sadržaja "0".

Red 140 provjerava razlikuje li se prva od dviju tekstualnih varijabli od simbola "0". Ukoliko se

razlikuje dolazi do izvršavanja redova 141 i 142. U njima se pozivaju već opisane funkcije

"Grafikon::setNoveValute" i "Grafikon::setMovingAvg". Naposljetku se u redovima 144-146

pozivaju funkcije "scrollBarUpdate" i "labelsUpdate", koje osvježavaju oznaku, kombinirane

okvire i klizač te se klizač vraća u krajnji desni položaj.

U nastavku su predočeni i opisani izvorni kodovi funkcija "MainWindow::movingAverage",

"MainWindow::toggleDrawCursor", "MainWindow::apsolutno" i "MainWindow::relativno".

148 void MainWindow::movingAverage() 149 { grafikon->setMovingAvg(!grafikon->getMovingAvg()); 150 tBar3->setVisible(grafikon->getMovingAvg()); 151 grafikon->movingAvgCalc(sBox1->value()); }

Red 149 poziva funkciju "Grafikon::setMovingAverage" i kao parametar joj zadaje suprotnu

vrijednost od vrijednosti, koju vraća funkcija "Grafikon::getMovingAverage". Vraća suprotnu

vrijednost zbog simbola "!" ispred poziva za funkciju. Funkcija "Grafikon::getMovingAverage"

vraća vrijednost varijable "Grafikon::movingAverage", odnosno istinito (rng. true) ili neistinito

(eng. false).

Red 150 postavlja vidljivost alatne trake "tBar3" sukladno vrijednosti, koju vraća funkcija

"Grafikon::getMovingAverage". Red 151 poziva funkciju "Grafikon::movingAvgCalc" i kao

parametar joj zadaje vrijednost zapisanu u alatnom bloku za unos vrijednosti "sBox1". Funkcija

"Grafikon::movingAvgCalc" preračunava pomične prosjeke. Kao parametar prima cjelobrojnu

vrijednost, koja predstavlja korak pomičnih prosjeka.

31

152 void MainWindow::toggleDrawCursor(bool checked) 153 { act32->setChecked(checked); 154 grafikon->toggleDrawCursor(); }

Red 153 postavlja akciju "act32" kao označenu (eng. checked), odnosno neoznačenu sukladno

vrijednosti sadržanoj u varijabli "checked". Vrijednost može biti istinito ili neistinito. Red 154

poziva funkciju "Grafikon::toggleDrawCursor". Ova funkcija mijenja vrijednost varijable

"Grafikon::drawCursor" u suprotnu vrijednost iste varijable. Ukoliko varijabla ima vrijednost

istinito, tada njena vrijednost prelazi u neistinito.

155 void MainWindow::apsolutno() 156 157

{ if (!act221->isChecked()) { grafikon->citanjeApsolutneKrivulje();}

158 act221->setChecked(true); }

Red 156 provjerava je li akcija "act221" postavljena kao označena. Ukoliko nije (treba primijetiti

simbol "!"), tada se izvršava red 157. On poziva funkciju "Grafikon::citanjeApsolutneKrivulje",

koja iz vanjskog dokumenta učitava povijesne odnose valutnih tečajeva. Naposljetku red 158

postavlja akciju "act221" kao označenu.

159 void MainWindow::relativno() 160 { IzborRelativnoDialog izborRelativnoDialog; 161 izborRelativnoDialog.exec(); 162 QStringList date = izborRelativnoDialog.getDate(); 163 164

if (date.size() == 3) { grafikon->citanjeRelativneKrivulje(date);}

165 act221->setChecked(false); }

U redu 160 se za razred "IzborRelativnoDialog" gradi istoimeni objekt. Graditelj ovog razreda

gradi prozor za komunikaciju s korisnikom. Red 161 naređuje prikaz prozora na zaslonu

računala. Prozorom program zahtijeva od korisnika unos referentnog datuma, prema kojemu će

se računati relativne vrijednosti. Red 162 inicira varijablu "Date". To je skup riječi (eng. string

list). Varijabla "date" prima skup riječi, koje vraća funkcija "IzborRelativnoDialog::getDate".

Ova funkcija prepoznaje je li korisnik unio datum u ispravnom formatu te ga razlaže na dan,

mjesec i godinu. Funkcija vraća dan, mjesec i godinu kao skup riječi. Ukoliko korisnik nije unio

datum u ispravnom formatu, tada funkcija vraća riječ "0".

32

Red 163 provjerava sadrži li varijabla "date" točno tri riječi (dan, mjesec i godinu). Ukoliko

sadrži izvršava se red 164, gdje se poziva funkcija "Grafikon::citanjeRelativneKrivulje", kojoj je

kao parametar pridružena varijabla "date". Ova funkcija pretvara prethodno učitane (apsolutne)

podatke u relativne. Red 165 postavlja akciju "act221" kao neoznačenu.

5.3.3. "Grafikon"

Izvorni kod naslovnog dokumenta razreda "Grafikon" predočen je u nastavku.

1 #ifndef GRAFIKON 2 #define GRAFIKON

3 #include <QtWidgets> 4 #include "krivulje.h"

Prva dva reda sprečavaju višestruko definiranje razreda "Grafikon". Red 3 upućuje da razred

"Grafikon" nasljeđuje od modula "QtWidgets", koji je već definiran programom "Qt". Red 4

upućuje da razred "Grafikon" nasljeđuje od razreda "Krivulje". U razredu "Krivulje" su

definirane funkcije za učitavanje podataka o odnosima valutnih tečajeva i upravljanje njima.

Razred sadrži i učitane podatke o valutnim tečajevima.

5 class Grafikon: public QWidget 6 { Q_OBJECT

7 public: 8 Grafikon(QWidget *parent = 0); 9 QSize minimumSizeHint() {return QSize(500,200);} 10 QSize sizeHint() {return QSize(1000, 400);} 11 QPixmap pixmap;

12 void setMovingAvg(bool x) {movingAverage = x;} 13 bool getMovingAvg() {return movingAverage;}

Red 5 inicira razred "Grafikon". Sa ": public QWidget" je definirano nasljeđivanje svih

javnih funkcija razreda "QWidget". Drugim riječima, objekt razreda "Grafikon" nasljeđuje sve

funkcije, koje ima i alatni blok. Stoga se i sâm objekt može smatrati alatnim blokom (eng.

widget), U redu 8 iniciran je graditelj (eng. creator) za razred "Grafikon".

33

Red 9 preopterećuje (eng. overload) funkciju "QSize::minimumSizeHint". Ona alatnom bloku

zadaje najmanje dopustive dimenzije. To su širina od 500 jedinica i visina od 200 jedinica (eng.

pixel). Red 10 preopterećuje funkciju "QSize::sizeHint", koja alatnom bloku zadaje početne

dimenzije, koje se koriste pri prvoj gradnji objekta, odnosno pri otvaranju programa "Testno1".

Treba naglasiti da će prozor programa "Testno1" biti veći od zadanih dimenzija (širina 1000

jedinica i visina 400 jedinica). Zadane dimenzije će imati samo alatni blok objekta

"Grafikon::grafikon". Prozor programa "Testno1" biti će veći za veličinu alatne trake i trake s

izbornicima. Red 11 gradi objekt "QPixmap::pixmap", koji razredu "QPainter" služi poput

slikarskog platna.

Redovi 12 i 13 iniciraju i definiraju funkcije "Grafikon::setMovingAvg" i

"Grafikon::getMovingAvg". Prva funkcija postavlja vrijednost varijable "movingAverage" na

vrijednost parametra "x", odnosno (ne)istinito. Druga funkcija vraća vrijednost varijable

"movingAverage". Ove funkcije su neophodne, jer je varijabla "movingAverage" zaštićena kao

privatna varijabla razreda "Grafikon".

14 int getPageStep() { return (width()-2*margin-60)/zoomLevel;}

15 int getSize() { return krivulja.getSize()-1 - getPageStep();}

16 QString getValuta(int x) { return krivulja.getValuta(x);}

17

void setNoveValute(QStringList noveValute) { krivulja.setNoveValute(noveValute);}

18 void citanjeApsolutneKrivulje(); 19 void citanjeRelativneKrivulje(QStringList date);

Red 14 inicira i definira funkciju "Grafikon::getPageStep", koja vraća broj podataka trenutno

prikazanih grafikonom. Slika 7 prikazuje alatni blok "Grafikon::grafikon" u standardnim

dimenzijama, odnosno širina 1000 jedinica i visina 400 jedinica. Funkcija "QWidget::width"

vraća širinu cijelog alatnog bloka. Od nje se oduzima 60 jedinica i dvostruka vrijednost varijable

"margin". Razlika se dijeli s varijablom "zoomLevel". Količnik često nije cijeli broj, no zadano

je da ova funkcija uvijek vraća cijeli broj (eng. integer). Pretvorbom "double" vrijednosti u "int"

vrijednost dolazi do zaokruživanja na manji cijeli broj. To je u ovom slučaju poželjno. Varijabla

34

"zoomLevel" je horizontalna udaljenost dva podatka. Što je udaljenost veća, toliko se grafikon

pričinja bliži, odnosno zumiran.

Slika 7. Alatni blok "Grafikon::grafikon"

Red 15 poziva funkciju "Grafikon::getSize". Ona poziva funkciju "Krivulja::getSize" i od

vraćene vrijednosti (od ukupnog broja podataka) oduzima vrijednost, koju vraća funkcija

"Grafikon::getPageSize" (broj trenutno prikazanih podataka). Funkcije "getPageSize" i "getSize"

vraćaju vrijednosti potrebne za određivanje dimenzija klizača "scrollBar". Slika 8 predstavlja

klizač "scrollBar" s označenim važnijim dimenzijama. Bitno je primijetiti da krajnji desni

položaj klizača ne odgovara ukupnom broju podataka. Kada bi se klizač pomakao samo jednu

jedinicu udesno, tada bi došlo do prekida rada programa "Testno1". Naime tada bi objekt

"grafikon" od objekta "krivulja" zatražio vrijednosti podataka, koji nisu dostupni i došlo bi do

neispravnog rada programa.

Slika 8. Klizač "scrollBar"

35

Red 16 inicira i definira funkciju "Grafikon::getValuta". Ona poziva funkciju

"Krivulje::getValuta", kojoj kao parametar pridružuje cijeli broj "x". On određuje hoće li

funkcija vratiti naziv prve ili druge valute, čiji je omjer trenutno predočen grafikonom. Red 17

inicira i definira funkciju "Grafikon::setnoveValute". Ona poziva funkciju

"Krivulje::setNoveValute" i predaje joj vlastiti parametar. Parametar "noveValute" je skup riječi,

odnosno naziva obje valute, koje će biti prikazane grafikonom. Redovi 18 i 19 iniciraju funkcije

"Grafikon::citanjeApsolutneKrivulje" i "Grafikon::citanjeRelativneKrivulje".

20 public slots: 21 void setPrviKorak(int x) {prviKorak = x; update();}22 void zoomIn() { if (zoomLevel<8) zoomLevel += 1; update();}

23 void zoomOut() { if (zoomLevel>1) zoomLevel -= 1; update();}

24 void movingAvgCalc(int razdoblje); 25 void toggleDrawCursor() {drawCursor=!drawCursor;}

Ključne riječi "public slots" u redu 20 predviđaju da su u sljedećim redovima inicirane funkcije,

koje mogu biti pozvane iz drugih razreda kao reakcije na odgovarajuće reakcije. Red 21 inicira i

definira funkciju, koja postavlja cjelobrojnu varijablu "prvikorak" na vrijednost parametra "x" i

zatim poziva funkciju "Grafikon::update", koja osvježava, odnosno ponovo crta grafikon na

zaslonu računala.

Redovi 22 i 23 iniciraju i definiraju funkcije "Grafikon::zoomIn" i "Grafikon::zoomOut". One

uvećavaju i umanjuju vrijednost cjelobrojne varijable "zoomLevel" za 1 te zatim pozivaju

funkciju "Grafikon::update". Varijabla "zoomLevel" može poprimiti vrijednosti od 1 do 8.

Red 24 inicira funkciju "Grafikon::movingAvgCalc". Red 25 inicira i definira funkciju

"Grafikon::toggleDrawCursor", koja mijenja vrijednost varijable "drawCursor" u suprotnu

vrijednost, odnosno (ne)istinito.

26 private: 27 void crtanjeResetke(QPainter *painter); 28 void crtanjeKrivulja(QPainter *painter); 29 void crtanjeMovingAvg(QPainter *painter); 30 void crtanjePointer(QPainter *painter); 31

36

32 void paintEvent(QPaintEvent *e); 33 void mouseMoveEvent(QMouseEvent *e) {update();} 34 QString axisNumber(double doubleNumber); 35 void infoDialog(); 36 37 Krivulje krivulja; 38 bool movingAverage; 39 int margin; 40 int prviKorak; 41 int horizKorak; 42 int vertKorak; 43 double zoomLevel; 44 bool drawCursor; 45 }; 46 47 #endif // GRAFIKON

Redovi 27-44 iniciraju privatne članove razreda "Grafikon". Redovi 27-30 iniciraju funkcije,

koje obavljaju crtanje grafikona na zaslonu računala. Red 32 inicira preopterećenu funkciju

"QWidget::paintEvent", koja se poziva svaki put kada dolazi do ponovnog crtanja alatnog bloka

"grafikon". To se može dogoditi prilikom promjene veličine prozora programa "Testno1" ili

prilikom micanja klizača "scrollBar". Red 33 inicira i definira preopterećenu funkciju

"QMouseEvent::mouseEvent", koja se poziva prilikom pomicanja pokazivača (eng. cursor).

Kada korisnik miče pokazivač preko grafikona, tada se poziva funkcija "Grafikon::update", koja

osvježava grafikon. Red 37 gradi objekt "Krivulje::krivulja". U redu 47 završava provjera, koja

je započeta u redovima 1 i 2.

U nastavku je predočen i opisan izvorni kod razreda "Grafikon".

1 #include "grafikon.h"

2 Grafikon::Grafikon(QWidget *parent): QWidget(parent) 3 { movingAverage = false; 4 margin = 20; 5 prviKorak = 0; 6 horizKorak = 50; 7 zoomLevel = 1; 8 drawCursor = false; 9 setMouseTracking(true);

10 setBackgroundRole(QPalette::Dark); 11 setAutoFillBackground(true); 12 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

37

13 setFocusPolicy(Qt::StrongFocus);

14 QPainter painter(this); 15 painter.initFrom(this);

16 update(); 17 }

Prvi red povezuje naslovni dokument s dokumentom, koji sadrži izvorni kod razreda "Grafikon".

Redovi 2-17 sadrže izvorni kod graditelja razreda "Grafikon". On se izvršava pri svakoj gradnji

objekta, koji pripada razredu "Grafikon". Redovi 3-8 zadaju vrijednosti privatnih varijabli

razreda "Grafikon". Funkcija "QWidget::setMouseTracking" u redu 9 uključuje praćenje kretanja

pokazivača. Pri svakom pomaku pokazivača sada se poziva funkcija

"QMouseEvent::mouseMoveEvent".

Redovi 10 i 11 definiraju boju pozadine alatnog bloka "grafikon". Red 12 dopušta alatnom bloku

"grafikon" da mijenja dimenzije sukladno promjeni dimenzija prozora programa "Testno1".

Redovi 14 i 15 grade objekt "QPainter::painter", koj pripada ovom alatnom bloku. Ovu

pripadnost uvjetuje ključna riječ "this". Red 16 poziva funkciju "Grafikon::update", koja je

zaduženja za crtanje cijelog alatnog bloka "grafikon".

18 void Grafikon::paintEvent(QPaintEvent *e) 19 { QPainter painter(this); 20 crtanjeResetke(&painter); 21 crtanjeKrivulja(&painter); 22 if (movingAverage) crtanjeMovingAvg(&painter); 23 if (drawCursor) crtanjePointer(&painter); 24 }

Redovi 19-23 donose izvorni kod funkcije "Grafiikon::paintEvent". To je preopterećena funkcija

"QWidget::paintEvent". Ona se poziva kada se javi potreba za ponovnim crtanjem alatnog bloka.

Red 19 gradi objekt "QPainter::painter". Ovaj objekt služi za crtanje raznih oblika, koji će biti

prikazani na zaslonu računala. Kao slikarsko platno, on koristi objekt "QPixmap::pixmap".

Red 20 poziva funkciju "Grafikon::crtanjeResetke", koja je zadužena za crtanje rešetke u koju će

se naknadno ucrtati grafikon. Red 21 poziva funkciju "Grafikon::crtanjeKrivulje", koja je

zadužena za ucrtavanje grafikona u sada već ucrtanu rešetku. Ukoliko varijabla

38

"movingAverage" sadrži vrijednost istinito, onda red 22 poziva izvršavanje funkcije

"Grafikon::crtanjeMovingAvg", koja je zadužena za crtanje krivulje, koja predstavlja pomične

prosjeke. Ukoliko varijabla "drawCursor" sadrži vrijednost istinito, onda red 23 poziva

izvršavanje funkcije "Grafikon::crtanjePointer", koja je zadužena za crtanje vertikalnog pravca

na mjestu na kojemu se trenutno nalazi pokazivač. Uz pravac su naglašeni i odgovarajući datum i

vrijednost odnosa valutnih tečajeva u istom datumu.

25 void Grafikon::crtanjeResetke(QPainter *painter) 26

{ QRect rect( margin+60, margin, width()-2*margin-60, height()-2*margin-30);

27 if (!rect.isValid()) {return;}

28 krivulja.getMinMax(prviKorak, getPageStep());

29 QPen pen1 = palette().dark().color().light(); 30

painter->setPen(pen1);

31 painter->drawLine(rect.left(), rect.top(), rect.left(), rect.bottom()+30);

32

painter->drawLine(rect.right(), rect.top(), rect.right(), rect.bottom()+30);

33 vertKorak = (height()-2*margin-30) / 30; 34 for (int i=0; i<=vertKorak; ++i) 35 { int y = rect.top() + i*rect.height() / vertKorak; 36

painter->drawLine( (rect.left()-10), y, rect.right(), y);

37 }

38

Red 26 gradi objekt "QRect::rect". To je pravokutnik, koji može sadržavati druge alatne blokove.

Dimenzije objekta "rect" zadane su kao parametri za graditelja razreda "QRect". Prva dva

parametra predstavljaju koordinate gornjeg lijevog ruba pravokutnika. Druga dva parametra

predstavljaju širinu i visinu pravokutnika, respektivno. Koordinatni sustav je jednostavan

Kartezijev koordinatni sustav s ishodištem u gornjem lijevom rubu alatnog bloka "grafikon".

Pozitivan smjer je udesno i prema dolje. Jedinična mjera je jedna točka (eng. pixel) zaslona

računala. Red 27 provjerava je li izgrađen ispravan objekt "rect". Ako nije, tada funkcija

"Grafikon::crtanjeResetke" vraća ništa (jer je funkcija definirana s ključnom riječi "void") i

prekida s radom.

39

Red 28 poziva funkciju "Krivulje::getMinMax". Parametri su varijabla "prviKorak" i vrijednost,

koju vraća funkcija "Grafikon::getPageStep". Cjelobrojna varijabla "prviKorak" sadrži redni broj

prvog, odnosno krajnjeg lijevog podatka prikazanog na grafikonu. Funkcija "getPageStep" vraća

broj trenutno prikazanih podataka. Funkcija "Krivulje::getMinMax" traži najvišu i najnižu

vrijednost valutnih tečajeva, koja je prikazana grafikonom. Vrijednosti su pohranjene u

privatnim varijablama "Krivulje::max" i "Krivulje::min", respektivno.

Red 29 gradi objekt "QPen::pen1" i zadaje mu bijelu boju. Red 30 zadaje objektu

"QPainter::painter" izgrađeni objekt "pen1" kao pisalo. Objekt "painter" će prilikom crtanja imati

svojstva objekta "pen1". Redovi 31 i 32 pozivaju funkciju "QPainter::drawLine", koje crtaju

krajnju lijevu i krajnju desnu liniju grafikona. Koordinate su zadane u odnosu na objekt "rect".

Red 33 računa vrijednost privatne cjelobrojne varijable "Grafkon::vertKorak". Visina grafikona

dijeli se s 50. Tako se dobiva poželjan broj horizontalnih linija na grafikonu. Poželjno je da linije

budu međusobno barem 30 jedinica udaljene. Naposljetku se izračunata vrijednost dodjeljuje

varijabli "vertKorak". Pritom se vrijednost zaokružuje na manji cijeli broj. U redovima 34-37

izvodi se "for" petlja. Ona se izvodi onoliko puta koliko je izračunato u redu 33 uvećano za

jedan, kako bi se iscrtala i prva, odnosno krajnja gornja linija. Red 35 računa vrijednost

vertikalne koordinate na kojoj će biti crtana sljedeća horizontalna krivulja i dodjeljuje ju

cjelobrojnoj varijabli "y". Red 36 poziva funkciju "QPainter::drawLine", koja crta odgovarajuću

horizontalnu liniju.

Izvorni kod za funkciju "Grafikon::crtanjeKrivulja" poprilično je opsežan te je stoga podijeljen

na nekoliko dijelova.

39 void Grafikon::crtanjeKrivulja(QPainter *painter) 40 { krivulja.getMinMax(prviKorak, getPageStep()); 41 double minValue = krivulja.minValue(); 42 double maxValue = krivulja.maxValue();

43 QFont textFont("Arial", 10); 44 painter->setFont(textFont); 45 for (int i=0; i<=vertKorak; ++i) 46 { int y = margin + (i*(height()-2*margin-30) / vertKorak);

40

47 QString text = axisNumber(maxValue-i*(maxValue- minValue)/vertKorak);

48 painter->drawText(margin, (y+5), text); 49 }

Red 40 poziva funkciju "Krivulje::getMinMax". Redovi 41 i 42 pozivaju funkcije

"Krivulje::minValue" i "Krivulje::maxValue" te prepisuju vrijednosti privatnih varijabli

"Krivulje::min" i "Krivulje::max" u varijable "Grafikon::minValue" i "Grafikon::maxValue".

Red 43 gradi objekt "QFont::textFont". Objekt sadrži značajke oblikovanja teksta "Arial" i 10

jedinica visine. U redu 44 objekt "QPainter::painter" prima značajke teksta objekta "setFont". U

redovima 45-49 izvršava se "for" petlja, koja ispisuje odgovarajuće vrijednosti s lijeve strane

vertikalnih linija. Red 47 poziva funkciju "Grafikon::axisNumber", koja osigurava da bude

prikazan broj s upravo pet decimala.

50 QPen pen1 = palette().dark().color().light(); 51 QPen pen2(Qt::red); 52 painter->setPen(pen2);

53 double trueValue = krivulja.value(prviKorak); 54

int pixValueOld = (1 - (trueValue-minValue) / (maxValue-minValue)) * (height()-2*margin-30) + margin;

55 QString mjesec1 = QString(krivulja.mjesec(prviKorak)); 56 QString godina1 = QString(krivulja.godina(prviKorak));

57 std::vector<int> mjeseci; 58 std::vector<int> godine; 59 mjeseci.push_back(60+margin); 60 godine.push_back(60+margin);

Red 50 definira objekt "QPen::pen1" kao pisalo bijele boje. Naizgled isti objekt definiran je u

redu 29, no on je zapravo jednak objekt. On je definiran unutar funkcije "crtanjeResetke". Kada

je funkcija završila s radom, tada je i objekt "QPen::pen1" izbrisan. Red 51 definira objekt

"QPen::pen2" kao pisalo crvene boje. Red 52 objektu "QPainter::painter" pridružuje objekt

"pen2" kao pisalo.

Red 53 definira decimalnu varijablu "trueValue" i pridodaje joj vrijednost, koju vraća funkcija

"Krivulje::value" za krajnji lijevi podatak prikazan grafikonom, odnosno vrijednost varijable

41

"prviKorak". Red 54 preračunava apsolutnu vrijednost varijable "trueValue" u cjelobrojnu

vrijednost, koja odgovara koordinatnom sustavu prozora programa "Testno1" te ju pohranjuje u

varijablu "pixValueOld". Treba uočiti da varijabla "trueValue" sadrži vrijednost određenog

podatka, a varijabla "pixValueOld" sadrži cjelobrojnu vrijednost koordinate, koja je rabljena za

crtanje na grafikonu.

Redovi 55 i 56 pozivaju funkcije "Krivulje::mjesec" i "Krivulje::godina", koje vraćaju naziv

mjeseca i broj godine u tekstualnom obliku. Vraćene vrijednosti se upisuju u varijable "mjesec1"

i "godina1". Redovi 57 i 58 definiraju vektore "mjeseci" i "godine". Oni su spremnici za

cjelobrojne varijable. Koristiti će se pri upisivanju mjeseca i godine u podnožju grafikona.

Redovi 59 i 60 funkcijama "push_back" upisuju prve vrijednosti u vektore "mjeseci" i "godine".

61 int i=0; 62 while ((i+1)*zoomLevel <= width()-2*margin-60) 63 {QString mjesec2 = QString(krivulja.mjesec(i+prviKorak)); 64 QString godina2 = QString(krivulja.godina(i+prviKorak)); 65 if (godina2 != godina1) 66 { painter->setPen(pen1); 67

painter->drawLine( (i*zoomLevel+margin+60), margin, (i*zoomLevel+margin+60), (height()-margin));

68 painter->setPen(pen2); 69 godine.push_back(i*zoomLevel+margin+60); 70 mjeseci.push_back(i*zoomLevel+margin+60); 71 godina1=godina2; 72 mjesec1=mjesec2; 73 } 74 else if (mjesec2 != mjesec1) 75 { painter->setPen(pen1); 76

painter->drawLine( (i*zoomLevel+margin+60), margin, (i*zoomLevel+margin+60), (height()-margin-15));

77 painter->setPen(pen2); 78 mjeseci.push_back(i*zoomLevel+margin+60); 79 mjesec1=mjesec2; 80 } 81 double trueValue = krivulja.value(i+prviKorak); 82

int pixValueNew = (1-(trueValue-minValue) / (maxValue-minValue)) * (height()-2*margin-30) + margin;

83

painter->drawLine( (i*zoomLevel+margin+60), pixValueOld, ((i+1)*zoomLevel+margin+60),

42

pixValueNew); 84 pixValueOld = pixValueNew; 85 i++; 86 }

Red 61 definira varijablu, odnosno ponavljač (eng. iterator) "i" i zadaje mu vrijednost 0. U

redovima 62-86 izvodi se "while" petlja. Petlja se izvodi za sve podatke, koji su trenutno

prikazani grafikonom.

Redovi 63 i 64 definiraju nove varijable "mjesec2" i "godina2". Obje se popunjavaju s

vrijednostima, koje vraćaju funkcije "Krivulje::mjesec" i "Krivulje::godina". Red 65 provjerava

jesu li varijable "godina1" i "godina2" jednake. Ukoliko nisu izvode se redovi 66-73. Red 67 crta

vertikalnu liniju na granici između dvije godine, ispod grafikona. Redovi 69 i 70 u vektore

"godine" i "mjeseci" upisuju horizontalnu koordinatu na kojoj se nalazi granica između dviju

godina. Redovi 71 i 72 prepisuju varijable "godina2" i "mjesec2" u varijable "godina1" i

"mjesec1".

Ukoliko varijable "godina1" i "godina" nisu jednake, red 74 provjerava jesu li varijable

"mjesec1" i "mjesec2" jednake. Ukoliko nisu izvršavaju se redovi 75-80. Red 76 crta vertikalnu

liniju na granici između dva mjeseca, ispod grafikona. Red 78 u vektor "mjeseci" upisuje

horizontalnu koordinatu na kojoj se nalazi granica između dva mjeseca. Red 79 prepisuje

varijablu "mjesec2" u varijablu "mjesec1".

Red 81 poziva funkciju "Krivulje::value", koja vraća vrijednost odnosa valutnih tečajeva u

trenutku, koji je definiran parametrom. Red 82 preračunava stvarnu vrijednost u danom trenutku

u koordinate za crtanje krivulje na grafikonu. Funkcija "QPainter:.drawLine" u redu 83 crta

dužinu između dviju točaka, za koje su parametrima zadane koordinate. Red 84 prepisuje

vrijednost varijable "pixValueNew" u varijablu "pixValueOld". Red 85 uvećava ponavljač "i" za

jedan.

87 mjeseci.push_back(width()-margin); 88 godine.push_back(width()-margin);

43

Redovi 87 i 88 u vektore "mjeseci" i "godine" upisuju koordinate krajnjeg desnog ruba

grafikona.

89 painter->setPen(pen1); 90 i=0; 91 while (i < mjeseci.size()-1) 92 { QString text; 93

if (zoomLevel < 3) { text = krivulja.mjesec(prviKorak + (mjeseci[i]-margin-60) / zoomLevel); }

94 else text = krivulja.mjesecText(prviKorak + (mjeseci[i]-margin-60) / zoomLevel);

95

painter->drawText(mjeseci[i], (height()-margin-30), (mjeseci[i+1]-mjeseci[i]), 15, Qt::AlignCenter, text);

96 i++; 97 }

Red 90 vraća vrijednost ponavljača "i" na 0. U redovima 90-97 izvršava se "while" petlja. Ona se

izvodi za sve elemente vektora "mjeseci". Red 92 definira tekstualnu varijablu "text". Red 93

provjerava je li varijabla manja od 3. Ukoliko je manja poziva se funkcija "Krivulje::mjesec". U

suprotnom se poziva funkcija "Krivulje::mjesecText". Prva funkcija vraća naziv mjeseca u

obliku broja, a druga funkcija vraća naziv mjeseca u obliku riječi. Vraćena vrijednost upisuje se

u varijablu "text". Red 95 prepisuje sadržaj varijable "text" na odgovarajuće mjesto u podnožju

grafikona. Red 97 uvećava ponavljač "i" za jedan.

98 i=0; 99 while (i < godine.size()-1) 100

{ QString text = krivulja.godina(prviKorak + (godine[i]-margin-60) / zoomLevel) + ".";

101

painter->drawText(godine[i], (height()-margin-15), (godine[i+1]-godine[i]), 15, Qt::AlignCenter, text);

102 i++; 103 } 104 }

Red 98 vraća vrijednost ponavljača "i" na 0. U redovima 99-103 izvodi se "while" petlja. Ona se

izvodi za sve elemente vektora "godine". Red 100 definira tekstualnu varijablu "text" i upisuje u

44

nju odgovarajuću godinu. Red 101 ispisuje sadržaj varijable "text" na odgovarajuće mjesto u

podnožju grafikona. Red 102 uvećava ponavljač "i" za jedan.

105 void Grafikon::crtanjeMovingAvg(QPainter *painter) 106 { double minValue = krivulja.minValue(); 107

double maxValue = krivulja.maxValue();

108 QPen pen3(Qt::blue); 109

painter->setPen(pen3);

110 double trueValue = krivulja.movingAvg(prviKorak); 111

int pixValueOld = (1 - (trueValue-minValue) / (maxValue-minValue)) * (height()-2*margin-30) + margin;

112 int date=0; 113 while ((date+1)*zoomLevel <= width()-2*margin-60) 114 { double trueValue = krivulja.movingAvg(date+prviKorak); 115

int pixValueNew = (1-(trueValue-minValue) / (maxValue-minValue)) * (height()-2*margin-30) + margin;

116

if (pixValueOld < height()-margin-30 && pixValueOld > margin && trueValue != 0)

117

{ painter->drawLine( (date*zoomLevel+margin+60), pixValueOld, ((date+1)*zoomLevel+margin+60), pixValueNew); }

118 pixValueOld = pixValueNew; 119 date++; 120 } 121 }

Redovi 106 i 107 pozivaju funkcije "Krivulje::minValue" i "Krivulje::maxValue" te prepisuju

vrijednosti privatnih varijabli "Krivulje::min" i "Krivulje::max" u varijable

"Grafikon::minValue" i "Grafikon::maxValue". Red 108 gradi objekt "QPen::pen3" kao pisalo

plave boje. Red 109 objektu "QPainter::painter" pridružuje objekt "pen3".

Redovi 110 i 111 učitavaju vrijednost pomičnih prosjeka za lijevi krajnji rub grafikona u

varijablu "trueValue" te ju preračunavaju u koordinate prozora programa "Testno1". Koordinate

se zapisuju u varijablu "pixValueOld".

45

Red 112 definira ponavljač "date" i zadaje mu vrijednost 0. U redovima 113-120 izvodi se

"while" petlja za sve podatke trenutno prikazane grafikonom. Redovi 114 i 115 učitavaju

odgovarajuću vrijednost pomičnih prosjeka i preračunavaju ju u koordinate, zapisane u varijabli

"pixValueNew". Red 116 provjerava nalazi li se vrijednost varijable "pixValueOld" unutar

grafikona te je li varijabla "trueValue" nejednaka 0. Ukoliko su svi uvjeti zadovoljeni, red 117

crta dužinu između dviju točaka, definiranih koordinatama, koje su zadane parametrima, koji su

pridruženi piozivu funkcije "QPainter::drawLine". Red 118 prepisuje vrijednost varijable

"pixValueNew" u varijablu "pixValueOld". Red 119 uvećava ponavljač "date" za jedan.

Izvorni kod funkcije "Grafikon::crtanjePointer" je opsežan te je stoga podijeljen i opisan u

dijelovima u nastavku.

122 void Grafikon::crtanjePointer(QPainter *painter) 123 { QPoint point = this->mapFromGlobal(QCursor::pos()); 124

int pointX = qRound((point.x()-margin-60)/zoomLevel) * zoomLevel;

125 int pointXm = pointX + margin + 60;

126 QPen pen3(Qt::red, 1, Qt::DotLine); 127 QPen pen2(Qt::red);

Red 123 definira varijablu "point". To je točka, odnosno skup dva cijela broja. U varijablu

"point" upisuju se trenutne koordinate pokazivača (eng. cursor). Red 124 pronalazi horizontalno

najbližu točku crvene krivulje, koja predočuje odnose valutnih tokova. Vrijednost prima

cjelobrojna varijabla "pointX". Red 125 definira varijablu "pointXm". Njena vrijednost jednaka

je zbroju varijabli "pointX" i "margin" te vrijednosti 60.

Red 126 gradi objekt "QPen::pen3", kojime će biti crtana točkasta crvena linija. Red 127 gradi

objekt "QPen::pen2" istovjetan već korištenom istoimenom objektu.

128 if (point.x()>margin+60 && point.x()<width()-margin && point.y()>margin && point.y()<height()-margin-30)

129 { painter->setPen(pen3); 130

painter->drawLine(pointXm,20, pointXm,height()-50);

131 painter->setPen(pen2); 132

painter->drawLine(pointXm, height()-50, pointXm, height());

46

133 painter->drawLine(pointXm, 0, pointXm, margin);

134 double trueValue = krivulja.value(prviKorak + pointX/zoomLevel - 1);

135 double minValue = krivulja.minValue(); 136 double maxValue = krivulja.maxValue(); 137

int pixValue = (1-(trueValue-minValue) / (maxValue-minValue)) * (height()-2*margin-30) + margin;

Red 128 provjerava nalazi li se pokazivač unutar područja grafikona. Ukoliko se nalazi

izvršavaju se redovi 129-148.

Red 129 objektu "QPainter::painter" pridružuje objekt "QPen::pen3" kao točkasto pisalo. Red

130 crta vertikalnu liniju, koja se proteže duž cijele visine rešetke grafikona. Red 131 objektu

"painter" pridružuje objekt "pen2". Redovi 132 i 133 produžuju nacrtanu vertikalnu liniju izvan

rešetke grafikona.

Red 134 pozivanjem funkcije "Krivulje::value" učitava vrijednost valutnih tečajeva u

promatranom trenutku i prepisuje ju u varijablu "trueValue". Redovi 135 i 136 pozivaju funkcije

"Krivulje::minValue" i "Krivulje::maxValue" te prepisuju vrijednosti privatnih varijabli

"Krivulje::min" i "Krivulje::max" u varijable "Grafikon::minValue" i "Grafikon::maxValue".

Red 137 temeljem varijabli "trueValue", "minValue" i "maxValue" određuje koordinate sjecišta

opisane vertikalne linije i krivulje, koja predstavlja valutne tečajeve.

138 QRect valueRect(pointXm-50, margin-20, pointXm-2, margin);

139 QString valueText = axisNumber(trueValue); 140

painter->drawText(valueRect, valueText);

141

142

QRect dateRect(pointXm-75, height()-margin, pointXm-2, height()-margin+20); int x = prviKorak+pointX/zoomLevel-1;

143

QString dateText = krivulja.dan(x) + "." + krivulja.mjesecText(x).left(3) + " " + krivulja.godina(x) + ".";

144 painter->drawText(dateRect, dateText);

145 QBrush brush1(Qt::white); 146 painter->setBrush(brush1); 147 painter->drawEllipse(pointXm-3, pixValue-3, 6, 6); 148 }

47

149 }

Red 138 gradi objekt "QRect::valueRect", odnosno pravokutnik iznad grafikona, u kojem će biti

napisana odnos valutnih tečajeva u sjecištu vertikalne linije i krivulje. Red 139 poziva funkciju

"Grafikon::axisNumber", koja vraća vrijednost varijable "trueValue" u tekstualnom obliku s pet

decimala. Red 140 ispisuje vrijednost u pravokutniku "valueRect". Redovi 141-144 imaju sličnu

zadaću. Oni ispisuju odgovarajući datum ispod grafikona. Redovi 145-147 crtaju bijeli kružić na

sjecištu vertikalne linije i krivulje.

150 QString Grafikon::axisNumber(double doubleNumber) 151 { QString x = QString::number(doubleNumber); 152 QString y = x.at(0); 153 for (int i=1; i<7; i++) 154 { if (x.at(i)!=0) {y+=x.at(i);} 155 else {y+="0";}; 156 } 157 return y; 158 }

Funkcija "Grafikon::axisNumber" parametar "doubleNumber" u obliku decimalnog broja

pretvara u skup znakova, koji predstavljaju decimalni broj s upravo sedam znakova (decimalna

točka je jedan od znakova).

Red 151 pretvara decimalni broj "doubleNumber" u skup znakova "x". Red 152 definira skup

znakova "y" i u njega prepisuje prvi znak iz skupa "x". Red 153 otvara "for" petlju. Petlja se

izvodi upravo sedam puta. Red 154 provjerava je li i-ti element skupa "x" prazan. Ukoliko nije

prazan i-ti simbol se prepisuje na kraj skupa "y". Ukoliko je prazan, na kraj skupa "y" dopisuje se

simbol "0". Red 157 vraća sadržaj varijable "y".

159 void Grafikon::movingAvgCalc(int razdoblje) 160 { if (movingAverage) krivulja.movingAvgCalc(razdoblje); 161 update(); 162 }

Funkcija "Grafikon::movingAvgCalc" provjerava ima li varijabla "movingAvg" vrijednost

istinito ili neistinito. Ukoliko sadrži vrijednost istinito, poziva se funkcija

48

"Krivulje::movingAvgCalc", koja za zadani korak izračunava pomične prosjeke. Red 161 poziva

funkciju "Grafikon::update", koja osvježava grafikon.

163 void Grafikon::citanjeApsolutneKrivulje() 164 { krivulja.citanjeApsolutneKrivulje(); 165 update(); 166 }

Funkcija "Grafikon::citanjeApsolutneKrivulje" u redu 164 poziva izvršavanje funkcije

"Krivulje::citanjeApsolutneKrivulje" te nakon toga i izvršenje funkcije "Grafikon::update".

167 void Grafikon::citanjeRelativneKrivulje(QStringList date) 168 { int dateInt=0; 169

while (krivulja.godina(dateInt).toInt() < date[2].toInt() && dateInt < krivulja.getSize()-1) dateInt++;

170 while (krivulja.mjesec(dateInt).toInt() < date[1].toInt() && dateInt < krivulja.getSize()-1) dateInt++;

171

while (krivulja.dan(dateInt).toInt() < date[0].toInt() && dateInt < krivulja.getSize()-1) dateInt++;

172

if (date[0].toInt()!=krivulja.dan(dateInt).toInt() || date[1].toInt()!=krivulja.mjesec(dateInt).toInt() || date[2].toInt()!=krivulja.godina(dateInt).toInt()) { infoDialog();}

173 krivulja.citanjeRelativneKrivulje(dateInt); 174 update(); 175 }

Funkcija "Grafikon::citanjeRelativneKrivulje" kao parametar prima skup riječi "date", koju je

korisnik unio u prozor za komunikaciju "izborRelativnoDialog". Red 168 definira ponavljač

"dateInt" i zadaju mu vrijednost 0. Vrijednost ponavljača raste u redu 169 sve dok se godina koju

je unio korisnik ne poklapa sa godinom, koju vraća funkcija "Krivulje::godina" za parametar

"dateInt". Redovi 170 i 171 na isti način uvećavaju vrijednost ponavljača "dateInt" sve dok se

cijeli datum, koji je unio korisnik ne poklopi s dostupnim datumima. Ukoliko je korisnik unio

datum izvan dosega krivulje, tada se prihvaća posljednji dostupan datum.

Red 172 provjerava jesu li svi dijelovi datuma (dan, mjesec i godina) jednaki onima, koje vraćaju

funkcije "Krivulje::dan", "Krivulje::mjesec" i "Krivulje::godina". Ukoliko nisu poziva se

funkcija "Grafikon::infoDialog". Funkcija je opisana u nastavku. Naposljetku red 173 poziva

49

funkciju "Krivulje::citanjeRelativneKrivulje", koja preračunava postojeće apsolutne podatke u

relativne. Red 174 poziva funkciju "Grafikon::update", koja osvježava grafikon.

176 void Grafikon::infoDialog() 177 { QMessageBox msgBox; 178 msgBox.setIcon(QMessageBox::Information); 179

msgBox.setText("Za odabrani datum nisu dostupne\n informacije o odnosu valuta.\n\n Stoga je odabran najbliži datum\n za koji su dostupne informacije.");

180 msgBox.exec(); 181 }

Red 177 gradi objekt "QMessageBox::msgBox". To je prozor, koji korisniku prenosi svojevrsnu

poruku. Red 178 zadaje prozoru odgovarajuću ikonu, koja navodi da je sadržaj prozora

informativan. Red 179 upisuje informativni tekst u prozor "msgBox". Kada je prozor izgrađen,

tada red 180 poziva funkciju "QWidget::exec", koja prikazuje prozor na zaslonu računala.

Prikazani prozor je modalni. Stoga korisnik ne može upravljati programom "Testno1" dok je

prozor prikazan.

5.3.4. "Krivulje"

Izvorni kod naslovnog dokumenta razreda "Krivulje" predočen je u nastavku.

1 #ifndef KRIVULJE 2 #define KRIVULJE

3 #include <QFile> 4 #include <QTextStream> 5 #include <QMessageBox>

Prva dva reda sprečavaju višestruko definiranje razreda "Krivulje". Redovi 3-5 upućuju da razred

"Krivulje" nasljeđuje od razreda "QFile", "QTextStream" i "QMessageBox", koji su već

definirani programom "Qt". Razred "QFile" sadrži funkcije potrebne za učitavanje podataka iz

stranog dokumenta. Razred "QTextStream" sadrži funkcije potrebne za obradu teksta, odnosno

učitanih podataka.

50

6 class Krivulje 7 { public: 8 Krivulje(); 9 void movingAvgCalc(int razdoblje);

10 void getMinMax(int prviKorak, int width);

11 double value(int date) {return krivuljaOsY[date];} 12

double movingAvg(int date) { return movingAverage[date];}

13 QString dan(int date) { return krivuljaOsX[date][0];}

14 QString mjesec(int date) { return krivuljaOsX[date][1];}

15 QString mjesecText(int date); 16

QString godina(int date) { return krivuljaOsX[date][2];}

17 double minValue() {return min;} 18

double maxValue() {return max;}

19 void citanjeApsolutneKrivulje(); 20

void citanjeRelativneKrivulje(int date);

21 int getSize() {return krivuljaOsX.size();} 22 QString getValuta(int x); 23 void setNoveValute(QStringList noveValute);

Redovi 8-23 iniciraju i definiraju pojedine javne funkcije razreda "Krivulje". Red 8 inicira

graditelj razreda "Grafikon". Redovi 11-16 iniciraju i definiraju funkcije "value", "movingAvg",

"dan", "mjesec", "mjesecText" i "godina". Ove funkcije kao parametar primaju cjelobrojnu

varijablu "date". Ona opisuje datum za koji će biti vraćena vrijednost valutnih tokova ili

pomičnih prosjeka ili pak oznaka dana, mjeseca ili godine. Redovi 17 i 18 definiraju funkcije

"minValue" i "maxValue", koje vraćaju najnižu i najvišu vrijednost trenutno prikazanu

grafikonom.

Redovi 19 i 20 iniciraju funkcije "citanjeApsolutneKrivulje" i "citanjeRelativneKrivulje", koje se

bave učitavanjem podataka iz stranog dokumenta i obradom podataka, odnosno izračunom

relativnih podataka. Red 21 definira funkciju "getSize", koja vraća broj elemenata, koje sadrži

vektor "krivuljaOsX", odnosno broj dostupnih podataka.

51

24 private: 25 std::vector<std::vector <QString> > krivuljaOsX; 26 std::vector<double> krivuljaOsY; 27 std::vector<double> movingAverage;

28 QString deviza1; 29 QString deviza2; 30 double min; 31 double max; 32 };

33 #endif // KRIVULJE

U redovima 25-31 inicirane su privatne varijable razreda "Krivulje". Redovi 26 i 27 iniciraju

vektore "krivuljaOsY" i "movingAverage", koji sadrže decimalne brojeve. Red 25 inicira vektor

"krivuljaOsX". Svaki element ovog vektora sadrži vektor, koji sadrži riječi, odnosno skupove

simbola (eng. string). Redovi 28 i 29 iniciraju varijable "deviza1" i "deviza2". Ove varijable

sadrže nazive valutnih tečajeva, koji se trenutno uspoređuju. Redovi 30 i 31 iniciraju decimalne

varijable "min" i "max", koje sadrže najnižu i najvišu vrijednost trenutno prikazanu grafikonom.

U redu 33 završava provjera, koja je započeta u redovima 1 i 2. Ovime završava opis naslovnog

dokumenta razreda "Krivulje". U nastavku će biti opisan dokument, koji sadrži izvorni kod.

1 #include "krivulje.h"

2 Krivulje::Krivulje() 3 { deviza1 = "EUR"; 4 deviza2 = "HRK"; 5 citanjeApsolutneKrivulje(); 6 };

Red 1 povezuje dokument, koji sadrži izvorni kod s naslovnim dokumentom razreda "Krivulje".

Redovi 2-6 definiraju graditelj "Krivulje::Krivulje". Redovi 3 i 4 zadaju početne vrijednosti

varijabli "deviza1" i "deviza2". Ove vrijednosti će biti postavljene pri pokretanju računalnog

programa "Testno1". Red 5 poziva funkciju "Krivulje::citanjeApsolutneKrivulje".

7 void Krivulje::citanjeApsolutneKrivulje() 8 { QString fileName = ":/TestnoFiles/ert_bil_eur_d.tsv"; 9 QFile file(fileName); 10 if(!file.open(QFile::ReadOnly | QFile::Text)) 11 { QMessageBox msgBox;

52

12 msgBox.setText("Dokument je neuspješno učitan!"); 13 msgBox.exec(); 14 return; 15

}

16 QTextStream in(&file);

Red 8 definira tekstualnu varijablu "fileName", koja sadrži adresu stranog dokumenta, iz kojega

će se učitavati podaci. Red 9 gradi objekt "QFile::file", koji sadrži dokument na adresi zadanoj

varijablom "fileName". Red 10 provjerava je li ispravno učitan dokument. Ukoliko nije na

zaslonu se prikazuje prozor s upozorenjem, a funkcija "citanjeApsolutneKrivulje" prekida s

radom. Ako je dokument uspješno učitan, redovi 11-15 se preskaču i izvodi se red 16. On gradi

objekt "QTextStream::in", koji služi za učitavanje podataka iz dokumenta "file" u pufer (eng.

buffer).

17 QString siroveVrijednosti = in.readLine(); 18

QStringList koordinateX = siroveVrijednosti.split('\t', QString::SkipEmptyParts);

19 koordinateX.append("end");

20 int check=0; 21 QStringList koordinateY; 22 QStringList koordinateY1; 23 QStringList koordinateY2;

Red 17 iz objekta "QTextStream::in" učitava prvi red teksta, odnosno učitava sve znakove dok

ne naiđe na simbol "\n", koji predstavlja "novi red". Red teksta upisuje se u varijablu

"siroveVrijednosti". Red 18 dijeli sadržaj varijable "siroveVrijednosti" na dijelove. Dijelovi su

odvojeni znakom "\t", koji predstavlja "karticu" (eng. tab). Pritom objekt

"QString::SkipEmptyParts" nalaže da se preskaču prazni dijelovi, odnosno razmaci. Svi odvojeni

dijelovi upisuju se u varijablu "koordinateX". To je skup riječi (eng. string list). Red 19 na kraj

varijable "koordinateX" dodaje element, odnosno riječ "end", koja služi programu da tijekom

iteracija prepoznaje posljednji element u skupu riječi.

Red 20 definira cjelobrojnu varijablu "check" i zadaje joj vrijednost 0. Redovi 21-23 definiraju

skupove riječi "koordinateY", "koordinateY1" i "koordinateY2".

53

24 if (deviza1=="EUR") {koordinateY1.append("EUR"); check++;}25 if (deviza2=="EUR") {koordinateY2.append("EUR"); check++;}26 do 27 { QString siroveVrijednosti = in.readLine(); 28

koordinateY = siroveVrijednosti.split('\t', QString::SkipEmptyParts);

29 koordinateY.append("end"); 30 koordinateY[0] = koordinateY[0].right(3); 31

if (koordinateY[0] == deviza1) { koordinateY1 = koordinateY; check++;}

32 else if (koordinateY[0] == deviza2) { koordinateY2 = koordinateY; check++;}

33 } while (check < 2);

Svi podaci u stranom dokumentu iz kojeg se učitavaju u program "Testno1" su zapisani u omjeru

pojedine valute i eura. To znači da u niti jednom redu stranog dokumenta nisu zapisani podaci,

koji prikazuju omjer u kojemu se euro nalazi u brojniku. U niti jednom redu u dokumentu se ne

nalazi riječ "EUR", koja označava valutu euro. Stoga na valutu euro treba obratiti posebnu

pozornost.

Redovi provjeravaju sadrži li ijedna od varijabli "deviza1" i "deviza2" riječ "EUR". Ukoliko

sadrži na kraj vektora "koordinateY1", odnosno "koordinateY2" dodaje se riječ "EUR". Sada su

vektori još prazni te se stoga riječ "EUR" dodaje kao prvi element vektora. Također se vrijednost

varijable "check" uvećava za jedan.

U redovima 26-33 izvodi se "do ... while" petlja. petlja se izvršava sve dok varijabla "check" ne

dosegne vrijednost 2. Cjelobrojna varijabla "check" broji koliko skupova podataka za

odgovarajuće valute je već pronađeno. Potrebno je pronaći dva skupa podataka, jer se uspoređuju

dva valutna toka.

Redovi 27-29 istovjetni su redovima 17-19. Razlika je što se odvojene riječi i riječ "end" upisuju

u vektor "koordinateY". Prvi element vektora "koordinateY" sada ima sljedeći oblik

"AVG,NAC,EUR" za valutu euro. Red 30 nad prvim elementom poziva funkciju

"QString::right" i pridružuje joj cjelobrojni parametar, kojime funkcija određuje koliko znakova

s desne strane će ostati pohranjeno. Tako od početnog oblika "AVG,NAC,EUR" ostaje

pohranjena samo oznaka valute "EUR". Redovi 31 i 32 provjeravaju je li oznaka valute jednaka

54

sadržaju jedne od varijabli "deviza1" i "deviza2". Ukoliko je jednaka sadržaj vektora

"koordinateY" prepisuje se u vektor "koordinateY1" ili "koordinateY2", a vrijednost varijable

"check" uvećava se za jedan.

34 int i=1; 35 while (koordinateY[i] != "end") 36 { check=0; 37

if (deviza1 == "EUR") { if (koordinateY2[i] != ": ") check=1;}

38 else if (deviza2 == "EUR") { if (koordinateY1[i] != ": ") check=2;}

39

else if (koordinateY1[i] != ": " && koordinateY2[i] != ": ") check=3;

40 if (check == 1) krivuljaOsY.push_back (koordinateY2[i].toDouble());

41 else if (check == 2) krivuljaOsY.push_back (1/koordinateY1[i].toDouble());

42

else if (check == 3) krivuljaOsY.push_back (koordinateY2[i].toDouble() / koordinateY1[i].toDouble());

43 if (check != 0) 44 { QString dateS = koordinateX[i]; 45 std::vector<QString> dateV; 46 dateV.push_back(dateS.mid(8,2)); 47 dateV.push_back(dateS.mid(5,2)); 48 dateV.push_back(dateS.mid(0,4)); 49 krivuljaOsX.push_back(dateV); 50 } i++; 51 }

Red 34 definira cjelobrojnu varijablu "i" i zadaje joj vrijednost 1. U redovima 35-51 izvodi se

"while" petlja sve dok ponavljač "i" ne dosegne posljednji element vektora "koordinateY",

odnosno element, koji sadrži riječ "end". Red 37 provjerava sadrži li varijabla "deviza1" riječ

"EUR" i je li i-ti element vektora "koordinateY2" različit od ": ", odnosno sadrži li vrijednost ili

je prazan (treba uzeti u obzir da valutni tečajevi nisu dostupni za sve dane). Ukoliko su oba

uvjeta zadovoljena, zadaje se vrijednost varijable "check" na 1. Red 38 obavlja sličnu provjeru i

varijabli "check" zadaje vrijednost 2. Red 39 provjerava sadrže li i-ti elementi vektora

"koordinateY1" i "koordinateY2" ikakvu vrijednost. Ukoliko sadrže varijabla "check" poprima

vrijednost 3.

55

Ukoliko varijabla "check" ima vrijednost 1, u redu 40 i-ti element vektora "koordinateY2"

prepisuje se kao posljednji element vektora "koordinateY". Ukoliko varijabla "check" ima

vrijednost 2, u redu 41 i-ti element vektora "koordinateY1" prepisuje se kao posljednji element

vektora "koordinateY". Ukoliko varijabla "check" ima vrijednost 3, u redu 42 količnik i-tih

elemenata vektora "koordinateY2" i "koordinateY1" upisuje se kao posljednji element vektora

"koordinateY".

Red 43 provjerava je li vrijednost varijable "check" različita od 0. Ukoliko nije različita, redovi

44-49 se zanemaruju. Red 44 definira tekstualnu varijablu "dateS" i u nju prepisuje sadržaj i-tog

elementa vektora "koordinateX", odnosno i-ti datum u obliku "2015Y05M15D". Red 45 inicira

vektor "dateV", koji sadrži tekstualne varijable. Funkcija "QString::mid" pamti samo dio

tekstualne varijable nad kojom je pozvana, a ostatak odbacuje. Prvi parametar funkcije određuje

prvi član varijable, koji će biti zapamćen. Drugi parametar određuje koliko članova će biti

zapamćeno. Redovi 46-48 pozivaju funkciju "QString::mid" nad varijablom "dateS" i rastavljaju

ju na tri dijela: dan, mjesec i godinu te se sva tri dijela upisuju u vektor "dateV" kao zasebni

elementi. Red 49 prepisuje vektor "dateV" kao novi posljednji element vektora "krivuljaOsX".

Red 50 uvećava vrijednost ponavljača "i" za jedan.

52 reverse(krivuljaOsX.begin(), krivuljaOsX.end()); 53

reverse(krivuljaOsY.begin(), krivuljaOsY.end());

54 file.flush(); 55 file.close(); 56 }

Prvi elementi vektora "krivuljaOsX" i "krivuljaOsY" su najsvježiji elementi. Njihov datum je

najmlađi. Za potrebe programa "Testno1" praktičniji je obratni raspored elemenata. Stoga se u

redovima 52 i 53 nad vektorima "krivuljaOsX" i "krivuljaOsY" poziva funkcija "reverse", koja ih

izvrće. Redovi 54 i 55 nad objektom "file" pozivaju funkcije "QFile::flush" i "QFile::close", koje

brišu sadržaj objekta i zatvaraju otvoreni dokument. Pozivanjem ovih funkcija štedi se radna

memorija računala.

57 void Krivulje::citanjeRelativneKrivulje(int date) 58 { double midValue = krivuljaOsY[date]; 59 for (int i=0; i<krivuljaOsY.size(); i++)

56

{ krivuljaOsY[i] = krivuljaOsY[i] / midValue;} 60 }

Funkcija "Krivulje::citanjeRelativneKrivulje" mnogo je jednostavnija od funkcije

"Krivulje::citanjeApsolutneKrivulje". U redu 58 definira se varijabla "midValue", u koju se

upisuje vrijednost vektora "krivuljaOsY" za odabrani datum "date". Red 59 definira "for" petlju,

koja se provodi za sve elemente vektora "krivuljaOsY". Svi elementi se dijele sa vrijednosti

varijable "midValue".

61 void Krivulje::getMinMax(int prviKorak, int width) 62 { Krivulje::min = krivuljaOsY[prviKorak]; 63

Krivulje::max = krivuljaOsY[prviKorak];

64 for (int i=prviKorak; i<=prviKorak+width; i++) 65

{ if (krivuljaOsY[i] < Krivulje::min) { Krivulje::min = krivuljaOsY[i];}

66 else if (krivuljaOsY[i] > Krivulje::max) { Krivulje::max = krivuljaOsY[i];}

67 } 68 }

Funkcija "Krivulje::getMinMax" nalazi najnižu i najvišu vrijednost u parametrima zadanom

rasponu, odnosno trenutno predočenu grafikonom. Prvi parametar "prviKorak" je redni broj

prvog podatka predočenog grafikonom. Drugi parametar "width" predstavlja broj podataka

trenutno predočenih grafikonom.

Redovi 62 i 63 u decimalne varijable "min" i "max" pohranjuju element vektora "krivuljaOsY"

definiran varijablom "prviKorak". Redovi 64-67 izvode "for" petlju za sve podatke, koji su

trenutno prikazani alatnim blokom "grafikon". Red 65 provjerava je li vrijednost i-tog elementa

vektora "krivuljaOsY" niža od vrijednosti varijable "min". Ukoliko je niža vrijednost elementa

vektora prepisuje se u varijablu "min". Red 66 provjerava je li vrijednost i-tog elementa vektora

"krivuljaOsY" viša od vrijednosti varijable "max". Ukoliko je viša vrijednost elementa vektora

prepisuje se u varijablu "max".

69 QString Krivulje::getValuta(int x) 70 { if (x==1) return deviza1; 71 else return deviza2; 72 }

57

Funkcija "Krivulje::getValuta" vraća naziv valute pohranjen u varijabli "deviza1" ili "deviza2".

Funkcija prima cjelobrojni parametar "x". Ukoliko parametar "x" iznosi 1, vraća se naziv sadržan

u varijabli "deviza1". U protivnom, kada "x" ne iznosi 1, vraća se naziv sadržan u varijabli

"deviza2". Program "Testno1" uvijek poziva funkciju "Krivulje::getValuta" s vrijednostima

parametra "x" 1 ili 2.

73 void Krivulje::setNoveValute(QStringList noveValute) 74 { deviza1 = noveValute[0]; 75 deviza2 = noveValute[1];

76 krivuljaOsX.clear(); 77 krivuljaOsY.clear(); 78 movingAverage.clear(); 79 citanjeApsolutneKrivulje(); 80 }

Funkcija "Krivulje::setNoveValute" zadaje nove valute te naređuje učitavanje odnosa među

njima. Redovi 74 i 75 prepisuju sadržaj parametra "noveValute" u varijable "deviza1" i

"deviza2". Redovi 76-78 pozivaju funkciju "clear" nad vektorima "krivuljaOsX", "krivuljaOsY" i

"movingAverage". Time se sadržaj vektora briše. Red 79 poziva funkciju

"Krivulje::citanjeApsolutneKrivulje", koja učitava podatke za novi par valutnih tečajeva i

popunjava vektore "krivuljaOsX" i "krivuljaOsY".

81 void Krivulje::movingAvgCalc(int razdoblje) 82 { int max = krivuljaOsY.size(); 83 int mid = int(razdoblje/2); 84

movingAverage.clear();

85 int nazivnik; 86 if (razdoblje%2 == 0) nazivnik=2; 87 else nazivnik=1;

Funkcija "Krivulje::movingAvgCalc" računa pomične prosjeke s korakom zadanim parametrom

"razdoblje". Red 82 definira cjelobrojnu varijablu "max" i u nju upisuje ukupan broj elemenata

vektora "krivuljaOsY". Red 83 definira cjelobrojnu varijablu "mid" i u nju upisuje polovicu

vrijednosti parametra "razdoblje", zaokruženu na manji cijeli broj. Funkcija "clear" u redu 84

briše sadržaj vektora "movingAverage".

58

Red 85 inicira cjelobrojnu varijablu "nazivnik". Red 86 provjerava je li ostatak dijeljenja

parametra "razdoblje" s dva jednak 0, odnosno je li vrijednost parametra "razdoblje" paran broj.

Ukoliko je paran broj, tada varijabla "nazivnik" poprima vrijednost 2. U suprotnom poprima

vrijednost 1.

88 double sum = krivuljaOsY[0] / nazivnik; 89 for (int i=1; i<razdoblje; i++) {sum+=krivuljaOsY[i];} 90

if (nazivnik == 2) sum += krivuljaOsY[razdoblje] / 2;

91 for (int i=0; i<=mid; i++) { movingAverage.push_back(0);}

92 movingAverage.push_back(sum/razdoblje);

93 for (int i=1+mid; i<max-mid; i++) 94

{ sum -= (krivuljaOsY[i-mid-1] + (nazivnik-1) * krivuljaOsY[i-mid]) / nazivnik;

95 sum += (krivuljaOsY[i+mid-1]*(nazivnik-1) + krivuljaOsY[i+mid]) / nazivnik;

96 movingAverage.push_back(sum/razdoblje); 97

}

98 for (int i=max-mid+1; i<=max; i++) { movingAverage.push_back(0);}

99 }

Red 88 definira decimalnu varijablu "sum" i pridružuje joj vrijednost količnika prvog elementa

vektora "krivuljaOsY" i varijable "nazivnik". Red 89 definira "for" petlju. Trajanje petlje

određeno je parametrom "razdoblje". Svakim korakom se vrijednost varijable "sum" uvećava za

vrijednost i-tog elementa "krivuljaOsY". Ukoliko vrijednost varijable "nazivnik" iznosi 2,

odnosno ako je vrijednost parametra "razdoblje" parna, tada se u redu 90 vrijednost varijable

"sum" uvećava za polovicu vrijednosti odgovarajućeg elementa vektora "krivuljaOsY".

Red 91 definira "for" petlju. Trajanje petlje određeno je varijablom "mid". U svakom ponavljanju

se u prve elemente vektora "movingAverage" upisuje vrijednost 0. Time je omogućeno ostalim

funkcijama da razaznaju elemente za koje nisu dostupni podaci o pomičnim prosjecima. Red 92

na kraj vektora "movingAverage" dodaje element, koji sadrži vrijednost količnika varijable

"sum" i parametra "razdoblje".

59

Red 93 definira novu "for" petlju. Redovi 94 i 95 umanjuju i uvećavaju vrijednost varijable

"sum" za odgovarajuće vrijednosti elemenata vektora "krivuljaOsY". Red 92 na kraj vektora

"movingAverage" dodaje element, koji sadrži vrijednost količnika varijable "sum" i parametra

"razdoblje". Red 98 definira zadnju "for" petlju u ovoj funkciji. Trajanje petlje određeno je

varijablom "mid". U svakom ponavljanju se na kraj vektora "movingAverage" dodaje element s

vrijednosti 0.

100 QString Krivulje::mjesecText(int date) 101 { QString x = krivuljaOsX[date][1]; 102 if (x == "01") return "siječanj"; 103 else if (x == "02") return "veljača"; 104 else if (x == "03") return "ožujak"; 105 else if (x == "04") return "travanj"; 106 else if (x == "05") return "svibanj"; 107 else if (x == "06") return "lipanj"; 108 else if (x == "07") return "srpanj"; 109 else if (x == "08") return "kolovoz"; 110 else if (x == "09") return "rujan"; 111 else if (x == "10") return "listopad"; 112 else if (x == "11") return "studeni"; 113 else return "prosinac"; 114 }

Funkcija "Krivulje::mjesecText" vraća riječ koja odgovara mjesecu određenom cjelobrojnim

parametrom "date". Red 101 definira tekstualnu varijablu "x" i u nju iz vektora "krivuljaOsX"

prepisuje oznaku mjeseca određenog parametrom "date". Redovi 102-113 ispituju o kojem

mjesecu je riječ i vraćaju odgovarajući naziv mjeseca.

60

6. ZAKLJUČAK

Iako je računalni program "Testno1" vrlo jednostavan i primitivan program, za autora

diplomskog rada to je do sad najkvalitetnije razvijen računalni program. Autor je već gradio

opsežnije programe, no bez poznavanja objektno orijentiranog programiranja on je bio primoran

razvijati programe složenije nego li je to bilo potrebno. Stoga je autora vlastito neznanje

sprječavalo od razvijanja računalnih programa, koji mogu obnašati složenije funkcije.

Razvijanjem računalnog programa "Testno1" autor je utemeljio i proširio svoje dosadašnje

poznavanje programiranja. Rješavanjem različitih problema s kojima se suočio, autor bolje

spoznaje opseg mogućnosti korištenja programskog jezika C++ i programa "Qt". Autor

namjerava nastaviti koristiti programski jezik C++ i program "Qt" kako bi "lakše" rješavao

različite probleme i zadatke, koji se pojave pred njim. Riječ lakše postavljena je među navodnike

kako bi se naglasila prisutnost alata, koji bi mogli ponuditi i jednostavnija rješenja za pojedine

probleme. Unatoč tome autor preferira programski jezik C++ zbog širokog spektra mogućnosti

koje pruža i zbog visokog stupnja učinkovitosti.

Pripremanjem i pisanjem diplomskog rada autor nije provodio stručna ili znanstvena istraživanja

ili eksperimentiranja. Stoga autor nije postigao nikakva znanstvena postignuća, no stekao je

izuzetno korisna znanja o programiranju, koja će moći vrlo učinkovito upotrijebiti u budućim

istraživanjima. Osim toga autor je stekao mnogo motivacije za nastavkom obrazovanja o

programiranju.

Tijekom svojih priprema, uoči početka pisanja diplomskog rada, autor je previdio značajan

problem. Autor je vrlo teško pronalazio odgovarajući prijevod s engleskog jezika za mnoge

stručne riječi.

61

LITERATURA

Knjige:

− Blanchette, J i Summerfeld, M 2008, C++ GUI Programming with Qt 4, Prentice Hall

− Davis, SR 2004, C++ for Dummies, Wiley Publishing, Inc., Indianapolis

− Sutherland, B 2014, Learn C++ for Game Development, Springer Science + Business

Media New York, New York

Web stranice:

− ASCII 2010, ASCII Table and Description, pregledano 6. lipnja 2015.

<http://www.asciitable.com/>

− C Plus Plus 2015, The C++ Resource Network, pregledano 4. lipnja 2015.

<http://www.cplusplus.com/>

− DTU 2014, C++ Standards, pregledano 2. lipnja 2015.

<http://www.open-std.org/jtc1/sc22/wg21/docs/standards>

− European Commission 2015, eurostat, pregledano 6. lipnja 2015.

<http://ec.europa.eu/eurostat/web/exchange-rates/data/database>

− Stack Exchange, Inc. 2015, Stack Overflow, pregledano 6. lipnja 2015.

<http://stackoverflow.com/>

− Stanley, M 2015, C++ Applications, pregledano 3. lipnja 2015.

<http://www.stroustrup.com/applications.html>

− The New Boston 2011, Buckys C++ Programming Tutorials, pregledano 4. lipnja 2015.

<https://www.thenewboston.com/videos.php?cat=16>

− The Qt Company, Ltd. 2015, Qt Documentation, pregledano 5. lipnja 2015.

<http://doc.qt.io/>

− VoidRealms, LLC 2015, Tutorials, pregledano 5. lipnja 2015.

<http://www.voidrealms.com/index.php?r=tutorial/index>

− Wikipedia 2015, C++14, pregledano 2. lipnja 2015.

<http://en.wikipedia.org/wiki/C%2B%2B14>

62

− Wikipedia 2015, GNU General Public License, pregledano 5. lipnja 2015.

<http://en.wikipedia.org/wiki/GNU_General_Public_License>

− Wikipedia 2015, GNU Lesser General Public License, pregledano 5. lipnja 2015.

<http://en.wikipedia.org/wiki/GNU_Lesser_General_Public_License>

− Wikipedia 2014, new(C++), pregledano 2. lipnja 2015.

<http://en.wikipedia.org/wiki/New_%28C%2B%2B%29>

− Wikipedia 2015, Object-oriented programming, pregledano 6. lipnja 2015.

<http://en.wikipedia.org/wiki/Object-oriented_programming>

− Wikiquite 2014, Bjarne Stroustrup, pregledano 2. lipnja 2015.

<http://en.wikiquote.org/wiki/Bjarne_Stroustrup>

− Youtube 2011, Buckys C++ Programming Tutorials, pregledano 4. lipnja 2015.

<https://www.youtube.com/watch?v=tvC1WCdV1XU>

− Youtube 2011, C++ Qt, pregledano 6. lipnja 2015.

<https://www.youtube.com/watch?v=6KtOzh0StTc>

Ostali Internet izvori:

− Atwood, J 2007, The Problem with C++, pregledano 2. lipnja 2015.

<http://blog.codinghorror.com/the-problem-with-c/>

− Rouse, M 2013, Object-oriented Programming (OOP) Definition, pregledano 6. lipnja

2015.

<http://searchsoa.techtarget.com/definition/object-oriented-programming>

− Shastri, A 2015, List of all famous software written in C++, pregledano 3. lipnja 2015.

<http://jabroo.blogspot.com/2012/08/c-plus-plus-applications-list.html>

63

POPIS SLIKA

Slika 1. Grafičko sučelje računalnog programa "Qt" .............................................................. 7

Slika 2. Grafičko sučelje računalnog programa "Testno1" ................................................... 14

Slika 3. Shema računalnog programa "Testno1" ................................................................... 15

Slika 4. Ikona računalnog programa "Testno1" ..................................................................... 23

Slika 5. Ikone alatnih blokova računalnog programa "Testno1" .......................................... 24

Slika 6. Kombinirani okviri i alatni blok za unos broja ........................................................ 25

Slika 7. Alatni blok "Grafikon::grafikon" .............................................................................. 34

Slika 8. Klizač "scrollBar" ...................................................................................................... 34

IZJAVA

kojom izjavljujem da sam diplomski rad s naslovom PROGRAM ZA ANALIZU VALUTNIH

TOKOVA GRAĐEN PROGRAMSKIM JEZIKOM C++ izradio samostalno pod

voditeljstvom prof. dr. sc. Marina Čičin - Šain. U radu sam primijenio metodologiju

znanstvenoistraživačkog rada i koristio literaturu koja je navedena na kraju diplomskog rada.

Tuđe spoznaje, stavove, zaključke, teorije i zakonitosti koje sam izravno ili parafrazirajući naveo

u diplomskom radu citirao sam na uobičajen, standardan način. Rad je pisan u duhu hrvatskog

jezika.

Suglasan sam s objavom diplomskog rada na službenim stranicama Fakulteta.

Student

Vedran Medica - Viola

ZAHVALE

Zahvaljujem mentorici prof. dr. sc. Marini Čičin - Šain na konstruktivnim savjetima i pomoći,

koja me vodila na putu u nova područja programiranja.

Zahvaljujem višem asistentu dr. sc. Ivanu Urodi na podrobnom pregledu rada i nesebičnoj

pomoći tijekom pripreme i izrade diplomskog rada.