QTableWidget

Pokud si do vyhledávacího pole v návrhářském režimu zadáte termín „table“, zjistíte, že takové podmínce odpovídají hned dva prvky – Table View a Table Widget. V našem programu využijeme ten druhý jmenovaný. Důvodem je především způsob zpracování metod třídy QTableWidget. Do karet dále nahrává množství funkcí oproti QTableView.

Důležitou součást každé správné tabulky symbolizuje horní hlavička. Právě ona totiž dává samotným údajům smysl. O její nastavení se postará setHorizontalHeaderLabels(QStringList). V parametru však vyžaduje list typu QstringList. Právě proto jej nejprve musíme vytvořit a vložit do něj přes append samotné popisky. Během programování rovněž nezapomeňte určit počet sloupců naší tabulky. Krásně k tomuto účelu poslouží počet prvků v listu.

Přidání řádku probíhá obdobně. Jednoduše jej vložíte za aktuální poslední záznam díky metodě insertRow(int). Množství používaných řádků vám přitom prozradí rowCount().

Zpracování informací

K procházení veškerých buněk v tabulce využijeme iterační cyklus, jehož proměnná bude reprezentovat daný řádek. Specifikaci sloupce poté můžeme provést staticky s pomocí proměnné typu int. Obsah buňky následně vrátí metoda item(int, int) avšak jako QtableWidgetItem *. Kýžený QString poté zprostředkuje text().

#include „widget.h“
#include „ui_widget.h“

#include

widget::widget(QWidget *parent) :
QWidget(parent),
ui(new Ui::widget)
{
ui->setupUi(this);

QStringList list;
list.append(„Jméno“);
list.append(„Příjmení“);
ui->tableWidget->setColumnCount(list.size());
ui->tableWidget->setHorizontalHeaderLabels(list);

setWindowTitle(„Tabulka“);

connect(ui->pb_info,SIGNAL(clicked()),this,SLOT(vypsat_info()));
connect(ui->pb_pridat,SIGNAL(clicked()),this,SLOT(pridat_radek()));
}

widget::~widget()
{
delete ui;
}

void widget::pridat_radek()
{
ui->tableWidget->insertRow(ui->tableWidget->rowCount());
}

void widget::vypsat_info()
{
for(int i = 0; i < ui->tableWidget->rowCount();i++)
{
QMessageBox::information(this,QString::number(i+1)+“. řádek“,“Jméno: „+
ui->tableWidget->item(i,0)->text()+“\n“+
„Příjmení: „+
ui->tableWidget->item(i,1)->text()
);
}
}

Grafické propojení

Tuto formu sjednocení signálů a slotů zmíním jen okrajově, protože dle mého názoru dokáže spíše práci znesnadnit. Jedinou možnou výhodu vidím ve znázornění principu odesílání zpráv a jejich zachytávání. Začátečník tak celou ideu patrně lépe pochopí. Vyzkoušet si tuto variantu můžete v návrhářském režimu po stisknutí F4, kdy tažením myši určíte zdroj signálu a příslušný cíl. Záhy však pravděpodobně přijdete o přehlednost a snadnou editaci.

Signals & Slots Editor

Velmi sofistikovaný nástroj se skrývá rovněž v designérském módu pod příslušnou záložkou. Zeleným tlačítkem plus zahájíte vytvoření nového spojení. Na určitou nevýhodu však brzy narazíte. Pakliže například naprogramujete vlastní slot, neobjeví se v rozevíracím seznamu. Nejprve jej s pomocí funkce Change signals/slot musíte do příslušné části ručně vepsat. Když si však přesně nepamatujete identifikátor, nezbývá, než se přepnout do zdrojového kódu a dotyčný název vyhledat. Já osobně například chvílemi přemýšlím, zda-li jsem slot pojmenoval jako uloz, ulozit či snad Ulozit :-).

Connect

Syntaxe určení závislosti mezi signálem a koncovým cílem zapsaná ve zdrojovém kódu patrně na první pohled nevypadá pro lidi začínající s Qt příliš lákavě. Nejde však o nic složitého a velmi záhy si na funkci connect dokážete zvyknout. Obvykle se stačí dobře seznámit s makry SIGNAL() a SLOT(). Editor vám navíc vždy ochotně napoví.

connect(ui->pb_barva,SIGNAL(clicked()),this,SLOT(barva()));

