P * P * D

Programming Practices in Delphi

Programozási Példák Delphi-ben

Power Programming with Delphi

Görbe Mihály

2009-

(Programozás kezdőknek és középhaladóknak)

Ezen a Web-helyen a Delphi7 programozásával foglalkozom, pontosabban ennek a fejlesztői környezetnek a segítségével próbálok megoldani néhány feladatot, illetve problémát. A Web-hely nem abszolút kezdőknek készül. Az alapok (a VCL elemeinek) bemutatására mindössze egyetlen projektet szánok. Ezt követően különböző problémák egyfajta számítógépes megoldását kívánom ismertetni, a használt programozási környezet lehetőséginek minél szélesebb körű használatával és megismertetésével.

Amire a szükség lehet: egy programozási nyelv (célszerűen a Pascal nyelv) alapos ismerete, a legfontosabb algoritmusok ismerete, Objektum Orientált Programozási alapismeretek valamint Windows-os fejlesztői környezetekben való jártasság. Mivel lesznek HTML, Word, Excel és Access kapcsolatok, ezért a Microsof Office alkalmazások felhasználói ismerete, esetleg ezek VB programozásában való eligazodás szintén hasznos lehet az olvasó számára.

A Delphi lehetőségeinek csak töredékét, de megítélésem szerint jól és gyakran használható részét fogom ismertetni. Tehát nem felhasználói kézikönyvet szeretnék írni. (Erre sem időm, sem energiám nem lenne, egyébként számos könyv részletesen foglalkozik a nyelv lehetőségeinek ismertetésével magyar nyelven is). A hangsúlyt az adatkezeléssel kapcsolatos problémákra, a nagyméretű programok kezelésére, különböző adminisztrációs feladatok ismertetésére kívánom helyezni, de lesznek grafikus és Web-es alkalmazások is.

Az említett előzetes ismeretek elsajátításához számos könyv, Web-hely adhat segítséget. Én a Pascal nyelvvel való ismerkedéshez ajánlom a jelen Web-hely, Turbo Pascal menüpontjában lévő leírásokat, illetve programokat. Akkor kezdjük az alapokkal:

Alapok

Az ilyen oldalak Hello World típusú programokkal szoktak kezdődni. Lehet, hogy a kiírás valami más, a lényeg az, hogy egy nagyon egyszerű project legyen, az abszolút kezdők számára.

Én gyakorlatilag egyetlen projektbe, egyetlen lapra (Form-ra) helyeztem el a legfontosabb vizuális vezérlőket, amelyekre kattintva egy egyszerű szöveges ablakban jelennek meg a vezérlővel kapcsolatos legfontosabb tulajdonságok, létrehozásának körülményei, alkalmazási lehetőségei. A vezérlőket nagyjából az eszköztáron való megjelenés sorrendjében helyeztem el a Form-on, oszlop-folytonosan. Lesz majd természetesen olyan program is, amely az itt megjelenített tulajdonságoknál sokkal többet alkalmaz, ilyen lesz például a StrigGrid elem. Aki a vázolt ismeretekkel tisztában van, az ezt a fejezetet nyugodtan kihagyhatja.

