als_Latn dik_Latn sna_Latn
Getting Started on the Commandline/sq
Contents
Fillimi i programimit në Qt
Mirë se vjen në botën e Qt—kornizë për zhvillim softuerik ndër-platformësh. Në këtë udhërrëfyes, ne ju mësojmë bazat mbi Qt duke ndërtuar një aplikacion të thjeshtë i cili shërben për mbajtjen e shenimeve që do ta quajmë Notepad. Pasi që ta lexoni këtë udhërrëfyes, ju duhet të jeni gati të hyni më thellë në pamjen e përgjithshme të Qt dhe dokumentimin e API (Ndërfaqe për programim të aplikacioneve) që e kemi në këtë faqe dhe jeni në gjendje të gjeni informacione të tjera lidhur me aplikacionin që ju jeni duke e ndërtuar. Përshëndetje Notepad Në këtë shembull ne në mënyrë të thjeshtë e krijojmë dhe e shfaqim një formë ne ndërfaqen tonë punuese (Ang. Desktop), kjo përfaqëson një Qt program shumë të thjeshtë që përmban pamje grafike (GUI).
Ja ku është kodi i cili krijon një formë të tillë:
#include
#include
int main(int argv, char **args)
{
QApplication app(argv, args);
QTextEdit textEdit;
textEdit.show();
return app.exec();
}
Le të kalojmë nëpër këtë kod rresht pas rreshti që ta kuptojmë më mirë. Në dy linjat e para, ne i përfshijmë header skedarët për QApplication dhe QTextEdit të cilët janë dy klasat që ne do ti përdorim në këtë shembull. Të gjitha Qt klasat kanë një header skedarë të emërtuar sipas tyre.
Linja 6 krijon një object të QApplication. Ky objekt menaxhon burimet e të gjithë aplikacionit dhe është I domosdoshëm për çdo Qt program që posedon pamje grafike (GUI). QApplication ka nevojë për argv dhe args argumentet e programin sepse Qt pranon disa argumente që futen nga linja komanduese (command line) e sistemit operativ.
Linja 8-të krijon një objekt të QTextEdit. Editori I tekstit është një element visual në një aplikacion me pamje grafike. Në Qt ne I thërrasim elementet e tilla, widgets. Shembuj të widget-ëve tjerë janë shiritat rrëshqitës, label-at dhe radio butonët. Widget-ët mund të jenë edhe konteinerë për widget-ë të tjerë; për shembull, një dialog apo dritarja kryesore e një apliacionit.
Linja 9 tregon edituesin e tekstit I cili gjindet në kornizën e tij të vetme dhe është I shfaqur në ekran. Pasi që widget-ët funksionojnë edhe si konteiner (për shembull një QMainWindow, I cili përmban shirit për vegla, meny, shirit për gjendje dhe Widget-ë të tjerë), është e mundur të shfaqet një widget të vetëm në dritren e tij të vetme. Widget-ët nuk janë dukshëm në vete; funksioni shoë() e bën një widget të dukshëm.
Linja e 11-të bën që QApplication të hyj në ciklin e tij të ngjarjeve (event loop). Kur një Qt aplikacion është në funksionim, ngjarjet gjenerohen dhe dërgohen tek widget-ët e aplikacionit. Shembuj të ngjarjeve janë shtypjet e miut dhe shtypjet e tasteve në tastierë. Kur ju shkruani tekst në një ëidget për editim të tekstit siç është QTextEdit, ai merr tastet e shtypura në tastierë dhe përgjigjet duke vizatuar tekstin e shtypur në widget. Për ta bërë aplikacionin të funksionojë, hape një linje të komandave (command line), dhe shkruani direktoriumin në të cilin e keni .cpp skedarin e programit. Komandat e shfaqura poshtë e ndërtojnë programin.
qmake -project
qmake
make
Kjo do ta krijoj një skedar ekzekutues në direktoriumin part1 (vëmendje sepse në sistemin operativ Ëindoës, ju duhet të përdorni nmake në vend të make. Po ashtu, skedarët ekzekutues do të vendosen në part1/debug apo part1/release). Qmake është vegla e Qt për ndërtim të programeve I cili pranon një skedar konfigurues. Qmake gjeneron këtë për ne pasi që I jepet –project argumenti. Pasi që skedari konfigurues të jetë krijuar (I cili ka prapashtesën .pro), qmake prodhon një make skedar I cili e ndërton programin për ju. Më vonë do të shikojmë se si mund ti shkruajmë .pro skedarët ne vetë.
Mëso më shumë Rreth: Gjeometria e widget-ëve dhe dritareve Këtu: Window and Dialog Widgets
Rreth: Ngjarjet dhe trajtimi i ngjarjeve Këtu: The Event System
Shtimi i një butoni për mbyllje
Në një aplikacion real ju duhet më shumë se një widget. Ne tani do të ju prezantojmë QPushButton që do të vendoset nën edituesin e tekstit. Pasi të shtypet butoni ka për detyrë ta mbyll Notepad aplikacionin (për shembull, pasi që të klikohet mbi të me miun e kompjuterit).
Së pari le të shikojmë kodin.
#include
int main(int argv, char **args)
{
QApplication app(argv, args);
QTextEdit textEdit;
QPushButton quitButton("Quit");
QObject::connect(&quitButton, SIGNAL (clicked()), qApp, SLOT (quit()));
QVBoxLayout layout;
layout.addWidget(&textEdit);
layout.addWidget(&quitButton);
QWidget window;
window.setLayout(&layout);
window.show();
return app.exec();
}
Linja 1 përfshinë QtGui i cili përmban të gjitha klasat e Qt që kanë të bëjnë me pamjen grafike (GUI). Linja 10 përdorë mekanizmin e sinjaleve (ang. Signal) dhe slot-ëve që janë të inkorporuara në Qt për ta bërë aplikacionin të mbyllet pasi që butoni për mbyllje I emërtuar Quit button të shtypet. Slot është një funksion thirrja e të cilit mund të bëhet në momentin kur aplikacioni është duke funksionuar (Ang. Runtime) duke përdorë emrin e atij funksioni përkatës. Sinjali është po ashtu një funksion thirrja e të cilit rezulton në thirrjen e çdo slot-i i cili është i regjistruar në atë sinjal përkatës; ne e quajmë këtë si lidhe slot-in në sinjal dhe emeto sinjalin.
Quit() është një slot i klasës QApplication i cili e mbyll aplikacionin. Clicked() është një sinjal të cilit e emeton QPushButton pasi që të shtypet. Funksioni static QObject::connect() kujdeset për lidhjen e slot-it me sinjal. SIGNAL () dhe SLOT() janë dy makro funksione që pranojnë si parametër nënshkrimet e funksioneve të sinjalit dhe slot-ëve për ti lidhur ata. Ne po ashtu duhet ti japim edhe treguesit (pointerët) e objekteve të cilët duhet të dërgojnë dhe pranojnë sinjalin.
Linja 12 krijon një QVBoxLayout objekt. Siç e kemi përmendur, widget-ët mund të përmbajnë widget-ë të tjerë. Është e mundur që menjëherë ti vendosim kufijtë (pozicionin dhe madhësinë) e widget-ëve fëmijë, por zakonisht është më lehtë të përdorim faqosje (Ang. Layout). Faqosja menaxhon kufijtë e fëmijëve të një widget-i. Përshembull QVBoxLayout vendos fëmijët në një rresht vertical. Linja 13 dhe 14 shton edituesin e tekstit dhe butonit në faqosje. Në linjën 17 ne vendosim faqosjen në widget.
Mëso më shumë Rreth: Sinjaleve dhe slot-ëve Këtu: Signals & Slots
Rreth: Faqosjeve Këtu: Layout Management, Widgets and Layouts, Layout Examples
Rreth: Widget-ët që vijnë me Qt Këtu: Qt Widget Gallery, Widget Examples
Nënklasimi i QWidget
Kur përdoruesi dëshiron ta mbyllë aplikacionin, ju dëshironi ta shfaqni një dialog i cili pyet nëse përdoruesi është i sigurtë për mbylljen e aplikacionit. Në këtë shembull, në e krijojmë një nënklasë (Ang. Subclass) të QWidget, dhe shtojmë një slot të cilin e lidhim me butonin për mbyllje.
Së pari le të shikojmë kodin.
5 class Notepad : public QWidget
6 {
7 Q_OBJECT
8
9 public:
10 Notepad();
11
12 private slots:
13 void quit();
14
15 private:
16 QTextEdit *textEdit;
17 QPushButton *quitButton;
18 };
Q_OBJECT makro funksioni duhet të jetë i pari në përcaktimin e klasës, dhe kjo deklaron klasën tonë si QObject (Natyrisht klasa jonë duhet të trashëgohet nga QObject). QObject shton disa aftësi në një klasë normale të C++. Sidomos kur marrja e emrit të klasës dhe i slot-ëve mund të bëhet kur aplikacioni është duke funksionuar. Po ashtu është e mundur marrja e tipeve të të dhënave që janë si parametër e një slot-i, dhe të bëhet thirrja e tij kur aplikacioni është në funksionim e sipër.
Linja 13 deklaron një slot quit(). Kjo bëhet shumë lehtë e mundur duke përdorë slots macron. Tani slot-i quit() mund të lidhet me sinjale të cilët kanë nënshkrim të njëjtë (apo ndonjë sinjal që nuk pranon parametra). Në vend se ta bëjmë lidhjen në funksionin kryesor (funksionin main()), ne tani e përdorim konstruktorin e Notepad aplikacionit.
Notepad::Notepad()
{
textEdit = new QTextEdit;
quitButton = new QPushButton(tr("Quit"));
connect(quitButton, SIGNAL (clicked()), this, SLOT (quit()));
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(textEdit);
layout->addWidget(quitButton);
setLayout(layout);
setWindowTitle(tr("Notepad"));
}
Si e patë në definimin e klasës, ne përdorim treguesit (pointerët) në QObject-et tona textEdit dhe quitButton. Si rregull ju duhet gjithmonë ti alokoni QObject-et në heap dhe asnjëherë ti kopjoni ato. Ne tani përdorim tr() funksionin rreth cdo stringu i cili është i dukshëm. Ky funksion është i domosdoshëm nëse dëshironi që ta shpërndani aplikacionin tuaj në më shumë se një gjuhë (për shembull, në Gjuhën Shqipe, Angleze apo Kineze). Nuk do të thellohemi në detale këtu por ju mund të ndiqni linkun e Qt Linguist nga tabela mëso më shumë.
Mëso më shumë Rreth: tr() dhe internacionalizimi Këtu: Qt Linguist Manual, Writing Source Code for Translation, Hello tr() Example, Internationalization with Qt
Rreth: QObjects dhe Qt modeli i objekteve (Kjo është e domosdoshme për ta kuptuar Qt) Këtu: Object Model
Rreth: qmake dhe Sistemi i ndërtimit në Qt Këtu: qmake Manual
Krijimi i .pro skedarit
Në vend se ta përdorim –project zgjedhjen e qmake programit, në këtë shembull ne do ta shkruajmë vetë një .pro skedar.
HEADERS = notepad.h
SOURCES = notepad.cpp main.cpp
Komandat në vazhdim do ta ndërtojnë shembullin tonë.
qmake
make
Përdorimi i QMainWindow
Shumë aplikacione përfitojnë nga përdorimi i QMainWindow, i cili ka faqosjen e tij në të cilin mund të shtoni shirit për meny, dok widget-ë, shirita për vegla dhe shirit të gjendjes. QMainWindow ka një zonë në qendër e cila mund të jetë i zënë nga çdo lloj i widget-ëve. Në shembullin tonë, ne do ta vendosim edituesin e tekstit në qendër të QMainWindow.
Le të shikojmë definimin e ri të klasës Notepad.
#include
class Notepad : public QMainWindow
{
Q_OBJECT
public:
Notepad();
private slots:
void open();
void save();
void quit();
private:
QTextEdit *textEdit;
QAction *openAction;
QAction *saveAction;
QAction *exitAction;
QMenu *fileMenu;
};
Ne i përfshijmë dy slot-e më shumë të cilat përdoren për ruajtjen dhe hapjen e dokumenteve. Zbatimi i tyre do të bëhet në seksionin në vazhdim.
Shpesh në një dritare kryesore, thirrja e një slot-i të vetëm duhet të bëhet nga disa widget-ë të ndryshëm.
Shembujt janë elementet e menysë dhe butonët në shiritin e veglave. Për ta bërë këtë më të lehtë, Qt siguron disa veprime që janë objekte të QAction, të cilët mund të jepen tek disa widget-ë përnjëherë, dhe mund të kenë lidhje në slot-e të ndryshme. Për shembull, njëlloj QMenu dhe QToolBar mund të krijojnë elemente në meny dhe butonë të veglave që shfaqen në QToolBar, dhe të gjitha këto mund të krijohen veprime të QAction dhe të përdoren në të dy pjesët. Do të shohim se si punojnë këto shumë shpejtë. Sikur më heret, ne përdorim konstruktorin e Notepad aplikacionit tonë për ta ngritur pamjën grafike (GUI).
Notepad::Notepad()
{
saveAction = new QAction(tr("&Open"), this);
saveAction = new QAction(tr("&Save"), this);
exitAction = new QAction(tr("E&xit"), this);
connect(openAction, SIGNAL (triggered()), this, SLOT (open()));
connect(saveAction, SIGNAL (triggered()), this, SLOT (save()));
connect(exitAction, SIGNAL (triggered()), qApp, SLOT (quit()));
fileMenu = menuBar()->addMenu(tr("&File"));
fileMenu->addAction(openAction);
fileMenu->addAction(saveAction);
fileMenu->addSeparator();
fileMenu->addAction(exitAction);
textEdit = new QTextEdit;
setCentralWidget(textEdit);
setWindowTitle(tr("Notepad"));
}
QAction objektet janë krijuar me një tekst i cili duhet të shfaqet ne widget-ë në të cilat ne i shtojmë ato (në rastin tonë, në elementet e menysë). Nëse kishim kërkuar që ti shtojmë të njëjtat objekte të QAction në një shirit për vegla, ne do ti kishim dhënë aksioneve tona edhe ikonë. Kur një element i menysë tani klikohet, elementi do ta shkaktojë aksionin dhe thirrja e slot-it përkatës do të bëhet.
Mëso më shumë Rreth: Dritareve kryesore dhe klasat e dritareve kryesore Këtu: Application Main Window, Main Window Examples
Rreth: Aplikacionet MDI Këtu: QMdiArea, MDI Example
Ruajtja dhe Ngarkimi
Në këtë shembull, ne do ta zbatojmë funksionalitetin e open() dhe save() slot-ëve që i kemi shtuar në shembullin paraprak.
Ne do të fillojmë me slot-in open():
QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), "",
tr("Text Files ('''.txt);;C++ Files ('''.cpp '''.h)"));
if (fileName != "") {
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly)) {
QMessageBox::critical(this, tr("Error"),
tr("Could not open file"));
return;
}
QString contents = file.readAll().constData();
textEdit->setPlainText(contents);
file.close();
}
Hapi i parë është pyetja e përdoruesit për emrin e skedarit të cilin ai dëshiron ta hapë. Qt vjen me QFileDialog, i cili është dialog prej të cilit përdoruesi mund të bën zgjedhjen e skedarit. Imazhi më lartë tregon dialogun në Kubuntu. Funksioni static getOpenFileName() shfaq një dialog modal i cili është i orientuar për hapjen e skedareve dhe nuk kthehet deri sa përdoruesi të bën zgjedhjen e skedarit. Funksioni kthen rrugën e skedarit në disk për skedarin e zgjedhur nga përdoruesi, apo një string të zbrazët nëse përdoruesi ka anuluar dialogun.
Pasi që ta kemi emrin e skedarit, ne provojmë ta hapim atë skedar me funksionin open() i cili e kthen një vlerë true nëse skedari është hapur me sukses. Ne nuk do ta përfshijmë trajtimin e gabimeve këtu, por ju mund ti ndiqni linqet nga seksioni mëso më shumë. Nëse skedari nuk mund të hapet, ne përdorim QMessageBox klasën për ta shfaqur një dialog me një mesazh gabimi (shih QMessageBox përshkrimin e klasës për detale të më tutjeshme).
Leximi i skedarëve është i lehtë duke përdorë funksionin readAll(), i cili i kthen të gjitha të dhënat e skedarit në QByteArray format. constData() kthen të gjitha të dhënat në varg si const char, për të cilin QString përmban konstruktor. Përmbajtja mund të shfaqet në edituesin e tekstit. Pastaj ne e bëjmë thirrjen e funksionit close() për ta kthejmë përshkruesin e skedarit tek sistemi operativ.
Tani le të vazhdojmë me slotin për ruajtje, të cilin e kemi emërtuar save().
QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"), "",
tr("Text Files ('''.txt);;C++ Files ('''.cpp '''.h)"));
if (fileName != "") {
QFile file(fileName);
if (!file.open(QIODevice::WriteOnly)) {
// error message
} else {
QTextStream stream(&file);
stream  toPlainText();
stream.flush();
file.close();
}
}
Kur ne dëshirojmë ta shkruajmë përmbajtjen e edituesit të tekstit në skedar, ne e përdorim klasën QTextStream, i cili mbështjell QFile objektin. Vargu i tekstit (text stream) mund të shkruaj përmbajtjen e QString drejtpërdrejt në skedar, QFile pranon vetëm të dhëna të papërpunuara (char) me funksionet ërite() të QIODevice.
Mëso më shumë Rreth: Skedarëve dhe I/O pajisjeve Këtu: QFile, QIODevice
eng_Latn cat_Latn als_Latn als_Latn als_Latn eng_Latn eng_Latn lmo_Latn unk eng_Latn dik_Latn eng_Latn eng_Latn unk als_Latn als_Latn als_Latn als_Latn als_Latn eng_Latn kam_Latn kam_Latn als_Latn als_Latn als_Latn als_Latn als_Latn als_Latn grn_Latn lmo_Latn unk eng_Latn dik_Latn hne_Deva eng_Latn hne_Deva swe_Latn hne_Deva eng_Latn hne_Deva eng_Latn eng_Latn unk als_Latn als_Latn als_Latn als_Latn als_Latn als_Latn dan_Latn als_Latn als_Latn eng_Latn unk hne_Deva unk eng_Latn lvs_Latn unk eng_Latn eng_Latn unk eng_Latn dik_Latn hne_Deva unk als_Latn als_Latn lvs_Latn unk dik_Latn hne_Deva eng_Latn eng_Latn swe_Latn hne_Deva shn_Mymr eng_Latn unk als_Latn als_Latn als_Latn als_Latn als_Latn als_Latn lvs_Latn eng_Latn als_Latn kam_Latn kam_Latn als_Latn als_Latn als_Latn grn_Latn eng_Latn unk hne_Deva eng_Latn lvs_Latn eng_Latn eng_Latn tpi_Latn eng_Latn eng_Latn dik_Latn eng_Latn eng_Latn eng_Latn ewe_Latn unk als_Latn als_Latn als_Latn lvs_Latn unk eng_Latn eng_Latn eng_Latn eng_Latn eng_Latn eng_Latn lmo_Latn fra_Latn eng_Latn ace_Latn fra_Latn dik_Latn swe_Latn eng_Latn unk als_Latn als_Latn als_Latn als_Latn als_Latn als_Latn nno_Latn hne_Deva eng_Latn nno_Latn eng_Latn eng_Latn eng_Latn eng_Latn unk eng_Latn cat_Latn eng_Latn unk als_Latn als_Latn als_Latn als_Latn nno_Latn hne_Deva eng_Latn nno_Latn eng_Latn hne_Deva eng_Latn eng_Latn eng_Latn mlt_Latn eng_Latn unk unk als_Latn als_Latn