QColorDialog

Dialog sloužící ke komfortnímu zvolení barvy není třeba od základu vytvářet. Plně postačí využít ten systémový. S tím nám pomůže knihovna QColorDialog. Jako parametr getColor přitom uvádíme náhodně zvolenou barvu, kterou přiřazuje do proměnnéswitch. Jako výsledek přitom obdržíte platný QColor jen v případě, že uživatel dialogové okno nezruší s pomocí Cancel. Toho lze krásně využít v podmínce, která tuto skutečnost testuje. O celou verifikaci se postará metoda isValid(). Samotná proměnná typu QColor však k nastavení pozadí nestačí. PlainTextEdit totiž nic podobného jako setColor(QColor) nezná. Musí proto dojít ke zrodu palety (QPalette), která v sobě obsahuje různé barvy jednoho objektu a identifikuje je díky ColorRole (v našem případě Qpalette::Base). Nově vzniklou paletu poté již stačí plainTextEditu nastavit s pomocí setPalette(QPalette). V konstruktoru si přitom povšimněte nastavení vlastnosti autoFillBackgroung na true, což zajistí vyplnění pozadí.

Náhodná čísla

Před samotným generováním musíme provést inicializaci. Funkce qsrand potřebuje údaj, který se bude měnit s každým spuštěním programu. Tuto záležitost elegantně řeší počet vteřin do půlnoci. Modulo za qrand určuje rozsah. Interval v našem případě začíná nulou a končí dvojkou. V podstatě tak dochází k náhodnému opakování tří čísel – 0, 1 a 2.

#include „widget.h“
#include „ui_widget.h“

#include
#include

Widget::Widget(QWidget *parent) :
QWidget(parent),
ui(new Ui::Widget)
{
ui->setupUi(this);

ui->plainTextEdit->setAutoFillBackground(true);
this->setWindowTitle(„Barva“);

connect(ui->pb_konec,SIGNAL(clicked()),this,SLOT(close()));
connect(ui->pb_barva,SIGNAL(clicked()),this,SLOT(barva()));

}

Widget::~Widget()
{
delete ui;
}

void Widget::barva()
{
QColor prednastavena;
QTime pulnoc(0,0,0,0);
qsrand(pulnoc.secsTo(QTime::currentTime()));
int nahodna = qrand() % 3;

switch (nahodna){
case 0:
prednastavena = Qt::black;
break;

case 1:
prednastavena = Qt::red;
break;

case 2:
prednastavena = Qt::blue;
break;

}

QColor barva = QColorDialog::getColor(prednastavena);

if(barva.isValid() == true)
{
QPalette paleta;
paleta.setColor(QPalette::Base,barva);
ui->plainTextEdit->setPalette(paleta);
}
}

Zpracování údajů po řádcích

Záměrně jsem se rozhodl nenačíst celý soubor najednou, ale postupovat po částech. Získáme tak jednotlivé řádky, se kterými můžeme dále pohodlně pracovat. Pakliže by například soubor obsahoval čísla, musíme vždy každý údaj nejprve převést, aby jej šlo uchovat v proměnné typu int či double. V našem případě však vyzkoušíme něco jiného. Jednotlivé záznamy obalíme tagem H3 a výsledek textEdit dostane v HTML formě. Zcela jednoduše lze proto s textem provádět mnoho činností – změnu barvy, transformaci v tučný záznam a podobné úpravy.

#include „mainwindow.h“
#include „ui_mainwindow.h“

#include
#include
#include
#include

MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);

setCentralWidget(ui->textEdit);

setWindowTitle(„Načtení souboru“);

connect(ui->action_Nacist_soubor,SIGNAL(triggered()),this,SLOT(nacti_soubor()));
connect(ui->action_Konec,SIGNAL(triggered()),this,SLOT(close()));
}

MainWindow::~MainWindow()
{
delete ui;
}

void MainWindow::nacti_soubor()
{
QString cesta = QFileDialog::getOpenFileName(this,“Zvolte soubor“,“/home“,“Textový soubor (*.txt);;Všechny soubory(*.*)“);

if(cesta.isNull())
{
QMessageBox::warning(this,“Varování“,“Nebyl vybrán žádný soubor k načtení“);
}
else
{
QFile soubor(cesta);
soubor.open(QIODevice::ReadOnly | QIODevice::Text);

QTextStream stream(&soubor);
stream.setCodec(„utf-8″);
QString radek,vysledek;

while(!stream.atEnd())
{
radek = soubor.readLine();
//V proměné radek máme načtená řádek ze souboru a můžeme s ním provádět další operace
vysledek += „

„+radek+“

\n“;

}
ui->textEdit->insertHtml(vysledek);
}
}

