1. Úvod do vytváření komponent

Tato kapitola poskytuje úvod do návrhu komponent a procesu zápisu komponent pro aplikace C++ Builderu. Předložený text předpokládá, že podrobně známe C++ Builder a jeho standardní komponenty.
Jsou zde popsány tyto sekce:

Knihovna vizuálních komponent

Komponenty C++ Builderu jsou součástí hierarchie tříd nazvané Knihovna vizuálních komponent (VCL). Následující obrázek ukazuje zjednodušenou hierarchii tříd tvořících VCL.
Typ TComponent je společný předek všech komponent VCL. TComponent poskytuje minimální vlastnosti a události nezbytné pro práci komponenty v C++ Builderu. Různé větve knihovny poskytují další více specializované komponenty. Vytvářenou komponentu přidáme do VCL odvozením nové třídy od některé existují třídy v hierarchii.

Komponenty a třídy

Komponenty jsou třídy a tvůrce komponent pracuje s třídami na jiné úrovni než uživatel komponent. Vytvoření nové komponenty vyžaduje odvození nové třídy. Jsou dva hlavní rozdíly mezi vytvářením komponent a používáním komponent. Při vytváření komponent musíme mít přístup k částem třídy, které jsou nepřístupné pro koncového uživatele a můžeme přidávat nové části (např. vlastnosti) ke svým komponentám. S ohledem na tyto rozdíly, je nutno dodržovat mnoho konvencí a brát ohled na používání našich komponent koncovými uživateli.

Jak vytváříme komponenty?

Komponenty jsou prvky programu s nimiž manipulujeme během návrhu. Vytváření nové komponenty znamená odvození třídy nové komponenty od existující třídy. Novou komponentu můžeme odvodit od libovolné existující komponenty, nejčastější způsoby vytváření komponenty jsou: V následující tabulce jsou uvedeny různé typy komponent a třídy od kterých je odvozujeme.
 
K provedení Začneme od typu
Modifikace existující komponenty libovolné existující komponenty, jako je TButton nebo TListBox, nebo od typu abstraktní komponenty jako je TCustomListBox.
Vytváření původního ovladače TCustomControl
Vytváření grafického ovladače TGraphicControl
Použití existujícího ovladače Windows TWinControl
Vytvoření nevizuální komponenty TComponent

Můžeme také odvodit jiné třídy, které nejsou komponentami a se kterými nelze manipulovat na formuláři. C++ Builder obsahuje mnoho těchto tříd, jako je TINIFile nebo TFont.

Modifikování existujícího ovladače

Nejjednodušší způsob vytvoření komponenty je začít od existující funkční komponenty a přizpůsobit ji. Novou komponentu můžeme odvodit od libovolné komponenty poskytnuté C++ Builderem. Např. můžeme chtít změnit hodnotu implicitní vlastnosti jednoho ze standardních ovladačů.
Některé ovladače, jako jsou komponenty seznamu a mřížky, mají mnoho variant na základní téma. V těchto případech C++ Builder poskytuje abstraktní typ ovladače (se slovem "Custom" ve svém jméně, jako je např. TCustomGrid), který slouží k odvozování jednotlivých verzí.
Např. můžeme potřebovat vytvořit speciální typ seznamu, který nemá některé vlastnosti standardního typu TListBox. Jelikož nelze odstranit vlastnost z typu předka, musíme svou komponentu odvodit od něčeho výše v hierarchii než je TListBox. Nemusíme začít od typu prázdného abstraktního ovladače a vytvářet všechny funkce seznamu, neboť VCL poskytuje TCustomListBox, který implementuje všechny vlastnosti potřebné pro seznam, ale všechny je nezveřejňuje. Když odvozujeme komponentu od některého z abstraktních typů, jako je TCustomListBox, zveřejníme ty vlastnosti, které chceme zpřístupnit ve své komponentě a ostatní ponecháme chráněné.

Vytváření původního ovladače

