Delphi - Fragen!

Hi,
ich habe ein Problem. Wenn man in einem Delphiprogramm auf einen Button klickt, soll in ein Label etwas geschrieben werden.

Hier ein entsprechendes Abfragebeispiel:

Code:

---

if not (v1 = 10) then
 lbltext.Caption := text[v1];

---

Diese Abfrage soll jetzt solange wiederholt werden, bis v1 nicht 10 ist, dann soll etwas in das Label geschrieben werden. Ich habe dies so versucht, das Programm hing sich dann aber wegen dem Loop auf:

Code:

---

repeat until ok = 1;
  begin
  if not (v1 = 10) then
    lbltext.Caption := text[v1];
    ok := 1;
    break;
  end;

---

Der Zweck des Loops ist eben, dass man nicht solange auf den Button klicken muss, bis die Bedingung erfüllt ist, sondern dass solange weitergemacht wird, bis die Bedingung erfüllt ist. Danach wird der nächste Abfrageloop für ein anderes Label gestartet. Mit einem Button werden also mehrere Labels beschrieben.

Was muss ich machen, damit es klappt und sich das Programm nicht mehr aufhängt?

Danke im Vorraus!

Also wenn du die Überprüfung beim Button-Klick machst, ist es ja klar, dass sich das Programm aufhängt, wenn die Bedingung jedesmal wieder durchlaufen wird. Wieso machst du die Überprüfung nicht dann, wenn sich der Textbox-Inhalt ändert. Soweit ich weiß, gibt es ein solches Ereignis bei der Textbox. (Kann das jetzt aber nicht überprüfen.)

Ein Loop ist unbedingt erforderlich, da sonst alles nur einmal überprüft wird und ggf. nicht alle Felder ausgefüllt werden. Da ist es auch egal, wie ich die Schleife abfrage.

Zitat:

---

Zitat von PX

Ein Loop ist unbedingt erforderlich, da sonst alles nur einmal überprüft wird und ggf. nicht alle Felder ausgefüllt werden. Da ist es auch egal, wie ich die Schleife abfrage.

---

Ich sagte doch, mach die Abfrage (normale If-Abfrage, kein Loop) jedesmal, wenn sich der Textbox-Inhalt ändert. Dann brauchst du garkeinen Loop. Dann wird, wenn der Anwender sein Eingabe korrigiert, automatisch die Überprüfung gestartet.

Zitat:

---

Zitat von The_Best_Isaac

Also wenn du die Überprüfung beim Button-Klick machst, ist es ja klar, dass sich das Programm aufhängt, wenn die Bedingung jedesmal wieder durchlaufen wird. Wieso machst du die Überprüfung nicht dann, wenn sich der Textbox-Inhalt ändert. Soweit ich weiß, gibt es ein solches Ereignis bei der Textbox. (Kann das jetzt aber nicht überprüfen.)

---

Das ist kompliziert, immer wenn sich der Text ändert, eine Überprüfung zu machen, erfüllt nicht den Sinn. Der Benutzer gibt eh nichts ein, v1 ist ein Random-Integer... Loops sind definitiv die einzige Lösung, da bin ich mir sicher.

Zitat:

---

Zitat von PX

Das ist kompliziert, immer wenn sich der Text ändert, eine Überprüfung zu machen, erfüllt nicht den Sinn. Der Benutzer gibt eh nichts ein, v1 ist ein Random-Integer... Loops sind definitiv die einzige Lösung, da bin ich mir sicher.

---

Gut, wenn die Änderung von v1 nicht vom Benutzer gemacht wird, hast du recht. Aber wenn du nach Klick auf den Button ein Loop durchläufst, in dem die abzufragende Variable nicht geändert wird, hast du eine Endlosschleife, also ist es klar, dass sich das Programm aufhängt. Wenn der Wert von v1 zufällig bestimmt wird, musst du die Bedingung eben nach jeder Änderung abfragen. Und wird die Änderung des ZUfallswerts durch den Benutzer veranlasst? Also dann man z.B. auf einen Button "Zufallszahl generieren" oder so klickt?

