TIP: Přetáhni ikonu na hlavní panel pro připnutí webu
Ak koreluju hodnoty s indexami, mozes odkazovat priamo na Index selectu, no pre istotu priklad uvediem podla hodnoty (zobrazenia) v combe. Na ComboBox udalost OnChange naprogramuj nieco take:
var
Subor: String;
begin
Subor := StrToIntDef(ComboBox.Items[ComboBox.SelectedItem], 0) + '.txt';
if FileExists(Subor) then
Memo1.Lines.LoadFromFile(Subor);
end;
No, grafike sa mi darilo celkom dobre vyhybat, takze neviem, ale ako som sa pozeral na implementaciu ScanLine, skor by som to vedel pouzit na ine veci, ale to je jedno. ScanLine vracia smernik na pole pixelov, tym padom, by si sa asi cyklu nevyhol - no mozno by to bolo rychlejsie. ScanLine je definovane na TBitmap, takze to budes musiet asi poriesit cez TBrush z Canvasu.
Mne to chodi - pri edite mam speedbutton, ked sa nan klikne zvoli sa subor. Dalsie tlacidlo savuje do INI suboru...
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Buttons;
type
TForm1 = class(TForm)
EditCesta: TEdit;
SpeedButtonVybratAdresar: TSpeedButton;
BitBtnUlozitDoINI: TBitBtn;
procedure SpeedButtonVybratAdresarClick(Sender: TObject);
procedure BitBtnUlozitDoINIClick(Sender: TObject);
private
function DajKonfigCestu: String;
procedure NastavKonfigCestu(const Hodnota: String);
public
property KonfigCesta: String read DajKonfigCestu write NastavKonfigCestu;
end; // TForm1
var
Form1: TForm1;
implementation
uses
IniFiles;
{$R *.dfm}
// *****************************************************************************
procedure TForm1.SpeedButtonVybratAdresarClick(Sender: TObject);
begin
with TOpenDialog.Create(nil) do
try // FINALLY
if Execute then
KonfigCesta := FileName;
finally
Free;
end; // FINALLY
end;
// *****************************************************************************
procedure TForm1.BitBtnUlozitDoINIClick(Sender: TObject);
begin
with TMemIniFile.Create('C:\A.INI') do
try // FINALLY
WriteString('PATHS', 'Template', KonfigCesta);
UpdateFile;
finally
Free;
end; // FINALLY
end;
// *****************************************************************************
// Vratime iba tie subory, ktore existuju
function TForm1.DajKonfigCestu: String;
begin
if FileExists(EditCesta.Text) then
Result := EditCesta.Text
else
Result := '';
// Pripadny log
end;
// *****************************************************************************
procedure TForm1.NastavKonfigCestu(const Hodnota: String);
begin
EditCesta.Text := Hodnota;
end;
end.
Aku vynimku hadze? Skusal si to zkroknut, co za text je v edite pred flushom do suboru?
To chces databazu drzat v objektoch?
To co su za clanky? Potrebujes proste riesit dynamicke zobrazovanie formularovych objektov podla kliknutia na TMenuItem? Ak ano, jednym z jednoduchych rieseni by bola napr. MDI aplikacia...
Naimportuj TLB SpeachLib_TLB a potom mozes pristupovat aj cez Interface, napr. (ale nie je to ziadna slava :)
uses
..., SpeachLib_TLB;
...
FSpeechVoice: ISpeechVoice;
...
FSpeechVoice := CoSpVoice.Create;
try // FINALLY
if (CLSIDFromProgID('SAPI.SpVoice', CLSID) = S_OK) // je API integrovane???
FSpeechVoice.Speak(Text, {Flags}0);
finally
FSpeechVoice := nil; // i tak by sa uvolnil (je to Interface)
end; // FINALLY
if (CLSIDFromProgID('SAPI.SpVoice', CLSID) = S_OK)
No,
V prvom rade by som urcite pouzil nejaku databazu. Tento projekt je trivialny, takze len dufam, ze uz ste sa stretli s DB systemami v skole (popripade ty sam doma). Odporucam napr. Firebird, sadnut a navrhnut datovy model. Zvysok je uz len prkotina.
Samozrejme, ze pedagog chce OOP - hoci by som vedel o tisic projektoch, kde sa da v OOP vyblaznit, tu s nim mozes len vybabrat. Najlepsie ukazat pracu s objektami je v odvozdovani formularov. Napr. si vytvoris TBaseDialog formular, ktory moze mat napr. staticku metodu Zobraz (public) a zopar dynamickych (kontrola pristupu). Na form umiestnis napr. Panel s alignom bottom, na nom dve tlacidla. Jedno ma akciu OK druhe zrusit (z TActionListu). Akcie odkazuju na dynamicku metodu "DoOK" a "DoCancel" (protected). V tele OK je napr. odkaz na abstraktnu triedu Kontroluj, ktoru si v konkretnych formularoch overridnes a obsah zadas podla potreby.
Potom by si mohol vytvorit v kazdom forme parametrovy system, ktory by sa ukladal do DB (pamatanie posledneho zvoleneho adresara, chcekov v konfiguracii apod.). Existovala by teda napr. jedna trieda TParameterAbs, ktory by mal odprogramovane zakladne veci ako ukladanie do db, nacitanie (najlepsie dynamicky z TypInfo published property). Kazdy form by mohol potom vytvarat "vlastnu" triedu TParameterDialogNastavenia. V TBaseDialogu by si mal odprogramovanu pracu s TParameterAbs, no property by obsahovala abstraktny getter. Ten by sice vracial TParameterAbs, ale dialog by vytvaral Result := TParameterDialogNastavenia.Create; V dialogu by si samozrejme musel pristupovat ku datam tak, zeby si tu property precastoval na zvoleny typ, o ktorom vies, ze vlastne existuje.
Je to len na tebe, moznosti je, ale ziadna slava :(
OK, takze mas ToolBar na nom tlacidla. Kazde tlacidlo ma priradenu akciu v action liste - je to lepsie ako definovat priamo na tlacidle, pretoze pri zmene komponentu je praktickejsie potom setovat existujuce akcie - resp. ich volat. Takze kazde tlacidlo ma vlastnu akciu - ta ma definovany ImageIndex, caption, execute apod.
Potom staci prejst vsetky akcie tlacidiel a disablovat ich. Na tlacidlo naviazeme tuto funkcnost...
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ImgList, ActnList, ComCtrls, ToolWin, StdCtrls;
type
TForm1 = class(TForm)
ToolBar1: TToolBar;
ToolButton1: TToolButton;
ToolButton2: TToolButton;
ToolButton3: TToolButton;
ToolButton4: TToolButton;
ActionList1: TActionList;
Action1: TAction;
Action2: TAction;
Action3: TAction;
Action4: TAction;
ImageList1: TImageList;
Button1: TButton;
procedure Action1Execute(Sender: TObject);
procedure Action2Execute(Sender: TObject);
procedure Action3Execute(Sender: TObject);
procedure Action4Execute(Sender: TObject);
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.Action1Execute(Sender: TObject);
begin
//
end;
procedure TForm1.Action2Execute(Sender: TObject);
begin
//
end;
procedure TForm1.Action3Execute(Sender: TObject);
begin
//
end;
procedure TForm1.Action4Execute(Sender: TObject);
begin
//
end;
procedure TForm1.Button1Click(Sender: TObject);
var
Index: Integer;
begin
for Index := 0 to Pred(ToolBar1.ButtonCount) do
TAction(ToolBar1.Buttons[Index].Action).Enabled := False;
end;
end.
Hm, chcelo by to zistit, ako je na tom Oracle s full-textovym vyhladavanim - tym by sa dali odfiltrovat dokumenty v TXT. No na HTML by si uz potreboval text parsovat, pretoze existuju rozne tagy, ktore urcite Oracle nezoberie do uvahy ( ). Analogicky problem nastane aj pri formatoch DOC a RTF. Ak sa napr. zmeni farba pismenka v strede slova, slovo uz "nedrzi" pevny format a moze byt podobne obsadene specialnymi riadiacimi znakmi. Toto uz musis osetrit sam.
Pochbujem, ze sa bude dat napisat storovana procedura - asi budes musiet kazdy subor z DB nacitat, spracovat podla formatu a v nom vyhladavat...
Mas Memo a jedno tlacidlo. Kliknutim na tlacidlo sa vypise pole. Pole sa vytvara pri starte, kde sa aj naplni (pocet aj cisla su ako konstanty). V inicializacii zavolame randomize - zapnutie generatora nahodnych cisel.
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
// ---------------------------------------------------------------------------
TForm1 = class(TForm)
Button1: TButton;
Memo1: TMemo;
procedure Button1Click(Sender: TObject);
private
FPole: TStringList;
protected
procedure VytvorPole;
class procedure DoplniPole(Pole: TStringList; const Pocet: Integer);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
end; // TForm1
var
Form1: TForm1;
implementation
const
// ---------------------------------------------------------------------------
MaxNahodneCislo = 1000;
PocetCisel = 20;
{$R *.dfm}
// *****************************************************************************
// Vypiseme pole kliknutim na tlacidlo
procedure TForm1.Button1Click(Sender: TObject);
var
Index: Integer;
begin
for Index := 0 to Pred(FPole.Count) do
Memo1.Lines.Add(FPole[Index]);
end;
// *****************************************************************************
procedure TForm1.VytvorPole;
begin
FPole := TStringList.Create;
end;
// *****************************************************************************
class procedure TForm1.DoplniPole(Pole: TStringList; const Pocet: Integer);
var
Index: Integer;
begin
if Assigned(Pole) then
begin
for Index := 1 to Pocet do
Pole.Add(IntToStr(Random(MaxNahodneCislo)));
end; // IF
end;
// *****************************************************************************
constructor TForm1.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
VytvorPole;
DoplniPole(FPole, PocetCisel); // Naplnime pole s nejakymi cislami
end;
// *****************************************************************************
destructor TForm1.Destroy;
begin
FreeAndNil(FPole);
inherited Destroy;
end;
// *****************************************************************************
initialization
Randomize;
end.
A co konkretne s Indy chces??? To je pomerne rozsiahla kniznica fcii pre pracu so sietou a otazka typu:
"Vie niekto nakonfigurovat operacny system? Prosim poradte, vdaka." ;)
Hm, už to vyzerá lepšie :), kód sa zmenšil a je prehliadnejší. Ešte sa nauč lepšie pomenúvať premenné. Potom nemusíš napr. komentovať a je to lepšie čitateľné!
SUC a POS sú fcie ekvivalentné so zápisom X + 1 a X - 1. Nič extra to nerobí. Používaj ako chceš, ja som si zvykol používať PRED napr. pri prechádzaní cyklov po "COUNT-1" a odvtedy to používam všade :)
Ináč, ešte jeden "tip", existuje fcia COPY, ktorá ti podreťazec od Indexu po počet znakov a teda nemusíš cyklom vyskladávať nový reťazec:
var
Index: Integer;
Vystup: String;
...
Index := Succ(Pos('(', Vystup)); // Zistime, kde sa nachadza zatvorka
ShowMessage(Copy(Vystup, Index, Pos(')', Vystup) - Index));
Vstup := Uppercase(Vstup); // Co ak sa pouziju male / velke pismena?
for Index := Length(Vstup) downto 1 do
begin
if (not (Vstup[Index] in ['(', ')', '[', ']', '{', '}', 'a'..KONSTANTA, 'D', 'I', 'E', '&'])) then
Delete(Vstup, Index, 1); // Odstranime kazdy znak, ktory ta nepatri
end; // FOR
Jasné, už viem čo to robí!!! Klobúk dole, že ti to ako tak chodí a vôbec, že si sa do toho dal!!! Ale :)
0. Som rád, že si to usporiadal :)
1. To zisťovanie, či sa nachádza XYZ zátvorka urob cez ten POS.
2. Snaž sa dodržiavať veľké a malé písmená, podľa toho, ako majú byť (ako sú fcie definované apod.). To docielíš jednoducho, že nebudeš písať celý reťazec, ale len zadáš napr. prvé tri písmená, stlačíš CTRL+Medzerník a máš zoznam vyhovujúcich možností. Ak vyberieš z neho, zmení sa ti aj písmo. Keď sa to naučíš používať, celkom šikovne sa dá písať kód.
3. Memo nemaš co FormCreate, ale v design-time móde komponenty. Vieš, čo nemusíš, nepchaj do kódu, aby to bolo prehliadnejšie.
4. Keď už vieme, čo má robiť odvzátvorkuj, tak využi tú fciu na prepísanie textu:
// *****************************************************************************
// Pøevede všechny závorky o stupeò níž, pokud je v øetìzci kulatá závorka, vrátí
// pùvodní øetìzec
function TForm1.Odzavorkuj(Retazec: String): String;
begin
Result := Retazec;
if Kulata(Retazec) then
Memo1.Lines.Add('Breakovano')
else
begin
// Nezistujeme, ci sa nachadza, tak ci tak by sa presiel aspon raz linearne
// vstupny retazec
Result := AnsiReplaceText(Retazec, '[', '(');
Result := AnsiReplaceText(Retazec, ']', ')');
Result := AnsiReplaceText(Retazec, '{', '[');
Result := AnsiReplaceText(Retazec, '}', ']');
Memo1.Lines.Add(Result);
end; // ELSE
end;
// *****************************************************************************
// jednoduše pøiøadí dané èíslici písmeno
function TForm1.CisTuPis(const Poradie: Byte): Char;
begin
// ---> Vratime podla ordinalneho cisla - existuje nieco ako zakladna ASCII
// tabulka, tak preco nevyuzit uz nieco, co existuje, ze? Poziciu znaku
// zistime napr. takto: ShowMessage(IntToStr(Ord('a'))); - vysledok je 97
// CHR zasa z cisla vrati znak, teda ShowMessage(Chr(97));
if Poradie in [1..15] then
Result := Chr(Poradie + Pred(97))
else
raise Exception.Create('Interna chyba: Neocakavam znak s index vacsim ako 15!'); // Osetrime extremy
end;
procedure TForm1.Button1Click(Sender: TObject);
var
Index: Integer;
begin
// 0. pridame nejake srandy
Memo1.Lines.Add('riadok 1');
Memo1.Lines.Add('riadok 2');
Memo1.Lines.Add('riadok POSLEDNY');
// 1. Pridanie na posledny riadok
if Memo1.Lines.Count > 0 then
begin
for Index := 1 to 20 do
Memo1.Lines[Pred(Memo1.Lines.Count)] := Memo1.Lines[Pred(Memo1.Lines.Count)] + IntToStr(Index);
end; // IF
// 2. Pridanie do riadku
for Index := 1 to 20 do
Memo1.Lines.Text := Memo1.Lines.Text + IntToStr(Index);
end;
Chlape, ak by som nemenil zamestnávateľa a holka mi nechľastala na kamkovici, asi by som nerobil tento altruistický krok, ale nedá sa mi neodpovedať :) Ten tvoj kód je hrozný bordel! Neber to osobne. Keď som začínal v profy oblasti, tiež som tým prešiel a to som vyhrával celoštátne súťaže - šéf sa usmial so slovami "humus".
Takže:
1. Netuším ako to má fungovať, stále mi to hádže výnimky.
2. Netuším čo to má robiť, preto nehodnotím tvoj kód podľa logických častí (ako si ho rozdelil na metódy), ale len podotnem ku každému niečo - týmto chcem, aby si sa niečomu naučil, keďže predpokladám, že s programovaním začínaš:
Dobré rady:
1. Píš komentáre, aj keby to malo byť posledné, čo si v živote napísal.
2. Keď bacáš komponenty na form, snaž sa im dať relevantný názov s prefixom ich triedy, teda napr. ButtonOK, LabelOtazka, SplitterGrid apod. Rovnako aj pomenuvaj premenne, napr. namiesto I pouzivaj Index, namiesto Pom: TFormField zadaj FormField: TFormFiel, takto bude jednoduchšie čítať kód aj pri rozsiahlejších kódoch.
3. Ak pracuješ s metódami, zoradzuj ich podľa toho, ako si ich definoval v triede (prehliadnejšie a môžeš rýchlo chodiť po kóde klávesami CTRL+SHIT+šípka hore / dole):
type
TMojaTrieda = class
private
procedure Jeden;
procedure Dva;
protected
function Kuko: Boolean;
end; // TMojaTrieda
procedure TMojaTrieda.Jeden;
...
procedure TMojaTrieda.Dva;
...
function TMojaTrieda.Kuko: Boolean;
...
function JePrvyZnakCislo(const Retazec: String): Boolean;
begin
Result := ((Length(Retazec) > 0) and (Retazec[1] in ['0'..'9'])); // Staci jeden riadok
{ NIE - i ked to nie je spatne
if (Length(Retazec) > 0) and (Retazec[1] in ['0'..'9']) then
Result := True
else
Result := False;
}
end;
{ TVOJE:
result:=false;
for I := 1 to length(t) do if t[i]='{' then result:=true;
}
{
// pr. 1: Ukoncit po najdeni prvej zatvorky
Result := (Length(T) = 0);
if (not Result) then
begin
for Index := 1 to Length(Retazec) do
begin
if Retazec[Index] = '{' then
begin
Result := True;
Exit; // Ukonci FOR
end; // IF
end; // FOR
end; // IF
}
// Relevantnejsie riesenie
Result := (Pos('{', Retazec) > 0);
// *****************************************************************************
function TFormMain.Odzavorkuj(const Retazec: String): String;
// ---------------------------------------------------------------------------
procedure NahradZatvorky(var Vystup: String; const SadaZatvoriek: String;
const ZaZatvorku: Char);
var
Index: Integer;
begin
if Length(SadaZatvoriek) > 0 then
begin
for Index := 1 to Length(SadaZatvoriek) do
Vystup := AnsiReplaceText(Vystup, SadaZatvoriek[Index], ZaZatvorku);
end; // IF
end;
// ---------------------------------------------------------------------------
const
LaveZatvorky = '[{</';
PraveZatvorky = ']}>\';
begin
Result := Retazec;
NahradZatvorky(Result, LaveZatvorky, '('); // Nahradime lave zatvorky
NahradZatvorky(Result, PraveZatvorky, ')'); // Nahradime lave zatvorky
Memo1.Lines.Add(Result);
end;
function TFormMain.NMocnina(const Zaklad: Integer; Exponent: Byte): Longint;
begin
if Exponent < 0 then
raise Exception.Create('Interná chyba: Záporný exponent!');
Result := 1;
if Exponent > 0 then
begin
while Exponent > 0 do
begin
Result := Result * Zaklad;
Dec(Exponent);
end; // WHILE
end; // IF
end;
Načítanie a výpis môže byť aj pomocou ObjectListu - ale najlepšie do nejakej SQL mem databázy (SQLite?).
Príklad načítania a spracovanie zoznamu pastujem. Nie je to však vhodné použiť na obrovitánske textové súbory. Pracuje to na princípe:
1. načítaj TXT
2. preskoč 3 riadky
3. aktuálny riadok rozdel na dve čísla, ktoré následne načítaj
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Contnrs;
resourcestring
// ---------------------------------------------------------------------------
sSuborNeexistuje = 'Subor "%s" neexistuje!';
sChybnyObsahSuboru = 'Súbor neobsahuje údaje!';
type
// ---------------------------------------------------------------------------
// --- TStruktura ------------------------------------------------------------
// ---------------------------------------------------------------------------
TStruktura = class
public
Energia: Double;
Zloziek: Integer;
end; // TStruktura
// ---------------------------------------------------------------------------
// --- TForm1 ----------------------------------------------------------------
// ---------------------------------------------------------------------------
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
FZoznam: TObjectList;
FFormatSettings: TFormatSettings;
protected
function NaplnZoznam(const NazovSuboru: String): Boolean;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
end; // TForm1
var
Form1: TForm1;
implementation
{$R *.dfm}
// *****************************************************************************
procedure TForm1.Button1Click(Sender: TObject);
var
Index: Integer;
begin
if NaplnZoznam('File1.txt') then
begin
ShowMessage('Nacitanie prebehlo uspesne, vypisujem obsah zoznamu:');
// Zobrazi zaznam po zazname
for Index := 0 to Pred(FZoznam.Count) do
begin
with TStruktura(FZoznam[Index]) do
ShowMessage(Format('%d. riadok: %0.3f = Energia; %d = Zloziek', [Succ(Index), Energia, Zloziek]));
end; // FOR
end; // IF
end;
// *****************************************************************************
function TForm1.NaplnZoznam(const NazovSuboru: String): Boolean;
const
SeparatorCisel = #32; // Medzera
var
ChybneRiadky, ObsahSuboru: TStringList;
Index: Integer;
Riadok, Cislo: String; // Optimalizacia
begin
Result := FileExists(NazovSuboru);
if (not Result) then
raise Exception.CreateResFmt(@sSuborNeexistuje, [NazovSuboru]);
// Samotne nacitanie do StringListu
FZoznam.Clear;
ChybneRiadky := TStringList.Create;
ObsahSuboru := TStringList.Create;
try // FINALLY
ObsahSuboru.LoadFromFile(NazovSuboru); // Nacitame kompatibilny textovy subor
Result := ObsahSuboru.Count > 3;
if (not Result) then
raise Exception.CreateRes(@sChybnyObsahSuboru);
FFormatSettings.DecimalSeparator := '.'; // Separator desatinnych cisel ma byt "bodka"
// Preskocime prve tri riadky a do vsetky riadky natlacime do struktury
for Index := 3 to Pred(ObsahSuboru.Count) do
begin
// Pridame riadok (vytvorime objekt, tento vratime smernik na tento objekt
// a pretypujeme ho na objekt o ktorom vieme, ze je)
with TStruktura(FZoznam[FZoznam.Add(TStruktura.Create)]) do
begin
Riadok := TrimLeft(ObsahSuboru[Index]); // Odrezeme prazdne znaky na zaciatku riadka
// Parsujeme hodnotu energie
Cislo := Copy(Riadok, 1, Pred(Pos(SeparatorCisel, Riadok))); // Prve cislo
if (not TryStrToFloat(Cislo, Energia, FFormatSettings)) then
begin
Energia := 0.0; // Ak sa nepodari rozparsovat prve cislo, hodi sa 0
ChybneRiadky.Add(Trim(ObsahSuboru[Index])); // Odpamatame chybny riadok
end; // IF
// Parsujeme hodnotu poctu zloziek
Cislo := Trim(Copy(Riadok, Pos(SeparatorCisel, Riadok), MaxInt));
if (not TryStrToInt(Cislo, Zloziek)) then
begin
Zloziek := 0; // Ak by sa nepodarilo rozparsovat druhe cslo, hodi sa 0
ChybneRiadky.Add(Trim(ObsahSuboru[Index])); // Odpamatame chybny riadok
end; // IF
end; // WITH
end; // FOR
// Spracujeme chybne riadky - napr. len vypiseme
Result := ChybneRiadky.Count = 0;
if (not Result) then
begin
ChybneRiadky.Delimiter := #13; // Nie je to relevantny EOLN, ale kaslat na to
raise Exception.Create(ChybneRiadky.DelimitedText);
end; // IF
finally
FreeAndNil(ObsahSuboru);
FreeAndNil(ChybneRiadky);
end; // FINALLY
end;
// *****************************************************************************
constructor TForm1.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FZoznam := TObjectList.Create;
// Nacitame nastavenie podla OS (jazykova mutacia apod.)
GetLocaleFormatSettings(LOCALE_SYSTEM_DEFAULT, FFormatSettings); // Systemove formaty
end;
// *****************************************************************************
destructor TForm1.Destroy;
begin
FreeAndNil(FZoznam);
inherited Destroy;
end;
end.
v run-time, ci design-time?
Ak by si kódil v CLX, tak myslím, že to už Borlanďáci dorobili. Ináč si musíš napísať vlastný komponent odvodený od TEditu, ktorý by sa mohol podobať na niečo také (aby som nevytváral komponent, tak som "hackol" pôvodný TEdit s novou vlastnosťou - nefuguje to však v design-time takto, takže si to prepíš na kompont):
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
const
// ---------------------------------------------------------------------------
DefaultStringAligment = taLeftJustify;
type
// ---------------------------------------------------------------------------
TEdit = class(StdCtrls.TEdit)
private
FAlignment: TAlignment;
function IsAlignmentStored: Boolean;
procedure SetAlignment(Value: TAlignment);
protected
procedure CreateParams(var Params: TCreateParams); override;
public
constructor Create(AOwner: TComponent); override;
published
property Alignment: TAlignment read FAlignment write SetAlignment stored IsAlignmentStored;
end; // TEdit
// ---------------------------------------------------------------------------
TForm1 = class(TForm)
Edit1: TEdit;
public
constructor Create(AOwner: TComponent); override;
end; // TForm1
var
Form1: TForm1;
implementation
{$R *.dfm}
// *****************************************************************************
function TEdit.IsAlignmentStored: Boolean;
begin
Result := (FAlignment <> DefaultStringAligment);
end;
// *****************************************************************************
procedure TEdit.SetAlignment(Value: TAlignment);
begin
if FAlignment <> Value then
begin
FAlignment := Value;
RecreateWnd;
end; // if
end;
// *****************************************************************************
procedure TEdit.CreateParams(var Params: TCreateParams);
const
Alignments: array[TAlignment] of Longword = (ES_LEFT, ES_RIGHT, ES_CENTER);
begin
inherited;
Params.Style := Params.Style or Alignments[FAlignment];
end;
// *****************************************************************************
constructor TEdit.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FAlignment := DefaultStringAligment;
end;
// *****************************************************************************
// *****************************************************************************
// *****************************************************************************
constructor TForm1.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
Edit1.Alignment := taRightJustify;
end;
end.
© 2003–2024 Programujte.com