4. Komponentenentwickulung Eigenschaft mit Untereigenschaft erstellen

Komponentenentwickulung Eigenschaft mit Untereigenschaft erstellen

  • B

    AndreasW schrieb:

    Hier ein Beitrag zum Thema von Bigwill aus einem anderen Thread:

    class  PACKAGE CDCB : public TPersistent
{
private:
        DCB FDCB;

public:

__published:
        __property DWORD BaudRate = {read=FDCB.BaudRate, write=FDCB.BaudRate};
        __property DWORD fBinary  = {read=FDCB.fBinary , write=FDCB.fBinary };
        __property DWORD fParity  = {read=FDCB.fParity,  write=FDCB.fParity };
};
#endif

    Ist es nicht eine Rekursion?

    In dem Text den ich oben gepostet habe sind auch Fehler, z.B. muss man von TPersisten ableiten und nicht von TObjekt, und der Datentyp für BorderStyles ist Set.

    0
  • ?

    hallo,

    eine komponente wird je nachdem was sie später darstellen bzw. leisten soll abgeleitet. eine kompo die zur entwurfszeit sichtbar sein soll damit man eigenschaften im oi editieren kann zur laufzeit aber unsichtbar ist (wie z. B. TOpenDialog) wird i. d. Regel von TComponent abgeleitet. alles was vor TComponent kommt ist noch keine komponente im sinne der cbuilder kompos sondern lediglich eine klasse (diese kann aber nicht im oi angezeigt werden). es wäre also sinnvoll die TComPort-Kompo von TComponent abzuleiten. Sets sind mengen, und eine menge mathematisch definiert ist etwas, das etwas enthalten kann oder eben auch nicht (deshalb bool) ist_enthalten=true; ist_nicht_enthalten=false. megen werdem im cbuilder folgendermaßen definiert:

    Set<type, minval, maxval>

    man kann mengen durch die schiebeoperatoren << >> etwas zuweisen bzw. herausholen. dann gibt es noch die funktion contains hiermit kann man prüfen, ob etwas enthalten ist oder nicht

    for (int i = 0; i < 255; i++)
  if (A.Contains(i))
    Memo1->Lines->Add(i);

    der unterschied zwischen einer menge und einem aufzählungstyp ist, bei einem aufzählungstyp kann man immer nur eines wählen, während bei einer menge 0,1 oder viele ausgewählt werden können. in der praxis existieren jedoch für viele mengen auch entsprechende aufzählungstypen. hier ein in der praxis nachvollziehbares beispiel:

    //Header:
enum TAbc //Aufzählungstyp
{
        Eins, Zwei, Drei
};

typedef Set<TAbc, Eins, Drei> TAbcSet; //Mengentyp bzw. Set.

class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
        TButton *Button1;
        void __fastcall Button1Click(TObject *Sender);
private:
        TAbcSet FAbc;
public:		// Anwender-Deklarationen
        __fastcall TForm1(TComponent* Owner);
};