Egyetlen dologra viszont felhívnám a figyelmet. Ennek a lapnak a végén található a Windows RegEdit olyan beállításának a leírása, mely XP alatt a nyitó szögletes zárójel ([) írását az IDE-ben lehetővé teszi.

A továbbiakban feltételezem, hogy az IDE (Itegrated Development Environment = Integrált Fejlesztői Környezet) szerkezetével tisztában van az olvasó. Aki hasonló környezetben programozott már, annak valószínű sok minden egyértelmű, világos.

Azért a programrendszer indítását és a környezet alaphelyzetét néhány ScreenShot-tal bemutatnám. A környezet indítása a C:\Program Files\Borland\Delphi7\Delphi32.exe állomány futtatásával történik (természetesen telepítéstől függően - ez az alapértelmezett hely). Ikonja, melyet ShortCut-ként az asztalon elhelyezett parancsikonban is láthatunk:

A rendszer betöltési ideje (mely gépünk teljesítményétől függően 5-10s) alatt a következő képet látjuk:

Az IDE a következő képernyővel jelentkezik be:

Az IDE négy különálló, de természetesen együttműködő ablakból áll.

Az első, a képernyő felső részén van, és tartalmazza a címsort, a menüsort, a fontosabb rendszerszintű parancsok ikonjait az eszköztár bal oldalán, majd egy TabControl elemen található a Komponenspaletta, melyből sok fül nem látható, de a jobb oldalon lévő vezérlőelem segítségével, görgetéssel fókuszba hozható:

A Delphi3-hoz képest hasznos újdonság az Object TreeView ablak, mellyel a Form-on található (tehát már használatba vett) elemeket gyorsan, nevükre való kattintással kiválaszthatjuk (melyen most csak a Form1-et látjuk):

A harmadik a vizuális elemek (VCL) tulajdonságait és működését beállító Object Inspector, mely egy, két füllel rendelkező TabControl, a baloldali a Properties (Tulajdonságok), jobboldali az Events (Esemény-kezelés). A Properties nézet:

Valamint az Events nézet:

A negyedik ablak az igazi szerkesztőablak, és rögtön egy alapértelmezett Form1-el jelenik meg. Lényegében egy programváz van mögötte, mely programot futtatni is lehet, csak épp egy üres Windows-os ablakon kívül semmit nem látunk. Az viszont igaz, hogy működik, méretezhető, áthelyezhető és bezárható, de semmi több. A VCL elemek elhelyezését egy pontrács segíti, alapértelmezésben az elemek ezekhez a pontokhoz igazítottan jelennek meg:

A VCL elemek elhelyezésének a módja: megkeressük az elemet a Komponenspalettán, egérrel kattintunk rajta (alapszíne világos-szürkére változik, benyomott állapotúnak látszik), majd kattintunk a Form azon pontján, ahová a VCL elem bal felső csúcsát gondoljuk elhelyezni. Az Object Inspector ekkor a neki megfelelő, alapértelmezett értékekre vált át. A többi, már a Form-on elhelyezett VCL elemre való kattintással válnak láthatóvá, az így kiválasztott elem tulajdonságai. Üres területen kattintva, a Form1 tulajdonságai láthatók.

A program szerkesztési-időben kétféle megjelenésben kezelhető. A Delphi egy 4GL típusú fejlesztői környezet, azaz a programírás egyik része a vizuális elemek elhelyezését, megjelenési tulajdonságainak (Properties) beállítását jelenti, a másik része a működését, az üzenetek kezelésének leírását, a valódi kódalkotást követeli meg. Attól, hogy egy VCL elem szépen megjelent, még nem biztos, hogy hasznosan működik is. A VCL elemek elhelyezésére szolgál az előző felület.

A kódablakra való átváltás a képernyőn Toggle Form/Unit (F12) parancsikonnal, vagy az F12 funkcióbillentyűvel lehetséges (és természetesen vissza is). Az átváltás után a kód láthatóvá válik, melyet fejlesztgethetünk, de teljesen szabadkezet nem kapunk. Majd az egyes programoknál ismertetem a megengedett és kötelező programozási lépéseket.

Pascal programozók számára rögtön feltűnhet, hogy nem Program, hanem Unit ablak jelenik meg átváltás után. A 4GL típusú fejlesztői környezetek sajátossága, hogy Project-ekben dolgozik. A Project-hez tartozó állományokat célszerű egyetlen mappában tárolni. Ha ezzel nem foglalkozunk (nem mentünk részeket direkt más mappába), akkor az IDE biztosan mindent abban a mappában hoz létre, melyet a mentéskor megadunk. Legyen például a Project-ünk neve: Minta. Hozzunk létre valamely meghajtón és környezetben egy ilyen nevű mappát (azaz Minta-t, mely név rövid és egyébként kifejezi a Project-ünk tartalmát).

Ha egyszerre csak kevés változóval és Unit-al dolgozunk, akkor a Code-lap baloldalán lévő ablakot bezárhatjuk, így több hely marad a kód megjelenítésére:

Mielőtt mentenénk, nézzük meg, hogy a Project-hez milyen szerkeszthető állományok tartoznak. A képernyőn, a harmadik eszköztároló sorban, az első helyen találjuk a parancsikont, melynek neve és funkciója: View Unit (Ctrl+F12). Erre kattintva a Unit-ok listáját láthatjuk:

Válasszuk a listából a Project1-et és OK. Most már programlistát kapunk, de nem Program1 a neve, hanem Project1. Pascal programozók nagyon jól tudják, hogy a Unit-ok belső és operációs rendszerbeli nevének meg kell egyezni, ez a Delphi-ben is így van. Mentéskor az IDE - a programoknál és a unitoknál egyaránt - az alapértelmezett belső nevet, a mentési névre kicseréli. Kattintás után a következőt láthatjuk:

Aki a Pascal környezetben Turbo Vision-ban programozott, vagy a szakirodalom által a Pascalban is ajánlott módon OOP alapú rendszereket fejlesztett, az ezzel a listával elégedett lehet. A főprogram tartalmaz Init-et, Create-et és Run-t. Talán a Done hiányzik (?), de azért, mert az ehhez tartozó tevékenységeket a Windows-os környezet, a program leállításakor automatikusan végrehajtja (ablakok zárása, szemétgyűjtés, Heap felszabadítás, egyéb változók és paraméterek nullázása, alapértelmezések visszaállítása).

Tegyünk még meg annyit, hogy Project-ünket a létrehozott Minta mappába mentsük le, majd futtassuk. Mentéshez a Save All (Shift+Ctrl+S) parancsikont válasszuk. A felajánlott Bin könyvtárat ne fogadjuk el, válasszuk helyette az általunk létrehozott Minta mappát. Változtassuk meg az alapértelmezett Unit1 nevet UMinta-ra, majd a Mentés következik, ekkor a Project1 jelenik meg a File név mezőben, melyet PMinta-ra írjunk át, majd újra Mentés. Nézzük meg, milyen állományok jöttek létre a Minta mappában:

Ezután futtassuk a programot a Run (F9) parancsgombbal. A megígért üres ablakot látjuk, az említett tulajdonságokkal:

Tegyük még meg azt, hogy megnézzük, hogyan változott a Minta mappánk tartalma:

Mint látható két állománnyal bővült: a PMinta.exe futtatható állománnyal, valamint az UMinta.dcu-val, ami nem más, mint az UMinta.pas forrás állománynak a lefordított változata. A további fejlesztések során már a Delphi-t a PMinta.dpr-ről, azaz Delhi project állományról célszerű indítani, így a fejlesztés közben nem kell a mentések célhelyével foglalkozni, mert biztosan abba a mappába menti, amelyikben a project állomány is volt. (Természetesen egyéb helyet is választhatunk, ekkor a PMinta.pas állomány listájából a célhely a későbbiekben kiolvasható.) A többi állomány jelentését, hasznát majd a későbbiekben részletezzük.

Most pedig lássuk a VCL (Visual Control Library) elemek bemutatását szolgáló program először szerkesztési, majd futási képét.

Minden elem leírása, beállítása, használati lehetősége a Project-ből megismerhető. A tulajdonságok felsorolásából kihagytam azokat, amely a VCL elemek szinte mindegyikében szerepel. Ezek itt írom le:

Left: az elem távolsága az őt tartalmazó konténer bal szélétől pixelben.

Top: az elem távolsága az őt tartalmazó konténer tetejétől pixelben.

Width: az elem szélessége pixelben.

Height: az elem magassága pixelben.

Align: az elem igazítása az őt tartalmazó konténer széleihez és a többi VCL elemhez viszonyítva.

Alignment: az elem tartalmának igazítása az elemen belül.

Color: az elem háttérszíne.

Font: amennyiben a VCL elemben karakterek jelennek meg, akkor a karakterek tulajdonságait egy párbeszédablakban állíthatjuk be:

Enabled: az elem kezelhetőségének (használhatóságának) beállítása, True vagy False.

Hint: alkalmas egy egysoros szöveg tárolására, mely az egérkurzornak a VCL elem fölé helyezésére megjelenik, ha engedélyezzük.

ShowHint: a Hint szöveg megjelenésének engedélyezése, értéke True vagy False.

Name: az elem azonosítója, a szokásos változónév-adási megkötésekkel.

PopupMenu: amennyiben a VCL elemen felbukkanó menüt szeretnénk az egér jobb gombjának kattintásával megjeleníteni, akkor ennek a tulajdonságnak az értéke, a hívni kívánt PopupMenu neve.

TabOrder: az elem elhelyezési sorrendje, mely átrendezhető (Form-on helyi menü egér jobb gomb segítségével, majd TabOrder menüpont.). A Tab billentyű e szerint hozza fókuszba az elemeket a Form-on, futási időben.

Visible: az elem láthatóságának beállítása, True vagy False.

A tulajdonságokat az Object Inspector/Properties ablakban láthatjuk. Az értékek beállításának lehetőségei:

- alapértelmezett,

- egy legördülő ComboBox listából választhatunk,

- a VCL elem Form-on történő elhelyezésével beállítódik

- vagy a tulajdonság egy Edit mezőben beírható.

A VCL elemek helyének és méretének finom (pixel szintű) beállítása: a hely beállítását Ctrl+[nyilakat tartalmazó billentyű], a méret beállítását Shift+[nyilakat tartalmazó billentyű] segítségével végezhetjük el.

Így az alapok megismerésének vége felé érdemes megemlíteni a nyelv azonosítóinak használatával kapcsolatban néhány tanácsot.

Az első az, hogy Delphi (ugyanúgy mint a Pascal sem) nem CaseSensitiv. Teljesen mindegy, hogy az azonosítókban kis vagy nagybetűkkel írjuk le a szavakat, a nyelv ugyanannak az azonosítónak veszi.

Nagyon gyakran előfordul, és én is előszeretettel használom az aláhúzás karakter helyett a szóösszetételeknél, a szavak első betűjének nagybetűs alakban való írását. Ez az azonosító jelentésének megértését, megjegyzését szolgálja (beszédes azonosítók), pl.: ClearScreen, SzinesNyomtato, BadCase, KovetkezoLap, stb. Az azonosítók programjaimban többnyire magyar szavakból származnak (természetesen magyar ékezetek nélkül írva), de közismertebbnek gondolt angol szavak vagy rövidítések is gyakran előfordulnak közöttük.

A következő, ami szintén az azonosítók alapján történő jobb kódmegértést, kódolvasást szolgálja a konvenciók. Míg az előbb leírtakban, előfordulnak kötelezően betartandó dolgok (pl.: egyetlen szó lehet, nem kezdődhet számmal, nem tartalmazhat bizonyos karaktereket), addig a konvenciókhoz egyszerűen csak célszerű ragaszkodni. Hogy mi az oka? Nincs nehezebben érthető dolog, mint az általunk több évvel ezelőtt szerkesztett kód, ha időközben teljesen mással foglalkoztunk. Ráadásul, ha sokan használják, akkor az általad írt kódot mások is könnyebben megérthetik, akár programbeli megjegyzések nélkül is. (Természetesen egy jól kommentezett kódlista mindenki számára aranyat ér, könnyen megérthető, visszafejthető, módosítható.) A konvenciók egy szűk köre a teljes azonosítóra vonatkozik, sok esetben csak az első, vagy az első két karakter következetes alkalmazását várják el tőlünk. Nézzünk mindhárom esetre példákat.

Teljes szavak, azonosítók: Init, Run, Done, Show, Hide az OOP nyelvekben standardnak mondhatók, másra ne használjuk. A Set és Get szókezdés az objektum mezőinek beállítását illetve lekérdezését jelöli (természetesen kiegészítve a mező nevével). Hasonlóan foglaltaknak vehetjük a Create, Open Close, Clear vagy UpDate Szavakat is. Az X, Y és Z általában koordinátarendszerekben használatosak, ezért én is legtöbbször ilyen értelemben használom. Az A, B, C, D, E, F, G és H betűket, mint általános azonosítókat kezelem, ha lényegük leírására több karakter teljesen fölösleges. Az I, J, K, L, M és N betűk szinte mindig ciklusváltozók, vagy egyszerű számlálások értékeit tárolják. Az O, P, Q, R, S és T gyakran ideiglenes (puffer) változók, míg az U, V és W-t egyéb munkaváltozóknak fogom használni.

Első betűre vonatkozó konvenciók: P: Project vagy Pointer, U: Unit, T: Type vagy tömb, R: Record, F: File vagy mező, I: Init (alapértelmezett, kezdő) érték.

Első két betűre vonatkozó konvenciók: st: String, fm: Form, bb: BitBtn, bt: Button, ca: Calendar, cb: CheckBox, cd: CheckListBox, cg: ClorGrid, cl: ComboBox, co: ColorBox, cr: CoolBar, dg: DrawGrid, dt: DateTimePicker, ed: Edit, gb: GroupBox, il: ImageList, im: Image, lb: Label, ld: ListBox, le: LabeledEdit, mc: MonthCalendar, me: MaskEdit, mi: MenuItem, mm: Memo, mn: MainMenu, pb: ProgressBar, pc: PageControl, pm: PopupMenu, pn: Panel, pp: PopupMenuItem, rb: RadioButton, re: RichEdit, rg: RadioGroup, sb: ScrollBar, se: SpinEdit, sg: StringGrid, sl: SrollBox, sp: Shape, st: StatusBar, tb: TrackBar, tc: TabControl, tl: ToolBar, ts: TabSheet, ud: UpDown, vl: ValueListEditor. (A kétbetűs előtagok kisbetűvel írandók, melyek nem mindig a szóösszetétel szerinti rövidítések, de ha tehetjük, azért használjuk ezeket. Én mindenesetre igyekszem.)

Végül következzék a bevezetőben ígért szögletes zárójeles probléma megoldása. Telepítés után, a Delphi7 AltGr+F-re nem ír szögletes zárójelet, ehhez a rendszer egy olyan HotKey-t rendel, amit én például nem szoktam használni, tömbindexet viszont annál inkább. Tehát a megoldás: a Windows/Start menü/Futtatás . . . ablakába írjuk be: regedit, majd OK:

A Rendszerleíróadatbázis-szerkesztőben keressük meg a Sajátgép/HKEY_CURRENT_USER/Software/Borland/Delphi/7.0/Editor/Options szakaszt:

A megnyitás után, a szerkesztő területen csak egyetlen sor található. Ezen a területen egér jobb fülével kattintva, a lokális menüből az Új/Karakterláncot menüpontot válasszuk. Az új sor nevét írjuk át: NoCtrlAltKeys-re, majd nyomjunk Entert. Ezek után a szerkesztőablakban megjelenő soron kettőt kattintva a következő ablak jelenik meg, melyben az Érték mezőnek adjunk 1-et:

Ezzel az átállítást befejeztük, az IDE írni fog nyitó szögletes zárójelet ([-et).

A VCL elemeket bemutató program listája (a tulajdonságokat megjelenítő Memo mező lemezes .txt állományokból olvassa be a tartalmakat, melyeket a listában rem-ekben láthatunk):

//**************************************
// A Vizuális Komponens Könyvtár (VCL) *
//          elemeit bemutató           *
//       demonstrációs program         *
//                                     *
//  Készítette: Görbe Mihály (GM-Soft) *
//                2009                 *
//**************************************

unit UVCL;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, 

Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls, Buttons, ComCtrls, CheckLst, Grids, Mask,
  Calendar, Spin, ColorGrd, ValEdit, Menus;

type
  TfmVCL = class(TForm)
    lbVCL: TLabel;
    edVCL: TEdit;
    mmVCl: TMemo;
    btVCL: TButton;
    cbVCL: TCheckBox;
    rbVCL: TRadioButton;
    ldVCL: TListBox;
    clVCLClose: TComboBox;
    clVCLOpen: TComboBox;
    sbVCL: TScrollBar;
    lbVCLSB: TLabel;
    btKilep: TButton;
    lbGorgeto: TLabel;
    gbVCL: TGroupBox;
    rgVCL: TRadioGroup;
    pnVCL: TPanel;
    bbVCL: TBitBtn;
    meVCL: TMaskEdit;
    sgVCL: TStringGrid;
    dgVCL: TDrawGrid;
    imVCL: TImage;
    spVCL: TShape;
    cdVCL: TCheckListBox;
    leVCL: TLabeledEdit;
    coVCL: TColorBox;
    tcVCL: TTabControl;
    pcVCL: TPageControl;
    tbVCL: TTrackBar;
    pbVCL: TProgressBar;
    udVCL: TUpDown;
    edUDVCL: TEdit;
    dtVCL: TDateTimePicker;
    mcVCL: TMonthCalendar;
    cgVCL: TColorGrid;
    seVCL: TSpinEdit;
    caVCL: TCalendar;
    mmVCLDescript: TMemo;
    ts1: TTabSheet;
    ts2: TTabSheet;
    ts3: TTabSheet;
    ts4: TTabSheet;
    mm3: TMemo;
    mm1: TMemo;
    ed2: TEdit;
    lb4: TLabel;
    pmMenu: TPopupMenu;
    pp1: TMenuItem;
    pp2: TMenuItem;
    pp3: TMenuItem;
    sgInTabCont: TStringGrid;
Procedure MemoView(X,Y, W,H: Word; OSVCL: String);
procedure lbVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure FormMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure sbVCLChange(Sender: TObject);
procedure clVCLOpenKeyPress(Sender: TObject; var Key: Char);
procedure btKilepClick(Sender: TObject);
procedure edVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure mmVClMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure btVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure cbVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure rbVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure ldVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure clVCLCloseClick(Sender: TObject);
procedure clVCLOpenClick(Sender: TObject);
procedure gbVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure rgVCLClick(Sender: TObject);
procedure pnVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure bbVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure sgVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure dgVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure imVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure spVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure meVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure cdVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure leVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure coVCLChange(Sender: TObject);
procedure tcVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure pcVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure tbVCLChange(Sender: TObject);
procedure pbVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure udVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure seVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure cgVCLMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
procedure caVCLChange(Sender: TObject);
procedure dtVCLChange(Sender: TObject);
procedure mcVCLClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
  fmVCL: TfmVCL;
  FVCL: Text;

implementation

{$R *.dfm}

Procedure TfmVCL.MemoView(X,Y, W,H: Word; OSVCL: String);
Begin
With mmVCLDescript Do
Begin
    Top:= Y; Left:= X; Width:= W; Height:= H; Visible:= True;
If FileExists(OSVCL) Then mmVCLDescript.Lines.LoadFromFile(OSVCL);
End;
End;

procedure TfmVCL.btKilepClick(Sender: TObject);
begin
  Close;
end;

procedure TfmVCL.clVCLOpenKeyPress(Sender: TObject; var Key: Char);
begin
With clVCLOpen do If Key=#13 Then Items.Add(Text);
end;

procedure TfmVCL.FormMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With mmVCLDescript Do
Begin
    Visible:= Not Visible;
If Visible Then MemoView(X,Y,200,150,'Form.txt');

//Form: TForm, létrehozása: Kattintás a New Form parancsgombon.
//Az alkalmazás ablaka, a VCL elemek elsődleges container objektuma.
//MDI (Multiple Document Interface) alkalmazás esetén a FormStyle
//tulajdonságot szülő ablaknál fsMDIForm-ra, gyermek ablaknál fsMDIChild-re
//kell állítani. Alapértermezett megjelenési méretről WindowsState
//tulajdonsággal lehet maximális, illetve minimális méretre állítani.
//Az ablak vezérlő ikonjait a BorderIcons tulajdonsággal ki-be kapcsolhatjuk.
//A BorderStyle tulajdonsággal a megjelenítő keret tulajdonságait
//határozhatjuk meg, vagy akár keret nélküli megjelenést (full screen-t) is
//választhatunk.
//A PopupMenu tulajdonságát a megfelelő PopupMenu-re kell beállítani.

End;
end;

procedure TfmVCL.lbVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'Label.txt');

//Label: TLabel, Standard paletta.
//Címke, legtöbbször változatlan tartalmú, szöveges megjelenítő elem.
//A megjelenítendő szöveget a Caption tulajdonság tartalmazza,
//mely szerkesztési és futási időben is megadható.
//A helyfoglalását automatikusan a szöveg beírásával állítja.
//A területét kijelölés után húzással megváltoztathatjuk.
//Célszerű olyan méretet beállítani, amikor a szöveg teljesen látható.
//Ha a szöveg a teljes lefoglalt területet nem tölti be, akkor igazitást
//állíthatunk be az Aligment és a Layout tulajdonságokkal. Ha többsoros
//címkét szeretnénk, akkor a WordWrap tulajdonságot állítsuk True-ra.

end;

procedure TfmVCL.sbVCLChange(Sender: TObject);
begin
  lbVCLSB.Caption:= IntToStr(sbVCL.Position);
With Mouse.CursorPos Do MemoView(X,Y,200,150,'ScrollBar.txt');

//ScrollBar: TScrollBar, Standard paletta.
//Görgetősáv. Alkalmas két határérték közötti értéknek egérrel vagy
//billentyüzetről a kurzorvezérlőkkel történő beállítására.

end;

procedure TfmVCL.edVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'Edit.txt');

