void exportXML(XMLImporter& importer)
{
StaticElement conditionElement("cond");
conditionElement.insertAttribute("value", m_test->c_str());
importer.pushElement(conditionElement);
m_result->exportXML(importer);
importer.popElement(conditionElement.name());
}
void exportXML(XMLImporter& importer)
{
importer << "\n";
for(Build::iterator i = m_build.begin(); i != m_build.end(); ++i)
{
StaticElement commandElement("command");
importer.pushElement(commandElement);
(*i).exportXML(importer);
importer.popElement(commandElement.name());
importer << "\n";
}
}
void popElement( const char* name ){
if ( string_equal( name, "epair" ) ) {
}
else
{
m_importer->popElement( name );
destructor( subprimitive() );
m_importer = 0;
}
}
void exportXML(XMLImporter& importer)
{
StaticElement projectElement("project");
projectElement.insertAttribute("version", BUILDMENU_VERSION);
importer.pushElement(projectElement);
importer << "\n";
for(Tools::iterator i = m_tools.begin(); i != m_tools.end(); ++i)
{
StaticElement toolElement("var");
toolElement.insertAttribute("name", (*i).first.c_str());
importer.pushElement(toolElement);
(*i).second.exportXML(importer);
importer.popElement(toolElement.name());
importer << "\n";
}
for(Project::iterator i = m_project.begin(); i != m_project.end(); ++i)
{
StaticElement buildElement("build");
buildElement.insertAttribute("name", (*i).first.c_str());
importer.pushElement(buildElement);
BuildXMLExporter buildExporter((*i).second);
buildExporter.exportXML(importer);
importer.popElement(buildElement.name());
importer << "\n";
}
importer.popElement(projectElement.name());
}
void pushElement( const XMLElement& element ){
if ( string_equal( element.name(), "epair" ) ) {
ASSERT_MESSAGE( string_equal( element.name(), "epair" ), PARSE_ERROR );
Node_getEntity( m_parent )->setKeyValue( element.attribute( "key" ), element.attribute( "value" ) );
}
else
{
NodeSmartReference node( createPrimitive( element.name() ) );
m_importer = Node_getXMLImporter( node );
constructor( subprimitive(), m_importer );
m_importer->pushElement( element );
Node_getTraversable( m_parent )->insert( node );
}
}
std::size_t write( const char* buffer, std::size_t length ){
return m_importer->write( buffer, length );
}
void popElement( const char* name ){
m_importer->popElement( name );
}
void pushElement( const XMLElement& element ){
m_importer->pushElement( element );
}
// Instantiate
ServerObject*
ClipObjectFactory::Instantiate(BString& type, const BString& id,
ServerObjectManager* library)
{
ServerObject* object = NULL;
if (type == "FileBasedClip") {
// find file by using server id as name
entry_ref ref;
status_t error = library->GetRef(id, ref);
if (error == B_OK) {
object = FileBasedClip::CreateClip(library, &ref, error,
false, fAllowLazyLoading);
} else {
printf("ClipObjectFactory::Instantiate() - "
"GetRef() failed: '%s'\n", strerror(error));
}
} else if (type == "ClockClip") {
object = new (nothrow) ClockClip("<new clock>");
} else if (type == "ColorClip") {
object = new (nothrow) ColorClip("<new color>");
} else if (type == "ScrollingTextClip") {
object = new (nothrow) ScrollingTextClip("<new ticker>");
} else if (type == "TextClip") {
object = new (nothrow) TextClip("<new text>");
} else if (type == "TimerClip") {
object = new (nothrow) TimerClip("<new timer>");
} else if (type == "WeatherClip") {
object = new (nothrow) WeatherClip("<new weather>");
} else if (type == "TableClip") {
TableClip* table = new (nothrow) TableClip("<new table>");
entry_ref ref;
status_t error = library->GetRef(id, ref);
if (error == B_OK) {
// an existing table object
BFile file(&ref, B_READ_ONLY);
#if 0
XMLImporter importer;
try {
importer.Restore(&table->Table(), &file);
object = table;
} catch (...) {
delete table;
printf("ClipObjectFactory::Instantiate() - "
"exception while loading table\n");
}
#else
try {
BMessage tableArchive;
status_t error = tableArchive.Unflatten(&file);
if (error == B_OK)
error = table->Table().Unarchive(&tableArchive);
if (error == B_OK) {
object = table;
table->SetDataSaved(true);
} else
delete table;
} catch (...) {
delete table;
printf("ClipObjectFactory::Instantiate() - "
"exception while loading table\n");
}
#endif
} else {
// a new table object
object = table;
}
} else if (string_ends_with(type, "Playlist")) {
// load playlist, it is also a clip
entry_ref ref;
BFile file;
status_t error = B_OK;
if (id.Length() > 0) {
error = library->GetRef(id, ref);
if (error == B_OK)
error = file.SetTo(&ref, B_READ_ONLY);
if (error < B_OK) {
printf("ClipObjectFactory::Instantiate() - failed "
"to init file for existing id: %s\n", strerror(error));
}
}
if (error == B_OK) {
Playlist* playlist;
const char* defaultName = NULL;
if (type == "SlideShowPlaylist") {
playlist = new (nothrow) SlideShowPlaylist();
defaultName = "<new Sildeshow Playlist>";
} else if (type == "StretchingPlaylist") {
playlist = new (nothrow) StretchingPlaylist();
defaultName = "<new Stretching Playlist>";
} else if (type == "CollectablePlaylist") {
playlist = new (nothrow) CollectablePlaylist();
defaultName = "<new Template Playlist>";
} else if (type == "CollectingPlaylist") {
playlist = new (nothrow) CollectingPlaylist();
defaultName = "<new Template Collector>";
} else if (type == "SequenceContainerPlaylist") {
playlist = new (nothrow) SequenceContainerPlaylist();
defaultName = "<new Sequence Container Playlist>";
} else {
playlist = new (nothrow) Playlist();
defaultName = "<new Playlist>";
}
if (file.InitCheck() == B_OK) {
#if 0
XMLImporter importer;
try {
// NOTE: the playlist will only reference
// clips by their id, therefor one needs
// to call library->ResolveDependencies()
// after all objects are loaded
importer.Import(playlist, &file, &ref);
object = playlist;
playlist->SetDataSaved(true);
} catch (...) {
delete playlist;
printf("ClipObjectFactory::Instantiate() - "
"exception while loading playlist\n");
}
#else
try {
BMessage playlistArchive;
status_t error = playlistArchive.Unflatten(&file);
if (error == B_OK)
error = playlist->Unarchive(&playlistArchive);
if (error == B_OK) {
object = playlist;
playlist->SetDataSaved(true);
} else
delete playlist;
} catch (...) {
delete playlist;
printf("ClipObjectFactory::Instantiate() - "
"exception while loading playlist\n");
}
#endif
} else {
// this is a new object
playlist->SetName(defaultName);
object = playlist;
}
}
}
if (!object) {
if (type != "ClockwerkComponent"
&& type != "ClockwerkRevision"
&& type != "ClientSettings") {
print_info("ClipObjectFactory::Instantiate() - "
"using place holder object for type %s and id %s\n",
type.String(), id.String());
}
// instantiate placeholder
object = new (nothrow) ServerObject(type.String());
}
// we already know the id
if (object && id.Length() > 0)
object->SetID(id);
if (object && (object->IsMetaDataOnly() || object->IsExternalData())) {
// we know that this object's data is saved
object->SetDataSaved(true);
}
return object;
}