//CPP
void __fastcall TForm1::Button1Click(TObject *Sender)
{
     FAbc<<Eins<<Zwei<<Drei;
     if (FAbc.Contains(Eins))
        ShowMessage("ja");
}

    nachdem du zu deiner Set-Definition entsprechende propertys im published bereich deklariert hast, erscheint das ganze bereits wie gewollt im oi.

    __published:
  __property TAbcSet Abc = {read=FAbc,write=FAbc}

    wobei du für die read/write direktive jeweils deine eigenen zugriffsmethoden angeben musst falls vorhanden...

    mfg
    murph

    0
  • A

    Was Bigwill möchte ist sowas im Objektinspektor ( wenn ich richtig liege):
    solch eine EIgenschaft:

    + Optionen

    expandiert:

    - Optionen    [eine zusammenfassung]
    Name      com-Port1           // String   
    BaudRate  4                   //DWORD  
    fBinary   9                   //DWORD  
    fParity   6                   //DWORD   
    connect   true                // bool- Wert

    also verschiedene Typen und keine reinen bool- Werte wie Sets.
    Das mach die Sache etwas schwieriger. Müsste aber gehn..

    0
  • B
     

    class  PACKAGE CDCB : public TPersistent 
{ 
private: 
        DCB FDCB; 

public: 

__published: 
        __property DWORD BaudRate = {read=FDCB.BaudRate, write=FDCB.BaudRate}; 
        __property DWORD fBinary  = {read=FDCB.fBinary , write=FDCB.fBinary }; 
        __property DWORD fParity  = {read=FDCB.fParity,  write=FDCB.fParity }; 
}; 
#endif

    Diese Klasse sollte nur als Aufnahme für die DCB Struktur dienen, da ich irgendwo (keine Ahnung mehr wo) gelesen hatte, das man solche Eigenschaften nicht aus Strukturen erstellen kann und DCB ist ja nunmal eine Struktur.

    Meine richtige Kompontene ist natürlich von TComponent abgeleitet und enthält dann diese Klasse. Damit hatte ich auch schon mein erstes Proplem gelösst, nähmlich das in der Entwicklungsumgebung alle Eigenschaften der DCB Struktur, als Unterelement von DCB angezeigt wurden (also so zum aufklappen, wie zum Bsp. bei Font).

    Dies geht aber auch noch ganz anders und ich bin schon auf den Code von Andres gespannt. Aber viel wichtiger ist halt im moment die Implementierung ines Aufzählunstyps. Ich weis das ich dazu irgendeine T....property ableiten muss, nur nicht welche und wie. Bzw. wo man das ganze dann in der Komponente hinschreibt und registriert. Dieen "List-Typ" wollte ich dann z. Bsp. für die Eigenschaft BaudRate der DCB Struktur benutzen, da es dafür verschiedene #define's gibt die mann dann darin auswählen können sollte. Oder für die Stopbits wo man dann zwischen 1 1,5 und 2 wählen kann (also ich brauche keinen Mengentyp, da immer nur eins gültig ist.

    Aber ich warte jetzt mal auf Andreas nächstes Posting oder eines von euch anderen, welcher ein kleins Bsp. dazu zur Verfügung stellt.

    Also einmal eine Struktur so kapseln, das man au deren Eigenschaften als Sub zugreifen kann und dann eine dieser Eigenschaften als Liste.

    Danke schonmal an alle die helfen.

    P.S. nicht das ihr denkt ich bin faul-hab dazu schon in mehreren Büchern und der Hilfe Brocken zusammengesucht, nur was wirklich funktionierendes ist halt bis jetzt nicht rausgekommen. Dazu kommen dann auch immer noch ein paar nette Fehlermeldungen der IDE, wozu die Hilfe nur schreibt, man soll Boröland informieren, wenn sowas kommt. 😃 Also mach ich quasie für die Bugsucher.

    P.S.S Andreas war nehn Moment schneller aber er hat verstanden was ich möchte. Wobei bei seinem Beispiel Option die DCB-Struktur sein sollte und die Eigenschaften dieser Struktur dann das was unten aufgeht.
    Und eine der Eigenschaften sollte dann halt noch eine Liste sein, so als Bsp.

    0
  • A

    ähm,

    hab mir deine Ansätze noch mal angeschaut.
    Du Nasenbär hast bestimmt vergessen die Instanz zu erzeugen 😃

    wie wäre es mit :

    myDCB=new CDCB;

    im Konstruktor von TComm ?

    nur mal so geraten... 🙂

    0
  • A

    und ich bin schon auf den Code von Andres gespannt

    ich hatte mal wieder zu weit gedacht. Natürlcih reicht es aus eine Klasse zu erzeugen, die die Properties enthält. Sie muss natürlich mindestens von TPersitent abgeleitet sein, weil dort die Speicherroutinen für die Formulardatei implementiert wurden.

    Mein anderer Ansatz wäre über die Kombination von zwei Eigenschaftseditoren.
    Den Haupteditor abgeleitet von TOrdinalProperty und für jede untergeordnete Eigenschaft einen entsprechenden Eigenschaftseditor. Als Basis dient dazu eine Ableitung von TNestedProperty.

    Dieser Weg ist allerding recht schwierig, weshalb ich ihn jetzt aus Zeitgründen nicht nachstelle. Im Tutorial werde ich aber versuchen ein möglichst gelungenes Beispiel zu geben.

    0
  • B

    Ne hatte ich nicht, wirklich. 😃
    Aber was ich Nasenbär vergessen hatte bzw. da noch nich wusste ist, das ich aus welchem Grund auch immer einfac nochmal auf Komponente installieren gehen musste. hab die Kompo quasie nochmal drüber installiert, dann ging es. Manchmal übernimmt der bei mir Änderungen an der Kompo komischerweise nähmlich nicht gleich in die, die ich in die KOmpopalette eingefügt habe.

    P.S. Ich war das übrigens auch mit der Mail an dich, brauchst also nicht hetzen mit dem Bsp. für mich (nicht das du für mich Überstunden machst) - ich probier einfach weiter den Builder zum Absturz zu bringen und das kann ich inzwischen echt gut. 😃 😃

    Andreas war schon wieder schneller. *grml
    Aber wie implementier ich den nun in obrige Klasse so ne Liste als Eigenschaft?

    0
  • A
     

    enum TListe{Wert1,Wert2,Wert3};