//Edit: TEdit, Standard paletta.
//Egysoros szerkeszthető beviteli mező. A beviteli mező tartalmát a Text
//tulajdonságban lehet megadni szerkesztési időben, futási időben pedig
//belső utasítással vagy billentyűzetről. Fókuszba kerüléskor alapértelmezés
//szerint a mező tartalma kijelölt lesz, azaz írásra felülíródik.
//Ezt állíthatjuk az AutoSelect tulajdonsággal. A MaxLength tulajdonsággal
//a billentyűzetről beolvasható karakterek maximális számát adhatjuk meg.
//Alapértelmezésben ez 0, ami azt jelenti, hogy nincs korlátozva a bevihető
//szöveg hossza (2 GB). Ha számot akarunk benne tárolni és onnan számként is
//szeretnénk kiolvasni azt, akkor IntToStr vagy FloatToStr konverziós
//függvényt, kiolvasáskor pedig - az ellenőrzés miatt - Val eljárást kell
//alkalmazni.

end;

procedure TfmVCL.mmVClMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'Memo.txt');

//Memo: TMemo, Standard paletta.
//Többsoros szövegszerkeztő. A tartalmat 1 indexel kezdődő Strig-ekben
//tárolja, mely a tulajdonságok között a Lines sorban található.
//Tartalmát szerkesztési időben is feltölthetjük. Ha az ablak a sorok
//megjelenítésére nem elég nagy akkor a sorvége jel mellett a szövegeket
//a Space helyeken tördeli. Ha nem szeretnénk csak a sorvégek szerinti
//tördelést, illetve látni szeretnénk, hogy a szöveg több sorból áll
//mint amennyi látható belőle, akkor a ScrollBars tulajdonságban
//beállíthatjuk, hogy mely scrollozó sávokat akarunk megjeleníteni.
//A WordWrap tulajdonság állításával a vízszintes tördelés letiltható,
//alapértelmezésben engedélyezett (True). A Memo futási időben is feltölthető.
//Ezt megtehetjük kódszerkesztőben felajánlott Lines.LoadFromFile()
//segítségével, ahol paraméterében meg kell adni a szöveges lemezes állomány
//teljes nevét. Ennek hatására az elem Create-je a beolvasást végrehajtja.
//A másik lehetőség, hogy billentyűzetről viszünk be karaktereket,
//vagy javítjuk a tartalmat. Ekkor a Form zárásakor, vagy egyéb parancs
//hatására a tartalmat ki kell menteni, szintén a kódszerkesztőben
//felajánlott Lines.SaveToFile() segítségével, ahol paraméterként meg kell
//adni a szöveges lemezes állomány teljes nevét. Ha azt szeretnénk,
//hogy a Memo mező csak olvasható legyen, akkor a ReadOnly Tulajdonságát
//állítsuk True-ra.

