Programiranje IV ALB PRINT

JULIJANA PETRESKA
PROGRAMIMI
Për vitin IV të profilit elektroteknik
për teknikë kompjuterike dhe automatikë
Programimi-Delphi
Botues:
MINISTRIA E ARSIMIT DHE SHKENCËS
E REPUBLIKËS SË MAQEDONISË
Rr. Mito Haxhivasilev Jasmin, p.n.
Shkup
Recensentë:
Dr. Ivan Çorbev,
docent në Fakultetin për elektroteknikë dhe teknologji informative
pranë universitetit “Shën Kirili dhe Metodij “ – Shkup
Biljana Pejovska,
Profesoreshë në shkollën e mesme “ Mihajllo Pupin” – Shkup
Daniela Sandeva,
Profesoreshë në shkollën e mesme “ Mihajllo Pupin” – Shkup
Përkthyes: Ing. Riza ETEMI
Lektor: Shkëlzen HALIMI
Shtypi: PROSVETNO DELLO ShA – Shkup
Shtypshkronja: NAPREDOK - Tetovë
ɋɨ ɪɟɲɟɧɢɟ ɧɚ Ɇɢɧɢɫɬɟɪɨɬ ɡɚ ɨɛɪɚɡɨɜɚɧɢɟ ɢ ɧɚɭɤɚ ɧɚ Ɋɟɩɭɛɥɢɤɚ

Ɇɚɤɟɞɨɧɢʁɚ ɛɪ. 22-4303/1 ɨɞ 28.07.2010 ɝɨɞɢɧɚ ɫɟ ɨɞɨɛɪɭɜɚ ɭɩɨɬɪɟɛɚɬɚ ɧɚ
ɨɜɨʁ ɭɱɟɛɧɢɤ.
Me vendim të Ministrit të Arsimit dhe Shkencës të Republikës së Maqedonisë

numër 22-4303/1 të datës 28.07.2010, lejohet përdorimi i këtij libri.
CIP – Ʉɚɬɚɥɨɝɢɡɚɰɢʁɚ ɜɨ ɩɭɛɥɢɤɚɰɢʁɚ

ɇɚɰɢɨɧɚɥɧɚ ɢ ɭɧɢɜɟɪɡɢɬɟɬɫɤɚ ɛɢɛɥɢɨɬɟɤɚ "ɋɜ.Ʉɥɢɦɟɧɬ Ɉɯɪɢɞɫɤɢ", ɋɤɨɩʁɟ
004.42(075.3)
ɉȿɌɊȿɋɄȺ, ȳɭɥɢʁɚɧɚ
ɉɪɨɝɪɚɦɢɪɚʃɟ ɡɚ IV ɝɨɞɢɧɚ ɡɚ ɩɪɨɮɢɥɨɬ ɟɥɟɤɬɪɨɬɟɯɧɢɱɚɪ ɡɚ ɤɨɦɩʁɭɬɟɪɫɤɚ
ɬɟɯɧɢɤɚ ɢ ɚɜɬɨɦɚɬɢɤɚ / ȳɭɥɢʁɚɧɚ ɉɟɬɪɟɫɤɚ. - ɋɤɨɩʁɟ: Ɇɢɧɢɫɬɟɪɫɬɜɨ ɡɚ
ɨɛɪɚɡɨɜɚɧɢɟ ɢ ɧɚɭɤɚ ɧɚ Ɋɟɩɭɛɥɢɤɚ Ɇɚɤɟɞɨɧɢʁɚ, 2010. - 186 ɫɬɪ.: ɢɥɭɫɬɪ.; 30 ɫɦ
ISBN 978-608-226-154-6
COBISS.MK-ID 84272138
2 Libër për vitin IV

Programimi-Delphi
PËRMBAJTJA
1. BAZA TË PROGRAMIMIT TË ORIENTUAR NË OBJEKTE................................ 7
1.1 Karakteristikat bazë të programeve të bazuar në dritare.................................... 7
1.2. Elementet e hapësirës grafike shfrytëzuese....................................................... 9
1.3. Programe të komanduara nga ngjarje............................................................... 13
1.4. Probleme që zgjidhen me Delphi..................................................................... 16
KAPITULLI 1 (SHKURT)…................................................................................... 17
Pyetje dhe detyra:….....……………………………………….…………………… 18
2. ANALIZA E EKRANIT TË DELPHI-it....................................................................... 19

2.1. Hyrje në hapësirën punuese të Delphi-it......................................................... 19
2.2 Interpreteri dhe kompajleri............................................................................. 24
2.3 Disa komponentë nga paleta e komponentëve................................................. 25
2.4 Projekt bosh...................................................................................................... 26
2.4.1. Rruajtja dhe hapja e projektit.............................................................. 26
2.5. Formulari (Forma) dhe përshtatja e vetive të saj.............................................. 28
2.6. Shtimi i komponentëve në formë (Label, Button, Edit).................................. 29
KAPITULLI 2 (SHKURT)........................................................................................ 33
Pyetje dhe detyra:...................................................................................................... 34
3. SHKRIMI I KODIT NË OBJEKT PASCAL.............................................................. 35

3.1. Projekti im i parë në Delphi. Programi përshëndetje........................................ 35
3.2. Elemente të gjuhës............................................................................................ 38
3.3. Të dhënat........................................................................................................... 38
3.4. Operatorë dhe shprehje..................................................................................... 39
3.5. Urdhri për dhënien e vlerës............................................................................... 39
3.5.1. Objekti Canvas….......................................................................................... 41
3.5.2. Komponenti Timer........................................................................................ 42
3.6. Projektimi i aplikacioneve me struktura lineare............................................... 44
3.6.1. Shndërrimi i të dhënave................................................................................. 46
3.7. Strukturat e degëzuar........................................................................................ 48
3.8. Komponentët për zgjedhje................................................................................. 50
3.8.1. Kontrolli Check Box.......................................................................... 50
3.8.2. Kontrolli RadioButton....................................................................... 54
3.8.3. Kontrolli Radio group........................................................................ 57
3.8.4. Komponenti ListBox.......................................................................... 63
3.8.5. Komponenti ComboBox.................................................................... 67
3.9. Komponentët kontejnerë................................................................................... 69
3.9.1. Komponenti GroupBox...................................................................... 69
3.9.2. Paneli.................................................................................................. 70
3.9.3. Bevel (korniza)................................................................................... 70
3.10. Module programore......................................................................................... 71
3.10.1. Trajta e përgjithshme e modulit të programit................................... 71
3.10.2. Fusha e veprimit të identifikuesit...................................................... 71
3.11. Strukturat ciklike.............................................................................................. 75
3.11.1. Urdhri WHILE-DO........................................................................... 75
3.11.2. Urdhri REPEAT UNTIL................................................................... 76
3.11.3. Urdhri FOR....................................................................................... 77
3.11.3.1. FOR-TO-DO (Për zmadhim deri në)................................. 77
3.11.3.2. FOR-DOWNTO-DO (Për zvogëlim deri në).................... 77
3.12. Komponentët për punë me vargje.................................................................... 78
Libër për vitin IV 3

Programimi-Delphi
3.12.1. Komponenti (Memo).................................................................................... 78

3.12.2. Komponenti StringGrid............................................................................... 85
3.13. Aplikacione multimediale (komponentët Shape dhe Image )......................... 88
3.13.1. Komponenti MediaPlayer................................................................ 94
KAPITULLI 3 (SHKURT)...................................................................................... 98
Pyetje dhe detyra:.................................................................................................... 101
4. SHKRIMI I MESAZHEVE (KORNIZA PËR DIALOG)………………………… 103

4.1. ShowMessage……….……………………………………………….……… 103
4.2. MessageDlg ………….……………………………………………………… 105
4.3. Messagedlgpos …………………………………………………………....… 109
4.4 Komponentët DIALOGS ……………………………………………………. 109
4.4.1. OpenDialog …………………………………………………….…. 110
4.4.2. SaveDialog ………………………………………………………... 111
4.4.3. ColorDialog …………………………………………………..…… 111
KAPITULLI 4 (SHKURT) ……………………………………………….……… 112
Pyetje dhe detyra:……………………………………………………………….... 112
5. KRIJIMI I MENYVE PËR FORMËN....………………………………………........ 113

5.1. MainMenu ………………………………………………………………........ 113
5.2. PopupMenu...……………………………………………………………........ 119
KAPITULLI 5 (SHKURT) …………….……………………………………….... 122
Ushtrime………………………………………………………………………....... 122
6. PROCEDURA (PROCEDURE) DHE FUNKSIONE

(FUNCTION) NË DELPHI.......................................................................................... 125
6.1. Nënprogramet ….………………………………………………….….......…. 125
6.2. Definimi i nënprogrameve............…………………………………........…… 125
6.3. Thirrja e nënprogrameve................. ………………………………….....…… 127
6.4. Kontrolli -ScrollBar. Detyra me funksione....………………………...……… 127
KAPITULLI 6 (SHKURT) ……………………….………………………......….. 132
Pyetje dhe detyra:………………………………………………………….....…… 133
7. BAZA E TË DHËNAVE …………………………………………………….…......... 135

7.1. Nocione për bazën e të dhënave.....……………………………………....................... 135
7.2. Çelësi primar, çelës i jashtëm dhe integriteti i bazës së të dhënave.............… 137
7.3. Lloje të bazave të të dhënave.. ………………………………………............. 140
7.4. Organizimi i lidhjeve me bazën e të dhënave................................................... 141
7.4.1. Teknologjia BDE (Borland Database Engine)................................................... 141
7.4.2. Krijimi i bazës së të dhënave duke shfrytëzuar programin
DatabaseDesktop..................................................................................................... 143
7.5. Projektimi i aplikacioneve për punë me bazë të të dhënave
duke shfrytëzuar magjistar……………………………………………….......… 147
7.6. Komponentë për lidhje me bazën e të dhënave....…………………….……… 152
7.6.1 Komponentë për lidhje me tabelën e bazës së të dhënave......…........ 152
7.6.2. Komponentë për shfaqjen dhe ndryshimin e të dhënave në bazë ….. 155
7.6.3. Filtrimi i të dhënave...........……………………………………..….. 161
7.6.4. Përpunimi i tabelës nga programi....……………………………...… 163
KAPITULLI 7 (SHKURT)...................................................................................... 175
Pyetje dhe detyra:..................................................................................................... 176
Përgjigje............................................................................................................................... 178
Literatura.............................................................................................................................. 186

Programimi-Delphi
PARATHËNIE
Motivimi themelor për realizimin e këtij libri është se ky është libër i parë
për lëndën adekuate në shkollat e mesme i cili përfshin materie për të cilën ekziston
interesim më i gjerë, dhe për të cilin ka literaturë të cunguar në gjuhën maqedonase
dhe shqipe.
Qëllimi primar i librit është të përgjigjet në nevojat për realizimin e
programit arsimor të lëndës programimi për vitin e katërt. Kjo kushtëzon që materia
e paraqitur të paraqes përforcim të diturive të fituara në lëndën e programimit në
vitin e dytë dhe tretë.
Në kapitullin e parë janë përpunuar bazat e programimit të orientuar në
objekte. Këtu analizohet hapësira punese e Windows-it dhe DOS-it, ekzekutimi
paralel i më shumë programeve (multitasking) dhe mundësia e punës duke
shfrytëzuar rrjetat.
Kapitulli i dytë përqendrohet në analizën e ekranit të Delphi-it, gjegjësisht
katër komponentët themelore të tij, puna me meny të programit, format si
komponentë kryesore të aplikacionit Delphi dhe mënyra e vendosjes së
komponentëve në formë.
Kapitulli i tretë ka të bëjë me shkrimin e kodit të programit dhe është më
voluminoz. Përshkruhen ngjarjet dhe mënyrat e vendosjes së kodit për ngjarjet.
Gjithashtu, do të mësohen elementet e gjuhës, strukturat programore, modulet
programore, fusha e veprimit të identifikatorit etj. Në të janë përfshirë numri më i
madh i komponentëve, siç janë: komponentët e zgjedhjes, komponentët kontejner,
komponentët për punë me vargje, komponentët për punë me aplikacione
multimediale etj.
Në kapitullin e katërt, i cili përbëhet nga shkrimi i mesazheve (kornizat për
dialog), është dhënë numër më i madh i dritareve dhe mënyrat e shfrytëzimit të
tyre. Ato nxënësit deri tani i kanë hasur vetëm gjatë punës me Windows dhe
aplikacionet e tij.
Kapitulli i pestë i përpunon mënyrat e krijimit të menyve për format.
Vëmendje e veçantë i kushtohet definimit të menysë kryesore si dhe menyve
ndihmëse. Procedurat dhe funksionet në Delphi janë përpunuar në kapitullin e
gjashtë, kapitulli i shtatë i përpunon bazat e të dhënave. Këtu bien ndarjet e bazave
dhe bazat e të dhënave relacionare, mënyra e lidhjes me bazat e të dhënave në
Delphi, mundësitë e shfrytëzimit të magjistarëve, si dhe mundësitë e qasjes
programore deri te të dhënat e bazës së të dhënave.
Numri i madh i fotografive të ekraneve punuese duhet t’ju ndihmojnë
nxënësve më lehtë t’i kuptojnë hapat e ekzekutimit të operacioneve të veçanta në
Delphi. Mund të vijë në dallime më të vogla në pamjen e ekranit në varësi nga
versioni i Delphi i cili do të shfrytëzohet.

Programimi-Delphi
Paraprakisht u falënderohem lexuesve dhe i lus t’i paraqesin komentet dhe

vërejtjet e tyre në lidhje me librin. Ajo do të më ndihmojë të rrisë kualitetin e
materies së shtruar.
Përkthimi i këtij libri ka qenë një detyrë shumë e vështirë dhe me
përgjegjësi. Duke marrë parasysh kompleksitetin e aplikacioneve që na mundësojnë
krijimin e programeve, jam munduar të jem sa më i saktë në përkthimin e termeve
që kanë të bëjnë me programimin. Po ashtu edhe intervenimet në kodet programore
janë bërë me qëllim të verifikimit dhe që rezultati i ekzekutimit të kodeve të jetë një
dritare në gjuhën shqipe.
Duke qenë i vetëdijshëm për specifikat e kodeve programore, ku çdo shenjë
është e rëndësishme, paraprakisht ju kërkoj ndjesë të gjithë lexuesve për ndonjë
lëshim që do të kenë në dorë këtë libër.

Programimi-Delphi
KAPITULLI 1
1. BAZAT E PROGRAMIMIT TË
ORIENTUAR NË OBJEKTE
Në këtë kapitull do të mësoni:
- të bëni dallimin mes sistemit operativ DOS dhe WINDOWS;
- të dalloni programin linear nga programi i orientuar në objekte;
- të shpjegoni multitasking-un;
- të sqaroni programimin e orientuar në objekte.
1.1. Karakteristikat bazë të programeve të bazuara në dritare
Parimet themelore të programimit janë vënë qysh në kohën e paraqitjes së

kompjuterëve të parë (vitet e pesëdhjeta të shekullit të kaluar). Në përputhje me
zhvillimin e teknologjisë kompjuterike, ndryshojnë edhe disa parime të zgjidhjes së
detyrave me ndihmën e kompjuterit. Ndryshime të rëndësishme në këtë lëmi
ndodhën me paraqitjen e sistemit operativ Windows i cili me kalimin e kohës e
zëvendësoi plotësisht sistemin operativ DOS.
DOS, si edhe sistemet operative tjera, komandon rrjedhën e informacioneve
mes pjesëve të ndryshme të kompjuterit. Me DOS-in punohet duke shkruar ose
zgjedhur komandat të cilat e orientojnë sistemin që të ekzekutojë komandat e
dhëna.
Sistemi operativ dallohet nga programet tjera nga ajo se është i
domosdoshëm për punën e kompjuterit. Kompjuteri pa sistemin operativ nuk mund
të punojë. Sistemi operativ harmonizon punën e të gjitha pjesëve nga të cilat
ndërtohet sistemi kompjuterik (ekrani, miu, tastiera, disku i fortë, programet që
shfrytëzohen etj.).
Sistemi operativ Windows sjell risi të rëndësishme siç janë: hapësira
punuese grafike (ndërfaqja shfrytëzuese (interfejs), ekzekutimi paralel i më tepër
programeve (multitasking) dhe mundësia e punës së shumë shfrytëzuesve në rrjetë.
Elementet dhe proceset e sistemit operativ Windows janë më të për-
shtatshëm dhe më të shumtë në krahasim me DOS-in dhe mundësojnë kontroll më
efikas në mundësitë e reja të sistemit operativ. Që të shfrytëzohen në masë më të
madhe mundësitë e reja të sistemit operativ, programuesit janë të detyruar të
ndryshojnë disa parime, hapat e zgjidhjes së detyrave me ndihmën e kompjuterit.
Deri në paraqitjen e Windows-it, komunikimi i shfrytëzuesit dhe programit
ishte shumë e ndërlikuar. Çdo prodhues i programit kishte idenë e tij për atë se
çfarë ndërfaqe do t’i ofrojë shfrytëzuesit. Shfrytëzuesi ishte ai i cili ishte i detyruar
të përshtatet në vizionin e prodhuesit të programit.
Zgjidhje e këtij problemi është gjetur në sistemet operative moderne, siç
është edhe Windows-i. Ndërfaqja shfrytëzuese është unifikuar në atë mënyrë që në
sistemin operativ janë ndërtuar elemente të cilat mundësojnë komunikim të thjeshtë
me shfrytëzuesin. Të gjitha elementet e ndërfaqes janë të natyrës grafike dhe për

Programimi-Delphi
nga pamja të orientojnë në aktivitetin që realizohet me të. Gjatë shkrimit të

programit, duhet të shfrytëzohen zgjidhjet ekzistuese të sistemit operativ. Për sa i
përket shfrytëzuesit, mjafton të njihet me mënyrën e punës dhe shfrytëzimin e
këtyre elementeve të njërit program. Puna me çdo program të ri do të ketë filozofi
të njëjtë dhe shfrytëzuesi më shpejt do të përvetësojë përdorimin e tij.
Me këtë qasje të zgjidhjes së problemeve kreatori i programit është i lirë nga
problemi i komunikimit me shfrytëzuesin, prandaj pjesën më të madhe të kohës së
punës mund ta orientojë në zgjidhjen e detyrës së dhënë. Që të mund të zgjidhen
detyrat në këtë mënyrë, është e domosdoshme njohja e sistemit operativ dhe
mekanizmat e tij për kontrollin e operacioneve të veçanta të cilët do të përfshihen
në program.
Karakteristikë bazë e programeve të shkruara për hapësirën e Windows-it
është se secili program ekzekutohet në dritare të veçantë. Në një moment mund të
kyçen më tepër programe. Secili nga programet e aktivizuara ka dritaren e vet në të
cilin ekzekutohet, kurse secili program mund t’i shfrytëzojë resurset e sistemit
operativ. Në fig. 1. është treguar pamja e sipërfaqes shfrytëzuese grafike kur janë
aktiv dy programe. Në shiritin e detyrave vërehet se janë shkruar dy emra të
programeve të aktivizuar. Njëri nga ata është dokument në Word, kurse tjetri, i cili
në momentin është aktiv, është dokument në Excel. Programi aktivizohet me klik,
me miun në shënimin adekuat në shiritin e detyrave (task panel). Shpërndarja e
dritareve në ekran mund të jetë edhe ndryshe (kaskadë), si në fig. 2.
Figura 1. Pamja e ndërfaqes shfrytëzuese kur punojnë dy programe.

Programimi-Delphi
Figura 2. Shpërndarja kaskadë e dritareve
1.2. Elemente të hapësirës shfrytëzuese grafike (ndërfaqes-interface)
Hapësirë shfrytëzuese grafike ka pamje të njëjtë për programe aplikative të

ndryshme të shkruar për punë në sistemin operativ Windows. Shkaqet për këtë
janë: shfrytëzim më i lehtë i programeve të ndryshme dhe shkrim më të lehtë të
programeve duke iu falënderuar shfrytëzimit të elementeve të gatshme të sistemit
operativ.
Tashmë përmendëm se element bazë i hapësirës shfrytëzuese grafike është
dritarja. Në varshmëri nga pamja dhe destinimi, të gjitha dritaret të cilat paraqiten
gjatë punës me programet aplikative mund të klasifikohen në disa grupe:
x Dritarja hyrëse e sistemit operativ (Desktop) ose sipërfaqja punuese,
x Dritarja e folderit,
x Dritarja-dokument,
x Dritarja-dialog.
Dritarja hyrëse paraqitet gjatë çdo nisje të sistemit operativ dhe në
përgjithësi përbëhet nga numër i caktuar i figurave të vogla që quhen ikona (icons).
Pamja e një dritare hyrëse është dhënë në figurën 3.

Programimi-Delphi
Figura 3. Dritarja e hyrëse e sistemit operativ. (Desktop)
Dritarja e folderit përfaqëson organizimin hierarkik të të dhënave në

sistemin operativ Windows. Në dritaren e folderit mund të gjinden folderë tjerë
(nënfolder) nëse ata ekzistojnë dhe/ose datoteka si grupe të organizuara të
informatave. Pamja e një folderi është dhënë në figurën 4.
Figura 4. Dritarja grupore My computer

Programimi-Delphi
Figura 5. Dritarja e aplikacionit PowerPoint
Dritarja e aplikacionit paraqet sipërfaqe në të cilën ekzekutohet programi

(aplikacioni). Dritarja e aplikacionit paraqitet pas aktivizimit të programit aplikativ
përkatës. Pamja e një dritare të aplikacionit është treguar në figurën 5.
Është normale, që produkti që del nga programi aplikativ të quhet dokument.
Mundësitë e sistemit operativ Windows lejojnë një program aplikativ të punojë me
më tepër dokumente të hapura ose njëkohësisht të aktivizohen më tepër programe
aplikative. Në atë rast mund të tregohen të gjitha dokumentet në të cilat punohet,
secili në dritaren e tij, si në figurën 6.

Programimi-Delphi
Figura 6. Dritarja e dokumentit
Dritaret për dialog janë të ndryshme varësisht nga destinimi. Më shpesh

paraqiten në formë të dritareve për paralajmërim ose në formë të dritareve për
dhënien e informatave plotësuese për sistemin operativ për punë të mëtejme. Në
figurën 7. është paraqitur një dritare për paralajmërim.
Figura 7. Dritare e paralajmërimit
Kjo dritare paraqitet nëse shfrytëzuesi përpiqet të dalë nga programi, kurse
punën në dokument nuk e ka ruajtur. Ky është paralajmërim i fundit për rruajtjen e
punës së mëparshme. Shfrytëzuesi ka në dispozicion tre mundësi prej të cilave
secila zgjidhet me shtypje në njërin prej butonave të treguar.
Dritarja-dialog mund të ketë edhe pamje më të ndërlikuar, e me atë edhe
funksionalitet më të madh, si dritarja në figurën 8.

Programimi-Delphi
Figura 8. Dritarja-dialog (Vetitë-Properties)
Në këtë dritare vërejmë ekzistimin e katër kartelave (faqeve), titujt e të

cilave janë dhënë në majë të dritares: Themes, Desktop, Screen Saver, Appearance
dhe Settings. Në figurë është dhënë funksioni i kartelës Themes. Kartelat tjera i
zgjedhim duke klikuar me mi në titullin përkatës. Në këtë dritare-dialog vendosen
shumë parametra të cilat ndikojnë në punën dhe sjelljen e sistemit operativ.
Është me rëndësi të ceket se disa dritareve nuk mund t’ju ndërrohet
madhësia e definuar nga sistemi operativ, ndërsa të tjerave mundet. Madhësia e
dritareve është e definuar paraprakisht.
1.3. Programe të komanduara nga ngjarje
Programet e komanduara nga ngjarje u mundësojnë shfrytëzuesve t’i

ekzekutojnë komandat sipas një radhitjeje çfarëdo. Koncepti i këtyre programeve
mundëson përpunimin e të dhënave sipas mënyrës që është më e pranueshme nga
shfrytëzuesi. Te këto programe një veprim i shfrytëzuesit mund të vë në lëvizje një
ngjarje ose varg ngjarjesh.
Ne jetojmë në një botë që udhëhiqet nga ngjarje. Të marrim, shembull,
sistemi muzikor. Të gjitha pajisjet më të reja të këtij lloji kanë komandues nga
largësia, me ndihmën e të cilit mund të zgjidhet pajisja që do të prodhojë muzikë
(radio, kasetofoni ose CD), mund të rregullohet volumi i zërit, kualiteti i zërit, të
ndërpritet zëri në kohë të caktuar, përsëri të ndalohet sistemi muzikor etj. Të gjitha

Programimi-Delphi
këto aktivitete, por edhe shumë të tjerë ekzekutohen me shtypjen e butonit përkatës
të telekomandës. Ky shembull i kontrollit të sistemit muzikor paraqet programim të
udhëhequr nga ngjarje. Shfrytëzuesi me shtypjen e butonit aktivizon ngjarje,
sistemi muzikor ndërmerr aksion përkatës, që do të thotë që shfrytëzuesi kontrollon
rrjedhën e ngjarjeve.
Në rrethin tuaj mund të hasni në numër të madh të pajisjeve të cilat janë të
programuara të reagojnë në ngjarje të caktuara.
Në botën e programimit edhe reagimet e kompjuterit mund të jenë shumë të
ndryshme: shtypje të tastit të tastierës, lëvizje të miut, klikim të miut, zgjedhje nga
menyja, lëvizje të dritares nga ana e shfrytëzuesit ose arritja e momentit kohor të
programuar në orën e brendshme të kompjuterit.
Sistemi operativ Windows është i ndjeshëm në ngjarje (i njeh) dhe me
mekanizmat e ngritur të tij reagon në to. Kur Windows “ndjen” ngjarje të caktuar,
ai përpiqet t’i “tregojë” programit për cilën ngjarje bëhet fjalë, duke dërguar
komandë adekuate. Programi aktiv duhet të interpretojë atë komandë, të njohë
ngjarjen për të cilën bëhet fjalë në mesazh dhe pastaj të reagoj në pajtim me atë.
Paketa programore Delphi mundëson shkrimin e programeve të cilat
ekzekutohen vetëm nëse ndodh ngjarje e caktuar. Vetëm nëse shfrytëzuesi shtyp
buton komandues të caktuar ose zgjedh ndonjë operacion, ekzekutohet program i
caktuar në Delphi.
Ngjarjet në programin Delphi mund të aktivizohen me veprim të
shfrytëzuesit, funksione interne, siç janë tajmerët (timer-orë të brendshme) ose nga
faktorë të jashtëm (pranim i mesazhit elektronik). Ekzistojnë shumë ngjarje të cilat
mund të ndodhin në programin aplikativ, i cili duhet të jetë i aftë t’i selektojë
ngjarjet. Aksionet zhvillohen vetëm gjatë ngjarjeve të caktuara.
Ngjarja mund të ndodhë në secilin moment gjatë kohës së punës së
programit. Windows i mundëson programit aplikativ të njohë ngjarjen. Kur
Windows do të njohë ngjarjen, programi ekzekuton kodin e programit që është i
shkruar për atë ngjarje. Problemi me ngjarjet është zgjidhur me bashkëpunim të
mirë mes Windows-it dhe paketës programore Delphi për të cilët mund të thuhet se
punojnë bashkë.
Në Delphi ekzistojnë dy tipe baze të ngjarjeve: ngjarje të cilën e nxit
shfrytëzuesi dhe ngjarja të cilën e ka nxitur sistemi operativ
Ngjarjet të cilat i nxit shfrytëzuesi, u mundësojnë kontroll të drejtimit në të
cilin ekzekutohet programi. Kjo do të thotë se shfrytëzuesi mund të ndërmarrë
veprime specifike kur të dëshirojë, që i jep liri të plotë në kontrollimin e programit.
Me paraqitjen e programimit të orientuar në objekte (POO) lehtësohet
krijimi programeve për Windows. Kjo mënyrë e programimit mundëson krijimin e
komponentëve për shfrytëzim të shumëfishtë në programe aplikative të ndryshme.
Nocione bazë në programimin e orientuar në objekte janë: komponentët, objektet,
metodat, vetitë dhe ngjarjet.
Komponentët janë elemente të vendosur në Delphi për shfrytëzim të
shumëfishtë dhe shfrytëzohen gjatë formimit të objekteve.
Objekti është element bazë në programin Delphi i cili ka veti të veçanta të
cilat i përcaktojnë karakteristikat e tij, metoda të cilat e definojnë sjelljen dhe
mundësitë e tij për njohjen e ngjarjeve në të cilat mund të reagojë.

Programimi-Delphi
Metoda është kod programor që i shoqërohet objektit e cila përcakton se si

objekti do t’i përpunojë informacionet dhe si do të reagojë në ngjarjet.
Veti janë karakteristika të objektit siç janë, për shembull: madhësia, pozita,
ngjyra ose fonti i tekstit. Vetitë e përcaktojnë paraqitjen, por ndonjëherë edhe
sjelljen e objektit. Vetitë mund të shfrytëzohen që objektit t’i gjejnë të dhëna dhe ta
kthejnë informatën nga objekti.
Programimi i orientuar në objekte është i ngritur në tre parime bazë:
enkapsulimi, të trashëguarit dhe poliformizmi.
Enkapsulimi do të thotë se të gjitha informacionet për objektin (vetitë) dhe
proceset (metodat) mbi të përmbahen në definimin e objektit. Për shembull, të
vëzhgojmë sistemin kompjuterik si objekt. Atë e përshkruajmë me ndihmën e
vetive të tij: lloji i procesorit, madhësia e diskut, memories, shpejtësia e modemit,
madhësia e monitorit.... Secila nga karakteristikat e cekura paraqet veti të sistemit
kompjuterik. Metodat paraqesin mënyrat në të cilat do të sillet sistemi kompjuterik
në situata të ndryshme, për shembull, aktivizimi i ndonjë programi. Në atë moment
sistemi operativ ekzekuton një varg operacionesh, kurse shfrytëzuesi në ndërkohë
nuk ka nevojë t’ia bëjë me dije sistemit kompjuterik se çfarë të bëjë.
Të trashëguarit do të thotë që një objekt mund të përshkruhet duke u bazuar
në një objekt tjetër. Nëse duhet të definohet kompjuteri portabël, nuk duhet të flitet
për ekranin dhe vetitë tjera të sistemit kompjuterik, por merret parasysh se ato janë
të njëjta si tek sistemi kompjuterik. Duhet të shtohen vetëm ato veti me të cilat
kompjuteri portabël dallohet nga kompjuteri klasik.
Poliformizmi ka kuptimin që shumë objekte mund të kenë të njëjtën metodë,
kurse veprimi adekuat ndërmerret nga objekti që e thirr atë metodë. Shembull,
programet për përpunimin e teksteve tekstin mund ta bartin në ekran ose shtypës.
Secili nga këta dy objektet, më ndihmën e metodës së tregimit ose shtypjes, e
lajmërojnë objektin që të shfaq tekstin në vendin e caktuar. Metoda tregon se çfarë
duhet të bëjmë në vartësi nga objekti që e thirr metodën.
Për ata që duan të dinë më tepër
OBJEKTE
Objektet mund t’i paramendojmë si sende në natyrë. Tek ata vërejmë:
-Veti- si gjatësia, lartësia, ngjyra.
-Ngjarje- si për shembull, ulja e shoferit në automobil.
-Metoda- si punon motori i automobilit.
-Nën objekte- si për shembull, motori që është pjesë përbërëse e automobilit.
Veti të caktuara të objekteve do të varen nga nën-objektet, si shembull, vetitë
ngasëse të automobilit në vartësi nga tipi i motit.
Do të thotë, objektet kanë metodat e tyre, veti, ngjarje. Kanë edhe nën-
objekte nga të cilët trashëgojnë vetitë, metodat dhe ngjarjet. Mund të jenë të
dukshëm ose jo.

Programimi-Delphi
VETI
Vetitë më shpesh janë variabla të ndonjë lloji, por mund të jenë edhe
funksione ose procedura, gjegjësisht objekte.
Me ndryshimin e vetive objekt sillen ndryshe.
Vetitë mund të ndërrohen në fazën e përpunimit të ndërfaqes (interfejsit në
Object Inspector) ose në fazën e përmbarimit të aplikacionit (me komandë në
dritaren Unit ).
NGJARJE
Ngjarje janë procedura me emër saktë të përcaktuar, kurse aktivizohen
vetëm atëherë kur vjen në shprehje vetia që e definon ngjarjen. Shembull, nëse
klikojmë në dritare, vjen në shprehje ngjarja Click, kurse nëse aplikojmë klik të
dyfishtë, vjen në shprehje ngjarja DblClick.
Njëkohësisht mund të vijnë në shprehje më tepër ngjarje.
Ngjarjet programohen ashtu që gjatë aktivizimit, aplikacioni tregon
ndërfaqen e tij - dritaret dhe objektet në to. Të gjithë ato presin që shfrytëzuesi të
bëjë diçka, që të mund të shkaktojë reagimin e tyre si përgjigje ndaj veprimit të
shfrytëzuesit. Kjo është normale në të gjitha aplikacionet e Windows-it, kështu që
programimi i tyre mbështetet në programimin e ngjarjeve (të cilat duhet të
ekzekutohen nëse shfrytëzuesi bën diçka).
METODA
Metoda ose veprime më shpesh janë procedura të cilat bëjnë diçka në
objekt. Mund të thirren me komanda në dritaren Unit ose me ndryshim të vetive.
Ata mund të nisin ndonjë ngjarje.
1.4. Probleme të cilat zgjidhen me Delphi
Delphi është paketë programore ɟ destinuar për krijimin e aplikacioneve për

Windows, për kompjuterë personal. Prodhimi përfundimtar i Delphi-it është
program ekzekutues i cili zgjidh detyrat. Gjuha programore të cilën e shfrytëzon
Delphi është version i modernizuar i Pascal-it i njohur si Object Pascal.
Programet e shkruara në Delphi mund të jenë me qëllime të ndryshme.
Karakteristika të mira tregon gjatë zgjidhjes së problemeve të cilat shfrytëzojnë
baza të të dhënave.
Pasi që rezultati përfundimtar i punës në Delphi është program ekzekutues
(EXE), me sukses mund të shfrytëzohet për krijimin e programeve komerciale të
pavarura. Shkrimi i programeve të mëdha për përpunimin e tekstit dhe fotografive
bëhet në ɋ++ ose assembler, por këto programe mund të bëhen edhe në Delphi.
Sot ekzistojnë edhe programe tjera me mënyrë të njëjtët të punës si Delphi,
të tillë siç janë Visual Basic dhe Visual C++. Secili nga këto programe ka
specifikën e vetë.
Versioni i parë i Delphi u paraqit në vitin 1995, si pasojë direkt e Windows
95. Sot më shpesh shfrytëzohen Delphi 5 dhe Delphi 7.

Programimi-Delphi
KAPITULLI 1
(SHKURT)
DOS si edhe sistemet operative tjera, komandon me rrjedhën e informatave
mes pjesëve të ndryshme të sistemit kompjuterik. Me DOS punohet duke shkruar
ose zgjedhur komanda të cilat e orientojnë sistemin të kryejë detyrat e dhëna.
Sistemi operativ Windows sjell risi domethënëse siç janë: hapësira punuese
grafike (ndërfaqja grafike), kryerja e më tepër programeve (multitasking) dhe
mundësia e punës të më shumë shfrytëzuesve në rrjetë.
Me paraqitjen e programimit të orientuar në objekte (POO) lehtësohet
krijimi i programeve të Windows-it.
Nocione bazë të programimit të orientuar në objekte janë: komponentët,
objektet, metodat, vetitë dhe ngjarjet.
Objekti është element themelor i programit Delphi i cili ka veti të cilat
përcaktojnë karakteristikat e tij, metodat të cilat definojnë sjelljen e tij dhe mundësi
të njohjes së ngjarjeve në të cilat mund të reagojë.
Metoda është kod programor që përcjell objektin i cili përcakton se si
objekti do t’i përpunojë informacionet dhe si do të reagojë në ngjarjet.
Vetitë janë karakteristika të objektit siç janë, për shembull: madhësia,
vendosja, ngjyra ose fonti i tekstit.
Paketa programore Delphi mundëson shkrimin e programeve të cilat
ekzekutohen, vetëm nëse ndodh ndonjë ngjarje.
Në Delphi ekzistojnë dy lloje bazë të ngjarjeve: ngjarje e shkaktuar nga
shfrytëzuesi dhe ngjarje e shkaktuar nga sistemi operativ.
Delphi është paketë programore e destinuar për krijimin e Windows
aplikacioneve për kompjuter personal.
Programimi i orientuar në objekte është i ngritur në tre parime bazë:
enkapsulimi, të trashëguarit dhe poliformizmi.

Programimi-Delphi
Pyetje dhe detyra:
1. Linja komandues është karakteristikë e sistemit operativ _________________,

kurse dritarja dhe tavolina punuese (desktop) janë karakteristika të sistemit
operativ ____________________.
2. Hapësira punuese e Windows-it karakterizohet me _______________________,
kurse DOS-it me _________________________________________________.
3. Nëse sistemin e shfrytëzojnë më tepër procese bëhet fjalë për ______________.
4. Shkrimi i programit në Delphi përfshin 2 hapa programore:
________________________________ dhe _______________________________
Përgjigje: Hapat programor vizuale dhe të kodit.
5. Nocioni multiuser në sistemin operativ do të thotë
___________________________________________________________________
Përgjigje: që sistemin njëkohësisht mund ta shfrytëzojnë më tepër shfrytëzues.
6. Cilët janë tre parimet themelore të programimit të orientuar në objekte

___________________________________________________________________
7. Karakteristikat e objektit siç janë. për shembull: madhësia, pozita, ngjyra ose
fonti i tekstit quhen ________________________________________________
8. Kodi programor që ndjek objektin i cili përcakton se si objekti do t’i përpunojë
informacionet dhe si do të reagojë në ngjarjet quhet ______________________.

Programimi-Delphi
KAPITULLI 2
2. ANALIZA E EKRANIT TË DELPHI-t

Në këtë kapitull do të mësoni:
- të përshkruani katër pjesët kryesore të dritares së Delphi-it;
- të shfrytëzoni opsionet më të rëndësishme të menysë kryesore FILE, EDIT,
VIEW, PROJECT, RUN, HELP.
- të dalloni kompajler dhe interpreter;
- të dalloni paletën e komponentëve dhe faqet më shpesh të shfrytëzuara;
- të njihni komponentët e faqes STANDARD;
- të njihni komponentët e faqes ADDITIONAL;
- të njihni komponentët e faqes SYSTEM;
- të sqaroni projektin DELPHI dhe datotekat nga të cilat përbëhet (.dpr,.dfr,.pas);
- të dalloni FORMËN si komponentë e parë dhe më e rëndësishme;
- të shpjegoni mënyrat e vendosjes së komponentit në formë;
- të ndryshoni veti të formës dhe komponentëve.
2.1. Hyrje në hapësirën punuese të Delphi-t
Delphi është paketë programore e cila bazohet në gjuhën programuese

Pascal, kurse shërben për përpunimin e programeve (aplikacioneve) të llojit të
bazuar në objekt me ndërfaqe shfrytëzuese grafike. Programi përbëhet nga objekte
të cilat reagojnë në veprimet e shfrytëzuesit. Aplikacioni në fazën e dizajnimit është
projekt.
Figura 2.1. Pamja fillestare e dritares së Delphi-it

Programimi-Delphi
Dritarja e hapësirës punuese të Delphi-it përbëhet nga tre pjesë edhe atë nga:
Dritarja kryesore (main)

E cila përbëhet nga:
a) shiriti- i emrit
b) shiriti- i menyve
c) shiriti me vegla Toolbars
d) shiriti me komponentë Component palette
Shiriti i emrit është linjë emri standard i Windows e cila përmban: ikonë të
programit, emrin e programit Delphi, emrin e projektit- dokumentin dhe tre butona
për kontrollimin e madhësisë së dritares së aplikacionit.
Shiriti- i menyve është shirit standard i menyve i cila përmban 11 opsione,

