C++ LabelPtr::BindText方法代码示例

void ReflectVectorInterpreter::InterpretField(const Field* field, const std::vector<Reflect::Element*>& instances, Container* parent)
{
    if ( field->m_Flags & FieldFlags::Hide )
    {
        return;
    }

    // create the container
    ContainerPtr container = CreateControl< Container >();
    parent->AddChild( container );

    // create the label
    LabelPtr label = CreateControl< Label >();
    container->AddChild( label );
    label->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );

    tstring temp;
    bool converted = Helium::ConvertString( field->m_UIName, temp );
    HELIUM_ASSERT( converted );

    label->BindText( temp );

    // compute dimensions
    int dimensions = 2;
    if ( field->m_SerializerID == Reflect::GetType<Vector3Serializer>() )
    {
        dimensions += 1;
    }
    if ( field->m_SerializerID == Reflect::GetType<Vector4Serializer>() )
    {
        dimensions += 2;
    }

    // create the dimension ui
    for ( int offset = 0; offset < dimensions*4; offset += 4 )
    {
        // create the serializers
        std::vector<Reflect::Serializer*> data;
        std::vector<Reflect::Element*>::const_iterator itr = instances.begin();
        std::vector<Reflect::Element*>::const_iterator end = instances.end();
        for ( ; itr != end; ++itr )
        {
            SerializerPtr s = new F32Serializer ();

            s->ConnectField(*itr, field, offset); 

            m_Serializers.push_back(s);

            data.push_back(s);
        }

        // create the text box
        ValuePtr value = CreateControl< Value >();
        container->AddChild( value );
        value->a_IsReadOnly.Set( ( field->m_Flags & FieldFlags::ReadOnly ) == FieldFlags::ReadOnly );
        value->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );

        // bind the ui to the serializers
        value->Bind( new MultiStringFormatter<Serializer>( data ) );
    }
}

//.........这里部分代码省略.........
            choice->a_IsDropDown.Set( true );
            choice->a_IsReadOnly.Set( readOnly );

            container->AddChild(choice);
        }
        else
        {
            if ( field->m_DataClass == Reflect::GetClass<BoolData>() )
            {
                CheckBoxPtr checkBox = CreateControl<CheckBox>();
                checkBox->a_IsReadOnly.Set( readOnly );
                checkBox->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );
                container->AddChild( checkBox );
            }
            else
            {
                ValuePtr value = CreateControl<Value>();
                value->a_IsReadOnly.Set( readOnly );
                value->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );
                container->AddChild( value );
            }
        }
    }

    //
    // Setup label
    //

    LabelPtr label = NULL;

    {
        V_Control::const_iterator itr = container->GetChildren().begin();
        V_Control::const_iterator end = container->GetChildren().end();
        for( ; itr != end; ++itr )
        {
            Label* label = Reflect::SafeCast<Label>( *itr );
            if (label)
            {
                break;
            }
        }
    }

    if (!label.ReferencesObject())
    {
        label = CreateControl<Label>();

        tstring temp;
        field->GetProperty( TXT( "UIName" ), temp );
        if ( temp.empty() )
        {
            bool converted = Helium::ConvertString( field->m_Name, temp );
            HELIUM_ASSERT( converted );
        }

        label->BindText( temp );
        label->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );

        container->InsertChild(0, label);
    }

    //
    // Bind data
    //

    std::vector<Data*> ser;

    {
        std::vector<Reflect::Object*>::const_iterator itr = instances.begin();
        std::vector<Reflect::Object*>::const_iterator end = instances.end();
        for ( ; itr != end; ++itr )
        {
            DataPtr s = field->CreateData();

            if (!s->IsClass(Reflect::GetClass<ContainerData>()))
            {
                s->ConnectField(*itr, field);

                ser.push_back(s);

                m_Datas.push_back(s);
            }
        }
    }

    Helium::SmartPtr< MultiStringFormatter<Data> > data = new MultiStringFormatter<Data>( ser );

    container->Bind( data );

    //
    // Set default
    //

    DataPtr defaultData = field->CreateDefaultData();
    if (defaultData.ReferencesObject())
    {
        tstringstream defaultStream;
        *defaultData >> defaultStream;
        container->a_Default.Set( defaultStream.str() );
    }