end;

procedure TfmVCL.btVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'Button.txt');

//Button: TButton, Standard paletta.
//Parancsgomb. Felíratát a Caption tulajdonság tartalmazza,
//mely szerkesztési és futási időben is átírható. A Default tulajdonság
//True értékre való állításával elérhetjük, hogy a billentyűzetről érkező,
//egyéb objektummal le nem kezelt üzenetet ez az elem kapja meg.
//Praktikusan: Enter hatása olyan, mintha az egérrel a parancsgombra
//kattintottunk volna, és ezzel kiváltottuk a hozzá rendelt eseményt,
//például egy alkalmazás bezárását. A ModalResult tulajdonsággal a
//fókuszba került parancsgombhoz előre definiált parancsokat rendelhetünk.
//A Default=True parancsgomb keretben jelenik meg a Form-on, de ha egyéb
//VCL elemre kattintunk kikerül a fókuszból, elveszíti Default tulajdonságát.

end;

procedure TfmVCL.cbVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'CheckBox.txt');

//CheckBox: TCheckBox, Standard paletta.
//Jelölőnégyzet. Kétállapotú, vagy be van jelölve, vagy nincs.
//Ezt a Checked tulajdonságban találjuk, mely szerkesztési és futási
//időben is változtatható, futási időben lekérdezhető. A jelölőnégyzet
//programbeli funkciójára a Caption tulajdonság szövege utal.
//Ezt a szöveget a WordWrap tulajdonság True-ra való állításával
//többsorossá tehetjük. A State tulajdonság segítségével lényegében
//három állapotúvá változtathatjuk, ugyanis a bejelölt állapot szürkítését
//a cbGrayed paraméter biztosítja. A jelölőnégyzeten való kattintással
//a cbGrayed állapot egyszerűen nem hozható létre, de természetesen
//egyéb esemény, vagy a kattintás esemény feltételessé tételével
//ezt a beállítást is elérhetjük.

