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))); }