void nuiFrame::InitAttributes()
{
nuiAttribute<const nuiRect&>* AttributeRect = new nuiAttribute<const nuiRect&>
(nglString(_T("ClientRect")), nuiUnitNone,
nuiAttribute<const nuiRect&>::GetterDelegate(this, &nuiFrame::GetSourceClientRect),
nuiAttribute<const nuiRect&>::SetterDelegate(this, &nuiFrame::SetSourceClientRect));
nuiAttribute<const nuiColor&>* AttributeColor = new nuiAttribute<const nuiColor&>
(nglString(_T("Color")), nuiUnitNone,
nuiAttribute<const nuiColor&>::GetterDelegate(this, &nuiFrame::GetColor),
nuiAttribute<const nuiColor&>::SetterDelegate(this, &nuiFrame::SetColor));
nuiAttribute<bool>* AttributeFrameColor = new nuiAttribute<bool>
(nglString(_T("UseWidgetFrameColor")), nuiUnitBoolean,
nuiAttribute<bool>::GetterDelegate(this, &nuiFrame::IsWidgetFrameColorUsed),
nuiAttribute<bool>::SetterDelegate(this, &nuiFrame::UseWidgetFrameColor));
nuiAttribute<const nglPath&>* AttributeTexture = new nuiAttribute<const nglPath&>
(nglString(_T("Texture")), nuiUnitNone,
nuiMakeDelegate(this, &nuiFrame::GetTexturePath),
nuiMakeDelegate(this, &nuiFrame::SetTexturePath));
nuiAttribute<bool>* AttributeInterpolation = new nuiAttribute<bool>
(nglString(_T("Interpolation")), nuiUnitBoolean,
nuiAttribute<bool>::GetterDelegate(this, &nuiFrame::IsInterpolated),
nuiAttribute<bool>::SetterDelegate(this, &nuiFrame::SetInterpolated));
AddAttribute(_T("ClientRect"), AttributeRect);
AddAttribute(_T("Color"), AttributeColor);
AddAttribute(_T("UseWidgetFrameColor"), AttributeFrameColor);
AddAttribute(_T("Texture"), AttributeTexture);
AddAttribute(_T("Interpolation"), AttributeInterpolation);
}
xmlNode* FArchiveXML::WriteGeometryMesh(FCDObject* object, xmlNode* parentNode)
{
FCDGeometryMesh* geometryMesh = (FCDGeometryMesh*)object;
xmlNode* meshNode = NULL;
if (geometryMesh->IsConvex() && !geometryMesh->GetConvexHullOf().empty())
{
meshNode = AddChild(parentNode, DAE_CONVEX_MESH_ELEMENT);
FUSStringBuilder convexHullOfName(geometryMesh->GetConvexHullOf());
AddAttribute(meshNode, DAE_CONVEX_HULL_OF_ATTRIBUTE, convexHullOfName);
}
else
{
meshNode = AddChild(parentNode, DAE_MESH_ELEMENT);
// Write out the sources
for (size_t i = 0; i < geometryMesh->GetSourceCount(); ++i)
{
FArchiveXML::LetWriteObject(geometryMesh->GetSource(i), meshNode);
}
// Write out the <vertices> element
xmlNode* verticesNode = AddChild(meshNode, DAE_VERTICES_ELEMENT);
xmlNode* verticesInputExtraNode = NULL,* verticesInputExtraTechniqueNode = NULL;
for (size_t i = 0; i < geometryMesh->GetVertexSourceCount(); ++i)
{
FCDGeometrySource* source = geometryMesh->GetVertexSource(i);
const char* semantic = FUDaeGeometryInput::ToString(source->GetType());
AddInput(verticesNode, source->GetDaeId(), semantic);
if (geometryMesh->GetPolygonsCount() > 0)
{
FCDGeometryPolygons* firstPolys = geometryMesh->GetPolygons(0);
FCDGeometryPolygonsInput* input = firstPolys->FindInput(source);
FUAssert(input != NULL, continue);
if (input->GetSet() != -1)
{
// We are interested in the set information, so if it is available, export it as an extra.
if (verticesInputExtraNode == NULL)
{
verticesInputExtraNode = FUXmlWriter::CreateNode(DAE_EXTRA_ELEMENT);
verticesInputExtraTechniqueNode = FUXmlWriter::AddChild(verticesInputExtraNode, DAE_TECHNIQUE_ELEMENT);
FUXmlWriter::AddAttribute(verticesInputExtraTechniqueNode, DAE_PROFILE_ATTRIBUTE, DAE_FCOLLADA_PROFILE);
}
AddInput(verticesInputExtraTechniqueNode, source->GetDaeId(), semantic, -1, input->GetSet());
}
}
}
if (verticesInputExtraNode != NULL) AddChild(verticesNode, verticesInputExtraNode);
FUSStringBuilder verticesNodeId(geometryMesh->GetDaeId());
verticesNodeId.append("-vertices");
AddAttribute(verticesNode, DAE_ID_ATTRIBUTE, verticesNodeId);
// Write out the polygons
for (size_t i = 0; i < geometryMesh->GetPolygonsCount(); ++i)
{
FArchiveXML::LetWriteObject(geometryMesh->GetPolygons(i), meshNode);
}
}
wxGLAttributes& wxGLAttributes::MinAcumRGBA(int mRed, int mGreen, int mBlue, int mAlpha)
{
int acumBits = 0;
if ( mRed >= 0)
{
AddAttribute(WGL_ACCUM_RED_BITS_ARB);
AddAttribute(mRed);
acumBits += mRed;
}
if ( mGreen >= 0)
{
AddAttribute(WGL_ACCUM_GREEN_BITS_ARB);
AddAttribute(mGreen);
acumBits += mGreen;
}
if ( mBlue >= 0)
{
AddAttribute(WGL_ACCUM_BLUE_BITS_ARB);
AddAttribute(mBlue);
acumBits += mBlue;
}
if ( mAlpha >= 0)
{
AddAttribute(WGL_ACCUM_ALPHA_BITS_ARB);
AddAttribute(mAlpha);
acumBits += mAlpha;
}
if ( acumBits )
{
AddAttribute(WGL_ACCUM_BITS_ARB);
AddAttribute(acumBits);
}
return *this;
}
wxGLAttributes& wxGLAttributes::FrameBuffersRGB()
{
AddAttribute(WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB);
AddAttribute(GL_TRUE);
SetNeedsARB();
return *this;
}
wxGLContextAttrs& wxGLContextAttrs::NoResetNotify()
{
AddAttribute(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB);
AddAttribute(WGL_NO_RESET_NOTIFICATION_ARB);
SetNeedsARB();
return *this;
}
void nuiDecoration::InitAttributes()
{
AddAttribute(new nuiAttribute<bool>
(nglString(_T("EnableBorder")), nuiUnitBoolean,
nuiMakeDelegate(this, &nuiDecoration::IsBorderEnabled),
nuiMakeDelegate(this, &nuiDecoration::EnableBorder)));
AddAttribute(new nuiAttribute<bool>
(nglString(_T("UseWidgetAlpha")), nuiUnitNone,
nuiMakeDelegate(this, &nuiDecoration::IsWidgetAlphaUsed),
nuiMakeDelegate(this, &nuiDecoration::UseWidgetAlpha)));
AddAttribute(new nuiAttribute<bool>
(nglString(_T("RedrawOnHover")), nuiUnitNone,
nuiMakeDelegate(this, &nuiDecoration::GetRedrawOnHover),
nuiMakeDelegate(this, &nuiDecoration::RedrawOnHover)));
AddAttribute(new nuiAttribute<nuiDecorationLayer>
(nglString(_T("Layer")), nuiUnitNone,
nuiMakeDelegate(this, &nuiDecoration::GetLayer),
nuiMakeDelegate(this, &nuiDecoration::SetLayer)));
}
//-------------------------------------------------------------------------------------------------
WorldShader::WorldShader( const char *name ) {
AddShader( "glsl\\worldshader.v.glsl", GL_VERTEX_SHADER );
AddShader( "glsl\\worldshader.f.glsl", GL_FRAGMENT_SHADER );
Link();
AddUniform( u_pattern_sampler, "sampler_patterns" );
AddUniform( u_noise_sampler, "sampler_noise" );
AddUniform( u_global_translation, "global_translation" );
AddUniform( u_camera, "camera" );
AddUniform( u_skylight_color, "skylight_color" );
AddUniform( u_skylight_intensity, "skylight_intensity" );
AddUniform( u_fog_distance, "fog_distance" );
AddUniform( u_fog_length, "fog_length" );
AddAttribute( a_instance_translation, "instance_translation", 1 );
AddAttribute( a_instance_form, "instance_form", 1 );
AddAttribute( a_instance_texture, "instance_texture", 1 );
AddAttribute( a_instance_color, "instance_color", 1, 4 );
//AddAttribute( attribInstanceColor2, "instance_color_2", 1 );
//AddAttribute( attribInstanceColor3, "instance_color_3", 1 );
//AddAttribute( attribInstanceColor4, "instance_color_4", 1 );
AddUniform( u_texture_sampler, "sampler_texture" );
AddUniform( u_texture_translation, "texture_translation" );
AddUniform( u_opacity, "opacity" );
AddUniform( u_fog_color, "fog_color" );
AddUniform( u_light_brightness, "light_brightness" );
AddUniform( u_light_colors, "light_colors" );
AddUniform( u_light_positions, "light_positions" );
Register( name );
}
void nuiLayout::SetProperty(const nglString& rName, const nglString& rValue)
{
nuiAttribBase attr(GetAttribute(rName));
if (attr.IsValid())
{
attr.FromString(rValue);
return;
}
if (rName.CompareLeft("VAnchors_", true) == 0 || rName.CompareLeft("HAnchors_", true) == 0)
{
// Create an attribute for this anchor, unless it exists already
AddAttribute(new LayoutAnchorValue(rName, this));
{
nuiAttribBase attr(GetAttribute(rName));
NGL_ASSERT(attr.IsValid());
attr.FromString(rValue);
}
}
else if (rName.CompareLeft("VAnchorsType_", true) == 0 || rName.CompareLeft("HAnchorsType_", true) == 0)
{
// Create an attribute for this anchor, unless it exists already
AddAttribute(new nuiAttribute<nuiAnchorType>(rName, this));
{
nuiAttribBase attr(GetAttribute(rName));
NGL_ASSERT(attr.IsValid());
attr.FromString(rValue);
}
}
else
{
nuiObject::SetProperty(rName, rValue);
}
}
void nuiColorDecoration::InitAttributes()
{
AddAttribute(new nuiAttribute<const nuiRect&>
(nglString(_T("ClientRect")), nuiUnitNone,
nuiAttribute<const nuiRect&>::GetterDelegate(this, &nuiColorDecoration::GetSourceClientRect),
nuiAttribute<const nuiRect&>::SetterDelegate(this, &nuiColorDecoration::SetSourceClientRect)));
AddAttribute(new nuiAttribute<float>
(nglString(_T("StrokeSize")), nuiUnitPixels,
nuiMakeDelegate(this, &nuiColorDecoration::GetStrokeSize),
nuiMakeDelegate(this, &nuiColorDecoration::SetStrokeSize)));
AddAttribute(new nuiAttribute<const nuiColor&>
(nglString(_T("FillColor")), nuiUnitColor,
nuiMakeDelegate(this, &nuiColorDecoration::GetFillColor),
nuiMakeDelegate(this, &nuiColorDecoration::SetFillColor)));
AddAttribute(new nuiAttribute<const nuiColor&>
(nglString(_T("StrokeColor")), nuiUnitColor,
nuiMakeDelegate(this, &nuiColorDecoration::GetStrokeColor),
nuiMakeDelegate(this, &nuiColorDecoration::SetStrokeColor)));
AddAttribute(new nuiAttribute<nuiShapeMode>
(nglString(_T("ShapeMode")), nuiUnitNone,
nuiMakeDelegate(this, &nuiColorDecoration::GetShapeMode),
nuiMakeDelegate(this, &nuiColorDecoration::SetShapeMode)));
}
//-----------------------------------------------------------------------------
// SDEditor class implementation
//-----------------------------------------------------------------------------
SDEditor::SDEditor (AudioEffect *effect)
: AEffEditor (effect), mpWin(NULL), mLock(false)
{
SetObjectClass(_T("SDEditor"));
nuiAttribute<float>* pDelayAttrib = new nuiValueAttribute<float>(_T("Delay"), effect->getParameter(kDelay));
pDelayAttrib->SetEditor(CreateEditor);
pDelayAttrib->SetFormater(DelayFormater);
nuiAttrib<float> delay(this, pDelayAttrib);
mSlotSink.Connect(delay.GetChangedSignal(), nuiMakeDelegate(this, &SDEditor::SetDelay));
AddAttribute(pDelayAttrib);
nuiAttribute<float>* pFeedbackAttrib = new nuiValueAttribute<float>(_T("Feedback"), effect->getParameter(kFeedBack));
pFeedbackAttrib->SetEditor(CreateEditor);
pFeedbackAttrib->SetFormater(FeedbackFormater);
nuiAttrib<float> feedback(this, pFeedbackAttrib);
mSlotSink.Connect(feedback.GetChangedSignal(), nuiMakeDelegate(this, &SDEditor::SetFeedback));
AddAttribute(pFeedbackAttrib);
nuiAttribute<float>* pOutAttrib = new nuiValueAttribute<float>(_T("Out"), effect->getParameter(kOut));
pOutAttrib->SetEditor(CreateEditor);
pOutAttrib->SetFormater(OutFormater);
nuiAttrib<float> out(this, pOutAttrib);
mSlotSink.Connect(out.GetChangedSignal(), nuiMakeDelegate(this, &SDEditor::SetOut));
AddAttribute(pOutAttrib);
mMainRect.top = 0;
mMainRect.left = 0;
mMainRect.bottom = 240;
mMainRect.right = 320;
effect->setEditor(this);
}
wxGLAttributes& wxGLAttributes::MinRGBA(int mRed, int mGreen, int mBlue, int mAlpha)
{
int colorBits = 0;
if ( mRed >= 0)
{
AddAttribute(WGL_RED_BITS_ARB);
AddAttribute(mRed);
colorBits += mRed;
}
if ( mGreen >= 0)
{
AddAttribute(WGL_GREEN_BITS_ARB);
AddAttribute(mGreen);
colorBits += mGreen;
}
if ( mBlue >= 0)
{
AddAttribute(WGL_BLUE_BITS_ARB);
AddAttribute(mBlue);
colorBits += mBlue;
}
if ( mAlpha >= 0)
{
AddAttribute(WGL_ALPHA_BITS_ARB);
AddAttribute(mAlpha);
// doesn't count in colorBits
}
if ( colorBits )
{
AddAttribute(WGL_COLOR_BITS_ARB);
AddAttribute(colorBits);
}
return *this;
}
void nuiButton::InitAttributes()
{
AddAttribute(new nuiAttribute<bool>
(nglString(_T("Pressed")), nuiUnitBoolean,
nuiMakeDelegate(this, &nuiButton::IsPressed),
nuiMakeDelegate(this, &nuiButton::SetPressed)));
AddAttribute(new nuiAttribute<bool>
(nglString(_T("AutoRepeat")), nuiUnitBoolean,
nuiMakeDelegate(this, &nuiButton::GetAutoRepeat),
nuiMakeDelegate(this, &nuiButton::EnableAutoRepeat)));
AddAttribute(new nuiAttribute<float>
(nglString(_T("AutoRepeatDelay")), nuiUnitSeconds,
nuiMakeDelegate(this, &nuiButton::GetAutoRepeatDelay),
nuiMakeDelegate(this, &nuiButton::SetAutoRepeatDelay)));
AddAttribute(new nuiAttribute<float>
(nglString(_T("AutoRepeatMinDelay")), nuiUnitSeconds,
nuiMakeDelegate(this, &nuiButton::GetAutoRepeatMinDelay),
nuiMakeDelegate(this, &nuiButton::SetAutoRepeatMinDelay)));
AddAttribute(new nuiAttribute<nuiSize>
(nglString(_T("ActivationOffset")), nuiUnitPixels,
nuiMakeDelegate(this, &nuiButton::GetActivationOffset),
nuiMakeDelegate(this, &nuiButton::SetActivationOffset)));
}
CStunSharedSecretResponseMessage::CStunSharedSecretResponseMessage(const char* pszUsername,
const char* pszPassword):
CStunMessage (SHARED_SECRET_RESPONSE)
{
AddAttribute (new CStunUsernameAttribute (pszUsername));
AddAttribute (new CStunPasswordAttribute (pszPassword));
}
wxGLContextAttrs& wxGLContextAttrs::LoseOnReset()
{
AddAttribute(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB);
AddAttribute(WGL_LOSE_CONTEXT_ON_RESET_ARB);
SetNeedsARB();
return *this;
}
void XMLTree::AddAttribute(const string& name, const bool& value )
{
if(value == true )
AddAttribute(name, string("true"));
else
AddAttribute(name, string("false"));
}
const char *XMLProcedureCall::MergeXSL(const char *szXSLTemplate)
{
AddAttribute( "MergeXSL", "yes" );
AddAttribute( "Template", szXSLTemplate );
m_bRunObjectFactory = 0;
return Execute();
}
xmlNode* AddArray(xmlNode* parent, const char* id, const char* arrayType, const char* content, size_t count)
{
xmlNode* arrayNode = AddChild(parent, arrayType);
AddContentUnprocessed(arrayNode, content);
AddAttribute(arrayNode, DAE_ID_ATTRIBUTE, id);
AddAttribute(arrayNode, DAE_COUNT_ATTRIBUTE, count);
return arrayNode;
}
xmlNode* AddParameter(xmlNode* parent, const char* name, const char* type)
{
xmlNode* parameterNode = AddChild(parent, DAE_PARAMETER_ELEMENT);
if (name != NULL && *name != 0) AddAttribute(parameterNode, DAE_NAME_ATTRIBUTE, name);
if (type == NULL) type = DAE_FLOAT_TYPE;
AddAttribute(parameterNode, DAE_TYPE_ATTRIBUTE, type);
return parameterNode;
}
wxGLContextAttrs& wxGLContextAttrs::MinorVersion(int val)
{
if ( val >= 0 )
{
AddAttribute(WGL_CONTEXT_MINOR_VERSION_ARB);
AddAttribute(val);
}
return *this;
}
wxGLAttributes& wxGLAttributes::BufferSize(int val)
{
if ( val >= 0 )
{
AddAttribute(WGL_COLOR_BITS_ARB);
AddAttribute(val);
}
return *this;
}
wxGLAttributes& wxGLAttributes::AuxBuffers(int val)
{
if ( val >= 0 )
{
AddAttribute(WGL_AUX_BUFFERS_ARB);
AddAttribute(val);
}
return *this;
}
wxGLAttributes& wxGLAttributes::Depth(int val)
{
if ( val >= 0 )
{
AddAttribute(WGL_DEPTH_BITS_ARB);
AddAttribute(val);
}
return *this;
}
wxGLAttributes& wxGLAttributes::Stencil(int val)
{
if ( val >= 0 )
{
AddAttribute(WGL_STENCIL_BITS_ARB);
AddAttribute(val);
}
return *this;
}
xmlNode* AddInput(xmlNode* parent, const char* sourceId, const char* semantic, int32 offset, int32 set)
{
if (sourceId == NULL || *sourceId == 0 || semantic == NULL || *semantic == 0) return NULL;
xmlNode* inputNode = AddChild(parent, DAE_INPUT_ELEMENT);
AddAttribute(inputNode, DAE_SEMANTIC_ATTRIBUTE, semantic);
AddAttribute(inputNode, DAE_SOURCE_ATTRIBUTE, fm::string("#") + sourceId);
if (offset >= 0) AddAttribute(inputNode, DAE_OFFSET_ATTRIBUTE, offset);
if (set >= 0) AddAttribute(inputNode, DAE_SET_ATTRIBUTE, set);
return inputNode;
}
wxGLContextAttrs& wxGLContextAttrs::ReleaseFlush(int val)
{
AddAttribute(WGL_CONTEXT_RELEASE_BEHAVIOR_ARB);
if ( val == 1 )
AddAttribute(WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB);
else
AddAttribute(WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB);
SetNeedsARB();
return *this;
}
wxGLAttributes& wxGLAttributes::Samplers(int val)
{
if ( val >= 0 )
{
AddAttribute(WGL_SAMPLES_ARB);
AddAttribute(val);
SetNeedsARB();
}
return *this;
}
void PointSet::Initialize ( int mode, int total )
{
switch (mode) {
case BPOINT: {
FreeBuffers ();
AddBuffer ( BPOINT, sizeof ( Point ), total );
AddAttribute ( 0, "pos", sizeof ( Vector3DF ), false );
AddAttribute ( 0, "color", sizeof ( DWORD ), false );
AddAttribute ( 0, "type", sizeof ( unsigned short), false );
Reset ();
} break;
case BPARTICLE: {
FreeBuffers ();
AddBuffer ( BPARTICLE, sizeof ( Particle ), total );
AddAttribute ( 0, "pos", sizeof ( Vector3DF ), false );
AddAttribute ( 0, "color", sizeof ( DWORD ), false );
AddAttribute ( 0, "vel", sizeof ( Vector3DF ), false );
AddAttribute ( 0, "ndx", sizeof ( unsigned short ), false );
AddAttribute ( 0, "age", sizeof ( unsigned short ), false );
AddAttribute ( 0, "type", sizeof ( unsigned short), false );
Reset ();
} break;
}
}
static void AddDevice(IXMLDOMDocument* pDoc,IXMLDOMElement* pParent,const DEVICE& d)
{
HRESULT hr;
IXMLDOMElementPtr bdatopology, topology, pintopology;
AddAttribute(pDoc,L"device_path",d.device_path.c_str(),pParent);
AddAttribute(pDoc,L"DeviceDesc",d.DeviceDesc.c_str(),pParent);
AddAttribute(pDoc,L"Service",d.Service.c_str(),pParent);
AddAttribute(pDoc,L"Class",d.Class.c_str(),pParent);
AddAttribute(pDoc,L"ClassGUID",d.ClassGUID.c_str(),pParent);
AddAttribute(pDoc,L"Driver",d.Driver.c_str(),pParent);
AddAttribute(pDoc,L"PhysicalDeviceObjectName",d.PhysicalDeviceObjectName.c_str(),pParent);
AddAttribute(pDoc,L"Enumerator_Name",d.Enumerator_Name.c_str(),pParent);
AddAttribute(pDoc,L"device_instance_id",d.device_instance_id.c_str(),pParent);
CreateElement(pDoc,L"bdatopology",&bdatopology);
CreateElement(pDoc,L"topology",&topology);
CreateElement(pDoc,L"pintopology",&pintopology);
AddBDATopology(pDoc,bdatopology,d.bdatopology);
AddTopology(pDoc,topology,d.topology);
AddPinTopology(pDoc,pintopology,d.pintopology);
AppendChild(bdatopology,pParent);
AppendChild(topology,pParent);
AppendChild(pintopology,pParent);
}
//------------------------------------------------------------------------
void CItemParamsNode::SetAttribute(const char *name, const char *attr)
{
//m_attributes.insert(TAttributeMap::value_type(name, string(attr)));
if (!strcmpi(name, "name"))
{
m_nameAttribute = attr;
AddAttribute( name,TItemParamValue(m_nameAttribute) );
}
else
AddAttribute( name,TItemParamValue(string(attr)) );
}
void nuiStateDecoration::InitAttributes()
{
AddAttribute(new nuiAttribute<const nuiRect&>
(nglString(_T("ClientRect")), nuiUnitNone,
nuiAttribute<const nuiRect&>::GetterDelegate(this, &nuiStateDecoration::GetSourceClientRect),
nuiAttribute<const nuiRect&>::SetterDelegate(this, &nuiStateDecoration::SetSourceClientRect)));
AddAttribute(new nuiAttribute<const nglString&>
(nglString(_T("OnUp")), nuiUnitNone,
nuiMakeDelegate(this, &nuiStateDecoration::GetDecoUp),
nuiMakeDelegate(this, &nuiStateDecoration::SetDecoUp)));
AddAttribute(new nuiAttribute<const nglString&>
(nglString(_T("OnDown")), nuiUnitNone,
nuiMakeDelegate(this, &nuiStateDecoration::GetDecoDown),
nuiMakeDelegate(this, &nuiStateDecoration::SetDecoDown)));
AddAttribute(new nuiAttribute<const nglString&>
(nglString(_T("OnUpHover")), nuiUnitNone,
nuiMakeDelegate(this, &nuiStateDecoration::GetDecoUpHover),
nuiMakeDelegate(this, &nuiStateDecoration::SetDecoUpHover)));
AddAttribute(new nuiAttribute<const nglString&>
(nglString(_T("OnDownHover")), nuiUnitNone,
nuiMakeDelegate(this, &nuiStateDecoration::GetDecoDownHover),
nuiMakeDelegate(this, &nuiStateDecoration::SetDecoDownHover)));
AddAttribute(new nuiAttribute<const nglString&>
(nglString(_T("OnSelected")), nuiUnitNone,
nuiMakeDelegate(this, &nuiStateDecoration::GetDecoSelected),
nuiMakeDelegate(this, &nuiStateDecoration::SetDecoSelected)));
AddAttribute(new nuiAttribute<const nglString&>
(nglString(_T("OnDisabled")), nuiUnitNone,
nuiMakeDelegate(this, &nuiStateDecoration::GetDecoDisabled),
nuiMakeDelegate(this, &nuiStateDecoration::SetDecoDisabled)));
AddAttribute(new nuiAttribute<const nglString&>
(nglString(_T("OnDisabledSelected")), nuiUnitNone,
nuiMakeDelegate(this, &nuiStateDecoration::GetDecoDisabledSelected),
nuiMakeDelegate(this, &nuiStateDecoration::SetDecoDisabledSelected)));
AddAttribute(new nuiAttribute<const nglString&>
(nglString(_T("OnUpDisabled")), nuiUnitNone,
nuiMakeDelegate(this, &nuiStateDecoration::GetDecoUpDisabled),
nuiMakeDelegate(this, &nuiStateDecoration::SetDecoUpDisabled)));
AddAttribute(new nuiAttribute<const nglString&>
(nglString(_T("OnDownDisabled")), nuiUnitNone,
nuiMakeDelegate(this, &nuiStateDecoration::GetDecoDownDisabled),
nuiMakeDelegate(this, &nuiStateDecoration::SetDecoDownDisabled)));
}