class  PACKAGE CDCB : public TPersistent  
{  
private:  
        DCB FDCB;  
   TListe FListe;
public:  

__published:  
        __property DWORD BaudRate = {read=FDCB.BaudRate, write=FDCB.BaudRate};  
        __property DWORD fBinary  = {read=FDCB.fBinary , write=FDCB.fBinary };  
        __property DWORD fParity  = {read=FDCB.fParity,  write=FDCB.fParity };  
        __property TListe Liste= {read=FListe,  write=FListe};  
};  
#endif

    😉

    0
  • A

    Bigwill schrieb:

    P.S. Ich war das übrigens auch mit der Mail an dich, brauchst also nicht hetzen mit dem Bsp. für mich (nicht das du für mich Überstunden machst) - ich probier einfach weiter den Builder zum Absturz zu bringen und das kann ich inzwischen echt gut. 😃 😃

    hehe, ja, da bin ich auch Meister drin... 🙂

    0
  • B

    Cool, das hatte ich so auch schon mal, nur mit anderen Bezeichnern. Nur dann hat wieder der Builder rumgesponnen und die Auswahlliste immer leer gelassen.

    Aber dann mach ich ahlt mal wiedr ein neues Projekt.

    Dann müsste ich aber doch noch eine Read and write Methode implementieren, da ja beim lesen und schreiben auch gleichzeitig der Wert in der DCB Struktur geämdert werden muss, stimmst?

    void __fastcall SetBaudRate(TListe wert)
{
  switch(wert)
  {  
    case 0:
      FDCB.BaudRate = 100;
      Liste = wert;
      break:
   case 1:
    .....
  };
}

    So in etwa, war jetzt trocken, müsste das gehen? Nur bei der read ätte ich jetzt auf Anhieb keine Ahnung wie ich das mache, ist bestimmt zuuuuuu einfach.

    0
  • B

    Aktueller Stand:

    enum TListe{Wert1,Wert2,Wert3};

//---------------------------------------------------------------------------
class  PACKAGE CDCB : public TPersistent
{
private:
   DCB FDCB;
   TListe FListe;
public:

protected:
      void __fastcall SetBaudRate(int wert)
      {
          switch(wert)
          {
            case 0:
                  FDCB.BaudRate = 100;
                  FListe = Wert1;
                  break;
            case 1:
                  FDCB.BaudRate = 200;
                  FListe = Wert2;
                  break;
            default:
                  FDCB.BaudRate = 300;
                  FListe = Wert3;
                  break;
          };
      }

__published:
        //__property DWORD BaudRate = {read=FDCB.BaudRate, write=FDCB.BaudRate};
        __property DWORD fBinary  = {read=FDCB.fBinary , write=FDCB.fBinary };   
        __property DWORD fParity  = {read=FDCB.fParity,  write=FDCB.fParity };   
        __property TListe BaudRate= {read=FListe,  write=SetBaudRate};
};   