Also, der Loop wird natürlich unterbrochen. Er wird solange gemacht, bis die Variable ok zu 1 wird (sie ist zunächst 0), tritt der Textänderungsfall ein, wird ja:

Code:

---

ok := 1

---

...der Loop unterbrochen! Die Zufallszahl(en) werden durch den Buttonklick veranlasst, das spielt aber keine Rolle.

Nur ein kleiner Einwurf...
Müsste da nicht das until ganz nach unten?

Code:

---

repeat
  if not (v1 = 10) then
    lbltext.Caption := text[v1];
  ok := 1;
  break;
until ok = 1;

---

Sonst wird doch die repeat-until-Schleife ohne Inhalt durchlaufen und die Bedingung kann sich gar nicht ändern. Oder denke ich grad falsch?
(Andererseits erscheint es so auch sinnlos, da man sich auch die Schleife sparen kann - selbst wenn ok vorher schon 1 ist, wird der Wert ja erst am Ende abgefragt, und wenn es nicht 1 ist, wird es in jedem Fall in der Schleife 1 gesetzt. Daher wird der Schleifeninhalt doch immer einmal aufgerufen, ganz egal, was geschieht... und dann ist doch die Schleife sinnlos. *Kopfschüttel* Irgendwie versteh ich das alles nicht. ^^)

Code:

---

repeat
  if v1 = 10 then
  sleep(1000);
until v1 <> 10;     
lbltext.Caption := text[v1];

---

So, ich hab das jetzt mal so umgebaut, wie ich dich verstanden habe... Die Schleife wird so lange wiederholt, bis v1 nicht mehr 10 ist. Dabei hab ich innendrin noch ein sleep, damit nicht die ganze Zeit lang diese Schleife durchgelaufen wird... Egal, kann man auch rauslassen. Jedenfalls - wenn dann v1 ungleich 10 wird, geht der Quelltext ganz normal danach weiter (wozu ein break?) und die Caption wird gesetzt. Aber bestimmt habe ich wirklich alles ganz falsch verstanden...

Sleeps kannte ich gar nicht, danke dafür.
Auch mit der repeat - until Schleife hast du gleube ich recht, aber trotzdem werden nicht alle Labels gefüllt! (erst nachdem man mehrmals geklickt hat) Wenn ich <> wähle, hängt es sich auch wieder auf.

Edit: Klappt! 10x getestet, funktioniert. Danke.

Edit2: ....... Da ja der Captionbefehl jetzt außerhalb des Loops steht, treten Fehler im Programm auf. Einfach in den Loop schreiben geht nicht. Was tun?

Was für Fehler treten denn auf? ^^

Nach dem Sleep bzw generell in JEDER laengeren Schleife sollte man Application.ProcessMessages; aufrufen, damit sich die GUI nicht aufhaengt, weil nur noch die Schleife und nicht mehr die Windows-Message-Loop abgearbeitet wird.

Der Fehler kann nicht dadran liegen, ob das label in oder ausserhalb der Schleife geaendert wird. Hast du dich vielleicht vertippt ?

Das Label wird doch nur aufgerufen, wenn die Bedingungen erfüllt sind.
Es ist: repeat - Bedingung(en) - then - until - Labeländerung. Stimmt das so? Beim Ausführen des Programms stelle ich dann aber fest, dass das Label auch geändert wird, wenn die Bedingungen nicht erfüllt sind! Habe ich evtl. begin und end vergessen oder was ist los?

Hm. Ich würde sagen, die Reihenfolge lautet doch eigentlich repeat-Codeblock-until-Bedingungen-Labeländerung. Und im Codeblock ist jetzt meinetwegen das sleep und noch Application.ProcessMessages, damit die Welt nicht untergeht, wenn man das Programm ausführt. *g*

Code:

---