Při vytváření původního (nového) ovladače je důležité toto. Standardní ovladač je prvek, který je viditelný při běhu aplikace a obvykle s ním uživatel může pracovat. Tyto standardní ovladače jsou všechny potomky třídy TCustomControl. Když vytváříme původní ovladač (takový, který není svázán s žádným existujícím ovladačem), musíme jako počáteční bod použít TCustomControl. Klíčovým aspektem standardního ovladače je to, že má madlo okna, uložené ve vlastnosti nazvané Handle. Madlo okna umožňuje Windows "vědět o" ovladači a mimo jiné umožňuje ovladači získat vstupní zaostření a předávat madlo funkcím Windows API (Windows potřebuje madlo k určení okna, se kterým má operovat). Jestliže náš ovladač nepotřebuje získat vstupní zaostření, můžeme jej vytvořit jako grafický ovladač, který nevyužívá systém zdrojů Windows. Všechny ovladače, které reprezentují standardní ovladače Windows, jako jsou tlačítka, seznamy a editační okna jsou potomky TWinControl (mimo TLabel, neboť tento ovladač nemůže získat vstupní zaostření).

Vytváření grafického ovladače

Grafické ovladače jsou velmi podobné uživatelským ovladačům, ale nejsou odvozeny od ovladačů Windows, tj. Windows nic o grafických ovladačích neví. Nemají madlo okna a tedy nečerpají zdroje systému. Hlavním omezením grafických ovladačů je, že nemohou získat vstupní zaostření. C++ Builder podporuje vytváření grafických uživatelských ovladačů prostřednictvím třídy TGraphicControl. TGraphicControl je abstraktní třída odvozená od TControl. Přestože můžeme odvozovat ovladače od TControl, je vhodnější je odvozovat od třídy TGraphicControl, která poskytuje plátno na kreslení a zpracovává zprávu WM_PAINT a není tedy nutné přepisovat metodu Paint.

Použití existujícího ovladače Windows

Windows má koncepci nazvanou třída okna, která se podobá koncepci objektově orientovaného programování objektů nebo tříd. Třída okna je množina informací sdílená mezi různými instancemi stejného typu oken nebo ovladačů ve Windows. Když vytváříme nový typ ovladače (obvykle nazývaný uživatelský ovladač) v tradičním programování Windows, definujeme novou třídu okna a registrujeme ji ve Windows. Můžeme také založit novou třídu okna na existující třídě. Jestliže chceme vytvořit uživatelský ovladač v tradičním programování Windows, musíme jej zapsat v DLL stejně jako standardní ovladače Windows a poskytnout k němu rozhraní.
Pomocí C++ Builderu můžeme vytvořit komponentu ?obálkou okolo existující třídy Windows. Jestliže tedy máme knihovnu uživatelských ovladačů, které chceme používat ve svých aplikacích C++ Builderu, můžeme vytvořit komponenty C++ Builderu, ve kterých použijeme existující ovladače a odvodíme od nich nové ovladače a to stejně jako od jiných komponent. I když v této publikaci není uveden žádný příklad použití existujícího ovladače Windows, můžeme se s touto technikou seznámit v komponentách v hlavičkovélkou? okolo StdCtls, které reprezentují standardní ovladače Windows, např. TEdit.

Vytváření nevizuálních komponent

Abstraktní třída TComponent je základním typem pro všechny komponenty. Nevizuální komponenty jsou komponenty, které odvozujeme přímo od TComponent. TComponent definuje všechny nezbytné vlastnosti a metody komponenty pro spolupráci s Návrhářem formuláře. Tedy libovolné komponenty odvozené od TComponent mají zabudované možnosti návrhu. Nevizuální komponenty jsou používány málo. Jejich využití je jako rozhraní pro nevizuální prvky programu (např. pro databázové prvky) a držení místa pro dialogová okna (např. souborová dialogová okna).

Co děláme v komponentách?

K udělání našich komponent nedělitelnou částí prostředí C++ Builderu, je nutno při jejich návrhu dodržovat jisté konvence. Tato sekce je rozepsána do následujících bodů:

Odstraňování závislostí

