updateViewProperties() 공개 메소드

public updateViewProperties ( AbstractVisualisation.PropertyType propertyType ) : void
propertyType AbstractVisualisation.PropertyType
리턴 void
예제 #1
0
 public void ValidateX_AxisDropdown()
 {
     if (visualisation != null)
     {
         visualisation.xDimension = DataAttributesNames[X_AxisDropDown.value];
         visualisation.updateViewProperties(AbstractVisualisation.PropertyType.X);
     }
 }
예제 #2
0
        /// <summary>
        /// Draw the inspector and update Visualisation when a property changes
        /// </summary>
        public override void OnInspectorGUI()
        {
            AbstractVisualisation.PropertyType?dirtyFlags = null;
            Visualisation targetVisualisation             = (Visualisation)serializedObject.targetObject;

            serializedObject.Update();

            EditorGUI.BeginDisabledGroup(true);
            EditorGUILayout.PropertyField(uidProperty);
            EditorGUI.EndDisabledGroup();

            EditorGUI.BeginChangeCheck();

            EditorGUILayout.PropertyField(dataSourceProperty);

            if (EditorGUI.EndChangeCheck())
            {
                loadData();

                targetVisualisation.xScatterplotMatrixDimensions = dimensions.Select(x => new DimensionFilter {
                    Attribute = x
                }).ToArray();
                targetVisualisation.yScatterplotMatrixDimensions = dimensions.Select(x => new DimensionFilter {
                    Attribute = x
                }).ToArray();
                targetVisualisation.zScatterplotMatrixDimensions = dimensions.Select(x => new DimensionFilter {
                    Attribute = x
                }).ToArray();
                targetVisualisation.parallelCoordinatesDimensions = dimensions.Select(x => new DimensionFilter {
                    Attribute = x
                }).ToArray();
            }

            if (dataSourceProperty.objectReferenceValue != null)
            {
                //Check if changing the visualisation type
                EditorGUI.BeginChangeCheck();

                EditorGUILayout.PropertyField(visualisationTypeProperty);

                if (EditorGUI.EndChangeCheck())
                {
                    dirtyFlags = AbstractVisualisation.PropertyType.VisualisationType;
                }

                //int visType = visualisationTypeProperty.intValue;
                //EnumPopup("Visualisation Type", Enum.GetNames(typeof(AbstractViualisation.VisualisationTypes)), ref visType);
                //visualisationTypeProperty.intValue = visType;

                EditorGUI.indentLevel++;

                //                switch ((AbstractViualisation.VisualisationTypes)visualisationTypeProperty.intValue)
                switch (targetVisualisation.visualisationType)
                {
                case AbstractVisualisation.VisualisationTypes.SCATTERPLOT:
                    ShowSimpleVisualisationMenu(ref dirtyFlags);
                    break;

                case AbstractVisualisation.VisualisationTypes.SCATTERPLOT_MATRIX:
                    ShowScatterplotMatrixMenu(ref dirtyFlags);
                    break;

                case AbstractVisualisation.VisualisationTypes.PARALLEL_COORDINATES:
                    ShowParallelCoordinatesMenu(ref dirtyFlags);
                    break;

                case AbstractVisualisation.VisualisationTypes.GRAPH_LAYOUT:
                    break;

                default:
                    break;
                }
                EditorGUI.indentLevel--;
                EditorGUILayout.Space();
            }


            EditorGUI.BeginChangeCheck();

            EditorGUILayout.PropertyField(geometryProperty);

            if (EditorGUI.EndChangeCheck())
            {
                dirtyFlags = AbstractVisualisation.PropertyType.GeometryType;
            }

            if (EnumPopup("Colour dimension", dimensions.ToArray(), colourDimensionProperty))
            {
                dirtyFlags = AbstractVisualisation.PropertyType.Colour;
                colorPaletteDimensionProperty.stringValue = "Undefined";
                colourPaletteProperty.ClearArray();
                colourPaletteProperty.arraySize = 0;
            }

            if (EnumPopup("Bind Colour palette", dimensions.ToArray(), colorPaletteDimensionProperty))
            {
                if (colorPaletteDimensionProperty.stringValue != "Undefined")
                {
                    int     nbPaletteCategories = dataSource.getNumberOfCategories(colorPaletteDimensionProperty.stringValue);
                    float[] uniqueValues        = dataSource[colorPaletteDimensionProperty.stringValue].MetaData.categories;

                    colourPaletteProperty.ClearArray();
                    colourPaletteProperty.arraySize     = nbPaletteCategories;
                    colourDimensionProperty.stringValue = "Undefined";
                }
            }

            if (colorPaletteDimensionProperty.stringValue != "Undefined" && colorPaletteDimensionProperty.stringValue != "")
            {
                EditorGUI.BeginChangeCheck();

                float[] paletteValues       = dataSource[colorPaletteDimensionProperty.stringValue].MetaData.categories;
                int     nbPaletteCategories = paletteValues.Length;

                EditorGUI.indentLevel += 1;
                for (int i = 0; i < nbPaletteCategories; i++)
                {
                    EditorGUILayout.PropertyField(
                        colourPaletteProperty.GetArrayElementAtIndex(i),
                        new GUIContent(dataSource.getOriginalValue(paletteValues[i], colorPaletteDimensionProperty.stringValue).ToString())
                        );
                }
                EditorGUI.indentLevel -= 1;

                if (EditorGUI.EndChangeCheck())
                {
                    dirtyFlags = AbstractVisualisation.PropertyType.Colour;
                }
            }

            if (EnumPopup("Blending Mode Source", Enum.GetNames(typeof(UnityEngine.Rendering.BlendMode)), blendingModeSourceProperty))
            {
                dirtyFlags = AbstractVisualisation.PropertyType.BlendSourceMode;
            }

            if (EnumPopup("Blending Mode Destination", Enum.GetNames(typeof(UnityEngine.Rendering.BlendMode)), blendingModeDestinationProperty))
            {
                dirtyFlags = AbstractVisualisation.PropertyType.BlendDestinationMode;
            }

            if (colourDimensionProperty.stringValue != "" && colourDimensionProperty.stringValue != "Undefined")
            {
                EditorGUI.BeginChangeCheck();

                EditorGUILayout.PropertyField(colourGradientProperty);

                if (EditorGUI.EndChangeCheck())
                {
                    dirtyFlags = AbstractVisualisation.PropertyType.Colour;
                }
            }
            else
            {
                EditorGUI.BeginChangeCheck();

                EditorGUILayout.PropertyField(colourProperty);

                if (EditorGUI.EndChangeCheck())
                {
                    dirtyFlags = AbstractVisualisation.PropertyType.Colour;
                }
            }

            if (EnumPopup("Size dimension", dimensions.ToArray(), sizeDimensionProperty))
            {
                dirtyFlags = AbstractVisualisation.PropertyType.Size;
            }

            if (EnumPopup("Linking dimension", dimensions.ToArray(), linkingDimensionProperty))
            {
                dirtyFlags = AbstractVisualisation.PropertyType.LinkingDimension;
            }

            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(attributeFiltersProperty, true);
            if (EditorGUI.EndChangeCheck())
            {
                dirtyFlags = AbstractVisualisation.PropertyType.AttributeFiltering;
            }
            // Size
            EditorGUI.BeginChangeCheck();

            EditorGUILayout.PropertyField(sizeProperty);
            EditorGUILayout.PropertyField(minSizeProperty);
            EditorGUILayout.PropertyField(maxSizeProperty);

            if (EditorGUI.EndChangeCheck())
            {
                dirtyFlags = AbstractVisualisation.PropertyType.SizeValues;
            }

            // Visualisation dimensions
            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(widthProperty);
            EditorGUILayout.PropertyField(heightProperty);
            EditorGUILayout.PropertyField(depthProperty);

            if (EditorGUI.EndChangeCheck())
            {
                dirtyFlags = AbstractVisualisation.PropertyType.Scaling;
            }

            // Update the options for this visualisation
            serializedObject.ApplyModifiedProperties();

            if (dirtyFlags == AbstractVisualisation.PropertyType.VisualisationType)
            {
                targetVisualisation.CreateVisualisation((AbstractVisualisation.VisualisationTypes)visualisationTypeProperty.intValue);
            }
            else
            if (dirtyFlags != null)
            {
                targetVisualisation.updateViewProperties(dirtyFlags.Value);
            }
        }