repeat
 if not (v1 = v2) then
 until ok <> 1;
 Label1.Caption := zahl[v1];
 ok := 1;

---

Solche Blöcke gibt es jetzt mehrmals in meinem Projekt. Ich programmiere etwas, das viele verschiedene Zahlen ausgibt, mit einem einzigen Buttonklick, und alle Zahlen sollen eben verschieden sein, was nicht immer der Fall ist (im Moment jedenfalls). Als es klappte, hing es sich ja immer auf.

Edit: Habe noch eine Frage. Warum sehen Panels unter dem XP-Manifest Befehl (D7) immer so komisch aus? (Schrift nicht lesbar, nur Rand zu sehen) Was kann man da tun?

Ich glaube, du hast das Arbeitsprinzip von Windows-Applikationen nicht ganz verstanden.

Die Callback Funktionen, die ein Button aufruft, oder jedes andere GUI Element, sollten immer so kurz wie moeglich gehalten werden. Denn die ganze GUI ist idR blockiert, solange diese CallBack Funktion nicht verlassen wird.

Daher sind Repeat ... Until Schleifen, die unabhaengig von der konkreten eingabe auf etwas warten, ein ganz ganz boeses NoNo. Dafuer hat man andere Mechanismen zur Verfuegung. Die Call Back Funktion ist idR nur dazu da, bestimmte Flags und Variablen deines Programms zu aendern. Was diese dann bewirken, das steht in einer anderen Routine (oder sogar in einem anderen Thread) und nicht in der GUI.

Du musst dich von der Vorstellung des sequentiellen Programmablaufes trennen. Unter Windows ist alles Message-Orientiert.

Ich mache mal ein kleines Beispiel:

Mach ein neues Formular und erzeuge ein Label, einen Button und einen Timer (Ich denke, der steht im Panel Systemkomponenten). Zudem lege eine integer Variable namens Counter in deinem Form an. Dann mach einen Doppelklick auf den Button und schreibe folgende Funktion zum Abarbeiten in das OnClickEvent

Code:

---

Form1.Timer1.enable := not(Form1.Timer1.enable);

---

Dann mache einen Doppelklick auf das Timer Objekt und gibt im OnTimerEvent folgenden Code ein:

Code:

---

inc(Form1.Counter);
Form1.Label1.Caption := toString(Form1.Counter);
Form1.Label1.Update;

---

Dann starte das Programm. Wenn du nun auf den button klickst, sollte das Label anfangen, im Sekundenrakt die Natuerlichen Zahlen sukzessiv anzuzeigen. Wenn du ein weiteres Mal auf den Button klickst, wird das Zaehlen angehalten. Ein weiterer Klick setzt das zaehlen fort. usw.

Der ganze Post ist aus der Erinnerung geschrieben, und ich glaube, ich hab das letzte Mal mit Delphi intensiv vor 5 jahren gearbeitet. Daher keine Gewaehr auf die syntaktische Richtigkeit.

Damit kann ich wenig anfangen, da es erstens nicht funktioniert (enable und Counter werden nicht erkannt) und da ich zweitens etwas ganz anderes umsetzen möchte, was mit repeat...until locker möglich sein sollte.

Zitat:

---

und da ich zweitens etwas ganz anderes umsetzen möchte, was mit repeat...until locker möglich sein sollte.

---

Aber nicht in einer GUI-Umgebung. In einem Kommandozeilenprogramm wäre eine repeat-schleife sicher die richtige Idee, in einem GUI-Programm aber nicht.

Ich versuch es mal anschaulich zu erklären:
Wenn du eine GUI-Applikation schreibst verzahnst du dein Programm eng mit der Funktionsweise von Windows. Sprich, Windows überwacht für dich den gesamten Userinput, also Mausbewegungen, Mausklicks und Tastendrücke. Wenn Windows nun merkt "Der Benutzer hat die linke Maustaste gedrückt" guckt Windows welches offene Programm gerade den Fokus hat und benarichtigt dieses Programm über dieses Ereigniss, indem es eben dem Programm eine Message sendet.
Das Programm wiederrum empfängt diese Message, verarbeitet diese und wartet wiederrum auf neue Messages.