Rád bych upozornil na fakt, že okno sloužící k výběru souboru můžeme vyšperkovat k představám programátora. Dozajista využijete specifikování typů povolených koncovek. Činí se tak v jednom z parametrů a to díky stringovému řetězci. Jednotlivé akceptovatelné varianty odděluje dvojice středníků. Dále určujeme i výchozí složku. Protože požívám Linux, vidíte ve zdrojovém kódu /home. Lidé preferující operační systém Windows mohou směle uvést např. C:\data.

Pozor na jednu skutečnost. Uživatel má možnost dialog zjišťující cestu kdykoliv ukončit a my poté pochopitelně nemůžeme žádný soubor načíst. Ošetření vyřeší jednoduchá podmínka testující, zda proměnná cesta obsahuje daný řetězec. Pakliže ano, vše je v pořádku a můžeme programu dovolit vykonat činnost, ke které ho vytváříme. V opačném případě raději vypíšeme hlášku a uživateli pochopitelně umožníme se o zvolení cesty pokusit kdykoliv později.

Povšimněte si, že po otevření samotného souboru využijeme knihovnu QTextStream, které předáme parametr typu QFile. Jakmile tak provedeme, můžeme s daty velmi pohodlně zacházet. Začnou-li vás trápit problémy s diakritikou, zkontrolujte, zda máte správně nastaveno kódování.

Díky cyklu s podmínkou na začátku zajistíme obdržení samotných řádků. Ty poté ukládáme do koncové proměnné výsledek. Ještě než se tak stane, však přidáme slíbený párový tag H3. Ten navíc obohacuje vlastnost style udávající barvu písma. Metoda insertHtml pak již na závěr celé dílo sama dokoná.

Designérský režim

Po vytvoření projektu se přepneme do módu design. Postupně přidáme oba combo boxy a několik Labelů. Nezapomeňte si jednotlivé objekty vhodně pojmenovat, díky čemuž si usnadníte následující programování.

Tvorba zdrojového kódu

Mezi pro nás nejdůležitější funkci combo boxu patří addItem. V konstruktoru třídy si s její pomocí naplníme ovládací prvek. Položky se přidávají vždy za poslední volbu a disponují rovněž vlastním interním id, které se počítá od nuly. To ostatně vysvětluje, proč jsem vytvořil i pomocnou funkci procistit. Původně přitom její tělo obsahovalo iterační cyklus, včas mě však zarazila hodnota vrácená s pomocí count. Ta totiž prozrazuje celkový počet záznamů a nikoliv nejvyšší id. Tuto hodnotu si musíme sami dopočítat, tedy odečíst jedničku. Procistit musíme zavolat po každé změně výběru, protože v opačném případě by se druhý combo box postupně rozrůstal o duplicitní informace. Spojení signálů a slotů pochopitelně naleznete opět v konstruktoru. Volají se v podstatě jen dvě funkce – zmena a souhrn. Ta první se postará o obměnu příslušného combo boxu. Druhá nám sestaví informační QString, který poté nastaví vlastnosti text u Labelu umístěného ve spodní části okna. Povšimněte si rovněž, že se plně obejdeme bez tlačítek. Veškeré úpravy probíhají ihned poté, co uživatel změní svůj názor.

#include „widget.h“
#include „ui_widget.h“

Widget::Widget(QWidget *parent) :
QWidget(parent),
ui(new Ui::Widget)
{
ui->setupUi(this);

ui->cb_typCesty->addItem(„Po zemi“);
ui->cb_typCesty->addItem(„Ve vzduchu“);

connect(ui->cb_typCesty,SIGNAL(activated(int)),this,SLOT(zmena(int)));
connect(ui->cb_typCesty,SIGNAL(activated(int)),this,SLOT(souhrn()));
connect(ui->cb_dopravniProstredek,SIGNAL(activated(int)),this,SLOT(souhrn()));
zmena(ZEME);
souhrn();

}