void ReflectStlVectorInterpreter::InterpretField(const Field* field, const std::vector<Reflect::Object*>& instances, Container* parent)
{
    if (field->m_Flags & FieldFlags::Hide)
    {
        return;
    }

    // create the label
    ContainerPtr labelContainer = CreateControl<Container>();
    parent->AddChild( labelContainer );
    LabelPtr label = CreateControl< Label >();
    label->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );
    labelContainer->AddChild( label );

    tstring temp;
    field->GetProperty( TXT( "UIName" ), temp );
    if ( temp.empty() )
    {
        bool converted = Helium::ConvertString( field->m_Name, temp );
        HELIUM_ASSERT( converted );
    }

    label->BindText( temp );

    // create the list view
    ContainerPtr listContainer = CreateControl<Container>();
    parent->AddChild( listContainer );
    ListPtr list = CreateControl<List>();
    list->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );
    listContainer->AddChild( list );

    // create the buttons
    ButtonPtr addButton;
    ButtonPtr removeButton;
    ButtonPtr upButton;
    ButtonPtr downButton;
    if ( !(field->m_Flags & FieldFlags::ReadOnly) )
    {
        addButton = AddAddButton( list );
        removeButton = AddRemoveButton( list );
        upButton = AddMoveUpButton( list );
        downButton = AddMoveDownButton( list );
    }

    // add the buttons to the container
    ContainerPtr buttonContainer = CreateControl<Container>();
    parent->AddChild( buttonContainer );
    if ( addButton )
    {
        buttonContainer->AddChild( addButton );
    }
    if ( removeButton )
    {
        buttonContainer->AddChild( removeButton );
    }
    if ( upButton )
    {
        buttonContainer->AddChild( upButton );
    }
    if ( downButton )
    {
        buttonContainer->AddChild( downButton );
    }

    // create the data objects
    std::vector<Reflect::Object*>::const_iterator itr = instances.begin();
    std::vector<Reflect::Object*>::const_iterator end = instances.end();
    for ( ; itr != end; ++itr )
    {
        DataPtr s = field->CreateData();

        OnCreateFieldData( s );

        s->ConnectField(*itr, field);

        m_Datas.push_back(s);
    }

    // bind the ui to the data objects
    Helium::SmartPtr< MultiStringFormatter<Data> > data = new MultiStringFormatter<Reflect::Data>( (std::vector<Reflect::Data*>&)m_Datas );
    list->Bind( data );

    // setup the default value
    DataPtr defaultData = field->CreateDefaultData();
    if (defaultData)
    {
        tstringstream defaultStream;
        *defaultData >> defaultStream;
        list->a_Default.Set( defaultStream.str() );
    }
}

//.........这里部分代码省略.........
		value->a_IsReadOnly.Set( readOnly );
		value->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );
		container->AddChild( value );
	}


	//
	// Setup label
	//

	LabelPtr label = NULL;

	{
		std::vector< ControlPtr >::const_iterator itr = container->GetChildren().begin();
		std::vector< ControlPtr >::const_iterator end = container->GetChildren().end();
		for( ; itr != end; ++itr )
		{
			Label* label = Reflect::SafeCast<Label>( *itr );
			if (label)
			{
				break;
			}
		}
	}

	if (!label.ReferencesObject())
	{
		label = CreateControl< Label >();

		std::string temp;
		field->GetProperty( TXT( "UIName" ), temp );
		if ( temp.empty() )
		{
			bool converted = Helium::ConvertString( field->m_Name, temp );
			HELIUM_ASSERT( converted );
		}

		label->BindText( temp );
		label->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );

		container->InsertChild(0, label);
	}

	//
	// Create type m_FinderSpecific data bound to this and additional objects
	//

	std::vector<Data*> datas;

	{
		std::vector<Reflect::Object*>::const_iterator itr = objects.begin();
		std::vector<Reflect::Object*>::const_iterator end = objects.end();
		for ( ; itr != end; ++itr )
		{
			Data s = field->CreateData();

			if (s->IsA(Reflect::GetMetaClass<ContainerData>()))
			{
				return;
			}

			s->ConnectField(*itr, field);

			datas.push_back(s);

			m_Datas.push_back(s);
		}
	}

	//
	// Create data and bind
	//

	Helium::SmartPtr< MultiStringFormatter<Data> > data = new MultiStringFormatter<Data>( datas );

	if (changingDelegate.Valid())
	{
		data->AddChangingListener( changingDelegate );
	}

	{
		std::vector<ContainerPtr>::const_iterator itr = groups.begin();
		std::vector<ContainerPtr>::const_iterator end = groups.end();
		for ( ; itr != end; ++itr )
		{
			(*itr)->Bind( data );
		}
	}

	//
	// Set default
	//

	Data defaultData = field->CreateDefaultData();
	if (defaultData.ReferencesObject())
	{
		std::stringstream defaultStream;
		*defaultData >> defaultStream;
		container->a_Default.Set( defaultStream.str() );
	}