Das Problem bei deinem Programm und der Schleife ist, der Verarbeitungsprozess der Nachricht "Button wurde angeklickt" ist erst beendet wenn die aufgerufene Funktion zuende ist. Baust du dort nun eine Schleife ein, wird dieser Prozess erst beendet wenn die Schleife beendet ist. Solange dieser Prozess aber nicht beendet wird, wird dein Programm auf neue Nachrichten von Windows nicht reagieren, also auch nicht auf neuen Userinput. Wenn du eine solche Schleife benutzt musst du auch innerhalb der Schleife selber dafür sorgen, daß sie irgendwann verlassen wird. Alles andere ist eine Endlosschleife. Bei deinem Code bricht die Schleife nur ab wenn eine Variable eine bestimmte Bedingung erfüllt, nur da die Variable innerhalb der Schleife nicht verändert wird gibt es nur 2 Möglichkeiten:
- Die Schleife bricht sofort ab da die Variable die Bedingung erfüllt
- Die Schleife bricht nie ab, da die Variable die Bedingung nicht erfüllt und auch nicht geändert wird

Wenn du willst, daß etwas geändert wird sobald Bedingung X erfüllt ist, aber gleichzeitig den normalen Programmablauf nicht unterbrechen willst (da du noch auf Userinput reagieren willst) musst du dich eben da einhaken wo eine Funktion periodisch immer aufgerufen wird, ein Timer wie Ineluki es im Beispiel benutzt wäre da eine Lösung.

Nun, ich hatte letztendlich nur einen begin + end Rahmen vergessen, es hat sich geklärt. Falls es jemanden interessiert:

Code:

---

begin
 repeat
 ok := false;
 v1 := random(51) + 1;
 if not (v1 = v2)
 then
 begin
 lbltext.Caption := text[v1];
 ok := true;
 end;
 until ok;
 end;

---

Ich hätte vielleicht sagen sollen, dass ich Random-Integers verwende. Diese mussten natürlich jedesmal neu bestimm werden, daher kam das Aufhängen. Da ich begin und end (rot markiert) vergessen hatte, wurde ok := true (ok ist ein Boolean) nicht ausgeführt und es kam zu Fehlern. Habe es zum Glück endlich herausgefunden, das, was ich wollte war wohl zu schaffen. Habe die Schleife nochmal blau markiert. Danke nochmal an alle anderen.


EDIT:
Dann mal meine nächste Frage.^^
Es gibt ja den sleep - Befehl. Wenn ich mitten beim Ausführen des Programmierten eine Pause haben will, dann gehts weiter, wie kann ich das dann machen? Mit sleeps funktioniert es irgendwie nicht richtig.

Zitat:

---

Zitat von PX

Damit kann ich wenig anfangen, da es erstens nicht funktioniert (enable und Counter werden nicht erkannt) und da ich zweitens etwas ganz anderes umsetzen möchte, was mit repeat...until locker möglich sein sollte.

---

Es kann nicht sein, dass Couter nicht gefunden wird, denn das ist die Variable, die du in deinem TForm1 definieren solltest.

Ausserdem hat TTimer (zumindest zu meiner Zeit bis Delphi6) eine Property namens enable. Also hast du entweder den Timer nicht aufs Formular gesetzt, wie ich gesagt habe, oder sie haben was in TTimer geaendert, was ich aber nicht glaube.

Am Besten, du postest mal den gesamten Quelltext deiner Unit.

Die Property, die du meinst, heißt "enabled".
Counter muss man als Boolean definieren, oder was meinst du?

enable oder enabled ... wie gesagt, auf den Sinn kommt es an. Nach 5 Jahren verschwimmen langsam die Erinnerungen, ob da nun ein d am ende stand oder nicht ...

