LabelPtr Label::create(const std::string& font, const std::string& text, const Vector2& textAnchor) { LabelPtr result = std::make_shared<Label>(); result->init(font, text, textAnchor); return result; }
Label* Interpreter::AddLabel(const tstring& name) { LabelPtr control = new Label (); control->Bind( new StringFormatter<tstring>( new tstring( name ), true ) ); m_ContainerStack.Get().top()->AddChild(control); return control; }
PanelPtr SceneEditor::createEditorTab(SceneComponentEditorPtr Editor, IconManagerPtr TheIconManager) const { //Editor Icon ImageComponentPtr EditorIcon = TheIconManager->createIconImageComponent(Editor->getPresentationIconName()); if(EditorIcon == NullFC) { EditorIcon = ImageComponent::create(); } beginEditCP(EditorIcon, ImageComponent::ScaleFieldMask | ImageComponent::AlignmentFieldMask); EditorIcon->setAlignment(Vec2f(0.5f,0.5f)); EditorIcon->setScale(ImageComponent::SCALE_MIN_AXIS); endEditCP(EditorIcon, ImageComponent::ScaleFieldMask | ImageComponent::AlignmentFieldMask); //Editor Label LabelPtr TabLabel = Label::create(); beginEditCP(TabLabel, Label::TextFieldMask | Label::BordersFieldMask | Label::BackgroundsFieldMask | Label::AlignmentFieldMask); TabLabel->setBorders(NullFC); TabLabel->setBackgrounds(NullFC); TabLabel->setText(Editor->getPresentationName()); TabLabel->setAlignment(Vec2f(0.5f,0.5f)); endEditCP(TabLabel, Label::TextFieldMask | Label::BordersFieldMask | Label::BackgroundsFieldMask | Label::AlignmentFieldMask); //Tab PanelPtr Tab = Panel::createEmpty(); //Layout SpringLayoutPtr TabLayout = SpringLayout::create(); //Editor Icon TabLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, EditorIcon, 0, SpringLayoutConstraints::WEST_EDGE, Tab); TabLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, EditorIcon, 0, SpringLayoutConstraints::EAST_EDGE, Tab); TabLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, EditorIcon, 0, SpringLayoutConstraints::NORTH_EDGE, Tab); TabLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, EditorIcon, -1, SpringLayoutConstraints::NORTH_EDGE, TabLabel); //Editor Label TabLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, TabLabel, 0, SpringLayoutConstraints::WEST_EDGE, Tab); TabLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, TabLabel, 0, SpringLayoutConstraints::EAST_EDGE, Tab); TabLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, TabLabel, 0, SpringLayoutConstraints::SOUTH_EDGE, Tab); TabLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, TabLabel, LayoutSpring::height(TabLabel)); //Tab Layout //TabLayout->putConstraint(SpringLayoutConstraints::WIDTH_EDGE, Tab, LayoutSpring::max(TabLayout->getConstraint(SpringLayoutConstraints::WIDTH_EDGE,TabLabel),TabLayout->getConstraint(SpringLayoutConstraints::WIDTH_EDGE,EditorIcon))); //TabLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, Tab, LayoutSpring::sum(TabLayout->getConstraint(SpringLayoutConstraints::HEIGHT_EDGE,TabLabel),TabLayout->getConstraint(SpringLayoutConstraints::HEIGHT_EDGE,EditorIcon))); TabLayout->putConstraint(SpringLayoutConstraints::WIDTH_EDGE, Tab, LayoutSpring::width(Tab)); TabLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, Tab, LayoutSpring::height(Tab)); beginEditCP(Tab, Panel::ChildrenFieldMask | Panel::LayoutFieldMask | Panel::PreferredSizeFieldMask); Tab->getChildren().push_back(EditorIcon); Tab->getChildren().push_back(TabLabel); Tab->setLayout(TabLayout); Tab->setPreferredSize(Vec2f(70.0f,50.0f)); endEditCP(Tab, Panel::ChildrenFieldMask | Panel::LayoutFieldMask | Panel::PreferredSizeFieldMask); return Tab; }
LabelPtr toLabel(char* key, int keyLen, char* value, int valueLen) { LabelPtr label = new Label(); if (key != NULL) label->set_key(key, keyLen); if (value != NULL) label->set_value(value, valueLen); return label; }
ComponentPtr DefaultDialogComponentGenerator::getQuestionComponent(DialogInterfacePtr Parent, const boost::any& Value) { std::string questionString(""); try { questionString = lexical_cast(Value); } catch (boost::bad_lexical_cast &) { std::cout<<"Unable to display question"<<std::endl; } LabelPtr TheQuestionString = Label::Ptr::dcast(getQuestionPrototype()->shallowCopy()); beginEditCP(TheQuestionString, Label::TextFieldMask); TheQuestionString->setText(questionString); endEditCP(TheQuestionString, Label::TextFieldMask); return TheQuestionString; }
/***************************************************************************\ * Instance methods * \***************************************************************************/ ComponentPtr DefaultCaptionComponentGenerator::getCaptionComponent(CaptionPtr Parent, const boost::any& Value) { std::string CaptionSegment(""); try { CaptionSegment = lexical_cast(Value); } catch (boost::bad_lexical_cast &) { std::cout<<"Unable to display segment"<<std::endl; } LabelPtr TheCaptionSegment = Label::Ptr::dcast(getCaptionSegmentPrototype()->shallowCopy()); beginEditCP(TheCaptionSegment, Label::TextFieldMask); TheCaptionSegment->setText(CaptionSegment); endEditCP(TheCaptionSegment, Label::TextFieldMask); return TheCaptionSegment; }
void fromLabel(LabelPtr l, char** key, int* keyLen, char** value, int* valueLen) { if (l->has_key()) { std::string* k = l->mutable_key(); *key = (char*) k->data(); *keyLen = k->size(); } if (l->has_value()) { std::string* v = l->mutable_value(); *value = (char*) v->data(); *valueLen = v->size(); } }
void NepomukTrack::removeLabel( const LabelPtr &label ) { const NepomukLabel *nlabel = dynamic_cast<const NepomukLabel*>(label.data()); if( !nlabel ) return; resource()->removeProperty( Soprano::Vocabulary::NAO::hasTag(), nlabel->tag() ); notifyObservers(); }
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 // 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 ) ); } Helium::SmartPtr< MultiStringFormatter<Data> > data = new MultiStringFormatter<Data>( datas, true ); container->Bind( data ); // // Set default // 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 ); } container->a_Default.Set( defaultStr.GetData() ); // // Close // parent->AddChild(container); }
void ReflectValueInterpreter::InterpretField(const Field* field, const std::vector<Reflect::Object*>& instances, 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; // // Parse // tstring fieldUI; field->GetProperty( TXT( "UIScript" ), fieldUI ); bool result = Script::Parse(fieldUI, this, parent->GetCanvas(), container, field->m_Flags); if (!result) { if ( field->m_DataClass == Reflect::GetClass<EnumerationData>() ) { ChoicePtr choice = CreateControl<Choice>(); const Reflect::Enumeration* enumeration = Reflect::ReflectionCast< Enumeration >( field->m_Type ); std::vector< ChoiceItem > items; items.resize( enumeration->m_Elements.GetSize() ); DynArray< EnumerationElement >::ConstIterator itr = enumeration->m_Elements.Begin(); DynArray< EnumerationElement >::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 { 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 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 ) ); } }
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() ); } }
int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // Set up Window TutorialWindowEventProducer = createDefaultWindowEventProducer(); WindowPtr MainWindow = TutorialWindowEventProducer->initWindow(); TutorialWindowEventProducer->setDisplayCallback(display); TutorialWindowEventProducer->setReshapeCallback(reshape); TutorialKeyListener TheKeyListener; TutorialWindowEventProducer->addKeyListener(&TheKeyListener); TutorialUpdateListener TheTutorialUpdateListener; TutorialWindowEventProducer->addUpdateListener(&TheTutorialUpdateListener); //Create Start and stop buttons for the caption ButtonPtr StartButton = osg::Button::create(); ButtonPtr StopButton = osg::Button::create(); ButtonPtr PauseButton = osg::Button::create(); UIFontPtr ButtonFont = osg::UIFont::create(); beginEditCP(ButtonFont, UIFont::SizeFieldMask); ButtonFont->setSize(16); endEditCP(ButtonFont, UIFont::SizeFieldMask); beginEditCP(StartButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask | Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask); StartButton->setMinSize(Vec2f(50, 25)); StartButton->setMaxSize(Vec2f(200, 100)); StartButton->setPreferredSize(Vec2f(100, 50)); StartButton->setToolTipText("This will start playing the caption!"); StartButton->setText("START"); StartButton->setFont(ButtonFont); StartButton->setTextColor(Color4f(1.0, 0.0, 0.0, 1.0)); StartButton->setRolloverTextColor(Color4f(1.0, 0.0, 1.0, 1.0)); StartButton->setActiveTextColor(Color4f(1.0, 0.0, 0.0, 1.0)); StartButton->setAlignment(Vec2f(0.25,0.5)); endEditCP(StartButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask | Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask); beginEditCP(StopButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask | Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask); StopButton->setMinSize(Vec2f(50, 25)); StopButton->setMaxSize(Vec2f(200, 100)); StopButton->setPreferredSize(Vec2f(100, 50)); StopButton->setToolTipText("This will stop the caption and reset it!"); StopButton->setText("STOP"); StopButton->setFont(ButtonFont); StopButton->setTextColor(Color4f(1.0, 0.0, 0.0, 1.0)); StopButton->setRolloverTextColor(Color4f(1.0, 0.0, 1.0, 1.0)); StopButton->setActiveTextColor(Color4f(1.0, 0.0, 0.0, 1.0)); StopButton->setAlignment(Vec2f(0.75,0.5)); endEditCP(StopButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask | Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask); beginEditCP(PauseButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask | Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask); PauseButton->setMinSize(Vec2f(50, 25)); PauseButton->setMaxSize(Vec2f(200, 100)); PauseButton->setPreferredSize(Vec2f(100, 50)); PauseButton->setToolTipText("This will Pause the caption!"); PauseButton->setText("PAUSE"); PauseButton->setFont(ButtonFont); PauseButton->setTextColor(Color4f(1.0, 0.0, 0.0, 1.0)); PauseButton->setRolloverTextColor(Color4f(1.0, 0.0, 1.0, 1.0)); PauseButton->setActiveTextColor(Color4f(1.0, 0.0, 0.0, 1.0)); PauseButton->setAlignment(Vec2f(0.5,0.5)); endEditCP(PauseButton, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask | Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask | Button::AlignmentFieldMask); StartButtonActionListener TheStartButtonActionListener; StartButton->addActionListener(&TheStartButtonActionListener); StopButtonActionListener TheStopButtonActionListener; StopButton->addActionListener(&TheStopButtonActionListener); PauseButtonActionListener ThePauseButtonActionListener; PauseButton->addActionListener(&ThePauseButtonActionListener); // Create the SimpleSceneManager helper mgr = new SimpleSceneManager; // Tell the Manager what to manage mgr->setWindow(MainWindow); // Make Torus Node (creates Torus in background of scene) NodePtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus scene = osg::Node::create(); beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask); scene->setCore(osg::Group::create()); scene->addChild(TorusGeometryNode); endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask); // Create the Graphics GraphicsPtr TutorialGraphics = osg::Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); LayoutPtr MainInternalWindowLayout = osg::FlowLayout::create(); PanelPtr CaptionContainer = osg::Panel::create(); beginEditCP(CaptionContainer, Panel::PreferredSizeFieldMask | Panel::LayoutFieldMask); CaptionContainer->setPreferredSize(Pnt2f(250.0,30.0)); CaptionContainer->setLayout(MainInternalWindowLayout); endEditCP(CaptionContainer, Panel::PreferredSizeFieldMask | Panel::LayoutFieldMask); //Initialize the Sound Manager SoundManager::the()->attachUpdateProducer(TutorialWindowEventProducer); TutorialSound = SoundManager::the()->createSound(); beginEditCP(TutorialSound, Sound::FileFieldMask | Sound::VolumeFieldMask | Sound::StreamingFieldMask | Sound::LoopingFieldMask); TutorialSound->setFile(Path("./Data/captionSoundFile.ogg")); TutorialSound->setVolume(1.0); TutorialSound->setStreaming(true); TutorialSound->setLooping(0); endEditCP(TutorialSound, Sound::FileFieldMask | Sound::VolumeFieldMask | Sound::StreamingFieldMask | Sound::LoopingFieldMask); // Create the Caption TutorialCaption = osg::Caption::create(); //Add the segments of text to be displayed TutorialCaption->captionSegment("Listeners can be used for a variety",1.7,3.4); TutorialCaption->captionSegment("of different applications.",3.4,4.7); TutorialCaption->captionSegment("In this tutorial we will",5.0,6.35); TutorialCaption->captionSegment("simply be changing the background though.",6.35,8.0); TutorialCaption->captionSegment("First we will change the",8.8,10.2); TutorialCaption->captionSegment("torus on screen to a sphere.",10.2,11.75); TutorialCaption->captionSegment("By timing things correctly we can make",12.7,14.6); TutorialCaption->captionSegment("the changes right as the word is spoken.",14.6,16.75); TutorialCaption->captionSegment("Such as changing the sphere to a cube",17.3,20.0); TutorialCaption->captionSegment("but personally I would prefer",20.33,21.65); TutorialCaption->captionSegment("the background to be blank.",21.65,22.8); TutorialCaption->captionSegment("Much better!",23.8,25.0); //Add the tutorial Caption Listener to the Caption that was set up for the tutorial TutorialCaptionListener TheCaptionListener; TutorialCaption->addCaptionListener(&TheCaptionListener); //Create the Caption component Generator TutorialCapGen = DefaultCaptionComponentGenerator::create(); TutorialCaption->attachWindowEventProducer(TutorialWindowEventProducer); beginEditCP(TutorialCaption, Caption::ParentContainerFieldMask | Caption::ComponentGeneratorFieldMask | Caption::CaptionDialogSoundFieldMask); TutorialCaption->setParentContainer(CaptionContainer); TutorialCaption->setComponentGenerator(TutorialCapGen); TutorialCaption->setCaptionDialogSound(TutorialSound); endEditCP(TutorialCaption, Caption::ParentContainerFieldMask | Caption::ComponentGeneratorFieldMask | Caption::CaptionDialogSoundFieldMask); //Create and modify the Label prototype that will be used for the caption LabelPtr LabelPrototype = Label::create(); LabelPrototype->setAlignment(Pnt2f(0.5f,0.5f)); LabelPrototype->setPreferredSize(Pnt2f(250.0,30.0)); //Add the prototype to the Generator for use beginEditCP(TutorialCapGen, DefaultCaptionComponentGenerator::CaptionSegmentPrototypeFieldMask); TutorialCapGen->setCaptionSegmentPrototype(LabelPrototype); endEditCP(TutorialCapGen, DefaultCaptionComponentGenerator::CaptionSegmentPrototypeFieldMask); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerPtr MainInternalWindowBackground = osg::ColorLayer::create(); MainInternalWindow = osg::InternalWindow::create(); beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask); beginEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); MainInternalWindow->getChildren().push_back(CaptionContainer); MainInternalWindow->getChildren().push_back(StartButton); MainInternalWindow->getChildren().push_back(StopButton); MainInternalWindow->getChildren().push_back(PauseButton); endEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask); // Create the Drawing Surface UIDrawingSurfacePtr TutorialDrawingSurface = UIDrawingSurface::create(); beginEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindowEventProducer); endEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundPtr TutorialUIForeground = osg::UIForeground::create(); beginEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); endEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask); mgr->setRoot(scene); // Add the UI Foreground Object to the Scene ViewportPtr TutorialViewport = mgr->getWindow()->getPort(0); beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask); TutorialViewport->getForegrounds().push_back(TutorialUIForeground); beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask); // Show the whole Scene mgr->showAll(); SoundManager::the()->setCamera(mgr->getCamera()); Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f); Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5); TutorialWindowEventProducer->openWindow(WinPos, WinSize, "05Caption"); //Enter main Loop TutorialWindowEventProducer->mainLoop(); osgExit(); return 0; }
int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // Set up Window TutorialWindowEventProducer = createDefaultWindowEventProducer(); WindowPtr MainWindow = TutorialWindowEventProducer->initWindow(); TutorialWindowEventProducer->setDisplayCallback(display); TutorialWindowEventProducer->setReshapeCallback(reshape); TutorialKeyListener TheKeyListener; TutorialWindowEventProducer->addKeyListener(&TheKeyListener); TutorialUpdateListener TheTutorialUpdateListener; TutorialWindowEventProducer->addUpdateListener(&TheTutorialUpdateListener); // Create the SimpleSceneManager helper mgr = new SimpleSceneManager; // Tell the Manager what to manage mgr->setWindow(MainWindow); // Make Torus Node (creates Torus in background of scene) NodePtr TorusGeometryNode = makeTorus(.5, 2, 16, 16); // Make Main Scene Node and add the Torus scene = osg::Node::create(); beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask); scene->setCore(osg::Group::create()); scene->addChild(TorusGeometryNode); endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask); // Create the Graphics GraphicsPtr TutorialGraphics = osg::Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); DefaultDialogComponentGeneratorPtr TutorialDialogGenerator = DefaultDialogComponentGenerator::create(); ButtonFont = osg::UIFont::create(); beginEditCP(ButtonFont, UIFont::SizeFieldMask); ButtonFont->setSize(16); endEditCP(ButtonFont, UIFont::SizeFieldMask); ButtonPtr Response = osg::Button::create(); beginEditCP(Response, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask | Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask ); Response->setMinSize(Vec2f(50, 25)); Response->setMaxSize(Vec2f(200, 100)); Response->setPreferredSize(Vec2f(100, 50)); Response->setToolTipText("These buttons are for selecting a response!"); Response->setFont(ButtonFont); Response->setTextColor(Color4f(1.0, 0.0, 0.0, 1.0)); Response->setRolloverTextColor(Color4f(1.0, 0.0, 1.0, 1.0)); Response->setActiveTextColor(Color4f(1.0, 0.0, 0.0, 1.0)); endEditCP(Response, Button::MinSizeFieldMask | Button::MaxSizeFieldMask | Button::PreferredSizeFieldMask | Button::ToolTipTextFieldMask | Button::TextFieldMask | Button::FontFieldMask | Button::TextColorFieldMask | Button::RolloverTextColorFieldMask | Button::ActiveTextColorFieldMask ); LabelPtr LabelPrototype = Label::create(); LabelPrototype->setAlignment(Pnt2f(0.5f,0.5f)); LabelPrototype->setPreferredSize(Pnt2f(250.0,30.0)); DialogInterfacePtr TutorialDialogInterface = osg::DialogInterface::create(); beginEditCP(TutorialDialogGenerator, DefaultDialogComponentGenerator::ResponseButtonPrototypeFieldMask | DefaultDialogComponentGenerator::QuestionPrototypeFieldMask); TutorialDialogGenerator->setResponseButtonPrototype(Response); TutorialDialogGenerator->setQuestionPrototype(LabelPrototype); endEditCP(TutorialDialogGenerator, DefaultDialogComponentGenerator::ResponseButtonPrototypeFieldMask | DefaultDialogComponentGenerator::QuestionPrototypeFieldMask); TutorialDialog = osg::DialogHierarchy::create(); beginEditCP(TutorialDialog, DialogHierarchy::DualNodeStyleFieldMask); TutorialDialog->setDualNodeStyle(true); endEditCP(TutorialDialog, DialogHierarchy::DualNodeStyleFieldMask); DialogPtr rootDialog = TutorialDialog->addDialog("Which do you prefer?", 0.0, NullFC, true, NullFC); DialogPtr RootDialogChildA = TutorialDialog->addDialog("Foreground", 0.0, NullFC, false, rootDialog); DialogPtr RootDialogChildB = TutorialDialog->addDialog("Background", 0.0, NullFC, false, rootDialog); DialogPtr SelectableDialogChildA = TutorialDialog->addDialog("What color would you like the forground to be?", 0.0, NullFC, true, RootDialogChildA); DialogPtr SelectableDialogChildB = TutorialDialog->addDialog("What object do you want to be in the background?", 0.0, NullFC, true, RootDialogChildB); ADialogChildA = TutorialDialog->addDialog("Blue", 0.0, NullFC, false, SelectableDialogChildA); ADialogChildB = TutorialDialog->addDialog("Red", 0.0, NullFC, false, SelectableDialogChildA); BDialogChildA = TutorialDialog->addDialog("Square", 0.0, NullFC, false, SelectableDialogChildB); BDialogChildB = TutorialDialog->addDialog("Sphere", 0.0, NullFC, false, SelectableDialogChildB); DialogPtr RestartEnd1 = TutorialDialog->addDialog("What would you like to do?", 0.0, NullFC, true, ADialogChildA); DialogPtr RestartEnd2 = TutorialDialog->addDialog("What would you like to do?", 0.0, NullFC, true, ADialogChildB); DialogPtr RestartEnd3 = TutorialDialog->addDialog("What would you like to do?", 0.0, NullFC, true, BDialogChildA); DialogPtr RestartEnd4 = TutorialDialog->addDialog("What would you like to do?", 0.0, NullFC, true, BDialogChildB); Restart1 = TutorialDialog->addDialog("Restart", 0.0, NullFC, false, RestartEnd1); End1 = TutorialDialog->addDialog("End", 0.0, NullFC, false, RestartEnd1); Restart2 = TutorialDialog->addDialog("Restart", 0.0, NullFC, false, RestartEnd2); End2 = TutorialDialog->addDialog("End", 0.0, NullFC, false, RestartEnd2); Restart3 = TutorialDialog->addDialog("Restart", 0.0, NullFC, false, RestartEnd3); End3 = TutorialDialog->addDialog("End", 0.0, NullFC, false, RestartEnd3); Restart4 = TutorialDialog->addDialog("Restart", 0.0, NullFC, false, RestartEnd4); End4 = TutorialDialog->addDialog("End", 0.0, NullFC, false, RestartEnd4); TutorialDialogListener TheTutorialDialogListener; rootDialog->addDialogListener(&TheTutorialDialogListener); RootDialogChildA->addDialogListener(&TheTutorialDialogListener); RootDialogChildB->addDialogListener(&TheTutorialDialogListener); ADialogChildA->addDialogListener(&TheTutorialDialogListener); ADialogChildB->addDialogListener(&TheTutorialDialogListener); BDialogChildA->addDialogListener(&TheTutorialDialogListener); BDialogChildB->addDialogListener(&TheTutorialDialogListener); Restart1->addDialogListener(&TheTutorialDialogListener); End1->addDialogListener(&TheTutorialDialogListener); Restart2->addDialogListener(&TheTutorialDialogListener); End2->addDialogListener(&TheTutorialDialogListener); Restart3->addDialogListener(&TheTutorialDialogListener); End3->addDialogListener(&TheTutorialDialogListener); Restart4->addDialogListener(&TheTutorialDialogListener); End4->addDialogListener(&TheTutorialDialogListener); SelectableDialogChildA->addDialogListener(&TheTutorialDialogListener); SelectableDialogChildB->addDialogListener(&TheTutorialDialogListener); RestartEnd1->addDialogListener(&TheTutorialDialogListener); RestartEnd2->addDialogListener(&TheTutorialDialogListener); RestartEnd3->addDialogListener(&TheTutorialDialogListener); RestartEnd4->addDialogListener(&TheTutorialDialogListener); LayoutPtr MainInternalWindowLayout = osg::FlowLayout::create(); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow MainInternalWindowBackground = osg::ColorLayer::create(); MainInternalWindow = osg::InternalWindow::create(); beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask); beginEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); endEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask); beginEditCP(TutorialDialogInterface, DialogInterface::ComponentGeneratorFieldMask | DialogInterface::ParentContainerFieldMask | DialogInterface::SourceDialogHierarchyFieldMask); TutorialDialogInterface->setComponentGenerator(TutorialDialogGenerator); TutorialDialogInterface->setParentContainer(MainInternalWindow); TutorialDialogInterface->setSourceDialogHierarchy(TutorialDialog); endEditCP(TutorialDialogInterface, DialogInterface::ComponentGeneratorFieldMask | DialogInterface::ParentContainerFieldMask | DialogInterface::SourceDialogHierarchyFieldMask); // Create the Drawing Surface UIDrawingSurfacePtr TutorialDrawingSurface = UIDrawingSurface::create(); beginEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindowEventProducer); endEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundPtr TutorialUIForeground = osg::UIForeground::create(); beginEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); endEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask); mgr->setRoot(scene); // Add the UI Foreground Object to the Scene ViewportPtr TutorialViewport = mgr->getWindow()->getPort(0); beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask); TutorialViewport->getForegrounds().push_back(TutorialUIForeground); beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask); // Show the whole Scene mgr->showAll(); SoundManager::the()->setCamera(mgr->getCamera()); TutorialDialog->start(); Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f); Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5); TutorialWindowEventProducer->openWindow(WinPos, WinSize, "07DialogTypeTwo"); //Enter main Loop TutorialWindowEventProducer->mainLoop(); osgExit(); return 0; }
void ReflectInterpreter::InterpretFilePathField( const std::vector< Reflect::Pointer >& pointers, Reflect::Translator* translator, const Reflect::Field* field, Container* parent ) { #if INSPECT_REFACTOR if (field->m_Flags & FieldFlags::Hide) { return; } // // Create the ui we are generating // std::vector< ContainerPtr > groups; ContainerPtr container = CreateControl<Container>(); groups.push_back( container ); bool pathField = field->m_DataClass == Reflect::GetMetaClass< PathData >(); bool readOnly = ( field->m_Flags & FieldFlags::ReadOnly ) == FieldFlags::ReadOnly; DataChangingSignature::Delegate changingDelegate; FileDialogButtonPtr fileDialogButton; // // Parse // std::string fieldUI; field->GetProperty( TXT( "UIScript" ), fieldUI ); bool result = Script::Parse(fieldUI, this, parent->GetCanvas(), container, field->m_Flags); if (!result) { if ( pathField || field->m_DataClass == Reflect::GetMetaClass<StlStringData>() ) { ContainerPtr valueContainer = CreateControl<Container>(); ValuePtr value = CreateControl< Value >(); value->a_Justification.Set( Justifications::Right ); value->a_IsReadOnly.Set( readOnly ); value->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) ); valueContainer->AddChild( value ); groups.push_back( valueContainer ); if ( !readOnly ) { changingDelegate = DataChangingSignature::Delegate(this, &PathInterpreter::DataChanging); // File dialog button fileDialogButton = CreateControl< FileDialogButton >(); fileDialogButton->a_HelpText.Set( TXT( "Open a file dialog to choose a new file." ) ); field->GetProperty( TXT( "FileFilter" ), m_FileFilter ); if ( !m_FileFilter.empty() ) { fileDialogButton->a_Filter.Set( m_FileFilter ); } container->AddChild( fileDialogButton ); value->SetProperty( TXT( "FileFilter" ), m_FileFilter ); } if ( objects.size() == 1 ) { // File edit button ButtonPtr editButton = CreateControl< Button >(); editButton->ButtonClickedEvent().Add( ButtonClickedSignature::Delegate ( this, &PathInterpreter::Edit ) ); editButton->a_Label.Set( TXT( "Edit" ) ); editButton->a_HelpText.Set( TXT( "Attempt to edit the file using its associated default application." ) ); container->AddChild( editButton ); } } } 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); } // // 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 ); m_Datas.push_back( s ); } data = new MultiStringFormatter<Data>( alphaSer ); slider->Bind( data ); value->Bind( data ); } if ( field->m_DataClass == Reflect::GetMetaClass<HDRColor3Data>() || field->m_DataClass == Reflect::GetMetaClass<HDRColor4Data>() ) { SliderPtr slider = CreateControl<Slider>(); container->AddChild( slider ); slider->a_Min.Set( 0.0 ); slider->a_Max.Set( 8.0 ); slider->a_IsReadOnly.Set( readOnly ); slider->a_HelpText.Set( TXT( "Adjusts the HDR value of the color." ) ); ValuePtr value = CreateControl<Value>(); container->AddChild( value ); value->a_IsReadOnly.Set( readOnly ); value->a_HelpText.Set( TXT( "Adjusts the HDR value of the color." ) ); std::vector<Data*> intensitySer; 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 Float32Data(); uintptr_t fieldAddress = (uintptr_t)(*itr) + field->m_Offset; if ( color3 ) { HDRColor3* col = (HDRColor3*)fieldAddress; intptr_t offsetInField = (intptr_t)( &col->s ) - fieldAddress; s->ConnectField( *itr, field, offsetInField ); } if ( color4 ) { HDRColor4* col = (HDRColor4*)fieldAddress; intptr_t offsetInField = (intptr_t)( &col->s ) - fieldAddress; s->ConnectField( *itr, field, offsetInField ); } intensitySer.push_back( s ); m_Datas.push_back( s ); } data = new MultiStringFormatter<Data>( intensitySer ); slider->Bind( data ); value->Bind( data ); } } } #endif }
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 ); } }
// Initialize OpenSG and set up the scene int main(int argc, char **argv) { // OSG init osgInit(argc,argv); // Set up Window TutorialWindowEventProducer = createDefaultWindowEventProducer(); WindowPtr MainWindow = TutorialWindowEventProducer->initWindow(); TutorialWindowEventProducer->setDisplayCallback(display); TutorialWindowEventProducer->setReshapeCallback(reshape); //Add Window Listener TutorialKeyListener TheKeyListener; TutorialWindowEventProducer->addKeyListener(&TheKeyListener); TutorialMouseListener TheTutorialMouseListener; TutorialMouseMotionListener TheTutorialMouseMotionListener; TutorialWindowEventProducer->addMouseListener(&TheTutorialMouseListener); TutorialWindowEventProducer->addMouseMotionListener(&TheTutorialMouseMotionListener); TutorialUpdateListener TheTutorialUpdateListener; TutorialWindowEventProducer->addUpdateListener(&TheTutorialUpdateListener); // Create the SimpleSceneManager helper mgr = new SimpleSceneManager; // Tell the Manager what to manage mgr->setWindow(MainWindow); //Print key command info std::cout << "\n\nKEY COMMANDS:" << std::endl; std::cout << "space Play/Pause the animation" << std::endl; std::cout << "B Show/Hide the bind pose skeleton" << std::endl; std::cout << "SHIFT-B Show/Hide the bind pose mesh" << std::endl; std::cout << "P Show/Hide the current pose skeleton" << std::endl; std::cout << "SHIFT-P Show/Hide the current pose mesh" << std::endl; std::cout << "O Toggle override status of TheSecondAnimation" << std::endl; std::cout << "CTRL-Q Exit\n\n" << std::endl; //Import scene from XML ChunkMaterialPtr ExampleMaterial; std::vector<SkeletonPtr> SkeletonPtrs; std::vector<SkeletonBlendedGeometryPtr> SkeletonBlendedGeometryPtrs; std::vector<GeometryPtr> GeometryPtrs; //Skeleton materaial LineChunkPtr SkelLineChunk = LineChunk::create(); beginEditCP(SkelLineChunk); SkelLineChunk->setWidth(0.0f); SkelLineChunk->setSmooth(true); endEditCP(SkelLineChunk); ChunkMaterialPtr SkelMaterial = ChunkMaterial::create(); beginEditCP(SkelMaterial, ChunkMaterial::ChunksFieldMask); SkelMaterial->addChunk(SkelLineChunk); endEditCP(SkelMaterial, ChunkMaterial::ChunksFieldMask); //LOAD FIRST ANIMATION FCFileType::FCPtrStore NewContainers; NewContainers = FCFileHandler::the()->read(BoostPath("./Data/23WalkingAnimation.xml")); FCFileType::FCPtrStore::iterator Itor; for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor) { if( (*Itor)->getType() == (ChunkMaterial::getClassType())) { //Set ExampleMaterial to the ChunkMaterial we just read in ExampleMaterial = (ChunkMaterial::Ptr::dcast(*Itor)); } if( (*Itor)->getType() == (Skeleton::getClassType())) { //Add the Skeleton we just read in to SkeletonPtrs SkeletonPtrs.push_back(Skeleton::Ptr::dcast(*Itor)); } if( (*Itor)->getType() == (SkeletonBlendedGeometry::getClassType())) { //Add the SkeletonBlendedGeometry we just read in to SkeletonBlendedGeometryPtrs SkeletonBlendedGeometryPtrs.push_back(SkeletonBlendedGeometry::Ptr::dcast(*Itor)); } if( (*Itor)->getType().isDerivedFrom(SkeletonAnimation::getClassType())) { //Set TheWalkingAnimation to the SkeletonAnimation we just read in TheWalkingAnimation = (SkeletonAnimation::Ptr::dcast(*Itor)); } if( (*Itor)->getType() == (Geometry::getClassType())) { //Add the Geometry we just read in to GeometryPtrs GeometryPtrs.push_back(Geometry::Ptr::dcast(*Itor)); } } //LOAD SECOND ANIMATION NewContainers = FCFileHandler::the()->read(BoostPath("./Data/23SamAnimation.xml")); for(Itor = NewContainers.begin() ; Itor != NewContainers.end() ; ++Itor) { //Import only the skeletonAnimation from the second XML file; we've already imported the skeleton and the geometry if( (*Itor)->getType().isDerivedFrom(SkeletonAnimation::getClassType())) { TheSecondAnimation = (SkeletonAnimation::Ptr::dcast(*Itor)); } } //Blend the two animations TheSkeletonBlendedAnimation = SkeletonBlendedAnimation::create(); beginEditCP(TheSkeletonBlendedAnimation); TheSkeletonBlendedAnimation->addAnimationBlending(TheWalkingAnimation, BlendWalking, false); TheSkeletonBlendedAnimation->addAnimationBlending(TheSecondAnimation, BlendTouchScreen, false); endEditCP(TheSkeletonBlendedAnimation); //Create unbound geometry Node (to show the mesh in its bind pose) for (int i(0); i < GeometryPtrs.size(); ++i) { NodePtr UnboundGeometry = Node::create(); beginEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask); UnboundGeometry->setCore(GeometryPtrs[i]); UnboundGeometry->setTravMask(0); //By default, we don't show the mesh in its bind pose. endEditCP(UnboundGeometry, Node::CoreFieldMask | Node::TravMaskFieldMask); UnboundGeometries.push_back(UnboundGeometry); } //Create skeleton nodes for (int i(0); i < SkeletonPtrs.size(); ++i) { //SkeletonDrawer SkeletonDrawablePtr ExampleSkeletonDrawable = osg::SkeletonDrawable::create(); beginEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask); ExampleSkeletonDrawable->setSkeleton(SkeletonPtrs[i]); ExampleSkeletonDrawable->setMaterial(SkelMaterial); ExampleSkeletonDrawable->setDrawPose(true); //By default we draw the current skeleton ExampleSkeletonDrawable->setPoseColor(Color4f(1.0, 0.0, 1.0, 1.0)); //Set color of current skeleton ExampleSkeletonDrawable->setDrawBindPose(false); //By default we don't draw the bind pose skeleton ExampleSkeletonDrawable->setBindPoseColor(Color4f(1.0, 1.0, 0.0, 1.0)); //Set color of bind pose skeleton endEditCP(ExampleSkeletonDrawable, SkeletonDrawable::SkeletonFieldMask | SkeletonDrawable::MaterialFieldMask | SkeletonDrawable::DrawPoseFieldMask | SkeletonDrawable::PoseColorFieldMask | SkeletonDrawable::DrawBindPoseFieldMask | SkeletonDrawable::BindPoseColorFieldMask); //Skeleton Node NodePtr SkeletonNode = osg::Node::create(); beginEditCP(SkeletonNode, Node::CoreFieldMask); SkeletonNode->setCore(ExampleSkeletonDrawable); endEditCP(SkeletonNode, Node::CoreFieldMask); SkeletonNodes.push_back(SkeletonNode); } //Create skeleton blended geometry nodes for (int i(0); i < SkeletonBlendedGeometryPtrs.size(); ++i) { NodePtr MeshNode = osg::Node::create(); beginEditCP(MeshNode, Node::CoreFieldMask); MeshNode->setCore(SkeletonBlendedGeometryPtrs[i]); endEditCP(MeshNode, Node::CoreFieldMask); MeshNodes.push_back(MeshNode); } //Setup scene NodePtr EmptyScene = osg::Node::create(); beginEditCP(EmptyScene, Node::CoreFieldMask); EmptyScene->setCore(Group::create()); endEditCP (EmptyScene, Node::CoreFieldMask); mgr->setRoot(EmptyScene); //User Interface // Create the Graphics GraphicsPtr TutorialGraphics = osg::Graphics2D::create(); // Initialize the LookAndFeelManager to enable default settings LookAndFeelManager::the()->getLookAndFeel()->init(); // Create the DefaultBoundedRangeModelPtr and // set its values DefaultBoundedRangeModelPtr UpperAnimationSliderRangeModel = DefaultBoundedRangeModel::create(); UpperAnimationSliderRangeModel->setMinimum(0); UpperAnimationSliderRangeModel->setMaximum(100); UpperAnimationSliderRangeModel->setValue(BlendWalking * 100); UpperAnimationSliderRangeModel->setExtent(0); //Create the upper animation blend amount slider LabelPtr TempLabel; SliderPtr UpperAnimationSlider = Slider::create(); beginEditCP(UpperAnimationSlider, Slider::LabelMapFieldMask | Slider::PreferredSizeFieldMask | Slider::MajorTickSpacingFieldMask | Slider::MinorTickSpacingFieldMask | Slider::SnapToTicksFieldMask | Slider::DrawLabelsFieldMask | Slider::RangeModelFieldMask); //Label the slider TempLabel = Label::Ptr::dcast(UpperAnimationSlider->getLabelPrototype()->shallowCopy()); beginEditCP(TempLabel, Label::TextFieldMask); TempLabel->setText("0.0"); endEditCP(TempLabel, Label::TextFieldMask); UpperAnimationSlider->getLabelMap()[0] = TempLabel; TempLabel = Label::Ptr::dcast(UpperAnimationSlider->getLabelPrototype()->shallowCopy()); beginEditCP(TempLabel, Label::TextFieldMask); TempLabel->setText("1.0"); endEditCP(TempLabel, Label::TextFieldMask); UpperAnimationSlider->getLabelMap()[100] = TempLabel; //Customize the slider UpperAnimationSlider->setPreferredSize(Vec2f(100, 300)); UpperAnimationSlider->setSnapToTicks(false); UpperAnimationSlider->setMajorTickSpacing(10); UpperAnimationSlider->setMinorTickSpacing(5); UpperAnimationSlider->setOrientation(Slider::VERTICAL_ORIENTATION); UpperAnimationSlider->setInverted(true); UpperAnimationSlider->setDrawLabels(true); UpperAnimationSlider->setRangeModel(UpperAnimationSliderRangeModel); endEditCP(UpperAnimationSlider, Slider::LabelMapFieldMask | Slider::PreferredSizeFieldMask | Slider::MajorTickSpacingFieldMask | Slider::MinorTickSpacingFieldMask | Slider::SnapToTicksFieldMask | Slider::DrawLabelsFieldMask | Slider::RangeModelFieldMask); DefaultBoundedRangeModelPtr LowerAnimationSliderRangeModel = DefaultBoundedRangeModel::create(); LowerAnimationSliderRangeModel->setMinimum(0); LowerAnimationSliderRangeModel->setMaximum(100); LowerAnimationSliderRangeModel->setValue(BlendTouchScreen * 100); LowerAnimationSliderRangeModel->setExtent(0); //Create the lower animation blend amount slider SliderPtr LowerAnimationSlider = Slider::create(); beginEditCP(LowerAnimationSlider, Slider::LabelMapFieldMask | Slider::PreferredSizeFieldMask | Slider::MajorTickSpacingFieldMask | Slider::MinorTickSpacingFieldMask | Slider::SnapToTicksFieldMask | Slider::DrawLabelsFieldMask | Slider::RangeModelFieldMask); //Label the slider TempLabel = Label::Ptr::dcast(LowerAnimationSlider->getLabelPrototype()->shallowCopy()); beginEditCP(TempLabel, Label::TextFieldMask); TempLabel->setText("0.0"); endEditCP(TempLabel, Label::TextFieldMask); LowerAnimationSlider->getLabelMap()[0] = TempLabel; TempLabel = Label::Ptr::dcast(LowerAnimationSlider->getLabelPrototype()->shallowCopy()); beginEditCP(TempLabel, Label::TextFieldMask); TempLabel->setText("1.0"); endEditCP(TempLabel, Label::TextFieldMask); LowerAnimationSlider->getLabelMap()[100] = TempLabel; //Customize the slider LowerAnimationSlider->setPreferredSize(Vec2f(100, 300)); LowerAnimationSlider->setSnapToTicks(false); LowerAnimationSlider->setMajorTickSpacing(10); LowerAnimationSlider->setMinorTickSpacing(5); LowerAnimationSlider->setOrientation(Slider::VERTICAL_ORIENTATION); LowerAnimationSlider->setInverted(true); LowerAnimationSlider->setDrawLabels(true); LowerAnimationSlider->setRangeModel(LowerAnimationSliderRangeModel); endEditCP(LowerAnimationSlider, Slider::LabelMapFieldMask | Slider::PreferredSizeFieldMask | Slider::MajorTickSpacingFieldMask | Slider::MinorTickSpacingFieldMask | Slider::SnapToTicksFieldMask | Slider::DrawLabelsFieldMask | Slider::RangeModelFieldMask); // Create Background to be used with the MainFrame ColorLayerPtr MainFrameBackground = osg::ColorLayer::create(); beginEditCP(MainFrameBackground, ColorLayer::ColorFieldMask); MainFrameBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); endEditCP(MainFrameBackground, ColorLayer::ColorFieldMask); // Create The Main InternalWindow // Create Background to be used with the Main InternalWindow ColorLayerPtr MainInternalWindowBackground = osg::ColorLayer::create(); beginEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask); MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5)); endEditCP(MainInternalWindowBackground, ColorLayer::ColorFieldMask); LayoutPtr MainInternalWindowLayout = osg::FlowLayout::create(); //GL Viewport ComponentPtr TheGLViewport = createGLPanel(); InternalWindowPtr MainInternalWindow = osg::InternalWindow::create(); beginEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask); MainInternalWindow->getChildren().push_back(UpperAnimationSlider); MainInternalWindow->getChildren().push_back(LowerAnimationSlider); MainInternalWindow->getChildren().push_back(TheGLViewport); MainInternalWindow->setLayout(MainInternalWindowLayout); MainInternalWindow->setBackgrounds(MainInternalWindowBackground); MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f)); MainInternalWindow->setScalingInDrawingSurface(Vec2f(1.0f,1.0f)); MainInternalWindow->setDrawTitlebar(false); MainInternalWindow->setResizable(false); endEditCP(MainInternalWindow, InternalWindow::ChildrenFieldMask | InternalWindow::LayoutFieldMask | InternalWindow::BackgroundsFieldMask | InternalWindow::AlignmentInDrawingSurfaceFieldMask | InternalWindow::ScalingInDrawingSurfaceFieldMask | InternalWindow::DrawTitlebarFieldMask | InternalWindow::ResizableFieldMask); // Create the Drawing Surface UIDrawingSurfacePtr TutorialDrawingSurface = UIDrawingSurface::create(); beginEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask); TutorialDrawingSurface->setGraphics(TutorialGraphics); TutorialDrawingSurface->setEventProducer(TutorialWindowEventProducer); endEditCP(TutorialDrawingSurface, UIDrawingSurface::GraphicsFieldMask | UIDrawingSurface::EventProducerFieldMask); TutorialDrawingSurface->openWindow(MainInternalWindow); // Create the UI Foreground Object UIForegroundPtr TutorialUIForeground = osg::UIForeground::create(); beginEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask); TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface); endEditCP(TutorialUIForeground, UIForeground::DrawingSurfaceFieldMask); ViewportPtr TutorialViewport = mgr->getWindow()->getPort(0); beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask); TutorialViewport->getForegrounds().push_back(TutorialUIForeground); beginEditCP(TutorialViewport, Viewport::ForegroundsFieldMask); //Attach the Slider Listeners BlendAmountSliderChangeListener UpperAnimationSliderListener(TheSkeletonBlendedAnimation, 0, UpperAnimationSlider); UpperAnimationSlider->addChangeListener(&UpperAnimationSliderListener); BlendAmountSliderChangeListener LowerAnimationSliderListener(TheSkeletonBlendedAnimation, 1, LowerAnimationSlider); LowerAnimationSlider->addChangeListener(&LowerAnimationSliderListener); //Animation Advancer TheAnimationAdvancer = ElapsedTimeAnimationAdvancer::create(); beginEditCP(TheAnimationAdvancer); ElapsedTimeAnimationAdvancer::Ptr::dcast(TheAnimationAdvancer)->setStartTime( 0.0 ); beginEditCP(TheAnimationAdvancer); //Create the Documentation SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow); // Show the whole Scene mgr->showAll(); TheAnimationAdvancer->start(); //Show window Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f); Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5); TutorialWindowEventProducer->openWindow(WinPos, WinSize, "23BlendXMLAnimations"); //Enter main Loop TutorialWindowEventProducer->mainLoop(); osgExit(); return 0; }
void ReflectBitfieldInterpreter::InterpretField(const Field* field, const std::vector<Reflect::Element*>& instances, Container* parent) { // If you hit this, you are misusing this interpreter HELIUM_ASSERT( field->m_SerializerID == Reflect::GetType<Reflect::BitfieldSerializer>() ); if ( field->m_SerializerID != Reflect::GetType<Reflect::BitfieldSerializer>() ) { return; } if ( field->m_Flags & FieldFlags::Hide ) { return; } const EnumerationField* enumField = static_cast< const EnumerationField* >( field ); // create the panel PanelPtr panel = m_Container->GetCanvas()->Create<Panel>(this); tstring temp; bool converted = Helium::ConvertString( field->m_UIName, temp ); panel->SetText( temp ); panel->SetExpanded( true ); parent->AddControl(panel); // build the child gui elements bool readOnly = ( field->m_Flags & FieldFlags::ReadOnly ) == FieldFlags::ReadOnly; M_StrEnumerationElement::const_iterator enumItr = enumField->m_Enumeration->m_ElementsByLabel.begin(); M_StrEnumerationElement::const_iterator enumEnd = enumField->m_Enumeration->m_ElementsByLabel.end(); for ( ; enumItr != enumEnd; ++enumItr ) { ContainerPtr row = m_Container->GetCanvas()->Create<Container>( this ); panel->AddControl( row ); LabelPtr label = m_Container->GetCanvas()->Create<Label>( this ); row->AddControl( label ); tstring temp; bool converted = Helium::ConvertString( enumItr->first, temp ); HELIUM_ASSERT( converted ); label->SetText( temp ); BitfieldCheckBoxPtr checkbox = m_Container->GetCanvas()->Create<ReflectBitfieldCheckBox>( this ); row->AddControl( checkbox ); converted = Helium::ConvertString( enumItr->first, temp ); HELIUM_ASSERT( converted ); checkbox->SetBitfieldString( temp ); checkbox->SetReadOnly( readOnly ); } // create the serializers std::vector<Reflect::Element*>::const_iterator itr = instances.begin(); std::vector<Reflect::Element*>::const_iterator end = instances.end(); for ( ; itr != end; ++itr ) { SerializerPtr s = field->CreateSerializer(); s->ConnectField(*itr, field); m_Serializers.push_back(s); } // bind the ui to the serializers panel->Bind( new MultiStringFormatter<Serializer>( (std::vector<Reflect::Serializer*>&)m_Serializers ) ); // setup the default value if (field->m_Default != NULL) { tstringstream outStream; *field->m_Default >> outStream; panel->SetDefault( outStream.str() ); }