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 Game::refreshContainer(const ContainerPtr& container) { if(!canPerformGameAction()) return; m_protocolGame->sendRefreshContainer(container->getId()); }
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::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::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 ReflectInterpreter::Interpret( const std::vector< void* >& instances, const Reflect::MetaStruct* commonType, const std::vector< Reflect::Object* >& objects, Container* parent ) { if ( parent == NULL ) { parent = m_Container; } ContainerPtr container = CreateControl<Container>(); std::string labelText; commonType->GetProperty( TXT( "UIName" ), labelText ); if ( labelText.empty() ) { labelText = commonType->m_Name; } container->a_Name.Set( labelText ); std::map< std::string, ContainerPtr > containersMap; containersMap.insert( std::make_pair( TXT( "" ), container) ); std::stack< const MetaStruct* > bases; for ( const MetaStruct* current = commonType; current != NULL; current = current->m_Base ) { bases.push( current ); } while ( !bases.empty() ) { const MetaStruct* current = bases.top(); bases.pop(); // for each field in the type DynamicArray< Field >::ConstIterator itr = current->m_Fields.Begin(); DynamicArray< Field >::ConstIterator end = current->m_Fields.End(); for ( ; itr != end; ++itr ) { const Field* field = &*itr; bool hidden = (field->m_Flags & Reflect::FieldFlags::Hide) != 0; if (hidden) { continue; } std::string fieldUIGroup; if ( field->GetProperty( TXT( "UIGroup" ), fieldUIGroup ) && !fieldUIGroup.empty() ) { std::map< std::string, ContainerPtr >::iterator itr = containersMap.find( fieldUIGroup ); if ( itr == containersMap.end() ) { // This container isn't in our list so make a new one ContainerPtr newContainer = CreateControl<Container>(); containersMap.insert( std::make_pair(fieldUIGroup, newContainer) ); ContainerPtr parent; std::string groupName; size_t idx = fieldUIGroup.find_last_of( TXT( "/" ) ); if ( idx != std::string::npos ) { std::string parentName = fieldUIGroup.substr( 0, idx ); groupName = fieldUIGroup.substr( idx+1 ); if ( containersMap.find( parentName ) == containersMap.end() ) { parent = CreateControl<Container>(); // create the parent hierarchy since it hasn't already been made std::string currentParent = parentName; for (;;) { idx = currentParent.find_last_of( TXT( "/" ) ); if ( idx == std::string::npos ) { // no more parents so we add it to the root containersMap.insert( std::make_pair(currentParent, parent) ); parent->a_Name.Set( currentParent ); containersMap[ TXT( "" ) ]->AddChild( parent ); break; } else { parent->a_Name.Set( currentParent.substr( idx+1 ) ); if ( containersMap.find( currentParent ) != containersMap.end() ) { break; } else { ContainerPtr grandParent = CreateControl<Container>(); grandParent->AddChild( parent ); containersMap.insert( std::make_pair(currentParent, parent) ); parent = grandParent; } currentParent = currentParent.substr( 0, idx ); } } containersMap.insert( std::make_pair(parentName, parent) ); } parent = containersMap[parentName]; } else { parent = containersMap[TXT( "" )]; groupName = fieldUIGroup; } newContainer->a_Name.Set( groupName ); parent->AddChild( newContainer ); } container = containersMap[fieldUIGroup]; } else { container = containersMap[TXT( "" )]; } if ( field->m_Count > 1 ) { for ( uint32_t i=0; i<field->m_Count; ++i ) { std::vector< Reflect::Pointer > pointers; for ( size_t j=0; j<instances.size(); ++j ) { pointers.push_back( Pointer ( field, instances[ j ], objects[ j ], i ) ); } InterpretField( pointers, field->m_Translator, field, container ); } } else { std::vector< Reflect::Pointer > pointers; for ( size_t i=0; i<instances.size(); ++i ) { pointers.push_back( Pointer ( field, instances[ i ], objects[ i ] ) ); } InterpretField( pointers, field->m_Translator, field, container ); } } } // Make sure we have the base container container = containersMap[TXT( "" )]; if ( !container->GetChildren().empty() ) { parent->AddChild(container); } }
OGRErr OGRLIBKMLLayer::ICreateFeature ( OGRFeature * poOgrFeat ) { if ( !bUpdate ) return OGRERR_UNSUPPORTED_OPERATION; if( m_bRegionBoundsAuto && poOgrFeat->GetGeometryRef() != NULL && !(poOgrFeat->GetGeometryRef()->IsEmpty()) ) { OGREnvelope sEnvelope; poOgrFeat->GetGeometryRef()->getEnvelope(&sEnvelope); m_dfRegionMinX = MIN(m_dfRegionMinX, sEnvelope.MinX); m_dfRegionMinY = MIN(m_dfRegionMinY, sEnvelope.MinY); m_dfRegionMaxX = MAX(m_dfRegionMaxX, sEnvelope.MaxX); m_dfRegionMaxY = MAX(m_dfRegionMaxY, sEnvelope.MaxY); } FeaturePtr poKmlFeature = feat2kml ( m_poOgrDS, this, poOgrFeat, m_poOgrDS->GetKmlFactory ( ), m_bUseSimpleField ); if( m_poKmlLayer != NULL ) m_poKmlLayer->add_feature ( poKmlFeature ); else { CPLAssert( m_poKmlUpdate != NULL ); KmlFactory *poKmlFactory = m_poOgrDS->GetKmlFactory ( ); CreatePtr poCreate = poKmlFactory->CreateCreate(); ContainerPtr poContainer; if( m_bUpdateIsFolder ) poContainer = poKmlFactory->CreateFolder(); else poContainer = poKmlFactory->CreateDocument(); poContainer->set_targetid(OGRLIBKMLGetSanitizedNCName(GetName())); poContainer->add_feature ( poKmlFeature ); poCreate->add_container(poContainer); m_poKmlUpdate->add_updateoperation(poCreate); } /***** update the layer class count of features *****/ if( m_poKmlLayer != NULL ) { nFeatures++; const char* pszId = CPLSPrintf("%s.%d", OGRLIBKMLGetSanitizedNCName(GetName()).c_str(), nFeatures); poOgrFeat->SetFID(nFeatures); poKmlFeature->set_id(pszId); } else { if( poOgrFeat->GetFID() < 0 ) { static int bAlreadyWarned = FALSE; if( !bAlreadyWarned ) { bAlreadyWarned = TRUE; CPLError(CE_Warning, CPLE_AppDefined, "It is recommended to define a FID when calling CreateFeature() in a update document"); } } else { const char* pszId = CPLSPrintf("%s." CPL_FRMT_GIB, OGRLIBKMLGetSanitizedNCName(GetName()).c_str(), poOgrFeat->GetFID()); poOgrFeat->SetFID(nFeatures); poKmlFeature->set_id(pszId); } } /***** mark the layer as updated *****/ bUpdated = TRUE; m_poOgrDS->Updated ( ); return OGRERR_NONE; }
void ReadiumJSApi::on_actionOpen_ePub3(std::string path) //QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), "", tr("Files (*.epub)")); { // CSingleLock lock(&g_cs, TRUE); try{ ////qDebug() << fileName; DWORD beginTimeMs = GetTickCount(); ContainerPtr container = Container::OpenContainer(path); DWORD containerOpened = GetTickCount(); if (container) { pkg = container->DefaultPackage(); if (pkg == 0) { auto pkgs = container->Packages(); if (pkgs.size() <= 0) { //QMessageBox messageBox; //messageBox.critical(0, "Error", "ReadiumSDK: No packages found !"); //messageBox.setFixedSize(500, 200); //messageBox.exec(); return; } pkg = pkgs[0]; } //int contentLength = container->getArchiveInfoSize("titlepage.xhtml"); OpenPageRequest req = OpenPageRequest::fromContentUrl("", "chapter_001.xhtml");//TODO: ViewerSettings set(true, 100, 20); DWORD openBookStartedMs = GetTickCount(); openBook(pkg, set, req); DWORD EndTimeTimeMs = GetTickCount(); //char buf[1024];wsprintf((LPWSTR)buf, L"TotalTime:%d ms\n Container::OpenContainer:%d ms\nopenBook:%d ms\n", (EndTimeTimeMs - beginTimeMs), (openBookStartedMs - beginTimeMs), (EndTimeTimeMs - containerOpened)); //AfxMessageBox((LPCTSTR)buf); //BYTE* bytes = 0; //ULONGLONG pSize = 0; //getByteResp("/chapter_001.xhtml", &bytes, &pSize); //delete[]bytes; //getByteResp("/chapter_002.xhtml", &bytes, &pSize); //delete[]bytes; //getByteResp("/chapter_003.xhtml", &bytes, &pSize); //openContentUrl("chapter_001.xhtml", ""); //ReadiumJsApi.openContentUrl((*list.begin())->Title().c_str(), ""); //unique_ptr<ePub3::ByteStream> byteStream = pkg->ReadStreamForItemAtPath("titlepage.xhtml"); //if (pkg) //{ //CollectionPtr previewCollection = pkg->PreviewCollection(); //unique_ptr<ePub3::ByteStream> byteStream1 = previewCollection->ReadStreamForItemAtPath("titlepage.xhtml"); //} } } //catch (ePub3::epub_spec_error err) //{ //} catch (...) { //qDebug() << "Exception!!!"; throw; } //openContentUrl("chapter_001.xhtml", ""); }
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() ); }
void ReflectInterpreter::InterpretType(const std::vector<Reflect::Object*>& instances, Container* parent, int32_t includeFlags, int32_t excludeFlags, bool expandPanel) { const Composite* composite = instances[0]->GetClass(); // create a container ContainerPtr container = CreateControl<Container>(); // parse ContainerPtr scriptOutput = CreateControl<Container>(); tstring typeInfoUI; composite->GetProperty( TXT( "UIScript" ), typeInfoUI ); bool result = Script::Parse(typeInfoUI, this, parent->GetCanvas(), scriptOutput); // compute container label tstring labelText; if (result) { V_Control::const_iterator itr = scriptOutput->GetChildren().begin(); V_Control::const_iterator end = scriptOutput->GetChildren().end(); for( ; itr != end; ++itr ) { Label* label = Reflect::SafeCast<Label>( *itr ); if (label) { label->ReadStringData( labelText ); if ( !labelText.empty() ) { break; } } } } if (labelText.empty()) { composite->GetProperty( TXT( "UIName" ), labelText ); } if ( labelText.empty() ) { labelText = *composite->m_Name; } container->a_Name.Set( labelText ); std::map< tstring, ContainerPtr > containersMap; containersMap.insert( std::make_pair( TXT( "" ), container) ); std::stack< const Composite* > bases; for ( const Composite* current = composite; current != NULL; current = current->m_Base ) { bases.push( current ); } while ( !bases.empty() ) { const Composite* current = bases.top(); bases.pop(); // for each field in the type DynArray< Field >::ConstIterator itr = current->m_Fields.Begin(); DynArray< Field >::ConstIterator end = current->m_Fields.End(); for ( ; itr != end; ++itr ) { const Field* field = &*itr; bool noFlags = ( field->m_Flags == 0 && includeFlags == 0xFFFFFFFF ); bool doInclude = ( field->m_Flags & includeFlags ) != 0; bool dontExclude = ( excludeFlags == 0 ) || !(field->m_Flags & excludeFlags ); bool hidden = (field->m_Flags & Reflect::FieldFlags::Hide) != 0; // if we don't have flags (or we are included, and we aren't excluded) then make UI if ( ( noFlags || doInclude ) && ( dontExclude ) ) { tstring fieldUIGroup; field->GetProperty( TXT( "UIGroup" ), fieldUIGroup ); if ( !fieldUIGroup.empty() ) { std::map< tstring, ContainerPtr >::iterator itr = containersMap.find( fieldUIGroup ); if ( itr == containersMap.end() ) { // This container isn't in our list so make a new one ContainerPtr newContainer = CreateControl<Container>(); containersMap.insert( std::make_pair(fieldUIGroup, newContainer) ); ContainerPtr parent; tstring groupName; size_t idx = fieldUIGroup.find_last_of( TXT( "/" ) ); if ( idx != tstring::npos ) { tstring parentName = fieldUIGroup.substr( 0, idx ); groupName = fieldUIGroup.substr( idx+1 ); if ( containersMap.find( parentName ) == containersMap.end() ) { parent = CreateControl<Container>(); // create the parent hierarchy since it hasn't already been made tstring currentParent = parentName; for (;;) { idx = currentParent.find_last_of( TXT( "/" ) ); if ( idx == tstring::npos ) { // no more parents so we add it to the root containersMap.insert( std::make_pair(currentParent, parent) ); parent->a_Name.Set( currentParent ); containersMap[ TXT( "" ) ]->AddChild( parent ); break; } else { parent->a_Name.Set( currentParent.substr( idx+1 ) ); if ( containersMap.find( currentParent ) != containersMap.end() ) { break; } else { ContainerPtr grandParent = CreateControl<Container>(); grandParent->AddChild( parent ); containersMap.insert( std::make_pair(currentParent, parent) ); parent = grandParent; } currentParent = currentParent.substr( 0, idx ); } } containersMap.insert( std::make_pair(parentName, parent) ); } parent = containersMap[parentName]; } else { parent = containersMap[ TXT( "" )]; groupName = fieldUIGroup; } newContainer->a_Name.Set( groupName ); parent->AddChild( newContainer ); } container = containersMap[fieldUIGroup]; } else { container = containersMap[ TXT( "" )]; } // // Pointer support // if (field->m_DataClass == Reflect::GetClass<Reflect::PointerData>()) { if (hidden) { continue; } std::vector<Reflect::Object*> fieldInstances; std::vector<Reflect::Object*>::const_iterator elementItr = instances.begin(); std::vector<Reflect::Object*>::const_iterator elementEnd = instances.end(); for ( ; elementItr != elementEnd; ++elementItr ) { uintptr_t fieldAddress = (uintptr_t)(*elementItr) + itr->m_Offset; Object* element = *((ObjectPtr*)(fieldAddress)); if ( element ) { fieldInstances.push_back( element ); } } if ( !fieldInstances.empty() && fieldInstances.size() == instances.size() ) { InterpretType(fieldInstances, container); } continue; } // // Attempt to find a handler via the factory // ReflectFieldInterpreterPtr fieldInterpreter; for ( const Reflect::Class* type = field->m_DataClass; type != Reflect::GetClass<Reflect::Object>() && !fieldInterpreter; type = Reflect::ReflectionCast< const Class >( type->m_Base ) ) { fieldInterpreter = ReflectFieldInterpreterFactory::Create( type, field->m_Flags, m_Container ); } if ( fieldInterpreter.ReferencesObject() ) { Interpreter::ConnectInterpreterEvents( this, fieldInterpreter ); fieldInterpreter->InterpretField( field, instances, container ); m_Interpreters.push_back( fieldInterpreter ); continue; } // // ElementArray support // #pragma TODO("Move this out to an interpreter") if (field->m_DataClass == Reflect::GetClass<ObjectStlVectorData>()) { if (hidden) { continue; } if ( instances.size() == 1 ) { uintptr_t fieldAddress = (uintptr_t)(instances.front()) + itr->m_Offset; std::vector< ObjectPtr >* elements = (std::vector< ObjectPtr >*)fieldAddress; if ( elements->size() > 0 ) { ContainerPtr childContainer = CreateControl<Container>(); tstring temp; field->GetProperty( TXT( "UIName" ), temp ); if ( temp.empty() ) { bool converted = Helium::ConvertString( field->m_Name, temp ); HELIUM_ASSERT( converted ); } childContainer->a_Name.Set( temp ); std::vector< ObjectPtr >::const_iterator elementItr = elements->begin(); std::vector< ObjectPtr >::const_iterator elementEnd = elements->end(); for ( ; elementItr != elementEnd; ++elementItr ) { std::vector<Reflect::Object*> childInstances; childInstances.push_back(*elementItr); InterpretType(childInstances, childContainer); } container->AddChild( childContainer ); } } continue; } // // Lastly fall back to the value interpreter // const Reflect::Class* type = field->m_DataClass; if ( !type->IsType( Reflect::GetClass<Reflect::ContainerData>() ) ) { fieldInterpreter = CreateInterpreter< ReflectValueInterpreter >( m_Container ); fieldInterpreter->InterpretField( field, instances, container ); m_Interpreters.push_back( fieldInterpreter ); continue; } } } } // Make sure we have the base container container = containersMap[TXT( "" )]; if ( !container->GetChildren().empty() ) { parent->AddChild(container); } }
/////////////////////////////////////////////////////////////////////////////// // Creates UI for the field variable specified. // void ReflectStlSetInterpreter::InterpretField( const Reflect::Field* field, const std::vector<Reflect::Object*>& instances, Container* parent ) { if ( field->m_Flags & Reflect::FieldFlags::Hide ) { return; } // create the container ContainerPtr container = CreateControl< Container >(); parent->AddChild( container ); tstring 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 ); // 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 ) { Reflect::DataPtr ser = Reflect::AssertCast< Reflect::Data >( Reflect::Registry::GetInstance()->CreateInstance( field->m_DataClass ) ); uintptr_t fieldAddress = ( uintptr_t )( *itr ) + field->m_Offset; ser->ConnectData( ( void* )fieldAddress ); m_Datas.push_back( ser ); } // create the list ListPtr list = CreateControl< List >(); list->a_HelpText.Set( field->GetProperty( TXT( "HelpText" ) ) ); container->AddChild( list ); // bind the ui to the serialiers list->Bind( new MultiStringFormatter< Reflect::Data >( (std::vector<Reflect::Data*>&)m_Datas ) ); // create the buttons if we are not read only if ( !( field->m_Flags & Reflect::FieldFlags::ReadOnly ) ) { ContainerPtr buttonContainer = CreateControl< Container >(); container->AddChild( buttonContainer ); ButtonPtr buttonAdd = CreateControl< Button >(); buttonContainer->AddChild( buttonAdd ); buttonAdd->a_Label.Set( TXT( "Add" ) ); buttonAdd->a_HelpText.Set( TXT( "Add an item to the list." ) ); buttonAdd->ButtonClickedEvent().Add( ButtonClickedSignature::Delegate ( this, &ReflectStlSetInterpreter::OnAdd ) ); buttonAdd->SetClientData( new ClientData( list ) ); ButtonPtr buttonRemove = CreateControl< Button >(); buttonContainer->AddChild( buttonRemove ); buttonRemove->a_Label.Set( TXT( "Remove" ) ); buttonRemove->a_HelpText.Set( TXT( "Remove the selected item(s) from the list." ) ); buttonRemove->ButtonClickedEvent().Add( ButtonClickedSignature::Delegate ( this, &ReflectStlSetInterpreter::OnRemove ) ); buttonRemove->SetClientData( new ClientData( list ) ); } // for now let's just disable this container if there is more than one item selected. I'm not sure if it will behave properly in this case. if ( instances.size() > 1 ) { container->a_IsEnabled.Set( false ); } }
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() ); DynamicArray< EnumerationElement >::ConstIterator itr = enumeration->m_Elements.Begin(); DynamicArray< 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() ); }
// along with this program. If not, see <http://www.gnu.org/licenses/>. // #include <ePub3/container.h> #include <ePub3/package.h> #include <ePub3/spine.h> #include "catch.hpp" #define LR_SPREAD_EPUB_PATH "TestData/page-blanche.epub" #define NO_SPREAD_EPUB_PATH "TestData/cole-voyage-of-life-20120320.epub" using namespace ePub3; TEST_CASE("Page spread comes back correctly", "") { ContainerPtr c = Container::OpenContainer(LR_SPREAD_EPUB_PATH); PackagePtr pkg = c->DefaultPackage(); SpineItemPtr item = pkg->FirstSpineItem(); REQUIRE(item->Spread() == PageSpread::Right); item = item->Next(); REQUIRE(item->Spread() == PageSpread::Left); } TEST_CASE("Multiple spine item properties should work", "") { ContainerPtr c = Container::OpenContainer(NO_SPREAD_EPUB_PATH); PackagePtr pkg = c->DefaultPackage(); SpineItemPtr item = pkg->SpineItemWithIDRef("s1b");
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() ); } }
static std::once_flag __once; std::call_once(__once, [&]() { SetErrorHandler([](const error_details& err) { if (err.epub_error_code() == EPUBError::OPFMissingModificationDateMetadata) return true; return DefaultErrorHandler(err); }); __c = Container::OpenContainer(EPUB_PATH); SetErrorHandler(DefaultErrorHandler); }); return __c; } TEST_CASE("SpineItems should have titles when they match a TOC item", "[toc]") { ContainerPtr container = GetContainer(); auto pkg = container->DefaultPackage(); auto spine = pkg->FirstSpineItem(); // in alice3.epub, the first item isn't in the TOC, and has an empty title // the full list should be: /* - "" - "I. Down the Rabbit-Hole" - "II. The Pool of Tears" - "III. A Caucus-Race and a Long Tale" - "IV. The Rabbit Sends in a Little Bill" - "V. Advice from a Caterpillar" - "VI. Pig and Pepper" - "VII. A Mad Tea-Party" - "VIII. The Queen's Croquet-Ground"
void ReflectInterpreter::InterpretType(const std::vector<Reflect::Element*>& instances, Container* parent, i32 includeFlags, i32 excludeFlags, bool expandPanel) { const Class* typeInfo = instances[0]->GetClass(); // create a panel PanelPtr panel = m_Container->GetCanvas()->Create<Panel>(this); // parse ContainerPtr scriptOutput = m_Container->GetCanvas()->Create<Container>(this); tstring typeInfoUI; typeInfo->GetProperty( TXT( "UIScript" ), typeInfoUI ); bool result = Script::Parse(typeInfoUI, this, parent->GetCanvas(), scriptOutput); // compute panel label tstring labelText; if (result) { V_Control::const_iterator itr = scriptOutput->GetControls().begin(); V_Control::const_iterator end = scriptOutput->GetControls().end(); for( ; itr != end; ++itr ) { Label* label = Reflect::ObjectCast<Label>( *itr ); if (label) { bool converted = Helium::ConvertString( label->GetText(), labelText ); HELIUM_ASSERT( converted ); if ( !labelText.empty() ) { break; } } } } if (labelText.empty()) { std::vector<Reflect::Element*>::const_iterator itr = instances.begin(); std::vector<Reflect::Element*>::const_iterator end = instances.end(); for ( ; itr != end; ++itr ) { Reflect::Element* instance = *itr; if ( labelText.empty() ) { labelText = instance->GetTitle(); } else { if ( labelText != instance->GetTitle() ) { labelText.clear(); break; } } } if ( labelText.empty() ) { labelText = typeInfo->m_UIName; } } tstring temp; bool converted = Helium::ConvertString( labelText, temp ); HELIUM_ASSERT( converted ); panel->SetText( temp ); M_Panel panelsMap; panelsMap.insert( std::make_pair( TXT( "" ), panel) ); // don't bother including Element's fields int offset = Reflect::GetClass<Element>()->m_LastFieldID; // for each field in the type M_FieldIDToInfo::const_iterator itr = typeInfo->m_FieldIDToInfo.find(offset + 1); M_FieldIDToInfo::const_iterator end = typeInfo->m_FieldIDToInfo.end(); for ( ; itr != end; ++itr ) { const Field* field = itr->second; bool noFlags = ( field->m_Flags == 0 && includeFlags == 0xFFFFFFFF ); bool doInclude = ( field->m_Flags & includeFlags ) != 0; bool dontExclude = ( excludeFlags == 0 ) || !(field->m_Flags & excludeFlags ); bool hidden = (field->m_Flags & Reflect::FieldFlags::Hide) != 0; // if we don't have flags (or we are included, and we aren't excluded) then make UI if ( ( noFlags || doInclude ) && ( dontExclude ) ) { // // Handle sub panels for grouping content // bool groupExpanded = false; field->GetProperty( TXT( "UIGroupExpanded" ), groupExpanded ); tstring fieldUIGroup; field->GetProperty( TXT( "UIGroup" ), fieldUIGroup ); if ( !fieldUIGroup.empty() ) { M_Panel::iterator itr = panelsMap.find( fieldUIGroup ); if ( itr == panelsMap.end() ) { // This panel isn't in our list so make a new one PanelPtr newPanel = m_Container->GetCanvas()->Create<Panel>(this); panelsMap.insert( std::make_pair(fieldUIGroup, newPanel) ); PanelPtr parent; tstring groupName; size_t idx = fieldUIGroup.find_last_of( TXT( "/" ) ); if ( idx != tstring::npos ) { tstring parentName = fieldUIGroup.substr( 0, idx ); groupName = fieldUIGroup.substr( idx+1 ); if ( panelsMap.find( parentName ) == panelsMap.end() ) { parent = m_Container->GetCanvas()->Create<Panel>(this); // create the parent hierarchy since it hasn't already been made tstring currentParent = parentName; for (;;) { idx = currentParent.find_last_of( TXT( "/" ) ); if ( idx == tstring::npos ) { // no more parents so we add it to the root panelsMap.insert( std::make_pair(currentParent, parent) ); parent->SetText( currentParent ); panelsMap[ TXT( "" ) ]->AddControl( parent ); break; } else { parent->SetText( currentParent.substr( idx+1 ) ); if ( panelsMap.find( currentParent ) != panelsMap.end() ) { break; } else { PanelPtr grandParent = m_Container->GetCanvas()->Create<Panel>(this); grandParent->AddControl( parent ); panelsMap.insert( std::make_pair(currentParent, parent) ); parent = grandParent; } currentParent = currentParent.substr( 0, idx ); } } panelsMap.insert( std::make_pair(parentName, parent) ); } parent = panelsMap[parentName]; } else { parent = panelsMap[ TXT( "" )]; groupName = fieldUIGroup; } newPanel->SetText( groupName ); if( groupExpanded ) { newPanel->SetExpanded( true ); } parent->AddControl( newPanel ); } panel = panelsMap[fieldUIGroup]; } else { panel = panelsMap[ TXT( "" )]; } // // Pointer support // if (field->m_SerializerID == Reflect::GetType<Reflect::PointerSerializer>()) { if (hidden) { continue; } std::vector<Reflect::Element*> fieldInstances; std::vector<Reflect::Element*>::const_iterator elementItr = instances.begin(); std::vector<Reflect::Element*>::const_iterator elementEnd = instances.end(); for ( ; elementItr != elementEnd; ++elementItr ) { uintptr fieldAddress = (uintptr)(*elementItr) + itr->second->m_Offset; Element* element = *((ElementPtr*)(fieldAddress)); if ( element ) { fieldInstances.push_back( element ); } } if ( !fieldInstances.empty() && fieldInstances.size() == instances.size() ) { InterpretType(fieldInstances, panel); } continue; } // // Attempt to find a handler via the factory // ReflectFieldInterpreterPtr fieldInterpreter; for ( const Reflect::Class* type = Registry::GetInstance()->GetClass( field->m_SerializerID ); type != Reflect::GetClass<Reflect::Element>() && !fieldInterpreter; type = Reflect::Registry::GetInstance()->GetClass( type->m_Base ) ) { fieldInterpreter = ReflectFieldInterpreterFactory::Create( type->m_TypeID, field->m_Flags, m_Container ); } if ( fieldInterpreter.ReferencesObject() ) { Interpreter::ConnectInterpreterEvents( this, fieldInterpreter ); fieldInterpreter->InterpretField( field, instances, panel ); m_Interpreters.push_back( fieldInterpreter ); continue; } // // ElementArray support // #pragma TODO("Move this out to an interpreter") if (field->m_SerializerID == Reflect::GetType<ElementArraySerializer>()) { if (hidden) { continue; } if ( instances.size() == 1 ) { uintptr fieldAddress = (uintptr)(instances.front()) + itr->second->m_Offset; V_Element* elements = (V_Element*)fieldAddress; if ( elements->size() > 0 ) { PanelPtr childPanel = panel->GetCanvas()->Create<Panel>( this ); tstring temp; bool converted = Helium::ConvertString( field->m_UIName, temp ); HELIUM_ASSERT( converted ); childPanel->SetText( temp ); V_Element::const_iterator elementItr = elements->begin(); V_Element::const_iterator elementEnd = elements->end(); for ( ; elementItr != elementEnd; ++elementItr ) { std::vector<Reflect::Element*> childInstances; childInstances.push_back(*elementItr); InterpretType(childInstances, childPanel); } panel->AddControl( childPanel ); } } continue; } // // Lastly fall back to the value interpreter // const Reflect::Class* type = Registry::GetInstance()->GetClass( field->m_SerializerID ); if ( !type->HasType( Reflect::GetType<Reflect::ContainerSerializer>() ) ) { fieldInterpreter = CreateInterpreter< ReflectValueInterpreter >( m_Container ); fieldInterpreter->InterpretField( field, instances, panel ); m_Interpreters.push_back( fieldInterpreter ); continue; } } } // Make sure we have the base panel panel = panelsMap[TXT( "" )]; if (parent == m_Container) { panel->SetExpanded(expandPanel); } if ( !panel->GetControls().empty() ) { parent->AddControl(panel); } }
void ReflectVectorInterpreter::InterpretField(const Field* field, const std::vector<Reflect::Object*>& 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; 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" ) ) ); // compute dimensions int dimensions = 2; if ( field->m_DataClass == Reflect::GetClass<Vector3Data>() ) { dimensions += 1; } if ( field->m_DataClass == Reflect::GetClass<Vector4Data>() ) { dimensions += 2; } // create the dimension ui for ( int offset = 0; offset < dimensions*4; offset += 4 ) { // create the data objects std::vector<Reflect::Data*> data; std::vector<Reflect::Object*>::const_iterator itr = instances.begin(); std::vector<Reflect::Object*>::const_iterator end = instances.end(); for ( ; itr != end; ++itr ) { DataPtr s = new Float32Data (); s->ConnectField(*itr, field, offset); m_Datas.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 data objects value->Bind( new MultiStringFormatter<Data>( data ) ); } }