Jednou kvalitou, která dělá komponentu použitelnou je absence omezení na to co můžeme dělat v jejich kódu. Podle jejich povahy, komponenty jsou  zapojovaný do aplikací v různých kombinacích, pořadí a obsahů. Musíme navrhnout komponenty, které jsou funkční v libovolné situaci a to bez nějakých podmínek.
Vzorovým příkladem odstraňování závislosti v komponentách je vlastnost Handle okenních ovladačů. Pokud jsme zapisovali dříve Windowsovské aplikace, pak víme, že nejobtížnějším a důležitým aspektem při získávání běžícího programu je zajištění toho, že nepřistupujeme k oknům nebo ovladačům dokud nejsou vytvořeny funkcí API CreateWindow. Volání API funkcí s chybnými madly způsobuje řadu chyb.
Komponenty C++ Builderu chrání uživatele před prací s madly a zajišťují, že v případě potřeby je dostupné přípustné madlo. Pomocí vlastnosti Handle okna, komponenta může testovat zda okno bylo vytvořeno a tedy zda má přípustné madlo. Pokud madlo není přípustné, pak vlastnost vytvoří okno a vrací madlo. Tedy, kdykoliv kód uživatele přistupuje k vlastnosti Handle, získá vždy přípustné madlo.
Měli bychom navrhovat své komponenty, aby jejich funkčnost v jakémkoli kontextu nebyla ničím podmíněna. Vytvořit komponenty, které nejsou závislé, možná zabere více času, je to ale vhodně využitý čas.

Vlastnosti, metody a události

Kromě viditelného obrazu komponenty, se kterým uživatel manipuluje na formuláři při návrhu, jsou nejdůležitější atributy komponenty její vlastnosti, události a metody.
Vlastnosti dávají uživatelům komponent iluzi nastavování nebo čtení hodnot proměnných v komponentě, zatímco tvůrce komponenty skrývá použité datové struktury a implementaci přístupu k hodnotám. Používání vlastností dává tyto výhody: Vlastnosti jsou přístupné během návrhu (to umožňuje uživatelům komponent nastavovat a měnit počáteční hodnoty vlastností bez zásahu do kódu), vlastnosti mohou testovat hodnoty nebo formáty, které jim uživatel přiřadí (kontrolou uživatelova vstupu zabraňujeme chybám způsobeným nedovolenými hodnotami) a komponenta může na žádost vytvářet příslušnou hodnotu (častý typ programátorských chyb je odkaz na proměnnou, která nemá přiřazenou počáteční hodnotu; vytvořením hodnoty vlastnosti, můžeme zajistit, že hodnota vlastnosti je vždy přípustná).
Události jsou propojením mezi výskyty určenými tvůrcem komponenty (např. akce myši nebo klávesnice) a kódem zapsaným uživatelem komponenty (obsluha události). Událost je možnost poskytnutá tvůrcem komponenty uživateli komponenty pro specifikaci kódu, který má být proveden v určitých případech. Uživatel komponenty může specifikovat obsluhu pro předdefinovanou událost a nemusí odvozovat vlastní komponentu.
Metody jsou funkce zabudované v komponentě. Uživatel komponenty používá metody k přikázání komponentě, aby provedla specifickou akci nebo vrátila jistou hodnotu, která není vlastností. Metody jsou také užitečné pro aktualizaci několika svázaných vlastností jediným voláním. Protože metody vyžadují provedení kódu jsou dostupné pouze za běhu programu.

Grafické zaobalení

