4. kommunizierende Komponenten

kommunizierende Komponenten

  • ?

    Gerade ist mir aufgefallen, dass ich das Casten in die Schnittstelle für diesen Zweck ja gar nicht brauche.
    Die Sache würde mich aber trotzdem interessieren. Ich fange mal einen neuen Thread an...

    0
  • A

    Mit Interface meinte ich so etwas:

    class MeinInterface
{
public:
  virtual void tuDies() = 0;
  virtual int tuDas(bool WirklichTun, int SoOftTun) = 0;
  // Weitere rein virtuelle Methoden

  __property int Count = {read=getCount, write=setCount};
  // und weitere Eigenschaften
protected:
  virtual int getCount() = 0;
  virtual void setCount(int Value) = 0;
};

    Der Header einer Implementierung könnte dann so aussehen:

    #include "MeinInterface.h"
#include "MeinInterface2.h"

class MeineImplementierung: public MeinInterface
{
public:
  MeineImplementierung();
  ~MeineImplementierung();

  virtual void tuDies();
  virtual int tuDas(bool WirklichTun, int SoOftTun);

  __property MeinInterface2* AnderesInterface = {read=FAnderesInterface, write=FAnderesInterface};
protected:
  virtual int getCount();
  virtual void setCount(int Value);
private:
  MeinInterface2* FAnderesInterface;
};

    Gruß,

    Alexander

    0
  • M

    Eine sehr schöne Idee. Leider funktioniert es nicht...
    Mittlerweile habe ich es so weit eingekreist, dass der Compiler schon meckert (E2109 Kein zulässiger Typ), wenn man überhaupt versucht einen Pointer auf ein Interface als Typ für eine Property zu verwenden. (Also ohne irgendwelche über-Kreuz-Geschichten)

    Hat noch jemand eine Idee?

    Gruß
    Marc

    0
  • A

    MarcE schrieb:

    Leider funktioniert es nicht...

    Solche Aussagen liebe ich 🙄

    MarcE schrieb:

    Mittlerweile habe ich es so weit eingekreist, dass der Compiler schon meckert, wenn man überhaupt versucht einen Pointer auf ein Interface als Typ für eine Property zu verwenden.

    Was genau hast Du denn gemacht?

    Unter Umständen müssen Klassen, die Du über eine Eigenschaft verwenden willst von TObject erben?

    Gruß,

    Alexander

    0
  • M

    Unter Umständen müssen Klassen, die Du über eine Eigenschaft verwenden willst von TObject erben?

    Tatsächlich, das war's! Ich find das könnt Borland an eine Stelle der Dokumentation schreiben, wo man es leicht findet...

    Vielen Dank,
    Marc

    0
  • A

    MarcE schrieb:

    Ich find das könnt Borland an eine Stelle der Dokumentation schreiben, wo man es leicht findet...

    Wo steht das denn?

    Gruß,

    Alexander

    0
  • M

    Nirgends, wo ich gesucht habe.

    Im Übrigen zu früh gefreut: TObject ist nicht abstrakt. Die Property kompiliert so zwar, aber die resultierende Klasse ist keine Schnittstelle mehr.

    0
  • M

    Damit wären wir also wieder bei "E2109 Kein zulässiger Typ", und zwar mit folgenden Code:

    __interface IZusatzfunktionalitaet
{
  public:
    virtual void __fastcall MachWas() = 0;
};

    #include "IZusatzfunktionalitaet.h"
//---------------------------------------------------------------------------
class PACKAGE TEditPlus : public TEdit
{
private:
  IZusatzfunktionalitaet* FZusatz;
protected:
public:
  __fastcall TEditPlus(TComponent* Owner);
__published:
  __property IZusatzfunktionalitaet* Zusatz = {read = FZusatz,
                                              write = FZusatz};
};
    0
  • A

    Nachdem ich jetzt noch mal ein bisschen rumprobiert habe, glaube ich, auf eine Lösung für das Problem
    gekommen zu sein. Im Prinzip funktioniert meine Lösung so ähnlich, wie ich es schon mal angedeutet
    hatte:
    - Zuerst habe ich mir zwei abstrakte Komponenten definiert - jeweils ein Abkömmling von TEdit und TStringGrid
    - Dann habe ich zwei konkrete Komponenten definiert, die von den ersten beiden erben und jeweils eine
    Eigenschaft der abstrakten Komponente besitzen.

    Hier mal ein wenig Code:

    //----------------------------------------
// MyAbstractComponents.h
//----------------------------------------

#ifndef MyAbstractComponentsH
#define MyAbstractComponentsH