//---------------------------------------------------------------------------

class PACKAGE TComm : public TComponent
{
private:
     CDCB *FDCB;

protected:

public:
        __fastcall TComm(TComponent* Owner);

__published:
        __property CDCB *DCB = {read=FDCB, write=FDCB};

};
//---------------------------------------------------------------------------
#endif

    Leider meckert er folgendermassen:

    [C++ Fehler] Comm.h(49): E2347 Keine Entsprechung der Parameter in write mit Zugriffsspezifikation der Eigenschaft BaudRate

    Ich weis aber nicht was der fürn Parameter erwartet ich dachte ein enum ist vom Typ her int??

    Oder ist das so agnz verkehrt?

    0
  • A

    Hi Michael,

    SetBaudRate(int wert)

    Der Parameter in der Funktion muss den selben Typ haben wie die Eigenschaft. Hier also DWORD

    SetBaudRate(DWORD wert)

    wäre also besser...

    0
  • ?

    hallo,

    @andreasw: ok, alles klar. ich waren falsche baustelle. haben immer wieder gelesen Set, Set, Set...

    mfg
    murph

    0
  • B

    Hallo Andreas,

    zuerst mal das wichtigste, ich heiße Markus, nicht Michael - wie kommste den darauf?

    AndreasW schrieb:

    Hi Michael,

    SetBaudRate(int wert)

    Der Parameter in der Funktion muss den selben Typ haben wie die Eigenschaft. Hier also DWORD

    SetBaudRate(DWORD wert)

    wäre also besser...

    Die Eigenschaft war aber doch vom Typ FListe!?

    Ich hab jetzt das mal so programmiert (Achtung Code):

    //---------------------------------------------------------------------------

enum TListe{BR_100,BR_200,BR_300};

//---------------------------------------------------------------------------
class  PACKAGE CDCB : public TPersistent
{
private:
        DCB FDCB;
        TListe FListe;
public:

protected:
      void __fastcall SetBaudRate(TListe wert)
      {
          switch(wert)
          {
            case 0:
                  FDCB.BaudRate = 100;
                  FListe = BR_100;
                  break;
            case 1:
                  FDCB.BaudRate = 200;
                  FListe = BR_200;
                  break;
            default:
                  FDCB.BaudRate = 300;
                  FListe = BR_300;
                  break;
          };
      }

      TListe __fastcall GetBaudRate()
      {
        if (FListe == BR_100)
          return BR_100;
        if (FListe == BR_200)
          return BR_200;
        return BR_300;  
      }

__published:
        __property DWORD fBinary  = {read=FDCB.fBinary , write=FDCB.fBinary };   
        __property DWORD fParity  = {read=FDCB.fParity,  write=FDCB.fParity };   
        __property TListe BaudRate= {read=GetBaudRate,  write=SetBaudRate};
};   

//---------------------------------------------------------------------------

class PACKAGE TComm : public TComponent
{
private:
     CDCB *FDCB;

protected:

public:
        __fastcall TComm(TComponent* Owner);

__published:
       // __property CDCB *DCB = {read=FDCB, write=FDCB};

};
//---------------------------------------------------------------------------
#endif

    Selbst das compilieren geht da, zumindest meistens. Allerdings frag ich mich nun wie ich auspropieren kann ob das so funktioniert. Ich kann ja in der Entwicklungsumgebung nicht feststellen ob er wirklich den anderen Wert in der dcb Struktur gesetzt hat.

    Und für den Zugriff wärend der Laufzeit muss ich mir dann wohl noch ne neue __property in public erzeugen?

    0
  • A

    Bigwill schrieb:

    zuerst mal das wichtigste, ich heiße Markus, nicht Michael - wie kommste den darauf?

    oh Markus, ja stimmt, hab dein Namen verwechselt... sorry

    Bigwill schrieb:

    Die Eigenschaft war aber doch vom Typ FListe!?

    ja hatte ich übersehen. Bleibt aber das selbe Problem, welches du ja anscheinend gelöst hast.

    Bigwill schrieb:

    Selbst das compilieren geht da, zumindest meistens. Allerdings frag ich mich nun wie ich auspropieren kann ob das so funktioniert. Ich kann ja in der Entwicklungsumgebung nicht feststellen ob er wirklich den anderen Wert in der dcb Struktur gesetzt hat.

    REchte Maustaste aus Formular. Und dann Ansicht als Text, wenn der neue Wert drin steht, wurde der auch erfolgkeich gesetzt.

    Bigwill schrieb:

    Und für den Zugriff wärend der Laufzeit muss ich mir dann wohl noch ne neue __property in public erzeugen?

    nein, wozu ?
    Zur Laufzeit kannst du schreiben:

    TComm* Comm =new TComm (this);
