Programování v jazyce C++ pro 4. ročník

Transkript

VY_32_INOVACE_EL_10_01
Digitální učební materiál
Seznamy - použití v aplikaci (1. část)
Šablona: III/2 - Inovace a zkvalitnění výuky prostřednictvím ICT
Sada: VY_32_INOVACE_EL_10 - Programování v jazyce C++ pro 4. ročník
DUM: VY_32_INOVACE_EL_10_01
Anotace: Postup vytvoření aplikace na procvičení práce se seznamy, jejich použití
v aplikaci a seznámení s dalšími komponentami
Autor: Ing. Petr Neumann
Škola: Střední průmyslová škola, Hronov, Hostovského 910
Obor: Počítačové řídicí systémy
Předmět: Programování
Ročník: 4.
Použitá literatura: Václav Kadlec - Učíme se programovat v C++Builder a jazyce C++
Příprava:
Seznamy slouží uživateli aplikace jako nabídka možností, ze kterých může
jednu položku vybrat. Většina seznamů má položky typu strings = řetězce znaků
(texty), proto u nich lze používat stejné metody jako u komponenty Memo. Seznamy
umožňují položky nejen vybírat, ale také setřídit podle abecedy, editovat, přidávat a
odebírat. Mezi nejčastěji používané komponenty patří:
a) ListBox - jednoduchý textový seznam, nejdůležitějšími vlastnostmi jsou Items,
ItemIndex a Sorted
b) ComboBox - rozbalovací textový seznam
c) CheckListBox - textový seznam s možností zaškrtávání položek
d) ListView - prohlížeč seznamů
Zadání - 1. část:
Vytvořte aplikaci „Seznamy1“ - na formuláři jsou umístěny dva různé typy
komponent pro práci se seznamy (aplikace slouží k vytváření seznamu skladeb od
různých interpretů). Stisknutím jednoho tlačítka lze přidat do seznamu skladbu,
druhým tlačítkem lze přidat interpreta, třetím tlačítkem lze odstranit skladbu a čtvrtým
tlačítkem lze odstranit interpreta.
Řešení - 1. část:
Spusťte vývojové prostředí, upravte velikost formuláře a umístěte na něj
komponenty. Zdrojový kód a projekt uložte. Pojmenujte všechny komponenty.
Vygenerujte funkci k události OnCreate pro frmSeznamy1 a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy1::FormCreate(TObject *Sender)
{
this->Caption = "Seznamy1";
this->Constraints->MinHeight = 284;
this->Constraints->MinWidth = 518;
lblNadpis1->Caption = "Skladba :";
lblNadpis2->Caption = "Interpret :";
edtPolozka->Text = "Láska je láska";
btnPridat1->Caption = "P ř idat skladbu";
btnPridat1->Width = 100;
btnPridat2->Caption = "P ř idat interpreta";
btnPridat2->Width = 100;
btnOdstranit1->Caption = "Odstranit skladbu";
btnOdstranit1->Width = 100;
btnOdstranit2->Caption = "Odstranit interpreta";
btnOdstranit2->Width = 100;
chbRadit->Caption = "Řadit položky";
chbRadit->Checked = true;
lbxSeznam1->Columns = 1;
lbxSeznam1->Sorted = true;
cbxSeznam2->Style = csSimple;
cbxSeznam2->Height = 185;
cbxSeznam2->Sorted = true;
cbxSeznam2->Items->Add("Lucie Bílá");
cbxSeznam2->Items->Add("Karel Gott");
cbxSeznam2->Items->Add("Helena Vondrá čková");
cbxSeznam2->Text = "";
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OClick pro btnPridat1,
btnPridat2, btnOdstranit1, btnOdstranit2 a chbRadit. Do zdrojového kódu zapište
tento text:
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy1::btnPridat1Click(TObject *Sender)
{
if (edtPolozka->Text == "")
ShowMessage("Zadej název skladby !!!");
else
{
if (cbxSeznam2->Text == "")
ShowMessage("Vyber jméno interpreta !!!");
else
{
lbxSeznam1->Items->Add(edtPolozka->Text + " - " + cbxSeznam2->Text);
edtPolozka->Clear();
}
}
edtPolozka->SetFocus();
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy1::btnPridat2Click(TObject *Sender)
{
if (cbxSeznam2->Text == "")
ShowMessage("Zadej jméno interpreta !!!");
else
{
cbxSeznam2->Items->Add(cbxSeznam2->Text);
cbxSeznam2->Text = "";
}
cbxSeznam2->SetFocus();
}
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy1::btnOdstranit1Click(TObject *Sender)
{
lbxSeznam1->Items->Delete(lbxSeznam1->ItemIndex);
}
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy1::btnOdstranit2Click(TObject *Sender)
{
cbxSeznam2->Items->Delete(cbxSeznam2->ItemIndex);
}
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy1::chbRaditClick(TObject *Sender)
{
lbxSeznam1->Sorted = chbRadit->Checked;
cbxSeznam2->Sorted = chbRadit->Checked;
}
//------------------------------------------------------------------------
Program uložte a přeložte.
Seznamy - použití v aplikaci (2. část)
Anotace: Postup vytvoření aplikace na procvičení práce se seznamy, jejich použití
Ročník: 4.
Vytvořte aplikaci „Seznamy2“ - na formuláři jsou umístěny různé komponenty
pro práci se seznamy (aplikace slouží k procvičení práce se seznamy). Stisknutím
jednoho tlačítka lze načíst soubor „zaznamy.txt“, druhým tlačítkem lze záznamy
rozdělit do dvou seznamů a třetím tlačítkem lze záznamy strukturovaně zobrazit.
Vygenerujte funkci k události OnCreate pro frmSeznamy2 a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy2::FormCreate(TObject *Sender)
{
this->Caption = "Seznamy2";
this->BorderStyle = bsDialog;
this->Position = poScreenCenter;
memZaznam->Clear();
lbxZaznam1->Columns = 1;
lbxZaznam1->Sorted = false;
lbxZaznam2->Columns = 1;
lbxZaznam2->Sorted = false;
lvwZaznam->ViewStyle = vsReport;
lvwZaznam->ShowColumnHeaders = true;
lvwZaznam->Width = 244;
//lvwZaznam->Columns->Add();
lvwZaznam->Column[0]->Caption = " č. :";
lvwZaznam->Column[0]->Width = 40;
lvwZaznam->Column[1]->Caption = "typ záznamu :";
lvwZaznam->Column[2]->Caption = "obsah záznamu :";
btnNacti->Caption = "Na čti soubor do Memo";
btnRozdel->Caption = "Rozděl záznamy do ListBoxů";
btnZobraz->Caption = "Zobraz záznamy v ListView";
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro btnNacti,
btnRozdel a btnZobraz. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy2::btnNactiClick(TObject *Sender)
{
memZaznam->Lines->LoadFromFile("zaznamy.txt");
btnRozdel->SetFocus();
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy2::btnRozdelClick(TObject *Sender)
{
lbxZaznam1->Clear();
lbxZaznam2->Clear();
for (int i = 0; i < memZaznam->Lines->Count; i += 2)
{
lbxZaznam1->Items->Add(memZaznam->Lines->Strings[i]);
lbxZaznam2->Items->Add(memZaznam->Lines->Strings[i + 1]);
}
btnZobraz->SetFocus();
}
//-----------------------------------------------------------------------void __fastcall TfrmSeznamy2::btnZobrazClick(TObject *Sender)
{
lvwZaznam->Clear();
for (int i = 0; i < lbxZaznam1->Count; i++)
{
lvwZaznam->Items->Add();
lvwZaznam->Items->Item[i]->Caption = IntToStr(i + 1);
lvwZaznam->Items->Item[i]->SubItems->Add(lbxZaznam1->Items->Strings[i]);
lvwZaznam->Items->Item[i]->SubItems->Add(lbxZaznam2->Items->Strings[i]);
}
}
//------------------------------------------------------------------------
Menu (uživatelské nabídky) - použití v aplikaci
Anotace: Postup vytvoření aplikace na procvičení práce s uživatelskými nabídkami,
jejich použití v aplikaci a seznámení s dalšími komponentami
Ročník: 4.
Příprava:
Uživatelské nabídky jsou běžnou součástí většiny aplikací. Slouží ke
komunikaci uživatele s aplikací, pomocí položek nabídky sděluje uživatel aplikaci, co
od ní požaduje. Položek je několik typů - příkazy, nastavení, dialogy a vnoření
(submenu). Při tvorbě menu je třeba dodržovat několik zásad, např. řídit se
zvyklostmi uživatele. K vytvoření menu se používá komponenta MainMenu, přes
kterou spustíme MenuDesigner. Z mnoha vlastností položek zpravidla využíváme
pouze Name a Caption.
Zadání:
Vytvořte aplikaci „Menu“ - na formuláři jsou umístěny tři Label, tři Button a tři
Panel. Pomocí položek menu lze třemi různými způsoby jednotlivé komponenty skrýt
a zase ukázat.
Řešení:
Vygenerujte funkci k události OnCreate pro frmMenu a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmMenu::FormCreate(TObject *Sender)
{
this->Caption = "Menu";
lblNadpis1->Caption = "Nadpis 1";
btnTlacitko1->Caption = "Tla čítko 1";
pnlPanel1->Caption = "Panel 1";
pmnPanel1->Checked = true;
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro jednotlivé
položky menu. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmMenu::pmnUkazN1Click(TObject *Sender)
{
lblNadpis1->Visible = true;
}
{
}
{
}
//-----------------------------------------------------------------------void __fastcall TfrmMenu::pmnSkryjN1Click(TObject *Sender)
{
lblNadpis1->Visible = false;
}
{
}
{
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmMenu::pmnZmenaT1Click(TObject *Sender)
{
btnTlacitko1->Visible = ! btnTlacitko1->Visible;
if (btnTlacitko1->Visible)
pmnZmenaT1->Caption = "Skryj Tla čítko 1";
else
pmnZmenaT1->Caption = "Ukaž Tla čítko 1";
}
{
else
}
{
else
}
//-----------------------------------------------------------------------void __fastcall TfrmMenu::pmnPanel1Click(TObject *Sender)
{
pnlPanel1->Visible = ! pnlPanel1->Visible;
pmnPanel1->Checked = ! pmnPanel1->Checked;
}
{
}
{
}
//------------------------------------------------------------------------
Časovače a další komponenty - použití v aplikaci
Anotace: Postup vytvoření aplikace na procvičení práce s časovači, tabulkami,
ukazateli průběhu, jejich použití v aplikaci a seznámení s dalšími komponentami
Ročník: 4.
Příprava:
Timer - časovač slouží k vykonání nějaké akce po uplynutí nastavené doby
nebo k pravidelnému opakování nějaké akce v nastaveném intervalu, nejdůležitějšími
vlastnostmi jsou Enabled a Interval. Další použité komponenty:
StringGrid - mřížka (tabulka) s texty, nejdůležitějšími vlastnostmi jsou Cells = buňky
(jedná se o dvourozměrné pole), Cols (columns) = sloupce a Rows = řádky
CGauge - ukazatel průběhu se zobrazením procent, nejdůležitějšími vlastnostmi jsou
MinValue, MaxValue a Progress
ProgressBar - ukazatel průběhu (jiná varianta), nejdůležitějšími vlastnostmi jsou Min,
Max a Position
Zadání:
Vytvořte aplikaci „Časovače“ - na formuláři jsou umístěna čtyři tlačítka, která
spouští čtyři časovače. Každý časovač ovládá jinou akci - blikající tabulka, mizející
nápis, hodiny a rostoucí průběhy.
Řešení:
Vygenerujte funkci k události OnCreate pro frmCasovace a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmCasovace::FormCreate(TObject *Sender)
{
this->Caption = "Časova če";
btnMrizka->Caption = "M ř ížka";
btnPrekvapeni->Caption = "P ř ekvapení";
btnHodiny->Caption = "Hodiny";
btnPrubeh->Caption = "Průběh";
tmrMrizka->Enabled = false;
tmrMrizka->Interval = 400;
tmrPrekvapeni->Enabled = false;
tmrPrekvapeni->Interval = 3000;
tmrHodiny->Enabled = false;
tmrHodiny->Interval = 1000;
tmrPrubeh->Enabled = false;
tmrPrubeh->Interval = 100;
sgrMrizka->ColCount = 3;
sgrMrizka->RowCount = 6;
sgrMrizka->FixedCols = 0;
sgrMrizka->FixedRows = 3;
sgrMrizka->FixedColor = clYellow;
lblPrekvapeni->Caption = "Vážený programátore, č tete mne rychle, protože
za 3 sekundy zase zmizím, Váš Label";
lblPrekvapeni->Visible = false;
pnlHodiny->Caption = "Reálný č as";
pnlHodiny->Font->Color = clRed;
pnlHodiny->Font->Size = 24;
cggPrubeh->BackColor = clBtnFace;
cggPrubeh->ForeColor = clLime;
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro btnMrizka,
btnPekvapeni, btnHodiny, btnPrubeh a OnTimer pro tmrMrizka, tmrPekvapeni,
tmrHodiny, tmrPrubeh. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmCasovace::btnMrizkaClick(TObject *Sender)
{
tmrMrizka->Enabled = true;
for (int i = 0; i < sgrMrizka->ColCount; i++)
for (int j = 0; j < sgrMrizka->RowCount; j++)
sgrMrizka->Cells[i][j] = "s." + IntToStr(i) + ", ř ." + IntToStr(j);
btnPrekvapeni->SetFocus();
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmCasovace::tmrMrizkaTimer(TObject *Sender)
{
if (sgrMrizka->FixedColor == clYellow)
sgrMrizka->FixedColor = clWindow;
else
sgrMrizka->FixedColor = clYellow;
}
//-----------------------------------------------------------------------void __fastcall TfrmCasovace::btnPrekvapeniClick(TObject *Sender)
{
tmrPrekvapeni->Enabled = true;
lblPrekvapeni->Visible = true;
btnHodiny->SetFocus();
}
//-----------------------------------------------------------------------void __fastcall TfrmCasovace::tmrPrekvapeniTimer(TObject *Sender)
{
tmrPrekvapeni->Enabled = false;
lblPrekvapeni->Visible = false;
}
//-----------------------------------------------------------------------void __fastcall TfrmCasovace::btnHodinyClick(TObject *Sender)
{
pnlHodiny->Caption = TimeToStr(Time());
tmrHodiny->Enabled = true;
btnPrubeh->SetFocus();
}
//-----------------------------------------------------------------------void __fastcall TfrmCasovace::tmrHodinyTimer(TObject *Sender)
{
pnlHodiny->Caption = TimeToStr(Time());
}
//-----------------------------------------------------------------------void __fastcall TfrmCasovace::btnPrubehClick(TObject *Sender)
{
cggPrubeh->Progress = 0;
pbrPrubeh->Position = 0;
//WinAPI funkce:
SendMessage(pbrPrubeh->Handle, PBM_SETBARCOLOR, 0, clLime);
tmrPrubeh->Enabled = true;
}
//-----------------------------------------------------------------------void __fastcall TfrmCasovace::tmrPrubehTimer(TObject *Sender)
{
cggPrubeh->Progress++;
pbrPrubeh->Position++;
}
//------------------------------------------------------------------------
Stavový řádek - použití v aplikaci
Anotace: Postup vytvoření aplikace na procvičení práce se stavovým řádkem, jeho
použití v aplikaci a seznámení s dalšími komponentami
Ročník: 4.
Příprava:
Stavový řádek je běžnou součástí většiny aplikací. Slouží k informování
uživatele o důležitých událostech a aktuálních nastaveních. K zobrazení informací
slouží vlastnost Panels->Items = panely->položky. Položky jsou typu strings =
řetězce znaků (texty). K vytvoření stavového řádku se používá komponenta
StatusBar, přes kterou spustíme Editing. Z mnoha vlastností položek zpravidla
využíváme pouze Text a Width.
Zadání:
Vytvořte aplikaci „Stavový řádek“ - na formuláři je umístěn Panel. Pomocí
položek menu lze nastavovat jeho vlastnosti, všechna nastavení se zobrazují na
stavovém řádku.
Řešení:
Vygenerujte funkci k události OnCreate pro frmStav a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmStav::FormCreate(TObject *Sender)
{
this->Caption = "Stavový ř ádek";
this->BorderStyle = bsSingle;
pnlPanel->Caption = "Panel";
pnlPanel->Height = 50;
pnlPanel->Width = 50;
pnlPanel->Left = 25;
pnlPanel->Top = 25;
stbStatus->Panels->Items[0]->Text = "Align: None";
stbStatus->Panels->Items[0]->Width = 75;
stbStatus->Panels->Items[1]->Text = "Color: BtnFace";
stbStatus->Panels->Items[2]->Text = "Font-Color: WindowText";
stbStatus->Panels->Items[3]->Text = "Font-Size: 8";
stbStatus->Panels->Items[4]->Text = "Font-Style: None";
stbStatus->Panels->Items[5]->Text = "Height: " + IntToStr(pnlPanel->Height);
stbStatus->Panels->Items[6]->Text = "Width: " + IntToStr(pnlPanel->Width);
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro jednotlivé
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnNoneClick(TObject *Sender)
{
pnlPanel->Align = alNone;
stbStatus->Panels->Items[0]->Text = "Align: None";
pnlPanel->Left = 25;
pnlPanel->Top = 25;
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnTopClick(TObject *Sender)
{
pnlPanel->Align = alTop;
stbStatus->Panels->Items[0]->Text = "Align: Top";
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnBottomClick(TObject *Sender)
{
pnlPanel->Align = alBottom;
stbStatus->Panels->Items[0]->Text = "Align: Bottom";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnLeftClick(TObject *Sender)
{
pnlPanel->Align = alLeft;
stbStatus->Panels->Items[0]->Text = "Align: Left";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnRightClick(TObject *Sender)
{
pnlPanel->Align = alRight;
stbStatus->Panels->Items[0]->Text = "Align: Right";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnClientClick(TObject *Sender)
{
pnlPanel->Align = alClient;
stbStatus->Panels->Items[0]->Text = "Align: Client";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnBtnFaceClick(TObject *Sender)
{
pnlPanel->Color = clBtnFace;
stbStatus->Panels->Items[1]->Text = "Color: BtnFace";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnRedClick(TObject *Sender)
{
pnlPanel->Color = clRed;
stbStatus->Panels->Items[1]->Text = "Color: Red";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnGreenClick(TObject *Sender)
{
pnlPanel->Color = clGreen;
stbStatus->Panels->Items[1]->Text = "Color: Green";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnBlueClick(TObject *Sender)
{
pnlPanel->Color = clBlue;
stbStatus->Panels->Items[1]->Text = "Color: Blue";
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmStav::smnWindowTextClick(TObject *Sender)
{
pnlPanel->Font->Color = clWindowText;
stbStatus->Panels->Items[2]->Text = "Font-Color: WindowText";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::smnRedClick(TObject *Sender)
{
pnlPanel->Font->Color = clRed;
stbStatus->Panels->Items[2]->Text = "Font-Color: Red";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::smnGreenClick(TObject *Sender)
{
pnlPanel->Font->Color = clGreen;
stbStatus->Panels->Items[2]->Text = "Font-Color: Green";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::smnBlueClick(TObject *Sender)
{
pnlPanel->Font->Color = clBlue;
stbStatus->Panels->Items[2]->Text = "Font-Color: Blue";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::smn8Click(TObject *Sender)
{
pnlPanel->Font->Size = 8;
}
{
}
{
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::smnNoneClick(TObject *Sender)
{
pnlPanel->Font->Style = pnlPanel->Font->Style >> fsBold >> fsItalic;
stbStatus->Panels->Items[4]->Text = "Font-Style: None";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::smnBoldClick(TObject *Sender)
{
pnlPanel->Font->Style = pnlPanel->Font->Style << fsBold >> fsItalic;
stbStatus->Panels->Items[4]->Text = "Font-Style: Bold";
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmStav::smnItalicClick(TObject *Sender)
{
pnlPanel->Font->Style = pnlPanel->Font->Style >> fsBold << fsItalic;
stbStatus->Panels->Items[4]->Text = "Font-Style: Italic";
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnH50Click(TObject *Sender)
{
}
{
}
{
}
//-----------------------------------------------------------------------void __fastcall TfrmStav::pmnW50Click(TObject *Sender)
{
}
{
}
{
}
//------------------------------------------------------------------------
Soubory - použití v aplikaci
Anotace: Postup vytvoření aplikace na procvičení práce se soubory, jejich použití
Ročník: 4.
Příprava:
Soubory slouží k ukládání dat, proto jsou důležitou součástí většiny aplikací.
K základním činnostem se soubory patří čtení a zápis dat, soubor se ale musí
nejprve otevřít a potom zase zavřít. Samotná data jsou často uložena v podobě
prostého (neformátovaného) textu (soubory typu txt). Pro práci se soubory máme
k dispozici například tyto možnosti:
a) použití knihovny funkcí standardních vstupů a výstupů (stdio.h) - pak lze použít
funkce fopen(), fscanf() a fclose()
b) použití některé z komponent, která má metody pro práci se soubory - pak lze
použít metody LoadFromFile() a SaveToFile()
c) použití systémových funkcí, které využívají „handle“ souboru - pak lze použít
funkce FileExists(), FileCreate(), FileOpen(), FileRead(), FileWrite(), FileSeek() a
FileClose()
d) použití standardních dialogů OpenDialog a SaveDialog - probereme v další části
Vytvořte aplikaci „Soubory1“ - na formuláři jsou umístěny dvě komponenty
Memo, do kterých se stisknutím tlačítka načte obsah souboru „data.txt“ pokaždé
jiným způsobem.
Spusťte vývojové prostředí,
upravte velikost formuláře a
umístěte na něj komponenty.
Zdrojový kód a projekt uložte. Pojmenujte všechny komponenty. Vygenerujte funkci
k události OnCreate pro frmSoubory1 a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmSoubory1::FormCreate(TObject *Sender)
{
this->Caption = "Soubory1";
btnSoubor1->Caption = "Load";
btnSoubor2->Caption = "Load";
memSoubor1->Clear();
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro btnSoubor1
a btnSoubor2. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------#include <stdio.h>
//-----------------------------------------------------------------------void __fastcall TfrmSoubory1::btnSoubor1Click(TObject *Sender)
{
FILE *soubor;
int cislo;
soubor = fopen("data.txt", "r");
while (fscanf(soubor, "%d", &cislo) != EOF)
memSoubor1->Lines->Add(IntToStr(cislo));
fclose(soubor);
}
//-----------------------------------------------------------------------void __fastcall TfrmSoubory1::btnSoubor2Click(TObject *Sender)
{
memSoubor2->Lines->LoadFromFile("data.txt");
}
//------------------------------------------------------------------------
Vytvořte aplikaci „Soubory2“ - na formuláři je umístěna komponenta ListBox,
do které se stisknutím tlačítka načte obsah souboru „osoby.txt“ opět jiným způsobem.
Další tlačítka umožňují editovat seznam a uložit ho do souboru.
Řešení - 2. část :
Vygenerujte funkci k události OnCreate pro frmSoubory2 a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmSoubory2::FormCreate(TObject *Sender)
{
this->Caption = "Soubory2";
btnNacti->Caption = "Na čti soubor";
btnPridej->Caption = "P ř idej osobu";
btnOdeber->Caption = "Odeber osobu";
btnUloz->Caption = "Ulož soubor";
btnVymaz->Caption = "Vymaž okno";
lbxSeznam->Sorted = true;
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro btnNacti,
btnPridej, btnOdeber, btnUloz a btnVymaz. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------#define osoby "osoby.txt"
//-----------------------------------------------------------------------void __fastcall TfrmSoubory2::btnNactiClick(TObject *Sender)
{
int handle;
if (!FileExists(osoby))
ShowMessage("Soubor neexistuje !!!");
else
{
handle = FileOpen(osoby, fmOpenRead);
if (handle == -1)
ShowMessage("Soubor nelze otev ř ít pro č tení !!!");
else
{
int delka = FileSeek(handle, 0, 2);
PChar buffer = StrAlloc(delka + 1);
FileSeek(handle, 0, 0);
int precteno = FileRead(handle, buffer, delka);
if (precteno < delka)
ShowMessage("Soubor nebyl na čten celý !!!");
else
{
buffer[delka] = '\0';
lbxSeznam->Items->Text = AnsiString(buffer);
}
StrDispose(buffer);
FileClose(handle);
}
}
}
//-----------------------------------------------------------------------void __fastcall TfrmSoubory2::btnPridejClick(TObject *Sender)
{
AnsiString prijmeni = "***";
AnsiString krestni = "***";
AnsiString rok = "***";
AnsiString prace = "***";
if (InputQuery("P ř idej osobu", "Napiš p ř íjmení :", prijmeni))
if (InputQuery("P ř idej osobu", "Napiš k ř estní jméno :", krestni))
if (InputQuery("P ř idej osobu", "Napiš rok narození :", rok))
if (InputQuery("P ř idej osobu", "Napiš zaměstnání :", prace))
lbxSeznam->Items->Add(prijmeni + " " + krestni
+ " (" + rok + ") - " + prace);
}
//-----------------------------------------------------------------------void __fastcall TfrmSoubory2::btnOdeberClick(TObject *Sender)
{
lbxSeznam->Items->Delete(lbxSeznam->ItemIndex);
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmSoubory2::btnUlozClick(TObject *Sender)
{
int handle;
if (!FileExists(osoby))
{
handle = FileCreate(osoby);
if (handle == -1)
ShowMessage("Soubor nelze vytvo ř it !!!");
}
else
{
handle = FileOpen(osoby, fmOpenWrite);
if (handle == -1)
ShowMessage("Soubor nelze otev ř ít pro zápis !!!");
}
FileSeek(handle, 0, 0);
int delka = lbxSeznam->Items->Text.Length();
int zapsano = FileWrite(handle, lbxSeznam->Items->Text.c_str(), delka);
if (zapsano < delka)
ShowMessage("Soubor nebyl zapsán celý !!!");
FileClose(handle);
}
//-----------------------------------------------------------------------void __fastcall TfrmSoubory2::btnVymazClick(TObject *Sender)
{
lbxSeznam->Clear();
}
//------------------------------------------------------------------------
Standardní dialogy - použití v aplikaci (1. část)
Anotace: Postup vytvoření aplikace na procvičení práce se standardními dialogy,
Ročník: 4.
Příprava:
Standardní dialogy jsou běžnou součástí většiny aplikací. Slouží ke
komunikaci mezi uživatelem a aplikací, používají se tedy jako tzv. uživatelské
rozhraní. Mezi nejčastěji používané dialogy patří: OpenDialog, SaveDialog,
OpenPictureDialog, SavePictureDialog, FontDialog, ColorDialog, PrinterSetupDialog,
PrintDialog, FindDialog a ReplaceDialog. Nejdůležitějšími vlastnostmi dialogů
OpenDialog a SaveDialog jsou FileName, Filter a Options, dialogu FontDialog Font a
dialogu ColorDialog Color, nejdůležitější metodou všech dialogů je Execute().
Zadání:
Vytvořte aplikaci „Dialogy“ - na formuláři je umístěna komponenta RichEdit,
která umožňuje práci s formátovaným textem. Pomocí položek menu lze otevřít nebo
uložit soubor, změnit font nebo barvu písma, najít nebo nahradit část textu. Vše se
bude zadávat pomocí standardních dialogů.
Vygenerujte funkci k události OnCreate pro frmDialogy a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::FormCreate(TObject *Sender)
{
this->Caption = "Dialogy";
redText->Align = alClient;
redText->PlainText = false;
redText->Clear();
dlgOtevri->DefaultExt = "rtf";
dlgOtevri->Filter = "Soubory RTF (*.rtf)|*.rtf|Všechny soubory (*.*)|*.*";
dlgOtevri->Options >> ofHideReadOnly;
dlgUloz->DefaultExt = "rtf";
dlgUloz->Filter = "Soubory RTF (*.rtf)|*.rtf|Všechny soubory (*.*)|*.*";
dlgNajdi->Options << frMatchCase;
dlgNahrad->Options << frMatchCase;
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro všechny
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::pmnOtevriClick(TObject *Sender)
{
if (dlgOtevri->Execute())
{
this->Caption = dlgOtevri->FileName;
redText->Lines->LoadFromFile(dlgOtevri->FileName);
redText->ReadOnly = dlgOtevri->Options.Contains(ofReadOnly);
}
}
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::pmnUlozClick(TObject *Sender)
{
if (dlgUloz->Execute())
{
this->Caption = dlgUloz->FileName;
redText->Lines->SaveToFile(dlgUloz->FileName);
}
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::pmnFontClick(TObject *Sender)
{
if (redText->SelLength > 0)
{
dlgFont->Font->Assign(redText->SelAttributes);
if (dlgFont->Execute())
redText->SelAttributes->Assign(dlgFont->Font);
}
else
{
dlgFont->Font->Assign(redText->DefAttributes);
if (dlgFont->Execute())
redText->DefAttributes->Assign(dlgFont->Font);
}
}
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::pmnBarvaClick(TObject *Sender)
{
{
dlgBarva->Color = redText->SelAttributes->Color;
if (dlgBarva->Execute())
redText->SelAttributes->Color = dlgBarva->Color;
}
else
{
dlgBarva->Color = redText->DefAttributes->Color;
redText->DefAttributes->Color = dlgBarva->Color;
}
}
//------------------------------------------------------------------------
Standardní dialogy - použití v aplikaci (2. část)
Anotace: Postup vytvoření aplikace na procvičení práce se standardními dialogy,
Ročník: 4.
Problematiku vyhledávání a nahrazování části textu nevyřeší dialog (ten slouží
jen ke komunikaci), tuto činnost je nutné naprogramovat. Vygenerujte funkce
k událostem OnClick pro pmnNajdi a pmnNahrad, OnFind pro dlgNajdi a dlgNahrad a
OnReplace pro dlgNahrad. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::pmnNajdiClick(TObject *Sender)
{
dlgNajdi->FindText = redText->SelText;
dlgNajdi->Execute();
}
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::dlgNajdiFind(TObject *Sender)
{
int zacatek_hledani; //pozice znaku, od kterého za číná hledání
int zbyva_do_konce;
//po čet znaků, které zbývají do konce souboru
int nalezena_pozice; //pozice prvního znaku nalezeného textu
zacatek_hledani = redText->SelStart + redText->SelLength;
else
zacatek_hledani = 0;
zbyva_do_konce = redText->Text.Length() - zacatek_hledani;
nalezena_pozice = redText->FindText(dlgNajdi->FindText, zacatek_hledani,
zbyva_do_konce, TSearchTypes() << stMatchCase);
if (nalezena_pozice != -1)
{
redText->SetFocus();
redText->SelStart = nalezena_pozice;
redText->SelLength = dlgNajdi->FindText.Length();
}
else
ShowMessage("Ukon čeno hledání v souboru - zvolený text nebyl nalezen !!!");
}
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::pmnNahradClick(TObject *Sender)
{
dlgNahrad->FindText = redText->SelText;
dlgNahrad->Execute();
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::dlgNahradFind(TObject *Sender)
{
int zbyva_do_konce;
else
nalezena_pozice = redText->FindText(dlgNahrad->FindText, zacatek_hledani,
zbyva_do_konce, TSearchTypes() << stMatchCase);
{
redText->SelLength = dlgNahrad->FindText.Length();
}
else
}
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::dlgNahradReplace(TObject *Sender)
//funkce nahradit nebo nahradit vše se rozliší podle:
//dlgNahrad->Options.Contains(frReplace) = false nebo true
//zde není ř ešeno
{
{
redText->SelText = dlgNahrad->ReplaceText;
redText->SelStart = redText->SelStart - dlgNahrad->ReplaceText.Length();
redText->SelLength = dlgNahrad->ReplaceText.Length();
}
else
ShowMessage("Nebyl ozna čen text pro nahrazení !!!");
}
//---------------------------------------------------------------------
V řešení popsaném v předchozích částech se opakují velmi podobné části
programu (viz. dlgNajdiFind a dlgNahradFind). Porovnejte toto řešení s následujícím
- zde se využívá (TObject *Sender), což je ukazatel na objekt, který danou událost
vyvolal. Také je zde vytvořena vlastní funkce najdi().
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::dlgNajdiFind(TObject *Sender)
{
najdi(Sender);
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::dlgNahradFind(TObject *Sender)
{
najdi(Sender);
}
//-----------------------------------------------------------------------void __fastcall TfrmDialogy::najdi(TObject *Sender)
//(TFindDialog*)Sender funguje pro FindDialog i pro ReplaceDialog
{
int zbyva_do_konce;
else
nalezena_pozice = redText->FindText(((TFindDialog*)Sender)->FindText,
zacatek_hledani, zbyva_do_konce, TSearchTypes() << stMatchCase);
{
redText->SelLength = ((TFindDialog*)Sender)->FindText.Length();
}
else
}
//------------------------------------------------------------------------
Komponenty pro lepší vzhled aplikace (1. část)
Anotace: Postup vytvoření aplikace na procvičení práce s komponentami pro lepší
vzhled aplikace a seznámení s dalšími komponentami
Ročník: 4.
Příprava:
Pro lepší (profesionálnější) vzhled aplikace můžeme použít například tyto
komponenty:
Splitter - rozdělení pracovní plochy na několik částí
Bevel - oddělovací čáry, nejdůležitějšími vlastnostmi jsou Shape a Style
ScrollBox - posuvná oblast
Animate - animace, nejdůležitějšími vlastnostmi jsou FileName, CommonAVI a Active
SpeedButton - základní prvek panelu nástrojů, nejdůležitějšími vlastnostmi jsou
GroupIndex, Down a AllowAllUp
PageControl - záložky
Vytvořte aplikaci „Vzhled1“ - na formuláři jsou umístěny komponenty Splitter,
Bevel, ScrollBox a Animate. Aplikace musí umožnit různé způsoby použití těchto
komponent.
Vygenerujte funkci k události OnCreate pro frmVzhled1 a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmVzhled1::FormCreate(TObject *Sender)
{
this->Caption = "Vzhled1";
pnlPanel1->Caption = "";
pnlPanel1->Align = alLeft;
splCara1->Align = alLeft;
splCara1->Width = 2;
pnlPanel3->Align = alRight;
splCara2->Align = alRight;
splCara2->Width = 2;
pnlPanel2->Align = alClient;
bvlRamecek->Shape = bsBottomLine;
bvlRamecek->Style = bsLowered;
rgpShape->Caption = "Shape";
rgpShape->Columns = 1;
rgpShape->Items->Add("bsBottomLine");
rgpShape->Items->Add("bsBox");
rgpShape->Items->Add("bsFrame");
rgpShape->Items->Add("bsLeftLine");
rgpShape->Items->Add("bsRightLine");
rgpShape->Items->Add("bsSpacer");
rgpShape->Items->Add("bsTopLine");
rgpShape->ItemIndex = 0;
rgpStyle->Caption = "Style";
rgpStyle->Columns = 1;
rgpStyle->Items->Add("bsLowered");
rgpStyle->Items->Add("bsRaised");
rgpStyle->ItemIndex = 0;
btnTlac1->Caption
btnTlac2->Caption
btnTlac3->Caption
btnTlac4->Caption
btnTlac5->Caption
btnTlac6->Caption
btnTlac7->Caption
btnTlac8->Caption
btnTlac9->Caption
=
=
=
=
=
=
=
=
=
"Tla čítko
"Tla čítko
"Tla čítko
"Tla čítko
"Tla čítko
"Tla čítko
"Tla čítko
"Tla čítko
"Konec";
1";
2";
3";
4";
5";
6";
7";
8";
//anmPohyb->FileName = "*.avi";
anmPohyb->CommonAVI = aviFindComputer;
btnStart->Caption = "Start";
btnStop->Caption = "Stop";
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro rgpShape,
rgpStyle, btnTlac9, btnStart a btnStop. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmVzhled1::rgpShapeClick(TObject *Sender)
{
switch (rgpShape->ItemIndex)
{
case 0 : bvlRamecek->Shape = bsBottomLine; break;
case 1 : bvlRamecek->Shape = bsBox; break;
case 2 : bvlRamecek->Shape = bsFrame; break;
case 3 : bvlRamecek->Shape = bsLeftLine; break;
case 4 : bvlRamecek->Shape = bsRightLine; break;
case 5 : bvlRamecek->Shape = bsSpacer; break;
case 6 : bvlRamecek->Shape = bsTopLine; break;
}
}
//-----------------------------------------------------------------------void __fastcall TfrmVzhled1::rgpStyleClick(TObject *Sender)
{
switch (rgpStyle->ItemIndex)
{
case 0 : bvlRamecek->Style = bsLowered; break;
case 1 : bvlRamecek->Style = bsRaised; break;
}
}
//-----------------------------------------------------------------------void __fastcall TfrmVzhled1::btnTlac9Click(TObject *Sender)
{
Application->Terminate();
}
//-----------------------------------------------------------------------void __fastcall TfrmVzhled1::btnStartClick(TObject *Sender)
{
anmPohyb->Active = true;
}
//-----------------------------------------------------------------------void __fastcall TfrmVzhled1::btnStopClick(TObject *Sender)
{
anmPohyb->Active = false;
}
//------------------------------------------------------------------------
Komponenty pro lepší vzhled aplikace (2. část)
Anotace: Postup vytvoření aplikace na procvičení práce s komponentami pro lepší
vzhled aplikace a seznámení s dalšími komponentami
Ročník: 4.
Vytvořte aplikaci „Vzhled2“ - na formuláři je umístěna komponenta
PageControl se třemi záložkami. Na poslední záložce jsou umístěny tři SpeedButton,
které mohou fungovat jako tlačítka, spínače nebo přepínač. Jejich stav je
signalizován také barvou tří panelů.
Vygenerujte funkci k události OnCreate pro frmVzhled2 a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmVzhled2::FormCreate(TObject *Sender)
{
this->Caption = "Vzhled2";
sbtTlac1->Height = 25;
sbtTlac1->Width = 25;
sbtTlac1->NumGlyphs = 4;
//původní nastavení:
sbtTlac1->GroupIndex = 0;
sbtTlac1->Down = false;
sbtTlac1->AllowAllUp = false;
pnlSignal1->Caption = "";
pnlSignal1->Height = 25;
pnlSignal1->Width = 25;
rbtPuvodni->Caption = "Původní";
rbtPuvodni->Checked = true;
rbtTlacitka->Caption = "Tla čítka";
rbtSpinace->Caption = "Spína če";
rbtPrepinac->Caption = "P ř epína č ";
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro rbtPuvodni,
rbtTlacitka, rbtSpinace a rbtPrepinac a OnMouseDown, OnMouseUp a OnClick pro
všechny tři SpeedButton. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmVzhled2::rbtPuvodniClick(TObject *Sender)
{
pnlSignal1->Color = clBtnFace;
}
//-----------------------------------------------------------------------void __fastcall TfrmVzhled2::rbtTlacitkaClick(TObject *Sender)
{
sbtTlac1->AllowAllUp = true;
}
//-----------------------------------------------------------------------void __fastcall TfrmVzhled2::rbtSpinaceClick(TObject *Sender)
{
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmVzhled2::rbtPrepinacClick(TObject *Sender)
{
sbtTlac1->Down = true;
pnlSignal1->Color = clYellow;
}
//-----------------------------------------------------------------------void __fastcall TfrmVzhled2::sbtTlac1MouseDown(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
if (rbtPuvodni->Checked || rbtTlacitka->Checked)
}
{
}
{
}
//-----------------------------------------------------------------------void __fastcall TfrmVzhled2::sbtTlac1MouseUp(TObject *Sender,
{
}
{
}
{
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmVzhled2::sbtTlac1Click(TObject *Sender)
{
if (rbtSpinace->Checked || rbtPrepinac->Checked)
{
if (sbtTlac1->Down)
else
if (sbtTlac2->Down)
else
if (sbtTlac3->Down)
else
}
}
{
{
if (sbtTlac1->Down)
else
if (sbtTlac2->Down)
else
if (sbtTlac3->Down)
else
}
}
//------------------------------------------------------------------------
{
{
if (sbtTlac1->Down)
else
if (sbtTlac2->Down)
else
if (sbtTlac3->Down)
else
}
}
//------------------------------------------------------------------------
Klávesové zkratky - použití v aplikaci
Anotace: Postup vytvoření aplikace na procvičení práce s klávesovými zkratkami,
Ročník: 4.
Příprava:
Klávesové zkratky jsou běžnou součástí většiny aplikací. Obvykle se tvoří
pomocí kombinace modifikační klávesy (Alt, Ctrl, Shift) a dalšího znaku. Slouží
k rychlejšímu a pohodlnějšímu ovládání aplikace pomocí klávesnice. Při tvorbě
klávesových zkratek je třeba dodržovat několik zásad, např. řídit se zvyklostmi
uživatele. K vytvoření klávesových zkratek lze použít různé postupy (např. znak & ve
vlastnosti Caption, vlastnost položek menu ShortCut apod.), pro volbu klávesových
zkratek přímo uživatelem slouží komponenta HotKey.
Zadání:
Vytvořte aplikaci „Klávesové zkratky“ - na formuláři jsou umístěny komponenty
ListView, HotKey a Button, dále je zde vytvořeno menu Soubor. Pomocí tlačítka lze
jednotlivým položkám menu přiřadit klávesovou zkratku. Funkci položek menu řešte
pro jednoduchost pouze zobrazením příslušné zprávy (informačního dialogu), pouze
položka Konec bude plně funkční (včetně kontrolního dotazu).
Řešení:
Vygenerujte funkci k události OnCreate pro frmZkratky a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmZkratky::FormCreate(TObject *Sender)
{
TListColumn *sloupec;
TListItem *polozka;
this->Caption = "Klávesové zkratky";
btnNastavit->Caption = "&Nastavit";
lvwVypis->HideSelection = false;
lvwVypis->ReadOnly = true;
lvwVypis->ViewStyle = vsReport;
sloupec = lvwVypis->Columns->Add();
sloupec->Caption = "Menu";
sloupec->Width = 100;
sloupec = lvwVypis->Columns->Add();
sloupec->Caption = "Zkratka";
sloupec->Width = 140;
for (int i = 0; i < hmnSoubor->Count; i++)
{
polozka = lvwVypis->Items->Add();
polozka->Caption = hmnSoubor->Items[i]->Caption;
polozka->SubItems->Add(ShortCutToText(hmnSoubor->Items[i]->ShortCut));
}
lvwVypis->Items->Item[0]->Selected = true;
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro lvwVypis,
btnNastavit a pro všechny položky menu. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmZkratky::lvwVypisClick(TObject *Sender)
{
if (lvwVypis->Selected)
htkZkratky->HotKey =
TextToShortCut(lvwVypis->Selected->SubItems->Strings[0]);
}
//-----------------------------------------------------------------------void __fastcall TfrmZkratky::btnNastavitClick(TObject *Sender)
{
if (lvwVypis->Selected->Caption != "-")
{
lvwVypis->Selected->SubItems->Strings[0] =
ShortCutToText(htkZkratky->HotKey);
for (int i = 0; i < hmnSoubor->Count; i++)
hmnSoubor->Items[i]->ShortCut =
TextToShortCut(lvwVypis->Items->Item[i]->SubItems->Strings[0]);
}
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmZkratky::pmnNovyClick(TObject *Sender)
{
Application->MessageBox("Soubor nový", "Informace",
MB_OK + MB_ICONINFORMATION);
}
//-----------------------------------------------------------------------void __fastcall TfrmZkratky::pmnOtevritClick(TObject *Sender)
{
Application->MessageBox("Soubor otev ř ít", "Informace",
}
//-----------------------------------------------------------------------void __fastcall TfrmZkratky::pmnUlozitClick(TObject *Sender)
{
Application->MessageBox("Soubor uložit", "Informace",
}
//-----------------------------------------------------------------------void __fastcall TfrmZkratky::pmnUlozitJakoClick(TObject *Sender)
{
Application->MessageBox("Soubor uložit jako", "Informace",
}
//-----------------------------------------------------------------------void __fastcall TfrmZkratky::pmnZavritClick(TObject *Sender)
{
Application->MessageBox("Soubor zav ř ít", "Informace",
}
//-----------------------------------------------------------------------void __fastcall TfrmZkratky::pmnKonecClick(TObject *Sender)
{
if(Application->MessageBox("Konec aplikace ?", "Otázka",
MB_YESNO + MB_ICONQUESTION) == mrYes)
}
//------------------------------------------------------------------------
Počítačová grafika - použití v aplikaci (1. část)
Anotace: Postup vytvoření aplikace na procvičení práce s počítačovou grafikou, její
Ročník: 4.
Příprava:
Počítačová grafika začíná kreslením jednoduchých geometrických obrazců
pomocí myši. Události OnMouse... mají několik důležitých parametrů: Button - které
tlačítko myši událost vyvolalo, Shift - která modifikační klávesa přitom byla stisknuta,
X a Y - souřadnice kurzoru myši.
Kreslit se dá na Canvas = plátno (vlastnost řady komponent) nebo lze použít
některou grafickou komponentu (např. Image nebo Shape). Objekt Canvas má
vlastnosti Brush = štětec (výplně geometrických obrazců) a Pen = pero (čáry a
obrysy geometrických obrazců). Objekt Brush má vlastnosti Color a Style. Objekt
Pen má vlastnosti Color, Mode, Style a Width.
Pro kreslení základních geometrických obrazců lze využívat např. tyto metody:
MoveTo() - počáteční bod čáry, LineTo() - koncový bod čáry, Ellipse() - elipsy a
kruhy, Rectangle() - obdélníky a čtverce a TextOut() - texty.
Pro práci s fotografiemi a podobnými obrázky lze využívat komponentu Image, její
vlastnost Canvas a jeho vlastnost Pixels - jedná se o dvourozměrné pole, které
procházíme bod po bodu pomocí dvou vnořených cyklů. Každý pixel = obrazový bod
je zadán jeho barvou.
Vytvořte aplikaci „Grafika1“ - na formuláři je umístěna komponenta Image, na
které je vytvořen jednoduchý obrazec ze základních geometrických obrazců. Pomocí
tlačítek myši lze na plátno kreslit další obrazce, při použití levého tlačítka mají
obrazce jiný štětec a pero než při použití pravého tlačítka. Bez modifikačních kláves
se vykreslují čtverce, s klávesou Shift kruhy, s klávesou Ctrl čárkované čáry z levého
horního rohu a s klávesou Alt tečkované čáry z pravého dolního rohu.
Vygenerujte funkci k události OnCreate pro frmGrafika1 a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmGrafika1::FormCreate(TObject *Sender)
{
this->Caption = "Grafika1";
kresli_pozadi();
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vytvořte vlastní funkci kresli_pozadi. Vygenerujte funkci
k události OnMouseDown pro imgObraz. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmGrafika1::kresli_pozadi(void)
{
imgObraz->Canvas->Brush->Color = clSkyBlue;
imgObraz->Canvas->FillRect(
Rect(0, 0, imgObraz->Picture->Width, imgObraz->Picture->Height));
imgObraz->Canvas->Brush->Color = clYellow;
imgObraz->Canvas->Pen->Color = clRed;
imgObraz->Canvas->Pen->Style = psSolid;
imgObraz->Canvas->Pen->Width = 5;
imgObraz->Canvas->MoveTo(25, 50);
imgObraz->Canvas->LineTo(25, 100);
imgObraz->Canvas->Rectangle(50, 50, 100, 100);
imgObraz->Canvas->LineTo(125, 100);
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmGrafika1::imgObrazMouseDown(TObject *Sender,
{
if ((!Shift.Contains(ssShift))
&& (!Shift.Contains(ssCtrl))
&& (!Shift.Contains(ssAlt)))
{
if (Button == mbLeft)
{
imgObraz->Canvas->Brush->Color = clLime;
imgObraz->Canvas->Pen->Color = clBlue;
imgObraz->Canvas->Rectangle(X - 10, Y - 10, X + 10, Y + 10);
}
if (Button == mbRight)
{
imgObraz->Canvas->Brush->Color = clAqua;
imgObraz->Canvas->Pen->Color = clGreen;
imgObraz->Canvas->Rectangle(X - 10, Y - 10, X + 10, Y + 10);
}
}
if (Shift.Contains(ssShift))
{
{
imgObraz->Canvas->Brush->Color = clLime;
imgObraz->Canvas->Pen->Color = clBlue;
imgObraz->Canvas->Ellipse(X - 10, Y - 10, X + 10, Y + 10);
}
{
imgObraz->Canvas->Brush->Color = clAqua;
imgObraz->Canvas->Pen->Color = clGreen;
imgObraz->Canvas->Ellipse(X - 10, Y - 10, X + 10, Y + 10);
}
}
if (Shift.Contains(ssCtrl))
{
{
imgObraz->Canvas->Pen->Color = clBlack;
imgObraz->Canvas->Pen->Style = psDash;
imgObraz->Canvas->LineTo(X, Y);
}
{
imgObraz->Canvas->Pen->Color = clFuchsia;
imgObraz->Canvas->Pen->Style = psDash;
}
}
if (Shift.Contains(ssAlt))
{
{
imgObraz->Canvas->Pen->Color = clBlack;
imgObraz->Canvas->Pen->Style = psDot;
imgObraz->Canvas->MoveTo(imgObraz->Width, imgObraz->Height);
}
{
imgObraz->Canvas->Pen->Color = clFuchsia;
imgObraz->Canvas->Pen->Style = psDot;
imgObraz->Canvas->MoveTo(imgObraz->Width, imgObraz->Height);
}
}
}
//------------------------------------------------------------------------
Ročník: 4.
Vytvořte aplikaci „Grafika2“ - na formuláři jsou umístěny tři záložky, na každé
z nich je komponenta Image a Button. Pomocí tlačítek lze na každé záložce nakreslit
jiný obrázek. Na první je plastický text, na druhé Lissajousův obrazec a na třetí
barevný přechod od modré po zelenou.
Vygenerujte funkci k události OnCreate pro frmGrafika2 a zapište do ní tento text:
{
btnOtevri->Caption = "Otev ř i";
btnTlac1->Caption = "Kresli";
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro btnOtevri,
btnTlac1, btnTlac2 a btnTlac3. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------#include <math.h>
#include "Grafika3.h"
//-----------------------------------------------------------------------void __fastcall TfrmGrafika2::btnOtevriClick(TObject *Sender)
{
frmGrafika3->ShowModal();
}
//-----------------------------------------------------------------------void __fastcall TfrmGrafika2::btnTlac1Click(TObject *Sender)
{
imgObr1->Canvas->Brush->Color = clGray;
imgObr1->Canvas->Rectangle(0, 0, imgObr1->Width, imgObr1->Height);
imgObr1->Canvas->Brush->Style = bsClear;
imgObr1->Canvas->Font->Name = "Arial";
imgObr1->Canvas->Font->Size = 100;
imgObr1->Canvas->Font->Style = imgObr1->Canvas->Font->Style << fsBold;
imgObr1->Canvas->Font->Color = clBlack;
imgObr1->Canvas->TextOut(33, 33, "Ahoj !");
imgObr1->Canvas->Font->Color = clWhite;
imgObr1->Canvas->Font->Color = clGray;
}
{
imgObr2->Canvas->Brush->Color = clYellow;
imgObr2->Canvas->Pen->Color = clRed;
for (int i = 0; i < 360; i++)
{
int x = 95 + 85 * cos(2 * i * 2 * 3.14 / 360);
//lze také: int x = 95 + 85 * cos(2 * i * 2 * M_PI / 360);
//" čisté" ř ešení: int x = (int) (95 + 85 * cos(2 * i * 2 * M_PI / 360));
int y = 95 + 85 * sin(6 * i * 2 * 3.14 / 360);
imgObr2->Canvas->Rectangle(x, y, x + 24, y + 16);
}
}
//------------------------------------------------------------------------
{
//p ř ípadně: int cervena = 0x00000F;
int zelena = 0x000F00; //sytost barevné složky (15 * 17 = 255)
int modra = 0x0F0000;
int pocet = 18;
int posun = 6;
int delka_x = imgObr3->Width / pocet;
int delka_y = imgObr3->Height / pocet;
int mezera_x = 1;
int mezera_y = 1;
imgObr3->Canvas->Pen->Style = psClear;
for (int x = 0; x < pocet; x++)
{
for (int y = 0; y < pocet; y++)
{
imgObr3->Canvas->Brush->Color = (TColor) (x * zelena + y * modra);
imgObr3->Canvas->Rectangle(delka_x * x + posun,
delka_y * y + posun,
delka_x * (x + 1) - mezera_x + posun,
delka_y * (y + 1) - mezera_y + posun);
}
}
}
//------------------------------------------------------------------------
Ročník: 4.
Vytvořte aplikaci „Grafika3“, která je spuštěna jako druhý formulář z aplikace
„Grafika2“ tlačítkem Otevři (viz. předchozí část) - na formuláři jsou umístěny dvě
komponenty Image, tři Button a jeden CheckBox. Na první Image je umístěn
obrázek. Pomocí tlačítek lze na druhé Image nakreslit černobílou kopii obrázku nebo
jeho černobílý negativ, třetí tlačítko formulář zavře. Při zatržení Korekce jasu bude
kopie i negativ přepočítáván s různou vahou složek RGB podle jasové rovnice.
Připravte druhý formulář. Vygenerujte funkci k události OnCreate pro
frmGrafika3 a zapište do ní tento text:
{
btnKopie->Caption = "ČB kopie";
btnNegativ->Caption = "ČB negativ";
btnZavri->Caption = "Zav ř i";
chbJas->Caption = "Korekce jasu";
imgVzor->Picture->LoadFromFile("obraz.bmp");
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnClick pro btnZavri,
btnKopie a btnNegativ. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmGrafika3::btnZavriClick(TObject *Sender)
{
this->Close();
}
//-----------------------------------------------------------------------void __fastcall TfrmGrafika3::btnKopieClick(TObject *Sender)
{
TColor barva;
unsigned char slozkaR, slozkaG, slozkaB;
for (int x = 0; x < imgKopie->Width; x++)
{
for (int y = 0; y < imgKopie->Height; y++)
{
barva = imgVzor->Canvas->Pixels[x][y];
slozkaR = barva & 0x0000FF;
slozkaG = (barva & 0x00FF00) >> 8;
slozkaB = (barva & 0xFF0000) >> 16;
if (chbJas->Checked)
imgKopie->Canvas->Pixels[x][y] = (TColor) (((slozkaR * 30
+ slozkaG * 59 + slozkaB * 11) / 100) * 0x010101);
else
imgKopie->Canvas->Pixels[x][y] = (TColor) (((slozkaR
+ slozkaG + slozkaB) / 3) * 0x010101);
}
}
imgKopie->Repaint();
}
//-----------------------------------------------------------------------void __fastcall TfrmGrafika3::btnNegativClick(TObject *Sender)
{
//standardní postup vykreslení:
/*
TColor barva;
for (int x = 0; x < imgKopie->Width; x++)
{
for (int y = 0; y < imgKopie->Height; y++)
{
slozkaR = 255 - (barva & 0x0000FF);
slozkaG = 255 - ((barva & 0x00FF00) >> 8);
slozkaB = 255 - ((barva & 0xFF0000) >> 16);
imgKopie->Canvas->Pixels[x][y] = (TColor) (((slozkaR * 30
else
imgKopie->Canvas->Pixels[x][y] = (TColor) (((slozkaR
}
}
imgKopie->Repaint();
*/
//rychlejší vykreslení (vytvo ř ení náhradní bitmapy):
Graphics::TBitmap *bmpKopie = new Graphics::TBitmap;
bmpKopie->Width = imgKopie->Width;
bmpKopie->Height = imgKopie->Height;
TColor barva;
for (int x = 0; x < bmpKopie->Width; x++)
{
for (int y = 0; y < bmpKopie->Height; y++)
{
slozkaR = 255 - (barva & 0x0000FF);
slozkaG = 255 - ((barva & 0x00FF00) >> 8);
slozkaB = 255 - ((barva & 0xFF0000) >> 16);
bmpKopie->Canvas->Pixels[x][y] = (TColor) (((slozkaR * 30
else
bmpKopie->Canvas->Pixels[x][y] = (TColor) (((slozkaR
}
}
imgKopie->Picture->Bitmap = bmpKopie;
delete bmpKopie;
}
//------------------------------------------------------------------------
Počítačová grafika - cvičení
Anotace: Postup vytvoření aplikace na procvičení práce s počítačovou grafikou
Ročník: 4.
Zadání:
Vytvořte aplikaci „Domácí úkol“ - na formuláři jsou umístěny komponenty
Image a Button. Pomocí tlačítka se na Image postupně vykresluje postava
sněhuláka.
Řešení:
Vygenerujte funkci k události OnCreate pro frmUkol a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmUkol::FormCreate(TObject *Sender)
{
this->Caption = "Domácí úkol";
btnKresli->Caption = "Kresli";
xxx = imgObraz->Picture->Width / 2;
yyy = imgObraz->Picture->Height - 70;
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkci k události OnClick pro btnKresli. Do
zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------int pocet = 0;
int xxx;
int yyy;
//-----------------------------------------------------------------------void __fastcall TfrmUkol::btnKresliClick(TObject *Sender)
{
pocet++;
switch (pocet)
{
case 1 :
imgObraz->Canvas->Brush->Color = clWhite;
imgObraz->Canvas->Ellipse(xxx - 40, yyy - 40, xxx + 40, yyy + 40);
yyy -= 70;
break;
case 2 :
break;
case 3 :
xxx -= 40;
xxx += 80;
xxx -= 40;
yyy -= 50;
break;
case 4 :
yyy -= 34;
break;
case 5 :
imgObraz->Canvas->Brush->Color = clRed;
imgObraz->Canvas->Rectangle(xxx - 14, yyy - 14, xxx + 14, yyy + 14);
break;
case 6 :
pocet = 0;
yyy = imgObraz->Picture->Height - 70;
break;
}
}
//------------------------------------------------------------------------
Textový editor - ukázka funkční aplikace (1. část)
Anotace: Postup vytvoření ukázkové funkční aplikace „Textový editor“
Ročník: 4.
Příprava:
Seznamte se nejdříve důkladně s programem „WordPad“, který je dodáván v
„Příslušenství“ k operačním systémům Windows.
Zadání:
Vytvořte aplikaci „Textový editor“ - na formuláři je umístěna komponenta
RichEdit, která plní funkci vlastního editoru. Dále je aplikace doplněna vlastní ikonou,
bohatým menu s ikonami a klávesovými zkratkami, panelem nástrojů a stavovým
řádkem.
Vygenerujte funkci k události OnCreate pro frmText a zapište do ní tento text:
//-----------------------------------------------------------------------#define sb 22
//-----------------------------------------------------------------------void __fastcall TfrmText::FormCreate(TObject *Sender)
{
this->Caption = "Textový editor";
pmnFormatTXT->Checked = true;
pmnZalamovaniRadku->Checked = true;
pnlPanel->Align = alTop;
pnlPanel->BevelOuter = bvLowered;
pnlPanel->Caption = "";
pnlPanel->Height = sb + 4;
sbtNovy->Height = sb;
sbtNovy->Width = sb;
sbtNovy->Left = 2;
sbtNovy->Top = 2;
sbtNovy->Hint = "Nový";
sbtNovy->ShowHint = true;
sbtOtevrit->Height = sb;
sbtOtevrit->Width = sb;
sbtOtevrit->Left = sb + 2;
sbtOtevrit->Top = 2;
sbtOtevrit->Hint = "Otev ř ít";
sbtOtevrit->ShowHint = true;
sbtUlozit->Height = sb;
sbtUlozit->Width = sb;
sbtUlozit->Left = 2 * sb + 2;
sbtUlozit->Top = 2;
sbtUlozit->Hint = "Uložit";
sbtUlozit->ShowHint = true;
sbtTisk->Height = sb;
sbtTisk->Width = sb;
sbtTisk->Left = 3 * sb + 14;
sbtTisk->Top = 2;
sbtTisk->Hint = "Tisk";
sbtTisk->ShowHint = true;
sbtVyjmout->Height = sb;
sbtVyjmout->Width = sb;
sbtVyjmout->Left = 4 * sb + 26;
sbtVyjmout->Top = 2;
sbtVyjmout->Hint = "Vyjmout";
sbtVyjmout->ShowHint = true;
sbtKopirovat->Height = sb;
sbtKopirovat->Width = sb;
sbtKopirovat->Left = 5 * sb + 26;
sbtKopirovat->Top = 2;
sbtKopirovat->Hint = "Kopírovat";
sbtKopirovat->ShowHint = true;
sbtVlozit->Height = sb;
sbtVlozit->Width = sb;
sbtVlozit->Left = 6 * sb + 26;
sbtVlozit->Top = 2;
sbtVlozit->Hint = "Vložit";
sbtVlozit->ShowHint = true;
sbtNajit->Height = sb;
sbtNajit->Width = sb;
sbtNajit->Left = 7 * sb + 38;
sbtNajit->Top = 2;
sbtNajit->Hint = "Najít";
sbtNajit->ShowHint = true;
sbtOProgramu->Anchors >> akLeft << akRight;
sbtOProgramu->Height = sb;
sbtOProgramu->Width = sb;
sbtOProgramu->Left = pnlPanel->Width - (sb + 2);
sbtOProgramu->Top = 2;
sbtOProgramu->Hint = "O programu";
sbtOProgramu->ShowHint = true;
redText->Align = alClient;
redText->PlainText = true;
redText->ScrollBars = ssBoth;
redText->WordWrap = true;
redText->Clear();
stbStav->Panels->Items[0]->Width = 55;
stbStav->Panels->Items[0]->Alignment = taCenter;
stbStav->Panels->Items[1]->Text = " Formát : TXT";
stbStav->Panels->Items[0]->Text = TimeToStr(Time());
dlgOtevrit->DefaultExt = "txt";
dlgOtevrit->Filter
= "Soubory TXT (*.txt)|*.txt|Všechny soubory (*.*)|*.*";
dlgOtevrit->Options << ofOverwritePrompt << ofEnableSizing;
dlgOtevrit->Options >> ofHideReadOnly;
dlgUlozit->DefaultExt = dlgOtevrit->DefaultExt;
dlgUlozit->Filter = dlgOtevrit->Filter;
dlgUlozit->Options << ofOverwritePrompt << ofEnableSizing;
dlgNajit->Options << frHideUpDown;
tmrHodiny->Interval = 1000;
tmrHodiny->Enabled = true;
nastavit_jmeno_souboru("Bez_názvu.txt");
}//------------------------------------------------------------------------
Ročník: 4.
V minulé části byla volána vlastní funkce „nastavit_jmeno_souboru“. Tuto
funkci je však nutné nejprve vytvořit. Protože bude potřeba vytvořit další vlastní
funkce, provedeme to nyní (nezapomeňte zapsat hlavičky funkcí do hlavičkového
souboru). Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------AnsiString jmeno_souboru;
int zacatek_hledani, zbyva_do_konce, nalezena_pozice;
//-----------------------------------------------------------------------void TfrmText::nastavit_jmeno_souboru(AnsiString file_name)
{
jmeno_souboru = file_name;
stbStav->Panels->Items[2]->Text = " Soubor : "
+ ExtractFileName(jmeno_souboru);
}
//-----------------------------------------------------------------------TModalResult TfrmText::ulozit_zmeny(void)
{
TModalResult vysledek;
if (redText->Modified)
{
vysledek = Application->MessageBox(
"Soubor byl změněn, chcete jej uložit ?", "Textový editor",
MB_YESNOCANCEL + MB_ICONQUESTION);
if (vysledek == mrYes)
pmnUlozitClick(this);
}
else
vysledek = mrOk;
return vysledek;
}
//-----------------------------------------------------------------------void TfrmText::ulozit_soubor(void)
{
redText->Lines->SaveToFile(jmeno_souboru);
redText->Modified = false;
}
//-----------------------------------------------------------------------void TfrmText::najit_text_dlgNajit(void)
{
// ř ešena "zatržítka" stylu hledání
// ne ř ešen směr hledání (v dialogu je skrytý)
if ((dlgNajit->Options.Contains(frMatchCase))
&& (dlgNajit->Options.Contains(frWholeWord)))
nalezena_pozice
= redText->FindText(dlgNajit->FindText, zacatek_hledani,
zbyva_do_konce, TSearchTypes() << stMatchCase << stWholeWord);
if ((dlgNajit->Options.Contains(frMatchCase))
&& !(dlgNajit->Options.Contains(frWholeWord)))
nalezena_pozice
zbyva_do_konce, TSearchTypes() << stMatchCase >> stWholeWord);
if (!(dlgNajit->Options.Contains(frMatchCase))
&& (dlgNajit->Options.Contains(frWholeWord)))
nalezena_pozice
zbyva_do_konce, TSearchTypes() >> stMatchCase << stWholeWord);
if (!(dlgNajit->Options.Contains(frMatchCase))
&& !(dlgNajit->Options.Contains(frWholeWord)))
nalezena_pozice
zbyva_do_konce, TSearchTypes() >> stMatchCase >> stWholeWord);
{
redText->SelLength = dlgNajit->FindText.Length();
}
else
{
Application->MessageBox("Ukon čeno hledání (konec souboru) !!!",
"Textový editor", MB_OK + MB_ICONINFORMATION);
redText->SelStart = 0;
redText->SelLength = 0;
}
}
//-----------------------------------------------------------------------void TfrmText::najit_text_dlgNahradit(void)
{
if ((dlgNahradit->Options.Contains(frMatchCase))
&& (dlgNahradit->Options.Contains(frWholeWord)))
nalezena_pozice
= redText->FindText(dlgNahradit->FindText, zacatek_hledani,
zbyva_do_konce, TSearchTypes() << stMatchCase << stWholeWord);
if ((dlgNahradit->Options.Contains(frMatchCase))
&& !(dlgNahradit->Options.Contains(frWholeWord)))
nalezena_pozice
zbyva_do_konce, TSearchTypes() << stMatchCase >> stWholeWord);
if (!(dlgNahradit->Options.Contains(frMatchCase))
&& (dlgNahradit->Options.Contains(frWholeWord)))
nalezena_pozice
zbyva_do_konce, TSearchTypes() >> stMatchCase << stWholeWord);
if (!(dlgNahradit->Options.Contains(frMatchCase))
&& !(dlgNahradit->Options.Contains(frWholeWord)))
nalezena_pozice
zbyva_do_konce, TSearchTypes() >> stMatchCase >> stWholeWord);
{
redText->SelLength = dlgNahradit->FindText.Length();
}
else
{
Application->MessageBox("Ukon čeno hledání (konec souboru) !!!",
redText->SelStart = 0;
redText->SelLength = 0;
}
}
//-----------------------------------------------------------------------void TfrmText::nahradit_text_dlgNahradit(void)
{
{
redText->SelText = dlgNahradit->ReplaceText;
redText->SelStart = redText->SelStart
- dlgNahradit->ReplaceText.Length();
redText->SelLength = dlgNahradit->ReplaceText.Length();
}
else
Application->MessageBox("Nebyl ozna čen text pro nahrazení !!!",
}
//-----------------------------------------------------------------------void TfrmText::nahradit_vse_dlgNahradit(void)
{
najit_text_dlgNahradit();
while (nalezena_pozice != -1)
{
nahradit_text_dlgNahradit();
}
}
//------------------------------------------------------------------------
Ročník: 4.
Nejprve vyřešíme funkci hodin na stavovém řádku a funkci menu Nápověda /
O_programu (vytvořte pro ni nový formulář frmProgram. Vygenerujte funkce
k událostem OnTimer pro tmrHodiny a OnClick pro všechny položky menu
Nápověda. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------#include "Program.h"
//-----------------------------------------------------------------------void __fastcall TfrmText::tmrHodinyTimer(TObject *Sender)
{
stbStav->Panels->Items[0]->Text = TimeToStr(Time());
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnOProgramuClick(TObject *Sender)
{
frmOProgramu->ShowModal();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::sbtOProgramuClick(TObject *Sender)
{
pmnOProgramuClick(this);
}
//------------------------------------------------------------------------
Program uložte a přeložte. Dále vyřešíme funkci menu Soubor. Vygenerujte funkce
k událostem OnClick pro všechny položky menu Soubor a OnCloseQuery pro
frmText. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnNovyClick(TObject *Sender)
{
if (ulozit_zmeny() != mrCancel)
{
if (pmnFormatTXT->Checked)
else
nastavit_jmeno_souboru("Bez_názvu.rtf");
redText->Clear();
}
}
//-----------------------------------------------------------------------void __fastcall TfrmText::sbtNovyClick(TObject *Sender)
{
pmnNovyClick(this);
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnOtevritClick(TObject *Sender)
{
if (dlgOtevrit->Execute())
{
nastavit_jmeno_souboru(dlgOtevrit->FileName);
redText->Lines->LoadFromFile(jmeno_souboru);
redText->ReadOnly = dlgOtevrit->Options.Contains(ofReadOnly);
}
}
//-----------------------------------------------------------------------void __fastcall TfrmText::sbtOtevritClick(TObject *Sender)
{
pmnOtevritClick(this);
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnUlozitClick(TObject *Sender)
{
if ((jmeno_souboru == "Bez_názvu.txt")
|| (jmeno_souboru == "Bez_názvu.rtf"))
pmnUlozitJakoClick(this);
else
ulozit_soubor();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::sbtUlozitClick(TObject *Sender)
{
pmnUlozitClick(this);
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnUlozitJakoClick(TObject *Sender)
{
if (dlgUlozit->Execute())
{
nastavit_jmeno_souboru(dlgUlozit->FileName);
ulozit_soubor();
}
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnNastaveniTiskarnyClick(TObject *Sender)
{
dlgNastaveniTiskarny->Execute();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnTiskClick(TObject *Sender)
{
if (dlgTisk->Execute())
redText->Print(jmeno_souboru);
}
//-----------------------------------------------------------------------void __fastcall TfrmText::sbtTiskClick(TObject *Sender)
{
pmnTiskClick(this);
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnKonecClick(TObject *Sender)
{
this->Close();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::FormCloseQuery(TObject *Sender, bool &CanClose)
{
{
CanClose = true;
}
else
CanClose = false;
}
//------------------------------------------------------------------------
Ročník: 4.
Dále vyřešíme funkci menu Úpravy. Vygenerujte funkce k událostem OnClick
pro všechny položky menu Úpravy, OnFind a OnReplace pro příslušné dialogy. Do
zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnVyjmoutClick(TObject *Sender)
{
redText->CutToClipboard();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::sbtVyjmoutClick(TObject *Sender)
{
pmnVyjmoutClick(this);
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnKopirovatClick(TObject *Sender)
{
redText->CopyToClipboard();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::sbtKopirovatClick(TObject *Sender)
{
pmnKopirovatClick(this);
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnVlozitClick(TObject *Sender)
{
redText->PasteFromClipboard();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::sbtVlozitClick(TObject *Sender)
{
pmnVlozitClick(this);
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnVybratVseClick(TObject *Sender)
{
redText->SelectAll();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnNajitClick(TObject *Sender)
{
dlgNajit->FindText = redText->SelText;
dlgNajit->Execute();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::sbtNajitClick(TObject *Sender)
{
pmnNajitClick(this);
}
//-----------------------------------------------------------------------void __fastcall TfrmText::dlgNajitFind(TObject *Sender)
{
najit_text_dlgNajit();
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnNahraditClick(TObject *Sender)
{
dlgNahradit->FindText = redText->SelText;
dlgNahradit->Execute();
}
//-----------------------------------------------------------------------void __fastcall TfrmText::dlgNahraditFind(TObject *Sender)
{
}
//-----------------------------------------------------------------------void __fastcall TfrmText::dlgNahraditReplace(TObject *Sender)
{
if (dlgNahradit->Options.Contains(frReplace))
nahradit_text_dlgNahradit();
else
nahradit_vse_dlgNahradit();
}
//------------------------------------------------------------------------
Program uložte a přeložte. Nakonec vyřešíme funkci menu Formát. Vygenerujte
funkce k událostem OnClick pro všechny položky menu Formát. Do zdrojového kódu
zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnPismoClick(TObject *Sender)
{
{
dlgPismo->Font->Assign(redText->SelAttributes);
if (dlgPismo->Execute())
redText->SelAttributes->Assign(dlgPismo->Font);
//redText->SelAttributes->Charset = dlgPismo->Font->Charset;
//redText->SelAttributes->Color = dlgPismo->Font->Color;
//redText->SelAttributes->Height = dlgPismo->Font->Height;
//redText->SelAttributes->Name = dlgPismo->Font->Name;
//redText->SelAttributes->Pitch = dlgPismo->Font->Pitch;
//redText->SelAttributes->Size = dlgPismo->Font->Size;
}
else
{
dlgPismo->Font->Assign(redText->DefAttributes);
if (dlgPismo->Execute())
redText->DefAttributes->Assign(dlgPismo->Font);
}
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnBarvaClick(TObject *Sender)
{
{
dlgBarva->Color = redText->SelAttributes->Color;
redText->SelAttributes->Color = dlgBarva->Color;
}
else
{
dlgBarva->Color = redText->DefAttributes->Color;
redText->DefAttributes->Color = dlgBarva->Color;
}
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnFormatTXTClick(TObject *Sender)
{
pmnFormatTXT->Checked = true;
pmnFormatRTF->Checked = false;
redText->PlainText = true;
dlgOtevrit->DefaultExt = "txt";
dlgOtevrit->Filter
= "Soubory TXT (*.txt)|*.txt|Všechny soubory (*.*)|*.*";
stbStav->Panels->Items[1]->Text = " Formát : TXT";
if (jmeno_souboru == "Bez_názvu.rtf")
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnFormatRTFClick(TObject *Sender)
{
pmnFormatTXT->Checked = false;
pmnFormatRTF->Checked = true;
redText->PlainText = false;
dlgOtevrit->DefaultExt = "rtf";
dlgOtevrit->Filter
= "Soubory RTF (*.rtf)|*.rtf|Všechny soubory (*.*)|*.*";
stbStav->Panels->Items[1]->Text = " Formát : RTF";
if (jmeno_souboru == "Bez_názvu.txt")
nastavit_jmeno_souboru("Bez_názvu.rtf");
}
//-----------------------------------------------------------------------void __fastcall TfrmText::pmnZalamovaniRadkuClick(TObject *Sender)
{
pmnZalamovaniRadku->Checked = !pmnZalamovaniRadku->Checked;
redText->WordWrap = !redText->WordWrap;
}
//------------------------------------------------------------------------
Inicializační soubory - použití v aplikaci
Anotace: Postup vytvoření aplikace na procvičení práce s inicializačními soubory,
Ročník: 4.
Příprava:
Inicializační soubory (*.ini) jsou běžnou součástí většiny aplikací. Slouží
k nastavení výchozích hodnot při spuštění aplikace a k zapamatování změn těchto
hodnot při ukončení aplikace. Pro čtení inicializačních souborů a zápis do nich lze
použít např. funkce z knihovny „inifiles.hpp“.
Zadání:
Vytvořte aplikaci „Inicializace“ - na formuláři jsou umístěny komponenty Edit a
tři CheckBox. Pomocí souboru „inicializace.ini“ nastavte výšku a šířku formuláře, jeho
umístění zleva a shora, text zobrazený v Edit a zatržení v CheckBox. Při ukončení
aplikace do souboru zapište aktuální hodnoty a doplňte datum a čas poslední změny.
Řešení:
Vygenerujte funkci k události OnCreate pro frmInicializace a zapište do ní tento text:
//-----------------------------------------------------------------------void __fastcall TfrmInicializace::FormCreate(TObject *Sender)
{
this->Caption = "Inicializace";
this->Height = pVyska;
this->Width = pSirka;
this->Left = pZleva;
this->Top = pShora;
edtNapis->Text = pNapis;
chbBox1->Caption
chbBox1->Checked
chbBox2->Caption
chbBox2->Checked
chbBox3->Caption
chbBox3->Checked
=
=
=
=
=
=
"box č .1";
pBox1;
"box č .2";
pBox2;
"box č .3";
pBox3;
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vytvořte soubor „inicializace.ini“, konstruktor a destruktor.
Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------#include <inifiles.hpp>
int pVyska, pSirka, pZleva, pShora;
AnsiString pNapis, ppNapis;
bool pBox1, ppBox1, pBox2, ppBox2, pBox3, ppBox3;
TDateTime ppZmena;
//-----------------------------------------------------------------------__fastcall TfrmInicializace::TfrmInicializace(TComponent* Owner)
: TForm(Owner)
{
TIniFile *inisoubor = new TIniFile(GetCurrentDir() + "\\inicializace.ini");
pVyska
pSirka
pZleva
pShora
=
=
=
=
inisoubor->ReadInteger("Rozmery", "Vyska", 100);
inisoubor->ReadInteger("Rozmery", "Sirka", 100);
inisoubor->ReadInteger("Poloha", "Zleva", 50);
inisoubor->ReadInteger("Poloha", "Shora", 50);
pNapis = inisoubor->ReadString("Text", "Napis", "text nena čten");
pBox1 = inisoubor->ReadBool("Boxy", "Box1", 0);
delete inisoubor;
}
//-----------------------------------------------------------------------__fastcall TfrmInicializace::~TfrmInicializace()
{
TIniFile *inisoubor = new TIniFile(GetCurrentDir()+"\\inicializace.ini");
inisoubor->WriteString("Text", "Napis", ppNapis);
inisoubor->WriteBool("Boxy", "Box1", ppBox1);
ppZmena = Now().CurrentDateTime();
inisoubor->WriteDateTime("Cas", "Zmena", ppZmena);
delete inisoubor;
}
//------------------------------------------------------------------------
Program uložte a přeložte. Vygenerujte funkce k událostem OnChange pro EdtNapis
a OnClick pro chbBox1, chbBox2 a chbBox3. Do zdrojového kódu zapište tento text:
//-----------------------------------------------------------------------void __fastcall TfrmInicializace::edtNapisChange(TObject *Sender)
{
ppNapis = edtNapis->Text;
}
//------------------------------------------------------------------------
//-----------------------------------------------------------------------void __fastcall TfrmInicializace::chbBox1Click(TObject *Sender)
{
ppBox1 = chbBox1->Checked;
}
{
}
{
}
//------------------------------------------------------------------------

Programování v jazyce C++ pro 4. ročník

Transkript

Podobné dokumenty

1. Seznámení s C++ Builderem

C++ Builder 4.0 - Tvorba software

Příručka Instalace a nastavení TRIFID 2013

Počítače a programování 2 - UTEE

Bakalářská práce - Vysoké učení technické v Brně

Programování v C++ II - Materiály pro výuku IDE C++ Builder