C++ Builder odstraňuje namáhavou práci s grafikou Windows zaobalením různých grafických nástrojů do plátna. Plátno reprezentuje kreslící plochu okna nebo ovladače a obsahuje další objekty jako je pero, štětec a písmo. Plátno je něco jako kontext zařízení Windows, ale přebírá starost o řadu věcí za nás.
Jestliže vytváříme grafickou aplikaci Windows, musíme se seznámit s typy požadavků grafického rozhraní Windows, jako jsou limity příslušných kontextů zařízení a obnovováním grafických objektů na jejich počáteční stav před jejich uvolněním.
Když pracujeme s grafikou v C++ Builderu, nemusíme tyto věci znát. Pro kreslení na formulář nebo komponentu, přistupujeme k vlastnosti Canvas. Jestliže chceme přizpůsobit pero nebo štětec, nastavíme barvu nebo styl. Když skončíme, C++ Builder přebírá odpovědnost za uvolnění zdrojů.
Máme stále plný přístup k GDI Windows, ale náš kód bude jednodušší a bude pracovat rychleji, jestliže použijeme plátno zabudované do komponent C++ Builderu.

Registrace

Dříve než můžeme komponentu použít při návrhu, musíme ji v C++ Builderu registrovat. Registrace říká C++ Builderu, na které stránce Palety komponent chceme komponentu zobrazit. Můžeme také přizpůsobit způsob jak C++ Builder ukládá své komponenty v souboru formuláře.

Vytváření nové komponenty

Novou komponentu můžeme vytvořit dvěmi způsoby: Použijeme některou z těchto metod k vytvoření minimální funkčnosti komponenty potřebné k instalaci na Paletu komponent. Po instalaci, můžeme přidat novou komponentu na formulář a otestovat ji jak při návrhu tak i za běhu. Ke komponentě pak můžeme přidat další služby, aktualizovat Paletu komponent a pokračovat v testování.
Proces vytváření komponenty se skládá z těchto kroků:
  1. Vytvoření jednotky (kombinace souboru CPP a hlavičkového souboru) pro novou komponentu.
  2. Odvození typu komponenty od existujícího typu komponenty.
  3. Přidání vlastností, metod a událostí podle potřeby.
  4. Registrování naší komponenty v C++ Builderu.
  5. Vytvoření nápovědného souboru pro naši komponentu a její vlastnosti, metody a události.
  6. Vytvoření balíčku (speciální DLL) ze kterého můžeme instalovat naši komponentu v IDE C++ Builderu.
Všechny tyto kroky budou popsány později. Když dokončíme vytváření komponenty, pak kompletní komponenta obsahuje tyto soubory: Vytvoříme nápovědný soubor k instruování uživatelů jak optimálně používat komponentu. Použití souboru nápovědy není povinné.
Použití průvodce vytvářením komponenty
Průvodce komponentou zjednodušuje počáteční stav vytváření komponenty. Je zapotřebí zadat pouze: Průvodce komponentou provede stejné úlohy, jako kdybychom komponentu vytvářeli ručně: Průvodce komponentou ale nedokáže přidat komponentu do již existující jednotky (v každé jednotce musí být pouze jedna komponenta). Pokud chceme přidat novou komponentu, pak ji musíme přidat ručně.
Pro spuštění Průvodce komponentou zvolíme Component | New Component nebo zvolíme File | New, přejdeme na stránku New a dvojitě klikneme na Component.
Vyplníme položky v Průvodci komponentou:
  1. V položce Ancestor Type, specifikujeme třídu od které odvozujeme naši novou komponentu.
  2. V položce Class Name, specifikujeme jméno třídy naší nové komponenty.
  3. V položce Palette Page, specifikujeme stránku na Paletě komponent na kterou chceme novou komponentu instalovat.
  4. V položce Unit file name, specifikujeme jméno jednotky, ve které chceme třídu jednotky deklarovat.
  5. Pokud jednotka není zadána s adresářovou cestou, pak v případě potřeby editujeme cestu v položce Search Path.
