Property Group im c++-Builder

moin!

Ich hab da mal ne Frage zur Komponentenentwicklung im C++-Builder...
Wie kann ich Property Groups erstellen (die im Object Inspector angezeigt werden)... ich kann ja mit
__property AnsiString Name=....

ne property erstellen die im OI angezeigt wird.... wie bekomme ich aber ne Group (wie z.B. bei Constraints oder Fonts)???

hoffe ihr wisst was ich meine...

thx

Xqgene

Wenn du in der Hilfe Thema Komponentenentwicklung durchliest, findest du auch die Antwort

Wie wärs wenn du mir die einfach gibst... in der Hilfe such ich schon die ganze Zeit...

Xqgene

Na z.B.:

Eine Eigenschaft kann einen beliebigen Typ haben. Unterschiedliche Typen werden auch unterschiedlich im Objektinspektor angezeigt. Dieser überprüft die Eigenschaftszuweisungen auf ihre Gültigkeit, und zwar unmittelbar bei ihrer Erstellung zur Entwurfszeit.

Eigenschaftstyp Anzeige im Objektinspektor

Einfach
Numerische, Zeichen- und Stringeigenschaften werden als Zahlen, Zeichen oder Strings angezeigt. Der Anwendungsentwickler kann den Wert der Eigenschaft direkt ändern.

Aufzählung
Eigenschaften mit Aufzählungstyp (einschließlich Boolescher Typen) werden als bearbeitbare Strings angezeigt. Der Entwickler kann die verschiedenen Werte durchsehen, indem er in der Wertspalte doppelklickt. Es ist eine Dropdown-Liste vorhanden, in der die möglichen Werte aufgeführt sind.

Menge
Eigenschaften mit Mengentyp werden in der entsprechenden Klammernotation angezeigt. Durch Doppelklicken auf die Eigenschaft kann der Entwickler die Menge erweitern und jedes Element als Booleschen Wert behandeln (wenn es zur Menge gehört).

Objekt
Eigenschaften, die selbst Klassen sind, besitzen häufig eigene Eigenschafts- Editoren, die in der Registrierungsprozedur der Komponente angegeben sind. Wenn die von einer Eigenschaft gebildete Klasse eigene Eigenschaften besitzt, die als published deklariert sind, kann der Entwickler im Objektinspektor die Liste erweitern (durch Doppelklicken), um diese Eigenschaften hinzuzufügen und einzeln zu bearbeiten. Objekteigenschaften müssen von der Klasse TPersistent abgeleitet werden.
Array
Array-Eigenschaften müssen über eigene Eigenschafts-Editoren verfügen. Der Objektinspektor unterstützt ihre Bearbeitung nicht. Sie können einen Eigenschafts-Editor erstellen, wenn Sie die Komponenten registrieren.

AndreasW

Hi,
ich arbeite an ein Kapitel mit diesen Thema für das Tutorial.

Ein Auszug:

**Der Objektinspektor und die Eigenschaftseditoren

Beschreibung der Zusammenhänge zur Entwurfs und Laufzeit**

Der Objektinspektor stellt die Schnittstelle zuwischen den Komponenten und den Anwendungsentwickler zur Entwurfszeit dar. Er zeigt die __published- Eigenschaften an und gibt den Anwendungsentwickler die Möglichkeit Änderungen an den Eigenschaften vorzunehmen. Die geänderten Daten setzt der Objektinspektor dann über die in der Eigenschaft definierten Write- Zugriff. Er ruft also entweder eine Funktion auf oder setzt die Variable, welche hinter der Eigenschaft steht direkt.