Widget::~Widget()
{
delete ui;
}

void Widget::zmena(int id){
procistit(ui->cb_dopravniProstredek);

if (id == ZEME){
ui->cb_dopravniProstredek->addItem(„Automobil“);
ui->cb_dopravniProstredek->addItem(„Motocykl“);
}else if (id == VZDUCH){
ui->cb_dopravniProstredek->addItem(„Letadlo“);
ui->cb_dopravniProstredek->addItem(„Helikoptéra“);
}
}

void Widget::procistit(QComboBox*& obj){
while(obj->count() != 0){
obj->removeItem(obj->count()-1);
}

}

void Widget::souhrn(){
QString typ = ui->cb_typCesty->itemText(ui->cb_typCesty->currentIndex());
QString prostredek = ui->cb_dopravniProstredek->itemText(ui->cb_dopravniProstredek->currentIndex());
QString vysledek = „Typ cesty: „+ typ +“. Dopravní prostředek: “ + prostredek;
ui->l_vysledek->setText(vysledek);
}

Enum

Závěrem ještě poukáži na výčtový typ pojmenovaný překvapivě jako TYP. Konstanta ZEME zastupuje číselnou hodnotu 0, zatímco VZDUCH symbolizuje 1. Zdrojový kód díky tomu získává na přehlednosti.

#ifndef WIDGET_H
#define WIDGET_H

#include
#include

#include

enum TYP{ZEME,VZDUCH};

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
Q_OBJECT

public:
explicit Widget(QWidget *parent = 0);
~Widget();

public slots:
void zmena(int);
void souhrn();

private:
Ui::Widget *ui;
void procistit(QComboBox*& obj);
};

#endif // WIDGET_H

Práce v designérském režimu

Při zakládání nového projektu nezapomeňte, že tentokrát budeme vycházet z třídy QMainWindow. Po otevření vzhledu okna začneme s přidáním dvou prvků line edit a několika popisků (label). Kompletně vynecháme jakákoliv tlačítka a vrhneme se na ovládací nabídku. Jednoduše vypíšeme názvy jednotlivých položek v menu, které se následně usídlí ve spodní záložce Action editor. Po kliknutí na některou z nich se nám otevře okno, ve kterém lze nastavit mnoho užitečných věcí. Konkrétně si ze souboru přidáme vhodnou ikonu. Pokud žádnou nedisponujete, vyzkoušejte tzv. projekt Nuvola. Jedná se o obsáhlou sadu ikonek v nejpoužívanějších rozměrech uvolněnou pod licencí LGPL.

Horké klávesy

Vždy se vyplácí aplikaci navrhovat takovým způsobem, aby ji bylo možno ovládat bez pomoci kurzoru myši. Stačí před název položky přidat znak ampersand (&) a následně lze využít následující písmeno při kombinaci s klávesou ALT pro získání kontroly nad programem. Vaši práci ocení například majitelé notebooků, kteří nemají po ruce myš a s touchpadem si příliš nerozumí.

Toolbar

Jakmile máte veškeré objekty seskupené v Action Editoru nastavené dle vašeho přání, přejděte k vytvoření toolbaru. Stačí přetáhnout libovolnou položku na požadované místo v toolbaru, který se automaticky nachází pod menu. O správném postupu vás okamžitě ubezpečí přidělená ikonka.

Zdrojový kód

Další postup již není nijak náročný. Stačí jen získat údaje z obou line editů, provést součet a výsledek nastavit jako text patřičnému labelu. Nezapomeňte rovněž propojit oba signály. Povšimněte si obzvláště slotu close(), který se postará o hladké ukončení programu. Nezapomeňte rovněž zajistit zobrazení výsledku získaného během průběhu secti() po kliknutí na Sečíst v menu.

#include „hlavniokno.h“
#include „ui_hlavniokno.h“
#include
#include

HlavniOkno::HlavniOkno(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::HlavniOkno)
{
ui->setupUi(this);
setWindowTitle(„Menu“);

QIntValidator *val;
val = new QIntValidator(this);

ui->le_prvni->setValidator(val);
ui->le_druhe->setValidator(val);

connect(ui->action_Secist,SIGNAL(triggered()),this,SLOT(secti()));
connect(ui->action_Konec,SIGNAL(triggered()),this,SLOT(close()));
}

HlavniOkno::~HlavniOkno()
{
delete ui;
}