#include <SysUtils.hpp>
#include <Classes.hpp>
#include <Controls.hpp>
#include <Grids.hpp>
#include <StdCtrls.hpp>

class PACKAGE TMyAbstractEdit : public TEdit
{
private:
protected:
   __fastcall TMyAbstractEdit(TComponent* Owner);
public:
__published:
};

class PACKAGE TMyAbstractStringGrid : public TStringGrid
{
private:
protected:
   __fastcall TMyAbstractStringGrid(TComponent* Owner);
public:
__published:
};

#endif

//----------------------------------------
// MyAbstractComponents.cpp
//----------------------------------------
#include <vcl.h>

#pragma hdrstop

#include "MyAbstractComponents.h"
#pragma package(smart_init)

__fastcall TMyAbstractEdit::TMyAbstractEdit(TComponent* Owner)
   : TEdit(Owner)
{
}

__fastcall TMyAbstractStringGrid::TMyAbstractStringGrid(TComponent* Owner)
   : TStringGrid(Owner)
{
}

//----------------------------------------
// MyEdit.h
//----------------------------------------

#ifndef MyEditH
#define MyEditH

#include <SysUtils.hpp>
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <MyAbstractEdit.h>

class PACKAGE TMyEdit : public TMyAbstractEdit
{
private:
   TMyAbstractStringGrid* FStringGrid;
protected:
public:
   __fastcall TMyEdit(TComponent* Owner);
__published:
   __property TMyAbstractStringGrid* StringGrid = {read=FStringGrid, write=FStringGrid};
};

#endif

//----------------------------------------
// MyEdit.cpp
//----------------------------------------
#include <vcl.h>

#pragma hdrstop

#include "MyEdit.h"
#pragma package(smart_init)

static inline void ValidCtrCheck(TMyEdit *)
{
   new TMyEdit(NULL);
}

__fastcall TMyEdit::TMyEdit(TComponent* Owner)
   : TMyAbstractEdit(Owner)
{
}

namespace Myedit
{
   void __fastcall PACKAGE Register()
   {
       TComponentClass classes[1] = {__classid(TMyEdit)};
       RegisterComponents("Test", classes, 0);
   }
}

//----------------------------------------
// MyStringGrid.h
//----------------------------------------

#ifndef MyStringGridH
#define MyStringGridH

#include <SysUtils.hpp>
#include <Classes.hpp>
#include <Controls.hpp>
#include <MyAbstractEdit.h>

class PACKAGE TMyStringGrid : public TMyAbstractStringGrid
{
private:
   TMyAbstractEdit* FEdit;
protected:
public:
   __fastcall TMyStringGrid(TComponent* Owner);
__published:
   __property TMyAbstractEdit* Edit = {read=FEdit, write=FEdit};
};

#endif

//----------------------------------------
// MyStringGrid.cpp
//----------------------------------------

#include <vcl.h>

#pragma hdrstop

#include "MyStringGrid.h"
#pragma package(smart_init)

static inline void ValidCtrCheck(TMyStringGrid *)
{
   new TMyStringGrid(NULL);
}

__fastcall TMyStringGrid::TMyStringGrid(TComponent* Owner)
   : TMyAbstractStringGrid(Owner)
{
}

namespace Mystringgrid
{
   void __fastcall PACKAGE Register()
   {
       TComponentClass classes[1] = {__classid(TMyStringGrid)};
       RegisterComponents("Test", classes, 0);
   }
}

    Das konnte ich bei mir kompilieren, installieren und auch verwenden.

    Gruß,

    Alexander

    0
  • M

    Ah, jetzt! Das tut. Vielen Dank!
    Das Ganze funktioniert übrigens auch, wenn man die abstrakten Komponenten in einzelne Dateien packt.

    Gruß
    Marc

    PS: Ich hatte (vergeblich) immer das versucht:

    class MyAbstractEdit
{
  public:
    ZusatzfunktionEdit() = 0;
}

class MyAbstractGrid
{
  public:
    ZusatzfunktionGrid() = 0; 
}

class MyEdit : public TEdit, public MyAbstractEdit
{
  private:
    MyAbstractGrid* FGrid;
  public:
    ZusatzfunktionEdit();
  __published:
    __property MyAbstractGrid* Grid = {read = FGrid, write = FGrid};
}

class MyGrid : public TStringGrid, public MyAbstractGrid
{
  private:
    MyAbstractEdit* FEdit;
  public:
    ZusatzfunktionGrid();
  published:
    __property MyAbstractEdit* Edit = {read = FEdit, write = FEdit};
}
    0
Anmelden zum Antworten