Wenn der Anwendungsentwickler die erstellte Anwendung startet werden von allen Formularen und Komponenten neue Instanzen erzeugt. Die Änderungen, welche zur Entwurfszeit vorgenommen wurde, bekommen die neuen Instanzen nun aber nicht mit. Das bedeutet, das der BCB die Änderungen, welche im Objektinspektor vorgenommen wurde, irgendwo mit in das Projekt reinkompilieren muss, damit die Änderungen auch für die neuen Instanzen erkennbar sind. Deshalb werden alle geänderten Eigenschaften des Formulars oder der Komponenten, die sich auf dem Formular befinden in eine binäre Datei gespeichert, die mit *.dfm endet. Das macht allerdings nicht der Objektinspektor sondern jede Komponente oder jedes Formular selbst. Die Routinen, welche für das Speichern und Laden von Daten aus der dfm- Datei zuständig sind werden in der Klasse TPersistent eingeführt. Alle Klassen, die mindestens von TPersistent abgeleitet sind können also Daten aus einer dfm- Datei lesen und auch dort ablegen. Des Prinzip der Selbstinitialisierung von Komponenten und Formularen bleibt somit gewährleistet. Weiters zu diesem Thema finden Sie im Absatz Lade- und Speicherroutinen von Komponenten.

Nachdem nun die Instanzen der Formulare und Komponenten zur Laufzeit erzeugt wurden, werden, bevor das Formular angezeigt wird, alle Eigenschaften aus dieser *.dfm- Datei geladen. Danach wird die Methode Loaded aufgerufen, in der die Komponenten sich initialisieren können. Dort werden die Änderungen der Eigenschaften übernommen. Erst nachdem sich das Formular und sich alle Komponente selbst initialisiert haben, wird das Formular auf dem Bildschirm angezeigt. Dadurch wird flackern der Komponenten und des Formular vermieden, welche durch schnell aufeinanderfolgende Änderungen von Eigenschaften entstehen können.

Sie können sich jederzeit den Zustand der .dfm- Datei anzeigen lassen. Klicken sie einfach auf das Formular, Datenmodul oder auf eine Komponente mit der rechten Maustaste. Wählen Sie dann "Ansicht als Text", worauf hin die Datei in den Editor des BCB's geladen wird. Sie können dort auch Änderungen am Formular oder an den Komponenten vornehmen. Achten Sie aber darauf, das die geänderte dfm- Datei dann noch gültig ist. Fügen sie nicht einfach ein Objekt ein, das nicht in der auf dem Formular existiert.

**
Der Objektinspektor braucht Eigenschaftseditoren**

Der Objektinspektor kann nicht einfach so Eigenschaften anzeigen. Ihm muss zuerst mitgeteilt werden, wie er eine Eigenschaft behandeln soll. Außerdem kann der Objektinspektor nur Text anzeigen. Deshalb muss die Eigenschaft in Text konvertiert werden. Dieses und die Definition der Art und Weise der Anzeige der Eigenschaft übernimmt aber nicht der Objektinspektor sondern speziell für die Verwaltung von Eigenschaften angelegten Eigenschaftseditoren. Diese Eigenschaftseditoren sind für die meisten Typen bereits vordefiniert und sind von der Klasse TPropertyEditor abgeleitet. Für jeden Typ, der im Objektinspektor visualisiert werden kann, gibt es eine abgeleitete Klasse, welche die entsprechenden Routinen definiert.

Wenn Sie eine Eigenschaft im __published- Bereich einer Komponente definieren, müssen Sie sich nicht um die Initialisierung der Eigenschaft und die Visualisierung der Eigenschaft im Objektinspektor kümmern. Der Objektinspektor identifiziert den Typ der Eigenschaft und sucht sich selbst den passenden PropertyEditor- Typ und erzeugt eine Instanz davon.

Wenn er allerdings kein entsprechenden Eigenschaftseditor finden kann, kann er die Eigenschaft auch nicht anzeigen. In diesen Fall muss man einen Eigenschaftseditor für diesen unbekannten Typ definieren und registrieren.

Standard- Eigenschaftseditoren

Hier mal eine kleine Liste von vorhandenen Property- Editoren, wie sie in der Hilfe zum Thema Komponentenentwicklung zu finden ist:

