Objekteigenschaften

Greetings!
Ihr kennt sie doch sicher alle, diese Programme, bei denen man etwas anwählen kann und dann gibt es ein Eigenschaftenfenster, in dem man die Eigenschaften von selektierten Objekten einsehen und verändern kann. Eben sowas möchte ich gerne umsetzen, aber ich weiß nicht ob nun mein erster Einsatz schon wieder über das Ziel hinausschießt oder zu sehr "dynamisch" wird.

Mein Ansatz war, dass man solche Objekte als "Properties"-Container ansieht. Wenn nun jemand ein solches Objekt im laufenden Betrieb anwählt, dann kommt das Eigenschaftenfenster daher und schaut nach, welche Eigenschaften das Objekt so hat und bietet sie dann dem Benutzer zur Bedienung an.

Zu diesem Zweck habe ich mir eine Property-Klasse zusammengebastelt und ein Helfertemplate:

class Property {
public:
	virtual std::wstring GetValue() = 0;
	virtual void SetValue( const std::wstring& val ) = 0;
};

template< typename T, class PropertyBase = Property, class StoragePolicy = LocalStorage<T>, class NotificationPolicy = NoNotification >
	class IntegralProperty : public PropertyBase, public StoragePolicy, public NotificationPolicy
{
public:
	IntegralProperty( T value = T() ) : StoragePolicy( value ) {}

	T operator=( T& val ) {
		Store( val );
		NotifyChange(*this);
		return Retrieve();
	}

#pragma region "Property Interface"
public:
	std::wstring GetValue() override {
		return boost::lexical_cast< std::wstring >( Retrieve() );
	}

	void SetValue( const std::wstring& value )
	{
		try {
			Store( boost::lexical_cast<T>( value ) );
		} catch( boost::bad_lexical_cast& ) {
			throw BadFormatException();
		}

		NotifyChange(*this);
	}

	std::set< std::wstring > GetMeta()
	{
		return std::set< std::wstring >();
	}
#pragma endregion
};

Jetzt könnte man dahergehen und folgendermaßen Eigenschaften in Objekten erstellen:

fx::IntegralProperty<float,fx::Property,fx::RemoteStorage<float>,fx::SignalNotification> myProp;
myProp.Changed.connect( boost::bind( &FxMathView::PropertyChanged, this, _1 ) );
myProp.Set = boost::bind( &FxMathView::PropertySet, this, _1 );
myProp.Get = boost::bind( &FxMathView::PropertyGet, this );

RegisterProperty( L"Example property", &myProp );

Die Properties müssten natürlich noch irgendwie ein bissl um Typ- oder Metainformation oder sowas angereichert werden, um besondere Eingabemöglichkeiten im Eigenschaftenfenster anzubieten.

Da hab ich nun gesessen und mich gefreut, man könnte ja auch toll Animationen zusammenschustern über solche "Eigenschaften" etc.. Aber tut man sich damit einen gefallen?

Eine andere Lösung wäre, einfach das Füllen der Eigenschaftenseite dem Objekt selber zu überlassen. Wenn es selektierbar ist, dann enthält es eine Funktion, der man das Eigenschaftenfenster übergibt und die dieses dann füllt.

Was meint ihr, sollten die Objekte über eine Schnittstelle Information nach außen geben (wie im Property-Beispiel) oder sollten sie sich selber darum kümmern, die Eigenschaftenseite zu füllen (sowas wie FillPropertiesPage( PropertiesPage& p) ).

Bin für alle Ansichten - am besten mit Gründen, die mir neue Gedankengänge näherbringen - sehr dankbar!

Deci