[C++] PropertyGrid und aufklappbare Collection

[VBFreak]

Hallo Ihr,

ich hab hier ein kleines Problemin meinen C++-Projekt mit einem PropertyGrid und einem Objekt mit einer Collection.

Ausgangsituation:

Mein Objekt im PropertyGrid hat zur Laufzeit folgende Struktur

Objekt (Klasse ModulSetting)

• Name = "Name des Objektes"
• Element-Collection (Klasse ParameterList)
  • Element 1 (Klasse DotNetParameter)
    • Name = "Name von Element 1"
    • Type = Enum-Wert
    • Value = "Wert von Element 1"
  • Element 2 (Klasse DotNetParameter)
    • Name = "Name von Element 2"
    • Type = Enum-Wert
    • Value = "Wert von Element 2"

Mein Problem:

Im PropertyGrid werden nicht die Elemente angezeigt, sondern nur Infos zu Capacity und Count:

Objekt (Klasse ModulSetting)

• Name = "Name des Objektes"
• Element-Collection (Klasse ParameterList)
  • Capacity = 4 (editierbar)
  • Count = 2 (ReadOnly)

So sieht mein Code für die Klassen bisher aus:

ModulSetting-Klasse

public ref class ModulSetting
	{
	private: System::String^ m_Name;
	private: ParameterList^ Inputs;
	public:
		ModulSetting(void)
		{
			this->m_Instance = modul;
			this->m_Name ="Das Modul";
			this->Inputs = gcnew ParameterList();

			//Folgende Zeilen Simulieren nur einen Parameter. Später kommen diese Informationen des std::vector<InputOutputParameters> über eine C-native Klasse und entfallen dann
			InputOutputParameter param;
			Description descr;

			param.sName = "Input 1";
			param.sValue= "0x123456";
			param.ParameterType = Image;
			
			std::vector<InputOutputParameter> *InputParams = new std::vector<InputOutputParameter>();

			InputParams->push_back(param);

			param.sName = "Input 2";
			param.sValue= "Value 2";
			param.ParameterType = Float;

			InputParams->push_back(param);

			for(unsigned int i = 0; i < InputParams->size(); i++)
			{
				param = InputParams->at(i);
				DotNetInputOutputParameter^ DNParam = gcnew DotNetInputOutputParameter(param);
				Inputs->Add(DNParam);
			}
			InputParams->clear();
			delete InputParams;
		}
	    public:

			property System::String^ Name 
			{
				System::String^ get(){return this->m_Name;}
				void set(System::String^ val){this->m_Name = val;}
			}

		[TypeConverter(System::ComponentModel::ExpandableObjectConverter::typeid)]
		property ParameterList^ InputParameters
		{
			ParameterList^  get() {return this->Inputs;}
		}
	};

ParameterList-Klasse:

public ref class ParameterList : public System::Collections::CollectionBase
	{
	public:
		ParameterList(void)
		{}

		void Add(DotNetInputOutputParameter^ param)
		{
		   this->List->Add(param);
		}

		void Remove(DotNetInputOutputParameter^ param)
		{
		   this->List->Remove(param);
		}

		property DotNetInputOutputParameter^ default[int]
		{
			DotNetInputOutputParameter^ get(int i) {return dynamic_cast<DotNetInputOutputParameter^>(this->List[i]);}
		}
	};

DotNetInputOutputParameter-Klasse

[TypeConverter(System::ComponentModel::ExpandableObjectConverter::typeid)]
	public ref class DotNetInputOutputParameter
	{
	private: InputOutputParameter* parameter;
	public:
		DotNetInputOutputParameter(InputOutputParameter param)
		{
			this->parameter =  new InputOutputParameter();
			this->parameter->sName         = param.sName; // =  std::string
			this->parameter->sValue        = param.sValue; // = std::string
			this->parameter->ParameterType = param.ParameterType; //Wert einer C-nativen Enum

		}
		~DotNetInputOutputParameter(System::Void)
		{
			delete this->parameter;
		}

		property System::String^ Name{
			System::String^ get(){ return gcnew System::String(this->parameter->sName.c_str());}
		}

		property eTypeOfParameter Type{
			eTypeOfParameter get(){ return this->parameter->ParameterType;}
		}

		property System::String^ Value{
			System::String^ get(){ return gcnew System::String(this->parameter->sValue.c_str());}
		}
	};

Was fehlt mir noch, damit die Collection beim Ausklappen nicht Capacity und Count sondern ihre Elemente anzeigt?
Wäre toll, wenn ihr mir da mit einer kurzen Erklärung zeigen könntet, was ich noch brauche.

Gruß,
VBFreak

 

[Spyke]

Hab jetzt kein Visual Studio hier aber wenn ichs noch richtig in Erinnerung habe müsstest du einen eigenen TypeConverter machen der dann die Anzeige der Einträge übernimmt.

Glaube am einfachsten vom ExpandableObjectConverter ableiten, und dann später deinen abgeleiteten im TypeConverterAttribute angeben.