Ich habe eine kleine Übungs-Kompo erstellt (statisch). Ich versuch mal das Problem stark vereinfacht darzustellen:

Die Kompo lädt ein Bild auf eine TForm.
Das Ganze funktioniert mit dem Objektinspektor soweit sogut. Das BMP läßt sich mit dem Objektinspektor aus einem Verzeichnis auswählen, laden u auch wieder entladen. Ich kann das Bild auf meiner Form hin- und herschieben, die Größe ändern, einen Rahmen zeichnen lassen usw.
**
Jetzt mein Problem.
Wenn ich das Programm mit geladenem BMP starten will erhalte ich die Exception EReadError: “Eigenschaft kann nur gelesen werden”.
**
Der Debugger bleibt dann in der Forms.hpp an der folgenden Stelle hängen:
/* TCustomForm.Create / inline __fastcall virtual TForm(Classes::TComponent AOwner)

Ohne geladenes Bild startet das Programm fehlerfrei.

Vielleicht kann mir jemand weiterhelfen. Ich habe mal die wichtigsten Stellen aus der Kompo hierherkopiert. Vielleicht sieht jemand den Fehler. Bin für jede Hilfe dankbar.

MyBild.h (nur das wichtigste)

class PACKAGE TMyBild : public TGraphicControl {
private:
    Graphics::TBitmap *FBild;
    void __fastcall SetBild(Graphics::TBitmap *Value);
    void __fastcall CalcBildLayout(TRect &r);
protected:
    void __fastcall Paint(void);
public:
    __fastcall TMyBild(TComponent* Owner);
__published:
    __property Graphics::TBitmap* Bild = {read=FBild, write=SetBild};
};

MyBild.cpp (nur das wichtigste)

__fastcall TMyBild::TMyBild(TComponent* Owner): TGraphicControl(Owner)
{   }

// ---------------------------------------------------------------------------
void __fastcall TMyBild::SetBild(Graphics::TBitmap * Value)
{
  if(Value == NULL){
    if (FBild)
      FBild = NULL;
    return;
  };
  if(!FBild) FBild = new Graphics::TBitmap;
  FBild->Assign(Value);
  Invalidate();
}
// ---------------------------------------------------------------------------
void __fastcall TMyBild::Paint(void) {
  TRect cRect, gRect;
  Canvas->Brush->Color = clBtnFace;
  Canvas->FillRect(ClientRect);
  cRect = ClientRect;
  Graphics::TBitmap *bit = new Graphics::TBitmap;
  bit->Width = ClientWidth;
  bit->Height = ClientHeight;
  bit->Canvas->Brush->Color = clBtnFace;
  bit->Canvas->FillRect(cRect);
  if(FBild)
    if(!FBild->Empty){
      CalcBildLayout(gRect);   //berechnet die Eckpunkte des Bilds
      bit->Canvas->StretchDraw(gRect, FBild);
    }
  BitBlt(Canvas->Handle,0,0, ClientWidth, ClientHeight, bit->Canvas->Handle,0,0,SRCCOPY);
  delete bit;
}

void __fastcall CalcBildLayout(TRect &r);
{ /*Anweisungen zur Festlegung von &r */}

Edit:
Bitte aussagekräftige Überschriften wählen. Danke!

object Form1: TForm1
  Left = 100
  Top = 100
  Width = 500
  Height = 200
  Caption = 'Test-Form1'
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'MS Sans Serif'
  Font.Style = []
  Icon.Data = {424D363......FFF}
  OldCreateOrder = False
  PixelsPerInch = 96
  TextHeight = 13
  object MyBild1: TMyBild
    Left = 88
    Top = 112
    Width = 185
    Height = 169
    Bild.Data = {36300000424......FFFFFF}
   end
end

Wenn ich wieder in die Ansicht zum Formular zurückkehren will, erscheint folgende Fehlermeldung:
"Fehler beim Lesen des Formulars
Eigenschaft kann nur gelesen werden. Fehler ignorieren und fortfahren?
WARNUNG: Ignorieren kann bedeuten, daß Komponenten gelöscht werden oder Eigenschaftswerte verloren gehen."

Gehe ich auf <Ignorieren>, ist mein geladenes Bild verschwunden.
Mein Problem ist, ich weiß nicht, wie die Übergabe des Bildes vom Objektinspektor auf meine Form geschieht.
Muss ich im Konstruktor noch eine Zuweisung einfügen, die das geladene Bild aufnimmt? Ich habe das schon mit Assign probiert, leider klappt das auch nicht.
Hier steckt mein Fehler. Kann mir jemand zeigen, wie das geht?

Mein Vorschlag:

__fastcall TMyBild::TMyBild(TComponent* Owner): 
  TGraphicControl(Owner),
  FBild(0)
{   }

Insgesamt könnte Dein Code sicherlich noch etwas überarbeitet werden

Gruß,

Alexander