K umístění komponenty do nového nebo existujícího balíčku, zvolíme Component | Install a použijeme zobrazené okno ke specifikaci balíčku.
Varování: Pokud odvozujeme třídu od třídy VCL, jejíž jméno začíná custom (jako např. TCustomControl), pak novou komponentu nesmíme umístit na formulář, dokud nemáme přepsány všechny abstraktní metody v původní komponentě.
Po vyplnění položek v Průvodci komponentou stiskneme OK. C++ Builder vytváří novou jednotku obsahující soubor CPP a přiřazený hlavičkový soubor.
CPP soubor je zobrazen v Editoru kódu. Obsahuje konstruktor komponenty a funkci Register, informující C++ Builder kterou komponentu přidáváme ke knihovně komponent a na které stránce Palety komponent se zobrazí. Soubor také obsahuje vkládaní potřebných hlavičkových souborů. Např.
#include <vcl\vcl.h>
#pragma hdrstop
#include "NewComponent.h"
#pragma package(smart_init);
static inline TNewComponent *ValidCtrCheck()
{
 return new TNewComponent(NULL);
}
__fastcall TNewComponent::TNewComponent(TComponent* Owner)
 : TComponent(Owner)
{
}
namespace Newcomponent
{
 void __fastcall PACKAGE Register()
 {
  TComponentClass classes[1] = {__classid(TNewComponent)};
  RegisterComponents("Samples", classes, 0);
 }
}
K otevření hlavičkového souboru v Editoru kódu, umístíme kurzor myši na jméno hlavičkového souboru a kliknutím pravým tlačítkem myši zobrazíme místní nabídku. Zde zvolíme Open File at Cursor.
Hlavičkový soubor obsahuje deklaraci nové třídy, včetně deklarace konstruktoru a vložení několika hlavičkových souborů pro podporu nové třídy. Např.
#ifndef NewComponentH
#define NewComponentH
#include <vcl\SysUtils.hpp>
#include <vcl\Controls.hpp>
#include <vcl\Classes.hpp>
#include <vcl\Forms.hpp>
class PACKAGE TNewComponent : public TComponent
{
private:
protected:
public:
 __fastcall TNewComponent(TComponent* Owner);
__published:
};
#endif
Jednotku před zpracováním uložíme a dáme ji smysluplné jméno.
Ruční vytváření komponenty
Ruční vytváření komponenty probíhá v těchto krocích:
  1. Vytvoříme soubor jednotky
  2. Odvodíme komponentu
  3. Deklarujeme nový konstruktor
  4. Registrujeme komponentu
Vytvoření jednotky
Jednotka C++ Builderu je složena z kombinace souboru CPP a souboru H, která je přeložena do souboru OBJ. C++ Builder používá jednotky pro několik účelů. Každý formulář má svoji vlastní programovou jednotku a většina komponent (nebo logických skupin komponent) má také svou vlastní jednotku.
Když vytváříme komponentu, můžeme pro komponentu vytvořit novou jednotku nebo přidat novou komponentu do existující jednotky.
K vytvoření jednotky pro komponentu, zvolíme File | New Unit nebo zvolíme File | New, přejdeme na stránku New zobrazeného dialogového okna, zvolíme Unit a stiskneme OK. C++ Builder vytvoří CPP soubor a hlavičkový soubor a CPP soubor otevře v Editoru kódu. Vytvořenou jednotku uložíme pod smysluplným jménem.
Pro přidání komponenty k existující jednotce, zvolíme File | Open a vybereme zdrojový kód existující jednotky. Když přidáváme komponentu k existující jednotce, musíme si být jisti, že jednotka obsahuje pouze kód komponent. Přidání kódu komponent k jednotce, která obsahuje např. formulář, způsobí chybu.
Jestliže máme novou nebo existující jednotku pro naši komponentu, pak můžeme odvodit třídu komponenty.

Odvození komponenty
Každá komponenta je třída odvozená od typu TComponent, od jednoho z více specializovaných potomků, jako je TControl nebo TGraphicControl, nebo od existujícího typu komponenty.
K odvození třídy komponenty, přidáme deklaraci třídy do hlavičkového souboru jednotky, který má komponentu obsahovat.
Např. pro vytvoření jednoduchého typu nevizuální komponenty ji odvodíme přímo od TComponent a do hlavičkového souboru naši jednotky přidáme následující deklaraci třídy:
class PACKAGE TNovaKomponenta : public TComponent
{
};
Makro PACKAGE je expandováno na příkaz, který umožňuje importování a exportování tříd. Musíme také přidat příkazy vložení hlavičkových souborů, které jsou nutné pro novou komponentu. Většinou to budou direktivy:
#include <vcl\SysUtils.hpp>
#include <vcl\Controls.hpp>
#include <vcl\Classes.hpp>
#include <vcl\Forms.hpp>
Nová komponenta se neliší od TComponent. Tvoří rámec, ve kterém budeme budovat svoji novou komponentu.