të cilët aktivizohen duke klikuar me mi në opsionin e dëshiruar. Secili opsion ka
numër të caktuar të urdhrave.
Në shiritin me vegla janë aktivitete si hapja e projektit, rruajtja e projektit,
pamja e kodit, debugimi i programit (gjetja dhe largimi i gabimeve), startimi i
programit etj. Këto urdhra jepen me klikim
direkt me mi në figurën përkatëse. Duke
filluar nga majtas-djathtas këto ikona kanë
këtë domethënie:
Shiriti Standard:
New – projekt i ri,
Open – hap projekt ekzistues, formë,....
Save – e ruan projektin,
Save all – ruan gjithë datotekat e projektit,
Open project – hap projekt ekzistues,
Add file to project – shton datotekë në projekt,
Remove file from project – largon datotekë nga projekti,
Shiriti Help – qasje në ndihmë,
Help contents – dritare për ndihmë,
Shiriti View – shirit i cili mundëson shfaqjen e programit ose të formës (ky
shirit gjendet ne radhën e dytë majtas),
View Unit –shfaq kodin programor të formës që dizajnohet,
View Form – tregon formën që dizajnohet,
Togle Form/Unit – zëvendëson formë dhe kod,
New Form – formë e re në projekt,
Shiriti Debug –shirit për përmirësimin e gabimeve në program (debugim)

Run – aktivizon ekzekutimin e programitɝɨ (ME PARALAJMËRIM
PARAPRAK),

Programimi-Delphi
Pause – ndërpret ekzekutimin e programit,

Trace into – e fillon ekzekutimin e programit urdhër pas urdhri (trace –
formë e debugimit tek i cili ndiqet radhitja e urdhrave) ose kalon në
ekzekutimin e urdhrit të ardhshëm të programit nëse trace tashmë ka filluar,
Step over – ekzekuton programin urdhër pas urdhri, duke marrë
nënprogramin si një urdhër, për dallim nga Trace i cili hyn në nënprogram.
Shiriti me komponentë përbëhet nga disa faqe, në çka secila dritare
përmban komponentët e saja të cilat mund të futen në formë. Pas startimit të
Delphi-it aktive është faqja Standard, kurse komponentët e saj janë treguar në
radhën e mëposhtme. Aktiviteti i faqes ndryshon me klikim me mi në titullin e
faqes, me çka ndërrohen edhe komponentët të cilat ndodhen në atë faqe.
Në pjesën e majtë të dritares ndodhen:
a) dritare për tregim hierarkik të komponentëve të aplikacioneve

b) dritare për caktimin e vetive dhe ngjarjeve të objekteve në aplikacion
- Object Inspector.
Ai ka dy pjesë:
z Properties (veti ose karakteristika)
z Events (ngjarje).
Në dritaren hierarkike tregohet prejardhja hierarkike e objekteve të vendosur
në aplikacion.
Në majë të dritares së Object Inspector-it gjinden dy tituj (Properties dhe
Events). Kjo do të thotë se kjo dritare ka dy faqe. Faqja e parë i tregon vetitë, kurse
tjetra ngjarjet për objektin e dhënë. Dritarja Properties është e ndarë në dy kolona.
Në të majtën janë emrat e vetive, kurse në të djathtë janë vlerat e tyre. Me klikim në
titullin Events fitohet lista e të gjitha ngjarje të mundshme për objektin e shikuar.
Në fushat për ngjarje regjistrohen emrat e procedurave të cilat ekzekutohen kur
paraqitet ngjarje e caktuar.
Shembull për veti: me ndryshimin e vetisë Color të ndonjë komponentë
ndryshohet ngjyra e asaj komponentë.
Shembull për ngjarje: nëse klikohet në komponentë të caktuar gjenerohet
ngjarje e cila tregon se në komponentë është klikuar. Mund të shkruhet kod
programor, i cili i përgjigjet kësaj ngjarje dhe i cili do të kryej veprime të caktuara
kur do të paraqitet ngjarja.
Pjesa e tretë e hapësirës së Delphi-it është dritarja e formularit ose
formës për dizajnimin e aplikacionit, ku i vendosim komponentët.
Pjesa e katërt e hapësirës së Delphi-it është dritare për shkrimin e kodit
të programit i cili gjendet pas dizajnuesit të formës.
Nga dritarja e tretë në të katërtën kalojmë me F12.
Gjatë kohës së krijimit të aplikacionit Object inspector, Code editor, Form
designer dhe Component palette punojnë në mënyrë interaktive.

Programimi-Delphi
Disa opsione nga shiriti-meny
Opsioni File nga menyja përmban:

New – projekt i ri, formë, Unit …;
New Application – aplikacion i ri
New Form – shton formë të re në aplikacion
Open – hap projekt ekzistues, formë,...;
Open Project – hap projekt
Reopen – rihap projekt, formë...
Save – e rruan Unit-in (njësinë);
Save As – rruan unit-in me emër tjetër;
Save Project As – rruan gjithë projektin;
Save all – i rruan të gjitha datotekat e projektit
Close – mbyll datotekën,
Close All – mbyll aplikacioni
Print – shtypje të formës ose të kodit,
Exit – dalje nga Delphi,
Opsioni EDIT i përmban nënopsionet vijuese:
Undelete – anulon fshirjen

Undo – anulon ndryshimet e bëra me operacionet e
fundit (zakonisht mbi tekstin)
Redo – kthen efektet e Undo,
Cut, Copy, Paste – urdhra për kopjimin dhe
zhvendosjen e tekstit
Select All – selekton gjithë tekstin ose gjithë objektet
në formë,
Align to grid – vendosja e komponentit së selektuar në
grid (rrjetën)-pikën më të afërt.
Bring to front, Send to back – vendosja e
komponentit në plan të parë ose në sfond,
Align- shtrirja e komponetës
Size - madhësisë,
Scale – faktori i zmadhimit, zvogëlimit,
Tab order – renditja e vendosjes në fokus të
komponentëve.
Lock Controls – i mbron kontrollet nga zhvendosja, zmadhimi ose zvogëlimi.

Programimi-Delphi
Opsioni VIEW i ka këto nënopsioni vijuese:
Project Manager – kjo dritare tregon informacione për

statutin dhe fajllat të cilat i përmban projekti i hapur për
momentin;
Object Inspector – e shfaq ObjectInspector;
Alignment palette – shiriti me vegla për rrafshim;
Units – tregon kodin e programit;
Forms – tregon format;
Toolbars – përfshirjen e shiritave me vegla.
Opsioni PROJECT i ka nënopsionet e mëposhtme:
Add to Project – shton një Unit ekzistues të cilin e

lidh me projektin vijues në Delphi. Kur do të shtoni
unit në projekt, Delphi automatikisht e shton këtë
unit në klauzolën uses në datotekën e projektit.
Remove from Project – largon nga projekti;
Compile Project – kompajlon gjithë fajllat e
projektit vijues të cilët ishin ndryshuar me
ndryshimet e fundit, duke krijuar datotekë
ekzekutuese - executable file (.EXE),. dynamic link
library (.DLL), resource file (.RES), etj. Kjo
komandë është e ngjashme me komandën Build, me
atë dallim që Build i rindërton të gjitha fajllat pa
dallim nëse ishin ndërruar ose jo.

Programimi-Delphi
Opsioni RUN ka këto nënopsione vijuese:
Run – aktivizon ekzekutimin e programit

(ME PARALAJMËRIM PARAPRAK)
Program Pause– ndërpret ekzekutimin e programit

Program Reset – programi fillon të ekzekutohet nga
fillimi, derisa gjejmë gabimet ose variablat kanë marrë
vlera të padëshiruara.
2.2. Interpreteri dhe kompajleri
Interpreteri është përkthyes i cili çdo rresht nga kodi burimor e përkthen në
gjuhën e makinës dhe e ekzekuton. Nëse një rresht programor përsëritet më tepër
herë, e njëjta do të analizohet aq herë sa paraqitet dhe do të përkthehet në gjuhën e
makinës gjithashtu aq herë me qëllim që të ekzekutohet. Kjo është arsyeja për të
cilën shfrytëzimi i interpreterit e ngadalëson ekzekutimin e programit. Nga ana
tjetër, interpreteri karakterizohet nga thjeshtësia, për shkak se është e mundur në
moment të zbulohen gabimet eventuale (me debagim) gjatë kohës së ekzekutimit të
programit.
Kompajleri është program i cili çdo urdhër të kodit burimor e analizon dhe
e përkthen në kodin e makinës, e regjistron në datotekë dalëse ekzekutuese. Gjatë
ekzekutimit ekzekutohen instruksionet e përkthyera në kodin e makinës, gjegjësisht
datotekën ekzekutuese. Kjo është arsyeja që programet ekzekutohen më shpejt për
dallim nga kur ekzekutimi shkon përmes interpreterit.

Programimi-Delphi
2.3. Disa komponentë nga Shiriti i komponentëve
Komponentët që ndodhen në faqen Standard të shiritit të komponentëve janë

siç vijon:
Frames Hap dritare-dialogu e cila shfaq në korniza listë të

përfshira në projektin në vijim. Korniza është
kontejner me objekte tjera.
MainMenu Komponenti për meny kryesore. Çdo formë e cila
duhet të ketë meny, duhet të ketë një komponentë të
këtillë.
PopupMenu Meny lokale. Kjo meny krijohet, por do të paraqitet
kur do të klikohet në butonin e djathtë të miut. Kjo
arrihet me vendosjen e AutoPopup në True.
Label Mundëson paraqitjen e tekstit statik në ekran.
Përmbajtja e etiketës (etiket) shkruhet në vetinë
Caption të etiketës.
Edit Komponenti për vendosjen e tekstit në një radhë.
Teksti i vendosur bashkëngjitet në vetinë Text. Nëse
në këtë komponentë vendoset numër, ai duhet të
përshtatet në mënyrë adekuate.
Memo Komponentë e ngjashme me Edit, me atë dallim që
mund të futet tekst në më tepër radhë.
Button Kjo paraqet buton të Windows. Titulli i tij jepet në

vetinë Caption. Në faqen Events definohet ngjarje në
të cilën do të reagojë butoni.
Check Box Komponentë e llojit ndërprerës. Me shtypjen e këtij
objekti përfshihet, gjegjësisht largohet, fusha logjike
e zgjedhur-Checked.
RadioButto Kjo është komponentë e ngjashme me CheckBox.
n Kur më tepër nga këto komponentë do të gjinden në
grup, vetëm njëra nga ato mund përfshihet.
ListBox Komponenti e cila paraqet tashmë listë të njohur të
Windows-it. Të dhënat mund të tregohen në më
tepër kolona që definohet me vetinë Columns.
ComboBox Kjo komponentë është kombinim i komponentëve
Edit dhe ListBox.
ScrollBar Kjo është komponentë e cila mundëson futjen e të

dhënave përmes rrëshqitësit.
GroupBox Komponentë e cila shërben që brenda saj të futen

komponentë tjerë. Kjo mundëson veprim të njëkohshëm
mbi të gjitha komponentët në kuadër të GroupBox.

Programimi-Delphi
RadioGroup Komponentë e cila mundëson që radio-butonat të

mos vendosen si komponentë të veçanta, por si
elemente të listës.
Panel Kjo komponentë shërben për zbukurimin e formës.
ActionList Krijon bashkësi të aksioneve, me çka centralizohet

aplikacioni në përputhje me aksionet e shfrytëzuesit.
2.4. Projekti i zbrazët
Projekti i zbrazët fitohet me aktivizimin e Delphi-it ose duke shfrytëzuar

opsionin File->New->Application nga menyja.
2.4.1. Ruajtja dhe hapja e projektit
Për të ruajtur projektin, duhet të bëjmë këto veprime:

- Në linjën e menyve zgjedhim opsioni File->Save Project As… me çka
fitohet dialog-dritarja si në figurën 2.2
Figura 2.2. Dritarja për rruajtjen e datotekës Unit.
- Pastaj në fushën për emrin e datotekës vendoset emri dhe klikojmë Save.
Kjo datotekë është datotekë e Pascal-it.

Programimi-Delphi
Figura 2.3. Dritarja për rruajtjen e projektit në datotekë
- Në hapin e ardhshëm paraqitet dritarja komunikuese, si në figurën 2.3. në

të cilën duhet të jepet emri i projektit.
- Pas këtij veprimi projekti është ruajtur në disk dhe kompjuteri lirisht mund
të ndalet ose të punohet me aplikacion tjetër.
Për të hapur projekt përsëri duhet të zbatohet procedura në vijim:
- Nga menytë zgjidhet opsioni File->Open Project…Ctrl+F11 dhe
fitohet dritare si në figurën 2.4.
Figura 2.4. Dritare për hapjen e projektit ekzistues
Në pjesën e sipërme të dritares ndodhet lista e projekteve të ruajtura. Projekti i

dëshiruar duhet të selektohet dhe emri i tij do të paraqitet djathtas nga File
name. Pastaj duhet të aktivizohet butoni Open.

Programimi-Delphi
2.6. Formulari (forma) dhe rregullimi i vetive të tij
Në figurën 2.1. vërejmë se shiriti i emrit i formularit e mban emrin Form1.

Ky emër titulli e ndan vetë Delphi. Për shfrytëzuesin, titulli i formularit duhet për
së afërmi të përcaktojë thelbin e tij. Që të ndryshohet titulli i formularit e
domosdoshme është të shfrytëzohet Object Inspector.
Vetia Caption rruan titullin e formularit. Atë do ta ndryshojmë nga Form1 në
Formular1. Ndërrohet edhe pamja e formularit.
Emri i formularit mund të ndryshohet duke shfrytëzuar vetinë Name. Me
këtë veti formularit i jepet emër që do të shfrytëzohet në aplikacion. Emri, i cili
është gjithashtu Form1, do ta ndryshojmë në Shembulli1.
Vetitë e komponentëve mund të ndryshohen edhe duke shfrytëzuar
kodin programor. Deri tek dritarja e kodit programor më lehtë vijmë nëse
klikojmë dy herë me mi në komponentin, në rastin tonë, në formë. Do të paraqitet
dritare si në figurën 2.5.
Figura 2.5. Dritarja e kodit programor
Me klikim të dyfishtë të formularit gjenerohet ngjarje e cila shkakton

formimin e drejtuesit të ngjarjeve në formë të kodit programor të dhënë në listingun
e mëposhtëm.
procedure TForm1.FormCreate(Sender: TObject);
begin
end;
end.
Këtë kod programor Delphi e formon automatikisht. Bëhet fjalë për kod në
Pascal. Në emrin e procedurës gjendet e shtuar vetia Name e formës. Në rastin e
parë ajo është Form1, kurse në rastin e dytë Shembulli1.

Programimi-Delphi
procedure TShembulli1.FormCreate(Sender: TObject);

begin
end;
end.
Shembulli 1: Mes begin dhe end do të fusim këtë urdhër:

Shembulli1. Caption:=’Emër i ri’;
Me këtë urdhër e detyrojmë Delphi-in të ndërrojë titullin e formularit në
Emër i ri. Në kodin programor të objektit mund të kemi qasej përmes emrit të tij.
Aplikacionin e ekzekutomë përmes urdhrit Run nga menyja.
Projekti duhet të rruhet dhe për këtë qëllim krijojmë folder të ri Ushtrime.
Pas rruajtjes, vërejmë se janë krijuar tetë datoteka. Për çdo formë ekzistojnë tre
datoteka:
x Datoteka me kod burimor të programit e cila e përshkruan formën dhe gjithë
nënprogramet (lloji.pas – PAScal source code), e cila paraqitet me futjen e
tekstit në dritaren e rregulluesit të kodit;
x Datoteka binare e kodit burimor të përkthyer (lloji.dcu – Delphi Compiled
Unit) të cilën e formon Delphi vetëm para ekzekutimit të projektit;
x Datoteka binare e formës (lloji.dfm – Delphi graphical form file) e cila e
përshkruan formën, dhe e cila krijohet gjatë rruajtjes së formës;
Nëse projekti shfrytëzon më tepër forma, për secilën nga ato krijohen të
gjitha të tre datotekat e cekura. Në secilin projekt- në Delphi ekzistojnë edhe 5
datotekat vijuese.
x Datoteka kryesore e projektit (lloji.dpr – Delphi Project File) të cilën Delphi
e krijon automatikisht gjatë projektimit, kurse përmban informacione për
modulet tjera programore të cilat i takojnë projektit si dhe tekst burimor të
programit kryesor të gjithë aplikacionit;
x Datoteka tekstuale e opsioneve të projektit (lloji.dot – Delphi project option
file), e cila përmban opsionet e përgjithshme të projektit;
x Datoteka tekstuale e konfiguracionit të projektit (lloji.cfg Configuration
file), e cila përmban parametra të përgjithshëm për hapësirën e Delphi-it;
x Datoteka binare e resurseve të projektit (lloji.res compiled Resource file), e
cila përmban ikonën e aplikacionit;
x Datoteka binare me kod ekzekutues të aplikacionit (lloji.exe compiled
EXEcutable file), të cilën Delphi e krijon pak para nisjes së ekzekutimit të
projektit.
2.7. Shtimi i komponentëve në formë (Label, Button, Edit)
Më në fund jemi në gjendje në formë të vendosim disa komponentë të cilat

do të bëjnë diçka konkrete.
Shembulli 2: Të krijohet aplikacion i ri, ku emri i formës të jetë Shembulli2,
kurse përshkrimi i saj Formular2. Vetitë duhet të ndërrohen në Object Inspector.
Secila formë mund të kuptohet si kuti në të cilën mund të vendosen numër i
caktuar i komponentëve. Komponentët zgjidhen nga shiriti i komponentëve.

Programimi-Delphi
Komponentin e zgjedhur në formular e vendosim në njërën nga

mënyrat e mëposhtme:
-me klik të dyfishtë në komponentë, me çka ajo vendoset në mes të formës,
-me klikim në komponentë, dhe pastaj me klik në formë në vendin ku duam
të vendoset komponenti.
Vendndodhja e komponentit në formë mund të ndryshohet.
Komponenta e parë të cilën do ta vendosim në formë është komponenta

Etiketa (Label). Ajo mundëson paraqitjen e tekstit statik në ekran.
Etiketa ka përshkrimin e saj të cilin Delphi automatikisht ia ndan. Që të mund të
ndërrohen vetitë e etiketës, ajo duhet të jetë e selektuar (në fokus) dhe në Object
Inspektor, të ndryshohet vetia Name në Etiketa1, dhe pastaj vetia Caption në
Objekti i parë. Vetia Font vendoset në Bold me madhësi 10.
Ndryshimin edhe të disa vetive të etiketës do ta kryejmë me ndihmën e kodit
programor, i cili aktivizohet me klikim të dyfishtë mbi etiketë. Pamja e procedurës
është treguar në listingun në vijim:
Procedure TShembulli2. Label1Click(Sender: TObject);

begin
Label1.color:=clRed;
Label1.Caption:='Emër i ri';
end;
Me ekzekutimin e këtij programi fitohet dritare si në figurën 2.6.
Figura 2.6. Ndryshimi i ngjyrës dhe përshkrimi i etiketës.
Ndryshimi i ngjyrës dhe përshkrimit të etiketës mundësohen nga dy radhët e

kodit programor. Disa veti të objektit mund të ndryshohen përmes Object Inspector
dhe me kodin programor; disa vetëm me kodin programor, kurse disa janë vetëm
për lexim dhe nuk mund të ndërrohen.
Komponenti e ardhshme me të cilin do të njihemi është Button. Ai është
buton klasik i Windows-it. Titulli i butonit jepet në vetinë caption. Në
faqen Events definohet ngjarja në të cilën do të reagojë me shfrytëzimin e
metodave adekuate. Për këtë qëllim krijojmë aplikacion të ri.

Programimi-Delphi
Shembulli 3: Në formular do të shtojmë dy komponentë: një etiketë dhe një

buton komandues. Në tabelë do të tregohen vetitë e komponentëve të cilat do të
ndryshohen, për shkak të qartësisë.
Pozita e etiketës në formë është treguar me tre kuadrate të zeza, por mundet
edhe aspak të mos shihet, nëse nuk është në fokus. Shkak për këtë është vlera në
vetinë AutoSize (true). Delphi këtë veti automatikisht e vendos në vlerën True.
Nëse shfrytëzuesi zgjedh vlerën False, hapësira në formë për etiketën, do të jetë aq
sa është etiketa. Në etiketë të vogël do të mund të vendoset tekst më i gjatë, nëse
vlera e vetisë është True.
Emri i komponentit Emri i vetisë Vlera e vetisë

Form1 Name Shembulli3
Caption Formulari3
Label1 Name Përshkrimi1
Caption Boshe
Button1 Name Starto
Caption Starto
Font Bold,10
Tabela 2.1. Vlera të vetive të komponentëve
Për të aktivizuar aplikacionin, duhet që në butonin komandues Starto të

shkruhet kod programor adekuat. Me klik të dyfishtë në buton aktivizohet
komanduesi me ngjarje dhe na mundëson shkrimin e kodit. Me aplikacionin duam
të arrijmë këtë: gjatë aktivizimit të aplikacionit, në hapësirën e etiketës të paraqitet
teksti,,Ky tekst paraqitet në etiketë”.
Programi përbëhet nga një linjë programore:
Përshkrimi1.Caption:=’Ky tekst paraqitet në etiketë’
Nëse e aktivizojmë ngjarjen, me klikim të miut në buton, do të ekzekutohet
kodi programor për këtë ngjarje.
Në kodin programor shtojmë këto dy rreshta:
Përshkrimi1.Font.Style:=[fsBold];
Përshkrimi1.Font.Size:=12;
Një nga rregullat që duhet të respektohet gjatë krijimit të aplikacionit është
se përkrah startimit të aplikacionit, duhet të sigurohet mundësia e ndërprerjes së
punës së aplikacionit. Në Formular3 shtojmë buton komandues me të njëjtin emër
dhe përshkrim Fund. Në klikim të këtij butoni hapet kodi programor në të cilin
shtohet vetëm një urdhër Close, i cili ka për detyrë të mbyll aplikacionin e nisur
Edit është komponentë për futjen e tekstit vetën në një rresht. Tekstit të
futur i shoqërohet vetia Text. Me shfrytëzimin e këtij objekti mund të futet ose
lexohet tekst. Nëse në këtë objekt futet numër ai duhet të shndërrohet që të mund të
shfrytëzohet si numër.
Shembulli 4: Të krijohet formë e re në të cilën do të vendosen dy etiketa të
reja, dy kuti Edit dhe dy butona. Vetitë e komponentëve të shfrytëzuar i tregojmë
në tabelën 2.2.
Tekstin që e vendosim në kutinë Edit ruhet në vetinë Text të komponentit.
Ideja e detyrës është që teksti i futur në kutinë e parë ȿdit, të paraqitet në të dytën.

Programimi-Delphi

Caption Formulari4
Caption Fut Emër dhe mbiemër
Font Bold,10
Caption Emri dhe mbiemri i futur është
Font Bold,10
Edit1 Name Fut
Text Boshe
Font Italic,10
Color Blue
Edit2 Name Shfaq
Text Boshe
Font Italic,10
Color Red
Button1 Name Starto
Caption Starto
Font Bold,10
Button2 Name Fund
Caption Fund
Font Bold,10
Tabela 2.2. Vlera të vetive të komponentëve
Kodi programor i cili i takon butonit Starto, i ngjarjes klik, është siç vijon:
Shfaq.text:=Fut.text;
Pasi që startohet aplikacioni, duhet të futet emër dhe mbiemër në kutinë
Edit1, dhe pastaj të shtypet në butonin Starto.
Disa veti të kontrollit Edit

Text – është variabël e tipit string në të cilën përfshihet teksti i futur.
Enabled – vlerë logjike e cila e tërheq vëmendjen në atë se a mundet kontrolli të
pranojë ngjarje nga tastiera ose miu. Nëse është me vlerë false, Kontrolli do të jetë
e zbehtë dhe nuk do të mund të futen të dhëna.
Read Only – shfrytëzuesi ka mundësi vetëm të lexoj të dhëna nga ajo kontrollë dhe
jo edhe të shkruaj në të.
Set Focus – vendos fokusin (kursorin) në kontrollin të cilin e thirr.
Password Char – definon shenjën me të cilën do të zëvendësohet teksti i vendosur.
SelText – veti e cila na jep gjithë tekstin e zgjedhur në kontroll.
Ngjarje të kontrollit Edit

On Change – ndodh çdoherë kur do të ndërrohet përmbajtja (text) e kontrollit Edit.
Shfrytëzoni ngjarjen për përpunim të të dhënave të futura nga ana e shfrytëzuesit
kur do të shfaqet kjo ngjarje.
On Enter – shfaqet kur Kontrolli fiton fokus për futje të të dhënave.
On Exit – shfaqet kur Kontrolli e humb fokusin për futjen e të dhënave.

Programimi-Delphi
KAPITULLI 2
(SHKURT)
Dritarja e sipërfaqes punuese të Delphi-t përbëhet nga katër pjesë edhe atë:
1. Dritarja kryesore (main) që përbëhet nga:
a) shiriti i-emrit;
b) shiriti-meny;
c) shiriti me vegla Toolbars;
d) shiriti me komponentë Component palette.
2. Në anën e majtë të dritares ndodhen:
ɚ) dritarja për tregimin hierarkik të komponentëve të aplikacionit
b) dritare për përcaktimin e vetive dhe ngjarjeve të objekteve në aplikacion -
Object Inspector.
Ai ka dy pjesë:
x Properties (vetitë ose karakteristikat)
x Events (ngjarjet).
3. Pjesa e tretë e hapësirës së Delphi-t është dritare e formularit ose formës
për dizajnimin e aplikacionit ku i vendosim komponentët.
4. Pjesa e katërt e hapësirës së Delphi-t është dritare për shkrimin e kodit
programor. I cili ndodhet pas dizajnuesit të formës.
Opsioni FILE i përmban këto nënopsione:
NEW, NEW APLICATION, NEW FORM, OPEN, OPEN PROJECT, REOPEN
SAVE, SAVE AS, SAVE PROJECT AS, SAVE ALL, CLOSE, CLOSE ALL, PRINT,
EXIT;
Opsioni EDIT i përmban këto nënopsione:
UNDELETE, REDO, CUT, COPY, PASTE, SELECT ALL, ALIGN TO GRID,
BRING TO FRONT, SENT TO BACK, ALIGN, SIZE, SCALE,TAB ORDER, LOCK
CONTROLS;
Opsioni VIEW i përmban këto nënopsione:
PROJECT MANAGER, OBJECT NSPECTOR, ALIGNMENT PALETTE,
UNITS, FORMS, TOOLBARS;
Opsioni PROJECT i përmban këto nënopsione:
ADD TO PROJECT, REMOVE FROM PROJECT, COMPILE PROJECT;
Opsioni RUN i përmban këto nënopsione:
RUN, PROGRAM PAUSE, PROGRAM RESET
Opsioni HELP. Ka komanda për të kërkuar ndihmë.
Interpeteri është përkthyes i cili çdo linjë të kodit burimor e përkthen në gjuhë të
makinës dhe e ekzekuton.
Kompajler është program i cili çdo urdhër nga kodi burimor e analizon dhe e
përkthen në kod të makinës, gjegjësisht, formon program të ekzekutueshëm.
Formulari-forma është komponenti themelore në aplikacionin e Delphi-it.
Vetitë e komponentëve mund të ndërrohen përmes Object Inspector dhe me
shfrytëzimin e kodit programor.
Komponentin e zgjedhur në formular i vendosim me njërën nga mënyrat e
mëposhtme:
- me klik të dyfishtë në komponentë, me çka ajo vendoset në qendër të formës,
- me klikim në komponentë, dhe pastaj me klikim në formë në vendim ku duam ta
sjellim komponentin.

Programimi-Delphi
Pyetje dhe detyra:
1. Nëse në Object Inspector ndryshohet vetia Name, si do të reflektohet në kodin

programor?
2. Nga cilat elemente përbëhet hapësira punuese e Delphi-t?
3. Për çka shfrytëzohet Kontrolli Edit?
4. Sqaro vetitë:
- Enabled
- Set Focus
- PasswordChar
- Read Only – kur përdoret
5. Në cilat dy mënyra mund të ndryshohen vetitë e objekteve?
6. Nga cilat elemente përbëhet Object Inspector?
7. Për çka shfrytëzohet Kontrolli Etiketa?
8. Sqaro ngjarjen:
- On Click
9. Cila procedurë do të hapet në ngjarjen On Click të butonit Button2 nga forma Form2.
10. Çka do të ndodhë nëse klikohet dy herë në komponentin e cila ndodhet në formular,
gjatë procesit të krijimit të aplikacionit?
11. Çka është kompajler dhe çka interpreter?
12. Si mundet të shfaqen të dhëna numerike në kutinë Edit?
13. Sqaro ngjarjet:
- On Enter
- On Change
Detyra:
1. Të hapet aplikacion i ri, të zgjidhet forma Form1, në Object Inspector të zgjidhet
Properties, të gjendet vetia Caption dhe vetia Height dhe të vendosen në këto vlera:
Form1.Caption:=’Ky është titulli i dritares’;
Form1.Height:=100;
2. Të krijohet program me një formë dhe një kuti Edit. Çdoherë kur shfrytëzuesi do ta
ndryshoj përmbajtjen e kontrollit Edit, përshkrimi i formës duhet të ndërrohet me tekstin e
futur (ngjarje OnChange tek Kontrolli Edit). Në vendin e tekstit të futur vërejmë vetëm yje
(Password Char të jetë * ).
Procedure Tform1.EditChange( );
Begin
Form1.caption:=edit1.text;
End;
3. Të krijohet program me një formë, dy kuti Edit dhe dy butona komandues njëri për
dalje, kurse tjetri e kopjon përmbajtjen e selektuar nga Kontrolli e parë Edit në të dytën.
Procedure Tform1.Button1Click( );
Begin
Edit2.text:=edit1.seltext;
End;
4. Të krijohet program në të cilin do të shfrytëzohet vetia Password Char, por e cila nuk
do të lejojë mbylljen e programit nëse nuk vendos pasword i saktë.
5. Të krijohet aplikacion i cila përmban dy kontrolle Edit. Kur shfrytëzuesi shkruan tekst
në komponentin e parë, i njëjti tekst duhet të paraqitet edhe në komponentin e dytë Edit.

Programimi-Delphi
KAPITULLI 3
3. SHKRUARJA E KODIT NË OBJECT PASCAL

Brenda këtij kapitulli do të bëhet fjalë për:
- kartelën EVENTS;
- ngjarjet më shpesh të përdorura ose të nënkuptueshme: EVENTS për
komponentët e duhura;
- rolin e ngjarjeve;
- përdorimin e komenteve në kod;
- shkrimin e komandave për ndarje;
- përdorimin e variablave (INTEGER, SHORTIN, LONGINT, BYTE,
WORD, SINGLE, DOUBLE, EXTENDED, REAL-COMP, REAL,
BOOLEAN, CHAR, STRING, POINTER);
- përdorimin e konstanteve;
- përdorimin e komandave për degëzim (IF dhe CASE);
- përdorimin e komandave për përsëritje (FOR, WHILE dhe REPEAT);
- transformimin e numrave të plotë në një varg-string dhe anasjelltas;
- shkrimin e ngjarjeve për BUTTON;
- shkrimin e ngjarjeve për ETIKETË;
- shkrimin e ngjarjeve për EDIT;
- shkrimin e ngjarjeve për LIST BOX;
- Përdorimin e metodave dhe elementeve përbërëse të secilit komponent në
një moment të dhënë.
3.1. Projektim im i parë Delphi

Programi përshëndetje
Kur niset ky program, paraqitet dritarja e paraqitur në figurën 3.1. Dritarja

përmban një formë, tre butonat komandues dhe një kuti testi Edit. Kur do të
klikohet në butonin komandues Trego, teksti "Përshëndetje njerëz!" do të shfaqet
në kutinë e tekstit. Kur ju klikoni butonin Fshi, teksti fshihet, dhe kur klikoni
butonin Dalje, programi mbaron.
Ndryshimi i vetive Caption të formës:
• Selektohet forma,
• Në dritaren Properties të Object Inspector e zgjedhim vetinë Caption,
• Në fushën djathtas nga Caption, tekstin Form1 e zëvendësojmë me
“Programi përshëndetje”
Tabela e vetive të komponentëve të Programit Përshëndetje:
Object Properties Settings

Form Name FrmPërshëndetje
Color Blue
Caption Programi përshëndetje
Button1 Name CmdDalje
Caption &Dalje
Font Arial
Size 14

Programimi-Delphi
Button2 Name CmdFshije

Caption &Fshije
Button3 Name CmdTrego
Caption &Trego
Edit1 Name TxtTrego
Text
(shenja & e nënvizon shenjën para së cilës është vendosur dhe lejon butoni të
aktivizohet nga tastiera duke shtypur njëkohësisht butonin Alt+ tastin)
Figura 3.1
Bashkëngjitja e kodit objekteve