end;

procedure TfmVCL.rbVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'RadioButton.txt');

//RadioButton: TRadioButton, Standard paletta.
//Választógomb. Két állapotú gomb, ki- és bekapcsolt állapota van.
//Programbeli szerepét a Caption tulajdonsággal írhatjuk le, mely szöveg
//a WordWrap tulajdonság True-ra állításával többsorossá tehető.
//A választógomb bekapcsolt állapotát a Checked tulajdonság tartalmazza,
//melyet szerkesztési és futási időben is beállíthatunk, egérrel való
//kattintással válthatunk. Általában több választógomb együttműködése
//kivánatos, melyet RadioGroup-ban helyezünk el, így a gombok közül
//egyik sem (-1), vagy legfeljebb egy lehet kiválasztva.

end;

procedure TfmVCL.ldVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'ListBox.txt');

//ListBox: TListBox, Standard paletta.
//Stringlisták megjelenítésére szolgál. A Stringeket egy 0 indexel kezdődő
//tömbben tárolja (Items). A kiválasztott elem az ItemIndex-ű elemben van.
//Ha nincs kiválasztva elem, akkor az ItemIndex -1. A lista oszlopszám
// szerint megjelenését a Columns tulajdonság tartalmazza. A megjelenítő
//ablakot és a megjelenített elemeket, illetve oszlopok számát össze kell
//hangolni. Ha ezt nem tesszük, akkor vizszintes ScrollBar jelenik meg.
//Ha a lista függőlegesen nem fér a megjelítő ablakba, akkor is ScollBar
//jelenik meg, melynek szélességével számolni kell. A listának fontos
//tulajtonsága a Sorted, azaz a rendezettség (true: rendezett). Ha rendezetté
//tettük, akkor az újabb elemeket már az Add metódus sorrend szerint helyezi
//be, ha futási időben a rendezettségét visszavontuk, akkor az újabb elemek
//hozzáadása a lista végére történik. Egy elem létezését IndexOf<>-1 reláció
//értéke adja vissza.