TOrdinalProperty Alle von TOrdinalProperty abgeleiteten Editoren für Integer-, Zeichen- und Aufzählungseigenschaften
TIntegerProperty Alle Integer-Typen einschließlich vor- und benutzerdefinierter Teilbereiche
TCharProperty Zeichen und Zeichen-Teilbereiche wie ‘A’..’Z’
TEnumProperty Alle Aufzählungstypen
TFloatProperty Alle Gleitkommawerte
TStringProperty AnsiString-Typen.
TSetElementProperty Einzelne Elemente in Mengen (angezeigt als boolesche Werte)
TSetProperty Alle Mengen. Mengen können nicht direkt bearbeitet werden. Sie werden als Liste der einzelnen Mengenelement-Eigenschaften angezeigt.
TClassProperty Klassen. Der Klassenname wird angezeigt, und die Eigenschaften der Klasse können eingeblendet werden.
TMethodProperty Methodenzeiger, vor allem Ereignisse
TComponentProperty Komponenten im selben Formular. Der Benutzer kann die Eigenschaften der Komponente nicht bearbeiten, aber auf eine bestimmte Komponente eines kompatiblen Typs verweisen.

Die Liste ist natürlich nicht vollständig und soll lediglich die wichtigsten Eigenschaftseditoren nennen. Wenn Sie eine Integer-Eigenschaft in der Komponente einführen, wird im Objektinspektor eine Instanz der TIntergerProperty – Eigenschaftseditor erstellt, wenn die Komponente zur Entwurfszeit geladen wird.

Für dich wäre es wohl am einfachsten eine Klasse von TPersistent abzuleiten und als Wrapperklasse zu benutzen. Registriere ein Objekt dieser Klasse als SupComponenent und erstelle ein Property mit den Typ dieser Klasse.

Es wird dann automatisch diese Kreutz angezeigt und die Eigenschaften der Wrapper- Klasse klappen dann auf.

Näheres kann man in etwa 3-4 Wochen, wenn das Kapitel fertig ist, auch im Tutorial nachlesen.

[ Dieser Beitrag wurde am 11.04.2003 um 08:51 Uhr von AndreasW editiert. ]

DerAltenburger

Sowas geht z.B.:
(Ist nur im Ansatz ausgefuehrt, geht aber im Prinzip!)

class  PACKAGE TDirectoryOptions : public TPersistent
{
private:
    Boolean FHidden;
        Boolean FReadOnly;
        Boolean FSysFile;
        Boolean FLinked;
public:
__published:
  __property Boolean Hidden = {read=FHidden, write=FHidden, default=false};
  __property Boolean ReadOnly = {read=FReadOnly, write=FReadOnly, default=false};
  __property Boolean SysFile = {read=FSysFile, write=FSysFile, default=false};
  __property Boolean Linked = {read=FLinked, write=FLinked, default=false};
};

Das ist 'ne Klasse fuer die 'Gruppe' (4x Bool- Option)

********************************************************
//Teil der Komponente (aus Header!!!)
.
.
private:
  TDirectoryOptions *FDirOption;//in Construktor mit new erzeugen
.
.
__published:
  __property TPwdDlg *PwdDlg ={read=FPwdDlg, write= FPwdDlg};
  __property TFileListBox *FileList ={read=FFLB, write= FFLB};
  __property TLabel *DirLabel ={read=FDL, write= FDL};
  __property TLabel *DirCountLabel ={read=FDCL, write= FDCL};
  __property TDirectoryOptions *DirectoryOption ={read=FDirOption, write= FDirOption};
.
.

Im OI erscheint Eigenschaft 'DirectoryOptions' mit 4 Unterpunkten!

Klappt bei mir problemlos!

Bigwill

Auf den Beitrag hier drüber hin, habe ich gerade folgendes probiert.

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

#include "CDCB.h"
//---------------------------------------------------------------------------
class PACKAGE TComm : public TComponent
{
private:
  DCB FDCB;
  CDCB* myDCB;

protected:
          void __fastcall SetBaudRate(DWORD br){FDCB.BaudRate=br;}

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

__published:
          __property DWORD BaudRate = {read=FDCB.BaudRate, write=SetBaudRate};
          __property CDCB *DCB_Settings = {read=myDCB, write=myDCB};

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

Aber irgendwie kommt da keine Liste bei mir. Muss man beim kompilieren eventl. noch was bestimmtes einstellen?

AndreasW

Hi,

was du brauchst ist ein Set.

Sets werden automatisch so angezeigt.

Siehe auch:
http://www.c-plusplus.net/forum/viewtopic.php?t=42520&highlight=tsetproperty