コード例 #1
0
		private void initializePinsLayer()
		{
			// Just initialize with empty so that it's guaranteed that there are sources initiated
			// when the pins collection is still null
			var mapLockedPinsSource = new MGLShapeSource(mapLockedPinsSourceKey, new NSObject[]{}, null);
			nStyle.AddSource(mapLockedPinsSource);

			// Pins with bearings layer - configure elements
			var mapLockedPinsLayer = new MGLSymbolStyleLayer(mapLockedPinsKey, mapLockedPinsSource) {
				IconImageName = NSExpression.FromKeyPath(pin_image_key),
				IconRotation = NSExpression.FromKeyPath(pin_rotation_key),
				IconScale = NSExpression.FromKeyPath(pin_size_key),
				IconRotationAlignment = NSExpression.FromConstant(NSObject.FromObject("map")), // Finally the map-lock flat = "map"
				IconAllowsOverlap = NSExpression.FromConstant(NSObject.FromObject(true)) // Always overlap
			};
			nStyle.AddLayer(mapLockedPinsLayer);

			// Just initialize with empty so that it's guaranteed that there are sources initiated
			// when the pins collection is still null
			var normalPinsSource = new MGLShapeSource(normalPinsSourceKey, new NSObject[] { }, null);
			nStyle.AddSource(normalPinsSource);

			// Normal pins layer - configure elements
			var normalPinsLayer = new MGLSymbolStyleLayer(normalPinsKey, normalPinsSource) {
				IconImageName = NSExpression.FromKeyPath(pin_image_key),
				IconScale = NSExpression.FromKeyPath(pin_size_key),
				IconOffset = NSExpression.FromKeyPath(pin_offset_key), //https://www.mapbox.com/mapbox-gl-js/style-spec/#layout-symbol-icon-offset
				IconAnchor = NSExpression.FromConstant(NSObject.FromObject("bottom")), // https://www.mapbox.com/mapbox-gl-js/style-spec/#layout-symbol-icon-anchor = "bottom" or "center"
				IconAllowsOverlap = NSExpression.FromConstant(NSObject.FromObject(true))
			};
			nStyle.AddLayer(normalPinsLayer);
		}
コード例 #2
0
        public void KeyPathPropertiesTest()
        {
            var availableProperties = new List <string> {
                "KeyPath", "Operand", "Arguments"
            };

            using (var expression = NSExpression.FromKeyPath("value")) {
                Assert.AreEqual(NSExpressionType.KeyPath, expression.ExpressionType);
                TestProperties(expression, availableProperties);
            }
        }
コード例 #3
0
 public NSPredicateEditorRowTemplate(
     IEnumerable <string> leftExpressionsFromKeyPaths,
     IEnumerable <string> rightExpressionsFromConstants,
     IEnumerable <NSPredicateOperatorType> operators,
     NSComparisonPredicateModifier modifier = NSComparisonPredicateModifier.Direct,
     NSComparisonPredicateOptions options   = NSComparisonPredicateOptions.None)
     : this(
         leftExpressionsFromKeyPaths.Select(k => NSExpression.FromKeyPath(k)),
         rightExpressionsFromConstants.Select(k => NSExpression.FromConstant(new NSString(k))),
         operators,
         modifier,
         options)
 {
 }
コード例 #4
0
 public NSPredicateEditorRowTemplate(
     IEnumerable <string> leftExpressionsFromKeyPaths,
     NSAttributeType attributeType,
     IEnumerable <NSPredicateOperatorType> operators,
     NSComparisonPredicateModifier modifier = NSComparisonPredicateModifier.Direct,
     NSComparisonPredicateOptions options   = NSComparisonPredicateOptions.None)
     : this(
         leftExpressionsFromKeyPaths.Select(k => NSExpression.FromKeyPath(k)),
         attributeType,
         operators,
         modifier,
         options)
 {
 }