Und was Counter angeht:

Zitat:

---

Zitat von Ineluki

Zudem lege eine integer Variable namens Counter in deinem Form an.

---

Dran denken, die muss in deinem Form definiert werden, und nicht innerhalb des Counter-Events, damit der Wert zwischen zwei Methodenaufrufen erhalten bleibt.

Naja, das Problem habe ich ja schon gelöst.
Ich würde lieber mal wissen, wie man auf 5er runden kann, also 32 = 35 oder 99 = 100.

Zitat:

---

Zitat von PX

Ich würde lieber mal wissen, wie man auf 5er runden kann, also 32 = 35 oder 99 = 100.

---

Kenn mich zwar in Delphi nicht aus, das dürfte aber dennoch möglich sein:

Wenn <zahl> Modulo 5 gleich 0 ist:
Gib <zahl> zurück
Ansonsten:
Gib <zahl> + (<zahl> Modulo 5) zurück

Zitat:

---

Zitat von Brainstar

Wenn <zahl> Modulo 5 gleich 0 ist:
Gib <zahl> zurück
Ansonsten:
Gib <zahl> + (<zahl> Modulo 5) zurück

---

Oder gleich
Zahl = Zahl + (Zahl modulo 5)
Zumindest falls du wirklich immer aufrunden willst, PX.

modulo gibt es doch gar nicht. Ihr meint wohl mod oder so etwas in der Art...

mod ist die Kurzform für modulo ;)

Wie kann man ein Wort in seine Buchstaben zerlegen lassen / bzw. ist das überhaupt möglich?

Nun, du kannst auf die Einzelnen Buchstaben zugreifen, wie du auf ein Array zugreifst:

Code:

---

var
  S: String;
begin
  S := 'Hallo';
  if S[1] = 'H' then
  [...]
end;

---

Beachten solltest du die Länge des Strings (Length(S)), da es sonst Zugriffsverletzungen gibt. Außerdem fängt dieses String-Array bei 1 und nicht bei 0 an, was historische Gründe hat (in Turbo Pascal war das erste Byte die Länge des Strings, somit wahren Strings in TP maximal 255 Char lang, in Delphi ist es nur aus Kompatibilität noch so, Strings können beliebig lang sein).

Danke.
Meine neue Frage:
Wie kann ich von einem Editfeld die maximale Anzahl an eingebbaren Zeichen definieren und wie kann ich nur Zahlen / bzw. nur Buchstaben erlauben lassen?

Zitat:

---

Zitat von PX

Danke.
Meine neue Frage:
Wie kann ich von einem Editfeld die maximale Anzahl an eingebbaren Zeichen definieren und wie kann ich nur Zahlen / bzw. nur Buchstaben erlauben lassen?

---

Im OnKeyPress kannst du einfach das hier machen:

Code:

---

if not ((Key in ['a'..'z']) OR (Key in ['A'..'Z'])) then
  Key := #0;

---

bzw.

Code:

---

if not (Key in ['0'..'9']) then
  Key := #0;

---

Für Zahlen bieten sich aber auch SpinEdits (Registerkarte: Examples/Beispiele) an. Da kannst du dir mal Min und Max anschauen. Ansonsten ist die maximale Stringlänge bei Edits in MaxLength gespeichert, wer hätte es gedacht ;)

Passend dazu bräuchte ich jetzt aber noch einen Code/Befehl für Backspace, da es für den Nutzer sonst problematisch wird, wieder etwas aus dem Feld zu löschen; also Backspace und andere wichtige Tasten wie Space sollten irgendwie funktionieren.

Schau mal hier: http://dsdt.info/grundlagen/codes/vks.php

VK_BACK oder auch $08. VK_Back wird aber nur für KeyUP/KeyDown gehen.

