4. Komponentenentwickulung Eigenschaft mit Untereigenschaft erstellen

Komponentenentwickulung Eigenschaft mit Untereigenschaft erstellen

  • 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
  • A

    Bigwill schrieb:

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

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

    Hi,
    welche der beiden ist Zeile 45? Ich habe die vermutung das diese Warnung von der 1. Zeile produziert wird!

    MFG

    Alexander Sulfrian

    0
  • B

    Die kommt bei allen beiden, war nur zu Faul die 2 mal reinzukopieren.
    Und mir ist auch klar warum die kommt, ich dachte nur man kann die irh´gendwie wegbekommen, denn gehen tut es.

    0
  • A

    hi,

    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?

    das sollte nur ein Beispiel sein, wie man eine Instanz erzeugt und Werte setzt. Das hat nicht mit der Klasse zu tun. Ich habs nur im Konstruktor vom Formular geschrieben, da dieser bei BCB- Start automatisch erzeugt wird. Faulheit siegt 😉 Hätte auch eine beliebig andere Funktion sein können...

    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.

    das geht perfekt, siech Beispiel von mir...

    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?

    wer sagt, dass das nicht geht.

    wenn ich nochmal auf mein Beispiel zurückkommen darf:

    __fastcall TForm1::TForm1(TComponent* Owner) 
   : TForm(Owner) 
{ 
 TComm* Comm=new TComm(this); 
// Comm->DCB->BaudRate= BR_200;  // hier setzt du die Bautrate 
Comm->DCB->BaudRate=(TListe)200; // nun setzt du das Property über ein DWORD

// oder
DWORD t=54;
Comm->DCB->BaudRate=(TListe)t;
 delete Comm; 
} 
//---------------------------------------------------------------------------

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

    ähm, du MUSST bei ein Datentyp bei der Implementierung bleiben. Wie der Anwender später castet ist seine Sache. Man kann ohne PRobleme ein DWORD oder ein int nach enum oder umgekehr casten.
    mach dich also um sowas kein Kopf...

    0
  • B

    Oh shit man, jetzt seh ich erst, das ich gepennt habe. Hatte dein Beispiel vorhins vor lauter Code net gesehen, dachte nämlich du hättest ein Stück aus meinem letzen Code zitiert, weil ich nicht gleich ne Änderung gesehen hatte.

    0
  • A

    🙂

    0
  • B

    So fast geschafft es geht alles bis auf eine kleine Sache. Hier erst mal der Code, die Fehlerbeschreibung untendrunter.

    enum nByteSize   {Bits4=4, Bits5=5, Bits6=6, Bits7=7, Bits8=8};
enum nStopBits   {OneStopBit, OneAndHalfStopBits, TwoStopBit};
enum nParity     {NoParity, OddParity, EvenParity, MarkParity, SpaceParity};
enum nRtsControl {RtsDisable, RtsEnable, RtsHandshake, RtsToggle};
enum nDtrControl {DtrDisable, DtrEnable, DtrHandshake};

//---------------------------------------------------------------------------
class PACKAGE CommSet : public TPersistent
{
__published:
        __property DWORD       BaudRate     = {read=GetBaudRate, write=SetBaudRate};
        __property nDtrControl fDtrControl  = {read=GetfDtrControl, write=SetfDtrControl};
        __property nRtsControl fRtsControl  = {read=GetfRtsControl, write=SetfRtsControl};
        __property nParity     Parity       = {read=GetParity, write=SetParity};
        __property nStopBits   StopBits     = {read=GetStopBits, write=SetStopBits};
        __property nByteSize   ByteSize     = {read=GetByteSize, write=SetByteSize};

private:
        DWORD       F_BaudRate;       //Current Baud Rate
        nDtrControl F_fDtrControl;    //Data-Terminal-Ready Flow Control
        nRtsControl F_fRtsControl;    //Request-To-Send Flow Control
        nParity     F_Parity;         //Specifies the Parity Scheme
        nStopBits   F_StopBits;       //Number of Stop Bits
        nByteSize   F_ByteSize;       //Number of Bits in Bytes transmitted and received

public:
        __fastcall CommSet()
        {
          BaudRate = 9600;
          fDtrControl = DtrHandshake;
          fRtsControl = RtsHandshake;
          Parity = EvenParity;
          StopBits = OneStopBit;
          ByteSize = Bits4;
        }

        __fastcall ~CommSet(){}

protected:
        DWORD       __fastcall GetBaudRate()                 {return F_BaudRate;}
        void        __fastcall SetBaudRate(DWORD br)         {F_BaudRate = br;}
        nDtrControl __fastcall GetfDtrControl()              {return F_fDtrControl;}
        void        __fastcall SetfDtrControl(nDtrControl br){F_fDtrControl = br;}
        nRtsControl __fastcall GetfRtsControl()              {return F_fRtsControl;}
        void        __fastcall SetfRtsControl(nRtsControl br){F_fRtsControl = br;}
        nParity     __fastcall GetParity()                   {return F_Parity;}
        void        __fastcall SetParity(nParity br)         {F_Parity = br;}
        nStopBits   __fastcall GetStopBits()                 {return F_StopBits;}
        void        __fastcall SetStopBits(nStopBits br)     {F_StopBits = br;}
        nByteSize  __fastcall GetByteSize()                  {return F_ByteSize;}
        void       __fastcall SetByteSize(nByteSize br)      {F_ByteSize = br;}

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

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

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

__published:
        __property CommSet *CommDCB = {read=FDCB, write=FDCB};

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

    Das Problem ist das erste enum ganz oben, wo ich ab 4 Initialisiere.
    Bei allen anderen geht alles aber bei diesem enum habe ich in der Ide als Standard Bit8 gesetzt obwohl ich doch im Construktor Bit4 angebe und in der Auswahlliste steht haufenweise wirres Zeug aber nicht das aus dem enum. Ich schätze mal das liegt daran, das ich nicht mit 0... Initialisiere wie bei den anderen, wenn ich das nähmlich mache, geht es da auch. Nur dummerweise kann ich es nicht machen, da ich nunmal als Wert 4-8 brauche und nicht 0-3.

    0
Anmelden zum Antworten