Deklarace nového konstruktoru
Každá nová komponenta musí mít konstruktor, který přepisuje konstruktor třídy, od které komponentu odvozujeme. Když zapisujeme konstruktor pro novou komponentu, pak tento konstruktor musí vždy volat zděděný konstruktor. V deklaraci třídy deklarujeme konstruktor a to ve veřejné části třídy. Např.
class PACKAGE TNovaKomponenta : public TComponent
{
  public:
    virtual __fastcall TNovaKomponenta(TComponent* AOwner);
};
Do CPP souboru vložíme implementaci konstruktoru:
__fastcall TNovaKomponenta::TNovaKomponenta(TComponent* AOwner)
    : TComponent(AOwner)
{
}
Do konstruktoru přidáme kód, který chceme provést při vytváření komponenty.

Registrace komponenty
Registrace komponenty je jednoduchý proces, který říká C++ Builderu, které komponenty přidat do své knihovny komponent a na které stránce Palety komponent bude komponenta zobrazena. K registraci komponenty přidáme funkci nazvanou Register do souboru CPP a umístíme ji do jmenného prostoru. Jméno jmenného prostoru je jméno souboru komponenty bez přípony, ve kterém jsou s výjimkou prvního písmena všechna písmena malá. Např. tento kód existuje ve jmenném prostoru Novakomp, poněvadž NovaKomp je jméno CPP souboru.
namespace Novakomp
{
  void __fastcall PACKAGE Register()
  {
  }
}
V této funkci deklarujeme otevřené pole typu TComponentClass, které obsahuje registrované komponenty. Syntaxe je tato:
TComponentClass classes[1] = {__classid(TNovaKomponenta)};
V tomto příkladě pole obsahuje právě jednu komponentu, ale můžeme přidat další komponenty, které chceme registrovat.
Ve funkci Register voláme RegisterComponents, a to pro každou registrovanou komponentu. Tato funkce přebírá tři parametry: jméno stránky palety komponent, pole tříd komponent a velikost pole tříd komponent zmenšenou o 1. Jestliže přidáváme komponentu k existující registraci, můžeme přidat novou komponentu k existujícímu příkazu nebo přidat nový příkaz, který volá RegisterComponents. Jedním voláním RegisterComponents můžeme registrovat i více komponent, jestliže jsou všechny na stejné stránce palety komponent.
K registraci komponenty nazvané TNovaKomponenta na stránce Samples Palety komponent tedy použijeme:
namespace Novakomp
{
  void __fastcall PACKAGE Register()
  {
    TComponentClass classes[1] = {__classid(TNovaKomponenta)};
    RegisterComponents("Samples", classes, 0);
  }
}
Volání Register umístí TNovaKomponenta na stránku Samples Palety komponent.
Registrovanou komponentu můžeme otestovat a nainstalovat ji na Paletu komponent.

Testování neinstalované komponenty