Com->DCB->fBinary=4;  // natürlich musst du die aukommentierte Zeile erst wieder reinnehmen.
....
    0
  • B

    Das mit dem Zugriff hatte ich mir auch so gedacht, doch dann bekamm ich dabei immer Fehlermeldunge das das nicht geht. Das muss ich mir nochmal anschauen.

    Die __published: __propertys stehen die zur laufzeit als public zur Verfügung?

    Wie setze ich dann zur Laufzeit die Baudrate, da die SetBaudRate Methode die ich als property habe da ja nicht gehen sollte, da mein Eingabe wert dann ja vom Typ DWORD ist.

    0
  • B

    Hier mein neuer Code, da ich das mit der enum Fliste nicht hinbekommen habe.

    class PACKAGE myDCB : public TPersistent
{
private:
        DCB *FDCB;

public:
        __fastcall myDCB()
        {
            FDCB = new DCB;
            FDCB->BaudRate = 9600;
            FDCB->fBinary = 1;
            FDCB->fParity = 1;
            FDCB->fOutxCtsFlow = 1;
            FDCB->fOutxDsrFlow = 1;
            FDCB->fDtrControl = 2;
        }
        __fastcall ~myDCB(){delete FDCB;}

protected:
        DWORD __fastcall GetBaudRate(){return FDCB->BaudRate;}
        void  __fastcall SetBaudRate(DWORD br){FDCB->BaudRate = br;}
        DWORD __fastcall GetfBinary(){return FDCB->fBinary;}
        void  __fastcall SetfBinary(DWORD br){FDCB->fBinary = br;}
        DWORD __fastcall GetfParity(){return FDCB->fParity;}
        void  __fastcall SetfParity(DWORD br){FDCB->fParity = br;}
        DWORD __fastcall GetfOutxCtsFlow(){return FDCB->fOutxCtsFlow;}
        void  __fastcall SetfOutxCtsFlow(DWORD br){FDCB->fOutxCtsFlow = br;}
        DWORD __fastcall GetfOutxDsrFlow(){return FDCB->fOutxDsrFlow;}
        void  __fastcall SetfOutxDsrFlow(DWORD br){FDCB->fOutxDsrFlow = br;}
        DWORD __fastcall GetfDtrControl(){return FDCB->fDtrControl;}
        void  __fastcall SetfDtrControl(DWORD br){FDCB->fDtrControl = br;}
        DWORD __fastcall GetfDsrSensitivity(){return FDCB->fDsrSensitivity;}
        void  __fastcall SetfDsrSensitivity(DWORD br){FDCB->fDsrSensitivity = br;}
        DWORD __fastcall GetfTXContinueOnXoff(){return FDCB->fTXContinueOnXoff;}
        void  __fastcall SetfTXContinueOnXoff(DWORD br){FDCB->fTXContinueOnXoff = br;}
        DWORD __fastcall GetfOutX(){return FDCB->fOutX;}
        void  __fastcall SetfOutX(DWORD br){FDCB->fOutX = br;}
        DWORD __fastcall GetfInX(){return FDCB->fInX;}
        void  __fastcall SetfInX(DWORD br){FDCB->fInX = br;}
        DWORD __fastcall GetfErrorChar(){return FDCB->fErrorChar;}
        void  __fastcall SetfErrorChar(DWORD br){FDCB->fErrorChar = br;}
        DWORD __fastcall GetfNull(){return FDCB->fNull;}
        void  __fastcall SetfNull(DWORD br){FDCB->fNull = br;}
        DWORD __fastcall GetfRtsControl(){return FDCB->fRtsControl;}
        void  __fastcall SetfRtsControl(DWORD br){FDCB->fRtsControl = br;}
        DWORD __fastcall GetfAbortOnError(){return FDCB->fAbortOnError;}
        void  __fastcall SetfAbortOnError(DWORD br){FDCB->fAbortOnError = br;}

__published:
        __property DWORD BaudRate = {read=GetBaudRate, write=SetBaudRate, default=9600};
        __property DWORD fBinary  = {read=GetfBinary,  write=SetfBinary, default=1};
        __property DWORD fParity  = {read=GetfParity,  write=SetfParity, default=1};
        __property DWORD fOutxCtsFlow = {read=GetfOutxCtsFlow, write=SetfOutxCtsFlow, default=1};
        __property DWORD fOutxDsrFlow = {read=GetfOutxDsrFlow, write=SetfOutxDsrFlow, default=1};
        __property DWORD fDtrControl  = {read=GetfDtrControl, write=SetfDtrControl, default=2};
        __property DWORD fDsrSensitivity = {read=GetfDsrSensitivity, write=SetfDsrSensitivity, default=1};
        __property DWORD fTXContinueOnXoff = {read=GetfTXContinueOnXoff, write=SetfTXContinueOnXoff, default=1};
        __property DWORD fOutX  = {read=GetfOutX,  write=SetfOutX, default=1};
        __property DWORD fInX  = {read=GetfInX,  write=SetfInX, default=1};
        __property DWORD fErrorChar  = {read=GetfErrorChar,  write=SetfErrorChar, default=1};
        __property DWORD fNull  = {read=GetfNull,  write=SetfNull, default=1};
        __property DWORD fRtsControl  = {read=GetfRtsControl,  write=SetfRtsControl, default=2};
        __property DWORD fAbortOnError  = {read=GetfAbortOnError,  write=SetfAbortOnError, default=1};

};
//---------------------------------------------------------------------------

