Anonymní profil LiborBes – Programujte.com
 x   TIP: Přetáhni ikonu na hlavní panel pro připnutí webu

Anonymní profil LiborBes – Programujte.comAnonymní profil LiborBes – Programujte.com

 

Příspěvky odeslané z IP adresy 88.212.20.–

LiborBes
Delphi › Načtení obsahu souboru do pole
2. 2. 2008   #64761

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;

LiborBes
Delphi › Grafika v BD7, prosím o rady…
28. 1. 2008   #64340

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.

LiborBes
Delphi › Zaujímavý problém s INI súbo…
13. 1. 2008   #62155

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.

LiborBes
Delphi › Zaujímavý problém s INI súbo…
13. 1. 2008   #62154

Aku vynimku hadze? Skusal si to zkroknut, co za text je v edite pred flushom do suboru?

LiborBes
Delphi › poradit s projektom
13. 1. 2008   #62152

To chces databazu drzat v objektoch?

LiborBes
Delphi › Položky menu
12. 1. 2008   #61985

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...

LiborBes
Delphi › Hlasový vstup / výstup
12. 1. 2008   #61984

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


ak chces zistit, ci je API integrovana:



if (CLSIDFromProgID('SAPI.SpVoice', CLSID) = S_OK)

LiborBes
Delphi › poradit s projektom
12. 1. 2008   #61983

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 :(

LiborBes
Delphi › toolbar
6. 1. 2008   #61286

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.

LiborBes
Delphi › Vyhladávanie v txt, rtf, doc…
6. 1. 2008   #61285

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...

LiborBes
Delphi › Pole
6. 1. 2008   #61283

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.

Labut
Delphi › Program co spustí webovou st…
3. 12. 2007   #57239

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." ;)

LiborBes
Delphi › Kritika programu - výroky
2. 12. 2007   #57025

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));


Tiež by si mal pred spracovaním reťazec naformátovať. Zabúdaš na také veci, ako sú napr. prázdne znaky, nekorektné znaky apod. Ak chceš v reťazci ponechať len konkrétne znaky, vstup najprv preformatuj cez niečo také:



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


Čo sa týka dodržiavania veľkých a malých písmen, kód je prehliadnejší a takéto detailky hovoria o programátorovi, že už nemá problém so samotným kódením, ide mu o "krásu" :) Svojim spôsobom je programátor umelec...

