diff -abBdpuNPr --exclude='*.svn' irrlicht-svn-ss/trunk/include/EAttributes.h Irrlicht_starsonata/include/EAttributes.h --- irrlicht-svn-ss/trunk/include/EAttributes.h 1970-01-01 01:00:00.000000000 +0100 +++ Irrlicht_starsonata/include/EAttributes.h 2007-10-22 18:57:04.000000000 +0200 @@ -0,0 +1,114 @@ +// This file is part of the "Irrlicht Engine". +// For conditions of distribution and use, see copyright notice in irrlicht.h + +#ifndef __E_ATTRIBUTES_H_INCLUDED__ +#define __E_ATTRIBUTES_H_INCLUDED__ + +namespace irr +{ + +namespace io +{ + +//! Types of attributes available for IAttributes +enum E_ATTRIBUTE_TYPE +{ + // integer attribute + EAT_INT = 0, + + // float attribute + EAT_FLOAT, + + // string attribute + EAT_STRING, + + // boolean attribute + EAT_BOOL, + + // enumeration attribute + EAT_ENUM, + + // color attribute + EAT_COLOR, + + // floating point color attribute + EAT_COLORF, + + // 3d vector attribute + EAT_VECTOR3D, + + // 2d position attribute + EAT_POSITION2D, + + // vector 2d + EAT_VECTOR2D, + + // rectangle attribute + EAT_RECT, + + // matrix attribute + EAT_MATRIX, + + // quaternion attribute + EAT_QUATERNION, + + // 3d bounding box + EAT_BBOX, + + // plane + EAT_PLANE, + + // 3d triangle + EAT_TRIANGLE3D, + + // line 2d + EAT_LINE2D, + + // line 3d + EAT_LINE3D, + + // array of stringws attribute + EAT_STRINGWARRAY, + + // array of float + EAT_FLOATARRAY, + + // array of int + EAT_INTARRAY, + + // binary data attribute + EAT_BINARY, + + // texture reference attribute + EAT_TEXTURE, + + // user pointer void* + EAT_USER_POINTER, + + // known attribute type count + EAT_COUNT, + + // unknown attribute + EAT_UNKNOWN +}; + +//! usage for default attributes +enum E_DEFAULT_ATTRIBUTE_USAGE +{ + //! do not use default attributes + EDAU_IGNORE, + + //! use default attributes on reading when no other attribute with that name exists + EDAU_READ_ONLY, + + //! do not write attributes if a default attribute with the same name does exist + EDAU_WRITE_ONLY, + + //! like EDAU_READ_ONLY and EDAU_WRITE_ONLY combined + EDAU_READ_WRITE, +}; + +} // end namespace io +} // end namespace irr + +#endif // __E_ATTRIBUTES_H_INCLUDED__ diff -abBdpuNPr --exclude='*.svn' irrlicht-svn-ss/trunk/include/IAttributes.h Irrlicht_starsonata/include/IAttributes.h --- irrlicht-svn-ss/trunk/include/IAttributes.h 2007-07-26 02:11:22.000000000 +0200 +++ Irrlicht_starsonata/include/IAttributes.h 2007-12-28 23:37:02.000000000 +0100 @@ -23,6 +23,7 @@ #include "irrString.h" #include "irrArray.h" #include "IXMLReader.h" +#include "EAttributes.h" namespace irr { @@ -34,93 +35,91 @@ namespace io { class IXMLWriter; -//! Types of attributes available for IAttributes -enum E_ATTRIBUTE_TYPE +class IAttribute : public virtual IUnknown { - // integer attribute - EAT_INT = 0, - - // float attribute - EAT_FLOAT, - - // string attribute - EAT_STRING, - - // boolean attribute - EAT_BOOL, - - // enumeration attribute - EAT_ENUM, - - // color attribute - EAT_COLOR, - - // floating point color attribute - EAT_COLORF, - - // 3d vector attribute - EAT_VECTOR3D, - - // 2d position attribute - EAT_POSITION2D, - - // vector 2d - EAT_VECTOR2D, - - // rectangle attribute - EAT_RECT, - - // matrix attribute - EAT_MATRIX, - - // quaternion attribute - EAT_QUATERNION, - - // 3d bounding box - EAT_BBOX, - - // plane - EAT_PLANE, - - // 3d triangle - EAT_TRIANGLE3D, - - // line 2d - EAT_LINE2D, - - // line 3d - EAT_LINE3D, +public: - // array of stringws attribute - EAT_STRINGWARRAY, + virtual ~IAttribute() {}; - // array of float - EAT_FLOATARRAY, + virtual bool isEqualTo(IAttribute* attrib) { return attrib ? (getStringW() == attrib->getStringW()) && (getType()==attrib->getType()) : false; } - // array of int - EAT_INTARRAY, + virtual s32 getInt() { return 0; } + virtual f32 getFloat() { return 0; } + virtual video::SColorf getColorf() { return video::SColorf(1.0f,1.0f,1.0f,1.0f); } + virtual video::SColor getColor() { return video::SColor(255,255,255,255); } + virtual core::stringc getString() { return core::stringc(getStringW().c_str()); } + virtual core::stringw getStringW() { return core::stringw(); } + virtual core::array getArray() { return core::array(); }; + virtual bool getBool() { return false; } + virtual void getBinary(void* outdata, s32 maxLength) {}; + virtual core::vector3df getVector() { return core::vector3df(); } + virtual core::position2di getPosition() { return core::position2di(); } + virtual core::rect getRect() { return core::rect(); } + virtual core::quaternion getQuaternion(){ return core::quaternion(); } + virtual core::matrix4 getMatrix() { return core::matrix4(); } + virtual core::triangle3df getTriangle() { return core::triangle3df(); } + virtual core::vector2df getVector2d() { return core::vector2df(); } + virtual core::vector2di getVector2di() { return core::vector2di(); } + virtual core::line2df getLine2d() { return core::line2df(); } + virtual core::line2di getLine2di() { return core::line2di(); } + virtual core::line3df getLine3d() { return core::line3df(); } + virtual core::line3di getLine3di() { return core::line3di(); } + virtual core::dimension2di getDimension2d() { return core::dimension2di(); } + virtual core::aabbox3d getBBox() { return core::aabbox3d(); } + virtual core::plane3df getPlane() { return core::plane3df(); } - // binary data attribute - EAT_BINARY, + virtual video::ITexture* getTexture() { return 0; } + virtual const char* getEnum() { return 0; } + virtual void* getUserPointer() { return 0; } - // texture reference attribute - EAT_TEXTURE, + virtual void setInt(s32 intValue) {}; + virtual void setFloat(f32 floatValue) {}; + virtual void setString(const char* text) {}; + virtual void setString(const wchar_t* text){ setString(core::stringc(text).c_str()); }; + virtual void setArray( core::array arr ) {}; + virtual void setColor(video::SColorf color) {}; + virtual void setColor(video::SColor color) {}; + virtual void setBool(bool boolValue) {}; + virtual void setBinary(void* data, s32 maxLenght) {}; + virtual void setVector(core::vector3df v) {}; + virtual void setPosition(core::position2di v) {}; + virtual void setRect(core::rect v) {}; + virtual void setQuaternion(core::quaternion v) {}; + virtual void setMatrix(core::matrix4 v) {}; + virtual void setTriangle(core::triangle3df v) {}; + virtual void setVector2d(core::vector2df v) {}; + virtual void setVector2d(core::vector2di v) {}; + virtual void setLine2d(core::line2df v) {}; + virtual void setLine2d(core::line2di v) {}; + virtual void setLine3d(core::line3df v) {}; + virtual void setLine3d(core::line3di v) {}; + virtual void setDimension2d(core::dimension2di v) {}; + virtual void setBBox(core::aabbox3d v) {}; + virtual void setPlane(core::plane3df v) {}; + virtual void setUserPointer(void* v) {}; - // user pointer void* - EAT_USER_POINTER, + virtual void setEnum(const char* enumValue, const char* const* enumerationLiterals) {}; + virtual void setTexture(video::ITexture*) {}; - // known attribute type count - EAT_COUNT, + core::stringc Name; - // unknown attribute - EAT_UNKNOWN + virtual E_ATTRIBUTE_TYPE getType() const = 0; + virtual const wchar_t* getTypeString() const = 0; }; + //! Provides a generic interface for attributes and their values and the possiblity to serialize them class IAttributes : public virtual IUnknown { public: + //! Default attribute values are returned as result when usual attributnames are not found + virtual void setDefaultAttributes(IAttributes * attrib) = 0; + virtual IAttributes * getDefaultAttributes() = 0; + + // set in which situations default attributes should be used. + virtual void setDefaultAttributeUsage(E_DEFAULT_ATTRIBUTE_USAGE usage) = 0; + //! Returns amount of attributes in this collection of attributes. virtual s32 getAttributeCount() = 0; @@ -740,6 +739,8 @@ public: //! Sets an attribute as user pointer virtual void setAttribute(s32 index, void* userPointer) = 0; + //! get attribute by name + virtual IAttribute* getAttributeP(const c8* attributeName) = 0; }; } // end namespace io diff -abBdpuNPr --exclude='*.svn' irrlicht-svn-ss/trunk/include/IGUIEnvironment.h Irrlicht_starsonata/include/IGUIEnvironment.h --- irrlicht-svn-ss/trunk/include/IGUIEnvironment.h 2007-07-26 02:11:22.000000000 +0200 +++ Irrlicht_starsonata/include/IGUIEnvironment.h 2008-05-31 04:53:40.000000000 +0200 @@ -12,6 +13,8 @@ #include "IEventReceiver.h" #include "IXMLReader.h" +#include "EAttributes.h" + namespace irr { class IOSOperator; @@ -418,6 +445,20 @@ public: //! reads an element virtual void readGUIElement(io::IXMLReader* reader, IGUIElement* parent) =0; + //! remove default attribute settings for all element types + virtual void clearDefaultElementAttributes() = 0; + + //! load a set of default attribute settings from a xml file + virtual bool loadDefaultElementAttributes(const c8* filename) = 0; + + //! save current default attribute settings to a xml file + virtual bool saveDefaultElementAttributes(const c8* filename) = 0; + + //! Use the settings of the given IGUIElement as default attribute settings for this element type + virtual void setDefaultElementAttribute(IGUIElement* defaultElement) = 0; + + //! Set how the default attributes for elements should be used + virtual void setDefaultElementAttributeUsage(io::E_DEFAULT_ATTRIBUTE_USAGE usage) = 0; }; diff -abBdpuNPr --exclude='*.svn' irrlicht-svn-ss/trunk/source/Irrlicht/CAttributeImpl.h Irrlicht_starsonata/source/Irrlicht/CAttributeImpl.h --- irrlicht-svn-ss/trunk/source/Irrlicht/CAttributeImpl.h 2007-07-26 02:11:08.000000000 +0200 +++ Irrlicht_starsonata/source/Irrlicht/CAttributeImpl.h 2007-12-28 23:36:02.000000000 +0100 @@ -1899,18 +1899,25 @@ class CStringWArrayAttribute : public IA { public: - CStringWArrayAttribute(const char* name, core::array value) + CStringWArrayAttribute(const char* name, const core::array& value) { Name = name; setArray(value); } + virtual bool isEqualTo(IAttribute* attrib) + { + if ( !attrib || attrib->getType() != EAT_STRINGWARRAY ) + return false; + return Value == static_cast(attrib)->Value; + } + virtual core::array getArray() { return Value; } - virtual void setArray(core::array value) + virtual void setArray(const core::array& value) { Value = value; } diff -abBdpuNPr --exclude='*.svn' irrlicht-svn-ss/trunk/source/Irrlicht/CAttributes.cpp Irrlicht_starsonata/source/Irrlicht/CAttributes.cpp --- irrlicht-svn-ss/trunk/source/Irrlicht/CAttributes.cpp 2007-07-26 02:11:08.000000000 +0200 +++ Irrlicht_starsonata/source/Irrlicht/CAttributes.cpp 2007-12-28 23:47:18.000000000 +0100 @@ -15,6 +15,8 @@ namespace io CAttributes::CAttributes(video::IVideoDriver* driver) : Driver(driver) +, DefaultAttributes(NULL) +, DefaultAttributeUsage(EDAU_IGNORE) { #ifdef _DEBUG setDebugName("CAttributes"); @@ -28,10 +30,32 @@ CAttributes::~CAttributes() { clear(); + if ( DefaultAttributes ) + DefaultAttributes->drop(); + if (Driver) Driver->drop(); } +void CAttributes::setDefaultAttributes(IAttributes * attrib) +{ + if ( DefaultAttributes ) + DefaultAttributes->drop(); + DefaultAttributes = attrib; + if ( DefaultAttributes ) + DefaultAttributes->grab(); +} + +IAttributes * CAttributes::getDefaultAttributes() +{ + return DefaultAttributes; +} + +// set in which situations default attributes should be used. +void CAttributes::setDefaultAttributeUsage(E_DEFAULT_ATTRIBUTE_USAGE usage) +{ + DefaultAttributeUsage = usage; +} //! Removes all attributes void CAttributes::clear() @@ -249,6 +273,12 @@ IAttribute* CAttributes::getAttributeP(c if (Attributes[i]->Name == attributeName) return Attributes[i]; + if ( DefaultAttributes && + (DefaultAttributeUsage == EDAU_READ_ONLY || DefaultAttributeUsage == EDAU_READ_WRITE) ) + { + return DefaultAttributes->getAttributeP(attributeName); + } + return 0; } @@ -1541,6 +1571,18 @@ void CAttributes::readAttributeFromXML(i } } +bool CAttributes::isEqualToDefaultAttribute(IAttribute* attrib) +{ + if ( !DefaultAttributes ) + return false; + + IAttribute * defaultAttrib = DefaultAttributes->getAttributeP(attrib->Name.c_str()); + if (!defaultAttrib) + return false; + + return attrib->isEqualTo( defaultAttrib ); +} + //! Write these attributes into a xml file bool CAttributes::write(io::IXMLWriter* writer, bool writeXMLHeader) { @@ -1556,6 +1598,9 @@ bool CAttributes::write(io::IXMLWriter* s32 i=0; for (; i<(s32)Attributes.size(); ++i) { + if ( (DefaultAttributeUsage == EDAU_WRITE_ONLY || DefaultAttributeUsage ==EDAU_READ_WRITE) + && isEqualToDefaultAttribute(Attributes[i]) ) + continue; if ( Attributes[i]->getType() == EAT_STRINGWARRAY ) { core::array arraynames, arrayvalues; diff -abBdpuNPr --exclude='*.svn' irrlicht-svn-ss/trunk/source/Irrlicht/CAttributes.h Irrlicht_starsonata/source/Irrlicht/CAttributes.h --- irrlicht-svn-ss/trunk/source/Irrlicht/CAttributes.h 2007-07-26 02:11:08.000000000 +0200 +++ Irrlicht_starsonata/source/Irrlicht/CAttributes.h 2007-10-22 18:56:54.000000000 +0200 @@ -17,13 +17,18 @@ namespace video namespace io { -class IAttribute; - //! Implementation of the IAttributes interface class CAttributes : public IAttributes { public: + //! Default attribute values are returned as result when usual attributnames are not found + virtual void setDefaultAttributes(IAttributes * attrib); + virtual IAttributes * getDefaultAttributes(); + + // set in which situations default attributes should be used. + virtual void setDefaultAttributeUsage(E_DEFAULT_ATTRIBUTE_USAGE usage); + CAttributes(video::IVideoDriver* driver=0); ~CAttributes(); @@ -642,86 +647,23 @@ public: //! Sets an attribute as user pointer virtual void setAttribute(s32 index, void* userPointer); + //! get attribute by name + virtual IAttribute* getAttributeP(const c8* attributeName); + protected: void readAttributeFromXML(io::IXMLReader* reader); + bool isEqualToDefaultAttribute(IAttribute* attrib); +private: core::array Attributes; - IAttribute* getAttributeP(const c8* attributeName); - video::IVideoDriver* Driver; -}; - - -class IAttribute : public virtual IUnknown -{ -public: - - virtual ~IAttribute() {}; - - virtual s32 getInt() { return 0; } - virtual f32 getFloat() { return 0; } - virtual video::SColorf getColorf() { return video::SColorf(1.0f,1.0f,1.0f,1.0f); } - virtual video::SColor getColor() { return video::SColor(255,255,255,255); } - virtual core::stringc getString() { return core::stringc(getStringW().c_str()); } - virtual core::stringw getStringW() { return core::stringw(); } - virtual core::array getArray() { return core::array(); }; - virtual bool getBool() { return false; } - virtual void getBinary(void* outdata, s32 maxLength) {}; - virtual core::vector3df getVector() { return core::vector3df(); } - virtual core::position2di getPosition() { return core::position2di(); } - virtual core::rect getRect() { return core::rect(); } - virtual core::quaternion getQuaternion(){ return core::quaternion(); } - virtual core::matrix4 getMatrix() { return core::matrix4(); } - virtual core::triangle3df getTriangle() { return core::triangle3df(); } - virtual core::vector2df getVector2d() { return core::vector2df(); } - virtual core::vector2di getVector2di() { return core::vector2di(); } - virtual core::line2df getLine2d() { return core::line2df(); } - virtual core::line2di getLine2di() { return core::line2di(); } - virtual core::line3df getLine3d() { return core::line3df(); } - virtual core::line3di getLine3di() { return core::line3di(); } - virtual core::dimension2di getDimension2d() { return core::dimension2di(); } - virtual core::aabbox3d getBBox() { return core::aabbox3d(); } - virtual core::plane3df getPlane() { return core::plane3df(); } - - virtual video::ITexture* getTexture() { return 0; } - virtual const char* getEnum() { return 0; } - virtual void* getUserPointer() { return 0; } - - virtual void setInt(s32 intValue) {}; - virtual void setFloat(f32 floatValue) {}; - virtual void setString(const char* text) {}; - virtual void setString(const wchar_t* text){ setString(core::stringc(text).c_str()); }; - virtual void setArray( core::array arr ) {}; - virtual void setColor(video::SColorf color) {}; - virtual void setColor(video::SColor color) {}; - virtual void setBool(bool boolValue) {}; - virtual void setBinary(void* data, s32 maxLenght) {}; - virtual void setVector(core::vector3df v) {}; - virtual void setPosition(core::position2di v) {}; - virtual void setRect(core::rect v) {}; - virtual void setQuaternion(core::quaternion v) {}; - virtual void setMatrix(core::matrix4 v) {}; - virtual void setTriangle(core::triangle3df v) {}; - virtual void setVector2d(core::vector2df v) {}; - virtual void setVector2d(core::vector2di v) {}; - virtual void setLine2d(core::line2df v) {}; - virtual void setLine2d(core::line2di v) {}; - virtual void setLine3d(core::line3df v) {}; - virtual void setLine3d(core::line3di v) {}; - virtual void setDimension2d(core::dimension2di v) {}; - virtual void setBBox(core::aabbox3d v) {}; - virtual void setPlane(core::plane3df v) {}; - virtual void setUserPointer(void* v) {}; - - virtual void setEnum(const char* enumValue, const char* const* enumerationLiterals) {}; - virtual void setTexture(video::ITexture*) {}; - core::stringc Name; + // MICHA, STARSONATA + IAttributes * DefaultAttributes; + E_DEFAULT_ATTRIBUTE_USAGE DefaultAttributeUsage; - virtual E_ATTRIBUTE_TYPE getType() const = 0; - virtual const wchar_t* getTypeString() const = 0; }; } // end namespace io diff -abBpNPwrU2 --exclude='*.svn' irrlicht-svn-ss/trunk/source/Irrlicht/CGUIEnvironment.cpp Irrlicht_starsonata/source/Irrlicht/CGUIEnvironment.cpp --- irrlicht-svn-ss/trunk/source/Irrlicht/CGUIEnvironment.cpp 2007-07-26 02:11:08.000000000 +0200 +++ Irrlicht_starsonata/source/Irrlicht/CGUIEnvironment.cpp 2008-08-15 18:20:47.000000000 +0200 @@ -31,4 +33,5 @@ #include "CGUIToolBar.h" +#include "CAttributes.h" #include "CDefaultGUIElementFactory.h" #include "IWriteFile.h" @@ -50,4 +55,5 @@ const wchar_t* IRR_XML_FORMAT_GUI_ELEMEN CGUIEnvironment::CGUIEnvironment(io::IFileSystem* fs, video::IVideoDriver* driver, IOSOperator* op) : IGUIElement(EGUIET_ELEMENT, 0, 0, 0, core::rect(core::position2d(0,0), driver ? driver->getScreenSize() : core::dimension2d(0,0))), + DefaultElementAttributeUsage(io::EDAU_IGNORE), Driver(driver), Hovered(0), Focus(0), LastHoveredMousePos(0,0), CurrentSkin(0), FileSystem(fs), UserReceiver(0), Operator(op) @@ -134,4 +146,6 @@ CGUIEnvironment::~CGUIEnvironment() } + clearDefaultElementAttributes(); + // delete all fonts u32 i; @@ -707,5 +769,213 @@ bool CGUIEnvironment::loadGUI(io::IReadF } +void CGUIEnvironment::clearDefaultElementAttributes() +{ + for ( u32 i=0; i < DefaultElementAttributes.size(); ++i ) + { + DefaultElementAttributes[i].Attribute->drop(); + } + DefaultElementAttributes.clear(); +} + +bool CGUIEnvironment::loadDefaultElementAttributes(const c8* filename) +{ + io::IReadFile* file = FileSystem->createAndOpenFile(filename); + if (!file) + { + os::Printer::log("Unable to open gui file", filename, ELL_ERROR); + return false; + } + + io::IXMLReader* reader = FileSystem->createXMLReader(file); + if (!reader) + { + file->drop(); + os::Printer::log("not a valid XML file", file->getFileName(), ELL_ERROR); + return false; + } + + // read file + while(reader->read()) + { + readDefaultElementAttribute(reader); + } + + // finish up + reader->drop(); + file->drop(); + + return true; + +} + +//! Set how the default attributes for elements should be used +void CGUIEnvironment::setDefaultElementAttributeUsage(io::E_DEFAULT_ATTRIBUTE_USAGE usage) +{ + DefaultElementAttributeUsage = usage; +} + +// Set a default element attribute, overriding former attributes of the same type +// The used Attribute will be grab'ed within this function. +void CGUIEnvironment::setDefaultElementAttribute(const SDefaultElementAttribute& attribute) +{ + if ( attribute.Attribute ) + attribute.Attribute->grab(); + for ( u32 i=0; idrop(); + DefaultElementAttributes[i] = attribute; + return; + } + } + DefaultElementAttributes.push_back( attribute ); +} + +void CGUIEnvironment::readDefaultElementAttribute(io::IXMLReader* reader) +{ + if (!reader) + return; + + SDefaultElementAttribute defaultAttrib; + if ( reader->getNodeType() == io::EXN_NONE + || reader->getNodeType() == io::EXN_UNKNOWN + || reader->getNodeType() == io::EXN_ELEMENT_END) + return; + + if (!wcscmp(IRR_XML_FORMAT_GUI_ENV, reader->getNodeName())) + { + // defaultAttrib.Type = ; CGUIEnvironment seems to have no own EGUI_ELEMENT_TYPE + } + else if (!wcscmp(IRR_XML_FORMAT_GUI_ELEMENT, reader->getNodeName())) + { + // find node type and create it + core::stringc attrName = reader->getAttributeValue(IRR_XML_FORMAT_GUI_ELEMENT_ATTR_TYPE); + defaultAttrib.Type = getTypeFromName(attrName.c_str()); + defaultAttrib.TypeName = attrName; + } + + // read attributes + + while(reader->read()) + { + bool endreached = false; + + switch (reader->getNodeType()) + { + case io::EXN_ELEMENT_END: + if (!wcscmp(IRR_XML_FORMAT_GUI_ELEMENT, reader->getNodeName()) || + !wcscmp(IRR_XML_FORMAT_GUI_ENV, reader->getNodeName())) + { + endreached = true; + } + break; + case io::EXN_ELEMENT: + if (!wcscmp(L"attributes", reader->getNodeName())) + { + // read attributes + io::IAttributes* attr = FileSystem->createEmptyAttributes(Driver); + attr->read(reader, true); + if ( defaultAttrib.Type != EGUIET_ELEMENT ) + { + defaultAttrib.Attribute = attr; + setDefaultElementAttribute(defaultAttrib); + } + attr->drop(); + } + else + if (!wcscmp(IRR_XML_FORMAT_GUI_ELEMENT, reader->getNodeName()) || + !wcscmp(IRR_XML_FORMAT_GUI_ENV, reader->getNodeName())) + { + readDefaultElementAttribute(reader); + } + else + { + os::Printer::log("Found unknown element in irrlicht GUI file", + core::stringc(reader->getNodeName()).c_str()); + } + + break; + } + + if (endreached) + break; + } +} + +bool CGUIEnvironment::saveDefaultElementAttributes(const c8* filename) +{ + io::IWriteFile* file = FileSystem->createAndWriteFile(filename); + if (!file) + return false; + + io::IXMLWriter* writer = FileSystem->createXMLWriter(file); + if (!writer) + { + file->drop(); + return false; + } + + writer->writeXMLHeader(); + + // root element start (to get a valid xml-file) + core::stringw nameRoot("unknown"); + writer->writeElement( IRR_XML_FORMAT_GUI_ELEMENT, + false, IRR_XML_FORMAT_GUI_ELEMENT_ATTR_TYPE, + nameRoot.c_str() ); + writer->writeLineBreak(); + writer->writeLineBreak(); + + for ( u32 i=0; igetAttributeCount() > 0 ) + { + core::stringw name(DefaultElementAttributes[i].TypeName.c_str()); + writer->writeElement( IRR_XML_FORMAT_GUI_ELEMENT, + false, IRR_XML_FORMAT_GUI_ELEMENT_ATTR_TYPE, + name.c_str() ); + + writer->writeLineBreak(); + writer->writeLineBreak(); + + DefaultElementAttributes[i].Attribute->write(writer); + writer->writeLineBreak(); + + // write closing brace + writer->writeClosingTag(IRR_XML_FORMAT_GUI_ELEMENT); + writer->writeLineBreak(); + writer->writeLineBreak(); + } + } + + // close root element + writer->writeClosingTag(IRR_XML_FORMAT_GUI_ELEMENT); + writer->writeLineBreak(); + writer->writeLineBreak(); + + writer->drop(); + file->drop(); + + return true; +} + +void CGUIEnvironment::setDefaultElementAttribute(IGUIElement* defaultElement) +{ + if ( !defaultElement ) + return; + + SDefaultElementAttribute attrib; + attrib.Type = defaultElement->getType(); + attrib.TypeName = defaultElement->getTypeName(); + + io::IAttributes* attr = FileSystem->createEmptyAttributes(Driver); + defaultElement->serializeAttributes(attr); + attrib.Attribute = attr; + setDefaultElementAttribute(attrib); + attr->drop(); +} //! reads an element @@ -723,4 +993,7 @@ void CGUIEnvironment::readGUIElement(io: reader->read(); + if ( reader->getNodeType() == io::EXN_ELEMENT_END) + return; + if (!parent && !wcscmp(IRR_XML_FORMAT_GUI_ENV, reader->getNodeName())) { @@ -761,5 +1034,19 @@ void CGUIEnvironment::readGUIElement(io: if (node) + { + // set the default attribute if available + u32 i; + for ( i=0; i < DefaultElementAttributes.size(); ++i ) + { + if ( DefaultElementAttributes[i].Type == node->getType() ) + { + attr->setDefaultAttributeUsage( DefaultElementAttributeUsage ); + attr->setDefaultAttributes( DefaultElementAttributes[i].Attribute ); + break; + } + } + node->deserializeAttributes(attr); + } attr->drop(); @@ -769,5 +1056,5 @@ void CGUIEnvironment::readGUIElement(io: !wcscmp(IRR_XML_FORMAT_GUI_ENV, reader->getNodeName())) { - readGUIElement(reader, node); + readGUIElement(reader, node ? node : parent); } else @@ -795,7 +1082,19 @@ void CGUIEnvironment::writeGUIElement(io const wchar_t* name = 0; - // write properties - io::IAttributes* attr = FileSystem->createEmptyAttributes(); + + // set the default attribute if available + u32 i; + for ( i=0; i < DefaultElementAttributes.size(); ++i ) + { + if ( DefaultElementAttributes[i].Type == node->getType() ) + { + attr->setDefaultAttributeUsage( DefaultElementAttributeUsage ); + attr->setDefaultAttributes( DefaultElementAttributes[i].Attribute ); + break; + } + } + + // write properties node->serializeAttributes(attr); diff -abBdpuNPr --exclude='*.svn' irrlicht-svn-ss/trunk/source/Irrlicht/CGUIEnvironment.h Irrlicht_starsonata/source/Irrlicht/CGUIEnvironment.h --- irrlicht-svn-ss/trunk/source/Irrlicht/CGUIEnvironment.h 2007-07-26 02:11:08.000000000 +0200 +++ Irrlicht_starsonata/source/Irrlicht/CGUIEnvironment.h 2008-05-31 04:51:06.000000000 +0200 @@ -10,6 +10,7 @@ #include "irrArray.h" #include "IFileSystem.h" #include "IOSOperator.h" +#include "EAttributes.h" namespace irr { @@ -226,7 +246,22 @@ public: //! reads an element virtual void readGUIElement(io::IXMLReader* reader, IGUIElement* parent); + //! remove default attribute settings for all element types + virtual void clearDefaultElementAttributes(); + + //! load a set of default attribute settings from a xml file + virtual bool loadDefaultElementAttributes(const c8* filename); + //! save current default attribute settings to a xml file + virtual bool saveDefaultElementAttributes(const c8* filename); + + //! Use the settings of the given IGUIElement as default attribute settings for this element type + virtual void setDefaultElementAttribute(IGUIElement* defaultElement); + + //! Set how the default attributes for elements should be used + virtual void setDefaultElementAttributeUsage(io::E_DEFAULT_ATTRIBUTE_USAGE usage); + + virtual void readDefaultElementAttribute(io::IXMLReader* reader); private: IGUIElement* getNextElement(bool reverse=false, bool group=false); @@ -261,4 +299,20 @@ private: }; SToolTip ToolTip; + + struct SDefaultElementAttribute + { + SDefaultElementAttribute() : Type(EGUIET_ELEMENT), Attribute(0) {} + + EGUI_ELEMENT_TYPE Type; + core::stringc TypeName; + io::IAttributes * Attribute; + }; + core::array DefaultElementAttributes; + io::E_DEFAULT_ATTRIBUTE_USAGE DefaultElementAttributeUsage; + + // Set a default element attribute, overriding former attributes of the same type + // The used Attribute will be grab'ed within this function. + void setDefaultElementAttribute(const SDefaultElementAttribute& attribute); + void updateHoveredElement(core::position2d mousePos);