Kodi zbatohet si rezultat i një ngjarje. Nëse ju klikoni mbi butonin Dalje
gjatë kohës së ekzekutimit të Programit Përshëndetje, atëherë automatikisht
gjenerohet ngjarja (event) On Click, e cila automatikisht ekzekuton kodin
programor që është i lidhur me ngjarjen. Kjo do të thotë se puna vjen për shkak të
ekzekutimit të kodit adekuat të përcaktuar për ngjarjen e objektit.
Bashkëngjitja e kodit për butonin komandues Trego:
• Mënyra- I
o selektohet butoni,
o nga kartela ngjarje (events -> Object Inspector) zgjidhet ngjarja On
Click,
o klikohet dy here në fushën djathtas ngjarjes së zgjedhur, me ç`rast
hapet procedura në të cilën e shkruajmë kodin programor.
• Mënyra- II
o Double-click mbi butonin komandues Trego. Në dritaren e kodit
automatikisht gjeneron emri i procedurës dhe emir i objektit në të
cilin është aktiv ngjarja e cila do të shkaktoj veprimin e dhënë.

Programimi-Delphi
Procedure TFrmPërshëndetje.CmdTregoClick(Sender: TObject);

begin
txtTrego.text:='PËRSHËNDETJE!';
end;
Bashkëngjitja e kodit butonit komandues Fshije, në ngjarjen OnClick:
Procedure TFrmPërshëndetje.CmdFshijeClick(Sender: TObject);
begin
txtTrego.text:=' ';
end;
Kodi i mëposhtëm është për butonin Dalje:
procedure TFrmPërshëndetje.CmdDaljeClick(Sender: TObject);
begin
Application.terminate;
end;
Detyra: Të bëhen ndryshime në programin e mëparshëm në Delphi, me
ç`rast në modelin ekzekutiv të fitojmë dritaren nga figura 3.2.
Figura 3.2.
3.2. Elemente të gjuhës
Grupi i shenjave
Këto përfshijnë të gjitha shkronjat e alfabeti anglez, dhjetë shifrat decimale

dhe karakteret e veçanta të tilla si -, *, /,,,:, [,], {,}, etj. Në pjesën zyrtare të
programit nuk bëhet dallimi në mes të shkronja të mëdha dhe të vogla.

Programimi-Delphi
Komentet
Komentet janë shpjegime për lexuesin e programit. Ata përkthyesi i kanë
lënë pas dore. Shkruhen në mes të kllapave të mëdha çifte {i}, ose në mes të
kllapave çifte të përbërë nga dy karaktere (* i *).
Për shembull: {Ky është koment}, (* por edhe ky është koment *).
Identifikuesit
Identifikuesit shërbejnë për shënimin e të gjitha llojeve të elementeve të
programit: variablave, konstantave, llojeve të të dhënave, moduleve, nën
programeve etj. Përbëhen nga shkronja, karaktere, viza e poshtme _, me çka shenja
e pare nuk mund të jetë shifër. Për të kuptuar më lehtë programin, identifikuesit
duhet të jenë emra që do të përshkruajnë objektet që u referohen.
Fjalë zyrtare dhe direktiva standarde

Në Pascal dhe me atë edhe në Delphi ekzistojnë fjalë zyrtare të cilat shënojnë
urdhrat, operatorët, konstanta dhe elemente të tjera zyrtare të gjuhës. Ata janë fjalë të
rezervuara dhe nuk duhet të përdoret si identifikues të objekteve të tjera në programe.
Fjalë zyrtare në Delphi janë: var, array, unit, and, case, begin, type etj.
3.3. Të dhënat
Këto janë objekte të cilat përpunohen në programe. Karakteristika kryesore e

të dhënës është lloji i saj. Lloji përcakton vlerat e mundshme të të dhënave dhe
operacionet e mundshme mbi to.
Llojet e të dhënave Numër i plotë janë grupe të numrave të plotë. Ato
dallohen për nga rangu i vlerave: Integer (-2147483648-2147483647), Longinteger
(-2147483648-2147483647), Cardinal (0-4294967295), Shortint (-128-127), Byte
(0-255), Word (0 - 65.535) dhe kështu me radhë.
Llojet e të dhënave Real janë grupe të numrave racional. Këtu përfshihen: Real (r
(5.0 * 10-324-1.7 * 10308)), Single (r (1.5 * 10-45-3.4 * 1038)), Double (r (5.0 * 10-
324
-1.7 *10308)), Extended (r (3.4 * 10-4932 -1.1* 10-4932)),…., Valutat...
Llojet e të dhënave Logjike shërbejnë për të paraqitur rezultatet e shprehjes logjike,
e cila mund të jetë e saktë apo jo e saktë. Në Delphi ekzistojnë Boolean, ByteBool,
WordBool, LongBool.
Llojet e të dhënave Shenja përdoren për paraqitjen e shkronjave, numrave dhe
karaktereve speciale, që mund të shfaqen në tekste të ndryshme. (Char, AnsiChar
dhe WideChar)
Konstantat janë të dhëna vlerat e të cilave nuk mund të ndryshojë gjatë
ekzekutimit të programit.
Const
Konstanta = vlera;
Shembull:
Pi = 3,14159265359;
Eps = 1E-9;
Ndryshoret janë të dhëna vlerat e të cilave mund të ndryshojnë gjatë ekzekutimit të
programit. Paraqiten duke përdorur identifikues. Definohen në pjesën var (variable
- ndryshore) për të definuar ndryshoret në formën e përgjithshme të mëposhtme:
Var ndryshorja1, ndryshorja 2,…, ndryshorja N: Lloji;

Programimi-Delphi
Shembull:
Var
Fillimi, Fundi:Integer;
Shenjë: Char;
Diametër, Rreth: Real;
P,Q,R,S,T:Boolean;
Definimi i llojeve. Me këtë nënkuptohet ndarja e identifikuesit të llojit të cilat i

përcakton përdoruesi. Llojet definohen në pjesën deklarative Type, e cili shërben
për të përcaktuar llojet, forma e përgjithshme e të cilëve është:
EmriILlojit=PërshkrimILlojit;
Shembull:
Type
TDita=(e Hen, e Mar, e Mer, e Enj, e Pre, e Sht, e Die);
TData=1..31;
TVargu=Array[1..10] of Integer;
3.4. Operatorët dhe shprehjet

Operatorët janë aktivitetet që kryhen mbi operantët (të dhënat) dhe japin
rezultate konkrete. Shprehjet janë sisteme komplekse të dala nga operatorët dhe
operantët.
Operatorët aritmetik
Ato përdoren për të kryer operacione themelore aritmetike. Për mbledhje +,
shumëzim *, zbritje -. Lloji i rezultatit të këtyre operatorëve është numër i plotë në
qoftë se të dy operantët janë numër i plotë, për ndryshe është real.
Për pjesëtim ekziston operatori /, i cili gjithmonë jep një rezultat të llojit real
dhe operatori div (pjesëtimi i numrave të plotë), në të cilën të dy operantët duhet të
jetë numër i plotë, por edhe rezultati është numër i plotë
Ekziston edhe operatori mod, operantët e të cilit janë numra të plotë, por edhe
rezultati është gjithashtu numër i plotë. Ky operator si rezultat e jep pjesën e mbetur
të pjesëtimit.
Operatorët Relacional
Përdoret për të krahasuar të dhënat numerike dhe llojet e të dhënave për
numërim. Rezultatet e këtyre operatorëve janë True ose False. Këto përfshihen: =,
>, <, <>, <=, > =.
Operatorët Logjik
Operatorët logjik shërbejnë për të kryer operacione logjike mbi të dhënat
logjike dhe japin rezultate logjike. Këtu përfshihen: not, and, or, xor.
Prioriteti i operatorëve
Prioriteti Operatori
Më i lartë not
*,/, div, mod, and
+, -, or, xor
Më i ulët =,<>, <, <=,>, >=
Tabela 3.1.

Programimi-Delphi
3.5. Urdhri për dhënien e vlerës
Ky është një urdhër me ndihmën e së cilit rezultati i ndonjë llogaritje

vendoset në ndonjë ndryshore. Forma e përgjithshme e komandës është:
Ndryshorja: = shprehje;
ku Ndryshorja është vendi në memorie ku vendoset rezultati, kurse Shprehje është
shprehja vlera e të cilës është llogaritur.
Shembull:
I: = J + K div L;
A: = S*12.5;
Ndryshorja dhe shprehja duhet të përputhen në lloj.
Detyra 2: Të bëhet një program në Delphi me të cilin do të ndryshohet ngjyra e

sfondit të formës. Në formë vendosen pesë butona komandues me postimet e
mëposhtme: Red, Blue, Yellow, Green, Normale. Duke klikuar në butonin e duhur
të ndryshohet ngjyra e formës. Përshkrimi formës të jetë Shembulli1. Pas
ekzekutimit të fitojmë një dritare si në figurën 3.3.
Figura 3.3.
Tabela e vetive
Objekti Vetia Vlera
Form1 Caption Shebulli1
Label1 Caption Nderimi i ngjyrës së sfondit
Button1 Caption E kuqe
Button2 Caption E kaltër
Button3 Caption E verdhë
Button4 Caption E gjelbër
Button5 Caption Normale
Tabela 3.2.
(Në këtë shembull nuk ndryshojnë vetitë Name të komponentëve)

Programimi-Delphi
Kodi që i shoqëron butonat është:

Procedure TForm1.Button1Click ();
Begin
Form1.color:=clred;
End;
Begin
Form1.color:=clblue;
End;
Begin
Form1.color:=clyellow;
End;
Begin
Form1.color:=clgreen;
End;
Begin
Form1.color:=clbtnface;
End;
Detyra 3: Të hapet aplikacion i ri. Ngjarja Click i formës të programohet, ashtu që

duhet të shkruhet tekstin PËRSHËNDETJE!
Zgjidhja: Aktivizohet aplikacion i ri. Aktivizohet ngjarja Click përmes Object

Inspector dhe shkruhet kodi i mëposhtëm:
Canvas.Textout (10,10, 'PËRSHËNDETJE!');
Detyra 4: Teksti "PËRSHËNDETJE" të paraqitet në një pikë me koordinata të

rastit.
Zgjidhja:
procedure TForm1.FormClick(Sender: TObject);
var x,y:integer;
begin
x:=random(690);
y:=random(480);
Canvas.Textout(x,y,'PËRSHËNDETJE!');
end;
3.5.1. Objekti Canvas
Ai është nën-objekt i formës dhe shërben për të nxjerrë dhe shkruar tekstin
pas saj. Përfaqëson zëvendësim për urdhrat Read/Write nga Paskali, si edhe disa
urdhra grafik. Metoda TextOut shkruan ndonjë tekst në koordinatat e dhëna.

Programimi-Delphi
Detyra 5: Të bëhet aplikacion i ri, e cila do të tregojë dritaren e dytë nëse klikohet
në të parë.
Zgjidhja: Të hapet një aplikacion i ri, të shtohet një formë e re, të programohet
ngjarja klik në Forma1 me urdhrin:
Form2.show.
Forma e re është shtuar me ikonën New form.
Metoda Show e tregon formën e përcaktuar. Aplikacionet të cilat kanë më tepër
dritare, gjatë aktivizimit i inicojnë të gjitha dritaret, por vetëm një është e dukshme
– dritarja fillestare, e cili zakonisht përmban ndërfaqen, kurse dritaret tjera mund të
shfaqet sipas nevojës si përgjigje e ndonjë aksioni të shfrytëzuesit.
3.5.2. Komponenti Timer (ora) gjendet në shiritin e komponentëve të faqes

Sistem. Komponentët e Delphi-t ndahen në të dukshme dhe të padukshme, në
varësi nga ajo se gjatë ekzekutimit të aplikacionit ata janë të dukshme apo jo.
Shumica e komponentëve janë të OnClick në një interval të dhënë kohor. Timer
është një lloj kronometër, që kryen periodikisht pjesë të kodit programor, pa marrë
parasysh gjendjen e programit.
Detyra 6: Të krijohet aplikacion i ri i cili do të na tregojë kohën dhe datën

momentale. Formulari përmban dy etiketa, dy kuti Edit dhe dy butona.

Caption Formulari5
Caption Koha
Font Bold,10
Caption Data
Font Bold,10
Edit1 Name Koha
Text Boshe
Font Bold,12
Edit2 Name Data
Text Boshe
Font Bold,12
Button1 Name Starto
Caption Starto
Font Bold,10
Button2 Name Fund
Caption Fundi i punës
Font Bold,10
Tabela 3.3. Vetitë dhe vlerat e komponentëve në shembull

Programimi-Delphi
Figura 3.4. Ndërfaqja shfrytëzuese për shembullin e shqyrtuar
Kodi i programit është shkruar për ngjarjen klik të butonin Starto:
procedure TShembulli5.StartoClick(Sender: TObject);

begin
Koha.text:=timetostr(time);
Koha.color:=claqua;
Data.text:=datetostr(date);
Data.color:=clyellow;
end;
Duke analizuar kodin e programimit, vërejmë funksion të ri për konvertimin

e kohës dhe datës në një varg-string. Kjo duhet të bëhet për shkak se kutia Edit
mund të pranojë vetëm tekst. Pasi të fillojë aplikacioni, në kutitë e Edit tregohet
koha dhe data. Presim që koha të ndryshojë, por kjo nuk ndodh. Problemi zgjidhet
duke shtuar komponentin Timer dhe me një ndryshim të vogël të kodit programor.
Timer-i ndodhet në faqen System të shiritit të komponentëve. Timer është
komponentë e padukshme, por në formë shihet. Gjatë ekzekutimit të aplikacionit
nuk duket. I ndryshojmë vetitë e komponentit Timer: Name (Saat), Enabled (False).
Dy vetitë tjera nuk i ndryshojmë. Me rëndësi është që vetia që ndikon në
shpejtësinë e punës së Timer-it është vetia Interval. Vlera e vendosur në 1000
prodhon ngjarje të një sekonde, që i përgjigjet punës së orës.
Me nisjen e programit fitohen dritare si në figurën 3.5, ndërsa në kutinë Edit
shfaqet koha reale.

Programimi-Delphi
Figura 3.5. Ndërfaqja shfrytëzuese për shembullin e shqyrtuar Timer
Kodi programor i ndryshuar është si vijon:

procedure TShembulli5.Fund Click(Sender: TObject);
begin
Close;
end;
procedure TShembulli5.Starto Click(Sender: TObject);
begin
saɚt.enabled:=true;
end;
procedure TShembulli5.satTimer(Sender: TObject);
begin
Koha.color:=claqua;
end;
3.6. Projektimi i aplikacioneve me struktura lineare
Pas njohjes së komponentëve Labela, Edit, Button dhe Timer mund të zgjedhim
probleme me struktura algoritmike lineare të thjeshta. Këto programe kanë vetinë
që çdo komandë të ekzekutohet vetëm një herë gjatë kohës së ekzekutimit të
programit.

Programimi-Delphi
Programet e këtilla të shkruara në Pascal përmbajnë urdhra për të futur të

dhëna, për përpunimin e të dhënave dhe nxjerrjen e rezultateve.
Detyra 1: Të shkruhet aplikacion që do të mbledh dy numra dhe do të tregon

rezultatin e tyre.
Zgjidhje: Duhen dy kuti Edit për të futur numrat dhe një kuti Edit për rezultatin.
Janë të nevojshme tre etiketa dhe dy butona.
Duhet të mendohet për kodin programor të mëposhtëm:
procedure TForm1.Button1Click(Sender: TObject);

begin
edit3.text:=edit1.text+edit2.text;
end;
Me ekzekutimin e këtij projekti, me futjen e vlerat të nevojshme në kutitë Edit

përkatëse dhe me klikim në butonin Mblidh fitohet dritarja si në figurën 3.6.
Figura 3.6.
Është e qartë se rezultati nuk është i mirë. Ai është fituar nga unifikimi i
këtyre dy numrave. Programi i trajton numrat e futur si vargjet-string, kurse
operacionin si një unifikim të vargut-stringut (konkatenacion).
Problemi duhet të zgjidhet në kodin programor me vendosjen e duhur të të
dhënave të aplikacionit.
Var
a,b,c:real;
begin

Programimi-Delphi
a:=StrToFloat(edit1.text);
b:=StrToFloat(edit2.text);
c:=a+b;
edit3.text:=FloatToStr(c);
end;
3.6.1. Konvertimi i të dhënave
Në kontrollin Edit mund të fusim të dhëna vetëm në formë të String-ut. Nëse

duhet që të dhënat e futura të jenë të dhëna numerike (numër), atëherë përdorim
funksione për konvertim.
Function StrToInt (const s:string):Integer;
(Konverton stringun-tekstin-në numër të plotë)
Function StrToFloat(const s:string):Extended;
(Konverton stringun-tekstin-në numër decimal)
Function IntToStr(value:Integer):String;
(Konverton numrin e plotë në varg-string)
Function FloatToStr(value:Extended):String;
(Konverton numrin decimal në varg-string)
function TimeToStr(Time: TDateTime): string;
(Konvertimi nga koha në varg)
function DateToStr(Date: TDateTime): string;
(Konvertimi nga data në varg)
Detyra 2: Të bëhet program për llogaritjen e shumës, zbritjes, produktit dhe herësit
të dy numrave. Vendosja bëhet përmes dy kutive Edit, gjithashtu edhe rezultati
shfaqet në kutinë e Edit.
Figura 3.7.