コード例 #5
0
		private void initializeRoutesLayer()
		{
			// Just initialize with empty so that it's guaranteed that there are sources initiated
			// when the routes collection is still null
			var routeSource = new MGLShapeSource(line_source_key, new NSObject[] { }, null);
			nStyle.AddSource(routeSource);

			var borderLinesLayer = new MGLLineStyleLayer(border_line_layer_key, routeSource);
			borderLinesLayer.LineColor = NSExpression.FromKeyPath(border_line_color_key);
			borderLinesLayer.LineWidth = NSExpression.FromKeyPath(border_line_width_key);
			borderLinesLayer.LineJoin = NSExpression.FromConstant(NSObject.FromObject("round"));
			borderLinesLayer.LineCap = NSExpression.FromConstant(NSObject.FromObject("round"));
			nStyle.AddLayer(borderLinesLayer);

			var linesLayer = new MGLLineStyleLayer(line_layer_key, routeSource);
			linesLayer.LineColor = NSExpression.FromKeyPath(line_color_key);
			linesLayer.LineWidth = NSExpression.FromKeyPath(line_width_key);
			linesLayer.LineJoin = NSExpression.FromConstant(NSObject.FromObject("round"));
			linesLayer.LineCap = NSExpression.FromConstant(NSObject.FromObject("round"));
			nStyle.AddLayer(linesLayer);
		}
コード例 #6
0
 public void FromKeyPath()
 {
     using (var expression = NSExpression.FromKeyPath("value"))
         using (var result = expression.EvaluateWith(null, null) as NSString)
             Assert.IsNull(result);
 }
コード例 #7
0
        private NSCompoundPredicate FindMatches(string searchString)
        {
            /*
             * Each searchString creates an OR predicate for: name, yearIntroduced, introPrice.
             * Example if searchItems contains "Gladiolus 51.99 2001":
             * - name CONTAINS[c] "gladiolus"
             * - name CONTAINS[c] "gladiolus", yearIntroduced ==[c] 2001, introPrice ==[c] 51.99
             * - name CONTAINS[c] "ginger", yearIntroduced ==[c] 2007, introPrice ==[c] 49.98
             */
            var searchItemsPredicate = new List <NSPredicate>();

            /*
             * Below we use NSExpression represent expressions in our predicates.
             * NSPredicate is made up of smaller, atomic parts:
             * two NSExpressions (a left-hand value and a right-hand value).
             */

            // Name field matching.
            var titleExpression        = NSExpression.FromKeyPath(ExpressionKeys.Title);
            var searchStringExpression = NSExpression.FromConstant(new NSString(searchString));

            var titleSearchComparisonPredicate = new NSComparisonPredicate(titleExpression,
                                                                           searchStringExpression,
                                                                           NSComparisonPredicateModifier.Direct,
                                                                           NSPredicateOperatorType.Contains,
                                                                           NSComparisonPredicateOptions.CaseInsensitive | NSComparisonPredicateOptions.DiacriticInsensitive);

            searchItemsPredicate.Add(titleSearchComparisonPredicate);

            var numberFormatter = new NSNumberFormatter
            {
                NumberStyle       = NSNumberFormatterStyle.None,
                FormatterBehavior = NSNumberFormatterBehavior.Default
            };

            // The `searchString` may fail to convert to a number.
            var targetNumber = numberFormatter.NumberFromString(searchString);

            if (targetNumber != null)
            {
                // Use `targetNumberExpression` in both the following predicates.
                var targetNumberExpression = NSExpression.FromConstant(targetNumber);

                // The `yearIntroduced` field matching.
                var yearIntroducedExpression = NSExpression.FromKeyPath(ExpressionKeys.YearIntroduced);
                var yearIntroducedPredicate  = new NSComparisonPredicate(yearIntroducedExpression,
                                                                         targetNumberExpression,
                                                                         NSComparisonPredicateModifier.Direct,
                                                                         NSPredicateOperatorType.EqualTo,
                                                                         NSComparisonPredicateOptions.CaseInsensitive | NSComparisonPredicateOptions.DiacriticInsensitive);

                searchItemsPredicate.Add(yearIntroducedPredicate);

                // The `price` field matching.
                var priceExpression = NSExpression.FromKeyPath(ExpressionKeys.IntroPrice);
                var finalPredicate  = new NSComparisonPredicate(priceExpression,
                                                                targetNumberExpression,
                                                                NSComparisonPredicateModifier.Direct,
                                                                NSPredicateOperatorType.EqualTo,
                                                                NSComparisonPredicateOptions.CaseInsensitive | NSComparisonPredicateOptions.DiacriticInsensitive);

                searchItemsPredicate.Add(finalPredicate);
            }

            return(NSCompoundPredicate.CreateOrPredicate(searchItemsPredicate.ToArray()));
        }