Chování komponenty můžeme testovat před její instalací na Paletu komponent. To je užitečné pro ladění nově vytvářených komponent, ale můžeme tuto techniku použít pro testování libovolných komponent, a to bez ohledu na to, zda komponenta je již zobrazena na Paletě komponent.
Testování neinstalovaných komponent děláme emulací akcí prováděných C++ Builderem, když uživatel umístí komponentu z palety na formulář. Provedeme tyto činnosti:
  1. Vytvoříme novou aplikaci nebo otevřeme existující.
  2. Zvolíme Project | Add to Project k přidání jednotky komponenty do našeho projektu.
  3. Vložíme hlavičkový soubor jednotky komponenty do hlavičkového souboru jednotky formuláře.
  4. Přidáme položku objektu reprezentujícího komponentu k typu formuláře. To je hlavní rozdíl mezi způsobem přidávání komponenty a způsobem prováděným C++ Builderem. Přidáme položku do veřejné části na závěr deklarace typu formuláře. C++ Builder ji přidává výše, do části deklarace, kterou sám zpracovává. My ji tam přidat nemůžeme. Prvky v této části deklarace typu odpovídají prvkům uloženým v souboru formuláře. Přidání jména komponenty, která neexistuje na formuláři, vytvoří chybný soubor formuláře.
  5. V konstruktoru formuláře vytvoříme komponentu. Když voláme konstruktor komponenty, musíme předat parametr specifikující vlastníka komponenty. Je vhodné jako vlastníka předávat vždy this. V metodě je this odkaz na objekt obsahující metodu. V obsluze událostí OnCreate se this odkazuje na formulář.
  6. Nastavíme vlastnost Parent. Nastavení vlastnosti Parent je vždy první věcí provedenou po vytvoření ovladače. Parent určuje komponentu, která vizuálně obsahuje ovladač (často to bývá formulář, ale může to být i panel nebo GroupBox). Normálně Parent nastavujeme na this, tj. na formulář. Parent vždy nastavujeme před nastavením ostatních vlastností ovladače.
  7. Nastavíme podle potřeby další vlastnosti komponenty.
Předpokládejme, že chceme testovat novou komponentu TNovaKomponenta uloženou v jednotce pojmenované NovyCtrl. Vytvoříme nový projekt a provedeme výše popsané kroky. Dostaneme tuto jednotku formuláře (nejdříve je vypsán jeho hlavičkový soubor).
#ifndef Unit1H
#define Unit1H
#include <vcl\Classes.hpp>
#include <vcl\Controls.hpp>
#include <vcl\StdCtrls.hpp>
#include <vcl\Forms.hpp>
#include "NovyCtrl.h"        // 2. Přidáme NovyCtrl do hlavičkového souboru formuláře
class TForm1 : public TForm
{
__published:
private:
public:
  TNovaKomponenta* NovyOvladac;   // 3. Přidáme datovou položku
  __fastcall TForm1(TComponent* Owner);
};
extern TForm1 *Form1;
#endif
Příkaz #include vkládající soubor NovyCtrl.h předpokládá, že soubory komponenty jsou v aktuálním adresáři projektu nebo v adresářích obsahujících vkládané soubory pro projekt.
Následuje CPP soubor jednotky:
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#pragma package(smart_init);
#pragma resource "*.dfm"
TForm1 *Form1;
static inline TNewControl *ValidCtrCheck()
{
    return new TNewControl(NULL);
}
__fastcall TForm1::TForm1(TComponent* Owner)
 : TForm(Owner)
{
  NovyOvladac = new TNovaKomponenta(this); // 4. Konstruktor komponenty
  NovyOvladac->Parent=this; // 5. Nastavení vlastnosti Parent, je-li to ovladač
  NovyOvladac->Left=12;     // 6. Nastavení ostatních vlastností podle potřeby
}

Instalování komponenty na Paletu komponent

Proces přidávání komponenty na Paletu komponent se skládá ze dvou částí. První udělá zdrojové soubory dostupnými a druhá použije Dialogové okno Install Component k přidání komponenty.
Tyto dva kroky jsou:

Kam umístíme naši komponentu

Všechny zdrojové soubory používané komponentou musí být umístěny ve stejném adresáři. Tyto soubory zahrnují soubory zdrojového kódu (CPP a PAS) a binární soubory (DFM, RES, RC a DCR). Hlavičkové soubory (H a HPP) musí být umístěny v adresáři Include (nebo v adresářích ve vyhledávacích cestách pro IDE nebo projekt).
Výsledkem procesu přidávání komponenty je vytvoření několika souborů. Tyto soubory jsou automaticky vloženy do adresáře specifikované volbou prostředí IDE (zvolíme Tools | Environment Options a přejdeme na stránku Library). LIB soubory do BPI/LIB output dir. Pokud přidáváme komponentu vytvářením nového balíčku (jako opak instalování do existujícího balíčku), pak BPL soubor je vložen do BPL output dir a soubory BPI do BPI/LIB output dir.