Programimi-Delphi
Mënyra I:
Procedure TForm1.Button1Click();
Var nr1,nr2,rez:Integer;
Begin
Nr1:=strtoint(edit1.text);
Rez:=nr1+nr2;
Edit3.text:=inttostr(rez);
Label5.caption:=’+’;
End;
Begin
Rez:=nr1-nr2;
Label5.caption:=’-’;
End;
Begin
Rez:=nr1*nr2;
Label5.caption:=’*’;
End;
Rez:Real;
Begin
Rez:=nr1/*nr2;
Edit3.text:=floattostr(rez);
Label5.caption:=’/’;
End;
Mënyra II:

Begin
Edit3.text:=inttostr(strtoint(edit1.text)+strtoint(edit2.text));
Label5.caption:=’+’;
End;

Programimi-Delphi
Për butonat tjerë kodi është shkruar në mënyrë të ngjashme. Për Butonin
"Herësi (/)" duhet të merret parasysh lloji i rezultatit.
Detyra:
3. Të bëhet një program në Delphi për llogaritjen e rezistencës ekuivalente të
rezistorëve të lidhur në seri dhe paralel.
Figura 3.8.
4. Duke klikuar në formë të ndryshojë përshkrimi i formës në "Kliko tek unë!"

5. Të shkruhet aplikacion në të cilin shkruhen vlerat e kateteve a dhe b të një
trekëndëshi kënddrejtë, të llogaritet hipotenuza s, të dy këndet e mprehta dhe
sipërfaqja e tij.
Udhëzime: c = sqrt (sqr (a) + sqr (b)), alfa = arctan (a / b) * 180/Pi, beta = arctan (b
/ a) * 180/Pi, P = a*b /2
3.7. Strukturat e degëzuara
Këto struktura lejojnë kryerjen e kushtëzuar të një ose të asnjë Urdhri nga
grupi i një ose më shumë urdhrave.
Forma e përgjithshme e urdhrit IF ose urdhri për zgjedhjen e dy opsione
If kushti then Urdhri1 else Urdhri2 ose
If kushti then Urdhri1,
ku kushti është një shprehje logjike, Urdhri1 është Urdhri që kryhet në qoftë se
kushti është i plotësuar, kurse Urdhri2 është Urdhri i cili kryhet nëse kushti nuk
është plotësuar.
Shembull: If A> B then C:=A else C: = B;
Forma e përgjithshme e Urdhrit CASE ose Urdhrit për zgjedhje nga më
shumë opsione
Case Shprehja of
VargVlerash: Urdhri;
VargVlerash: Urdhri;
…..
VargVlerash: Urdhri
Else Urdhri;
End;

Programimi-Delphi
ku shprehja është shprehje e çfarëdo lloji e numërueshme (numerike), përveç vlerës

Longint e cila përdoret gjatë marrjes së vendimit, kurse VargVlerash janë konstanta të
të njëjtit tip si Shprehja. Së pari llogaritur Shprehja, dhe pastaj ekzekutohet Urdhri para
së cilës konstanta e dhënë është e barabartë me vlerën e fituar në Shprehje.
Shembull:
Case Shenja of
‘0’..’9’:Mesazhi.caption:=’Numër’;
‘A’..’Z’,’a’..’z’:Mesazhi.caption:=’Shkronjë’;
‘+’,’-‘,’*’,’/’:Mesazhi.caption:=’Operator’
Else
Mesazhi.caption:=’Tjetër’
End;
Detyra 1: Ngjyros formën:
Figura 9.3.

var a:integer;
begin
a:=strtoint(edit1.text);
if a=1 then form1.Color:=clred;
if a=2 then form1.Color:=clyellow;
if a=3 then form1.Color:=clblue;
end;
procedure TForm1.Button2Click(Sender: Tobject);
begin
form1.Color:=clbtnface;
end;
Detyra 2: Të krijohet program në Delphi për llogaritjen e S dhe P të trekëndëshit

pasi të vërtetohet se ky trekëndësh a mund të ekzistojë. Vlera hyrëse janë krahët e
trekëndëshit.

Programimi-Delphi
3.8. Komponentët për zgjedhje
3.8.1. Kontrolli Check Box
Kontrolli TCheckBox gjendet në faqen Standard. Përdoret gjatë zgjedhjes së

detyrave kur është e nevojshme përfshirja apo përjashtimi i një apo më shumë
opsioneve. Mund të ketë dy gjendje: e përfshirë dhe e përjashtuar.
Shembull: Shënoni sistemet operative që dini t'i përdorni.
Kjo kontroll përdoret për të zgjedhur disa vlera kur mund të zgjidhen më
tepër vlera të ndryshme dhe ku asnjëra nuk e përjashton tjetrën. Secila vlerë mund
të zgjidhet ose jo.
Veti:
Checked – Veti e llojit,,krabëz-bullov,, që përcakton nëse Kontrolli është e zgjedhur. Të
mundshme janë dy gjendje True (e zgjedhur) ose False (e pa zgjedhur).
Detyra 1: Të krijohet një formë në të cilën ka Etiketë, kuti Edit, buton për dalje dhe dy
kontrolle Checkbox në të cilin mund të zgjidhen që teksti i futur është bold apo italic.
Figura 10.3.

Programimi-Delphi
procedure TForm1.CheckBox1Click(Sender: TObject);

begin
If checkBox1.checked then
edit1.Font.style:=[fsbold]
else
edit1.Font.style:=[]
end;
begin
edit1.Font.style:=[fsitalic]
else
end;
Detyra 2: Të krijohet një kod që do të marrë parasysh të gjitha kombinimet e

butonave të përfshirë dhe të përjashtuar.

begin
If (checkBox1.checked) and (checkBox2.checked) then
edit1.Font.style:=[fsbold,fsitalic]
else
else
else
edit1.Font.style:=[ ]
end; {procedura përbëhet nga 3 cikle të degëzuara If}
E njëjta procedurë është edhe për ngjarjen TForm1.CheckBox2Click.

begin
If (checkBox2.checked) and (checkBox1.checked) then
edit1.Font.style:=[fsbold,fsitalic]
else
else
else
end; {procedura përbëhet nga 3 cikle të degëzuara If}

Programimi-Delphi
Detyra 3: Të krijohet aplikacion në të cilin në formë ka 4 kontrolle Checkbox të

cilat përfshijnë pjesët e trupit të njeriut - kokën, trupin, duart, këmbët.
Figura 3.11.
Procedure TForm1.CheckBox1Click(Sender: TObject);

var t,t1:Tcolor;
begin
if checkbox1.Checked then
form1.canvas.Ellipse(200,10,240,50)
else
begin
t:=form1.Canvas.Brush.Color;
t1:=form1.Canvas.Pen.Color;
form1.Canvas.Brush.Color:=form1.color;
form1.canvas.pen.color:=form1.color
form1.canvas.ellipse(200,10,240,50);
form1.Canvas.Brush.Color:=t;
form1.Canvas.Pen.Color:=t1;
end;
end;
var t,t1:tcolor;
begin
form1.canvas.Rectangle(200,50,240,100)
else
begin

Programimi-Delphi
form1.canvas.pen.color:=form.color;
form1.canvas.Rectangle(200,50,240,100);
end;
end;
var t,t1:tcolor;
begin
begin
end
else
begin
form1.canvas.pen.color:=form.color
end;
end;
var t,t1:tcolor;
begin
begin
end
else
begin
form1.canvas.pen.color:=form.color
end;
end;
procedure TForm1.FormPaint(Sender: TObject);

Programimi-Delphi
begin {Ngjarje e cila ndodh para canvas-it të formës, përsëri të vizatohet

gjegjësisht ridimensionohet (zhvendoset ose zmadhohet). D.t.th. kur do të
zmadhohet forma (jo edhe kur zvoglohet), kur krijohet foma etj.}
checkbox1.Checked:=false;
end;
end.
3.8.2. Kontrolli RadioButton
Kontrolli RadioButton përdoret për të zgjedhur njërin nga disa opsione të

mundshme. Zgjedhim një nga disa mundësi të ofruara të butonave RadioButton në
hapësirën e vetëm një objekti. Mund të zgjidhet vetëm një buton RadioButton. Me
përfshirjen e vetëm një radiobutoni të gjithë të tjerët përjashtohen. Ky buton
përdoret në grupe. Lejon përdoruesin të zgjedh vetëm një nga disa opsione, sepse
zgjedhja e njërit prej tyre do të thotë përjashtimin automatik të të gjithë të tjerëve.
Për këtë komponent më të rëndësishme janë vetitë Caption – mbishkrimi dhe
Checked - që nënkupton gjendjen e radiobutonit: aktivizuar ose çaktivizuar.
Shembull: Vendosni gjininë tuaj.
Figura 3.12.
Objektet e llojit RadioButton kanë shumë ngjashmëri me objektet e llojit

Checkbox.
Detyra 1: Të bëhet një formë në të cilën fjala "Mirdita" ose "Tung" shfaqet në disa
gjuhë. Zgjedhja e gjuhëve është bërë nga komponenti RadioButton. Në formë duhet
të vendoset Kontrolli Edit (me sfond të verdhë dhe shkronja blu) për të shfaqur
përshëndetjen e zgjedhur. Mbi këtë fushë në komponentin Etiketa të shfaqet gjuha e
zgjedhur. Zgjedhja e gjuhëve bëhet nga RadioButton-i, kurse përshëndetja të
shkruhet kur të klikohet butoni komandues me mbishkrimin "Përshëndetje."

Programimi-Delphi
Pamja e formës:
Figura 3.13.
Kodi i Programit:
begin
if RadioButton1.Checked then
begin
Edit1.Text:= përshëndetje;
Label2.Caption:= 'Maqedonisht';
end;
begin
Edit1.Text:= 'Hello';
Label2.Caption:= 'Anglisht';
end;
begin
Edit1.Text:= 'Guten Tag';
Label2.Caption:= 'Gjermanisht';
end;
begin
Edit1.Text:= 'Bonjour';
Label2.Caption:= 'Frengjisht';
end;
begin

Programimi-Delphi
Edit1.Text:= 'Aloha';
Label2.Caption:= 'Kroatisht';
end;
begin
Edit1.Text:= 'Përshëndetje';
Label2.Caption:= 'Shqip';
end;
end;

begin
application.Terminate;
end;
end.
Detyra 2: Të bëhet aplikacioni i cili në formë do të ketë pesë radiobutona,

përshkrimet e të cilave janë figurat gjeometrike të mëposhtme (trekëndësh, katror,
drejtkëndësh, romb dhe trapezoid), pesë Etiketa, dy kuti Edit dhe një buton për
Mbarim. Kur ju zgjidhni RadioButtonin e duhur, në kutitë Edit paraqiten formulat
për llogaritjen e S (sipërfaqes) dhe P (perimetrit) të figurave gjeometrike.
Udhëzime: trekëndësh (S = a *h / 2, P = a+b+c, katrori (S = a * a, P = 4 * a),
drejtkëndëshi (S = a* b, P = 2 * (a+b)), rombi (S = a* h, P = 4 * a), trapezoid (S =
(a+b)*h / 2, P = a+b+c+d),
Figura 3.14

Programimi-Delphi
3.8.3 Kontrolli RadioGroup
Radiobutonat mund të vendosen në një kuti të veçantë - RadioGroup.

Qëllimi i ekzistimit të RadioGroup është të lehtësohet grupimi i radiobutonave në
një vend. Futja dhe shpërndarja e radiobutonave rregullohet automatikisht me vetitë
specifike të komponentit RadioGroup.
Vetitë e RadioGroup janë
-Columns - kjo veti përcakton numrin e kolonave në të cilat janë të
vendosur butonat brenda RadioGroup,
-Items – mundëson të definohet, lexohet dhe ndryshohet lista e
përshkrimeve dhe numri i radiobutonave që gjinden në kuadër të RadioGroup,
-ItemIndex - specifikon indeksin e Radiobutonit aktualisht aktiv, brenda
RadioGroup-it. Butoni i pare ka indeks 0. Nëse nuk është zgjedhur asnjë buton,
indeksi është -1.
Detyra 1: Të krijohet aplikacion e cila në kuadër të RadioGroup-it do të
shfaq grupe numrash dhe më pas me zgjedhjen e njërit prej tyre do të shfaq
ndonjërin nga numrat që e karakterizojnë.
Forma ka formën e mëposhtme:
Figura 3.15.
Vendosja e radiobutonave brenda kutisë së përbashkët është arritur nga vetia

Items nga Object Inspector. Me klikim në fushën me tre pika fitohet dritarja e
ardhshme (Figura 3.16) për të futur titujt e butonave:

Programimi-Delphi
Figura 3.16.
Në fund të futje klikohet në butonin OK. Për të qenë butonat në dy kolona,

vetia Columns vendoset në vlerën 2.
Kodi i programit është si më poshtë:
Procedure TForm1.RadioGroup1Click(Sender: TObject);

begin
Case RadioGroup1.itemIndex of
0:Begin
edit1.text:='1,2,3,4,...';
Label1.caption:='Natyror';
end;
1: Begin
edit1.text:='...,-3,-2,-1,0,1,2,3,4,...';
Label1.caption:='Të plotë';
end;
2:Begin
edit1.text:='...,-p/q,...,-1,-1/3,0,1/2,1,...,p/q,...';
Label1.caption:='Racional';
end;
3:Begin
edit1.text:='Nuk mund të shkruhen në formën p/q';
Label1.caption:='Iracional';
end;
4:Begin
edit1.text:='Unioni i shumës së numrave racional dhe iracional';
Label1.caption:='Real';
end;

Programimi-Delphi
5:Begin
edit1.text:='Në formën: -2i,i,3i,...';
Label1.caption:='Imagjinar';
end;
6:Begin
edit1.text:='Në formë a+bi, a-bi';
Label1.caption:='Kompleks';
end;
end; {fundi i Urdhrit Case}
end;
begin
application.terminate;
end;
end.
Detyra 2. Të bëhet aplikacioni i mëposhtëm.
Figura 3.17.

Programimi-Delphi

var
x,y,z:real;
a,b,c,i:integer;
s:string;
begin
Val(edit1.text,x,i);
Val(edit2.text,y,i);
Val(edit1.text,a,i);
Val(edit2.text,b,i);
Case radiogroup1.ItemIndex of
0:Begin
z:=x+y; Str(z:8:3,s);edit3.text:=s;
end;
1:Begin
z:=x-y; Str(z:8:3,s);edit3.text:=s;
end;
2:Begin
z:=x*y; Str(z:8:3,s);edit3.text:=s;
end;
3:Begin
z:=x/y; Str(z:8:3,s);edit3.text:=s;
end;
4:Begin
c:=a div b; Str(c,s);edit3.text:=s;
end;
5: Begin
c:=a mod b; Str(c,s);edit3.text:=s;
end
else
edit3.text:=edit1.text+edit2.text;
end;
end;
end.
Val (edit1.text,numër,code)
Ky funksion konverton një varg (string) në numër. Treguesi i transformimit -

code tregon në suksesin e transformimit. Ai ka vlerën 0 në qoftë se konvertimi ka
përfunduar me sukses. (Numri i 91vv4 nuk do të konvertohet suksesshëm).
Str(numer, string) kryen konvertimin e kundërt të numrit në një varg.

Programimi-Delphi
Detyra 3: Të bëhet një program që kryen konvertimin e gradëve nga Farad në

Celsius dhe anasjelltas. Për zgjedhjen e metodës së konvertimit shfrytëzohet
komponenti RadioGroup. Në formë duhet të vendosen dy komponentë Edit me
sfond të verdhë dhe numra të kuq për futjen e gradëve, si dhe buton komande
Llogarit nëpërmjet të cilit do të aktivizohet llogaritja.
Figura 3.18.
Forma përmban komponentë RadioGroup e cila mund të përmbajnë më

shumë butona nga të cilat vetëm një mund të zgjidhet në një moment. Duke klikuar
vetinë Items në Properties hapet ekrani në vijim:
Figura 3.19
Në editor i fusim titujt e butonave të cilët do t’i shfrytëzojmë.

Pjesa kryesore e kodit të këtij programi është si më poshtë:
procedure TForm1.RadioGroup1Click(Sender: TObject);
begin
case radiogroup1.itemindex of

Programimi-Delphi
0:begin
edit1.setfocus;
edit1.selectall;
end;
1:begin
edit2.setfocus;
edit2.selectall;
end;
end;
end;
var s:string;
n:real;
gr:integer;
begin
case radiogroup1.itemindex of
0:begin
s:=edit1.text;
val(s,n,gr);
if gr<>0 then
begin
ShowMessage('Nuk janë futur mirë Faradët');
edit1.setfocus;
edit1.SelectAll;
end
else
edit2.text:=floattostr((5/9)*(strtofloat(edit1.text)-32));
end;
1:begin
s:=edit2.text;
val(s,n,gr);
if gr<>0 then
begin
ShowMessage('Nuk janë futur mirë Celsiuzët');
edit2.setfocus;
edit2.SelectAll;
end
else
edit1.text:=floattostr(1.8*(strtofloat(edit2.text))+32);
end;
end;
end;
procedure TForm1.FormActivate(Sender: TObject);
begin
radiogroup1.itemindex:=0 {Kushtet fillestare}
end;
end.
Detyra 4: Të bëhet një program për konvertimin e valutave (Euro – denarë dhe
anasjelltas).

Programimi-Delphi
3.8.4. Komponenti ListBox
Paraqet një dritare normale Windows-i për listë. Lista përmban një
listë mundësish që mund t’i zgjedh përdoruesi. Nëse lista përmban më shumë
opsione se sa mund të shfaqen, në kuadrin e listës shfaqen shiritat me ashensor. Kjo
komponentë lejon shfaqjen e përmbajtjes në më shumë kolona duke vendosur
vetinë Columns në numrin e dëshiruar të kolonave. Kur kjo kontroll është në
fokus, përdoruesi shtyp ndonjë shkronjë në tastierë dhe opsioni i parë që fillon me
këtë shkronjë bëhet aktual. Ky funksion lejon gjetjen e shpejtë të mundësive të
kërkuara.
ListBox përdoret më shpesh kur të dhënat që duhet të paraqiten paraqesin
një listë, për shembull, emrat e shumë njerëzve ose disa tituj. Përdoruesi mund të
zgjedh opsione të ndara nga një listë që automatikisht regjistrohet si veti adekuate.
Pastaj vlera e vetisë mund të përdoret në programin për marrjen e vendimeve të
caktuara. Komponenti ListBox është e vendosur në fletën me komponentë
standarde.
Detyra 1: Në formular të vendosen tre etiketa, një ListBox dhe një buton.
Etiketa e tretë ka vetitë e mëposhtme: AutoSize = False; WordWrap = True;
Caption =' '
Vetia e parë largon rregullimin automatik të përshkrimit të etiketës përkundër
madhësisë së tekstit. Funksion i dytë lejon paraqitjen e tekstit në më tepër linja.
Prandaj, madhësinë e etiketës duhet të përcaktojmë me dorë.
Figura 3.20.
Opsionet, gjegjësisht mundësitë, i fusim në listë me ndihmën e vetisë Items nga

Object Inspector.

Programimi-Delphi

begin
ɚpplication.terminate;
end;
procedure TForm1.ListBox1Click(Sender: TObject);
begin
case listbox1.itemindex of
0:begin
Label3.caption:='Viti i parë 4 orë'+#13+
'Viti i dytë 4 orë'+#13+
'Viti i tretë 3 orë'+#13+
'Viti i katërt 3 orë'+#13+
‘Gjithsej 14 orë'
end;
1: Begin
Label3.caption:= 'Viti i parë 3 orë'+#13+
end;
2: Begin
end;
3: Begin
end;
4:Begin
‘Gjithsej 8 orë'
end;
5:Begin
Label3.caption:= 'Viti i tretë 3 orë'+#13+
‘Gjithsej 6 orë'
end;

Programimi-Delphi
6: Begin
‘Gjithsej 6 orë'
end;
7: Begin
‘Gjithsej 6 orë'
end;
8: Begin
‘Gjithsej 9 orë'
end;
9: Begin
‘Gjithsej 6 orë'
end;
10:Begin
Label3.caption:= 'Viti i dytë 4 orë'+#13+
end;
end;
end;
end.
Në kodin e programit vërehen disa pjesë të stringut që nuk janë përdorur deri
tani: # 13. Kjo është shfaqje e imponuar e tekstit në etiketë, pas kësaj shenje teksti
të vazhdojë në rresht të ri. Numri 13 është KOD ASCII i shenjës për kalim në rresht
të ri. Përndryshe, kalimi në një resht të ri realizohet duke shtypur në tastierë Enter,
me të cilën gjenerohet saktësisht kodi komandues numër 13. Pastaj vërehet se
stringjet e gjata shndërrohen në më të shkurtër, pastaj me ndihmën e operatorit #
(thurje-konkavitetit) shfaqen në kuadrin e një komande.
Detyra 2: Konvertimi i numrit dhjetore-decimal në heksadecimal me

komponentë ListBox.
Të shkruhet programi që do të konvertoj numrat e mëposhtëm decimal në
heksadecimal: 12, 14, 123, 512, 1 023, 2 111, 4 780 dhe 27 500. Numrat e dhënë të
shkruhen në komponentë ListBox (ngjyra e sfondit clCream, kurse ngjyra e
numrave blu). Në formë të definohet fushë Edit (sfond i verdhë, me numra blu) për
shfaqjen e numrin heksadecimal të fituar. Mbi këtë fushë në komponentin Label
shkruaj Heksa, kurse mbi komponentin ListBox shkruaj Decimal.

Programimi-Delphi
Figura 3.21.
Forma përdor komponentin e re ListBox që përmban një varg opsionesh dhe

ju lejon të zgjidhni një të tillë. Me vetinë Items hapet dritare String Lista Editor me
ndihmën e të cilës i shkruajmë anëtarët në listë - Figura 3.22..
Figura 3.22.
procedure TForm1.ListBox1Click(Sender: TObject);

Var
i:integer;
begin
i:=ListBox1.ItemIndex;

Programimi-Delphi
Edit1.Text:=IntToHex(StrToInt(ListBox1.Items[i]),2);
end;
end.
Në procedurën ListBoxClick (që thirret duke klikuar në ndonjë numër në
listë) përcaktojmë numrin rendor të numrit të përzgjedhur (i:=
ListBox1.ItemIndex;), dhe pastaj e paraqesim prezantimin e tij heksadecimal në
fushën Edit1. Për këtë arsye përdorim funksionin IntToHex i cili transformon
numrin decimal në heksadecimal, si dhe funksioni StrToInt i cili numrin e zgjedhur
nga ListBox (i cili është i tipit String) e shndërron në një numër decimal. Numri 2
në funksion na tregon se numri heksadecimal do të përmbajë minimum 2 shifra.
function IntToHex(Value: Integer; Digits: Integer): string;
3.8.5 Komponenti ComboBox
ComboBox është komponent; që kombinon mundësitë për futjen e tekstit në

kutinë Edit dhe zgjedhja e njërës nga mundësitë e ofruara të ListBox. Kjo
komponentë përbëhet nga fusha e futjes e ngjashme me kutinë edit e cila djathtas ka
butonin në formë shigjete për poshtë dhe listën e opsioneve të ngjashme me
ListBox, e cila shfaqet kur klikohet shigjeta e vogël poshtë. Përdoruesi mund të
zgjedh një nga vlerat e sugjeruara nga lista, me çka vlera e zgjedhur bartet në
fushën Edit, ose në fushën edit të futet një vlerë krejt e re.
ComboBox më i thjeshtë nuk ka mundësinë e shtimit të vetive të reja, por
vetëm mund të zgjidhen vlerat e ofruara.
Shembull: Në ComboBox të shkruhen fushat e interesimit, dhe pastaj në
etiketën më afër pastaj të shpjegohen.
E shfrytëzojmë vetinë Items, si edhe tek ListBox që të fusim opsionet në
ComboBox: Literatura, Teknika, Muzika, Sporti, Udhëtime, Rekreacion, Pushim
dhe Kozmos.
Figura 3.23.

Programimi-Delphi
procedure TForm1.ComboBox1Change(Sender: TObject);

begin
Case combobox1.ItemIndex of
0:Begin
Label2.caption:=combobox1.items[0];
Label3.caption:='Poezia'+#13+
'Proza'+#13+'Për fëmijë'+#13+'Klasike'+#13+'Moderne';
end;
1:Begin
Label3.caption:='Radio'+#13+
'Video'+#13+'Elektro'+#13+'Avio'+#13+'Komunikacion';
end;
2:Begin
Label3.caption:='Popullore'+#13+
'Argëtuese'+#13+'Për fëmijë'+#13+'Jazz'+#13+'Opera';
end;
3: Begin
Label3.caption:='Atletika'+#13+
'Fudboll'+#13+'Basket'+#13+'Hendboll'+#13+'Volejboll';
end;
4:Begin
Label3.caption:='Me tren'+#13+
'Me autobus'+#13+'Me aeroplan'+#13+'Me anije'+#13+'Në këmbë';
end;
5:Begin
Label3.caption:='Notim'+#13+
'Kujtime'+#13+'Planifikim'+#13+'Gjueti'+#13+'Peshkim';
end;
6:Begin
Label3.caption:='Radio'+#13+
'Televizion'+#13+'Lexim'+#13+'Hulumtim'+#13+'Bisedë';
end;
7:Begin
Label3.caption:='Planeti'+#13+
'Dielli'+#13+'Vëzhgim'+#13+'Udhëtim'+#13+'Fluturim';
end;
end;
end;
begin
end;
end.

Programimi-Delphi
3.9. Komponentët kontejner
Këto komponentë mundësojnë grupimin e komponentëve individuale në

njësi të caktuara. Një lloj komponentë kontejner është RadioGroup.
3.9.1. Komponenti GroupBox
Kjo komponentë nuk ka ndonjë rëndësi të veçantë të pavarur nga

komponentët tjerë. Kuptimi i saj është të jetë një kontejner (kuti) për një grup të
komponentëve që vendosen atje. Ky grupim nuk ka funksionalitet të rëndësishëm,
por duhet në mënyrë vizuale të ndajë disa komponentë nga të tjerat. Kjo
komponentë përdoret kur duhet të punojmë me të dhëna që përbëjnë një tërësi
logjike. Të gjitha komponentët që do të vendosen në GroupBox i përkasin atij.
Detyra 1: Të bëhet një aplikacion që përmban informacionet bazë për

nxënësit dhe notat e tyre. Të llogaritet suksesi mesatar i nxënësit. Në figurë ka dy
njësi logjike të të dhënave: njëra është të dhënat për nxënësin dhe tjera është notat.
Figura 3.24.

begin
end;
Var a,b,i,j:integer;
c:real;
s:string;
begin

Programimi-Delphi
i:=0; b:=0;
if length(Emri.text)>1 then inc(i);
if length(Mbiemri.text)>1 then inc(i);
if length(Qyteti.text)>1 then inc(i);
val(IParë.Text,a,j);
if (j=0) and ((a>1) and (a<6)) then begin b:=b+a;inc(i);end;
val(IDytë.Text,a,j);
val(ITretë.Text,a,j);
val(IKatër.Text,a,j);
val(IPestë.Text,a,j);
val(IGjashtë.Text,a,j);
val(IShtatë.Text,a,j);
val(ITetë.Text,a,j);
val(INëntë.Text,a,j);
val(IDhjetë.Text,a,j);
c:=b/(i-3);
str(c:4:2,s);
if (i=13) and (Suksesi.checked=true) then
Label14.caption:='Suskesi mesatar i nxënësit është:'+s
else Label14.caption:='Nuk janë regjistrime të sakta-Verifikoi!'
end;
end.
Funksioni Length përcakton gjatësinë e argumentit që është e dhënë shenjë.

Funksioni Inc rrit vlerën momentale të argumentit për 1. Me programin është
planifikuar të futen të gjitha të dhënat, përndryshe lëshohet një mesazh adekuat se
kjo nuk është bërë. Nëse një notë është e pavlefshme, gjegjësisht nuk është në mes
të 2 dhe 5, nuk do të llogaritet suksesi mesatar.
3.9.2.Paneli
Paneli është komponent kontejnerët, qëllimi kryesor i së cilës është të

grupojë komponentët tjera në sipërfaqen e saj. Vetitë që i posedon paneli,
mundësojnë që ajo të përdoret për fituar objekte estetike në formë.
3.9.3. Bevel (korniza)
Kjo komponentë lejon vizatimin e vijave, kornizave apo paneleve me efekte

tredimensionale.

Programimi-Delphi
3.10. Module programi
Modulet lejonte vendosjen e tekstit burimor të programit në më shumë

datoteka. Çdo modul mund të përmbajë numër të çfarëdoshëm të nën-programeve
dhe vendoset në një datotekë-file të veçantë.
3.10.1. Forma e përgjithshme e modulit të programit
Titulli (Header) i modulit - titull (Unit)

Interface-ndërfaqja
Pjesët deklarative
Titulli i nën-programit
Implemetation-zbatimi
Pjesët deklarative
Përkufizimi i nën-programeve
Initialization (vlerat fillestare)
urdhra
Finalization
urdhra
end.
Titulli (Header) ka formën e mëposhtme:

Unit EmriIModulit;
EmriIModulit - emri i datotekës në të cilën është moduli.
Pjesa tjetër e modulit të programit ndahet në katër pjesë:
a) Pjesa e lidhjes (interface) - përmban informacione rreth lidhjeve me
modulet tjera
Uses Modul, Modul2...
Jepen emrat e nënprogrameve, gjegjësisht procedurat që do të përdoret në një
modul të dhënë;
b) Pjesa për realizim (implementation) – përmban përkufizime që nuk
duhet të jenë të kapshme për modulet tjera. Në këtë pjesë:
-definohen identifikuesit
-definohen nënprogramet që i përkasin modulit të dhënë
(definohen të gjitha programet titujt e të cilëve janë dhënë në pjesën për lidhje);
c) Pjesa për inicializim (initialization)- i përmban urdhrat ekzekutues me të
cilat vendosen vlerat fillestare të disa variablave nga moduli para se të fillojë
ekzekutimi i programit kryesor.
Kjo pjesë nuk është e domosdoshme mund të mos ekzistojë.
d) Pjesa për finalizim (finalization) – përmban urdhra ekzekutiv dhe
veprimet përfundimtare dhe nuk është i domosdoshëm.
Përfundimi "end" patjetër të ekzistojë.
3.10.2. Fusha e veprimit të identifikuesit
Fusha e veprimit është pjesë e programit burimor në të cilën ai identifikues

mund të përdoret. Fusha e veprimit është nga vendi i futjes së identifikuesit deri në
fund të programit, nën-programit apo modulit.

Programimi-Delphi
Identifikuesit e futur në programin kryesor janë global dhe mund të përdoret

në të gjitha nën-programet e definuar në atë program.
Në nënprograme definohen identifikues të quajtur lokal dhe që vlejnë vetëm
në atë nënprogram.
Loja me button (versioni-I)

Detyrë: Të bëhet loja "Kape butonin,,. Duhet që butoni të lëviz në dritaren e
formës në të katër drejtimet. Kur përdoruesi do të kap butonin, aplikacioni mbaron.
Të futen 55.000 e më poshtë pikë, në varësi se sa zgjat loja.
Hapet aplikacion i ri në të cilin në formë vendoset objekti Button
Programimi i ngjarjeve:
Për të zgjedhur lëvizjen horizontale, ndryshohet vetia Button1.Left, kurse
për lëvizjen vertikale ndryshohet vetia Button1.Top. Lëvizja djathtas dhe poshtë
është arritur duke shtuar ndonjë vlerë në Right dhe Bottom, ndërsa për majtas dhe
lartë merret ndonjë prej Left dhe Top. Kjo praktikisht më thjesht realizohet me
definimin e një konstante të caktuar të cilës i ndërrohet para shenja.
Sa është vlera për të cilën do të zhvendoset butoni, përcaktohet në nivel të
gjithë programit. Kjo vlerë duhet të jetë e kapshme për të gjitha nën-programet,
kështu që është e domosdoshme të deklarohen variablat globale Sx dhe Sy.
Procedura për përgatitjen e programit përbëhet nga katër hapa:
x paraqiten variablat globale Sx, Sy;
x u jepen vlerat fillestare
x programohet zhvendosja dhe refuzimi i ngjarjes Form1.Click;
x përfundimi programohet në ngjarjen Button1.
1. Variablat globale paraqiten në dritaren Unit në pjesën Var
Var
Form1: TForm;
Sx,Sy:Integer;
2. Vlerat fillestar shtohen në ngjarjen FormActivate, ajo ngjarje paraqitet në
momentin kur forma është shfaqur, kurse procedura është si vijon:
procedure TForm1.FormActivate( );
begin
Sx:=3;
Sy:=3;
end;
3. Programimi i zhvendosjes dhe refuzimi vendosen në ngjarjen Form1.Form Click.
Zhvendosja ndodh nëse klikojmë në formë.
procedure TForm1.FormClick( );
Begin
Button1.Left:=Button1.Left+Sx;
Button1.Top:=Button1.Top+Sy;
if(Button1.Left<0)or((Button1.Left+Button1.Width+10)>form1.Width)
then
Sx:=-Sx;
if(Button1.Top<0)or((Button1.Top+Button1.Height+30)>form1.Height)
then
Sy:=-Sy;
end;

Programimi-Delphi
4. Fundi i punës programohet në butonin Button1:

procedure TForm1.Button1Click( );
begin
end;
Loja me butonin (versioni-II)

Në këtë version butoni vetëm që do të lëviz pa pasur nevojë të klikojmë në
dritare. Gjithashtu do të shtohen edhe pikët. Në versionin e mëparshëm shtohet
komponenti Timer dhe dy etiketa.
Vetia:
Timer1.intervalÅ10
Label1.Caption Å Score:(Pikët)
Programimi i ngjarjeve
Që të mundësohet lëvizja e butonit pa klikuar në dritare, do të përdorim objektin
Timer. Kështu fitojmë një cikël kohor i cili do të lëviz butonin. Urdhrat nga ngjarja
Form1.Click nga programi i mëparshëm zhvendosen në ngjarjen Timer1.Timer.
Procedure TForm1.Timer1Timer( )
Begin
Button1.Left:=Button1.Left + sx;
Button1.Top:= Button1.Top +sy;
if(Button1.Left<0)or((Button1.Left+Button1.Width+10)>form1.Width)
then
Sx:=-Sx;
if(Button1.Top<0)or((Button1.Top+Button1.Height+30)>form1.Height)
then
Sy:=-Sy;
Score:=Score – 1;
Label2.Caption:=IntToStr(Score);
End;
Pikët do të reduktohen në çdo 10 [ms] që varet nga Intervali i Timer -it,
kurse në label2 do të tregohen pikët.
Ndryshorja Score duhet të jetë globale dhe të shkruhet në pjesën e paraqitjes
së variablave globale.
Inicializimi i variablës globale score (vlera fillestare) jepet në procedurën
FormActivate.
Nëse lojtari e huq butonin mund të hiqen tre pikë. Kjo programohet në
ngjarjen FormClick.
Procedure Form1.Form Click( )
Begin
Score:=Score – 3;
End;
Mbarimi i lojës mbetet i njëjtë.
Loja me butonin (versioni-III)
Loja mund të përmirësohet, kështu që kur të klikohet në Button1 do të ndalet
llogaritja e pikëve. Atëherë ato mund të shihen. Kjo arrihet duke shtuar një dritare
të re Form2, e cila do të aktivizohet duke klikuar në Form1.Button1. Forma e dytë
duhet të lexojë pikë nga forma e parë.

Programimi-Delphi
Përgatitja e formës
Shtojmë një formë të re. Në të vendosim Label1 me mbishkrimin "Rezultatet e
lojës janë:", Label2 do të tregojë pikët përfundimtare dhe Button1 me mbishkrimin
"Fundi i lojës".
Figura 3.25.
Figura 3.26.
Programimi i ngjarjeve
Në Form1 ndryshojmë ngjarjen Button1Click.
begin
timer1.interval:=0; {ndalja e tajmerit dhe me të edhe heqja e
pikëve}
form1.visible:=false; {fshihet forma e parë}
form2.show; {shfaqet forma e dytë}
end;
var
Form1: TForm1;
sx,sy:integer;
score:integer;
implementation
uses unit2; {shfrytëzohet unit2, njësoj veprohet në Unit2 për
Unit1}
{$R *.DFM}
Shfaqja e pikëve është më e përshtatshme në kohën e shfaqjes së dritares së Form2:

begin

Programimi-Delphi
Label2.caption:=form1.label2.caption;
end;
begin
sx:=3;
sy:=3;
score:=5000;
end;
procedure TForm1.FormClick(Sender: TObject);
begin
score:=score-1;
end;
procedure TForm1.Timer1Timer(Sender: TObject);
begin
button1.left:=button1.left+sx;
button1.top:=button1.top+sy;
if (button1.left<0) or
((button1.left+button1.width+10)>form1.Width) then
sx:=-sx;
if (button1.top<0) or
((button1.top+button1.height+10)>form1.height) then
sy:=-sy;
score:=score-1;
Label2.caption:=inttostr(score);
end;
Ushtrimi: Të bëhet një program kalkulator duke përdorur variablat globale.
3.11. Strukturat ciklike
Ciklet janë struktura kontrolluese që mundësojnë që ekzekutimi i ndonjë

Urdhri të përsëritet.
3.11.1. Urdhri WHILE-DO
Kjo komandë përdoret për realizimin e strukturës përsëritje me dalje në

fillim.
Sintaksa e komandës është:
While kushti do
Urdhri
Domethënia e Urdhrit është:
Derisa (While), është kusht i përmbushur, ekzekuto (do) Urdhrin. Nëse ka
më shumë urdhra (bllok), ata janë të vendosur në mes të BEGIN dhe END.
Për shembull: While kushti do
Begin
Urdhri1;
Urdhri2;

Programimi-Delphi
….
UrdhriN;
End;
Fjalët WHILE dhe DO janë fjalë të rezervuara. Kushti është një shprehje që
llogaritet para çdo ekzekutimi të komandës ose bllokut të komandave. Vlera e
kushtit mund të jetë e true apo false. Nëse është true ekzekutohen komandat pas
DO, por nëse është false nuk ekzekutohen komandat por ato do kapërcehen.
Shembull:
While N<=10 do
Begin
Write(N:3);
N:=N+1;
End;
Mund të ndodhë që urdhrat e ciklit asnjëherë të mos ekzekutohen.
3.11.2. Urdhri REPEAT UNTIL
Kjo komandë është përdorur për strukturën përsëritje me dalje në fund.

Repeat
urdhra
Until kushti;
Përsërit (Repeat) kryerjen e urdhrave deri në (Until) plotësimin e kushtit.
Kushtet mund të jenë shprehje ose relacion dhe mund të ketë vlerën e njërës
nga konstantat logjike True ose False. Pas ekzekutimit të urdhrave pas Repeat,
ndryshohen variablat e kushtit në cikël, me ç`rast mund të ndryshojë edhe vlera e
kushtit në fund të ciklit.
Pas çdo ekzekutimi të urdhrave, pyetet a është plotësuar kushti. Nëse kushti
nuk është plotësuar, përsëritet ekzekutimi i urdhrave, dhe nëse është plotësuar,
vazhdohet me Urdhrin pas Until. Do të thotë, përsëritja mbaron kur kushti do të
marrë vlerën True.
Komandat që ekzekutohen me Repeat nuk vendosen në bllok në mes të
Begin dhe End.
Shembull:
K:=0;
Repeat
K:=K+1;
S:=S+k;
Until K>10;

Programimi-Delphi
3.11.3 Urdhri FOR
3.11.3.1. FOR-TO- DO (zmadhim deri në)
Kjo komandë përdoret për realizimin e strukturave përsëritje me numërimit

të cikleve. Përsëritjet numërohen me numërues të veçantë, për të cilin shtohen vlerat
e fillimit dhe mbarimit të numëruesit.
For ndryshorja:=vlera e fillimit to vlera e fundit do
Urdhri;
Për vlera të ndryshores nga një vlerë e fillimit, duke u rritur për 1 deri në një
vlerë përfundimtare, të ekzekutohet Urdhri në vazhdim.
Shembulli 1:
For I:=1 to 5 do
Writeln(I);
Shembulli2:
For Shkronja:=‘A’ to ‘Z’ do
Write(Shkronja);
x Ndryshorja (në shembujt I dhe Shkronja) paraqet numërues të cikleve dhe
kjo duhet të jetë e tipit linear të rregulluar, dhe nuk duhet të jetë një
ndryshore reale.
x Vlera e fillimit dhe vlera përfundimtare e ndryshores mund të jenë konstantë
ose shprehje, por duhet të jetë e llojit të njëjtë me të.
x Këto vlera nuk duhet të ndryshohen në Urdhrin pas fjalës së rezervuar DO.
x Ndryshores automatikisht i caktohet vlera e ardhshme për ciklin e ardhshëm,
në të cilin ekzekutohet Urdhri.
x Nëse ka më shumë urdhra pas DO, atëherë ata vendosen në bllok mes Begin
dhe End.
Shembull:
For ndryshore:=vlera fillestare to vlera përfundimtare do
Begin
Urdhri;
…
Urdhri;
End;
3.11.3.2. FOR-DOWNTO-DO (zvogëlim deri në)

For ndryshore:=vlera fillestare downto vlera përfundimtare do
Urdhri;
Për vlerat e ndryshores nga një vlerë e fillimit, duke e zvogëluar atë nga 1
deri në një vlerë përfundimtare të ekzekutohet Urdhri në vijim.
Shembull:
For I:=15 downto 5 do
Writeln(I);

Programimi-Delphi
3.12. Komponenti për punë me vargjeve
3.12.1. Komponenti (Memo), është e vendosur në faqen Standard të paletës

së komponentëve. Ajo është e ngjashme me kutinë Edit. Dallimi kryesor është se në
komponentin Memo mund të shfaqet tekst në më shumë reshta.
Figura 3.27.
Kjo kornizë mund të jetë me ose pa ashensor-rrëshqitës. Teksti mund të

rrafshohet në të majtë apo djathtas dhe në qendër.
Veti:
Lines (rreshtat) i llojit Tstrings është veti kryesore e cila përmban tekstin në
komponentin Memo,
Allignement – Rrafshimi në skajin e majtë, djathtas apo në qendër,
Counts - përmban numrin e përgjithshëm të linjave të tekstit të shkruar,
Scrollbars (Rrëshqitësi) - Përcakton se cilët rrëshqitës ekzistojnë (horizontal,
vertikal apo të dy),
Names – veti që na lejon vendosjen dhe leximin e emrave të stringjeve. Çdo string-
varg arrihen duke përdorur indeksin e tij - numri rendor. I pari është me indeks 0, i
dyti me indeks 1 dhe kështu me radhë.
Names[Index:Integer]:String;
Tekst –i gjithë teksti nga rreshtat së bashku,
Values – mer ose vendos vlerë të stringut në varg,
Function Add(const:string):Integer; - Shton string në fund të listës,
Shembulli 1: Çka bën procedura e mëposhtme?

Procedure Tform1.button1click();
Var I: integer;
Begin
Memo1.lines.clear;
For i:=0 to 5 do
Memo1.lines.add(‘ky është kapërcim ‘+ inttostr(i));
Memo1.lines.add(‘ ‘);
End;

Programimi-Delphi
Shembulli 2: T bëhet program, për të përcaktuar anëtarin më të madh në varg.
Figura 3.28
var
Form1: TForm1;
a:array[1..30] of integer;
implementation
{$R *.DFM}

Var max,i,j,n,gr: integer;
s: string;
begin
For i:=0 To 9 Do
Begin
s:=Memo1.Lines[i];
Val(s,n,gr); j:=i+1;
If gr = 0 Then a[j]:=StrToInt(Memo1.Lines[i]);
End;
max:=a[1];
For i:=2 To 10 Do
If a[i] > max Then max:=a[i];
Edit1.Text:=IntToStr(max);
end;
Var i: integer;
begin
memo1.lines.clear;
For i:=1 To 100 Do
a[i]:=0;
edit1.text:=' ';
memo1.setfocus;
end;
end.

Programimi-Delphi
Metoda II:
var
max,i,j,n,gr:integer;
s:string;
begin
max:=0;
for i:=1 to 10 do
a[ i ]:=0;
for i:=0 to 9 do
begin
s:=memo1.lines[ i ];
val(s,n,gr);
j:=i+1;
if gr=0 then a[ j ]:=strtoint(memo1.lines[ i ]);
end;
max:=a [ 1 ];
for i:=1 to 10 do
if a[ i ] > max then max:=a[ i ];
edit1.text:= inttostr(max);
end;
Shembulli 3: Të bëhet një program për rregullimin e të dhënave në varg:
Figura 3.29.

Programimi-Delphi
…
var
Form1: TForm1;
a:array[1..30] of integer; {globalna varijabla}
implementation
{$R *.DFM}

var
i,j,n,gr,pom:integer;
s:string;
begin
for i:=0 to 9 do
begin
s:=memo1.lines[i];
val(s,n,gr);
j:=i+1;
if gr=0 then a[j]:=strtoint(memo1.lines[i]);
end;
for i:=1 to 9 do
for j:=i+1 to 10 do
if a[i]>a[j] then
begin
pom:=a[i];
a[i]:=a[j];
a[j]:= pom;
end;
for i:=0 to 9 do
memo2.lines.add(inttostr(a[i+1]));
end;
var i:integer;
begin
for i:=1 to 10 do
a[i]:=0;
end;
Duhet të vendosen 10 të dhëna dhe të futet e dhënë në rreshtin e parë.
Shembull 4: Çfarë bën programi në vazhdim?

begin
if memo1.seltext<>' ' then
begin
memo2.lines.text:=memo1.lines.text;
memo2.Lines.savetofile('tekst.txt');
end
else
memo1.Lines.savetofile('tekst.txt'); end;

Programimi-Delphi
Detyrë - Projekti: Hap formë të re dhe në të shto një komponentë Memo

ngjyra e së cilës është clInfoBk me përfshirjen e ashensorit vertikale. Djathtas prej
saj shto katër komponentë RadioButton me titujt e mëposhtëm: Numri i shfaqjes së
shkronjës a, Numri i shfaqjes së shkronjës i, Numri i zanoreve dhe numri i
përgjithshëm i shkronjave (Font Ms Sans Serif, Bold, me madhësi 10 dhe ngjyra
Green), me çrast e para është poshtëshënuar. Në formë vendos buton me titull
Llogarit. Vendos fushë Edit1 (clYellow, Font Ms Sans Serif, Bold, madhësia 12
dhe ngjyra Navy) me mbishkrim Rezultati. Në formë vendos buton me përshkrimin
Ruaj. Duke shtypur këtë buton duhet të rruhet përmbajtja e kornizës Memo në
datotekën Ushtrimi.txt.
Pasi të thirret programi, duhet të futen 4-5 rreshta me tekst latin në kornizën
Memo, dhe pastaj të thirren llogaritjet e shtuara dhe të plotësohet Tabela I.
Selekto dhe fshije tekstin e futur në kornizën Memo, dhe vendos këtë: në
fjalinë e parë - emrin dhe mbiemri juaj, në të dytën data dhe vendi i lindjes, në të
tretën rruga dhe vendi i banimit, në të katërtën numri i telefonit tuaj fiks dhe celular
dhe në të pestën hobin tuaj, dhe pastaj klikoni butonin Rruaj. Hape datotekën
Ushtrimi.txt dhe verifiko nëse përmbajtja e dhënë është ruajtur në të.
Përshkrimi i zgjidhjes:
Figura 3.30.
1. E rruajmë projektin tonë me Urdhrin Save Project As në folderin

Delphi_ushtrime në diskun C duke i dhënë emrin programit Prog_fjalia.
2. Me butonin Llogarit thirret proceduara në të cilën bëhen llogaritjet,
varësisht cili RadioButton është zgjedhur. Llogaritja e numrit të paraqitjes
së shkronjës a është si më poshtë:
If RadioButton1.Checked Then
Begin
For i:=0 To Memo1.Lines.Count-1 Do
Begin
recen:=Memo1.Lines[i];
For j:=1 To Length(recen) Do

Programimi-Delphi
If (recen[j]='a') or (recen[j]='A') Then Nr:=Nr+1;

End;
End;
Është e qartë se marrim një nga një fjalitë nga komponenti Memo me ndihmën e
ciklit të parë For. Pastaj fjalinë e zgjedhur ia ndajmë stringut
recen(recen:=Memo1.Lines[i]).
Në ciklin e ardhshëm For marrim një nga një karakteret nga fjalia e
zgjedhur dhe hulumtojmë nëse ajo është e njëjtë me shkronjën A të vogël ose të
madhe. Nëse është e njëjtë, atëherë numëruesin Nr e zmadhojmë për 1.
Gjatë llogaritjes së numrit të përgjithshëm të shkronjave në tekstin e dhënë,
shfrytëzohet procedura e mëposhtme:
Shkronjat e mëdha kanë vlera ASCII mes 65 dhe 90, kurse të voglat nga 97
deri në 122, kështu që nëse një vlerë ASCII e shkronjës është në fushën e dhënë
atëherë e zmadhojmë vlerën e numëruesit.
3. Duke shtypur butonin Rruaj thirret procedura Save në të cilën gjendet
Urdhri:
Memo1.Lines.SaveToFile('Ushtrimi1.txt');
Përmes së cilës rruajmë tekstin e futur në komponentin Memo në datotekën
Ushtrimi.txt.
Tabela I
Numri i paraqitjes së shkronjës a
Numri i paraqitjes së shkronjës i
Numri i zanoreve
Numri total i shkronjave
PROGRAMI:
program Prog1;
uses
. var
Form1: TForm1;
br:integer;
implementation
{$R *.DFM}
var i,j:integer;
recen:string;
begin
Begin
Begin
If (recen[j]='a') or (recen[j]='A') Then Nr:=Nr+1;
End;
edit1.text:=inttostr(br);
Nr:=0;

Programimi-Delphi
End;
Begin
Begin
If (recen[j]='i') or (recen[j]='I') Then Nr:=Nr+1;
End;
Nr:=0;
End;
Begin
Begin
If (recen[j]='a') or (recen[j]='A')or (recen[j]='i') or
(recen[j]='I') or (recen[j]='e') or (recen[j]='E')or (recen[j]='o')
or (recen[j]='O')or (recen[j]='u') or (recen[j]='U')
Then Nr:=Nr+1;
End;
Nr:=0;
End;
Begin
Begin
If ((65<=ord(recen[j]))and (ord(recen[j])<90)) or
((97<=ord(recen[j]))and (ord(recen[j])<122)) Then
Nr:=Nr+1;
End;
Nr:=0;
End;
end;
begin
Nr:=0;
end;
begin
Memo1.Lines.SaveToFile('Ushtrimi1.txt');
end;
end.

Programimi-Delphi
3.12.2. Komponenti StringGrid
Kjo komponentë lejon që të dhënat të shfaqet në formën e një tabele. Kjo

ndodhet në kartelën e dytë (Additional). Tabela është e organizuar në kolona dhe
rreshta. Në kryqëzimin e kolonave dhe rreshtave ndodhen celulat. Përmbajtja e
celulave është e përcaktuar si e dhënë shenjë, por çdo celule, përveç tekstit, mund
t’i bashkëngjitet çdo objekt që ekziston në Delphi.
Komponenti StringGrid është e ngjashme me tabelën në Excel. Numri i
kolonave dhe rreshtave është dhënë nga vetitë ColCount dhe RowCount. Celulat në
rreshtin e parë dhe kolona e parë janë me një ngjyrë të ndryshme - gri, që do të
thotë se ata janë të fiksuara. Fiksimi arrihet me shtimin e vlerave në FixedRows dhe
FixedCols (dy veçoritë kanë vlerën 1). Në celula qasemi në program duke u bazuar
në indeksin që përcakton kolonën dhe rreshtin, njëlloj si në fushat dy-dimensionale.
Celula e parë është [0,0].
Detyra 1: Të bëhet aplikacion për tabelën e shumëzimit të numrave një

shifror.
Figura 3.31.

Programimi-Delphi
Procedure Tform1.Button1Click();
Var
I,j,n:Integer;
S,t:String;
Begin
Tabela.Cells[0,0]:=’Shumëzimi’;
For i:=1 to 9 do
Begin
Str(i,s);
Tabela.Cells[0,i]:=s;
Tabela.Cells[i,0]:=s;
End;
For i:=1 to 9 do
For j:=1 to 9 do
Begin
N:=i*j;
Str(n,t);
Tabela.cells[i,j]:=t;
End;
End;
End.
Detyra 2: Të bëhet aplikacion i cili mundëson futjen e n numrave dhe shfaqjen e

tyre në renditje të kundërt.
Zgjidhja: Së pari do të sigurojmë informacion për numrin e numrave që do të

futen. Pastaj duke përdorur komponentë StringGrid do të fusim numrat, dhe pastaj
do të shfaqen në kontrollin Memo. Forma është paraqitur në figurën 3.32.
Figura 3.32.

Programimi-Delphi
Në formë janë vendosur nëntë komponentë. Ata janë të grupuara në bazë të

qëllimit të të dhënave. Për komponentin StringGrid duhet vendosur vetitë e
mëposhtme: ColCount=1, FixedCols=0, FixedRows=1, RowCount=5, With=100
dhe Name=vargu
Kodi programor përmes të cilit zgjidhet detyra është si më poshtë:

begin
end;
procedure TForm1.varguSelectCell(Sender: TObject; ACol, ARow:
Integer;
var CanSelect: (Boolean);
var i,n:integer;
begin
val(Numer.text,n,i);
vargu.RowCount:=n+1;
end;
var i,j,n,m:integer;
begin
val(Numer.text,n,j);
m1.lines.clear;
For i:=n downto 0 do
m1.lines.add(vargu.cells[0,i]);
end;
end.
Që të mund të futen të dhënat në fushat e komponentit StringGrid, është e

nevojshme që në vetinë Options, opsioni goEditing të vendoset në vlerën True.
Komponentit StringGrid i ndajmë ngjarje OnSelectCell e cila aktivizohet kur
përdoruesi përpiqet të selektojë një celulë. Kjo ngjarje na lejon që në celulat e
tabelës me një kolonë të fusim vlerat e numrave të dëshiruar.
Me butonin Krijo aktivizojmë ngjarjen OnClick, e cila lejon në fushën
Memo të tregohen numrat e futur në renditje të kundërt. Rreshti "m1.lines.clear;"
mundëson fshirjen e përmbajtjes së komponentit Memo, ndërsa rreshti „
m1.lines.add(vargu.cells[0,i]); “, lejon shfaqjen e numrave të futur në tabelë në
renditje të kundërt.
Me ekzekutimin e programit fitohet dritarja e figurës 3.33.

Programimi-Delphi
Figura 3.33.
Detyra 3: Në shembullin e mëparshëm të bëhen korrigjime, ashtu që të llogaritet

dhe të shfaqet shuma e numrave të futur.
3.13. Aplikacionet multimediale
Me zhvillimin e teknologjisë kompjuterike, janë krijuar mundësi të

përdorimit të grafikës dhe zërit brenda programit. Delphi lejon programimin e
aplikimeve multimediale. Për shfaqjen e grafikës në Delphi, përdoren komponentët
në vijim:
Komponenti Shape. Gjendet në kartelën Additional dhe përdoret për të
futur forma të thjeshta në formë.
Veti të rëndësishme janë Brush dhe Pen. Brush e përcakton ngjyrën e furçës ose
modelin e brendisë. Pen përcakton stilin dhe ngjyrën e vijës me të cilën vizatohet.
Mund të vizatoni kënddrejtë, elipsa, kuadrate....
Komponenti Image përdoret për të shfaqur një imazh në formë. Ajo
ndodhet në kartelën Additional. Në Delphi mbështeten këto formate të mëposhtme
të imazheve: jpg, jpeg, bmp, ico,emf, wmf. Nëse kemi një imazh nga një format
tjetër, ai duhet të konvertohet në një format që është i njohur për Delphi-n. Nëse
vetia Autosize është e vendosur në True, atëherë komponenti Image do të përshtatet
në madhësinë e imazhit. Ndërsa, nëse vetia Stretch është vendosur true, atëherë
madhësia e imazhit i përshtatet madhësisë së komponentit. Nëse të dy vetitë janë të
vendosur në False, imazhi do të zë vetëm një pjesë nga komponenti ose nuk do të
shihet e tëra në komponentë, në varësi nga madhësia e saj. Cili imazhi do të
vendoset, varet nga vetia Picture me të cilën paraqitet Picture editor, përmes të cilës
futet imazhi me butonin Load.

Programimi-Delphi
Detyra 1: Të bëhet aplikacion i cili duke u bazuar në materialin grafik

ekzistues do të tregojë pjesët e trupit të njeriut - një enciklopedi e vogël. Forma
është paraqitur në figurën 3.34.
Figura 3.34.
Në formë ka dy panele, ListBox, imazh dhe dy butona komandues.

Shfrytëzuesi zgjedh një opsion nga lista, klikon butonin Shfaq dhe imazhi i duhur
shfaqet në pjesën e parashikuar të formës.
begin
end;
begin
image1.visible:=false;
case listbox1.itemindex of
0:begin
image1.visible:=true;
image1.picture.loadfromfile('c:\program files\borland\'+
'\delphi5\projects\foto\sl1.bmp'); {rruga deri te folderi foto}
end;
end;
end;
end.
Në kodin e programit përdoret vetia Visibile e komponentit Image për të
mundësuar ose pamundësuar shfaqjen e imazhit.
Është e mundur një zgjidhje e dytë e detyrës, shfaqja e imazhit do të shkojë
vetëm duke klikuar nëpër listën e opsioneve.

Programimi-Delphi
Detyra 2: Të bëhet aplikacion që do të nxisë funksionimin e aparatit të fatit.

Puna e këtij aparati është si vijon: pas çdo klikimi në butonin Luaj! Tregohen tre
numra të rastit nga intervali nga 0 në 9. Nëse një nga këto numra është 5, lojtari
fiton para. Simulimi i fitimit realizohet me paraqitjen e parave në vend të
komponentit së imazhit. Forma është paraqitur në figurën 3.35.
Figura 3.35.

var r,p,q:Integer;
s:String;
begin
Image1.visible:=false;
r:=random(10);
str(r,s);
Label1.caption:=s;
p:=random(10);
str(p,s);
Label2.caption:=s;
q:=random(10);
str(q,s);
Label3.caption:=s;
If (p=5) or (r=5) or (q=5) then
begin
image1.visible:=true;
Beep;
Label4.caption:='FITOVE....!!!!';

Programimi-Delphi
end;
end;
begin
end;
Funksioni Random(10) gjeneron numër rasti në intervalin nga 0 deri në 9.

Në kod, imazhi në fillim është i padukshëm. Ai do të jetë i dukshëm, nëse vetëm
njëri nga numrat e gjeneruar është 5.
Gjatë çdo startimi të ri të aplikacionit fitohen seri të njëjta të numrave. Që të
tejkalohet kjo, futet funksioni Ramdomize i cili e shfrytëzon orën e sistemin të
kompjuterit për të gjeneruar numër rasti të vërtetë. Ky funksion vendoset në
ngjarjen FormActivate dhe do të ekzekutohet gjatë çdo startimi të aplikacionit.
begin
randomize;
image1.visible:=false;
end;
Përveç kësaj mënyrë të shfaqjes së imazheve, Delphi lejon shfaqjen e
pikturave, vizatimin e pikturave dhe futjen e tekstit kudo në dritaren e ekzekutimit
të programit. Për këtë qëllim përdoret objekt i veçantë, ekran për vizatim Canvas.
Kjo strukturë përdoret për vizatim në sipërfaqen punuese të formës.
Objekti Canvas përdoret, por së pari me ndihmën e vetive përcaktohen
parametrat për vizatim, dhe pastaj vizatohet. Veti të rëndësishme për vizatim janë
lloji dhe trashësia e vijës, forma e figurës dhe mbushja me ngjyra, pamja e fontit
etj. Parametra të domosdoshëm janë koordinatat e vizatimit, madhësia e tij, ngjyra
etj.
Objektet që më shpesh përdoren gjatë vizatimit dhe shkrimit në Canvas janë:
- stilolapsi, lapsi, furça dhe fontet.
Stilolapsi (pen) përcakton mënyrën e shfaqjes së vijës gjatë vizatimit.
Stilolapsit mund t’i përcaktohen karakteristikat e mëposhtme: ngjyra, stili dhe
gjerësia (trashësia).
Furça (brush) lejon mbushjen e zonës së vizatuar. Ajo mund të jetë mbushje
me ngjyra, por edhe sipërfaqe e vijëzuar-patern.
Ekzistojnë shumë metoda për vizatim në ekranin (Canvas). Metodat që më
shpesh përdoren janë si më poshtë:
1. Ellipse, e cila vizaton një elips me stilolapsin e zgjedhur momentalisht dhe e
mbushur me furçën e zgjedhur momentalisht
2. LineTo (x, y), e cila vizaton një vijë nga pozicioni aktual në pozitën e
përcaktuar nga koordinatat x dhe y.
3. MoveTo, e cila përcakton pozitën momentale për të vizatuar më tej.
4. Polygon, e cila vizaton poligonin në koordinata të dhëna.
5. PolyLine, vizaton vijë nëpërmjet në një varg pikash të dhëna.
6. Rectangle, vizaton një drejtkëndësh.
7. RoundRect, vizatoni një drejtkëndësh me kulme jo të mprehta.

Programimi-Delphi
Detyra 3: Të vizatohen dy vija në sipërfaqen punuese të aplikacionit, një e kuqe

e plotë dhe një blu e ndërprerë. Në formë duhet të vendosim buton dhe të
programojmë ngjarjen e tij OnClick. Ngjarjes së specifikuar i shoqërojmë kodin
programor në vijim:
begin
Canvas.pen.color:=clred;
canvas.MoveTo(20,20);
canvas.lineto(320,20);
canvas.pen.color:=clblue;
canvas.pen.style:=psdash;
canvas.moveto(20,50);
canvas.LineTo(320,50)
end;
begin
end;
end.
Nga kodi mund të konkludohet se ekrani për vizatim është sipërfaqe e
koordinatave, në të cilën në çdo pikë mund të arrihen duke dhënë koordinatat e saj.
Origjina e koordinatave është vendosur në cepin e sipërm të majtë të dritares.
Me ekzekutimin e programit fitohet dritare si në figurën 3.36.
Figura 3.36.
Detyra 4: Të formohet aplikacion i cili në canvas- do të vizatojë një trekëndësh,

drejtkëndësh dhe rreth. Në formë vendosim katër butona komande me mbishkrim
Trekëndësh, Drejtkëndësh, Rreth dhe Fund.
begin
canvas.MoveTo(20,250);
canvas.LineTo(20,250)
end;

Programimi-Delphi

begin
end;
begin
canvas.rectangle(160,250,260,100);
end;
begin
canvas.ellipse(480,50,280,250);
end;
begin
canvas.Pen.color:=clred;
canvas.brush.color:=claqua;
end;
end.
Forma do të ketë pamjen e paraqitur në figurën 3.37.
Figura 3.37.
Me metodën „canvas.rectangle(160,250,260,100);“ jepen argumentet të cilat

kanë kuptimet vijuese: (160,250) është koordinata e kulmit të majtë të poshtëm,
kurse (260,100) është koordinata e kulmit të djathtë të sipërm e drejtkëndëshit.
Koordinatat e dhëna në metodën për vizatim të elipsës, përfaqësojnë kulmet e
drejtkëndëshit në të cilin është vizatuar elipsa.
Përveç vizatim të figurave në canvas, mund të paraqitet (vizatohet) tekst me
ndihmën e metodës TextOut dhe TextRect.
Metoda e parë lejon paraqitjen e tekstit në një pozicion të përcaktuar nga
koordinata e këndit të majtë të sipërm nga i cili tregohet teksti.

Programimi-Delphi
Nëse është e nevojshme, teksti që tregohet të jetë me një gjatësi të caktuar

dhe në kuadër të një fushe drejtkëndëshe, atëherë përdoret metoda TextRect.
Kodi i programit për zbatimin praktik të këtyre dy komandave është si më
poshtë:

begin
canvas.textOut(80,100,'Programimi në Delphi');
end;
begin
end;
begin
canvas.textrect(rect(50,50,150,70),50,50,' Programimi në
Delphi');
end;
Forma, pasi të aktivizohet aplikacioni, ka pamjen si në figurën 3.38.
Figura 3.38.
3.13.1. Komponenti MediaPlayer për aplikacione multimediale të thjeshta

ndodhet në faqe System. Kjo komponentë mund të ekzekutojë datoteka zëri
dhe video datoteka, nëse posedojmë datoteka të formatit të cilat i njeh Delphi. Nëse
gjatë startimit të një datoteke, Delphi dërgon mesazh që nuk e njeh këtë format,
është e nevojshme të gjendet driver i duhur. Me vendosjen e kësaj komponentë në
formë fitohet formë si në figurën 3.39.

Programimi-Delphi
Figura 3.39.
Në figurë shohim se kjo komponentë përmban butona për nisje, pauzë,

ndërprerje, kalim të shpejtë përpara, kërcim përpara dhe prapa, regjistrimin dhe
asgjësimin e mediumit. Kështu, në panelin kontrollues ndodhet gjithçka që gjendet
në shumicën e kasetofonëve.
Përdorimi i komponentit MediaPlayer është shumë i thjeshtë. Pasi të keni
vendosur komponentin në formë, duhet vetëm të vendoset vetia e saj FileName në
vlerën që është emër i datotekës përkatëse multimediale. Pastaj fillojmë zbatimin e
aplikacionit dhe klikojmë butonin Play. Nëse butoni i përmendur nuk është në
dispozicion, do të thotë se vetia e cila përcakton nëse pajisja është e hapur pas
krijimit, është vendosur në vlerën False. Në këtë rast, vetia AutoOpen duhet të
vendoset në vlerën true. Pas klikimit mbi butonin Play, duhet të paraqitet zë i
ruajtur në datotekën emri i së cilës është dhënë në vetinë FieldName.
Komponenti MediaPlayer ka të ndërtuar një mekanizëm me ndihmën e të
cilit automatikisht zbulohet nëse bëhet fjalë për datotekë audio ose video.
Që të mund në mënyrë programore të menaxhohet me komponentin
MediaPlayer, duhet të njihemi me vetitë themelore të saj:
1. AutoOpen përcakton nëse pajisja do jetë e hapur pas krijimit të komponentit
MediaPlayer. Vlera fillestare është False.
2. AutoRewind lejon vendosjen e treguesit në pozicionin fillestar të datotekës
kur datoteka do të realizohet deri në fund.
3. DeviceType mundëson përshtatjen automatike të pajisjes në llojin e
datotekës. Për të lehtësuar këtë, vlera e kësaj vetie duhet të jetë
dtAutoSelect.
4. Display është vetie e rëndësishme për pajisjet video. Ajo mundëson shfaqjen
e videodatotekës në komponentë e cila mund të pranoj raporte (shfaq tekste).
5. DisplayRect është veti që është e lidhur drejtpërdrejt me të mëparshmen dhe
lejon që madhësia e paraqitjes së videodatotekës të rregullohet me
madhësinë e komponentit në të cilën shfaqet. Vlera e vetisë është vendosur
në mënyrë të programuar.
6. VisibleButtons përcakton cilët butonat në MediaPlayer do të jenë aktiv.
Nënkuptohet që të gjithë butonat do të jenë aktiv. Vlera e këtyre vetive
mund të vendoset në mënyrë programore ose përmes Object Inspector.
7. Wait përcakton nëse kontrolli kthehet në aplikacion në moment ose pas
mbarimit të datotekës muzikore.
Metodat më të rëndësishme të përdorura nga komponenti MediaPlayer janë:

1. Close është metodë që mbyll pajisjen.

Programimi-Delphi
2. Eject është metodë, e cila largon (nxjerr) mediumin nëse është e

mundur.
3. Next metoda kalon në fillimin e shiritit të ardhshëm, nëse pajisja
mbështet shirita.
4. Open është metodë që hap pajisjen. Kjo metodë përdoret në qoftë se
vetia AutoOpen është vendosur në False.
5. Pause është metodë që ndalon përkohësisht ekzekutimin e datotekës.
6. Play është metodë që aktivizon ekzekutimin e datotekës.
7. Stop është metodë që ndalon aktivitetin aktual.
Në disa raste është e dëshirueshme që komponenti MediaPlayer të jetë e
padukshëm gjatë periudhës së ekzekutimit të datotekës zanore. Në këtë
rast, me komponentin menaxhojmë përmes kodit të programit.
Shembulli 1: Të krijohet aplikacion i ri, forma e të cilit duket si në figurën 3.40.
Figura 3:40.
Kodi i programit që lejon të fshehim komponentin MediaPlayer dhe

kontrollin e saj programor është si më poshtë:

begin
muzika.visible:=false;
muzika.filename:='D:\serenata_mp3\muzika.MP3';
muzika.open;
muzika.play;
end;
begin
muzika.stop;
muzika.visible:=true;
end;
begin
end;
end.

Programimi-Delphi
Në figurën 3.41. është treguar dritarja e punës e aplikacionit në kohën e punës

së datotekës muzikore, ekzekutimi i së cilës mundet të ndalet përkohësisht ose
plotësisht të ndërpritet.
Figura 3.41.
Përdorimi i datotekave audio nga CD-disqet është shumë i thjeshtë, kur ne

përdorim MediaPlayer-in. Është e nevojshme të ndryshohet vetia DeviceType në
CDAudio, dhe pastaj të klikohet në butonin Play.
Përdorimi i komponentit MediaPlayer për shfaqjen e datotekave video, shpie
në vendosjen e vetisë FileName nga ObjectInspector në vlerë, që paraqet rrugën
dhe emrin e datotekës video dhe klikim në butoni Play.
Është e mundur që shfaqja e datotekës video të orientohet në një komponentë
tjetër, për shembull, panel. Kjo arrihet duke vendosur vetinë Display të
komponentit MediaPlayer në vlerën me emrin e komponentit (p.sh. Panel1). Nëse
gjithë fotografia e datotekës video nuk mund të shfaqet në komponentin e
përzgjedhur do të shfaqet vetëm një pjesë e saj. Me vendosjen e vetisë DisplayRect,
fotografia mund të tkurret ose të zgjerohet, kështu që e gjitha do të jetë në
komponentin e zgjedhur. Kjo mund të arrihet në mënyrë programore.
Shembull 2: Të bëhet aplikacion i cili do të mundësojë shfaqjen e
videodatotekës në komponentin Panel. Me nisjen e aplikacionit, fitohet dritare
punuese në të cilën në komponentin Paneli ekzekutohet videodatoteka. Vetinë
Name të komponentit MediaPlayer e ndryshojmë në Fotografi dhe e programojmë
ngjarjen OnClick të komponentit MediaPlayer.
Figura 3.42.
procedure TForm1.FotografiClick(Sender: TObject; Button: TMPBtnType;
var DoDefault: Boolean);
begin
fotografi.displayrect:=panel1.clientrect;
end;

Programimi-Delphi
KAPITULLI 3
(SHKURT)
Kodi zbatohet si rezultat i një ngjarjeje. Nëse klikojmë në buton,

automatikisht do të gjenerohet ngjarja (event) OnClick që automatikisht e
ekzekuton kodin e programit që është i lidhur me ngjarjen.
Bashkëngjitja e kodit butonit të komandës Shfaq:
x Mënyra I
o Selektohet butoni
o Nga kartela ngjarje (events->Oobject Inspector) zgjidhet ngjarja
OnClick
o Me klik të dyfishtë në fushën djathtas nga ngjarja e zgjedhur, hapet
procedura në të cilën e shkruajmë kodin e programit.
x Mënyra II
o Double-click në butonin komandues Shfaq. Në dritaren e kodit
automatikisht gjenerohet emrin i procedurës dhe emri i objektit, në të cilin
është aktiv ngjarja që do të shkaktoj veprimin e dhënë.
Elemente të gjuhës:
Një grup shenjash, komente, identifikues, fjalë zyrtare dhe direktiva
standarde
Të dhëna:
Numra të plotë, realë, logjik, shenja, konstanta, variabla,...
Operatorët dhe shprehjet

operatorët aritmetike
operatorët relacionale
logjik
Urdhri për dhënien e vlerës ": ="
Projektimi i aplikacioneve me struktura lineare:
Programet e kësaj strukture të shkruara në Pascal përmbajnë urdhra për futjen e të

dhënave, për përpunimin e të dhënave dhe për shfaqjen e rezultateve.
Konvertimi i të dhënave:
Function StrToInt (const s:string):Integer;
Function StrToFloat(const s:string):Extended;
Function IntToStr(value:Integer):String;
Function FloatToStr(value:Extended):String;
function TimeToStr(Time: TDateTime): string;
function DateToStr(Date: TDateTime): string;

Programimi-Delphi
Strukturat e degëzuara:
Forma e përgjithshme e Urdhrit IF ose për zgjedhje nga dy opsione
Forma e përgjithshme e Urdhrit CASE ose Urdhrit për zgjedhje nga më shumë
opsione Komponentë për zgjedhje:
Kontrolli CheckBox. Kontrolli TCheckBox gjendet në faqen Standard.
Përdoret gjatë zgjidhjes së detyrave, kur është e nevojshme përfshirja apo
përjashtimi i një apo më shumë opsioneve.
Kontrolli RadioButton. Kontrolli RadioButton përdoret për të zgjedhur një
nga disa opsionet e mundshme.
Kontrolli Radiogroup. Radio butonat mund të vendosen në një kuti të
veçantë - RadioGroup. Qëllimi i ekzistencës së RadioGroup është që të
thjeshtësohet grupimi i radio butonave në një vend.
Komponenti ListBox. Paraqet një dritare liste normale në Windows. Lista
përmban një listë mundësish të cilat përdoruesi mund t’i zgjedh.
Komponenti ComboBox. ComboBox është një komponent që kombinon
mundësitë për futjen e tekstit në kutinë Edit dhe zgjedhjen e njërës prej mundësive
të ofruara në ListBox. Komponentët kontejnerë
Komponenti GroupBox. Kjo komponentë nuk ka ndonjë kuptim të veçantë
të pavarur nga komponentët tjerë. Rëndësia e saj është të jetë një kontejner (kuti)
për një grup të komponentëve që janë vendosur atje.
Panel
Bevel (korniza)
Module programesh
Forma e përgjithshme e modulit të programit

Titulli (Header) i modulit - titull (Unit)
Interface-ndërfaqja
Pjesët deklarative
Titulli i nën-programit
Implemetation-zbatimi
Pjesët deklarative
Përkufizimi i nën-programeve
Initialization (vlerat fillestare)
urdhra
Finalization
urdhra
end.
Fusha e veprimit të identifikuesit. Fusha e veprimit të identifikuesit është pjesë e

programit burimor në të cilën ai identifikues mund të përdoret.
Strukturat ciklike
WHILE-DO Urdhri
REPEAT UNTIL Urdhri
FOR Urdhri
FOR-TO-DO (Zmadho deri në)
FOR-DOWNTO-DO (Zvogëlo deri në)

Programimi-Delphi
Komponentët për punë me vargje

Komponenti (Memo). Komponenti (Memo), është e vendosur në fletën
Standard në paletën e komponentëve. Ajo është e ngjashme me Editbox. Dallimi
kryesor është në atë se komponenti memo mund të shfaq tekstin në rreshta të
shumtë.
Komponenti StringGrid. Kjo komponentë lejon të dhëna të shfaqet në
formën e një tabele.
Me zhvillimin e teknologjisë kompjuterike, janë krijuar mundësitë e
përdorimit të grafikës dhe zërit brenda aplikacionit. Delphi lejon programimin e
aplikimeve multimediale.
Komponenti Shape. Ndodhet në kartelën Additional dhe mundëson dhënien
e formave të thjeshta formës.
Karakteristika të rëndësishme janë Brush dhe Pen. Brush përcakton ngjyrën
e furçës ose modelin e brendshëm. Pen përcakton stilin dhe ngjyrën e vijës me të
cilën vizatojmë.
Komponenti Image përdoret për shfaqjen e fotografisë në formë. Ajo
ndodhet në kartelën Additional.
Objekti Canvas përdoret, ashtu që së pari me ndihmën e vetive përcaktohen
parametrat për vizatim, dhe pastaj vizatohet. Veti të rëndësishme për vizatim janë
pamja dhe trashësia e vijës, forma e figurës dhe mbushja me ngjyrë, lloji i fontit etj.
Parametra të nevojshëm janë koordinatat e vizatimit, madhësia e tij, ngjyra etj.
Përveç vizatimit të figurave, në canavas – mund të paraqitet (vizatohet) tekst
me ndihmën e metodës TextOut dhe TextRect.
Komponenti MediaPlayer për aplikacione multimediale të thjeshta gjendet
në faqen System. Kjo komponentë mund të ekzekutojë datoteka zëri dhe
videodatoteka, nëse posedojmë datoteka formatin e të cilave e njeh Delphi.

Programimi-Delphi
Pyetje dhe detyra:
1. Cila ngjarje ndodh nëse klikoni në formën e aplikacionit, dhe cili nëse klikoni
mbi butonin?
2. Në cilat dy mënyra mund të hapet rregullatori i ngjarjeve për ta shkruar kodin e
programit për butonin komandues Button1?
3. Shpjegoni funksionet:
-IntToStr
-StrToFloat.
-StrToInt
-FloatTo Str
4. Cila procedurë do të hapet, nëse shtypni butonin Button1 në formën Form1?
5. Çfarë arrihet me Urdhrin për ndarjen e vlerës?
6. Për të lehtësuar përfshirjen apo përjashtimin e një ose më shumë opsioneve,
përdoret
kontrolla___________________________________________________________
_____
7. Çfarë është Kontrolli Checkbox dhe kur përdoret?
Shkruani një komandë me të cilën do të verifikohet nëse është klikuar në këtë
kontrollë dhe nëse po, të shtypet në Label1 që është e klikuar, dhe nëse nuk
është klikuar, të shtypet në Label1 që nuk është klikuar.
8. Shpjegoni rreshtat e programit:
-StringGrid1.Row:=ComboBox1.itemindex+1;
-Edit1.SetFocus;
-StringGrid1.Cells[0,1]:='1.';
9. Çfarë është Kontrolli RadioButton dhe kur përdoret?
Shkruani një komandë me të cilën do të verifikohet a është klikuar në këtë
kontrollë dhe nëse po, të shty në Label2 që është klikuar, dhe nëse nuk është
klikuar, të shtypet në Label2 që nuk është klikuar.
10. Shpjegoje vetitë:
-Items
-ItemIndex
11. Cila nga këto opsione është pjesë e hapësirës punuese të Delphi-t?
A) Object Projector,
B) Object Inspector,
C) Object Detector.
12. Në cilat mënyra mund të futet teksti në komponentin Memo?
13. A mundet të nderohet çdoherë teksti i futur në komponentin Memo?
14. Si sillet komponenti Memo gjatë futjes së tekstit nëse vetia WordWrap është
vendosur në False?
15. Cila komponentë Delphi lejon shfaqjen e të dhënave në më shumë rreshta dhe
kolona?
16. Cilat objekte shfaqen me komponentin StringGrid?
17. Cili numër tregon indeksin e elementit të parë në një varg 0 apo 1?
18. Në kolonën e tretë, e cila është bosh, shkruaj shkronjën (a, b, c) e cila ndodhet
para Urdhrit për struktura ciklike e është shkruar në anën e majtë, dhe e cila është
shpjeguar me disa nga propozimet në anën e djathtë.

Programimi-Delphi
ɚ) Repeat – Struktura përsëritje me kusht në

until mbarim të ciklit,
b) While do Struktura përsëritje me kusht në
fillim të ciklit,
c) For do Struktura përsëritje me kërcim në
rresht programi të caktuar
Struktura përsëritet me numrin e
cikleve
19. Në kolonën e tretë, e cila është bosh, shkruaj shkronjat (a, b, c, d), e cila
ndodhet para propozimit që është shkruar në anën e majtë, dhe që është shpjeguar
me disa nga propozimet në anën e djathtë.
Ⱥ) Properties Ngjarje
B) Events Veti
C) Tools Paletë e komponentëve
D) Component Shirit me vegla
palettɟ
Detyra
1. Krijo një program me të cilin do të vendosen pesë numra dhe do të llogaritet

mesi aritmetik i tyre. (Shembull me komponentin Edit).
2. Të bëhet një aplikacion me të cilin do të ngjyroset Kontrolli Edit në varësi të
numrit të futur në Edit. (1-blu, 2-e verdhë, 3-rozë).
3. Krijo një program që do të krahasojë dy numra dhe do të shtypet numri më i
madh prej tyre. (Shembull me komponentin Edit).
4. Të bëhet një aplikacion i ri që do të tregojë kohën dhe datën momentale.
5. Të krijohet aplikacion i cili do të shfaq sa herë një zanore paraqitet në fjali.
6. Të shkruhet aplikacion për përcaktimin e moshës së personit të bazuar në datën e
lindjes dhe datën e sotme.
7. Të shkruhet një program që do të punojë si një kuis me 6 pyetje. Për çdo pyetje
duhet të ofrohen nga 4 përgjigje (opsione), prej të cilave vetëm një është e saktë.
Në fundi, në formën e dytë të tregohen pikët e fituara dhe nota e fituar.
8. Të krijohet loja "Xheku me një dorë” në formë me tre fusha automatikisht
ndryshojnë numrat. Kur ju klikoni butonin "më ndalo,,, nëse të gjithë tre numrat
nuk janë të njëjtë, shfaqet mesazhi- urime dhe pyete për të luajtur përsëri.
9. Të shkruhet aplikacion që do të vizatojë linja me gjatësi të rastit në ekran.

Programimi-Delphi
KAPITULLI 4
4. SHKRIMI I MESAZHEVE (KORNIZA PËR DIALOG)
Në këtë kapitull do të përpunohen këto mundësi:-përshkrimi i sistemit për

mesazhe;
-zbatimi i komandës showmessage;
-zbatimi i komandës messagedlg;
-zbatimi i komandës messagedlgpos.
Format si objekte themelore në Delphi mund të trajtohen si një dritare-
dialogu. Por, kur themi dritare-dialogu, nënkuptojmë lloj special të dritares që ka
vetitë e mëposhtme:
1. Madhësia e kornizës nuk mund të ndryshohen,
2. Kjo dritare më shpesh përdor butonin OK, por disa dritare kanë edhe butona
Close, Cancel, Help.
3. Në shiritin e titullit (emrit) nuk ka butona për minimizim dhe zmadhim.
Në kuadër të Delphi ekzistojnë korniza që vetë mund t’i definojmë dhe dritare të
cilat veçse janë të definuara.
4.1. ShowMessage
Ajo përdoret për të shfaqur mesazhe të caktuara gjatë ekzekutimit të

aplikacionit. Paraqitja e dritares-dialog e ndalon ekzekutimin e aplikacionit, deri në
mbylljen e tij, me klikim në butonin OK. Ky dialog përdoret kur aplikacioni duhet
t’i tregojë përdoruesit ndonjë mesazh.
Detyra 1: Të krijohet aplikacion i cili shfrytëzuesit i tregon a i lejohet puna
me aplikacionin apo jo. Puna lejohet vetëm në ditë pune. Ditë jo pune janë e shtuna
dhe e diela.
Figura 4.1.

Programimi-Delphi

var
data:TdateTime;
i:integer;
begin
Data:=StrToDate(edit1.text);
i:=DayOfWeek(data);
if (i=1) or (i=7) then
begin
ShowMessage('SOT ËSHTË DITË JO PUNE, NUK MUND T’I QASENI
APLIKACIONIT ');
Close;
end
else
ShowMessage('MIRË SE ERDHËT');
end;
end.
Për realizimin e detyrës së dhënë, është përdorur funksioni
DayOfWeek(data) e cila në bazë të datës jep numrin rendor të ditës së javës. Sipas
saj ditë e parë është dita e diel: 1, kurse e fundit e shtunë: 7,
Kodi i programit lejon futjen e datës së gabuar, shembull, për ditë jo pune të
futet datë e ditës së punës.
Të bëhet korrigjim i kodit programor, në atë mënyrë që të bëjë të pamundur
futjen në aplikacion nëse data e sistemit nuk përputhet me datën e futur. Në këtë
rast, të shkruhet mesazhi:
DATA E FUTUR NUK E SOTSHME.
var
data:TdateTime;
i:integer;
begin
Data:=StrToDate(edit1.text);
i:=DayOfWeek(data);
Label2.Caption:= 'Today is ' + DateToStr(Date);
if data<>date then
BEGIN
ShowMessage('NUK KE FUTUR DATË TË SAKTË');
CLOSE;
END
ELSE
if (i=1) or (i=7) then
begin
ShowMessage('SOT ËSHTË DITË JO PUNE, NUK
MUND T”I QASENI APLIKACIONIT');
Close;
end
else
ShowMessage('MIRË SE ERDHËT');
end; end.

Programimi-Delphi
4.2. MessageDlg
Kjo dritare-dialog i ngjan të mëparshmes, me atë që përshkrimi i titullit bie në grup

të veçantë të përshkrimeve të Windows-it.
Figura 4.2
Në rreshtin për titull paraqitet fjala Information. Përveç saj, në rreshtin për
përshkrim mund të paraqiten fjalët e mëposhtme: Warning (shenjë paralajmëruese e
verdhë), Error (ikonë e kuqe me shenjë ndal), Confirmation (pyetësor), Custom
(nuk përmban ikonë).
Figura 4.3.
Numri i butonave për të lëshuar dritaren-dialog mund të jenë të ndryshëm.
Figura 4.4.
Detyra 2: Të bëhet aplikacion i cili gjatë ekzekutimit do të japë vlerat e disa

funksioneve elementare, të tilla si katrori i numrit 5, rrënja katrore e 2 dhe pjesa e
plotë e numrit -3,8.
Në formë vendosim butonin për të cilin do të shkruajmë kodin e mëposhtëm të
programit:

Programimi-Delphi
Procedure TForm1.Button1Click(Sender: TObject);

var
s,t:string;
begin
str(sqr(5.0):3:1,t);
s:='5 në katror është ' + t + #13;
str(sqrt(2.0):5:4,t);
s:=s+'Rrënja katrore e 2 është' + t + #13;
str(trunc(-3.8),t);
s:=s+'Pjesa e plotë e numri -3.8 është'+t;
MessageDlg(s,mtInformation,[mbOk],0);
end;
Figura 4.5.
Argumentet e funksionit MessageDlg kanë këto kuptime: s - paraqet tekstin

që do të shfaqet në dritaren-dialogun, mtInformation paraqet tekstin në shiritin e
titullit dhe shenja- ikonën në dritare, [mbOk] është emri i butonit do të shfaqet në
dritaren-dialog dhe zero (0) Delphit i shërben si një indikator.
Me urdhrin vijues në Delphi fitohet dritarja-dialog nga figura 4.3:
MessageDlg('E dhëna e futur nuk mund të konvertohet në numër. '+#13+
'Futni të dhënë valide', mtError,[mbOk],0);
Me procedurën e ardhshme në Delphi fitohet dritarja-dialog si në figurën 4.4:
begin
if MessageDlg('Welcome to my Object Pascal application. Exit now?',
mtConfirmation, [mbYes, mbNo], 0) = mrYes then
begin
MessageDlg('Exiting the Object Pascal application.', mtInformation,
[mbOk], 0);
Close;
end;
end;
Detyra 3: Të bëhet aplikacion me të cilën për N numra të çfarëdoshëm të numrave

të futur do të llogaritet shuma.
Udhëzime: Futet N - numri i numrave që do t’i mbledhim, dhe pastaj numrat futen
në dritaren-dialog në kuadër të një cikli.

Programimi-Delphi
Figura 4.6.

var
s,x:real;
t,p:string;
n,i,j:integer;
begin
val(edit1.text,n,j);
if(j<>0)or(n<=0)then
begin
messageDlg('E dhëna nuk është e sakte',mtError,[mbOk],0);
close;
end;
s:=0;
i:=1;
while i<=n do
begin
str(i,p);
t:=inputBox('Numra','Futet'+p+'-numri',' ');
val(t,x,j);
if j/<>0then
begin
messageDlg('E dhëna nuk është e sakte',mtError,[mbOk],0);
close;
end;
s:=s+x;inc(i);
end;
str(s:8:3,p);
showmessage('Mbledhja është s='+p);
end;

Programimi-Delphi

begin
end;
Urdhri t:=inputBox('numra','futet'+p+'-numër',' ');

Përdor funksionin InputBox, që përmban tre parametra. Parametër i parë "numra"
përcakton se çfarë paraqitet në shiritin e titullit, parametri i dytë 'futet`+p+'numër',
jep mesazhin që do të shfaqet në dritaren-dialog, kurse parametri i tretë përfaqëson
vlerën e të dhënave që do të importohen. Në rastin tonë kjo është e dhënë boshe-
nuk ka vlerë fillestare.
Detyrë: Të bëhet aplikacion që përcakton mesin gjeometrik të dy gjatësive të

dhëna. Numrat matës të gjatësive të dhëna duhet të jenë numra pozitiv.
Figura 4.7.
procedure TForm1.LlogaritClick(Sender: TObject);

Var
a,b,c:Real;
s:String;
i,j:Integer;
begin
Val(edit1.text,a,i);
Val(edit2.text,b,j);
If (i=1) or (j=1) then
MessageDlg('e dhena nuk nuk numt te trasformohet ne numer'+#13+
'Fut te dhene te sakte', mtError,[mbOk],0);

Programimi-Delphi
if (a<=0) or (b<=0) then

MessageDlg('Numri matës i gjatësisë nuk është i mirë!'+#13+
'Fut vlerë pozitive', mtError,[mbOk],0)
else
begin
c:=sqrt(a*b);
str(c:8:3,s);
MessageDlg('Mesi gjeometrike i gjatësive të dhëna
është:'+s,mtInformation,[mbOk],0);
end;
end;
end.
4.3. Messagedlgpos
Shfaq dritaren-dialog me mesazh në koordinata të caktuara në ekran.

Ky shembull përdor buton në formë. Kur përdoruesi klikon butonin, shfaqet dritare
me mesazh me tre butona: Yes, No, dhe butonin Cancel në të:

begin
MessageDlgPos('Are you there?',mtConfirmation, mbYesNoCancel, 0, 200,
200);
end;
Figura 4.8.
4.4 Komponentët DIALOGS
Në kartelën Dialog ndodhen komponentë të ndryshme për dialog si

OpenDialog, SaveDialog, ColorDialog dhe të tjera. Ata përdoren për qasje të
unifikuar në operacionet më të zakonshme që ekzekutohen në aplikacione. Në
programe, dialogu aktivizohet me metodën Execute. Asnjë dialog nuk kryen
veprime konkrete, por vetëm e lejon përdoruesin të bëjnë zgjedhje, kurse veprimet
e veçanta realizohen në kodin e programit.

Programimi-Delphi
4.4.1. OpenDialog i lejon përdoruesit të zgjedh datotekën nga disku që

dëshironi ta lexojë.
Detyra 1: Të krijohet formë me dy butona dhe OpenDialog.
Figura 4.9.
Figura 4.10.
Kodi i programor që mundëson shfaqjen e OpenDialog është si më poshtë:

begin
OpenDialog1.Execute;
end;

Programimi-Delphi
4.4.2. SaveDialog paraqet një dritare-dialogu standarde të Windows-it. Komanda

që aktivizon këtë dritare-dialog është si më poshtë:
SaveDialog1.Execute;
Figura 4.11.
4.4.3. ColorDialog ofron në mënyrë standarde të zgjidhet ngjyra. Komanda që

aktivizon këtë dritare-dialogu është si më poshtë:
ColorDialog1.Execute;
Figura 4.12.

Programimi-Delphi
KAPITULLI 4
(SHKURT)
Dritarja-dialog përdoret për shfaqjen e mesazheve të caktuara gjatë
ekzekutimit të aplikacionit.
Përdoren këto lloje të dritareve-dialog:
- ShowMessage
Ajo përdoret për të shfaqur mesazhe të caktuara gjatë ekzekutimit të
aplikacioneve. Shfaqja e dritares-dialog ndalon ekzekutimin e programit deri në
mbylljen e tij, duke klikuar butonin OK.
- MessageDlg
Kjo dritare-dialog i ngjan të mëparshmes, me atë që përshkrimi në titullin i
takon një grupi të veçantë të përshkrimeve të Windows-it.
Në rreshtin për titull paraqitet fjala Information. Përveç tij, në rreshtin e
përshkrimit mund të paraqiten fjalët e mëposhtme: Warning (shenjë paralajmëruese
e verdhë), Error (ikonë e kuqe me shenjë ndal), Confirmation (pyetësor), Custom
(nuk përmban ikonë).
- Messagedlgpos
Tregon dritaren-dialog me mesazh në ekran në koordinata të caktuara.
Komponentët DIALOGS
OpenDialog lejon përdoruesin të zgjedh datotekën në disk nga ku do të
lexoj.
SaveDialog paraqet dritare-dialogu standarde të Windows-it.
Komanda që aktivizon këtë dritare-dialog është si më poshtë:
SaveDialog1.Execute;
ColorDialog ofron një mënyrë standarde për të zgjedhur ngjyra.
Komanda që aktivizon këtë dritare-dialog është si vijon:
ColorDialog1.Execute;
Pyetje dhe detyra:
1. Jepni arsyet e përfshirjes së dritares-dialog në aplikacion?

2. A mund të zgjidhen problemet pa përdorimin e dritares-dialog?
3. Nga çfarë varet titulli i dritares-dialoguse ShowMessage?
4. Në cilin rast është e dëshirueshme të përdoret dritarja-dialog InputBox?
5. Cilat janë pjesët kryesore të dritares InputBox?
6. Cili është funksioni i Messagedlgpos?

Programimi-Delphi
KAPITULLI 5
5. KRIJIMI I MENYVE PËR FORMË

Në këtë kapitull do të bëhet fjalë për:
- përshkrimin e sistemit të menyve;
- përdorimi i komponentit MAIN MENU;
- përdorimi i komponentit POPUP MENU, SPEED MENU;
- lidhshmëria e opsioneve nga menyja me forma të tjera dhe futja në
projektin momental.
5.1. MainMenu
Menyja është një pjesë e rëndësishme e aplikacioneve të Windows-it.

Ndodhet në rreshtin e dytë pas shiritit të titullit. Përbëhet nga disa fjalë të quajtura
opsione dhe ka nënmeny.
Në komponentin Standard është komponenti MainMenu dhe të e vendosim
në formë. Duke klikuar dy herë në MainMenu, hapet dizajnuesi i menyve. Ai duket
si një formë boshe.
Për opsionin nga menyja duhet të ndryshohen vetitë:
Name - FileMenu
Caption - & File (Alt +F)
Paraqitet hapësirë boshe nën File dhe në të djathtë të saj.
File Name - FileNew

Caption - &New
New
Hapat paraprak përsëriten që të krijohen pjesë të menysë:
Open Open, Save, SaveAs.
Save
SaveAs
Rekomandohet standardizimi i menyve, gjegjësisht ata të duken si në
aplikacionet tjera të Windows-it.
Separator është një linjë horizontale për ndarjen e opsioneve të menyve.
Krijohet si më poshtë:
Në fushën poshtë Save As të vetisë Caption vendoset (-)
Shtimi i nënmenyve bëhet sipas mënyrës vijuese:
Insert - Sub menu
Create - Sub menu
Me klik të djathtë Insert- Sub menu
Zgjedhjen e cilitdo opsion e aktivizon OnClick dhe ekzekutohen urdhrat në
at procedurë.
Detyra 1: Të krijohet aplikacioni ora me ngjyra. Në formë vendosim
komponentët në vijim: MainMenu, Timer dhe Label.
Kodi i programit është si vijon:
Procedure TForm1.MenuKohaClick(Sender:Tobject);
Begin
Label1.caption:=TimeToStr(time);
End;

Programimi-Delphi
Procedure TForm1.MenuDataClick(Sender:Tobject);
Begin
Label1.caption:=DateToStr(Date);
End;
Procedure TForm1.E kuqe1Click();
Begin
Label1.color:=clred;
E kuqe1.enabled:=False;
E gjelbër1.enabled:=True;
E kaltër1.enabled:=True;
End;
Procedure TForm1.E gjelbër1Click();
Begin
Label1.color:=clgreen;
E kuqe1.enabled:=True;
E gjelbër1.enabled:=False;
E kaltër1.enabled:=True;
End;
Procedure TForm1.E
kaltër11Click();
Begin
Label1.color:=clblue;
E kuqe1.enabled:=True;
E gjelbër1.enabled:=True;
E kaltër1.enabled:=False;
End;
Figura 5.1.
Komponenti Timer mund të përdoret për të shfaqur kohën momentale.
Detyra 2: Të bëhet një aplikacion i cili do të punojë si program i thjeshtë për

përpunimin e tekstit. Me programin do të përpunohen datoteka dhe tekst. Tek
datotekat aktivitete janë: krijimi i datotekës, leximi i ekzistueses, rruajtja, shtypja.
Përpunimi i tekstit është: zgjedhja, prerja, kopjimi i tekstit, ngjitja e pjesës së tekstit
etj.
x Hapet aplikacion i ri.
x Shtohet komponenti Memo në të.
Fshihet teksti Memo përmes editorit për tekst (vetia Lines)
Vetia ScrollBars -> ssVertical
Vendosim fontin e sistemi Fixedsys
Align-> alClient me çka komponenti Memo zen gjithë formën.
x Në formë shtohet komponenti MainMenu.
x Krijimi i një menyje.

Programimi-Delphi
Figura 5.1.
x Shtimi i shkurtesave të opsioneve në meny:

- të shënohet E re në opsionin Datoteka;
- në vetinë ShortCut të zgjidhet Ctrl+N.
x Djathtas nga datoteka duhet të krijohet opsioni Editim nga menyja.
Figura 5.2.
x Shtimi i opsioneve në nënmeny bëhet duke klikuar mbi butonin Insert,

kurse fshirja me Delete.
x Qasja e opsioneve bëhet me vetinë Enabled - False.
x Në meny shtojmë komponenti nga kartela edhe atë OpenDialog,
SaveDialog.

Programimi-Delphi
Figura 5.3.
procedure TForm1.Dalje1Click(Sender: TObject);

begin
close;
end;
procedure TForm1.ERe1Click(Sender: TObject);
Var res:integer;
begin
if memo1.modified then
begin
Res:=Application.MessageBox('Datoteka aktuale është ndryshuar.
Rruani ndryshimet?',
'Tekst1Message',MB_YESNOCANCEL);
If res=IDYES then Rruaj1Click(Sender);
If res=IDCANCEL then exit;
end;
if memo1.Lines.count>0 then memo1.clear;
savedialog1.filename:=' ';
end;
procedure TForm1.Rruaj1Click(Sender: TObject);
begin
if savedialog1.filename<>' ' then
begin
memo1.lines.savetofile(savedialog1.filename);
memo1.modified:=false;
end
else
Rruaj si1click(sender);
end;
procedure TForm1.Hap1Click(Sender: TObject);
var res:Integer;
begin
if memo1.modified then
begin

Programimi-Delphi
Res:=Application.MessageBox('Datoteka aktuale është ndryshuar.

Rruani ndryshimet?',
'Tekst1Message',MB_YESNOCANCEL);
If res=IDYES then Rruaj1Click(Sender);
If res=IDCANCEL then exit;
end;
opendialog1.filename:='FileName ';
if opendialog1.execute then
begin
if memo1.lines.count>0 then memo1.clear;
memo1.lines.loadfromfile(opendialog1.filename); {hapje}
savedialog1.filename:=opendialog1.filename;
end;
end;
procedure TForm1.Rruaj si1Click(Sender: TObject);
begin
savedialog1.title:='Rruaj si';
if savedialog1.execute then
begin
memo1.lines.savetofile(savedialog1.filename); {rruajtja}
memo1.modified:=false;
end;
end;
procedure TForm1.Anulo1Click(Sender: TObject);
begin
SendMessage(memo1.handle,WM_UNDO,0,0);
end;
procedure TForm1.Preje1Click(Sender: TObject);

begin
memo1.CutToClipboard;
end;
procedure TForm1.Kopjo1Click(Sender: TObject);
begin
memo1.CopyToClipboard;
end;
procedure TForm1.Ngjit1Click(Sender: TObject);
begin
memo1.PasteFromClipboard;
end;
procedure TForm1.Më tepër rreshta1Click(Sender: TObject);
begin
memo1.wordwrap:=not memo1.WordWrap;
Më tepër rreshta1.checked:=memo1.WordWrap;
if memo1.WordWrap then memo1.scrollbars:=ssVertical
else
memo1.scrollbars:=ssboth;
end;
procedure TForm1.ZgjidhKrejt1Click(Sender: TObject);

Programimi-Delphi
begin
memo1.selectAll;
end;
end.
Teksti i shkruar me këtë aplikacion është paraqitur në figurën 5.4.
Figura 5.4.
Procedura për dalje mundëson përfundimi e punës dhe të daljes nga

aplikacioni, por i mundëson përdoruesit që gjatë daljes nga aplikacioni të
paralajmërohet se në datotekë janë bërë disa ndryshime pas rruajtjes së fundit.
Procedura E re hap një datotekë të re, por paraprakisht kontrollohet që
datoteka momentale a ka pësuar ndryshime pas rruajtjes së fundit dhe përdoruesit i
ofrohet mundësia e rruajtjes së ndryshimeve.
Procedura Hap, hap datotekën e zgjedhur nga folderi i zgjedhur.
Paraprakisht verifikohet në datotekën momentale a janë ruajtur ndryshimet e fundit.
Kodi programor përmban OpenDialog dhe LoadFromFile.
Procedura Save kryen regjistrimin-rruajtjen e datotekës. Ky opsion duhet
të përdoret nëse datotekës tashmë i është dhënë emër. Përndryshe zgjedhim
opsionin Save As.
Redaktimi i tekstit bëhet duke ndjekur procedurat e mëposhtme;
Procedura Anulo anulon aktivitetet e mëparshme me të cilat është bërë
ndonjë ndryshim në datotekë. Pasi që Delphi nuk ka një mundësi të tillë, përdoret
komanda e Windows-it WM_UNDO,0,0.
Procedura Përzgjedh mundëson selektimin e gjithçka që është futur deri
tani në datotekë.
Procedura Preje e bart pjesën e përzgjedhur të tekstit në memorien e
përkohshme Clipboard dhe njëkohësisht e largon nga datoteka.
Procedura Kopjo punon njëlloj si Preje, vetëm se pjesën e përzgjedhur nuk
e largon nga datoteka.
Procedura Ngjit e kthen përmbajtjen nga temorja e përkohshme në
datotekë në vendndodhjen e kursorit (treguesit).

Programimi-Delphi
Procedura Më tepër rreshta lejon shkrimin e tekstit në datotekë në më tepër

rreshta. Ky opsion duhet vetëm të përzgjidhet, dhe pastaj duhet vetëm ashensor
vertikal, përndryshe, duhen të dy ashensorët.
5.2. PopupMenu
Në Delphi mund të përdoret meny ndihmëse (PopupMenu). Krijimi i kësaj

meny është e ngjashme me mënyrën e krijimit të menysë kryesore. Efekti i dhënies
së kësaj menyje është ajo e opsioneve të shumta që shfaqen kur klikojmë butonin e
djathtë të miut në ndonjë komponentë ose tekst. Shkrimi i kodit për këtë meny
është i ngjashëm me shkrimin e kodit për menynë kryesore.
Do të përdorim aplikacionin paraprak për të shtuar mundësinë e përdorimit
të menysë ndihmëse. Në programet për përpunim të tekstit, zakonisht kur një pjesë
e tekstit do të shënohet dhe në të do të klikohet me klik-të djathtë, menyja ndihmëse
mundëson prerjen, kopjimin dhe ngjitjen e tekstit.
Që të mund në menynë kryesore të përfshijmë edhe meny ndihmëse, e cila
do të veprojë në opsionin Editim, shkohet sipas procedurës së mëposhtme:
1. Thirrim aplikacionin që ka të bëjë me menynë kryesore, sepse në të bëhet
ndërhyrja.
2. Komponentin PopupMenu e vendosim në formë.
3. Ja ndërrojmë Emrin në MeniNdihmëse.
Forma ka pamjen si në figurën 5.5.
Rregullimi
Figura 5.5.
4. Klikojmë dy herë në këtë komponentë që të startojmë dizajnuesin e

menyve. Pastaj paraqitet një dritare me një drejtkëndësh blu, në këndin e saj të
majë lartë. Kjo meny mund të krijohen në të njëjtën mënyrë si menyja kryesore,
por mundet edhe në një mënyrë tjetër, gjatë së cilës do të përdoren opsionet që
janë krijuar në menynë kryesore.
5. Me klik të djathte në katrorin blu thirrim dizajnuesin e menyve
ndihmëse. Nga nënmenyja zgjedhim Select Meny (figura 5.6.), me çka paraqitet
një dritare që i tregon menytë, e disponueshme në aplikacion figura 5.6.

Programimi-Delphi
Figura 5.6.
6. Zgjedhim MainMenu1 dhe butonin OK.

7. Në dritaren e fituar zgjedhim opsionin Editim, në të cilën do të zgjedhim në
opsionet Preje, Kopjo dhe Ngjite.
8. I bartim opsionet e zgjedhura në memorien ndihmëse me metodën e kopjimit
nga programi Delphi. (Ctrl+C).
Figura 5.7.
9. Pastaj zgjedhim SelectMenu, kurse në dritaren e fituar zgjedhim

MenyNdihmëse dhe butonin OK. Shfaqet meny ndihmëse boshe.
10. E bartim përmbajtjen e memories së përkohshme, me çka i kemi kopjuar
opsionet e menysë ndihmëse.
11. Ndryshojmë emrat e opsioneve të vendosura në menynë ndihmëse
PjejeNdihmëse, KopjoNdihmëse, dhe NgjitNdihmëse.

Programimi-Delphi
Duhet të shkruhet kodi i programit për komanduesit me ngjarje për

opsionet e menysë ndihmëse. Puna mund të na lehtësohet, sepse tashmë kemi kode
programore të shkruara për të njëjtat ngjarje në menynë kryesore. Kemi mundësi që
për të njëjtat ngjarje të përdorin kontrolluesit e përbashkët të ngjarjeve. Procedura
për lidhjen e opsioneve të menysë ndihmëse me kontrolluesit ekzistues të ngjarjeve
e kryejmë në këtë mënyrë:
12. Në dizajnuesin e menyve zgjedhim opsionin Preje.
13. Në kartelën ObjectInspector zgjedhim Events.
14. Klikojmë në butonin me shigjetë poshtë, që ndodhet në të djathtë të
ngjarjes OnClick. Shfaqet lista e procedurave që janë krijuar deri tani në
aplikacion.
15. Nga lista e ofruar duhet të zgjedhim EditoPreje. Në këtë mënyrë kemi
lidhur ngjarjen me kodin programor tashmë ekzistues.
16. Hapat 12-15 duhet të përsëritet për dy opsionet e mbetura të menysë
ndihmëse.
17. Që të përfundoj krijimi i menysë ndihmëse, në formë selektojmë
komponentin Memo dhe vetinë PopupMenu e ndryshojmë
MenynëNihmëse.
Me këtë mbaron procedura e krijimit të menysë ndihmëse. Nëse e startojmë
aplikacionin dhe në dritaren për tekst klikojmë me buton të djathtë të miut, do të
fitohet dritarja e Figurës 5.8.
Figura 5.8. Pamja e aplikacionit me meny ndihmëse.

Programimi-Delphi
KAPITULLI 5
(SHKURT)
Menyja është pjesë e rëndësishme e aplikacioneve të Windows-it. Gjendet

në rreshtin e parë pas rreshtit të titullit. Përbëhet nga më tepër fjalë të quajtura
opsione dhe ka nënmeny.
Në komponentët Standard gjendet komonenta MainMenu, atë e vendosim
në formë. Me klikim të dyfishtë në MainMenu hapet dizajnuesi i menyve.
PopupMenu – meny ndihmëse. Efekti i dhënies të kësaj menyje është ajo
e opsioneve të shumta që shfaqen gjatë klikimit të dyfishtë të butonin të miut mbi
një komponentë ose tekst.
Ushtrime
Operacione me numra (komponenti PopupMenu)

Të shkruhet një program me të cilin kryhen operacionet mbledhja, zbritja,
shumëzimi dhe zbritja e dy numrave. Në formë të përcaktohen fushat përkatëse
Edit (sfond të verdhë me numra blu), për futjen e numrave numër1 dhe numë2,
ndërsa për rezultatin gjithashtu fushë Edit (sfond të verdhë me numra të kuq). Në
formë të vendoset PopupMenu në të cilën definohen operacionet Mblidh, Zbrit,
Shumëzo dhe Pjesëto.
Pamja e formës në zgjidhjen e kësaj detyre është treguar në figurën 5.9
.
Figura 5.9.
Forma përdor komponentët standarde Label, Edit dhe komponentin

PopupMenu, e cila aktivizohet në nivel të formës duke klikuar në butonin e djathte
të miut. Që të shtohen opsionet në meny, duhet të klikohet dy herë në Items në
vetinë e PopupMeni me ndihmën e së cilës shtohen opsionet në meny siç është
treguar në figurën 5.10.

Programimi-Delphi
Figura 5.10.
Pjesa kryesore e kodit të programit është si më poshtë:
procedure TForm1. Kontrolla_e_numrit_te_pare(Sender: TObject);

Var s:string;
n:real;
gr: integer;
Begin
s:=Edit1.Text; Val(s,n,gr);
If gr <> 0 Then Begin
ShowMessage('Nuk eshte fut mire numri 1');
Edit1.SetFocus; Edit1.SelectAll;
End
end;
procedure TForm1. Kontrolla_e_numrit_te_dyte(Sender: TObject);
Var s:string;
n:real;
gr: integer;
Begin
s:=Edit2.Text; Val(s,n,gr);
If gr <> 0 Then Begin
ShowMessage('Nuk eshte fut mire numri 2');
Edit2.SetFocus; Edit2.SelectAll;
End
end;
procedure TForm1.Mblidh(Sender: TObject);
begin
Edit3.Text:=FloatToStr(StrToFloat(Edit1.Text)+StrToFloat(Edit2.Text));
Label2.Caption:='+';
end;

Programimi-Delphi
procedure TForm1.Zbrit(Sender: TObject);

begin
Edit3.Text:=FloatToStr(StrToFloat(Edit1.Text)-StrToFloat(Edit2.Text));
Label2.Caption:='-';
end;
procedure TForm1.Shumëzo(Sender: TObject);

begin
Edit3.Text:=FloatToStr(StrToFloat(Edit1.Text)*StrToFloat(Edit2.Text));
Label2.Caption:='X';
end;
procedure TForm1.Pjesëto(Sender: TObject);

begin
Label2.Caption:='/';
If(StrToFloat(Edit2.Text))=0 Then Begin
ShowMessage('Pjesëtim me zero');
Edit2.SetFocus;
Edit2.SelectAll
End
Else
Edit3.Text:=FloatToStr(StrToFloat(Edit1.Text)/StrToFloat(Edit2.Text));
end;
end.
Të shpjegojmë veçoritë kryesore të këtij kodi:
Përmbajtja e fushës Edit është ndryshore string-varg, kështu që është e

nevojshme që të kontrollohet nëse është futur e dhënë numerike në fushën për
numër. Kjo kontrollohet me procedurën Kontrolla_e_numrit_te_pare dhe
Kontrolla_e_numrit_te_dyte. Në ngjarjet (Events) onExit fusim emrat e
procedurave (ngjarja ndodh pas lëshimit të kësaj fushe). Në procedurë ndryshores s
i ndajmë përmbajtjen e fushës (s: = Edit1.Text), dhe pastaj e thirim procedurën
Val e cila ndryshoren string e konverton në numër. Në rast se string-u nuk është
numerik, parametri i tretë i kësaj procedure gr do të ketë vlerë tjetër nga 0. Në atë
rast dërgohet mesazhi për gabim ShowMessage, kthehemi përsëri në këtë fushë me
metodën SetFocus, kurse përmbajtja e saj zgjidhet me metodën SelectAll.
Në procedurat Mblidh, Zbrit, Shumëzo dhe Pjesëto kryejmë operacionin
përkatës aritmetik dhe e shfaqin rezultatin e fituar. Për të kryer operacionin e duhur,
duhet në fillim përmbajtjen e fushës e cila është e llojit string të konvertohet në një
ndryshore numerike me ndihmën e funksionit StrToFloat dhe në fund, rezultati i
fituar të shndërrohet në string. Me funksionin FloatToStr. Gjithashtu, në fushën
Label2 shfaqim shenjën e operacionit matematikor, prsh.,,Mbledhjes,,:
Label2.Caption: =;
Kur është fjala për operacioni pjesëtim, është e domosdoshme të
verifikohet nëse i pjesëtueshmi është i barabartë me 0, dhe në qoftë se po, shfaqim
mesazhin e duhur për gabimi.

Programimi-Delphi
KAPITULLI 6
6. PROCEDURAT (PROCEDURE) DHE

FUNKSIONET (FUNCTIONS) NË DELPHI
Në këtë kapitull, nxënësi do të mësojë:
- të shpjegojë procedurat-procedure;
- të shpjegojë funksionet-function;
- të interpretojë dallimet mes procedurave dhe funksioneve;
- të shkruaj tituj për procedurat dhe funksionet;
- të ndajë dhe transferojë parametra në funksione;
- të njohë procedurën për përdorimin e procedurave;
- të shkruaj procedura për probleme të caktuara;
- të njohë procedurën për përdorimin e funksioneve;
- të shkruaj funksione për problemet që përsëriten;
- të zgjidh shembuj dhe detyra të llojeve komplekse të të dhënave;
- të aplikojë funksione për transformimin e numrit real në string dhe anasjelltas.
6.1. Nën-programet
Nën-programet janë mekanizma për transformimin e sistemeve programore

komplekse në njësi logjike më të vogla. Përpunimet komplekse realizohen duke i
kombinuar këto nën-programe.
Nënprogramet paraqesin pjesë programore të pavarura të cilat kanë të dhënat
e tyre hyrëse dhe japin rezultate dalëse.
Struktura e nën-programit është e ngjashme me strukturën e programit
kryesor. Forma e përgjithshme e nën-programit është:
TitulliINënprogrami
Blloku
;
TitulliINënprogramit përcakton llojin e nën-programit (funksion ose

procedurë), emri i nënprogramit dhe argumentet për pranimin e të dhënave nga
programi që e thirr (programi kryesor ose një nënprogram tjetër) dhe për kthimin e
rezultateve nga përpunimi.
Blloku ka strukturë të njëjtë si programi kryesor.
6.2. Definimi i nënprogramit
Ka dy lloje të nënprogrameve: funksione dhe procedura.

Funksionet janë nënprograme të cilat mbi bazën e argumenteve të tyre japin
një rezultat. Rezultati i tillë quhet vlerë e funksionit.
Procedurat janë nënprograme, të cilat në bazë të argumenteve të tyre mund
të japin më tepër rezultate. Këto rezultate janë gjithashtu edhe argumente të
procedurës.
Forma e përgjithshme e titullit të funksionit dhe procedurës është:
Function EmriIFunksionit(Arg; …;Arg):LlojiIRezultatit;
Procedure EmriIProcedures(Arg; …;Arg);

Programimi-Delphi
Arg = EmriArg, EmriArg, …, EmriArg, EmriArg: LlojiArg; ose

var EmriArg, EmriArg, …, EmriArg, EmriArg: LlojiArg; ose
out EmriArg, EmriArg, …, EmriArg, EmriArg: LlojiArg; ose
const EmriArg, EmriArg, …, EmriArg, EmriArg: TipArg;
ku EmriIFunksionit, EmriIProcedurës janë identifikues për emërtimin e një

nënprogrami. LlojiIRezultatit është identifikues për llojin e rezultatit të funksionit,
EmriArg - identifikues për emërtimin e argumenteve, LlojiArg - identifikuesi i llojit
të argumentit.
Nëse nënprogrami nuk ka argumente duhet të hiqen kllapat.
Argumentet në titullin e nënprogramit quhen argumente formale, të cilat
gjatë thirrjes së nënprogramit do të zëvendësohen me argumentet e duhura të
vërteta.
Shembulli 1: Shuma e N e numrave të parë natyror.
Mënyra I:
Function Shuma (N:Integer):Integer;
Var
I: Integer;
Begin
Result:=0;
For I:=1 to N do Result:=Result+I;
End;
Çdo funksion në gjuhën Object Pascal ka një ndryshore lokale me emrin
Rezult. Kjo variabël fshehurazi deklaron përkthyes, kurse përdoret për të ruajtur
vlerën të cilën e kthen funksioni. Ndryshores Rezult i ndahet një vlerë në kuadër të
funksionit.
Mënyra II.
Function Shuma (N:Integer):Integer;
Var
I: Integer;
Begin
Shuma:=0;
For I:=1 to N do
Shuma:=Shuma+I;
End;
Vlerën që e rikthen funksioni i jepet ndryshores Shuma. Në trupin e
funksionit duhet të ekzistojë urdhër për dhënien e vlerës emrit të funksionit.
Shembull 2: Të krijohet procedurë me të cilën do të llogaritet mesi aritmetik

i N numrave të parë natyror.
Procedure Vlera Mesatare;
Var I,mbledhja:Integer;
Begin
mbledhja:=0;
For I:=1 to N do
mbledhja:=mbledhja+I;
Mesi:=mbledhja/N;
End;

Programimi-Delphi
Shembulli 3: Të bëhet një procedurë për mbledhjen dhe shumëzimin e N numrave

të parë natyror:
Procedure MbledhjeProdhim (N:Integer; var S, P: Integer);
Var I:Integer;
Begin
S:=0;
P:=0;
For I:=1 to N do
begin
S:=S+I;
P:=P*I;
End;
End;
6.3. Thirrja e nënprogrameve
TitulINënprogramit duhet të përcaktohet në pjesën Interface-ndërfaqe.

Përkufizim të plotë të nënprogramit duhet të kemi në pjesën Implementation
– Zbatimi.
Nënprogramet thirren përmes emrit të tyre në programin kryesor. Prapa
emrit të nënprogramit jepen argumentet e vërteta. Argumentet e vërteta në numër
dhe lloj duhet të përputhen me argumentet formale.
Ka nënprograme që e thirrin vetveten dhe quhen nënprogrme rekursive. Ata
mundësojnë zgjidhje të lehtë dhe elegante të problemeve që janë rekursiv në natyrë.
Shembull 4: Për definimin rekursiv të faktorit: n! = n* (n-1)!, ku 0! = 1, mund të

shkruhet funksioni rekursiv i mëposhtëm:
function fact (n:integer):longint;
begin
if n>0 then fact:=n*fact(n-1) {thirrja rekursive e funksionit fact}
else fact:=1; {pika e ndërprerjes}
end;
6.4. Scrollbar - Kontrolla. Detyrë me funksion
Kjo kontrollë përdoret për të futur ndonjë vlerë numerike mes vlerave
numerike të përcaktuara. Mund të vendoset horizontalisht ose vertikalisht.
Veti:
Kind - tregon se çfarë lloji është rrëshqitësi (horizontal ose vertikal);
Min, Max (Integer) - përcakton vlerat kufitare të cilat mund të paraqiten me
rrëshqitësin;
Position (integer) - përcakton pozitën momentale të rrëshqitësit
Ngjarje:
On Scroll - ndodh kur lëviz rrëshqitësi në ScrollBar.
Shembull 5: Të bëhet një program në Delphi i cili do të llogaritë

N! =N * (N-1) * (N-2) *... * 1, ku N është futur me rrëshqitës.

Programimi-Delphi
Figura 6.1.
implementation
{$R *.dfm}
function fact (n:integer):longint;
begin
if n=0 then fact:=1
else fact:=n*fact(n-1);
end;
Procedure TForm1.ScrollBar1Change(Sender:TObject );
Begin
Edit1.text:=IntToStr(fact(ScrollBar1.position));
Label1.Caption:=IntToStr(ScrollBar1.position)+'!=';
end;
begin
end;
end.
Shembull 6: Të bëhet një program për konvertim EURO – DEN me ndihmën e
komponentit ScrolBar.
Shembull 7: Të bëhet një program ku do të futen dy operand në dy kuti Edit dhe

me ta do të kryhen operacionet themelore aritmetike: mbledhja, zbritja, shumëzimi
dhe pjesëtimi. Operatori zgjidhet me RadioButton. Problemi të zgjidhet me
nënprogram.
Procedure Operacione(op1,op2:Real;operator:char;Var Rez:Real);

Begin
Case operator of
'+':Rez:=op1+op2;
'-':Rez:=op1-op2;
'*':Rez:=op1*op2;
'/':Rez:=op1/op2;

Programimi-Delphi
End;
End;
begin
a:=strtofloat(edit1.text);
b:=strtofloat(edit2.text);
If radiobutton1.checked then o:='+';
If radiobutton2.checked then o:='-';
If radiobutton3.checked then o:='*';
If radiobutton4.checked then o:='/';
Operacion(A,B,o,C); {thirrja e procedurës Operacion}
edit4.text:=floattostr(c);
end;
end.
Shembulli 8: Të bëhet një program për të gjetur elementin më të vogël në vargun

(A(i)n,(n = 10)) dhe numrin rendor të tij.
type
Vargu=Array[1..20] of integer; {paraqitja e tipit të vet}
TForm1 = class(TForm)
Memo1: TMemo;
Button1: TButton;
Edit1: TEdit;
procedure Button1Click(Sender: TObject);
procedure FormActivate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Var {pjesa për paraqitjen e variablave globale}
Form1: TForm1;
implementation
{$R *.DFM}
Procedure mëivogël(a:vargu; n:byte; var min:integer; var
NrRend:byte);
Var i:byte;
Begin
Min:=a[1];
NrRend:=1;
For i:=2 to n do
If a[i]<min then
Begin
Min:=a[i];
NrRend:=I;
End;
End;

Programimi-Delphi
var
i,j,n,gr,min:integer;
s:string;
Fusha:vargu;
nr:byte;
begin
for i:=0 to 9 do
begin
s:=memo1.lines[i];
val(s,n,gr);
j:=i+1;
if gr=0 then a[j]:=strtoint(memo1.lines[i]);
end;
Mëivogël(fusha,10,min,nr); {thirrja e procedurës}
edit1.text:=Inttostr(min);
end;
Var i:integer;
begin
for i:=1 to 10 do
a[i]:=0;
end;
end.
Shembulli 9: Të bëhet një nënprogram, i cili kohën e dhënë të shprehur në sekonda

do ta kthejë në orë, minuta dhe sekonda.
Procedure Koha(sek:integer; Var C,M,S:Integer);
Begin
S:=sek mod 60;
Sek:=sek div 60;
M:=sek mod 60;
Sek:=sek div 60;
C:=sek;
End;
Shembull 10: Të bëhet një procedurë që do të formojë dy stringje, njëri vetëm nga
zanoret, kurse tjetri nga bashkëtingëlloret e stringut të dhënë.
Procedure Shkronja(s:string; var zanor, bashkt:string);
var
dol,i:byte;
shkronja, zanor, bashkt:set Of char;
begin
dol:=length(s);
shkronja:=['a'..'z','A'..'Z'];
zanor:=['a','e','i','o','u','A','E','I','O','U'];
bashkt:=shkronja-zanor;
zan:=' ';
bash:=' ';
for i:=1 to dol do

Programimi-Delphi
begin
if s[i] in zanor
then
zan:=zan+s[i];
if s[i] in bashkt
then
bash:=bash+s[i];
end;
end;
Shembull 11: Të bëhet një program që do të llogarit shkallën (eksponentin) Xn.

Function XneN(N:integer; X:Real):Real;
Var i:Integer; P:Real;
Begin
P:=1;
For i:=1 to N do
P:=P*X;
XneN:=P;
End;
Var N:Integer;
A,Rezultat:Real;
Begin
a:=strtofloat(edit1.text);
n:=strtoint(edit2.text);
Rezultat:=XneN(N,a);
edit3.text:=floattostr(rezultat);
end;
end.
Figura 2.6

Programimi-Delphi
KAPITULLI 6
(SHKURT)
Nënprogramet janë mekanizma për transformimin e strukturave programore
komplekse në pjesë më të vogla logjike. Përpunimet komplekse arrihen me
kombinimin e këtyre nënprogrameve.
Funksionet janë nënprograme të cilat mbi bazën e argumenteve të tyre japin
një rezultat. Rezultati i tillë quhet vlerë e funksionit.
Procedurat janë nënprograme, të cilat në bazë të argumenteve të tyre mund
të japin më tepër rezultate. Këto rezultate janë gjithashtu edhe argumente të
procedurës.
Argumentet në titullin e nënprogramit quhen argumente formale, të cilat
gjatë thirrjes së nënprogramit do të zëvendësohen me argumentet e duhura të
vërteta.
Nënprogramet thirren përmes emrit të tyre në programin kryesor. Prapa
emrit të nënprogramit jepen argumentet e vërteta. Argumentet e vërteta në numër
dhe lloj duhet të përputhen me argumentet formale.
Ka nënprograme që e thirrin vetveten dhe quhen nënprogrme rekursive.

Programimi-Delphi
Pyetje dhe detyra:
1. Shkruaj një procedurë Delphi të ashtuquajtur Multiply, e cila pranon dy numra

integer, number1 dhe number2, kurse shtyp rezultatin e shumëzimit të dy numrave.
ɚ) procedure Multiply(number1, number2: integer );

var Result: Integer;
begin
Result:= number1 * number2;
Edit1.text:= inttostr(Result )
end;
b) procedure Multiply(number1, number2: integer );
begin
edit1.text:=inttostr(number1 + number2 )
end;
c) function Multiply(number1, number2: integer): Result;
var Result: Integer;
begin
Edit1.text:=inttostr(Result )
end;
2. Kush është prodhim i këtij programi në Paskal:

program Sample(output );
var x, y: integer;
procedure godoit(x, y: integer );
begin
x:= y; y:= 0;
write(x, y );
end;
begin
x:= 1; y:= 2;
godoit(x, y );
writeln(x, y )
end.
ɚ) 2001
b) 1020
c) 2012
d) 1234
3. Shkruaj funksionin në Paskal të quajtur Multiply2 i cili kthen rezultat integer.

Funksioni pranon dy parametra integer, number1 dhe number2, kurse kthen
vlerën e shumëzimit të dy parametrave
a) procedure Multiply2(number1, number2: integer): integer;
var Result: integer;
begin
Multiply2:= Result
end;

Programimi-Delphi
b) function Multiply2(number1, number2: integer): real;

begin
Multiply2:= Result
end;
c) function Multiply2(number1, number2: integer): integer;
begin
Multiply2:= Result
end;
4. Cilët ndryshore janë globale?
5. Shpjego parametrat e vërtetë.
6. Çfarë është nënprogrami?
7. Cilët parametra janë formal?
8. Shpjegoni variablat lokale.
9. Të bëhet një funksion për shumëzimin e dy numrave. Ai duhet të thirret në
programin kryesor në ngjarjen OnClick të butonit Button1. Numrat të futen
përmes dy kontrolleve Edit në formë.
10. Të bëhet një funksion për llogaritjen e faktorielit. Ai të thirret në programin
kryesor në ngjarjes On Change në kontrollin ScrollBar. Forma duhet të
përmbajë të ScrollBar, Edit-për shfaqjen e rezultateve, Etiketë, Button - Dalje.
11. Të bëhet një funksion për llogaritjen e Shuma_n. Ai të thirret në programin
kryesor në ngjarjen On Change të kontrollës ScrollBar. Forma duhet të
përmbajë një ScrollBar, Edit-për shfaqjen e rezultateve, Etiketë, Button - Dalje.
12. Shkruaj një program për të kthyer shkallën nga Celsiusi në Farad me kontrollë
ScrollBar (1F = 1,8 *c+32).
13. Shkruaj një program për të konvertuar euron në denarë me kontrollën ScrollBar
(1E = 61,5 den).
14. Në cilën pjesë të programit deklarohet procedura? Shkruaj formën e
përgjithshme të komandave me të cilat bëhet deklarimi i procedurës në program.
15. Le të jetë formuar procedura e mëposhtme:
Procedure Koha(sek:integer; Var C,M,S:Integer);
a) thirre këtë procedurë në programin kryesor.
16. Le të jetë krijuar procedura e mëposhtme:
Procedure mëivogël(a:varg; n:byte; var min:integer; var nrrend:byte);
a) thirre këtë procedurë në programin kryesor.

Programimi-Delphi
KAPITULLI 7
BAZAT E TË DHËNAVE
Në këtë kapitull nxënësit do të njihen dhe fitojnë njohuri themelore në fushat e
mëposhtme:
- definimi i fushës, regjistrimit (record), tabelës, baza e të dhënave;
- dallimi në mes të bazës së të dhënave me më tepër tabela në datoteka të ndryshme
dhe bazës së të dhënave me më tepër tabela në një datotekë;
- baza e të dhënave në server;
- arkitektura e bazës së të dhënave në DELPHI;
- komponentët e kartelës DATA ACCESS;
- komponentët e kartelës DATA CONTROLS;
- lidhja mes komponentëve të dy kartelave DATA ACCESS dhe DATA
CONTROLS;
- aplikimi i metodave për të shfaqur gjendjen e DataSet;
- aplikimi i metodave për të lëvizur nëpër DataSet;
- përdorimi i komponentit TABLE;
- kërkimi i tabelës;
- përpunimi i bazës së shkurtës të të dhënave në ACCESS;
- përpunimi i ndërfaqes-interface për një bazë të caktuar të të dhënave.
Nocioni për bazën e të dhënave
Në botën moderne kompjuteri është bërë një instrument i nevojshëm për

përpunimin e të dhënave dhe pajisje më efikase për marrjen e informacioneve.
Baza e të dhënave ka ekzistuar edhe para daljes së kompjuterëve, kurse me
paraqitjen e kompjuterëve ata kanë marrë formë elektronike. Kurdo që të bëni një
listë të të dhënave, për shembull, listë me emra, adresa ose numra telefonash, ju në
të vërtetë krijoni një bazë të të dhënave.
Baza e të dhënave është një numër regjistrimesh të ruajtura në kompjuter në
mënyrë sistematike, kështu që ato mund të arrihen, menaxhohen dhe rindërtohen lehtë.
Modele më të njohura të bazave janë:
x hierarkike,
x të rrjetave dhe
x relacionale.
Modeli më shpesh i përdorur është modeli i bazës së të dhënave relacionale.
Kur është e nevojshme të procesohen të dhënave nga më tepër datoteka, atëherë
datotekat bashkohen në një sistem logjik, të quajtur bazë e të dhënave. Datotekat
grafikisht përfaqësohen nga tabelat, kurse për baza do të përdorim termin lidhje e
tabelave. Tabelat përbëhen prej rreshtave dhe kolonave. Rreshta përfaqësojnë
regjistrime–(records), kurse kolonat fusha (fields) në regjistrime.
Tabela 7.1.

Programimi-Delphi
Çdo regjistrim (record) ka të dhënat e veta në fusha, me çka i njëjti

karakterizohet si një objekt i veçantë, i quajtur entitet
Tabela 7.2.
Për shembull, në tabelën 7.1. të dhënat kanë të bëjnë me individët, pra entitet
është një person. Në tabelën 7.2., entitet është filmi. Fusha përfaqëson një
karakteristikë të entitetit dhe quhet atribut.
Para se të bëhet baza, duhet të bëhet një analizë e shërbimeve që do të
ofrohen nga sistemi që do të menaxhojë bazën e të dhënave. Duhet të arrihet deri te
të dhënat që do të futen në bazën e të dhënave dhe sistemi për menaxhim me të
dhëna të na mundësojë zgjerimin dhe ndryshimin e tyre.
Baza përbëhet nga disa tabela, mes të cilave janë vendosur relacione të
caktuara. Baza e tillë është quajtur një bazë e të dhënave relacionare.
Në bazë do të figurojnë 2 entitete edhe atë: filma dhe klientë. Prandaj, së
pari duhet të definohen atributet e tyre.
Tek klientët, atribute janë: emri, mbiemri, telefon, e-maili, karta e identitetit
etj.
Te filmat, atribute janë: titulli, zhanri, roli kryesor, formati, viti, gjuha dhe
çmimi.
Menjëherë mund të përcaktohet lloji i fushës dhe tekstuale janë: emri,
mbiemri, adresa, telefoni, e-mail, titulli, zhanri, roli kryesor, formati, gjuha, karta e
identitetit, ndërkohë që numerike janë viti dhe çmimi.
Mund të ndodhë që disa të dhëna në fusha të jenë të njëjta. Që të mos vijë
deri te gabimet e padëshiruara në tabelë shtohet edhe një kolonë me numër
identifikimi. Numrat e identifikimit gjenerohen automatikisht dhe nuk mund të vijë
në caktimin e të njëjtit numër për regjistrime të ndryshme.
Tjetër çka duhet të bëjmë është të lidhim këto dy tabela që të punojë
videotekata/dvdtekata. Puna e saj përfshin huazimin e një filmi një personi - klienti.
Gjatë çdo huazimi duhet të shkruhet klienti, filmi dhe data e huazimit. Gjithashtu,
gjatë kthimit të filmit, ju duhet të shkruani datën e kthimit dhe çmimin që paguhet.
Prandaj është e domosdoshme të krijojmë një tabelë me fusha të cilat do të
përmbajnë këto të dhëna.

Programimi-Delphi
Tabela 7.3. Huazimi
7.2. Çelësi primar, çelësi i jashtëm dhe integriteti i bazës së të dhënave
Në çdo tabelë duhet të ketë së paku një fushë që do të jenë unike për çdo
regjistrim, gjegjësisht përmbajtja e kësaj fushe nuk do të përsëritet në asnjë
regjistrim. Këto zakonisht janë numra identifikues (të dhëna numerike) apo ndonjë
fushë tjetër vlera e të cilës nuk përsëritet (numri i amzës). Fusha e tillë është quajtur
çelës primar i tabelës.
Çelësi primar siguron që të gjitha regjistrimet nga një tabelë të jenë të
lidhura me regjistrimet nga një tabelë tjetër.
Për lidhjen e tabelave ekzistojnë llojet e mëposhtme të relacioneve:
një në një (One-to-One)(1: 1) – ky është relacioni i përdorur më shpesh. Në
të një rreshti nga tabela e parë mund t’i shoqërohen më tepër rreshta nga tabela e
dytë, por një rreshti nga tabela e dytë mund t’i shoqërohet vetëm një rresht nga
tabela e parë. Një klient mund të bëjë më tepër huazime. E njëjta vlen edhe për
filmat - një film mund të huazohet disa herë.
më tepër në më tepër (n:n) – në këtë relacion një rreshti nga tabela e parë
mund t’i shoqërohen më tepër rreshta të caktuar nga tabela e dytë dhe anasjelltas.
Për shembull,, le të kemi tabelë me klasë dhe profesorë. Pasi që në shumë klasë
ligjërojnë të njëjtit profesorë, shumë regjistrime në tabelën me klasë do të
përmbajnë të njëjtit profesor. Gjithashtu, pasi që një profesor ligjëron në më tepër
klasë, shumë regjistrime në tabelën me profesorë do të përmbajë të njëjtën klasë.
Në shembullin e Dvdtekës, tabelat janë të lidhura përmes fushave
ekuivalente, pra fusha që përmbajnë lloj të njëjtë të të dhënave. Fushat nuk është e
thënë të kenë emra të njëjtë. Zakonisht, lidhja vendoset në mes fushës, e cila është
çelësi primar në njërën tabelë (primare), me fushën nga tabela tjetër (sekondare), e
cili korrespondon me atë të tabelës së parë.

Programimi-Delphi
Çelësi i jashtëm (Foreing Key)
Ky është një atribut, që është i njëjtë me vlerën e çelësit primar nga një tjetër
tabelë. Me ndihmën e tij lidhen tabelat njëra me tjetrën.
Relacionet paraqesin një lidhje në mes të tabelave. Në shumicën e rasteve
lidhen, çelësi primar nga një tabelë me çelësin e jashtëm nga tabela tjetër.
Figura 7.1. Relacionet mes tabelave
Integriteti i bazës së të dhënave përbëhet nga një grup rregullash që

sigurojnë rregullsinë e pavarësisë dhe pandryshueshmërisë së gjendjes së bazës së
të dhënave, rifreskim dhe fshirje të të dhënave. Rregulli bazë i integritetit është se
në çdo regjistrim të tabelës sekondare, patjetër të ekzistojë vetëm një regjistrim nga
tabela primare. Ja disa rregulla të integritetit:
1. Nuk është e mundur që të futet regjistrim në tabelën e sekondare, nëse nuk
ka asnjë regjistrim në primaren,
2. Nuk mund të fshihet regjistrim nga tabela primare, në qoftë se ekziston
regjistrim që është i lidhur me tabelën sekondare,
3. Nuk lejohet modifikimi i regjistrimeve në tabelën sekondare nëse për çelësin
e jashtëm nuk ka vlera të përshtatshme në tabelën primare,
4. Nuk mund të ndryshohet vlera e çelësit primar në tabelën primare, derisa ka
regjistrim të lidhur me tabelën sekondare.
Për ata që duan të dinë më shumë
Planifikimi i tabelave
Shikuar teknikisht, duhet vetëm një tabelë për funksionimin e bazës së të dhënave.
Gabim i madh është vendosja e shumë informacion në një tabelë. Në bazat
relacionare të të dhënave mund të punohet me më shumë tabela dhe të vendosen
relacione mes tyre.

Programimi-Delphi
Shembulli 1: Le të supozojmë se duhet të rruhet informacioni për kontakt

me çdo konsumator, në bazë të çdo transaksioni të bërë. Nëse e gjithë kjo ruhet në
një tabelë, duhet të ketë një përsëritje të emrit të konsumatorit, adresës dhe numrit
të telefonit gjatë futjes së çdo transaksioni të ri.
Tabela 7.a.
Nëse konsumatori ka ndryshuar adresën, atëherë ajo do të duhet të
ndryshojë në të gjitha transaksionet.
Mënyrë më e mirë është që çdo konsumatori t’i caktojmë numër identifikimi
(ID) - Shifër. Ai do të përfshihet në tabelën konsumatorët, në të cilën do të jenë
emri, adresa dhe numri i telefonit të konsumatorit. Në tabelën për transaksionet, do
të përfshihej gjithashtu numri ID - i konsumatorit si një ndërlidhje me tabelën e
parë, dhe do të përmblidheshin informacionet për transaksionet.
Tabela 7.b: Konsumatorët
Tabela 7.c.: Transaksionet
Gabimi i dytë i madh është përpjekja për të krijuar tabelë të veçantë për
secilin raport. Në këtë rast, të dhënat përsëriten në më shumë tabela. Kjo është e
panevojshme, sepse edhe në raportet mund të përfshihen informacione nga më
shumë tabela. Kjo do të thotë se është e mjaftueshme që informacioni të ekzistojnë
vetëm në një tabelë.
Shembulli 2: Në një organizatë duhet të rruhen informacionet për atë se
cilët punëtor kanë kryer kurse të veçanta.
Zgjidhja me një tabelë është si vijon:
Tabela 7.ç.

Programimi-Delphi
Nëse një punëtor ka kryer më tepër kurse, patjetër të shtohen regjistrime të

dyfishta në tabelë. Nëse një punëtor e lë kompaninë, të dhënat e tij duhet të
fshihen,me çka mund të humbasin të dhënat për kohëzgjatjen e kursit. (Me.Altin B.
janë të lidhura kurset për Exel dhe Power Point).
Tabela 7.d Tabela me të dhëna të fshira.
Mënyrë më e mirë është krijimi i tabelave të veçanta për të punësuarit, për

kurset dhe kurset e përfunduara, kurse lidhja mes tyre të sigurohet me shifrat-
numrat e identifikimit.
Tabela 7.e. Të punësuarit (Kursistët)
Tabela 7.f. Kurset
Tabela 7.g. Kurset e përfunduara
7.4. Llojet e Bazave të të dhënave

Sa i përket kompleksitetit, ekzistojnë tre lloje të ndryshme të bazave të të
dhënave:
x bazat e të dhënave lokale,
x bazat e të dhënave klient / server dhe
x bazat e të dhënave të shpërndara.

Programimi-Delphi
Bazat lokale të të dhënave paraqesin llojin më të thjeshtë të bazës së të dhënave.

Kjo është një bazë të dhënash e vendosur në një kompjuter. Të gjitha ndryshimet e
të dhënave regjistrohen direkt në bazën e të dhënave. Përfaqësues të bazave të të
dhënave lokale janë Access, dBase dhe Paradoks. Në punën konkrete me baza të të
dhënave do të përdorim bazat e të dhënave lokale.
Lloji i dytë i bazës së të dhënave është klient / server. Në këtë lloj të bazës së të
dhënave baza është e vendosur në një kompjuter të veçantë, i cili quhet server i
bazës së të dhënave (file server) dhe ai administron bazën e të dhënave. Një ose më
shumë përdorues ( lient), mund të kenë qasje në bazën e të dhënave. Përdoruesit
janë shpesh në rrjet, të pavarur nga njëri-tjetri dhe në të njëjtën kohë disa prej tyre
mund të dëshirojnë të hyjnë në bazën e të dhënave. Këtë situatë e zgjidh serveri, i
cili ka ndërtuar mekanizma për zgjidhjen e problemeve të qasjes së njëkohshme në
bazën e të dhënave.
Për shkak të mbrojtjes së të dhënave, përdoruesit nuk kanë qasje direkte në
bazën e të dhënave, por me ndihmën e programeve në kompjuterët lokal. Këto
programe, të cilët quhen programe klient, kujdesen për atë që klientët të respektojnë
rregulla të caktuara dhe të mos ndërmarrin veprime që mund të dëmtojnë bazën e të
dhënave.
Lloj i posaçëm i bazës së të dhënave klientit / server janë bazat e të dhënave të
shpërndara.
7.4. Organizimi i lidhjeve me bazën e të dhënave
7.4.1. Teknologjia BDE (Borland Database Engine)
Që të ju mundësojë qasje në bazat e të dhënave, Delphi shfrytëzon

teknologjinë BDE. Kjo është një përmbledhje e programeve shërbyese të cilët
mundësojnë qasje në baza të ndryshme të të dhënave. Mënyra e komunikimit të
aplikacionit me bazën e të dhënave është paraqitur në figurën 7.1.
Formatet e bazave të prodhuesve të ndryshëm janë të ndryshme, prandaj
BDE rekomandohet me një grup drajverësh të cilët u mundësojnë programeve të
komunikojnë me lloje të ndryshme të të dhënave. Këto drajver i përkthejnë
komandat deri tek baza e të dhënave në komanda specifike për llojin e bazës së të
dhënave. Të gjitha versionet e Delphi kanë një drajver i cili mbështet qasjen në
bazat e të dhënave të Paradoks dhe dBASE. Ky drajver quhet STANDARD dhe
siguron gjithçka që është e domosdoshme për të punuar me këto lloje të bazave.
Aplikacioni
BDE
Baza e të dhënave
Figura 7.1.

Programimi-Delphi
Për qasje korrekte në bazën e të dhënave BDE përdorur alias (alias). Ajo
është një grup i parametrave që përshkruajnë mënyrën e lidhjes me bazën e të
dhënave. Alias i tregon BDE, cilin drajver të përdor dhe ku gjinden në disk
datotekat me bazën e të dhënave.
Numri më i madh i komponentëve për punë me bazën e të dhënave gjinden
në faqet BDE, Data Access dhe DataControl. Komponetet për punë me bazën e të
dhënave mund të ndahet në jo vizuale dhe vizuale. Komponentët jo vizuale sigurojë
qasje në bazën e të dhënave, pra në të dhënat në bazën e të dhënave. Komponentët
vizuale lejojë veprim me të dhënat (pamje, ndryshim...). Komponenti jo vizuale më
shpesh e përdorur është Table. Komponentët vizuale të përdorura më shpesh janë
DBEdit, DBListBox, DBGrid, DBNavigator dhe të tjerë. Për komunikimin e
komponentëve jo vizuale dhe vizuale shfrytëzohet komponenti jo vizuale
DataSource.
Komponentet
vizuale
DataSource
Komponentet
jovizuale
Baza e të
dhënave
Figura 7.2.
Në punën me bazat e të dhënave përdoret termi DataSet. Ajo është një grup i
të dhënave në të cilat mund të arrihet në bazë të informatave të përfshira në bazën e
të dhënave. Të dhënat nga DataSet nuk është e domosdoshme t’i përkasin një
tabele.

Programimi-Delphi
7.4.2. Krijimi i një bazë të dhënash duke përdorur programin

DatabaseDesktop
Para se të formohet baza duhet të bëhet alias për bazën adekuate.
Figura 7.3
x Startohet programi BDE Administrator, përmes Start-> Borland Delphi7 ->

BDE Administrator.
x Në dritare zgjedhim kartelën Database, kurse nga menyja zgjidhet Objects->
New.
Figura 7.4.

Programimi-Delphi
x Programi ofron për shfrytëzim drajverin STANDARD për formimin e

aliasve,
x Shënojmë emrin për aliasin e ri- Biblioteka dhe shtegun (PATH) ku do të
rruhet, siç është treguar në figurën 7.5.
Figura 7.5.
x Kthehemi në Delfi.
Delphi ofron mundësinë e krijimit të tabelave duke përdorur meny:
-Tools-> Database desktop
-File-New-Table (tip PARADOX),
- Pastaj dizajnohet tabela. Për çdo fushë definohet emri, lloji,
madhësia dhe çelësi.
- Struktura e tabelës rruhet me Save As.
- Tabela plotësohet përmes Delphi Tools-> DatabaseDesktop.
Figura 7.6.

Programimi-Delphi
Në opsionin File-> New-> Table krijojmë tabelën. Fusim emrat e fushave, llojin e
tyre, madhësinë dhe çelësin.
Figura 7.7.
Struktura e tabelës Shkrimtarët e cila formohet ka formën e mëposhtme:
Figura 7.8.

Programimi-Delphi
Ajo rruhet në Save As si Shkrimtarët.

Plotësohet gjersa hapet në Database Desktop, dhe pastaj nga menyja Table-
>Edit.
Figura 7.9.
E mbushur dhe e dizajnuar, tabela Shkrimtarët do të ketë pamjen si në

figurën 10.7.
Figura 7.10.

Programimi-Delphi
Në mënyrë të ngjashme formohet tabela Libra pamja e të cilës është

paraqitur në figurën 7.11.
Figura 7.11.
Me këtë në Delphi krijuam bazë të,,gjallë,, të dhënave e cila mund të

përdoret për qëllime të ndryshme.
7.5. Projektimi i aplikacioneve për punë me bazë të të dhënave

duke përdorur magjistarin
Të dhënat nga bazat e të dhënave ekzistuese mund të përdoren pa përdorimin

e komponentëve për të punuar me bazat e të dhënave. Delphi në opsionin Database
ka komandën Form Wizard, me ndihmën e së cilës mund të bëhet një formë për të
futur të dhëna në bazën e të dhënave.
x Me aktivizimin e Urdhrit Form Wizard fitohet dritarja-dialoguese si në
figurën 7.12.
Figura 7.12.

Programimi-Delphi
Në këtë dialog - dritare përcaktohet lloji i bazës të të dhënave dhe llojin i

DataSet që do të shfrytëzohet. Në punën tonë kemi zgjedhur
- Create a simple form
- Create a form using Ttable objects
x Në dritaren-dialoguese në vijim, që është treguar në figurën 7.13.
mundësohet zgjedhja e tabelës që do të përdoret duke u bazuar në drajverin
dhe aliasin adekuat. Duhet të gjenden në ComboBox, aliasi - Biblioteka, dhe
pastaj duhet të zgjedhim tabelën Shkrimtarët.db.
Figura 7.13.
x Në dritaren e tretë dialoguese (figura 7.14.) duhet të zgjidhen fushat nga

tabela e zgjedhur do të paraqiten në formë. Fushat mund të barten një nga
një (>) apo të gjitha përnjëherë (>>). Për punën e mëtejshme do të
transferojmë të gjitha fushat nga lista e majtë në të djathtë.

Programimi-Delphi
Figura 7.14.
x Pastaj zgjidhet radhitja e komponentëve: horizontale, vertikale apo në

formën e një rrjeti (Fig. 7.15.). Ne do të zgjedhin shtrirjen vertikale
Figura 7.15.
x Zgjidhet pozita e përshkrimeve (etiketave) për fushat në kuadër të çdo

komponentë. Ato mund të vendosen në të majtë ose sipër komponentëve.

Programimi-Delphi
Figura 7.16.
x Në dritaren vijuese mund të zgjedhim krijimin vetëm të formës apo të

formës dhe moduleve për të dhënat.
o Zgjidhet opsioni Form only.
Figura 7.17.
Pas klikimit në butonin Finish fitohet forma vijuese:

Programimi-Delphi
Figura 7.18.
Me klikim në butonin Run fitohet forma, në këndin e sipërm të së cilës

ndodhet komponeta për lëvizje në tabelën e bazës së të dhënave- DBNavigator. Me
ndihmën e kësaj komponentë mund të shihet tabela Shkrimtarët, gjithashtu mund të
ndryshohen të dhënat. Ndryshimet pranohen nëse aktivizohet butoni për regjistrim
ose nëse kalohet në regjistrimin tjetër, kurse nuk pranohen nëse selektohet butoni
për anulimin e ndryshimeve (X).
Figura 7.19.

Programimi-Delphi
7.6. Komponentët për lidhje me bazën e të dhënave
7.6.1. Komponentët për lidhje me tabelën e bazës së të dhënave
Komponentët për punë me bazat e të dhënave, gjinden në faqet BDE, Data

Access dhe Data Controls të rreshtit të komponentëve. Ato funksionojnë si vizuale
dhe jo vizuale. Që të mund Delphi të komunikojë me bazën e të dhënave në formë
elementare, është e nevojshme të përdoren këto tre komponentë:
1. Table
2. DataSource
3. DBGrid
Komponenti Tabela ndodhet në faqen Data Access. Ajo siguron qasje më të
shpejtë dhe më të thjeshtë deri te tabelat e bazës së të dhënave. Ajo është e
mjaftueshme për të punuar me bazat lokale të të dhënave.
Komponenti DataSource, gjithashtu gjendet në faqen Data Access. Kjo

komponentë siguron mekanizëm të lidhjes së komponentë jo vizuale (Table,..) me
komponentët vizuale të cilat shfaqin të dhëna (DBGrid,...). Të gjithë komponentët
që punojnë me të dhënat që janë të vendosura në formë, janë të lidhur përmes
DataSource me shumicën e të dhënave - DataSet.
Komponenti DBGrid mundëson shfaqjen e DataSet në formë tabelore.

Me ndihmën e komponentëve të cekura, në formë mund të shfaqim të dhëna
nga ndonjë tabelë nga baza e të dhënave. Procedura për këtë është si vijon:
1. Duhet të startohet aplikacion i ri dhe në formë të vendoset komponenti
Table.
2. Në ObjectInspector, vetia DatabaseName duhet të vendoset në vlerën
Biblioteka.
3. Në vetinë TableName zgjedhim tabelën Shkrimtarët, që do të thotë se do të
punojmë me tabelën shkrimtarët.
4. Në formë vendoset komponenti DataSource dhe për vetinë e saj DataSet
zgjedhim Tabela1. Me këtë procedurë burimi i të dhënave është e lidhur me
DataSet.
5. Hapi i ardhshëm është vendosja e komponentit DBGrid në formë. Vetia
DataSource e kësaj komponentë duhet vendosur në vlerën DataSource1. Me
këtë procedurë, rrjeti lidhet me burim e të dhënave, dhe në mënyrë indirekte
me DataSet.
6. Më në fund komponentit Table e cila është në formë, duhet t’i ndërrohet
vetia Active në vlerën True. Me këtë mundësohet shfaqja e të dhënave nga
tabela Shkrimtarët në kontrollën DBGrid.
Pamja e formës që do të fitohet është paraqitur në figurën 7.20. Me startimin e
këtij aplikacioni fitohet dritare punuese 7.21.. Në këtë tabelë mund të kemi qasje në
çdo të dhënë. Vlerat në fushë mund të ndryshohen, por pas përfundimit të punës së
aplikacionit ndryshimet nuk do të rruhen në tabelë. Për të mundësuar përpunimin e
të dhënave në bazën e të dhënave, është e nevojshme të vendoset një tjetër
komponentë në formë që siguron manipulimin e nevojshëm me të dhënat.

Programimi-Delphi
Figura 7.20.
Figura 7.21.

Programimi-Delphi
Komponenti DBNavigator i mundëson përdoruesit kontrollin mbi operacionet

të shkruarit, fshirjen, ndryshimin dhe lëvizjen nëpër regjistrimet e bazës së të
dhënave. Navigator zakonisht përdoret me komponetet tjera për të komunikuar me
bazën e të dhënave (Table, DataSource, DBGrid,...). Komponenti DBNavigator ka
pamjen e mëposhtme.
I pari I ardhshëm Fut Rregullo Anulo

First Next Insert Edit Cancel
Prior Last Delete Post Refresh

Paraprak I fundit Fshi Verifiko Rifresko
DBNavigator përmban dhjetë butonat me funksionet e mëposhtme:

x Butoni First mundëson kalimin në regjistrimin e parë në tabelë,
x Butoni Prior mundëson zhvendosjen e treguesit (kursorit) për një regjistrim
prapa,
x Butoni Next mundëson zhvendosjen e kursorit për një regjistrimin përpara,
x Butoni Last mundëson zhvendosjen e kursorin në regjistrimin e fundit,
x Butoni Insert mundëson futjen e regjistrimit në tabelë,
x Butoni Delete fshin regjistrimin nga tabela në adresën ku ndodhet kursori,
x Butoni Edit mundëson ndryshimin e përmbajtjes së fushës,
x Butoni Post kryen ruajtjen e përmbajtjes së regjistrimit në bazën e të
dhënave,
x Butoni Cancel anulon ndryshimet e bëra në regjistrime,
x Butoni Refresh freskon të dhënat e komponentëve për punë me bazën.
Pas vendosjes së komponentit DBNavigator në formës, fitohet pamje e re e
formës, e cila është treguar në figurën 7.22. Me startimin e aplikacionit, fitohet
dritare e re e punës, në të cilën mund të përdoren butonat e cekur nga DBNavigator.

Programimi-Delphi
Figura 7.22.
7.6.2. Komponentë për të shfaqur dhe ndryshuar të dhënat në bazën e të

dhënave
Përveç komponentëve të përmendura më parë, ka shumë komponentë të tjera

që mund të përdoret në punën me bazën e të dhënave. Shumë prej tyre vijnë nga
komponentët tashmë të përpunuara në faqen Standard. Ndryshojnë me atë që kanë
prefiks DB, që shpien në atë se këto komponentë posedojnë mekanizma për
komunikim automatik me komponentët për qasje në bazat e të dhënave. Ky
komunikim arrihet përmes komponentës DataSource. Kur komponenti është e
lidhur me burimin e të dhënave, gjegjësisht kur janë vendosur vetitë e saj
DataSource dhe DataField, të dhënat shfaqen automatikisht në të.
Ka veti të cilat janë të përbashkëta për të gjithë komponentët për punë me
bazat e të dhënave: DataSource, DataField dhe ReadOnly. Komponentët DBGrid
dhe DBNavigator nuk kanë veti DataField, sepse këto komponentë kryejnë
operacione mbi gjithë regjistrimet.
Në vetinë DataSource shtohet emri i komponentit DataSource me të cilën
lidhet kjo komponentë.
Vetia DataField siguron fushën përmbajtja e së cilës do të shfaqet në
komponentë.
Me vendosjen e vlerës së vetisë ReadOnly në vlerën True, i mundësohet
përdoruesit të ndryshojë përmbajtjen e komponentit, dhe me këtë edhe përmbajtjen
e fushës.

Programimi-Delphi
Komponenti DBText përdoret për të shfaqur përmbajtjen e fushës nga tabela.

Nuk ka mundësi të ndryshohet përmbajtja e saj.
Si edhe komponenti Edit, komponenti DBEdit mund të shfaq të dhënën me

mundësinë e ndryshimit të saj nga ana e përdoruesit. Kur do të lidhen me
DataSource, do të shfaqen të dhëna nga një fushë e caktuar e regjistrimit momental
në tabelë. Nëse tabela lejon korrigjimin (vlera e vetisë CanModify e komponentit
DataSource është True), atëherë përdoruesit mund të ndryshojë të dhënën.
Ndryshimi regjistrohet në tabelë kur do të thirret metoda Post në komponentin
Table.
DBMemo është komponentë e cila përdoret për të shfaqur përmbajtjen e

fushës e cila mund të ndryshohet. Ajo ka veti si komponenti standarde Memo, e cila
mund të shfaq dhe ndryshojë tekstin në më shumë rreshta. Vetia AutoDisplay
kontrollon nëse të dhënat nga DataSet shfaqen automatikisht (True) ose jo (False).
DBImage – siguron shfaqjen e imazhit nga baza e të dhënave. Komponenti

mundëson shfaqjen e imazhit kur do të kërkojë shfrytëzuesi, me vendosjen e vetive
përkatëse apo në mënyrë programore.
Në shembullin e mëparshëm me baza formuam alias Biblioteka dhe dy

tabela – shkrimtarët dhe libra. Këto dy tabela mund të lidhen në marrëdhënie: një
për më shumë. Lidhje të përshtatshme mund të realizojmë duke përdorur
magjistarin si vijon:
1. Nga manyja startojmë: Database-> FormWizard. Në dritaren-dialoguese të parë,
në pjesën për krijimin e formës zgjedhim opsionin e dytë Create a master/ detail
form.
2. Hapi tjetër është zgjedhja e tabelës primare (master). Për këtë qëllim së pari
zgjedhim alias-> Biblioteka, nga dritarja për tabela tabelën libra, dhe pastaj
Next.
3. Zgjedhim fushat Shifra_K, Shifra_Sh dhe Titulli dhe i shtojmë në dritaren
OrderedSelectedFields, dhe pastaj klikojmë Next.
4. Zgjedhim paraqitjen horizontale të komponentëve
5. Zgjedhim tabelën sekondare (detail), kurse ajo është tabela Shkrimtarët.
6. I bartim fushat Shifra_Sh, Emri dhe Mbiemri në dritaren
OrderedSelectedFields, dhe pastaj klikojmë në Next.
7. E zgjedhim opsionin e vendosjes së komponentëve në rrjetë (In a grid).

Programimi-Delphi
Figura 7.23.
8. Në figurë shohim se në dritaret Detail Fields dhe Master Field gjinden vetëm dy
fusha të njëjta. I shënojmë të dy fushat. Mes tyre paraqitet butoni Add, dhe pas
klikimit në të, në dritaren e poshtme Joined Fields paraqiten Shifra_Sh->
Shifra_Sh, që do të thotë se tabelat janë të lidhura sipas fushës Shifra_Sh.
9. Duhet të zgjedhim Generate a main form dhe -> Finish.
Figura 7.24.
Pas hapit të nëntë paraqitet dritarja si në figurën 7.25.

Programimi-Delphi
Figura 7.25.
Nga figura shohim se magjistari ka vendosur të gjitha komponentët e

nevojshme për aplikacionin (Table, DataSource, Label, DBEdit, DBNavigator,
DBGrid).
Pas startimit të aplikacionit fitohet dritare si në figurën 7.26.
Figura 7.26.
Duke përdorur butonin DBNavigator mund të lëvizim nëpër tabelën primare

me çka tregohen edhe fushat e zgjedhura nga tabela sekondare.
Në Delphi ka baza të cilat ai i instalon. Shembulli i mëposhtëm është për një
bazë të tillë të dhënash. Përdorim alias DBDEMOS dhe tabelën ANIMALS.DB.

Programimi-Delphi
Aplikacioni do të shfaq tabelën regjistrim pas regjistrimi. Atë do ta formojnë

në hapat e mëposhtëm:
1. Nisim aplikacion të ri dhe në formë vendoset komponenti Table. Në tabelën
e figurës së mëposhtme janë dhënë vetitë që duhet të ndryshojnë për
komponetët e këtij aplikacioni.
2. Në tabelë vendosim komponentët DataSource dhe në ObjectInspector
përcaktohen vlerat nga tabela.
Emri i Vetia Vlera

komponentit
Form1 Name Forma1
Caption FORMA
Table DataBaseName DBDEMOS
TableName Animals.dbf
DataSource DataSet Table1
DBNavigator DataSource DtaSource1
DBEdit1 Name DBEmri
DataSource DtaSource1
DataField EMRI
Labela 1 Name Përshkrimi1
Caption EMRI
DBEdit2 Name DBZona
DataField ZONA
Caption ZONA
DBEdit3 Name DBPesha
DataField PESHA
Caption PESHA
DBEdit4 Name DBMadhësia
DataField MADHËSIA
Caption MADHËSIA
DBImage Name BMPImage
DataSource DataSource1
DataField BMP
Caption IMAZHI
3. Vendoset komponenti DBNavigator (majtas lart)

4. Në pjesën e majtë janë vendosur 4 komponentët DBEdit nga faqja
DataControls.
5. Mbi çdo komponentë Edit vendosen komponentë Labela.
6. Pasi që tabela regjistrimet e së cilës i tregojmë përmban edhe imazhe, në
formën tonë duhet të shtojmë komponentë me të cilën do të tregojmë
imazhin. Kjo është komponenti DBImage, dhe mbi të është vendosur etiketa.
Forma e aplikacionit do të ketë formën e mëposhtme (Figura 7.27).

Programimi-Delphi
Figura 7.27.
Para se të startohet aplikacioni duhet që për komponentin Table të

ndryshohet vetia Active në vlerën True. Përmes butonave të DBNavigator
lëvizim nëpër regjistrimet e bazës DBDEMOS.
Figura 7.28.

Programimi-Delphi
7.6.3. Filtrim të dhënave
Operacion i cili përdoret shpesh kur punojmë me baza të të dhënave është shfaqja
e të dhënat që plotësojnë kushte të caktuara. Ky operacion është quajtur filtrim.
Shembullin e filtrimit mund ta shpjegojmë tek tabelat në bazën e të dhënave
për nxënësit. Le të jenë në një tabelë emrat e nxënësve të një klase, të dhënat bazë
dhe notat e tyre. Për raportin në nivel të shkollës kërkohen të dhëna për numrin e
nxënësve me sukses pozitiv, sukses negativ dhe numri i mungesave me arsye dhe
pa arsye. Për të mundësuar marrjen e DataSet vetëm me të dhënat e kërkuara
përdoret filtrimi.
Për komponentin Table në ObjectInspector ekzistojnë dy veti: Filtered dhe
Filter të cilat mundësojnë shfaqen e të dhënave të dëshiruara nga tabela. Vetia
Filtered përcakton nëse tabela është e filtruar apo jo. Nëse vetia ka vlerën Trues,
tabela do të filtrohet. Kriteri me të cilin bëhet filtrimi jepet në vetinë Filter. Vlera e
kësaj vetie përbëhet nga emri i fushës, operatori logjik dhe vlera. Gjatë filtrimit
vlejnë rregullat e mëposhtme:
1. Emrat dhe fushat e operatorëve logjik mund të përshkruhen me shkronja të
vogla dhe të mëdha.
2. Kur filtrohet tekst, vetia FilterOptions definon nëse do t’u kushtojmë
kujdes shkronjave të vogla dhe të mëdha.
Filtri mund të ketë pamjen e mëposhtme:
Emri= 'Naim'
Mbiemri= 'Frashëri' and VitiL> '1 / 1 / 68 '
Mbiemri= 'FRASHËRI' AND VITI_L> '1 / 1 / 68 '
Filtri i parë mundëson shfaqjen e të gjitha regjistrimeve të cilët në fushën Emri
kanë vlerën Naim. Dy shembujt e tjerë për rezultat kanë vlerë të njëjtë, derisa në
vetinë FilterOptions nuk kërkohet që shkronjat e vogla dhe të mëdha të dallohen.
Në tabelën e mëposhtme tregohen shprehje logjike që mund të përdoren
gjatë filtrimit.
Operatori Kuptimi
> Më i madh se
< Më i vogël se
= I barabartë
<> I ndryshëm
<= Më i vogël ose i barabartë
>= Më i madh ose i barabartë
() Përdoret për ndryshimin e radhitjes së ekzekutimit
{} Përdoret për regjistrimin e emrave të fushave të cilat
përmbajnë boshllëqe
AND,OR,NO Operatorë logjik
T
Shembull filtrimi
1. Të startohet aplikacion i ri dhe në formë të vendoset komponenti Table.
Vetia Active vendoset në vlerën True. DatabaseName e vendosim në alias
Biblioteka. Nga Baza e të dhënave zgjedhim emrin TableName Libra.
2. E vendosim komponentin DataSource në formë. Vetinë e saj DataSet e
vendosim në vlerën DataSource1.

Programimi-Delphi
3. Në formë vendosim komponentë DBGrid, kurse në vetinë e saj DataSource

i japim vlerën DataSource1.
Figura 7.29.
Në këtë moment forma do të ketë formën si në figurën 7.29.

4. Hapat e mëposhtëm mundësojnë filtrimin e Table, në vetinë Filter duhet të
futet Titulli='Këngët'
5. Në të njëjtën komponentë, vlera e vetisë Filtered të vendoset në True.
DataSet-i i fituar do të duket si në Figurën 7.30.
Figura 7.30.
Në qoftë se në fushën Filter shkruajmë Botues='Toena', do të marrim

DataSet si në figurën 7.31.

Programimi-Delphi
Figura 7.31.
Përpunimi i tabelës nga programi
Deri tek të dhënat e tabelës mund të arrihen edhe nga programi. Kur komponenti
Table është krijuar dhe tabela është e hapur, aktiv është vetëm një regjistrim i tabelës.
Qasja është e mundur vetëm në fushat e regjistrimit aktiv. Pas hapjes së tabelës aktiv
është vetëm regjistrimi i parë. Kalimi në tjetrin, të mëparshmin, të parin apo të fundit
kryhet me ndihmën e metodave Next, Prior, First ose Last.
Për të treguar lëvizjen nëpër tabelë duke përdorur kodin e programit, e
formojmë aplikacionin i cila nga tabela e të dhënave Shkrimtarët do të shfaq
përmbajtjet e fushave të regjistrimeve të cilave u qasemi me metodat e cekura.
Forma e ka formën e treguar në figurën 7.32.
Figura 7.32.
Për çdo buton është definuar ngjarje OnClick kodet programore të të cilave janë
paraqitur në listingun e mëposhtëm.

Programimi-Delphi

begin
end;

begin
Table1.active:=true;
Table1.first;
DBShifra.Text:=Table1.Fields[0].Value;
DBEmri.Text:=Table1.Fields[1].Value;
DBMbiemri.Text:=Table1.Fields[2].Value;
DBViti.Text:=Table1.Fields[3].Value;
DBShteti.Text:=Table1.Fields[4].Value;
end;

begin
Table1.last;
end;

begin
Table1.next;
end;

begin
Table1.prior;
end;
end.

Programimi-Delphi
Figura 7.33.
Gjatë ekzekutimit të programit do të shfaqet dritarja nga Figura 7.33.

Në kodin e programit kemi katër pjesë të ngjashme. Çdo seksion përcakton
ngjarjen për metodën përkatëse të lëvizjes nëpër tabelë. Në formë është vendosur
tabela dhe DataSource përkatëse. Tabelën në program mund ta hapim me vendosjen
e metodës Active në vlerën True ose duke thirrur metodën Open. Shkrimet në kodin
e programit
Table1.Active:=True;
Table1.Open
kanë të njëjtin kuptim. Nëse në aplikacion nuk ndryshohen vetitë TableName dhe
DatabaseName, nuk është e domosdoshme të përdoret metoda për mbylljen e
tabelës së hapur, pasi që kjo ndodh automatikisht në fund të punës së aplikacionit.
Për ndryshe, tabela aktiv duhet të mbyllet duke përdorur një nga metodat e
mëposhtme:
Table1.Active:=False;
Table1.Close.
Përshkrimi Table1.Prior mundëson qasje në regjistrimin paraprak në krahasim me
momentalin. Ngjashëm, përshkrimi Table1.Next ofron qasje në regjistrimin e
ardhshme, Table1.Last në qasje në regjistrimin e fundit dhe Table1.First qasje në
regjistrimin e parë në tabelën me të dhëna.
Rreshtat programor:
sigurojnë qasje në vlerat e fushave të regjistrimit aktiv nga tabela e bazës së të
dhënave dhe shfaqjen e përmbajtjes së tyre në komponentët përkatëse DBEdit.
Vërejmë se fusha të cilës i qasemi është e shënuar me pozitën, gjegjësisht numrin
rendor në regjistrim. Fusha e parë ka numër rendor zero (0).

Programimi-Delphi
Pasi të startohet aplikacioni, fitohet një dritare punuese si në figurën 7.33.

Përveç këtyre mundësive të lëvizjes nëpër tabelë, Delphi mundëson
zhvendosjen për numër të caktuar të regjistrimeve në raport me regjistrimin
momental.
Shembull 1: Të bëhet aplikacion i cili në bazën e të dhënave Biblioteka,
duke shfrytëzuar tabelën Shkrimtarët.DB, do të mundësojë kalimin për numër të
caktuar të regjistrimeve në raport me numrin momental të regjistrimit dhe do të
njoftojë përdoruesit kur të arrihet në regjistrimin e parë ose të fundit në tabelë.
Forma e aplikacionit të mësipërm do të ketë formën e treguar në figurën 7.34.
Figura 7.34.
Kodi i programit me të cilin është realizuar aplikacioni është si vijon:

Procedure TForm1.FormCreate(Sender: TObject);
begin
Table1.open;
end;
Në këtë aplikacion për dallim nga ai përpara, tabela hapet në
momentin e krijimit të formës.
Var
n,i:Integer;
begin
Val(Nr.text,n,i);
ifundit.text:=' ';
Table1.MoveBy(n);

Programimi-Delphi
if (table1.eof) or (table1.Bof) then
Ifundit.text:='Nuk ka më regjistrime';
end;
begin
end;
end.
Rreshti i programit Table1.MoveBy(n); mundëson kërcimin në regjistrimin
e larguar për N regjistrime nga ai momental. Nëse N është me parashenjë negative,
lëvizja bëhet kah regjistrimi i parë.
Rreshti tjetër i programit përmban Urdhrin e mëposhtëm:
if (table1.eof) or (table1.Bof) then
Ifundit.text:='Nuk ka më regjistrime';
ku përdoren vetitë Bof dhe Eof që mundësojnë kontrollin e aktivizimit të
regjistrimit të parë ose të fundit të tabelës. Vetitë Bof dhe Eof kanë vlerë True nëse
regjistrimi momental është i pari, gjegjësisht i fundit.
Figura 7.35.
Në Delphi kemi mundësi drejtpërdrejtë t’u qasemi regjistrimeve përmes

fushave dhe vlerave të fushave (një ose më shumë fusha). Për këtë qëllim përdoret
metoda Locate. Kjo metodë e gjen regjistrimin e parë që plotëson kushte e
vendosura. Nëse në tabelën tonë Shkrimtarët, ne duam të gjejmë regjistrimin i cili
në fushën Emri ka përmbajtje Ismail (Kadare), duhet të bëhet programi në vijim,
kurse pamja e formës është treguar në figurën 7.36.

Programimi-Delphi
Figura 7.36.
Kodi i programit është si vijon:

begin
Table1.Active:=true;
end;
Var
O:TLocateOptions;
begin
If Table1.Locate('Emri','Ismail',O) then
begin
end
else MessageBox(Handle,'Regjistrimi nuk është
gjetur','Message',MB_OK);
end;
begin
end; end.

Programimi-Delphi
Në kod vërejmë deklarimin e variablës O, si një lloj të veçantë të ndryshores

të llojit TlocateOptions, e cila është e nevojshme për ekzekutimin e metodës
Locate. Në qoftë se regjistrimi është gjetur në tabelë, metoda Locate kthen vlerën
True e cila përdoret në Urdhrin e kushtëzuar If.
Pas startimit të aplikacionit fitohet dritare si në figurën 7.37.
Figura 7.37.
Nëse në rreshtin e programit If Table1.Locate('Emri', 'Ismail', O) atëherë, të

dhënën shenjë "Ismail" e zëvendësojmë me 'Isa', do të marrim përgjigjen vijuese
aplikacionit:
Figura 7.38.
Për të ndryshuar fushën në regjistrimin e tabelës, është e nevojshme së pari

të vendosim kursorin në regjistrimin fushën e të cilit duam të ndryshojmë, dhe
pastaj të thirret metoda për ndryshimin Edit. Në aplikacionin në vijim në tabelën
Shkrimtarët.DB do të ndryshojmë emrin Ismail në Isa.
Pamja e formës është paraqitur në figurën 7.39.

Programimi-Delphi
Figura 7.39.
Kodi i programit për këtë aplikacion është si vijon:

Var
s:String;
O:TLocateOptions;
begin
s:=Emri1.text;
Table1.Locate('Emri',s,O);
table1.edit;
table1.Fields[1].value:='Stiven';
end;
begin
end;
Urdhrat
s:=Emri1.text;
Table1.Locate('Emri',s,O);
na mundësojnë të gjejmë regjistrimin, fusha e së cilës ndryshohet, në bazë të vlerës
së dhënë për Emri në kontrollin Edit. Pastaj aplikohet metoda Edit dhe jepet
përmbajtja e re në fushën e cila duhet të ndryshohet.
table1.edit;
table1.Fields[1].value:='Stiven';

Programimi-Delphi
Pasi të kemi ekzekutuar aplikacionin, fitohet një dritare si në figurën 7.40.
Figura 7.40.
Shembull: Nëse duam të fusim regjistrim të ri në tabelë, atëherë duhet të

përdorim metodën Insert. Aplikacioni i cili fut regjistrime në tabelë mund të ketë
pamjen e formës si në figurën 7.41.
Figura 7.41.
Kodi i programit me të cilin realizohet operacioni i futjes së regjistrimeve në

tabelën Shkrimtarët është si vijon:
Var t:String;
begin
With Table1 do
begin
Insert;

Programimi-Delphi
FieldByName('Shifra_Sh').AsInteger:=22;
FieldByName('Emri').AsString:='Ndre';
FieldByName('Mbiemri').AsString:='Mjeda';
FieldByName('Viti_L').AsString:='1866';
FieldByName('Shteti').AsString:='Shqipëri';
end;
t:=inputBox('KUJDES','A doni të funi regjistrim?','Jo');
if t='Po'
then Table1.Post else Table1.Cancel;
end;
begin
table1.open;
end;
Në këtë kod programor vërejmë një mënyrë të re për t`ju qasur tabelës, si
dhe fushave të tabelës. Ajo mundësohet duke përdorur komandën:
With Table1 do.
Mënyra e re për t`ju qasur fushave të tabelës realizohet duke u bazuar në

emrin e fushës të regjistrimit në vend të përdorimit të numrit rendor të fushës së
regjistrimit.
Dritarja që fitohet kur aplikacioni ekzekutohet është paraqitur në figurën 7.42.
Figura 7.42.
Në punën me bazat e të dhënave shpesh është e nevojshme të fshihen

regjistrime të caktuara nga tabela aktive. Për këtë qëllim përdoret metoda Delete.
Së pari regjistrimi që fshihet deklarohet aktiv, dhe pastaj aktivizohet metoda
Delete. Aplikacioni i fshin regjistrimin e futur në shembullin e mësipërm, mund të
ketë formën e treguar në figurën 7.43.

Programimi-Delphi
Figura 7.43.
Siç shihet, aplikacioni është pasuruar me mundësinë për të shfaqur

regjistrimin i cili do të fshihet. Kodi i programit i këtij aplikacioni është si më
poshtë:
Var
t:String;
begin
With Table1 do
begin
SetKey;
FieldByName('Shifra_Sh').AsInteger:=22;
GoToNearest;
DBEdit1.text:= FieldByName('Shifra_Sh').AsString;
DBEdit2.text:= FieldByName('Emri').AsString;
DBEdit3.text:= FieldByName('Mbiemri').AsString;
DBEdit4.text:= FieldByName('Viti_L').AsString;
DBEdit5.text:= FieldByName('Shteti').AsString;
end;
t:=inputBox('KUJDES','Doni të fshini regjistrimin?','Jo');
if t='Po' then Table1.Delete
else Table1.Cancel;
end;
begin
end;
begin
table1.open;
end; end.

Programimi-Delphi
Në këtë kod programor përdoren tre metoda të reja:

Metoda SetKey mundëson vendosjen e çelësit në tabelën aktive.
Metoda e dytë GoToNearest, lokalizon regjistrimin në tabelë vlera e të cilit
është më e afërt me vlerën e përcaktuar në Urdhrin mbi metodën GoToNearest.
Metoda e tretë është Delete dhe kjo realizon fshirjen e regjistrimi në tabelë.
Kjo metodë duhet të përdoret me kujdes, sepse me aplikimin e saj të dhënat
humben pakthyeshëm.

Programimi-Delphi
KAPITULLI 7
(SHKURT)
Me grupimin e të dhënave të përafërta në forma të përshtatshme për
përdorim, rezultojnë bazat e të dhënave. Karakteristikat bazë të bazave të të
dhënave relacionale është se informacionet janë ndarë në grupe logjike të të
dhënave të cilat janë të vendosura në tabela. Tabelat janë objekte themelore të
bazave të të dhënave relacionale.
Sasia më e vogël e informacionit në tabelë është një fushë - kolonë.
Shuma e të gjitha fushave në një rresht të tabelës është quajtur një
regjistrim.
Që të lidhen tabelat në bazën e të dhënave, tabela referente patjetër të ketë
çelës primar. Kjo është një fushë (ose grup i fushave) që përcakton në mënyrë
unike çdo regjistrim në tabelë. Dy regjistrime në tabelë nuk mund të kenë të njëjtën
vlerë në fushën e çelësit primar. Çelësi primar siguron që të gjitha regjistrimet
nga njëra tabelë të jetë të lidhur me të dhënat nga një tabelë tjetër. Në tabelën
sekondare fusha me të cilën realizohet lidhja, quhet çelës i jashtëm dhe nuk është e
thënë të përmbajnë një vlerë të vetme.
Indeksi është fushë që përdoret për renditjen logjike të regjistrimeve në
tabelë.
Që të lejojë qasje në bazat e të dhënave, Delphi përdor teknologjinë BDE
(Borland Database Engine). Ajo është një grup i programeve shërbyese që lejojnë
qasje në baza të ndryshme të të dhënave.
Të gjitha versionet e Delphi-t kanë një driver i cili mbështet qasjen në bazat
e të dhënave Paradox dhe dBase.
Për qasje korrekte deri në bazën e të dhënave BDE përdorur alias (alias).
Ajo është një grup i parametrave që përshkruan mënyrat e lidhjes me bazën e të
dhënave. Alias i tregon BDE cilin drajver të përdor dhe ku gjendet datoteka në disk
me bazën e të dhënave.
Komponentët për punë me bazat e të dhënave mund të ndahet në jo vizuale
dhe vizuale.
Krijimi i bazës së të dhënave duke përdorur programin

DatabaseDesktop:
- formohet alias,
- krijohet tabela,
- Plotësohet tabela.
Projektimi i aplikacioneve për punë me bazat e të dhënave duke
përdorur magjistarin.
Komponentët për lidhje me tabelën e bazës së të dhënave

Table
DataSource
DBGrid
Komponenti DBNavigator i lejon përdoruesit kontrollin mbi operacionet të
shkruarit, fshirjen, ndryshimet dhe lëvizjen nëpër regjistrimet e bazës së të dhënave.
Komponentët për shfaqjen dhe ndryshimin e të dhënave në bazë:
DBText, DBEdit, DBMemo, DBImage

Programimi-Delphi
Filtrimi i të dhënave
Operacion që shpesh përdoret gjatë punës me bazat e të dhënave është
shfaqja e të dhënat që i plotësojnë kushtet e caktuara.
Përpunimi i tabelave nga programi
Deri tek të dhënat në tabelë mund të arrihet edhe nga programi. Kur
komponenti Table është krijuar dhe tabela është e hapur, aktiv vetëm një regjistrim
në tabelë. Qasja është e mundur vetëm në fushat e regjistrimit aktiv. Pas hapjes së
tabelës aktiv është vetëm regjistrimi i parë. Kalimi në të ardhshmin, të mëparshmin,
të parin apo të fundit kryhet duke përdorur metodat Next, Prior, First ose Last.
Në Delphi ekziston mundësia q; drejtpërdrejt të kemi qasje deri në regjistrim
përmes fushave dhe vlerave të fushave (një ose më shumë fusha). Për këtë qëllim
përdoret metoda Locate.
Për të ndryshuar fushën në regjistrimin e tabelës, është e nevojshme së pari
të vendoset kursori në regjistrimin fushat e të cilit duam t’i ndryshojmë, dhe pastaj
të thirret metoda për ndryshim Edit.
Nëse duam të fusim regjistrim të ri në tabelë, atëherë duhet të përdorim
metodën Insert.
Në punën me bazat e të dhënave shpesh është e nevojshme fshihen
regjistrime të caktuara nga tabela aktive. Për këtë qëllim përdoret metoda Delete.
Pyetje dhe detyra:
1. Çka është baza lokale e të dhënave?

2. Cili është roli i BDE në Delphi?
3. Shpjego dallimet mes tabelës dhe DataSet.
4. Çka është alias-i?
5. Përshkruani se si punojnë bashkërisht programi juaj, BDE dhe baza e të dhënave.
6. Krijo një alias BDE të ri, dhe pastaj krijo bazën e të dhënave përkatëse që do të
kenë numrin e nevojshëm të tabelave me të dhëna për dvdtekën.
7. Në ObjectInspector, komponenti DBEdit nuk ka vetinë Text. Në çfarë mënyre
mund t’i qasemi përmbajtjes së kësaj komponentë?
8. Cilat janë metodat me të cilat mund të lëvizni nëpër regjistrimet e tabelës së
bazës së të dhënave?
9. Në çfarë mënyre mund të kontrollohet shpërndarja dhe numri i kolonave që do të
shfaqen në komponentin DBGrid?
10. Cilat komponentë mund të përdoret që DataSet të shfaqet në formë tabelore?
11. Në cilën mënyrë butona të veçantë të komponentit DBNavigator mund të bëhen
pasiv?
12. Cilën komponentë mund të përdorim për të shfaqur dhe ndryshuar fushën-tekst
në tabelën e bazës së të dhënave?
13. Të shkruhet aplikacion për shfaqjen e tabelës filma nga baza e të dhënave që
keni bërë më parë (Figura 7.44).
14. Krijo aplikacion që do të lejojë korrigjimin, futjen dhe fshirjen e regjistrimeve
në tabelën klientët në bazën e të dhënave (Figura 7.45.).

Programimi-Delphi
Figura 7.44. Tabela Filmat
Figura 7.45. Tabela klientët
Figura 7.46. Tabela lidhshmëria

Programimi-Delphi
Përgjigjet
Kapitulli 1
1. Rreshti komandues është tipar i sistemit operativ DOS, kurse dritarja dhe
tavolina punuese (desktopi) janë tipare të sistemit operativ Windows.
2. Hapësira punuese e Windowsit karakterizohet me ikona, kurse DOS-i me urdhra.
3. Sistem shumë-funksional (multitasking).
4. Hap programor vizual dhe Kod.
5. Që sistemin mund ta shfrytëzojnë të njëjtën kohë disa përdorues.
6. Inkapsulim, trashëgimi dhe poliformizëm.
7. Veti.
8. Metodë.
Kapitulli 2
1. Nëse në ObjectInspector ndryshohet vetia Name, në kodin programor

ndryshohen emrat e procedurave.
2. Dritare kryesore (main), ObjectInspector, dritare e formularit ose formës, dritare
për të shkruar kodin e programit.
3. Edit është një komponentë për futjen e tekstit vetëm në një rresht. Tekstit të
futur i shoqërohet vetia Tekst.
4. Enanled- vlerë logjike e tregon nëse kontrolli mund të pranojë ngjarje nga
tastiera apo miu. Nëse është me vlerë false, kontrolli do të jetë i zbehtë dhe nuk
mund të futen të dhëna.
Read only- përdoruesi ka mundësi vetëm të lexojë të dhëna nga kontrolli, por jo
edhe të shkruaj në të.
Set Focus - vendos fokusin (kursorin) në kontrollin që e thirr.
Password Char- definon shenjën me të cilën do të zëvendësohet teksti i futur,
përdoret kur krijohen shifrat e fshehta (passwords).
5. Në mënyrë programore dhe përmes ObjectInspector.
6. Properties, Events.
7. Kontrolli Etiket-Etiketa mundëson paraqitjen e tekstin statik në ekran.
8. Ngjarja OnClick paraqitet kur do të klikohet mbi komponentin.
9. procedure TForm2.Button2Click (Sender: TObject);
10. Hapet redaktuesi i kodit me emrin e procedurës përkatëse e cila përmban emrin
e formës, emrin e komponentit dhe emrin e ngjarjes.
11. Interpreteri është një përkthyes, i cili çdo linjë të kodit burimor e përkthen në
gjuhën e makinës dhe e ekzekuton. Kompajleri është një program i cili çdo urdhër
të kodit burimor e analizon dhe e përkthen në gjuhën e makinës, gjegjësisht krijon
program të ekzekutueshëm.
12. Me konvertimit adekuat.
13. On Enter- paraqitet kur kontrolli fiton fokus për futjen e të dhënave.
On Change- paraqitet sa herë që ndryshohet përmbajtja (text) e kontrollit Edit.
Përdorni ngjarjen për përpunimin e të dhënave të futura nga ana e përdoruesit kur
paraqitet ajo ngjarje.

Programimi-Delphi
Detyra
4. Password Char (edit2) <=*;

begin
edit2.visible:=true;
edit2.SetFocus;
if edit2.text='emuc' then
end;
5. procedure TForm1.Edit1Change(Sender: TObject);
begin
edit2.text:=edit1.text;
end;
Kapitulli 3
1. procedure TForm1.FormCreate, procedure TForm1.Button1Click.
2. Përmes kartelës ngjarje (events -> ObjectInspector), zgjidhet ngjarja OnClick ose
me klikim të dyfishtë në butonin komandues.
-IntToStr (konvertimi nga numër i plotë në string-tekst), StrToFloat (konverton
tekst-string në numër decimal), StrToInt (konverton tekst-string në numër të plotë),
FloatToStr (konvertim nga numri decimal në string)
3. procedure Tform1.Button1Click (Sender: TObject);
4. Ndryshorja: = shprehja;
ku Ndryshorja është vend në memorie në të cilën vendoset rezultati, kurse Shprehja
është shprehja vlera e së cilës llogaritet.
5. CheckBox.
6. Kontrolli TCheckBox gjendet në faqen Standard. Përdoret gjatë zgjidhjes së
detyrave kur është e nevojshme të përfshihen ose përjashtohen një apo më shumë
opsione.
7. If checkBox1.checked then
Label1.caption:=’E klikuar’
else
Label1.caption:=’Nuk është e klikuar’
8. Shpjegoni rreshtat e programit:
-StringGrid1.Row:=ComboBox1.itemindex+1;- Numri i rreshtave të komponentit
StringGrid do të jetë i barabartë me numrin e të dhënave në komponentin
ComboBox.
-Edit1.SetFocus;- fokusin e vendos në komponentin Edit1.
-StringGrid1.Cells[0,1]:= 1.';- Në celulën e rreshtit 0 dhe kolonës 1 shkruan "1".
9. Kontrolli RadioButton përdoret për të zgjedhur një nga disa opsione të
mundshme.
If radiobutton1.checked then
Label1.caption:=’ ’E klikuar’
else
Label1.caption:=’ Nuk është e klikuar’
10. –Items – mundëson të definohet, të lexohet dhe ndryshojë lista e mbishkrimeve
dhe numrin e radiobutonave të cilët ndodhen në kuadër të RadioGroup,
-ItemIndex - specifikon indeksin e Butonit aktualisht aktiv, në kuadër të
RadioGroup. Butoni i pare ka indeksin 0. Nëse asnjë buton nuk është zgjedhur,
indeksi është -1.

Programimi-Delphi
11. B)
12. Përmes vetisë Lines, në mënyrë ekzekutive direkt në komponentin, rruajtje nga
datoteka.
13. Jo.
14. Me vetinë pamundësohet shfaqja e tekstit në më shumë rreshta.
15. Komponenti StringGrid.
16. Përmbajtja e celulave është përcaktuar si e dhënë shenjë, por në çdo celulë, në
përjashtim të tekstit, mund të shoqërohet cilido objekt që ekziston në Delphi.
17. "0"
18.
ɚ) For do C Struktura përsëritje me kusht në
mbarim të ciklit,
b) While do B Struktura përsëritje me kusht në
fillim të ciklit,
c) Repeat – - Struktura përsëritje me kalim të
until rreshtit të caktuar të programit
Ⱥ Struktura përsëritje me numërim të
cikleve
19.
ɚ) Properties B Ngjarje
b) Events Ⱥ Veti
c) Tools D Paleta e komponentëve
ç) Component C Shiriti me vegla
palettɟ
Detyra
1. Procedure TForm1.Button4Click();
Var nr1,nr2,nr3,nr4,nr5:Integer;
Rez:Real;
Begin
Nr1:=strtoint(edit1.text);Nr2:=strtoint(edit2.text);
Nr3:=strtoint(edit3.text);Nr4:=strtoint(edit4.text);
Rez:=(nr1 + nr2+nr3+nr4+nr5)/5;
Edit6.text:=floattostr(rez);
End;
2. procedure TForm1.Button1Click(Sender: TObject);
var a:integer;
begin
if a=1 then form1.Color:=clblue;
if a=2 then form1.Color:=clyellow;
if a=3 then form1.Color:=clpink;
end;
3. Procedure TForm1.Button4Click();
Begin

Programimi-Delphi
If nr1>nr2 then rez:=nr1 else rez:=nr2;
4. End;
5. procedure TShembulli5.satTimer(Sender: TObject);
begin
Koha.color:=claqua;
end;
6.
7. procedure TForm1.Button1Click(Sender: TObject);

Var a,e,i,o,u,j:integer;
s,t:string;
begin
a:=0; e:=0; i:=0; o:=0; u:=0;
s:=fjalia.text;
for j:=1 to length(s) do
begin
t:=copy(s,j,1);
if (t='a') or (t='A') then a:=a+1;
if (t='e') or (t='E') then e:=e+1;
if (t='i') or (t='I') then i:=i+1;
if (t='o') or (t='O') then o:=o+1;
if (t='u') or (t='U') then u:=+1;
end;
str(a,s); shkronjaa.text:=s;
str(e,s); shkronjae.text:=s;
str(i,s); shkronjai.text:=s;
str(o,s); shkronjao.text:=s;
str(u,s); shkronjau.text:=s;
end;

Programimi-Delphi
8.
Var dd,md,gd,dr,mr,gr,d,m,g:integer;
Begin
dd:=strtoint(edit1.text);md:=strtoint(edit2.text);
d:=strtoint(edit3.text);
dr:=strtoint(edit4.text);mr:=strtoint(edit5.text);
gr:=strtoint(edit6.text);
if dd<dr then
begin
dd:=dd+30;
md:=md-1;
end;
d:=dd-dr;
if md<mr then
begin
md:=md+12;
gd:=gd-1;
end;
m:=md-mr;
g:=gd-gr;
edit7.text:=inttostr(d); edit7.text:=inttostr(m); edit7.text:=inttostr(g);
end;
8. Të bëhet një program i cili do të punojë si një quiz me 6 pyetje. Për çdo pyetje
duhet të ofrohet nga 4 përgjigje (opsione), prej të cilave vetëm njëra është e saktë.
Së fundi në formën e dytë të tregohen pikët e fituara dhe nota e fituar.
9. Në formë vendosen 3 etiketa, 1 buton, 3 timer
Veti: vetia caption e etiketave te vendosen në tre numra të ndryshëm.
Tajmerët të vendosen në intervale të ndryshme.
Ngjarje: button.click, timer1,2,3. timer
begin
timer1.enabled:=false;
timer2.enabled:=false;
timer3.enabled:=false; {i bllokojmë të gjithë tre tajmerët}
if (label1.caption= label2.caption)and (label1.caption= label3.caption)
then { nëse caption e të tre etiketave është e njëjtë atëherë kemi mesazh }
if messagebox(0,'You are our new lucky winner! Do you want to play
again?','congratulations',mb_yesno)=mryes then {nëse klikohet yes
atëherë përsëri startohen tajerët për të vazhduar loja }
begin
form1.show;
timer1.enabled:=true;
end
else { nëse klikohet në NO mbyllet aplikacioni}
application.Terminate
else
form1.show;

Programimi-Delphi
{ nëse të tre numrat nuk janë të njëjtë loja vazhdon, tajerët aktivizohen }
end;

begin
label3.caption:=inttostr((strtoint(label3.caption)+1)mod 10); {gjeneron
numër rasti 0-9 }
end;

begin
label2.caption:=inttostr((strtoint(label2.caption)+1)mod 10);
end;

begin
Label1.caption:=inttostr((strtoint(label1.caption)+1)mod 10);
end;
Sfida: Në vend të numrave futni foto-për këtë mund të përdoren bitbuttonat.
10.
Var x,y,x1,y1:integer;
begin
x:=random(690);
y:=random(480);
x1:=random(690);
y1:=random(480);
Canvas.pen.color:=clred;
canvas.MoveTo(x1,y1);
canvas.lineto(x,y);
end;
Kapitulli 4.
1. Dritaret- dialoguese në aplikacion lejojnë mënyra të ndryshme të futjes së të

dhënave hyrëse për punë tët aplikacionit, gjithashtu edhe shfaqja e të
dhënave dalëse mund të paraqitet në forma të ndryshme.
2. Po
3. Nga emri i projektit.
4. Gjatë futjes së të dhënave në aplikacion.
5. Funksioni InputBox i cili përmban 3 parametra. Parametri i parë përcakton
se çka do të shfaqet në shiritin e titullit, parametri i dytë e jep mesazhin që
do të shfaqet në dritaren-dialoguese, dhe parametri i tretë përfaqëson vlerën
e të dhënës që do të futet.
6. Tregon dritaren-dialoguese me një mesazh në koordinata të përcaktuara në
ekran.

Programimi-Delphi
Kapitulli 6.
1. a)
2. c)
3. c)
4. Globale janë ndryshoret që definohen në programin kryesor,
5. Gjatë thirrjes së nënprogramit argumente quhen argumente reale.
6. Nënprogramet paraqesin pjesë programore të pavarura që kanë të dhënat e tre
hyrëse dhe japin rezultate dalëse.
7. Argumentet në fillimin e nënprogramit quhen argumente formale.
8. Variablat lokale deklarohen në nënprogram.
9. function Shumz(br1, br2: integer): integer;
begin
Result:= br1 * br2;
Shumz:= Result
end;
Var a,b,rezultat:Integer;
Begin
b:=strtoint(edit2.text);
Rezultat:=shumz(a,b);
edit3.text:=inttostr(rezultat);
end;
end.
10. function fact (n:integer):longint;
begin
if n=0 then fact:=1
else fact:=n*fact(n-1);
end;
Begin
Edit1.text:=IntToStr(fact(ScrollBar1.position));
Label1.Caption:=IntToStr(ScrollBar1.position)+'!=';
end;
11.
function suman (n:integer):longint;
begin
if n=1 then suman:=1
else suman:=n+suman(n-1);
end;
Begin
Edit1.text:=IntToStr(suman(ScrollBar1.position));
Label1.Caption:=IntToStr(ScrollBar1.position)+'=';
end;
12.
function far (cel:integer):real;
begin
far:=1.8*cel+32
end;

Programimi-Delphi
procedure TForm1.ScrollBar1Change(Sender: TObject);

begin
Edit1.text:=FloatToStr(far(ScrollBar1.position));
end;
13. function den (eur:integer):real;

begin
den:=eur/61.5;
end;
procedure TForm1.ScrollBar1Change(Sender: TObject);
begin
Edit1.text:=FloatToStr(den(ScrollBar1.position));
end;
14. Titulli Nënprogramit duhet të definohet në pjesën Interface.

Definim të plotë nënprogramit duhet të ketë në pjesën Implementation.
Forma e përgjithshme dhe procedura e funksionit header është:
Function EmriIFunksionnit(Arg; …;Arg):LlojiIRezultatit;
Procedure EmriIFunksionnit (Arg; …;Arg);
15. Koha(s,a,b,c);
16. MëIvogël(fushë,10,min,nr);
Kapitulli 7
1. Bazat lokale të të dhënave paraqesin lloj më të thjeshtë të bazave. Ajo është

një bazë të dhënash e vendosur në një kompjuter. Të gjitha ndryshimet në të
dhënat regjistrohen direkt në bazë.
2. Për të mundësuar qasjen në bazat e të dhënave, Delphi përdor teknologjinë
BDE. Ajo është një përmbledhje e programeve shërbyese të cilët
mundësojnë qasje në baza të ndryshme të të dhënave.
3. Në punën me bazat e të dhënave përdoret termi DataSet. Ajo është një grup i
të dhënave deri tek të cilat mund të arrihet në bazë të informatave të
përfshira në bazën e të dhënave. Të dhënat nga DataSet nuk është e thënë t’i
përkasin një tabele.
4. Për qasje korrekte në bazën e të dhënave BDE përdor alias (alias). Ajo është
një grup i parametrave që përshkruajnë lidhjen me bazën e të dhënave.
Alias-i i tregon BDE cilin drajver të përdor dhe ku gjinden në disk datoteka
me bazën e të dhënave.
5. Aplikacioni - BDE – baza e të dhënave. BDE paraqet lidhjen mes bazës së të
dhënave dhe aplikacionit.
6. DBEdit.Text.
7. DBNavigator.
8. Columns editor
9. Table, DataSource, DBGrid
10. Komponenti DBEdit.

Programimi-Delphi
Literatura
-Miodrag Stojanoviq: Informatika dhe llogaritja
-Laslo Kraus: Fusha programuese Delphi 7
-Gjorgji Jovançevski:Teknologjia informative (për vitin e parë të arsimit të mesëm)
-Dragan Andonov, Cane Kotevski: bazat e Softverit
-Marko Cantu: Mastering Delphi 4
-Niklaus Wirth: Doracak i Pascal-it
-Adresa nga Interneti:
-http://vojo.milanovic.org/
-http://www.hkbu.edu.hk/~bba_ism/ISM2110/index.htm (Pascal Programming)
-http://www.tutorijali.org/delphi.php
-Marko Shvaljek: Borland Delphi (libër në internet)

Programiranje IV ALB PRINT

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programiranje IV ALB PRINT

Uploaded by

Copyright:

Available Formats

JULIJANA PETRESKA

Përkthyes: Ing. Riza ETEMI

Lektor: Shkëlzen HALIMI

Shtypi: PROSVETNO DELLO ShA – Shkup

Shtypshkronja: NAPREDOK - Tetovë

ɋɨ ɪɟɲɟɧɢɟ ɧɚ Ɇɢɧɢɫɬɟɪɨɬ ɡɚ ɨɛɪɚɡɨɜɚɧɢɟ ɢ ɧɚɭɤɚ ɧɚ Ɋɟɩɭɛɥɢɤɚ

Me vendim të Ministrit të Arsimit dhe Shkencës të Republikës së Maqedonisë

CIP – Ʉɚɬɚɥɨɝɢɡɚɰɢʁɚ ɜɨ ɩɭɛɥɢɤɚɰɢʁɚ

2 Libër për vitin IV

2. ANALIZA E EKRANIT TË DELPHI-it....................................................................... 19

3. SHKRIMI I KODIT NË OBJEKT PASCAL.............................................................. 35

Libër për vitin IV 3

3.12.1. Komponenti (Memo).................................................................................... 78

4. SHKRIMI I MESAZHEVE (KORNIZA PËR DIALOG)………………………… 103

5. KRIJIMI I MENYVE PËR FORMËN....………………………………………........ 113

6. PROCEDURA (PROCEDURE) DHE FUNKSIONE

7. BAZA E TË DHËNAVE …………………………………………………….…......... 135

4 Libër për vitin IV

Libër për vitin IV 5

Paraprakisht u falënderohem lexuesve dhe i lus t’i paraqesin komentet dhe

6 Libër për vitin IV

1.1. Karakteristikat bazë të programeve të bazuara në dritare

Parimet themelore të programimit janë vënë qysh në kohën e paraqitjes së

Libër për vitin IV 7

nga pamja të orientojnë në aktivitetin që realizohet me të. Gjatë shkrimit të

Figura 1. Pamja e ndërfaqes shfrytëzuese kur punojnë dy programe.

8 Libër për vitin IV

Figura 2. Shpërndarja kaskadë e dritareve

1.2. Elemente të hapësirës shfrytëzuese grafike (ndërfaqes-interface)

Hapësirë shfrytëzuese grafike ka pamje të njëjtë për programe aplikative të

Libër për vitin IV 9

Figura 3. Dritarja e hyrëse e sistemit operativ. (Desktop)

Dritarja e folderit përfaqëson organizimin hierarkik të të dhënave në

Figura 4. Dritarja grupore My computer

10 Libër për vitin IV

Figura 5. Dritarja e aplikacionit PowerPoint

Dritarja e aplikacionit paraqet sipërfaqe në të cilën ekzekutohet programi

Libër për vitin IV 11

Figura 6. Dritarja e dokumentit

Dritaret për dialog janë të ndryshme varësisht nga destinimi. Më shpesh

Figura 7. Dritare e paralajmërimit

12 Libër për vitin IV

Figura 8. Dritarja-dialog (Vetitë-Properties)

Në këtë dritare vërejmë ekzistimin e katër kartelave (faqeve), titujt e të

1.3. Programe të komanduara nga ngjarje

Programet e komanduara nga ngjarje u mundësojnë shfrytëzuesve t’i

Libër për vitin IV 13

14 Libër për vitin IV

Metoda është kod programor që i shoqërohet objektit e cila përcakton se si

Për ata që duan të dinë më tepër

Libër për vitin IV 15

1.4. Probleme të cilat zgjidhen me Delphi

Delphi është paketë programore ɟ destinuar për krijimin e aplikacioneve për

16 Libër për vitin IV

Libër për vitin IV 17

Pyetje dhe detyra:

1. Linja komandues është karakteristikë e sistemit operativ _________________,

6. Cilët janë tre parimet themelore të programimit të orientuar në objekte

18 Libër për vitin IV

2. ANALIZA E EKRANIT TË DELPHI-t

2.1. Hyrje në hapësirën punuese të Delphi-t

Delphi është paketë programore e cila bazohet në gjuhën programuese

Figura 2.1. Pamja fillestare e dritares së Delphi-it

Në pjesën e sipërme të dritares ndodhet lista e projekteve të ruajtura. Projekti i