Mir ist aufgefallen, dass Du nirgendwo FBild initialisierst, weshalb u.U. die entsprechende Set-Methode
fehlschlagen könnte.

das macht er in der Set Methode.

Ich würde aber auch in Constructor das Bild erzeugen und im Destructor deleten!
Ich denk auch , dass der Fehler irgendwie damit zu tun hat.

__property TStringList* FixedColsText = { read=FFixedColsText, write=SetFixedColsText,stored=true};

Alexander Kempf schrieb:

Mir ist aufgefallen, dass Du nirgendwo FBild initialisierst, weshalb u.U. die entsprechende Set-Methode
fehlschlagen könnte.

das macht er in der Set Methode.

Ich glaube, das geht da schief.
Nehmen wir an FBild zeigt irgendwohin (nicht sauber auf 0 initialisiert):

thunderbol5 schrieb:

void __fastcall TMyBild::SetBild(Graphics::TBitmap * Value)
{
  // Hoffen wir das was vernünftiges übergeben wird, d.h. Value != 0 (NULL)...
  if(Value == NULL){//...dann ist diese Bedingung false, d.h. es geht unten weiter...

    if (FBild)
      FBild = NULL;
    return;
  };
//...hier geht's weiter und FBild zeigt irgendwohin,...
  if(!FBild) //...d.h. !FBild ist false und...
    FBild = new Graphics::TBitmap; //...dieser Befehl wird nicht abgearbeitet
// hier zeigt FBild immer noch irgendwohin, wohin weiß nur der liebe Gott
  FBild->Assign(Value);  // Was passiert dann?
  Invalidate();
}

Oder liege ich total daneben?
Das müsste sich aber durch Debuggen herausfinden lassen - sofern man weiß, wie man Komponenten
debuggt...

Gruß,

Alexander

Ich glaube, das geht da schief.

Ich sag ja, ich mach das auch lieber im Constructor/Destructor.

Ich sag ja, ich mach das auch lieber im Constructor/Destructor.

Ich glaube nicht, dass das was mit Vorlieben zu tun hat.
Wenn man im Konstruktor nicht sauber initialisiert, verlässt man sich auf den Zufall - ziemlich
riskant.
Die Frage bleibt natürlich, ob's in dem Fall daran liegt.

Gruß,

Alexander

erstmal vielen Dank für Eure Mithilfe. Hatte zwischenzeitlich schon nicht mehr damit gerechnet eine Antwort in diesem Forum zu bekommen, obwohl ich mir ja richtig Mühe gemacht hatte.

Ich habe mittlerweile das Problem gelöst. Die Kompo funktioniert jetzt einwandfrei.

Ihr hattet Recht.

Der Fehler liegt tatsächlich im Konstruktor. Dort muss eine Variable vom Typ TBild angelegt sein, wenn ein Bild aus dem Objektinspektor geladen werden soll.
Ich hatte ursprünglich angenommen, dass die Übergabe eines Bitmaps, das vom Objektinspektor geladen wurde, in der Set-Funktion auf die Kompo geschieht. Das scheint aber nicht so zu sein bzw. zu funktionieren.
Bei anderen Property-Typen wie z.B int, bool scheint eine Initialisierung im Konstruktor nicht notwendig zu sein.

Ich habe das so gelöst:

__fastcall TMyBild::TMyBild(TComponent* Owner):TGraphicControl(Owner){
...
if (!FBild) FBild = new Graphics::TBitmap;
...
}

Dadurch ist in der Funktion

void __fastcall TMyBild::SetBild(Graphics::TBitmap* Value)

die Anweisung

if (!FBild) FBild = new Graphics::TBitmap;

natürlich überflüssig, da sie ja bereits im Konstruktor durchgeführt wird und die Variable erst beim Verlassen der Kompo gelöscht wird.

__fastcall TMyBild::BeforeDestruction(void){
if (FBild) delete FBild;
}

Ich habe das so gelöst:

__fastcall TMyBild::TMyBild(TComponent* Owner):TGraphicControl(Owner){
...
if (!FBild) FBild = new Graphics::TBitmap;
...
}

Meines Erachtens ist hier die Überprüfung !FBild naturlich genauso falsch. Woher sollte denn im
Konstruktor der Wert für FBild gesetzt sein? Auch dort wird er wohl irgendwo hinzeigen.
Korrekt wäre z.B.:

__fastcall TMyBild::TMyBild(TComponent* Owner):
  TGraphicControl(Owner),
  FBild(new Graphics::TBitmap())
{
...
}

Falsch bzw. nicht initialisierte Zeiger sind immer wieder Anlass für schwer nachvollziehbare
Fehler und Abstürze. Ich habe mir angewöhnt, jede Membervariable auf die oben gezeigte Art zu
initialisieren. Zeiger entweder auf 0 oder auf eine neu erzeugte Instanz. Alles andere ist
Zufallsprogrammierung.

Gruß,

Alexander

Überzeugt!
Habe Deinen Rat aufgenommen und den Konstruktor entsprechend umgebaut.