Přidávání komponenty

Pro přidání komponenty ke knihovně komponent:
  1. Zvolíme Component | Install Component. Je zobrazeno dialogové okno instalace komponenty.
  2. Zvolíme instalaci nové komponenty do existujícího nebo nového balíčku volbou příslušné stránky v dialogovém okně.
  3. Zadáme jméno CPP souboru obsahujícího novou komponentu nebo stiskneme tlačítko Browse a jednotku nalezneme.
  4. Zadáme vyhledávací cestu, pokud CPP soubor pro novou komponentu není v implicitním adresáři.
  5. Zadáme jméno balíčku do kterého chceme komponentu instalovat nebo stiskneme tlačítko Browse a nalezneme jej.
  6. Pokud komponentu instalujeme do nového balíčku, pak můžeme zadat smysluplný popis balíčku.
  7. K uzavření dialogového okna stiskneme OK. To přeloží/přebuduje balíček a instaluje komponentu na Paletu komponent.
Poznámka: Nově instalovaná komponenta je zobrazena na stránce Palety komponent specifikované tvůrcem komponenty. Komponentu můžeme po její instalaci přesunout na jinou stránku pomocí dialogového okna zobrazeného po volbě Component | Configure Palette.

Instalování balíčků komponent

V C++ Builderu všechny komponenty jsou instalovány v IDE jako balíčky. Pokud zapisujeme své vlastní komponenty, pak vytvoříme a zapíšeme balíček, který je obsahuje. Zdrojový kód naší komponenty musí splňovat popis uvedený v předchozích bodech této kapitoly. Pokud k jednomu balíčku přidáme více jednotek, kde v každé je komponenta, pak musíme udělat jednu funkci Register  pro všechny komponenty ve jmenném prostoru, který má jméno balíčku.
K instalaci nebo odinstalaci svých vlastních komponent nebo komponent jiných dodavatelů, provedeme tyto kroky:
  1. Pokud instalujeme nový balíček, pak překopírujeme nebo přesuneme soubory balíčku do lokálního adresáře. Pokud balíček je dodán jako soubory BPL, BPI, LIB, OBJ a hlavičkové soubory, pak je musíme překopírovat všechny. Adresář do kterého ukládáme soubory BPI a hlavičkové soubory (a další soubory pokud jsou vloženy do distribuce) musí být v Library Path C++ Builderu.
  2. Zvolíme Component | Install Packages nebo Project | Options a přejdeme na stránku Package.
  3. V části Design packages je zobrazen seznam dostupných balíčků.
  4. Stiskneme OK.
Komponenty v balíčku jsou instalované na stránky Palety komponent specifikované ve funkci RegisterComponents komponent, pod jmény přiřazenými ve stejné funkci.
Nové projekty jsou vytvářeny se všemi dostupnými instalovanými balíčky, pokud nezměníme implicitní nastavení. K udělání současných instalačních voleb automaticky implicitními pro nové projekty, označíme značku Default ve spodní části dialogového okna.
K odstranění komponent z Palety komponent bez odinstalování balíčku, zvolíme Component | Configire Palette nebo Tools | Environment Options a přejdeme na stránku Palette. Zde je seznam všech komponent společně se jménem stránky na které je komponenta zobrazena. Výběrem komponenty a stiskem Hide odstraníme komponentu z palety.
  1. Pomocí Experta komponent vytvořte novou komponentu TButtonX, která bude pracovat stejně jako původní komponenta TButton. Umístěte ji na stránku Sample Palety komponent a vyzkoušejte její použití na nějakém formuláři.
  2. Ručně vytvořte novou komponentu TEditX, která bude pracovat stejně jako původní komponenta TEdit. Umístěte ji na stránku Sample Palety komponent a vyzkoušejte její použití na nějakém formuláři.
1. Úvod do vytváření komponent