public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            SerializedProperty m_Value           = property.FindPropertyRelative("m_Value");
            SerializedProperty m_Name            = property.FindPropertyRelative("m_Name");
            SerializedProperty m_RequirementType = property.FindPropertyRelative("m_RequirementType");

            position.y += 2f * AnalyticsEventTrackerEditor.k_LineMargin;

            Rect nameLabelRect = position;

            nameLabelRect.width  = AnalyticsEventTrackerEditor.k_LeftListMargin;
            nameLabelRect.height = EditorGUIUtility.singleLineHeight;
            EditorGUI.LabelField(nameLabelRect, nameLabelContent);

            Rect nameRect = position;

            nameRect.width -= nameLabelRect.width;
            nameRect.x     += nameLabelRect.width;
            nameRect.height = nameLabelRect.height;
            AnalyticsEventParam.RequirementType requirement = (AnalyticsEventParam.RequirementType)m_RequirementType.enumValueIndex;
            EditorGUI.BeginDisabledGroup(requirement != AnalyticsEventParam.RequirementType.None);
            switch (requirement)
            {
            case AnalyticsEventParam.RequirementType.Required:
                EditorGUI.TextField(nameRect, m_Name.stringValue + " (required)");
                break;

            case AnalyticsEventParam.RequirementType.Optional:
                EditorGUI.TextField(nameRect, m_Name.stringValue);
                break;

            case AnalyticsEventParam.RequirementType.None:
            default:
                m_Name.stringValue = EditorGUI.TextField(nameRect, m_Name.stringValue);
                break;
            }
            EditorGUI.EndDisabledGroup();

            position.y += EditorGUIUtility.singleLineHeight + AnalyticsEventTrackerEditor.k_LineMargin;
            EditorGUI.PropertyField(position, m_Value);

            if (nameRect.Contains(Event.current.mousePosition))
            {
                ShowParamNameTooltip(nameRect, property);
            }
        }
        void BuildRequirementsList(Type type)
        {
            if (type != null && type != payloadType && m_FieldsArray != null)
            {
                payloadType = type;
                definedParams.Clear();


                FieldInfo[] fieldInfos = payloadType.GetFields();

                foreach (FieldInfo fieldInfo in fieldInfos)
                {
                    string key = "";

                    AnalyticsEventParam.RequirementType requirement = AnalyticsEventParam.RequirementType.None;
                    string            groupId      = null;
                    string            tooltip      = null;
                    RequiredParameter requiredAttr =
                        (RequiredParameter)Attribute.GetCustomAttribute(fieldInfo, typeof(RequiredParameter));
                    if (requiredAttr != null)
                    {
                        key         = requiredAttr.sendName;
                        requirement = AnalyticsEventParam.RequirementType.Required;
                        groupId     = requiredAttr.groupId;
                        tooltip     = requiredAttr.tooltip;
                    }
                    else
                    {
                        OptionalParameter optionalAttr =
                            (OptionalParameter)Attribute.GetCustomAttribute(fieldInfo, typeof(OptionalParameter));
                        key         = optionalAttr.sendName;
                        requirement = AnalyticsEventParam.RequirementType.Optional;
                        tooltip     = optionalAttr.tooltip;
                    }
                    CustomizableEnum customEnum = (CustomizableEnum)Attribute.GetCustomAttribute(fieldInfo, typeof(CustomizableEnum));

                    DefinedParameter parm;
                    if (!definedParams.ContainsKey(key))
                    {
                        var newParm = new DefinedParameter();
                        newParm.type = null;
                        definedParams.Add(key, newParm);
                    }
                    parm             = definedParams[key];
                    parm.requirement = requirement;
                    parm.groupId     = groupId;
                    parm.tooltip     = tooltip;
                    //Assert(parm.type == null || parm.type == fieldInfo.FieldType);
                    parm.type       = fieldInfo.FieldType;
                    parm.customEnum = customEnum != null ? customEnum.Customizable : false;
                }

                // only clear out and reset the fields array if this is the result of a type change instead
                // of the result of refreshing the tracker (i.e. the drawer was destroyed and recreated)
                if (!refreshTracker)
                {
                    m_FieldsArray.ClearArray();
                    foreach (KeyValuePair <string, DefinedParameter> kv in definedParams)
                    {
                        base.AddElement(m_ReorderableList);

                        var listItem = m_FieldsArray.GetArrayElementAtIndex(m_FieldsArray.arraySize - 1);

                        SerializedProperty m_Name = listItem.FindPropertyRelative("m_Name");
                        m_Name.stringValue = kv.Key;

                        SerializedProperty m_RequirementType = listItem.FindPropertyRelative("m_RequirementType");
                        m_RequirementType.enumValueIndex = (int)kv.Value.requirement;

                        SerializedProperty m_GroupId = listItem.FindPropertyRelative("m_GroupID");
                        m_GroupId.stringValue = kv.Value.groupId;

                        SerializedProperty m_Tooltip = listItem.FindPropertyRelative("m_Tooltip");
                        m_Tooltip.stringValue = kv.Value.tooltip;

                        SerializedProperty m_Value     = listItem.FindPropertyRelative("m_Value");
                        SerializedProperty m_ValueType = m_Value.FindPropertyRelative("m_ValueType");
                        SerializedProperty m_EnumType  = m_Value.FindPropertyRelative("m_EnumType");
                        SerializedProperty m_EnumTypeIsCustomizable = m_Value.FindPropertyRelative("m_EnumTypeIsCustomizable");
                        m_EnumTypeIsCustomizable.boolValue = kv.Value.customEnum;

                        m_ValueType.stringValue = kv.Value.type.ToString();

                        if (kv.Value.type.IsEnum)
                        {
                            m_EnumType.stringValue = kv.Value.type.ToString();
                        }

                        SerializedProperty m_CanDisable = m_Value.FindPropertyRelative("m_CanDisable");
                        m_CanDisable.boolValue = kv.Value.requirement == AnalyticsEventParam.RequirementType.Optional || !string.IsNullOrEmpty(kv.Value.groupId);

                        SerializedProperty m_PropertyType = m_Value.FindPropertyRelative("m_PropertyType");
                        if (m_CanDisable.boolValue)
                        {
                            // disable any values that don't have an invalid default value
                            bool hasInvalidDefault = kv.Value.type == typeof(string) ? true : false;
                            m_PropertyType.enumValueIndex = hasInvalidDefault ? (int)ValueProperty.PropertyType.Static : (int)ValueProperty.PropertyType.Disabled;
                        }
                        else
                        {
                            m_PropertyType.enumValueIndex = (int)ValueProperty.PropertyType.Static;
                        }

                        SerializedProperty m_FixedType = m_Value.FindPropertyRelative("m_FixedType");
                        m_FixedType.boolValue = true;
                    }
                }
            }
        }