end;

procedure TfmVCL.clVCLCloseClick(Sender: TObject);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'ComboBoxC.txt');

//ComboBox: TComboBox Standard paletta.
//Kombinált lista. Zárt, elemeit nem változtathatod a beviteli
//mezője segítségével. Az elemeket String tömbben tárolja. Tulajdonságai
//a listadobozzal egyébként megegyeznek. Ha egy billentyűt megnyomunk,
//akkor a neki megfelelő első karakterű elemre ugrik.

end;

procedure TfmVCL.clVCLOpenClick(Sender: TObject);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'ComboBoxO.txt');

//ComboBox: TComboBox, Standard paletta.
//Kombinált lista. Beviteli mezőjébe beírt szöveget (Enter megnyomására)
//a lista végéhez adja, rendezett esetén a helyére beszúrja.
//Tulajdonságai a listadobozzal megegyeznek. Az Enter kezelését az
//Object Inspector Events oszlopának OnKeyPress sora segítségével
//be kell írni a kódlistába.

end;

procedure TfmVCL.gbVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'GroupBox.txt');

//GroupBox: TGroupBox, Standard paletta.
//VCL elemek tárolására szolgáló container. Az elemek csak a téglalap
//alakú területen belül látszanak.

end;

procedure TfmVCL.rgVCLClick(Sender: TObject);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'RadioGroup.txt');