void HlavniOkno::secti(){
int prvni,druhe,vysledek;
QString pom;
prvni = ui->le_prvni->text().toInt();
druhe = ui->le_druhe->text().toInt();

vysledek = prvni + druhe;

ui->l_vysledek->setText(pom.setNum(vysledek));

}

#ifndef HLAVNIOKNO_H
#define HLAVNIOKNO_H

#include

namespace Ui {
class HlavniOkno;
}

class HlavniOkno : public QMainWindow
{
Q_OBJECT

public:
explicit HlavniOkno(QWidget *parent = 0);
~HlavniOkno();

private:
Ui::HlavniOkno *ui;
public slots:
void secti();
};

#endif // HLAVNIOKNO_H

Poměrně dlouho jsem přemýšlel, jaký příklad pro tuto problematiku zvolit. Nakonec došlo ke stvoření jednoduché aplikace, která nás vybízí k výběru několika druhů sýra. Po stisknutí na tlačítko nám následně všechny zvolené potraviny vypíše. Po dalším rozšíření by tento program mohl například využívat kuchař v pizzerii, který si přesně nepamatuje, co si zákazníci vlastně objednali.

#ifndef WIDGET_H
#define WIDGET_H

#include
#include

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
Q_OBJECT

public:
explicit Widget(QWidget *parent = 0);
~Widget();

private:
Ui::Widget *ui;
QButtonGroup *syr_skupina;

public slots:
void syr();
};

#endif // WIDGET_H

#include „widget.h“
#include „ui_widget.h“

Widget::Widget(QWidget *parent) :
QWidget(parent),
ui(new Ui::Widget)
{
ui->setupUi(this);

syr_skupina = new QButtonGroup(this);
syr_skupina->addButton(ui->ch_hermelin,1);
syr_skupina->addButton(ui->ch_eidam,2);
syr_skupina->addButton(ui->ch_mozzarella,3);
syr_skupina->setExclusive(false);

}

Widget::~Widget()
{
delete ui;
}

void Widget::syr(){
QAbstractButton *vracene;
QString vysledek = „Objedávka: \n“;
int pocet = 0;

for(int i = 1; i < 4;i++){
vracene = syr_skupina->button(i);
if (vracene->isChecked()){
vysledek += vracene->text() + „\n“;
pocet++;
}
}

if(pocet == 0){
vysledek += „Není vybrán žádný sýr!“;
}else{
vysledek += „Přejeme dobrou chuť!“;
}

ui->l_vysledek->setText(vysledek);
}

Skupina prvků v podání QbuttonGroup

V návrhářském režimu stačí přidat několik popisných labelů a samotné checkboxy. Nezapomeňte rovněž na ovládací prvek, ve kterém se zobrazí získaný výsledek. V našem případě se opět jedná o klasický label. Zajímavější kroky na nás čekají v konstruktoru. Vytvoříme si totiž skupinu prvků tzv. QbuttonGroup a přidáme do ní jednotlivé checkboxy. Musíme u nich specifikovat i vlastní id, které později budeme potřebovat při procházení v iteračním cyklu. S pomocí setExclusive dosáhneme toho, že se celá skupina začne chovat dle našich požadavků. Pokud bychom jako parametr předali true, získáme checkboxy fungující jako radio buttony.

Zpracování

Ve slotu, který se spouští po signálu clicked z tlačítka se provádí samotný výpis. V cyklu si projdeme jednotlivé checkboxy a ověříme si, zda je uživatel zaškrtnul. Pokud ano, přidáme jejich popisek (text) do stringové proměnné, kterou nakonec nastavíme s pomocí setText výslednému labelu v hlavním okně.

Přípravy

Nejprve si přidáme do prostoru okna dva potřebné elementy. Jde o již zmíněné tlačítko a popisek (Label). Nezapomeňte vždy zadat vhodné objectName, což nám usnadní život při samotném programování. V případě objektu třídy QLabel rovněž nastavte vlastnost text na nějakou pěknou větu, kterou po kliknutí uživatele překvapíme. Pokud si nyní celý projekt zkompilujete a spustíte, zaskočí vás, že tento řetězec se v okně vyskytuje. Abychom tomu zabránili a vytvořili tak dojem skrytého prvku, zavoláme v konstruktoru naší třídy odpovídající funkci hide().