Wie baue ich Objektunabhängige Prozeduren richtig ein?
Beispiel: Beim Klick auf Button X öffnet sich eine Nachricht, dann wird mehrmals hintereinander diese unabhängige Prozedur ausgeführt. Habe mich bereits auf anderen Seiten erkundigt, angeblich soll man die Prozedur über eine Variable einbauen, das ergab mir aber Fehler.

Zitat:

---

Zitat von PX

Wie baue ich Objektunabhängige Prozeduren richtig ein?
Beispiel: Beim Klick auf Button X öffnet sich eine Nachricht, dann wird mehrmals hintereinander diese unabhängige Prozedur ausgeführt. Habe mich bereits auf anderen Seiten erkundigt, angeblich soll man die Prozedur über eine Variable einbauen, das ergab mir aber Fehler.

---

Könntest du das näher erläutern? Was meinst du mit Objektunabhängig? Meinst du eine Procedure, die nicht zu einer Klasse gehört?

Ich meine eine Prozedur, die keinen (Sender: TObject) braucht, sondern dessen Befehle ausgeführt werden, wenn man den Namen der Prozedur innerhalb einer anderen Prozedur aufruft:

Procedure ABC;
begin
...
...
...
end;

Prozedure XYZ(Sender: TObject);
begin
...
ABC;
...
end;

Zitat:

---

Zitat von PX

Ich meine eine Prozedur, die keinen (Sender: TObject) braucht, sondern dessen Befehle ausgeführt werden, wenn man den Namen der Prozedur innerhalb einer anderen Prozedur aufruft:

Procedure ABC;
begin
...
...
...
end;

Prozedure XYZ(Sender: TObject);
begin
...
ABC;
...
end;

---

Genauso geht's doch auch. Einfach vor die Procedure in der es aufgerufen wird einfügen. Oder aber es im private/public Bereich der Klasse deklamieren und dann TXYZ. Procedere als Name nutzen, dann wäre die Reihenfolge wieder egal. Auch eine extra Unit dafür anlegen ist möglich. Im Grunde hab ich nur grad keine Ahnung was dein Problem dabei ist.

Zitat:

---

Zitat von Crash-Override

Im Grunde hab ich nur grad keine Ahnung was dein Problem dabei ist.

---

Lol, das weiß ich auch nicht. :p
Manchmal stelle ich mich schon ziemlich blöd an. Aber das Problem dabei war warscheinlich, dass ich mich nicht an die Reihenfolge gehalten habe.


Neue Frage bezüglich Images:
Wie kann ich auf einfache Weise das Picture eines Images ändern, also mit einem Befehl? [Image1.Picture......]

Zitat:

---

Zitat von PX

[Image1.Picture......]

---

LoadFrom* [File|Steam] :D

Zitat:

---

Zitat von Crash-Override

Schau mal hier: http://dsdt.info/grundlagen/codes/vks.php

VK_BACK oder auch $08. VK_Back wird aber nur für KeyUP/KeyDown gehen.

---

Habe es noch nicht verstanden.

Code:

---

if not (Key in ['VK_BACK']) then
  Key := #0;

---

So geht es nicht...

Zitat:

---

Zitat von PX

Habe es noch nicht verstanden.

Code:

---

if not (Key in ['VK_BACK']) then
  Key := #0;

---

So geht es nicht...

---