//RadioGroup: TRadioGroup, Standard paletta.
//Több választógomb együttműködését biztosítja. A caption tulajdonságában
//a programbeli szerepét írhatjuk le. A gombok Items-ekben találhatók,
//melyet nevükkel adhatunk meg az Items tulajdonságban. Ha egyik sincs
//kiválasztva, akkor az ItemIndex értéke -1, egyébként a kiválaszott indexe.
//Kiválasztáskor csak egyetlen választógomb lesz bekapcsolva, tehát egymást
//kizáró értékek, események megjelenítésére, beállítására alkalmas.
//Megjelenését az objetum területe jelentősen befolyásolja. Az elrendezésben
//segíthet, ha több oszloposra állítjuk a Columns tulajdonság segítségével.

end;

procedure TfmVCL.pnVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'Panel.txt');

//Panel: TPanel, Standard paletta.
//VCL elemek tárolására szolgáló container. Az elemek csak a téglalap alakú
//területen belül látszanak. Gyakran a futási időben generált vizuális
//elemek tárolására használjuk.

end;

procedure TfmVCL.bbVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'BitBtn.txt');

//BitBtn: TBitBtn, Additional paletta.
//Bitképes parancsgomb. Egyébként a tulajdonságai a Button tulajdonságaival
//megegyeznek.

end;

procedure TfmVCL.meVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'MaskEdit.txt');

//MaskEdit: TMaskEdit, Additional paletta.
//Egysoros szerkeszthető beviteli mező. Ha az Object Inspektor Properties
//oszlopa, PasswordChar mezejében található default értéket (#0) például
//"*"-ra cseréljük, akkor a bevitt karakterek nem látszanak, azaz egy
//PassWord bevitelére alkalmas szerkesztőt kapunk.

end;

procedure TfmVCL.sgVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'StringGrid.txt');

//StringGrid: TStringGrid, Additional paletta.
//Szövegek táblázatos megjelenítsére alkalmas. A nulladik sora és oszlopa
//fejléc illetve "oldalléc" szerepet tölt be. Elemei olvashatók és írhatók,
//azaz valódi tárolásra alkalmas.

end;

procedure TfmVCL.dgVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'DrawGrid.txt');

//DrawGrid: TDrawGrid, Additional paletta.
//A StringGrid-hez hasonló szerkezetű, grafikus elemek megjelenenítésére
//alkalmas elem. Nem igazi tároló, csak a képernyőn való rendezett
//megjelenítést szolgálja.

end;

procedure TfmVCL.imVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'Image.txt');

//Image: TImage, Additional paletta.
//.BMP kiterjesztésű képek megjelenítésére szolgál.

end;

procedure TfmVCL.spVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'Shape.txt');

//Shape: TShape, Additional paletta.
//Alak, körvonal. Egyszerű geometriai alakzatok megjelenítésére szolgál.
//Az Object Inspector Properties oszlopa Shape sorában választhatunk a
//különböző alakzatok közül.

end;

procedure TfmVCL.cdVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'CheckListBox.txt');

//CheckListBox: TCheckListBox:, Additional paletta.
//Több, logikailag összetartozó CheckBox megjelenítésére alkalmas. A címkéket
//Items-ekben tárolja. Az egyes tételek kiválásztottságát a
//Checked[0..Items.Count-1] logikai tömb tartalmazza. A tétel kijelölése
//még nem jelenti a kiválasztás, ehhez a tétel neve előtti jelölőnézetre kell
//kattintani.

end;

procedure TfmVCL.leVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'LabeledEdit.txt');

//LabeledEdit: TLabeledEdit, Additional paletta.
//Címkés beviteli mező. Lényes tulajdonságai az Edit tulajdonságaival
//megegyeznek.

end;

procedure TfmVCL.coVCLChange(Sender: TObject);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'ColorBox.txt');

//ColorBox: TColorBox, Additional paletta.
//Választó listadobozban, névvel és szímintával megjelenő színválasztást
//tesz lehetővé. Az alapértelmezett szint a DefaultColorColor tulajdonság,
//a kiválasztott színt a Selected tulajdonság tartalmazza, melynek típusa:
//TColor.

end;

procedure TfmVCL.tcVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'TabControl.txt');

//TabControl: TTabControl, Win32 paletta.
//Fülekkel rendelkező, többlapos megjelenítő elem. A TabIndex tartománya:
//0..Tabs.Count-1. Az aktuális TabIndex szerkesztési és futási időben is
//beállítható, vagy a füleken kattintva aktualizálódik.
//A fülek felírata a Tabs tulajdonságban beállítható szerkesztési időben,
//a String-ek beírásával a lapok létrejönnek. Ha egyébként a megjelenést
//külön nem szabályozzuk, akkor a szerkesztési időben a Control-ra helyezett
//VCL elem minden lapon megjelenik. Értelemszerűen a lapok váltogatásával
//a megjelenő elemet célszerű módosítani.

end;

procedure TfmVCL.pcVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'PageControl.txt');