コード例 #8
0
        static NSExpression ToExpression(NSArray array)
        {
            var objects   = SubArray(array, 0);
            var @operator = objects[0].ToString();
            var arguments = SubArray(objects, 1);

            if (OperatorMap.TryGetValue(@operator, out var functionName))
            {
                var subexpressions = ToSubexpressions(arguments);
                switch (functionName)
                {
                case "+":
                    if (subexpressions.Count > 2)
                    {
                        var sumArguments = NSExpression.FromAggregate(subexpressions.ToArray());

                        return(NSExpression.FromFunction("sum:", new[] { sumArguments }));
                    }

                    break;

                case "^":
                    if (arguments[0].ToString() == "e")
                    {
                        functionName   = @"exp:";
                        subexpressions = SubArray(subexpressions, 1);
                    }

                    break;

                default:
                    break;
                }

                return(NSExpression.FromFunction(functionName, subexpressions.ToArray()));
            }
            else
            {
                switch (@operator)
                {
                case "collator":
                    return(NSExpression.FromFunction("MGL_FUNCTION", ToSubexpressions(objects).ToArray()));

                case "literal":
                    if (arguments[0] is NSArray literalArray)
                    {
                        return(NSExpression.FromConstant(literalArray));
                        // WARNING This may be wrong
                        //var expressions = ToSubexpressions(SubArray(literalArray, 0));
                        //return NSExpression.FromAggregate(expressions.ToArray());
                    }

                    return(ToExpression(arguments[0]));

                case "to-boolean": {
                    var operand = ToExpression(arguments[0]);
                    return(NSExpression.FromFunction(operand, "boolValue", new NSExpression[0]));
                }

                case "to-number":
                case "number": {
                    var operand = ToExpression(arguments[0]);
                    if (arguments.Count == 1)
                    {
                        if (arguments[0] is NSNumber number)
                        {
                            return(NSExpression.FromFormat("%@", new NSObject[] { arguments[0] }));
                        }
                        return(NSExpression.FromFormat("CAST(%@, 'NSNumber')", new NSObject[] { operand }));
                    }
                    else
                    {
                        var innerArguments = SubArray(arguments, 1);
                        return(NSExpression.FromFunction(operand, "mgl_numberWithFallbackValues",
                                                         ToSubexpressions(innerArguments).ToArray()));
                    }
                }

                case "to-string":
                case "string": {
                    var operand = ToExpression(arguments[0]);
                    return(NSExpression.FromFormat("CAST(%@, 'NSString')", new NSObject[] { operand }));
                }

                case "to-color":
                case "color": {
                    var operand = ToExpression(arguments[0]);

                    if (arguments.Count == 1)
                    {
#if __IOS__
                        return(NSExpression.FromFormat("CAST(%@, 'UIColor')", new NSObject[] { operand }));
#else
                        return(NSExpression.FromFormat("CAST(%@, 'NSColor')", new NSObject[] { operand }));
#endif
                    }

                    return(NSExpression.FromFunction("MGL_FUNCTION", ToSubexpressions(objects).ToArray()));
                }

                case "to-rgba": {
                    var operand = ToExpression(arguments[0]);
                    return(NSExpression.FromFormat("CAST(noindex(%@), 'NSArray')", new NSObject[] { operand }));
                }

                case "get": {
                    if (arguments.Count == 2)
                    {
                        var operand = ToExpression(arguments[arguments.Count - 1]);

                        if (arguments[0] is NSString value)
                        {
                            return(NSExpression.FromFormat("%@.%K", new NSObject[] { operand, value }));
                        }

                        var keyExpression = ToExpression(arguments[0]);
                        return(NSExpression.FromFormat("%@.%@", new NSObject[] { operand, keyExpression }));
                    }

                    return(NSExpression.FromKeyPath(arguments[0].ToString()));
                }

                case "length": {
                    var subexpressions = ToSubexpressions(arguments);
                    var function       = @"count:";

                    if (subexpressions[0].ExpressionType == NSExpressionType.ConstantValue &&
                        subexpressions[0].ConstantValue is NSString value)
                    {
                        function = "length:";
                    }

                    return(NSExpression.FromFunction(function, new NSExpression[] { subexpressions[0] }));
                }
                    ;

                case "rgb": {
                    var subexpressions = ToSubexpressions(arguments);

                    return(UIColorAdditions.FromRgb(subexpressions.ToArray()));
                }

                case "rgba": {
                    var subexpressions = ToSubexpressions(arguments);

                    return(UIColorAdditions.FromRgba(subexpressions.ToArray()));
                }

                case "min":
                case "max": {
                    var subexpressions = ToSubexpressions(arguments);
                    var subexpression  = NSExpression.FromAggregate(subexpressions.ToArray());
                    return(NSExpression.FromFunction(@operator, new[] { subexpression }));
                }

                case "e": {
                    return(NSExpression.FromConstant(NSNumber.FromDouble(Math.E)));
                }

                case "pi": {
                    return(NSExpression.FromConstant(NSNumber.FromDouble(Math.PI)));
                }

                case "concat": {
                    var subexpressions = ToSubexpressions(arguments);
                    var subexpression  = NSExpression.FromAggregate(subexpressions.ToArray());
                    return(NSExpression.FromFunction("mgl_join:", new[] { subexpression }));
                }

                case "at": {
                    var subexpressions = ToSubexpressions(arguments);

                    return(NSExpression.FromFunction("objectFrom:withIndex:",
                                                     new[] { subexpressions[1], subexpressions[0] }));
                }

                case "has": {
                    var subexpressions = ToSubexpressions(arguments);
                    var operand        = subexpressions.Count > 1
                                ? subexpressions[1]
                                : NSExpression.ExpressionForEvaluatedObject;
                    var key = subexpressions[0];
                    return(NSExpression.FromFunction("mgl_does:have:", new[] { operand, key }));
                }

                case "interpolate": {
                    var firstObject = arguments[0];
                    if (firstObject is NSArray == false)
                    {
                        return(null);
                    }

                    var interpolationOptions = SubArray((NSArray)firstObject);

                    var      curveType           = interpolationOptions[0].ToString();
                    var      curveTypeExpression = ToExpression(interpolationOptions[0]);
                    NSObject curveParameters;
                    switch (curveType)
                    {
                    case "linear": {
                        var temp = new NSMutableArray(2);
                        temp.Add((NSString)"literal");
                        temp.Add(NSNumber.FromDouble(1.0));
                        curveParameters = temp.Copy();
                        temp.Dispose();
                        break;
                    }

                    case "exponential":
                        curveParameters = interpolationOptions[1];
                        break;

                    case "cubic-bezier": {
                        var temp = new NSMutableArray(5);
                        temp.Add((NSString)"literal");
                        temp.Add(interpolationOptions[1]);
                        temp.Add(interpolationOptions[2]);
                        temp.Add(interpolationOptions[3]);
                        temp.Add(interpolationOptions[4]);
                        curveParameters = temp.Copy();
                        temp.Dispose();
                        break;
                    }

                    default:
                        curveParameters = NSNull.Null;
                        break;
                    }

                    var curveParameterExpression = ToExpression(curveParameters);
                    arguments = SubArray(arguments, 1);

                    var inputExpression = ToExpression(arguments[0]);
                    var stopExpressions = SubArray(arguments, 1);
                    var stops           = new NSMutableDictionary();
                    for (int i = 0; i < stopExpressions.Count; i++)
                    {
                        var keyExpression   = stopExpressions[i++];
                        var valueExpression = ToExpression(stopExpressions[i]);

                        stops[keyExpression] = valueExpression;
                    }

                    var stopExpression = NSExpression.FromConstant(stops);

                    return(NSExpression.FromFunction("mgl_interpolate:withCurveType:parameters:stops:", new[]
                        {
                            inputExpression,
                            curveTypeExpression,
                            curveParameterExpression,
                            stopExpression
                        }));
                }

                case "step": {
                    var          inputExpression  = ToExpression(arguments[0]);
                    var          stopExpressions  = SubArray(arguments, 1);
                    NSExpression miniumExpression = null;

                    if (stopExpressions.Count % 2 == 1)
                    {
                        miniumExpression = ToExpression(stopExpressions[0]);
                        stopExpressions  = SubArray(stopExpressions, 1);
                    }

                    var stops = new NSMutableDictionary();
                    for (int i = 0; i < stopExpressions.Count; i++)
                    {
                        var keyExpression   = stopExpressions[i++];
                        var valueExpression = ToExpression(stopExpressions[i]);

                        if (miniumExpression == null)
                        {
                            miniumExpression = valueExpression;
                            continue;
                        }

                        stops[keyExpression] = valueExpression;
                    }

                    if (miniumExpression == null)
                    {
                        return(null);
                    }

                    var stopExpression = NSExpression.FromConstant(stops);

                    return(NSExpression.FromFunction("mgl_step:from:stops:", new[]
                        {
                            inputExpression,
                            miniumExpression,
                            stopExpression
                        }));
                }

                case "zoom": {
                    return(NSExpression_MGLAdditions.ZoomLevelVariableExpression(null));
                }

                case "heatmap-density": {
                    return(NSExpression_MGLAdditions.HeatmapDensityVariableExpression(null));
                }

                case "line-progress": {
                    return(NSExpression_MGLAdditions.LineProgressVariableExpression(null));
                }

                case "geometry-type": {
                    return(NSExpression_MGLAdditions.GeometryTypeVariableExpression(null));
                }

                case "id": {
                    return(NSExpression_MGLAdditions.FeatureIdentifierVariableExpression(null));
                }

                case "properties": {
                    return(NSExpression_MGLAdditions.FeatureAttributesVariableExpression(null));
                }

                case "var": {
                    return(NSExpression.FromVariable(arguments[0].ToString()));
                }

                case "case": {
                    var args = new NSMutableArray();

                    for (int i = 0; i < arguments.Count; i++)
                    {
                        if (i % 2 == 0 & i != arguments.Count - 1)
                        {
                            var predicate = ToPredicate(arguments[i]);
                            var arg       = NSExpression.FromConstant(predicate);
                            args.Add(arg);
                        }
                        else
                        {
                            args.Add(ToExpression(arguments[i]));
                        }
                    }

                    if (args.Count == 3)
                    {
                        return(NSExpression.FromConditional(
                                   (NSPredicate)ObjCRuntime.Runtime.GetNSObject <NSExpression>(args.ValueAt(0))
                                   .ConstantValue,
                                   ObjCRuntime.Runtime.GetNSObject <NSExpression>(args.ValueAt(1)),
                                   ObjCRuntime.Runtime.GetNSObject <NSExpression>(args.ValueAt(2))));
                    }

                    return(NSExpression.FromFunction("MGL_IF",
                                                     NSArray.FromArray <NSExpression>((NSArray)args.Copy())));
                }

                case "match": {
                    var optionsArray = new NSMutableArray();

                    for (int i = 0; i < arguments.Count; i++)
                    {
                        NSExpression option = ToExpression(arguments[i]);

                        if (i > 0 && i < arguments.Count - 1 && !(i % 2 == 0) && arguments[i] is NSArray sub)
                        {
                            option = NSExpression.FromAggregate(ToSubexpressions(SubArray(sub)).ToArray());
                        }

                        optionsArray.Add(option);
                    }

                    return(NSExpression.FromFunction("MGL_MATCH",
                                                     NSArray.FromArray <NSExpression>((NSArray)optionsArray.Copy())));
                }

                case "format": {
                    var attributedExpressions = new List <NSExpression>();

                    for (int i = 0; i < arguments.Count; i += 2)
                    {
                        var expression = ToExpression(arguments[i]);
                        var attrs      = new NSMutableDictionary();

                        if (i + 1 < arguments.Count)
                        {
                            attrs = NSMutableDictionary.FromDictionary(arguments[i + 1] as NSDictionary);
                        }

                        foreach (var key in attrs.Keys)
                        {
                            attrs[key] = ToExpression(attrs[key]);
                        }

                        var attributedExpression = new MGLAttributedExpression(expression, attrs);

                        attributedExpressions.Add(NSExpression.FromConstant(attributedExpression));
                    }

                    return(NSExpression.FromFunction("mgl_attributed:", attributedExpressions.ToArray()));
                }

                case "coalesce": {
                    var subexpressions = ToSubexpressions(arguments);
                    return(NSExpression.FromFormat("mgl_coalesce(%@)", subexpressions.ToArray()));
                }

                default: {
                    var subexpressions = ToSubexpressions(objects);
                    return(NSExpression.FromFunction(@"MGL_FUNCTION", subexpressions.ToArray()));
                }
                }
            }
        }