void ReflectInterpreter::InterpretColorField( const std::vector< Reflect::Pointer >& pointers, Reflect::Translator* translator, const Reflect::Field* field, Container* parent )
{
#if INSPECT_REFACTOR
	ContainerPtr container = CreateControl< Container >();
	parent->AddChild( container );

	LabelPtr label = CreateControl< Label >();

	std::string temp;
	field->GetProperty( TXT( "UIName" ), temp );
	if ( temp.empty() )
	{
		bool converted = Helium::ConvertString( field->m_Name, temp );
		HELIUM_ASSERT( converted );
	}

	label->BindText( temp );
	label->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );

	container->AddChild( label );

	bool color3 = field->m_ValueType == Reflect::GetMetaStruct<Color3>() || field->m_ValueType == Reflect::GetMetaStruct<HDRColor3>();
	bool color4 = field->m_ValueType == Reflect::GetMetaStruct<Color4>() || field->m_ValueType == Reflect::GetMetaStruct<HDRColor4>();
	HELIUM_ASSERT( !(color3 && color4) ); // we shouldn't ever have both!

	if ( color3 || color4 )
	{
		std::vector<Data*> datas;
		std::vector<Reflect::Object*>::const_iterator itr = objects.begin();
		std::vector<Reflect::Object*>::const_iterator end = objects.end();
		for ( ; itr != end; ++itr )
		{
			Data s;

			if ( color3 )
			{
				s = new Color3Data();
			}

			if ( color4 )
			{
				s = new Color4Data();
			}

			if (s.ReferencesObject())
			{
				s->ConnectField( *itr, field );
				datas.push_back( s );
				m_Datas.push_back( s );
			}
		}

		if ( !m_Datas.empty() )
		{
			ColorPickerPtr colorPicker = CreateControl<ColorPicker>();
			container->AddChild( colorPicker );

			colorPicker->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );

			bool readOnly = ( field->m_Flags & FieldFlags::ReadOnly ) == FieldFlags::ReadOnly;
			colorPicker->a_IsReadOnly.Set( readOnly );

			DataBindingPtr data = new MultiStringFormatter<Data>( datas );
			colorPicker->Bind( data );

			if ( color3 )
			{
				colorPicker->a_Alpha.Set( false );
			}

			if ( color4 )
			{
				colorPicker->a_Alpha.Set( true );

				SliderPtr slider = CreateControl<Slider>();
				container->AddChild( slider );
				slider->a_Min.Set( 0.0 );
				slider->a_Max.Set( 255.0f );
				slider->a_IsReadOnly.Set( readOnly );
				slider->a_HelpText.Set( TXT( "Sets the alpha value for the color." ) );

				ValuePtr value = CreateControl<Value>();
				container->AddChild( value );
				value->a_IsReadOnly.Set( readOnly );
				value->a_HelpText.Set( TXT( "Sets the alpha value for the color." ) );

				std::vector<Data*> alphaSer;
				std::vector<Reflect::Object*>::const_iterator itr = objects.begin();
				std::vector<Reflect::Object*>::const_iterator end = objects.end();
				for ( ; itr != end; ++itr )
				{
					Data s = new UInt8Data ();

					uintptr_t fieldAddress = (uintptr_t)(*itr) + field->m_Offset;

					Color4* col = (Color4*)fieldAddress;
					intptr_t offsetInField = (intptr_t)( &col->a ) - fieldAddress;
					s->ConnectField( *itr, field, offsetInField );

					alphaSer.push_back( s );
//.........这里部分代码省略.........

void ReflectInterpreter::InterpretBitfieldField( const std::vector< Reflect::Pointer >& pointers, Reflect::Translator* translator, const Reflect::Field* field, Container* parent )
{
	bool isEnumeration = field->m_Translator->IsA( Reflect::MetaIds::EnumerationTranslator );

	// If you hit this, you are misusing this interpreter
	HELIUM_ASSERT( isEnumeration );
	if ( !isEnumeration )
	{
		return;
	}

	if ( field->m_Flags & FieldFlags::Hide )
	{
		return;
	}

	// create the container
	ContainerPtr container = CreateControl<Container>();

	std::string temp;
	field->GetProperty( TXT( "UIName" ), temp );
	if ( temp.empty() )
	{
		bool converted = Helium::ConvertString( field->m_Name, temp );
		HELIUM_ASSERT( converted );
	}

	container->a_Name.Set( temp );

	parent->AddChild(container);

	// create the data objects
	std::vector<Data*> datas;
	for ( std::vector< Reflect::Pointer >::const_iterator itr = pointers.begin(), end = pointers.end(); itr != end; ++itr )
	{
		datas.push_back( new Data ( *itr, translator ) );
	}

	String defaultStr;
	Pointer defaultPtr ( field, field->m_Structure->m_Default, NULL );
	ScalarTranslator* scalar = Reflect::ReflectionCast< ScalarTranslator >( field->m_Translator );
	if ( scalar )
	{
		scalar->Print( defaultPtr, defaultStr );
	}

	const Reflect::MetaEnum* enumeration = Reflect::ReflectionCast< MetaEnum >( field->m_ValueType );

	// build the child gui elements
	bool readOnly = ( field->m_Flags & FieldFlags::ReadOnly ) == FieldFlags::ReadOnly;
	DynamicArray< Reflect::MetaEnum::Element >::ConstIterator enumItr = enumeration->m_Elements.Begin();
	DynamicArray< Reflect::MetaEnum::Element >::ConstIterator enumEnd = enumeration->m_Elements.End();
	for ( ; enumItr != enumEnd; ++enumItr )
	{
		ContainerPtr row = CreateControl< Container >();
		container->AddChild( row );

		LabelPtr label = CreateControl< Label >();
		label->a_HelpText.Set( enumItr->m_HelpText );
		label->BindText( enumItr->m_Name );
		row->AddChild( label );

		CheckBoxPtr checkbox = CreateControl< CheckBox >();
		checkbox->a_IsReadOnly.Set( readOnly );
		checkbox->a_HelpText.Set( enumItr->m_HelpText );
		
		// TODO: Compute correct default value
		checkbox->a_Default.Set( defaultStr.GetData() );
		checkbox->Bind( new MultiBitfieldStringFormatter ( &*enumItr, datas ) );
		row->AddChild( checkbox );
	}
}

void ReflectInterpreter::InterpretValueField( const std::vector< Reflect::Pointer >& pointers, Reflect::Translator* translator, const Field* field, Container* parent )
{
	if (field->m_Flags & FieldFlags::Hide)
	{
		return;
	}

	//
	// Create the ui we are generating
	//

	ContainerPtr container = CreateControl<Container>();

	bool readOnly = ( field->m_Flags & FieldFlags::ReadOnly ) == FieldFlags::ReadOnly;

	if ( field->m_ValueType && field->m_ValueType->IsA( MetaIds::MetaEnum ) )
	{
		const Reflect::MetaEnum* enumeration = Reflect::ReflectionCast< MetaEnum >( field->m_ValueType );

		ChoicePtr choice = CreateControl<Choice>();

		std::vector< ChoiceItem > items;
		items.resize( enumeration->m_Elements.GetSize() );

		DynamicArray< MetaEnum::Element >::ConstIterator itr = enumeration->m_Elements.Begin();
		DynamicArray< MetaEnum::Element >::ConstIterator end = enumeration->m_Elements.End();
		for ( size_t index=0; itr != end; ++itr, ++index )
		{
			ChoiceItem& item = items[index];

			item.m_Key = itr->m_Name;
			item.m_Data = itr->m_Name;
		}

		choice->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );
		choice->a_Items.Set( items );
		choice->a_IsDropDown.Set( true );
		choice->a_IsReadOnly.Set( readOnly );

		container->AddChild(choice);
	}
	else
	{
		ScalarTranslator* scalar = ReflectionCast< ScalarTranslator >( field->m_Translator );
		if ( scalar && scalar->m_Type == ScalarTypes::Boolean )
		{
			CheckBoxPtr checkBox = CreateControl<CheckBox>();
			checkBox->a_IsReadOnly.Set( readOnly );
			checkBox->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );
			container->AddChild( checkBox );
		}
		else
		{
			ValuePtr value = CreateControl<Value>();
			value->a_IsReadOnly.Set( readOnly );
			value->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );
			container->AddChild( value );
		}
	}

	//
	// Setup label
	//

	LabelPtr label = NULL;

	{
		std::vector< ControlPtr >::const_iterator itr = container->GetChildren().begin();
		std::vector< ControlPtr >::const_iterator end = container->GetChildren().end();
		for( ; itr != end; ++itr )
		{
			Label* label = Reflect::SafeCast<Label>( *itr );
			if (label)
			{
				break;
			}
		}
	}

	if (!label.ReferencesObject())
	{
		label = CreateControl<Label>();

		std::string temp;
		field->GetProperty( TXT( "UIName" ), temp );
		if ( temp.empty() )
		{
			bool converted = Helium::ConvertString( field->m_Name, temp );
			HELIUM_ASSERT( converted );
		}

		label->BindText( temp );
		label->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) );

		container->InsertChild(0, label);
	}

	//
	// Bind data
	//
//.........这里部分代码省略.........