A prečo pomáham? Keby mne niekto v prváku takto pomohol, bol by som úplne inde už v 18tke. Lenže okolo mňa nikto nekódil :( Síce som povyhrával nejaké súťaže aj na úrovni celoštátnych kôl, ale to programovanie bolo skôr "akademické". Keď sa dostaneš do nejakej firmy, potom uvidíš také zázraky, o ktorých sa nesníva ani cvičiacim na VŠ!

BTW: Odporúčam naštudovať OOP (zmení tvoj pohľad na programovanie) a prejsť si knihy ako Algoritmy od pána Wroblevskeho (Computer Press). Keď sa naučíš myslieť "optimálne" a anlyticky, spoznáš pojmy teória grafov apod. (čo sa dá samoštúdiom do roka nadupať), tak odporúčam súťaže - popri nich sa veľa naučíš a s týmito vedomosťami položíš aj porodcov (väčšinou hovno rozumejú programovaniu). Mňa nikto neodkázal na žiadne "grafy" a tak som somár tri mesiace hľadal optimálne riešenie na nájdenie najkratšej cesty v bludisku. Keď som sám vytvoril algoritmus (dosť humus), tak som si myslel, že by som mal dostať nobelovku. Po súťaži mi prišlo vyhodnotenie, len polka bodov za príklad - hoci riešenie bolo. Prečo???? Bol som naštavatý, a odpoveď bola: "Lebo prehľadávanie grafov do hĺbky sa dá napísať aj lepším spôsobom". Vtedy som prvý krát počul pojem graf (matematický) a zistil som, že na nič svetoborné som neprišiel, len som vymyslel to, čo už existovalo. Ak by som o tom vedel, tri mesiace som mohol riešiť iné veci :(

Držím palce v ďalšej tvorbe.

LiborBes
Delphi › Kritika programu - výroky
1. 12. 2007   #56820

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;


5. Neviem kto ťa učí matiku, ale choď mu poriadne vynadať. Rôzne druhy zátvoriek sa nemajú používať na označovanie "stupňa vnorenia". Každý typ, má svoj význam (tak ako v Delphi). Mal by si rátať len s guľatými zátvorkami.

6. Využívaj konštanty. Napr. som presne nevedel, že horná definícia TArr s horným extrémom (ó) koreluje s CisTuPis. Ak zmeniš na jednom mieste, musíš pamätať, kde všade. Kód sa preto zvykne písať dosť obecne, ak by niekto do toho pozeral (či už z týmu, alebo ako Open-Source) a nevedel, ako to presne funguje, zmenena definície, aby sa aplikovala aj v kóde.

Ale tiež sa dá zistiť písmeno jednoduchšie cez ASCII poradie (tam ale samozrejme "A" nie je na prvom mieste, takže treba odratávať v tabuľke):



// *****************************************************************************
// 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;

LiborBes
Delphi › memo: riadky
27. 11. 2007   #56356



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;

LiborBes
Delphi › Kritika programu - výroky
27. 11. 2007   #56353

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;
...


4. Boolové fcie sa dajú písať aj elegantnejšie:



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;


5. Uvažuj keď kódiš! Skús rozmýšľat (netreba veľa rozumu a hneď poznať smernikovú aritmetiku, stačí logika) optimálne aj v cykloch, napr. tvoja haluz:



{ 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);


Prechádza sa celá dĺžka reťazca! Ak sa narazí na prvú zátvorku, výsledok fcie bude TRUE. Potom sa už nikde nemení na iný!!! Načo dôjsť do konca? A za ďalšie, hľadanie sub-reťazca je fcia známa už Turbo Pascalu (pr. 2)

6. Fcia odzátvrokuj je pekný bordel. Keďže si nedal komentár, dá sa len z kódu vyčítať čo robí:
- Prepíše všetky iné zátvorky za guľaté
- Zistí, či sa nachádzajú guľaté zátvorky ak nie vráti pôvodný reťazec.

Ak si to myslel takto, tak si mal najprv zistiť, či sa nachádzajú guľaté zátvorky a až potom, ak nie, odstráňovať tie druhé! Ak sa totiž v reťazci nenachádzajú, zbytočne sa odstránia, aj keď pre túto vetvu programu to nie je podstatné.

Ale i tak pochybujem, že tá fcia má robiť to, ako je napísaná... Skús naštudovať toto (fcia na prepísanie textu je z Delphi, nie je najrýchlejšia pri malých reťazcoch, ale skús si to s 1GB a budeš prekvapený :)



// *****************************************************************************
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;


7. V Delphi existuje fcia StrToBool, nemusíš ju písať.

8. Pri výpočte mocniny si nemyslel na všetky možnosti. Okrem toho, snaž sa aj argumenty prispôsobiť realite. Ak maš LONGINT^LONGINT, tak určite pri brutálnom čísle RESULT pretečie, preto sa to dá napísať aj napr. takto:



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;


9. Asi by som pokračoval, ale keďže ma volali na pivo, tak sa na to vybodnem :) Dúfam, že som ťa neodplašil - zapamätaj, kritika nie je zlá, len sa treba prekúsať svojim egom a ťažiť z nej. Mne to chvíľku trvalo, ale bola to tá najlepšia škola!

LiborBes
Delphi › Zapracovani txt souboru
24. 11. 2007   #56065

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.

LiborBes
Delphi › zameneni nazvu komponenty za…
21. 11. 2007   #55624

v run-time, ci design-time?

LiborBes
Delphi › Zarovnání doprava u komponen…
21. 11. 2007   #55618

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.

 

 

Hostujeme u Českého hostingu       ISSN 1801-1586       ⇡ Nahoru Webtea.cz logo © 20032021 Programujte.com
Zasadilo a pěstuje Webtea.cz, šéfredaktor Lukáš Churý