class PACKAGE TComm : public TComponent
{
private:
        myDCB *FDCB;

protected:
public:
        __fastcall TComm(TComponent* Owner);
        __fastcall ~TComm();

__published:
        /*

        */
        __property myDCB *CommDCB = {read=FDCB, write=FDCB};

};
//---------------------------------------------------------------------------

    Jetzt habe ich das Problem, das die Defaultwerte nur zum Teil in der Ide gestezt werden.
    Genau genommen wird nur die BaudRate manchmal gesetzt und alle anderen nicht, und das obwohl ich sie alle im Konstruktor initialisiert habe.
    Langsam verlier ich echt die Nerven. Alles was ich probiere geht schief.

    0
  • A

    hm,
    was soll daran nicht gehen:

    //---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------  
enum TListe{BR_100=100,BR_200=200,BR_300=300}; 
//---------------------------------------------------------------------------
class  PACKAGE CDCB : public TPersistent 
{ 
private: 
        DCB FDCB; 
        TListe FListe; 
public:
protected:
      void __fastcall SetBaudRate(TListe wert) 
      {
          FListe=wert;
          FDCB.BaudRate=(int)wert;
      } 
      TListe __fastcall GetBaudRate()
      {
      return FListe;
      }
__published: 
        __property DWORD fBinary  = {read=FDCB.fBinary , write=FDCB.fBinary };    
        __property DWORD fParity  = {read=FDCB.fParity,  write=FDCB.fParity };    
        __property TListe BaudRate= {read=GetBaudRate,  write=SetBaudRate};
};     
//--------------------------------------------------------------------------- 
class PACKAGE TComm : public TComponent
{ 
private:
     CDCB *FDCB;          
protected: 
public: 
        __fastcall TComm(TComponent* Owner); 
__published: 
        __property CDCB *DCB = {read=FDCB, write=FDCB}; 
}; 
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{
 TComm* Comm=new TComm(this);
 Comm->DCB->BaudRate= BR_200;  // hier setzt du die Bautrate
 delete Comm;
}
//---------------------------------------------------------------------------

    Bigwill schrieb:

    Die __published: __propertys stehen die zur laufzeit als public zur Verfügung?

    Klar, hast du dir schon mal die Klassen der Formulare angeschaut ? Sonst könntest du ja nicht von Ausserhalb auf die Objkte der Formulare zugreifen. Natürlcih halte ich ein solches Vorgehen sowieso nicht so toll, aber es ist ja möglich.

    Bigwill schrieb:

    Das mit dem Zugriff hatte ich mir auch so gedacht, doch dann bekamm ich dabei immer Fehlermeldunge das das nicht geht.

    Welchen Fehler ?

    0
  • B

    Hab jetzt einen Fehler entdeckt (war ein Denkfehler) ich hab ja für die BaudRate ein enum angelegt und kann dann logischerweise auch nur Werte aus dem enmu setzen. Ich wollte es aber so das man in der Ide ein Wert aus dem enum wählt (da stehen die Standartwerte für die BaudRate drin) und während der Laufzeit sollte man dann auch DWORD werte setzen können, weil man auch beliebige non Standartwerte verwenden kann. Das geht natürlich aber mit der _property nicht, geht das überhaupt irgendwie?

    Du hast den Wert BaudRate (im Post hier drüber) doch im Konstruktor der Form gestezt. Das kann aber doch so nicht richtig sein. Ich wollte doch den Wert, der in der Ide angezeigt werden soll initialisieren, ich denke dann muss ich den in den KOnstruktor der Klasse schreiben, oder?

    Warum das mit dem setzen der Werte aus meinem vorigen Beispiel nicht geht habe ich auch rausgefunden, da DCB ja trotz allem ein Strukt war und das damit nicht geht. Daraufhin habe ich alle Eigenschaften einzeln in der Klasse aufgeführt, seitdem geht es.

    Den genauen Wortlaut der Fehlermeldung habe ich nicht zur Hand aber wenn ich mit F1 die Hilfe dazu befragt habe, stand da immer "Bitte Informieren Sie Borland, wie sie diese Fehlermeldung produziert haben." <- zumindest so ähnlich.
    Und die Fehlermeldung wegen dem Zugriff hat sich erledigt, da ich ja wie gesagt versucht habe in FListe ein DWORD zu befördern oder wars umgekehrt?!

    Also, alles im allen hat sich das meiste jetzt erledigt, werde am Wochenende (also jetzt) mal versuchen das umzusetzen. Ich hab zwar noch paar Fragen, die mir heute aufm Heimweg eingefallen sind aber hab sie schon wieder vergessen.

    Also, ich probier jetzt erstmal und melde mich dann nochma hier bzw. eher wenn was nicht geht. 🙂

    0
  • B

    Und schon isses passiert, ist aber nur eine Kleinigkeit.

    enum nByteSize{FourBits=4, FifeBits=5, SixBits=6, SevenBits=7, EightBits=8};

//---------------------------------------------------------------------------
class PACKAGE myDCB : public TPersistent
{
__published:
        __property nByteSize ByteSize     = {read=GetByteSize, write=SetByteSize};

private:
        BYTE  F_ByteSize;

public:

protected:
        nByteSize  __fastcall GetByteSize(){return F_ByteSize;}
        void  __fastcall SetByteSize(nByteSize br){F_ByteSize = br;}

};
//---------------------------------------------------------------------------

    Hab mal alles unwichtige rausgekürzt.

    [C++ Warnung] Comm.h(45): W8006 nByteSize wird mit unsigned char initialisiert

    Das ist die Fehlermeldung die ich bekomme. liegt daran, das ich versuche gleich BYTE in meine nByteSize enumeration zu schreiben, müsste ja eigentlich gehen, da es ja vom Typ her int ist und BYTE da ja locker reinpasst. Dachte so spar ich mir den ganzen switchkram. Hab auch schon versucht das vorher zu casten aber hat nix gebracht oder ich habs verkehrt gemacht.

    0
Anmelden zum Antworten