//PageControl: TPageControl, Win32 paletta.
//A TabConrol-hoz hasonló megjelenítő elem. Lényeges különbség: egymástól
//egyébként független lapokból áll. Szerkesztési időben az ActivePage
//tulajdonság mutatja a kiválasztott lap nevét. A lapok neve TabSheet,
//vagy röviden: ts+index (az index 1-el kezdődik). Minden lapra külön-külön
//helyezhetünk VCL elemeket. A lapokat tervezési időben úgy hozhatjuk létre,
//hogy a Form-ra helyezett PageControl-on egér jobb fülével kattintunk, és a
//megjelenő helyi menüből New Page-t válaszjuk. A TabSheet Caption
//tulajdonságával adhatunk nevet a lapoknak. A kiválasztott lapot Delete
//billentyűvel törölhetjük. Ha a füleken kattintunk, akkor a teljes
//PageControl tulajdonságát, ha a lapok területén kattintunk, akkor a felül
//lévő lap tulajdonságát látjuk, szerkeszthetjük.

end;

procedure TfmVCL.tbVCLChange(Sender: TObject);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'TrackBar.txt');

//TrackBar: TTrackBar, Win32 paletta.
//Értékbeállításra alkalmas csúszka. Az értékhatárokat a Min és Max
//tulajdonság tartalmazza. Az orientációját a Orientation tulajdonsággal
//adhatjuk meg, mely lehet trHorizontal és trVertical. A csúszka állapotát
//a Position tartalmazza. A érték jelölésének sűrűségét a Frequency
//segítségével adhatjuk meg. A SelStart és SelEnd tulajdonság segítségével
//kiválasztó csíkot jeleníthetünk meg a TrackBar belsejében, a csúszka
//alatt. Futási időben ezeket változtatva, folyamatok létét
//érzékeltethetjük vele.

end;

procedure TfmVCL.pbVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'ProgressBar.txt');

//ProgressBar: TprogressBar, Win32 paletta.
//Folyamatjelző, a TrakBar-hoz nagyon hasonló tulajdonságokkal. A Min, Max
//é Step tulajdonságokkal a folyamat és követése (megjelenítése)
//összehangolandó.

end;

procedure TfmVCL.udVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'UpDown.txt');

//UpDown: TUpDown, Win32 paletta.
//Le-fel számláló elem. A számolás megjelenítésére használhatunk sokféle
//VCL elemet. Azt, hogy melyiket kapcsoljuk hozzá, az Associate
//tulajdonságban választhatjuk ki (a már létezők közül, futási időben
//értékadással rendelhetjük össze). Az Increment állítja a léptéket egy
//kattintásnál, míg a Min és Max tulajdonság tartalmazza a határokat.
//Ha a VCL input fogadására képes (Edit), akkor az aktuális érték
//futási időben, billentyűzetről bevihető. Ha nem fogad inputot, akkor
//aktuális értéket egyéb módon beállíthatju.

end;

procedure TfmVCL.seVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'SpinEdit.txt');

//SpinEdit: TSpinEdit, Samples paletta.
//Az UpDown képességeivel szinte teljesen megegyező elem, azzal a megkötéssel,
//hogy a kapcsolt megjelenítője egy Edit mező.

end;

procedure TfmVCL.cgVCLMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'ColorGrid.txt');

//ColorGrid: TColorGrid, Samples paletta.
//16 színből történő választást lehetővé tevő elem. A szinek kis téglalapokban
//jelenik meg. Az elrendezésük a GridOrdering tulajdonsággal adható meg.
//Lehetőségek: 16x1, 8x2, 4x4, 2x8, 1x16. A kiválasztott szinek a
//BackGrounIndex illetve ForeGroundIndex tulajdonságból olvashatók ki.

end;

procedure TfmVCL.caVCLChange(Sender: TObject);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'Calendar.txt');

//Calendar: TCalendar, Sample paletta.
//Naptár. Az évet a Year tulajdonsággal, az aktuális hónapot a
//UseCurrentDate True-ra állításával adhatjuk meg. A StartOfWeek segítségével
//az első oszlopban megjelenő napokat állíthatjuk, 0: Vasárnap, 6: Szombat.
//Az, hogy ma hanyadika van, a Day mező tartalmazza.

end;

procedure TfmVCL.mcVCLClick(Sender: TObject);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'MonthCalendar.txt');

//MonthCalendar: TMonthCalendar, Win32 paletta.
//Hónapos naptár. Beállítható az aktuális dátum, és ez után az a hónap jelenik
//meg, amely ezt tartalmazza. Erre szolgál a Date mező. Beállítható, hogy
//a megjelenésben az első oszlop a hét melyik napját tartalmazza. Ezt a
//FirtDayOfWeek segítségével tehetjük meg. A naptár lapozható a két vezérlő
//nyomógombbal, de a MinDate és MaxDate tulajdonságokkal az intervallum is
//beállítható. A időbeállítást már szerkesztési időben is ellenőrzi.
//Futási időben a mai dátum be van jelölve. Kattintással a Date tulajdonság
//beállítódik az aktuális napra, mely TDate típusú.

end;

procedure TfmVCL.dtVCLChange(Sender: TObject);
begin
With Mouse.CursorPos Do MemoView(X,Y,200,150,'DateTimePicker.txt');

//DataTimePicker: TDateTimePicker, Win32 paletta.
//Gyakorlatilag a MonthCalendar helytakarékos megoldása. Alaphelyzetben
//csak az aktuális dátum látható egy beviteli mezőben. A dátum
//dátumszakaszonkét beírható. Lenyíló ComboBox-hoz hasonlóan a teljes hónap
//megjeleníthető. Egyéb tulajdonságaiban a MonthCalender-hez hasonló.

end;

end.