Okno před kliknutím

Okno po kliknutí

Propojení signálu se slotem

Nyní již vše funguje tak jak má. Po inicializaci programu můžete pouze kliknout na tlačítko. To však pochopitelně momentálně neví, co má v případě signálu clicked() vykonat. K tomuto účelu musíme vytvořit v úvodu nastíněné propojení. Učiníme tak opět v konstruktoru s pomocí funkce connect. Povšimněte si vyžadovaných parametrů. Nejprve specifikujeme objekt, který odesílá signál. Následně již přijde na řadu jeho konkretizace. Poté pokračujeme zadáním příjemce. V našem případě se zde nachází slovíčko this, protože slot uvedený jako poslední patří do stejné třídy, ze které je volána funkce connect. Sloty si tak ve své podstatě můžete představit jako naprosto běžné funkce, které vykonávají vámi určené věci. K jejich zavolání přitom slouží právě signály, které mnoha způsoby produkují objekty přidané v návrhářském režimu.

#include „okno.h“
#include „ui_okno.h“

okno::okno(QWidget *parent) :
QWidget(parent),
ui(new Ui::okno)
{
ui->setupUi(this);

ui->l_text->hide();

connect(ui->pb_text,SIGNAL(clicked()),this,SLOT(zobraz()));
}

okno::~okno()
{
delete ui;
}

void okno::zobraz(){
ui->l_text->show();
}

Rád bych vás dále upozornil na pár řádků kódu v hlavičkovém souboru třídy. Jde především o sekci public slots: (pozor na zrádné a zpočátku opomíjené ‚s‚ na konci!). Zde se uvádí deklarace slotů, které bude program využívat.

#ifndef OKNO_H
#define OKNO_H

#include

namespace Ui {
class okno;
}

class okno : public QWidget
{
Q_OBJECT

public:
explicit okno(QWidget *parent = 0);
~okno();

private:
Ui::okno *ui;

public slots:
void zobraz();
};

#endif // OKNO_H

Třída QintValidator

Způsobů, jak zkontrolovat zadaná data je pochopitelně několik. Ukážeme si však postup, který nezabere mnoho času a zvládne jej i začátečník. V rámci tohoto jednoduchého příkladu jsem se rozhodl vytvořit okno, ve kterém na nás bude po inicializaci čekat jeden lineEdit a Label, který vysvětlí, jaký vstup vyžadujeme.

Práci v designérském módu určitě zvládnete, stačí jen přidat oba prvky a vhodně je pojmenovat. Mnohem zajímavější činnost začíná ve třídě, která přísluší otevíranému oknu. Zde našemu lineEditu nastavíme validátor, který se postará o omezení rozsahu zadávaných hodnot. Nejprve ho však musíme vytvořit. K tomuto kroku přistoupíme v konstruktoru zvolené třídy, protože pochopitelně chceme, aby ke kontrole údajů docházelo vždy.

#include „widget.h“
#include „ui_widget.h“
#include

Widget::Widget(QWidget *parent) :
QWidget(parent),
ui(new Ui::Widget)
{
ui->setupUi(this);

QIntValidator * validator;
validator = new QIntValidator(0,100,this);

ui->lineEdit->setValidator(validator);
}

Widget::~Widget()
{
delete ui;
}

Světe div se, máme hotovo. Pokud svůj program nyní zkompilujete, zjistíte, že nic jiného než integerové číslo v rozmezí 0 až 100 do lineEditu skutečně nelze zapsat. Konstruktor objektu QintValidator je pochopitelně přetížený, a proto pokud potřebujete, můžete stanovený limit velmi jednoduše odstranit. Stačí, když příslušný řádek zaměníte za tento:

validator = new QIntValidator(this);

Stále budete těžit z toho, že uživatel dokáže vložit jen platné integerové číslo. Ovšem nezapomeňte, že nyní již může jít i do záporných hodnot. Uvedené řešení se proto nehodí v případě, kdy očekáváte pouze kladný rozsah. Jako zajímavý způsob řešení uvedené situace se mi jeví stanovení horní hranice na konstantu INT_MAX, která symbolizuje maximální hodnotu integeru, což pro naše účely plně postačuje.

validator = new QIntValidator(0,INT_MAX,this);

Příchozí dotazy:

• Přidat komentář Jméno Zadejte validační kód