public Slider InstantiateSlider(string name, int X, int Y)
    {
        Transform TempSlider;

        TempSlider = Instantiate(sliderPrefab, Vector3.zero, Quaternion.identity) as Transform;
        TempSlider.SetParent(sliderParent);
        TempSlider.gameObject.name = name;
        Slider tempSlider = TempSlider.GetComponent <Slider>();

        tempSlider.value = 0.5f;

        RectTransform myRect = tempSlider.GetComponent <RectTransform>();

        Vector3 tmpPos = myRect.position;

        tmpPos.x             = 60 + X * 100;
        tmpPos.y             = -40 - Y * 60;
        myRect.localPosition = tmpPos;

        myRect.anchorMin = new Vector2(0, 1);
        myRect.anchorMax = new Vector2(0, 1);

        tempSlider.transform.FindChild("Text").GetComponent <Text>().text = name;
        tempSlider.onValueChanged.AddListener(UpdateUMA);

        return(tempSlider);
    }
Exemple #2
0
        // Constructor
        public WizControlPage(WizLightModel model)
        {
            BindingContext = model;
            InitializeComponent();

            // Set binding programmatically
            TempSlider.SetBinding(Slider.ValueProperty, "Temperature", BindingMode.TwoWay, new RangeToPercentConverter(model.MinimumTemperature, model.MaximumTemperature));
        }
    public SliderControl InstantiateSlider(string name, int X, int Y)
    {
        Transform TempSlider;

        TempSlider                 = Instantiate(sliderPrefab, Vector3.zero, Quaternion.identity) as Transform;
        TempSlider.parent          = transform;
        TempSlider.gameObject.name = name;
        SliderControl tempSlider = TempSlider.GetComponent("SliderControl") as SliderControl;

        tempSlider.actualValue          = 0.5f;
        tempSlider.descriptionText.text = name;
        tempSlider.sliderOffset.x       = 20 + X * 100;
        tempSlider.sliderOffset.y       = -20 - Y * 60;
        return(tempSlider);
    }
        void ResetSettings(UIBarButtonItem sender)
        {
            var filter = ciRawFilter;

            if (filter == null)
            {
                return;
            }

            filter.SetValueForKey(NSNumber.FromInt32(0), CIFilterInputKey.EV);
            ExposureSlider.SetValue(0, animated: false);

            filter.SetValueForKey(NSNumber.FromFloat(originalTemp), Keys.kCIInputNeutralTemperatureKey);
            TempSlider.SetValue(originalTemp, animated: false);

            filter.SetValueForKey(NSNumber.FromFloat(originalTint), Keys.kCIInputNeutralTintKey);
            TintSlider.SetValue(originalTint, animated: false);

            ImageView.SetNeedsDisplay();
        }
        // On load, construct the CIRawFilter
        public override void ViewDidLoad()
        {
            base.ViewDidLoad();

            var asset = Asset;

            if (asset == null)
            {
                return;
            }

            // Setup options to request original image.
            var options = new PHImageRequestOptions {
                Version     = PHImageRequestOptionsVersion.Original,
                Synchronous = true
            };

            // Request the image data and UTI type for the image.
            PHImageManager.DefaultManager.RequestImageData(asset, options, (imageData, dataUTI, _, __) => {
                if (imageData == null || dataUTI == null)
                {
                    return;
                }

                // Create a CIRawFilter from original image data.
                // UTI type is passed in to provide the CIRawFilter with a hint about the UTI type of the Raw file.
                //var rawOptions = [String (kCGImageSourceTypeIdentifierHint) : dataUTI ]
                var rawOptions     = new NSMutableDictionary();
                var imageIOLibrary = Dlfcn.dlopen("/System/Library/Frameworks/ImageIO.framework/ImageIO", 0);
                var key            = Dlfcn.GetIntPtr(imageIOLibrary, "kCGImageSourceTypeIdentifierHint");
                rawOptions.LowlevelSetObject(dataUTI, key);

                ciRawFilter = CIFilter.CreateRawFilter(imageData, rawOptions);
                if (ciRawFilter == null)
                {
                    return;
                }

                // Get the native size of the image produced by the CIRawFilter.
                var sizeValue = ciRawFilter.ValueForKey(Keys.kCIOutputNativeSizeKey) as CIVector;
                if (sizeValue != null)
                {
                    imageNativeSize = new CGSize(sizeValue.X, sizeValue.Y);
                }

                // Record the original value of the temperature, and setup the editing slider.
                var tempValue = (NSNumber)ciRawFilter.ValueForKey(Keys.kCIInputNeutralTemperatureKey);
                if (tempValue != null)
                {
                    originalTemp = tempValue.FloatValue;
                    TempSlider.SetValue(tempValue.FloatValue, animated: false);
                }

                // Record the original value of the tint, and setup the editing slider.
                var tintValue = (NSNumber)ciRawFilter.ValueForKey(Keys.kCIInputNeutralTintKey);
                if (tintValue != null)
                {
                    originalTint = tintValue.FloatValue;
                    TintSlider.SetValue(tintValue.FloatValue, animated: false);
                }
            });

            // Create EAGL context used to render the CIImage produced by the CIRawFilter to display.
            ImageView.Context = new EAGLContext(EAGLRenderingAPI.OpenGLES3);
            ciContext         = CIContext.FromContext(ImageView.Context, new CIContextOptions {
                CIImageFormat = CIImage.FormatRGBAh
            });
        }