Klick mal mit gedrückter CTRL/STRG Taste auf VK_BACK und du wirst sehen es ist eine Vordefinierte const (VK_BACK = 8; in der Unit "Windows"). Aber Key ist wie du oben siehst ein Char (oder ein Byte im Grunde, da es ASCII Chars bis max. Nr. 255 sind. Also schreibst du entweder #8 (Das sagt Delphi du möchstest einen Char mit dem Wert 8) oder du wandelst deine Konstanze (im Grunde ja auch 8) in ein Char um. Dafür gibt es den Befehl Chr().

Code:

---

procedure TXYZ.OnKeyPress(Sender: TObject; var Key: Char);
begin
  if Key = Chr(VK_Back) then
    // Whatever...
end;

---

OnKeyPress liefert eben nur Char-Werte. OnKeyUp/OnKeyDown liefern dir den Wert als "Word" (= 4Byte Integer also ein normales Integer in Delphi). Hier würde die Umwandlung ausbleiben. Der Unterschied ist die Auslösung der Ereignisse.

OnKeyDown wird ausgelöst wenn der Nutzer die Taste runterdrückt.
OnKeyUp wird ausgelöst wenn der Nutzer die Taste loslässt.
OnKeyPress wird ausgelöst wenn der Nutzer die Taste runterdrückt und zusätzlich nach einiger Zeit wieder, ähnlich wie wenn man in einem Memo "A" gedrückt hält. Zuerst kommt ein "A", wie gewollt und nach einigen Millisekunden viele "A"s mehr und zwar diesmal recht schnell hintereinander, also mit weniger Abstand als das erste und das zweite.

Wie wird die maximale Charakteranzahl eines Editfeldes begrenzt?

Edit: Achja, wie lautet eigentlich der Tastencode für Enter?

Enter == Return -> #13, VK_RETURN 0D Return-Taste

Ich wuerde allerdings immer die VK_* Konstanten verwenden. Zum einen erleichtert das die Portierbarkeit des Programms, zum anderen ist es auch fuer dich leichter lesbar.

Einige Bilddateien liegen in einem normalen Ordner meines projektes und werden durch den Pfad ganz einfach gerufen:

Code:

---

... LoadFromFile('Bilder\Bild 1.bmp') ...

---

Das funktioniert auch prima. Nur möchte ich den Bilderordner verschlüsseln, bzw. in ein Archiv stecken, damit nicht jeder die Dateien so einfach einsehen kann. Wie muss ich jetzt den Pfad zum aufrufen der Bilddateien ändern?

Edit: Möchte immernoch wissen: Wie wird die maximale Charakteranzahl eines Editfeldes begrenzt?
Außerdem interessiere ich mich für eine Art "Screenshotsperre" innerhalb eines gesamten Delphiprojektes, falls es so etwas gibt.

Das haengt wohl von deiner Verschluesselung bzw. deinem Archiv ab.
IdR kannst du auf sowas nicht einfach so wie auf ein Dateisystem zugreifen.
Die einfachste Variante waere wohl, die Dateien zu entschluesseln (wie das geht, musst du deiner Verschluesslungs- oder Archivierungsbibliothek entnehmen), die z.B. im lokalen Temp Ordner zu speichern, darauf ein LoadFromFile zu machen und am ende wieder zu loeschen.

Es kann auch sein, dass es eine LoadFromStream oder LoadFromMemory Methode gibt, aber dafuer wuerde ich jetzt auf anhieb nicht die Hand ins Feuer legen. ist bei mir schon etliche Jahre her. Ansonsten gibt es immer noch die Moeglichkeit, mit der (Windows-)API direkt aus dem Speicher ein Bitmap-Objekt zu erstellen und mittels bitblt auf den Canvas deiner Zeichenflaeche zu blitten (Stichwort: TBitmap.Handle bzw TCanvas.Handle).

Habe jetzt etwas über einen sehr komplizierten Vorgang zum Lesen aus Archiven gefunden... Nunja, mich interessiert viel brennender die Begrenzung der Zeichenzahl im Editfeld. In diesem Feld ist übrigens VK_RETURN freigeschaltet, aber trotzdem wird das zugeordnete OnEnter-Ereignis nicht ausgeführt. Warum?

Zitat:

---

Zitat von PX

Nunja, mich interessiert viel brennender die Begrenzung der Zeichenzahl im Editfeld.

---

Hat Crash doch schon geschrieben:

Zitat:

---

Zitat von Crash-Override

Ansonsten ist die maximale Stringlänge bei Edits in MaxLength gespeichert, wer hätte es gedacht ;)

---

Einfach in den Eigenschaften des jeweiligen Edit-Felds ändern...

Hab ich übersehns. Danke dir. ;)