From be18e6a9bdf0b5cad38c4bab6fa391cff49d6dfd Mon Sep 17 00:00:00 2001 From: Lauren Budorick Date: Wed, 23 Aug 2017 15:03:15 -0700 Subject: Implement icon-anchor property --- .../style/conversion/make_property_setters.hpp | 3 +- include/mbgl/style/layers/symbol_layer.hpp | 10 +- include/mbgl/style/types.hpp | 2 +- mapbox-gl-js | 2 +- .../mapbox/mapboxsdk/style/layers/Property.java | 56 +++++++++++ .../mapboxsdk/style/layers/PropertyFactory.java | 23 +++++ .../mapbox/mapboxsdk/style/layers/SymbolLayer.java | 12 +++ .../mapboxsdk/testapp/style/SymbolLayerTest.java | 105 ++++++++++++++++++++ platform/android/scripts/generate-style-code.js | 6 ++ platform/android/src/style/conversion/types.hpp | 8 +- .../src/style/conversion/types_string_values.hpp | 56 +++++------ platform/android/src/style/layers/symbol_layer.cpp | 7 ++ platform/android/src/style/layers/symbol_layer.hpp | 2 + platform/darwin/scripts/generate-style-code.js | 14 ++- platform/darwin/src/MGLSymbolStyleLayer.h | 86 +++++++++++++++++ platform/darwin/src/MGLSymbolStyleLayer.mm | 45 ++++++++- platform/darwin/test/MGLSymbolStyleLayerTests.mm | 50 +++++++++- scripts/generate-style-code.js | 3 + src/mbgl/layout/symbol_layout.cpp | 1 + src/mbgl/style/function/categorical_stops.cpp | 2 +- src/mbgl/style/function/identity_stops.cpp | 4 +- src/mbgl/style/layers/symbol_layer.cpp | 22 ++++- src/mbgl/style/layers/symbol_layer_properties.hpp | 10 +- src/mbgl/style/types.cpp | 20 ++-- src/mbgl/text/shaping.cpp | 106 ++++++++++++--------- src/mbgl/text/shaping.hpp | 7 +- test/text/quads.test.cpp | 4 +- 27 files changed, 551 insertions(+), 115 deletions(-) diff --git a/include/mbgl/style/conversion/make_property_setters.hpp b/include/mbgl/style/conversion/make_property_setters.hpp index 9252297d75..ef96f534a9 100644 --- a/include/mbgl/style/conversion/make_property_setters.hpp +++ b/include/mbgl/style/conversion/make_property_setters.hpp @@ -45,6 +45,7 @@ auto makeLayoutPropertySetters() { result["icon-padding"] = &setProperty, &SymbolLayer::setIconPadding>; result["icon-keep-upright"] = &setProperty, &SymbolLayer::setIconKeepUpright>; result["icon-offset"] = &setProperty>, &SymbolLayer::setIconOffset>; + result["icon-anchor"] = &setProperty, &SymbolLayer::setIconAnchor>; result["icon-pitch-alignment"] = &setProperty, &SymbolLayer::setIconPitchAlignment>; result["text-pitch-alignment"] = &setProperty, &SymbolLayer::setTextPitchAlignment>; result["text-rotation-alignment"] = &setProperty, &SymbolLayer::setTextRotationAlignment>; @@ -55,7 +56,7 @@ auto makeLayoutPropertySetters() { result["text-line-height"] = &setProperty, &SymbolLayer::setTextLineHeight>; result["text-letter-spacing"] = &setProperty, &SymbolLayer::setTextLetterSpacing>; result["text-justify"] = &setProperty, &SymbolLayer::setTextJustify>; - result["text-anchor"] = &setProperty, &SymbolLayer::setTextAnchor>; + result["text-anchor"] = &setProperty, &SymbolLayer::setTextAnchor>; result["text-max-angle"] = &setProperty, &SymbolLayer::setTextMaxAngle>; result["text-rotate"] = &setProperty, &SymbolLayer::setTextRotate>; result["text-padding"] = &setProperty, &SymbolLayer::setTextPadding>; diff --git a/include/mbgl/style/layers/symbol_layer.hpp b/include/mbgl/style/layers/symbol_layer.hpp index 6e355c0057..2d5123573f 100644 --- a/include/mbgl/style/layers/symbol_layer.hpp +++ b/include/mbgl/style/layers/symbol_layer.hpp @@ -98,6 +98,10 @@ public: DataDrivenPropertyValue> getIconOffset() const; void setIconOffset(DataDrivenPropertyValue>); + static DataDrivenPropertyValue getDefaultIconAnchor(); + DataDrivenPropertyValue getIconAnchor() const; + void setIconAnchor(DataDrivenPropertyValue); + static PropertyValue getDefaultIconPitchAlignment(); PropertyValue getIconPitchAlignment() const; void setIconPitchAlignment(PropertyValue); @@ -138,9 +142,9 @@ public: DataDrivenPropertyValue getTextJustify() const; void setTextJustify(DataDrivenPropertyValue); - static DataDrivenPropertyValue getDefaultTextAnchor(); - DataDrivenPropertyValue getTextAnchor() const; - void setTextAnchor(DataDrivenPropertyValue); + static DataDrivenPropertyValue getDefaultTextAnchor(); + DataDrivenPropertyValue getTextAnchor() const; + void setTextAnchor(DataDrivenPropertyValue); static PropertyValue getDefaultTextMaxAngle(); PropertyValue getTextMaxAngle() const; diff --git a/include/mbgl/style/types.hpp b/include/mbgl/style/types.hpp index 44b16f16e7..ec7358de8c 100644 --- a/include/mbgl/style/types.hpp +++ b/include/mbgl/style/types.hpp @@ -68,7 +68,7 @@ enum class TextJustifyType : uint8_t { Right }; -enum class TextAnchorType : uint8_t { +enum class SymbolAnchorType : uint8_t { Center, Left, Right, diff --git a/mapbox-gl-js b/mapbox-gl-js index 3730e8377f..5f4d86d276 160000 --- a/mapbox-gl-js +++ b/mapbox-gl-js @@ -1 +1 @@ -Subproject commit 3730e8377faccd7d0b83508d2be610c4743b1dc4 +Subproject commit 5f4d86d2762db83c62f7e9eeb362f3fa3a8f2176 diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java index be24b65d27..8d5858217b 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/Property.java @@ -160,6 +160,62 @@ public final class Property { @Retention(RetentionPolicy.SOURCE) public @interface ICON_TEXT_FIT {} + // ICON_ANCHOR: Part of the icon placed closest to the anchor. + + /** + * The center of the icon is placed closest to the anchor. + */ + public static final String ICON_ANCHOR_CENTER = "center"; + /** + * The left side of the icon is placed closest to the anchor. + */ + public static final String ICON_ANCHOR_LEFT = "left"; + /** + * The right side of the icon is placed closest to the anchor. + */ + public static final String ICON_ANCHOR_RIGHT = "right"; + /** + * The top of the icon is placed closest to the anchor. + */ + public static final String ICON_ANCHOR_TOP = "top"; + /** + * The bottom of the icon is placed closest to the anchor. + */ + public static final String ICON_ANCHOR_BOTTOM = "bottom"; + /** + * The top left corner of the icon is placed closest to the anchor. + */ + public static final String ICON_ANCHOR_TOP_LEFT = "top-left"; + /** + * The top right corner of the icon is placed closest to the anchor. + */ + public static final String ICON_ANCHOR_TOP_RIGHT = "top-right"; + /** + * The bottom left corner of the icon is placed closest to the anchor. + */ + public static final String ICON_ANCHOR_BOTTOM_LEFT = "bottom-left"; + /** + * The bottom right corner of the icon is placed closest to the anchor. + */ + public static final String ICON_ANCHOR_BOTTOM_RIGHT = "bottom-right"; + + /** + * Part of the icon placed closest to the anchor. + */ + @StringDef({ + ICON_ANCHOR_CENTER, + ICON_ANCHOR_LEFT, + ICON_ANCHOR_RIGHT, + ICON_ANCHOR_TOP, + ICON_ANCHOR_BOTTOM, + ICON_ANCHOR_TOP_LEFT, + ICON_ANCHOR_TOP_RIGHT, + ICON_ANCHOR_BOTTOM_LEFT, + ICON_ANCHOR_BOTTOM_RIGHT, + }) + @Retention(RetentionPolicy.SOURCE) + public @interface ICON_ANCHOR {} + // ICON_PITCH_ALIGNMENT: Orientation of icon when map is pitched. /** diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java index ef89c6809e..3e90605a92 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/PropertyFactory.java @@ -1881,6 +1881,29 @@ public class PropertyFactory { return new LayoutPropertyValue<>("icon-offset", function); } + /** + * Part of the icon placed closest to the anchor. + * + * @param value a String value + * @return property wrapper around String + */ + public static PropertyValue iconAnchor(@Property.ICON_ANCHOR String value) { + return new LayoutPropertyValue<>("icon-anchor", value); + } + + + + /** + * Part of the icon placed closest to the anchor. + * + * @param the function input type + * @param function a wrapper function for String + * @return property wrapper around a String function + */ + public static PropertyValue> iconAnchor(Function function) { + return new LayoutPropertyValue<>("icon-anchor", function); + } + /** * Orientation of icon when map is pitched. * diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/SymbolLayer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/SymbolLayer.java index fe81dcb638..d0fb82dce5 100644 --- a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/SymbolLayer.java +++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/style/layers/SymbolLayer.java @@ -251,6 +251,16 @@ public class SymbolLayer extends Layer { return (PropertyValue) new PropertyValue("icon-offset", nativeGetIconOffset()); } + /** + * Get the IconAnchor property + * + * @return property wrapper value around String + */ + @SuppressWarnings("unchecked") + public PropertyValue getIconAnchor() { + return (PropertyValue) new PropertyValue("icon-anchor", nativeGetIconAnchor()); + } + /** * Get the IconPitchAlignment property * @@ -901,6 +911,8 @@ public class SymbolLayer extends Layer { private native Object nativeGetIconOffset(); + private native Object nativeGetIconAnchor(); + private native Object nativeGetIconPitchAlignment(); private native Object nativeGetTextPitchAlignment(); diff --git a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/SymbolLayerTest.java b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/SymbolLayerTest.java index e2694af348..1c9faeb9ea 100644 --- a/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/SymbolLayerTest.java +++ b/platform/android/MapboxGLAndroidSDKTestApp/src/androidTest/java/com/mapbox/mapboxsdk/testapp/style/SymbolLayerTest.java @@ -1213,6 +1213,111 @@ public class SymbolLayerTest extends BaseActivityTest { }); } + @Test + public void testIconAnchorAsConstant() { + validateTestSetup(); + setupLayer(); + Timber.i("icon-anchor"); + invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() { + @Override + public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) { + assertNotNull(layer); + + // Set and Get + layer.setProperties(iconAnchor(ICON_ANCHOR_CENTER)); + assertEquals((String) layer.getIconAnchor().getValue(), (String) ICON_ANCHOR_CENTER); + } + }); + } + + @Test + public void testIconAnchorAsCameraFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("icon-anchor"); + invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() { + @Override + public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) { + assertNotNull(layer); + + // Set + layer.setProperties( + iconAnchor( + zoom( + interval( + stop(2, iconAnchor(ICON_ANCHOR_CENTER)) + ) + ) + ) + ); + + // Verify + assertNotNull(layer.getIconAnchor()); + assertNotNull(layer.getIconAnchor().getFunction()); + assertEquals(CameraFunction.class, layer.getIconAnchor().getFunction().getClass()); + assertEquals(IntervalStops.class, layer.getIconAnchor().getFunction().getStops().getClass()); + assertEquals(1, ((IntervalStops) layer.getIconAnchor().getFunction().getStops()).size()); + } + }); + } + + @Test + public void testIconAnchorAsIdentitySourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("icon-anchor"); + invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() { + @Override + public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) { + assertNotNull(layer); + + // Set + layer.setProperties( + iconAnchor(property("FeaturePropertyA", Stops.identity())) + ); + + // Verify + assertNotNull(layer.getIconAnchor()); + assertNotNull(layer.getIconAnchor().getFunction()); + assertEquals(SourceFunction.class, layer.getIconAnchor().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getIconAnchor().getFunction()).getProperty()); + assertEquals(IdentityStops.class, layer.getIconAnchor().getFunction().getStops().getClass()); + } + }); + } + + @Test + public void testIconAnchorAsIntervalSourceFunction() { + validateTestSetup(); + setupLayer(); + Timber.i("icon-anchor"); + invoke(mapboxMap, new MapboxMapAction.OnInvokeActionListener() { + @Override + public void onInvokeAction(UiController uiController, MapboxMap mapboxMap) { + assertNotNull(layer); + + // Set + layer.setProperties( + iconAnchor( + property( + "FeaturePropertyA", + interval( + stop(1, iconAnchor(ICON_ANCHOR_CENTER)) + ) + ) + ) + ); + + // Verify + assertNotNull(layer.getIconAnchor()); + assertNotNull(layer.getIconAnchor().getFunction()); + assertEquals(SourceFunction.class, layer.getIconAnchor().getFunction().getClass()); + assertEquals("FeaturePropertyA", ((SourceFunction) layer.getIconAnchor().getFunction()).getProperty()); + assertEquals(IntervalStops.class, layer.getIconAnchor().getFunction().getStops().getClass()); + } + }); + } + @Test public void testIconPitchAlignmentAsConstant() { validateTestSetup(); diff --git a/platform/android/scripts/generate-style-code.js b/platform/android/scripts/generate-style-code.js index a8b2c98c86..abc0796bc1 100644 --- a/platform/android/scripts/generate-style-code.js +++ b/platform/android/scripts/generate-style-code.js @@ -111,6 +111,9 @@ global.propertyNativeType = function (property) { if (/-(rotation|pitch|illumination)-alignment$/.test(property.name)) { return 'AlignmentType'; } + if (/^(text|icon)-anchor$/.test(property.name)) { + return 'SymbolAnchorType'; + } switch (property.type) { case 'boolean': return 'bool'; @@ -267,6 +270,9 @@ global.evaluatedType = function (property) { if (/-(rotation|pitch|illumination)-alignment$/.test(property.name)) { return 'AlignmentType'; } + if (/^(text|icon)-anchor$/.test(property.name)) { + return 'SymbolAnchorType'; + } if (/position/.test(property.name)) { return 'Position'; } diff --git a/platform/android/src/style/conversion/types.hpp b/platform/android/src/style/conversion/types.hpp index a00f668c24..375d1a33aa 100644 --- a/platform/android/src/style/conversion/types.hpp +++ b/platform/android/src/style/conversion/types.hpp @@ -58,15 +58,15 @@ struct Converter { }; template <> -struct Converter { - Result operator()(jni::JNIEnv& env, const mbgl::style::TextJustifyType& value) const { +struct Converter { + Result operator()(jni::JNIEnv& env, const mbgl::style::SymbolAnchorType& value) const { return convert(env, toString(value)); } }; template <> -struct Converter { - Result operator()(jni::JNIEnv& env, const mbgl::style::TextAnchorType& value) const { +struct Converter { + Result operator()(jni::JNIEnv& env, const mbgl::style::TextJustifyType& value) const { return convert(env, toString(value)); } }; diff --git a/platform/android/src/style/conversion/types_string_values.hpp b/platform/android/src/style/conversion/types_string_values.hpp index e96de3b01e..a19ca33a2f 100644 --- a/platform/android/src/style/conversion/types_string_values.hpp +++ b/platform/android/src/style/conversion/types_string_values.hpp @@ -109,51 +109,34 @@ namespace conversion { } } - // text-justify - inline std::string toString(mbgl::style::TextJustifyType value) { - switch (value) { - case mbgl::style::TextJustifyType::Left: - return "left"; - break; - case mbgl::style::TextJustifyType::Center: - return "center"; - break; - case mbgl::style::TextJustifyType::Right: - return "right"; - break; - default: - throw std::runtime_error("Not implemented"); - } - } - - // text-anchor - inline std::string toString(mbgl::style::TextAnchorType value) { + // icon-anchor + inline std::string toString(mbgl::style::SymbolAnchorType value) { switch (value) { - case mbgl::style::TextAnchorType::Center: + case mbgl::style::SymbolAnchorType::Center: return "center"; break; - case mbgl::style::TextAnchorType::Left: + case mbgl::style::SymbolAnchorType::Left: return "left"; break; - case mbgl::style::TextAnchorType::Right: + case mbgl::style::SymbolAnchorType::Right: return "right"; break; - case mbgl::style::TextAnchorType::Top: + case mbgl::style::SymbolAnchorType::Top: return "top"; break; - case mbgl::style::TextAnchorType::Bottom: + case mbgl::style::SymbolAnchorType::Bottom: return "bottom"; break; - case mbgl::style::TextAnchorType::TopLeft: + case mbgl::style::SymbolAnchorType::TopLeft: return "top-left"; break; - case mbgl::style::TextAnchorType::TopRight: + case mbgl::style::SymbolAnchorType::TopRight: return "top-right"; break; - case mbgl::style::TextAnchorType::BottomLeft: + case mbgl::style::SymbolAnchorType::BottomLeft: return "bottom-left"; break; - case mbgl::style::TextAnchorType::BottomRight: + case mbgl::style::SymbolAnchorType::BottomRight: return "bottom-right"; break; default: @@ -161,6 +144,23 @@ namespace conversion { } } + // text-justify + inline std::string toString(mbgl::style::TextJustifyType value) { + switch (value) { + case mbgl::style::TextJustifyType::Left: + return "left"; + break; + case mbgl::style::TextJustifyType::Center: + return "center"; + break; + case mbgl::style::TextJustifyType::Right: + return "right"; + break; + default: + throw std::runtime_error("Not implemented"); + } + } + // text-transform inline std::string toString(mbgl::style::TextTransformType value) { switch (value) { diff --git a/platform/android/src/style/layers/symbol_layer.cpp b/platform/android/src/style/layers/symbol_layer.cpp index b6cf51ec7e..d44744a6cf 100644 --- a/platform/android/src/style/layers/symbol_layer.cpp +++ b/platform/android/src/style/layers/symbol_layer.cpp @@ -125,6 +125,12 @@ namespace android { return jni::Object(*converted); } + jni::Object SymbolLayer::getIconAnchor(jni::JNIEnv& env) { + using namespace mbgl::android::conversion; + Result converted = convert(env, layer.as()->SymbolLayer::getIconAnchor()); + return jni::Object(*converted); + } + jni::Object SymbolLayer::getIconPitchAlignment(jni::JNIEnv& env) { using namespace mbgl::android::conversion; Result converted = convert(env, layer.as()->SymbolLayer::getIconPitchAlignment()); @@ -520,6 +526,7 @@ namespace android { METHOD(&SymbolLayer::getIconPadding, "nativeGetIconPadding"), METHOD(&SymbolLayer::getIconKeepUpright, "nativeGetIconKeepUpright"), METHOD(&SymbolLayer::getIconOffset, "nativeGetIconOffset"), + METHOD(&SymbolLayer::getIconAnchor, "nativeGetIconAnchor"), METHOD(&SymbolLayer::getIconPitchAlignment, "nativeGetIconPitchAlignment"), METHOD(&SymbolLayer::getTextPitchAlignment, "nativeGetTextPitchAlignment"), METHOD(&SymbolLayer::getTextRotationAlignment, "nativeGetTextRotationAlignment"), diff --git a/platform/android/src/style/layers/symbol_layer.hpp b/platform/android/src/style/layers/symbol_layer.hpp index 6d3da13ae9..417e5e143f 100644 --- a/platform/android/src/style/layers/symbol_layer.hpp +++ b/platform/android/src/style/layers/symbol_layer.hpp @@ -59,6 +59,8 @@ public: jni::Object getIconOffset(jni::JNIEnv&); + jni::Object getIconAnchor(jni::JNIEnv&); + jni::Object getIconPitchAlignment(jni::JNIEnv&); jni::Object getTextPitchAlignment(jni::JNIEnv&); diff --git a/platform/darwin/scripts/generate-style-code.js b/platform/darwin/scripts/generate-style-code.js index 5a4936c0ee..4ee86e65da 100644 --- a/platform/darwin/scripts/generate-style-code.js +++ b/platform/darwin/scripts/generate-style-code.js @@ -148,6 +148,9 @@ global.mbglTestValue = function (property, layerType) { if (/-(rotation|pitch)-alignment$/.test(originalPropertyName(property))) { type = 'Alignment'; } + if (/^(text|icon)-anchor$/.test(originalPropertyName(property))) { + type = 'SymbolAnchor' + } let value = camelize(_.last(_.keys(property.values))); if (property['light-property']) { return `mbgl::style::Light${type}Type::${value}`; @@ -500,6 +503,9 @@ global.mbglType = function(property) { if (/-(rotation|pitch)-alignment$/.test(originalPropertyName(property))) { type = 'Alignment'; } + if (/^(text|icon)-anchor$/.test(originalPropertyName(property))) { + type = 'SymbolAnchor' + } return `mbgl::style::${type}Type`; } case 'color': @@ -648,10 +654,10 @@ while ((match = exampleRegex.exec(examplesSrc)) !== null) { let testMethodName = match[1], indentation = match[2], exampleCode = match[3]; - + // Trim leading whitespace from the example code. exampleCode = exampleCode.replace(new RegExp('^' + indentation, 'gm'), ''); - + examples[testMethodName] = exampleCode; } @@ -663,13 +669,13 @@ global.guideExample = function (guide, exampleId, os) { console.error(`MGLDocumentationExampleTests.test${testMethodName}() not found.`); process.exit(1); } - + // Resolve conditional compilation blocks. example = example.replace(/^(\s*)#if\s+os\((iOS|macOS)\)\n([^]*?)(?:^\1#else\n([^]*?))?^\1#endif\b\n?/gm, function (m, indentation, ifOs, ifCase, elseCase) { return (os === ifOs ? ifCase : elseCase).replace(new RegExp('^ ', 'gm'), ''); }).replace(/\n$/, ''); - + return '```swift\n' + example + '\n```'; }; diff --git a/platform/darwin/src/MGLSymbolStyleLayer.h b/platform/darwin/src/MGLSymbolStyleLayer.h index d8dded7dbd..bc39df5b16 100644 --- a/platform/darwin/src/MGLSymbolStyleLayer.h +++ b/platform/darwin/src/MGLSymbolStyleLayer.h @@ -7,6 +7,51 @@ NS_ASSUME_NONNULL_BEGIN +/** + Part of the icon placed closest to the anchor. + + Values of this type are used in the `MGLSymbolStyleLayer.iconAnchor` + property. + */ +typedef NS_ENUM(NSUInteger, MGLIconAnchor) { + /** + The center of the icon is placed closest to the anchor. + */ + MGLIconAnchorCenter, + /** + The left side of the icon is placed closest to the anchor. + */ + MGLIconAnchorLeft, + /** + The right side of the icon is placed closest to the anchor. + */ + MGLIconAnchorRight, + /** + The top of the icon is placed closest to the anchor. + */ + MGLIconAnchorTop, + /** + The bottom of the icon is placed closest to the anchor. + */ + MGLIconAnchorBottom, + /** + The top left corner of the icon is placed closest to the anchor. + */ + MGLIconAnchorTopLeft, + /** + The top right corner of the icon is placed closest to the anchor. + */ + MGLIconAnchorTopRight, + /** + The bottom left corner of the icon is placed closest to the anchor. + */ + MGLIconAnchorBottomLeft, + /** + The bottom right corner of the icon is placed closest to the anchor. + */ + MGLIconAnchorBottomRight, +}; + /** Orientation of icon when map is pitched. @@ -344,6 +389,34 @@ MGL_EXPORT @property (nonatomic, null_resettable) MGLStyleValue *iconAllowOverlap __attribute__((unavailable("Use iconAllowsOverlap instead."))); +/** + Part of the icon placed closest to the anchor. + + The default value of this property is an `MGLStyleValue` object containing an + `NSValue` object containing `MGLIconAnchorCenter`. Set this property to `nil` + to reset it to the default value. + + This property is only applied to the style if `iconImageName` is non-`nil`. + Otherwise, it is ignored. + + You can set this property to an instance of: + + * `MGLConstantStyleValue` + * `MGLCameraStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLSourceStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + * `MGLInterpolationModeIdentity` + * `MGLCompositeStyleFunction` with an interpolation mode of: + * `MGLInterpolationModeExponential` + * `MGLInterpolationModeInterval` + * `MGLInterpolationModeCategorical` + */ +@property (nonatomic, null_resettable) MGLStyleValue *iconAnchor; + /** If true, other symbols can be visible even if they collide with the icon. @@ -1983,6 +2056,19 @@ MGL_EXPORT #pragma mark Working with Symbol Style Layer Attribute Values +/** + Creates a new value object containing the given `MGLIconAnchor` enumeration. + + @param iconAnchor The value for the new object. + @return A new value object that contains the enumeration value. + */ ++ (instancetype)valueWithMGLIconAnchor:(MGLIconAnchor)iconAnchor; + +/** + The `MGLIconAnchor` enumeration representation of the value. + */ +@property (readonly) MGLIconAnchor MGLIconAnchorValue; + /** Creates a new value object containing the given `MGLIconPitchAlignment` enumeration. diff --git a/platform/darwin/src/MGLSymbolStyleLayer.mm b/platform/darwin/src/MGLSymbolStyleLayer.mm index 2541e6b0a4..7e8b0b247b 100644 --- a/platform/darwin/src/MGLSymbolStyleLayer.mm +++ b/platform/darwin/src/MGLSymbolStyleLayer.mm @@ -13,6 +13,18 @@ namespace mbgl { + MBGL_DEFINE_ENUM(MGLIconAnchor, { + { MGLIconAnchorCenter, "center" }, + { MGLIconAnchorLeft, "left" }, + { MGLIconAnchorRight, "right" }, + { MGLIconAnchorTop, "top" }, + { MGLIconAnchorBottom, "bottom" }, + { MGLIconAnchorTopLeft, "top-left" }, + { MGLIconAnchorTopRight, "top-right" }, + { MGLIconAnchorBottomLeft, "bottom-left" }, + { MGLIconAnchorBottomRight, "bottom-right" }, + }); + MBGL_DEFINE_ENUM(MGLIconPitchAlignment, { { MGLIconPitchAlignmentMap, "map" }, { MGLIconPitchAlignmentViewport, "viewport" }, @@ -166,6 +178,23 @@ namespace mbgl { return self.iconAllowsOverlap; } +- (void)setIconAnchor:(MGLStyleValue *)iconAnchor { + MGLAssertStyleLayerIsValid(); + + auto mbglValue = MGLStyleValueTransformer().toDataDrivenPropertyValue(iconAnchor); + self.rawLayer->setIconAnchor(mbglValue); +} + +- (MGLStyleValue *)iconAnchor { + MGLAssertStyleLayerIsValid(); + + auto propertyValue = self.rawLayer->getIconAnchor(); + if (propertyValue.isUndefined()) { + return MGLStyleValueTransformer().toDataDrivenStyleValue(self.rawLayer->getDefaultIconAnchor()); + } + return MGLStyleValueTransformer().toDataDrivenStyleValue(propertyValue); +} + - (void)setIconIgnoresPlacement:(MGLStyleValue *)iconIgnoresPlacement { MGLAssertStyleLayerIsValid(); @@ -586,7 +615,7 @@ namespace mbgl { - (void)setTextAnchor:(MGLStyleValue *)textAnchor { MGLAssertStyleLayerIsValid(); - auto mbglValue = MGLStyleValueTransformer().toDataDrivenPropertyValue(textAnchor); + auto mbglValue = MGLStyleValueTransformer().toDataDrivenPropertyValue(textAnchor); self.rawLayer->setTextAnchor(mbglValue); } @@ -595,9 +624,9 @@ namespace mbgl { auto propertyValue = self.rawLayer->getTextAnchor(); if (propertyValue.isUndefined()) { - return MGLStyleValueTransformer().toDataDrivenStyleValue(self.rawLayer->getDefaultTextAnchor()); + return MGLStyleValueTransformer().toDataDrivenStyleValue(self.rawLayer->getDefaultTextAnchor()); } - return MGLStyleValueTransformer().toDataDrivenStyleValue(propertyValue); + return MGLStyleValueTransformer().toDataDrivenStyleValue(propertyValue); } - (void)setTextFontNames:(MGLStyleValue *> *)textFontNames { @@ -1344,6 +1373,16 @@ namespace mbgl { @implementation NSValue (MGLSymbolStyleLayerAdditions) ++ (NSValue *)valueWithMGLIconAnchor:(MGLIconAnchor)iconAnchor { + return [NSValue value:&iconAnchor withObjCType:@encode(MGLIconAnchor)]; +} + +- (MGLIconAnchor)MGLIconAnchorValue { + MGLIconAnchor iconAnchor; + [self getValue:&iconAnchor]; + return iconAnchor; +} + + (NSValue *)valueWithMGLIconPitchAlignment:(MGLIconPitchAlignment)iconPitchAlignment { return [NSValue value:&iconPitchAlignment withObjCType:@encode(MGLIconPitchAlignment)]; } diff --git a/platform/darwin/test/MGLSymbolStyleLayerTests.mm b/platform/darwin/test/MGLSymbolStyleLayerTests.mm index 6b0b20354b..abbaef9159 100644 --- a/platform/darwin/test/MGLSymbolStyleLayerTests.mm +++ b/platform/darwin/test/MGLSymbolStyleLayerTests.mm @@ -87,6 +87,40 @@ XCTAssertThrowsSpecificNamed(layer.iconAllowsOverlap = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it"); } + // icon-anchor + { + XCTAssertTrue(rawLayer->getIconAnchor().isUndefined(), + @"icon-anchor should be unset initially."); + MGLStyleValue *defaultStyleValue = layer.iconAnchor; + + MGLStyleValue *constantStyleValue = [MGLStyleValue valueWithRawValue:[NSValue valueWithMGLIconAnchor:MGLIconAnchorBottomRight]]; + layer.iconAnchor = constantStyleValue; + mbgl::style::DataDrivenPropertyValue propertyValue = { mbgl::style::SymbolAnchorType::BottomRight }; + XCTAssertEqual(rawLayer->getIconAnchor(), propertyValue, + @"Setting iconAnchor to a constant value should update icon-anchor."); + XCTAssertEqualObjects(layer.iconAnchor, constantStyleValue, + @"iconAnchor should round-trip constant values."); + + MGLStyleValue * functionStyleValue = [MGLStyleValue valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil]; + layer.iconAnchor = functionStyleValue; + + mbgl::style::IntervalStops intervalStops = { {{18, mbgl::style::SymbolAnchorType::BottomRight}} }; + propertyValue = mbgl::style::CameraFunction { intervalStops }; + + XCTAssertEqual(rawLayer->getIconAnchor(), propertyValue, + @"Setting iconAnchor to a camera function should update icon-anchor."); + XCTAssertEqualObjects(layer.iconAnchor, functionStyleValue, + @"iconAnchor should round-trip camera functions."); + + + + layer.iconAnchor = nil; + XCTAssertTrue(rawLayer->getIconAnchor().isUndefined(), + @"Unsetting iconAnchor should return icon-anchor to the default value."); + XCTAssertEqualObjects(layer.iconAnchor, defaultStyleValue, + @"iconAnchor should return the default value after being unset."); + } + // icon-ignore-placement { XCTAssertTrue(rawLayer->getIconIgnorePlacement().isUndefined(), @@ -931,7 +965,7 @@ MGLStyleValue *constantStyleValue = [MGLStyleValue valueWithRawValue:[NSValue valueWithMGLTextAnchor:MGLTextAnchorBottomRight]]; layer.textAnchor = constantStyleValue; - mbgl::style::DataDrivenPropertyValue propertyValue = { mbgl::style::TextAnchorType::BottomRight }; + mbgl::style::DataDrivenPropertyValue propertyValue = { mbgl::style::SymbolAnchorType::BottomRight }; XCTAssertEqual(rawLayer->getTextAnchor(), propertyValue, @"Setting textAnchor to a constant value should update text-anchor."); XCTAssertEqualObjects(layer.textAnchor, constantStyleValue, @@ -940,8 +974,8 @@ MGLStyleValue * functionStyleValue = [MGLStyleValue valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil]; layer.textAnchor = functionStyleValue; - mbgl::style::IntervalStops intervalStops = { {{18, mbgl::style::TextAnchorType::BottomRight}} }; - propertyValue = mbgl::style::CameraFunction { intervalStops }; + mbgl::style::IntervalStops intervalStops = { {{18, mbgl::style::SymbolAnchorType::BottomRight}} }; + propertyValue = mbgl::style::CameraFunction { intervalStops }; XCTAssertEqual(rawLayer->getTextAnchor(), propertyValue, @"Setting textAnchor to a camera function should update text-anchor."); @@ -2345,6 +2379,7 @@ - (void)testPropertyNames { [self testPropertyName:@"icon-allows-overlap" isBoolean:YES]; + [self testPropertyName:@"icon-anchor" isBoolean:NO]; [self testPropertyName:@"icon-ignores-placement" isBoolean:YES]; [self testPropertyName:@"icon-image-name" isBoolean:NO]; [self testPropertyName:@"icon-offset" isBoolean:NO]; @@ -2396,6 +2431,15 @@ } - (void)testValueAdditions { + XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorCenter].MGLIconAnchorValue, MGLIconAnchorCenter); + XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorLeft].MGLIconAnchorValue, MGLIconAnchorLeft); + XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorRight].MGLIconAnchorValue, MGLIconAnchorRight); + XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorTop].MGLIconAnchorValue, MGLIconAnchorTop); + XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorBottom].MGLIconAnchorValue, MGLIconAnchorBottom); + XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorTopLeft].MGLIconAnchorValue, MGLIconAnchorTopLeft); + XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorTopRight].MGLIconAnchorValue, MGLIconAnchorTopRight); + XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorBottomLeft].MGLIconAnchorValue, MGLIconAnchorBottomLeft); + XCTAssertEqual([NSValue valueWithMGLIconAnchor:MGLIconAnchorBottomRight].MGLIconAnchorValue, MGLIconAnchorBottomRight); XCTAssertEqual([NSValue valueWithMGLIconPitchAlignment:MGLIconPitchAlignmentMap].MGLIconPitchAlignmentValue, MGLIconPitchAlignmentMap); XCTAssertEqual([NSValue valueWithMGLIconPitchAlignment:MGLIconPitchAlignmentViewport].MGLIconPitchAlignmentValue, MGLIconPitchAlignmentViewport); XCTAssertEqual([NSValue valueWithMGLIconPitchAlignment:MGLIconPitchAlignmentAuto].MGLIconPitchAlignmentValue, MGLIconPitchAlignmentAuto); diff --git a/scripts/generate-style-code.js b/scripts/generate-style-code.js index b1d0ed28ec..fe9a1a906b 100644 --- a/scripts/generate-style-code.js +++ b/scripts/generate-style-code.js @@ -29,6 +29,9 @@ global.evaluatedType = function (property) { if (/-(rotation|pitch|illumination)-alignment$/.test(property.name)) { return 'AlignmentType'; } + if (/^(text|icon)-anchor$/.test(property.name)) { + return 'SymbolAnchorType'; + } if (/position/.test(property.name)) { return 'Position'; } diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp index 229b8f2ee2..adb8ce5927 100644 --- a/src/mbgl/layout/symbol_layout.cpp +++ b/src/mbgl/layout/symbol_layout.cpp @@ -233,6 +233,7 @@ void SymbolLayout::prepare(const GlyphMap& glyphMap, const GlyphPositions& glyph shapedIcon = PositionedIcon::shapeIcon( imagePositions.at(*feature.icon), layout.evaluate(zoom, feature), + layout.evaluate(zoom, feature), layout.evaluate(zoom, feature) * util::DEG2RAD); if (image->second->sdf) { sdfIcons = true; diff --git a/src/mbgl/style/function/categorical_stops.cpp b/src/mbgl/style/function/categorical_stops.cpp index 1a30a1f1c7..dd179f5376 100644 --- a/src/mbgl/style/function/categorical_stops.cpp +++ b/src/mbgl/style/function/categorical_stops.cpp @@ -34,7 +34,7 @@ template class CategoricalStops>; template class CategoricalStops; template class CategoricalStops; template class CategoricalStops; -template class CategoricalStops; +template class CategoricalStops; template class CategoricalStops; } // namespace style diff --git a/src/mbgl/style/function/identity_stops.cpp b/src/mbgl/style/function/identity_stops.cpp index 7815f4aca0..0ac6fda846 100644 --- a/src/mbgl/style/function/identity_stops.cpp +++ b/src/mbgl/style/function/identity_stops.cpp @@ -50,12 +50,12 @@ optional IdentityStops::evaluate(const Value& } template <> -optional IdentityStops::evaluate(const Value& value) const { +optional IdentityStops::evaluate(const Value& value) const { if (!value.is()) { return {}; } - return Enum::toEnum(value.get()); + return Enum::toEnum(value.get()); } template <> diff --git a/src/mbgl/style/layers/symbol_layer.cpp b/src/mbgl/style/layers/symbol_layer.cpp index 803ae7397e..2b86b26025 100644 --- a/src/mbgl/style/layers/symbol_layer.cpp +++ b/src/mbgl/style/layers/symbol_layer.cpp @@ -332,6 +332,22 @@ void SymbolLayer::setIconOffset(DataDrivenPropertyValue> va baseImpl = std::move(impl_); observer->onLayerChanged(*this); } +DataDrivenPropertyValue SymbolLayer::getDefaultIconAnchor() { + return IconAnchor::defaultValue(); +} + +DataDrivenPropertyValue SymbolLayer::getIconAnchor() const { + return impl().layout.get(); +} + +void SymbolLayer::setIconAnchor(DataDrivenPropertyValue value) { + if (value == getIconAnchor()) + return; + auto impl_ = mutableImpl(); + impl_->layout.get() = value; + baseImpl = std::move(impl_); + observer->onLayerChanged(*this); +} PropertyValue SymbolLayer::getDefaultIconPitchAlignment() { return IconPitchAlignment::defaultValue(); } @@ -492,15 +508,15 @@ void SymbolLayer::setTextJustify(DataDrivenPropertyValue value) baseImpl = std::move(impl_); observer->onLayerChanged(*this); } -DataDrivenPropertyValue SymbolLayer::getDefaultTextAnchor() { +DataDrivenPropertyValue SymbolLayer::getDefaultTextAnchor() { return TextAnchor::defaultValue(); } -DataDrivenPropertyValue SymbolLayer::getTextAnchor() const { +DataDrivenPropertyValue SymbolLayer::getTextAnchor() const { return impl().layout.get(); } -void SymbolLayer::setTextAnchor(DataDrivenPropertyValue value) { +void SymbolLayer::setTextAnchor(DataDrivenPropertyValue value) { if (value == getTextAnchor()) return; auto impl_ = mutableImpl(); diff --git a/src/mbgl/style/layers/symbol_layer_properties.hpp b/src/mbgl/style/layers/symbol_layer_properties.hpp index fe6ab38e92..0d163b9fb9 100644 --- a/src/mbgl/style/layers/symbol_layer_properties.hpp +++ b/src/mbgl/style/layers/symbol_layer_properties.hpp @@ -87,6 +87,11 @@ struct IconOffset : DataDrivenLayoutProperty> { static std::array defaultValue() { return {{ 0, 0 }}; } }; +struct IconAnchor : DataDrivenLayoutProperty { + static constexpr const char * key = "icon-anchor"; + static SymbolAnchorType defaultValue() { return SymbolAnchorType::Center; } +}; + struct IconPitchAlignment : LayoutProperty { static constexpr const char * key = "icon-pitch-alignment"; static AlignmentType defaultValue() { return AlignmentType::Auto; } @@ -137,9 +142,9 @@ struct TextJustify : DataDrivenLayoutProperty { static TextJustifyType defaultValue() { return TextJustifyType::Center; } }; -struct TextAnchor : DataDrivenLayoutProperty { +struct TextAnchor : DataDrivenLayoutProperty { static constexpr const char * key = "text-anchor"; - static TextAnchorType defaultValue() { return TextAnchorType::Center; } + static SymbolAnchorType defaultValue() { return SymbolAnchorType::Center; } }; struct TextMaxAngle : LayoutProperty { @@ -259,6 +264,7 @@ class SymbolLayoutProperties : public Properties< IconPadding, IconKeepUpright, IconOffset, + IconAnchor, IconPitchAlignment, TextPitchAlignment, TextRotationAlignment, diff --git a/src/mbgl/style/types.cpp b/src/mbgl/style/types.cpp index 4fbf767e11..0a1781e01b 100644 --- a/src/mbgl/style/types.cpp +++ b/src/mbgl/style/types.cpp @@ -53,16 +53,16 @@ MBGL_DEFINE_ENUM(SymbolPlacementType, { { SymbolPlacementType::Line, "line" }, }); -MBGL_DEFINE_ENUM(TextAnchorType, { - { TextAnchorType::Center, "center" }, - { TextAnchorType::Left, "left" }, - { TextAnchorType::Right, "right" }, - { TextAnchorType::Top, "top" }, - { TextAnchorType::Bottom, "bottom" }, - { TextAnchorType::TopLeft, "top-left" }, - { TextAnchorType::TopRight, "top-right" }, - { TextAnchorType::BottomLeft, "bottom-left" }, - { TextAnchorType::BottomRight, "bottom-right" } +MBGL_DEFINE_ENUM(SymbolAnchorType, { + { SymbolAnchorType::Center, "center" }, + { SymbolAnchorType::Left, "left" }, + { SymbolAnchorType::Right, "right" }, + { SymbolAnchorType::Top, "top" }, + { SymbolAnchorType::Bottom, "bottom" }, + { SymbolAnchorType::TopLeft, "top-left" }, + { SymbolAnchorType::TopRight, "top-right" }, + { SymbolAnchorType::BottomLeft, "bottom-left" }, + { SymbolAnchorType::BottomRight, "bottom-right" } }); MBGL_DEFINE_ENUM(TextJustifyType, { diff --git a/src/mbgl/text/shaping.cpp b/src/mbgl/text/shaping.cpp index a40ef0cf39..5d688ea539 100644 --- a/src/mbgl/text/shaping.cpp +++ b/src/mbgl/text/shaping.cpp @@ -11,12 +11,63 @@ namespace mbgl { -PositionedIcon PositionedIcon::shapeIcon(const ImagePosition& image, const std::array& iconOffset, const float iconRotation) { +struct AnchorAlignment { + AnchorAlignment(float horizontal_, float vertical_) + : horizontalAlign(horizontal_), verticalAlign(vertical_) { + } + + float horizontalAlign; + float verticalAlign; +}; + +AnchorAlignment getAnchorAlignment(style::SymbolAnchorType anchor) { + float horizontalAlign = 0.5; + float verticalAlign = 0.5; + + switch (anchor) { + case style::SymbolAnchorType::Top: + case style::SymbolAnchorType::Bottom: + case style::SymbolAnchorType::Center: + break; + case style::SymbolAnchorType::Right: + case style::SymbolAnchorType::TopRight: + case style::SymbolAnchorType::BottomRight: + horizontalAlign = 1; + break; + case style::SymbolAnchorType::Left: + case style::SymbolAnchorType::TopLeft: + case style::SymbolAnchorType::BottomLeft: + horizontalAlign = 0; + break; + } + + switch (anchor) { + case style::SymbolAnchorType::Left: + case style::SymbolAnchorType::Right: + case style::SymbolAnchorType::Center: + break; + case style::SymbolAnchorType::Bottom: + case style::SymbolAnchorType::BottomLeft: + case style::SymbolAnchorType::BottomRight: + verticalAlign = 1; + break; + case style::SymbolAnchorType::Top: + case style::SymbolAnchorType::TopLeft: + case style::SymbolAnchorType::TopRight: + verticalAlign = 0; + break; + } + + return AnchorAlignment(horizontalAlign, verticalAlign); +} + +PositionedIcon PositionedIcon::shapeIcon(const ImagePosition& image, const std::array& iconOffset, style::SymbolAnchorType iconAnchor, const float iconRotation) { + AnchorAlignment anchorAlign = getAnchorAlignment(iconAnchor); float dx = iconOffset[0]; float dy = iconOffset[1]; - float x1 = dx - image.displaySize()[0] / 2.0f; + float x1 = dx - image.displaySize()[0] * anchorAlign.horizontalAlign; float x2 = x1 + image.displaySize()[0]; - float y1 = dy - image.displaySize()[1] / 2.0f; + float y1 = dy - image.displaySize()[1] * anchorAlign.verticalAlign; float y2 = y1 + image.displaySize()[1]; return PositionedIcon { image, y1, y2, x1, x2, iconRotation }; @@ -200,7 +251,7 @@ void shapeLines(Shaping& shaping, const std::vector& lines, const float spacing, const float lineHeight, - const style::TextAnchorType textAnchor, + const style::SymbolAnchorType textAnchor, const style::TextJustifyType textJustify, const float verticalHeight, const WritingModeType writingMode, @@ -258,58 +309,23 @@ void shapeLines(Shaping& shaping, y += lineHeight; } - float horizontalAlign = 0.5; - float verticalAlign = 0.5; - - switch (textAnchor) { - case style::TextAnchorType::Top: - case style::TextAnchorType::Bottom: - case style::TextAnchorType::Center: - break; - case style::TextAnchorType::Right: - case style::TextAnchorType::TopRight: - case style::TextAnchorType::BottomRight: - horizontalAlign = 1; - break; - case style::TextAnchorType::Left: - case style::TextAnchorType::TopLeft: - case style::TextAnchorType::BottomLeft: - horizontalAlign = 0; - break; - } - - switch (textAnchor) { - case style::TextAnchorType::Left: - case style::TextAnchorType::Right: - case style::TextAnchorType::Center: - break; - case style::TextAnchorType::Bottom: - case style::TextAnchorType::BottomLeft: - case style::TextAnchorType::BottomRight: - verticalAlign = 1; - break; - case style::TextAnchorType::Top: - case style::TextAnchorType::TopLeft: - case style::TextAnchorType::TopRight: - verticalAlign = 0; - break; - } + auto anchorAlign = getAnchorAlignment(textAnchor); - align(shaping, justify, horizontalAlign, verticalAlign, - maxLineLength, lineHeight, lines.size()); + align(shaping, justify, anchorAlign.horizontalAlign, anchorAlign.verticalAlign, maxLineLength, + lineHeight, lines.size()); const uint32_t height = lines.size() * lineHeight; // Calculate the bounding box - shaping.top += -verticalAlign * height; + shaping.top += -anchorAlign.verticalAlign * height; shaping.bottom = shaping.top + height; - shaping.left += -horizontalAlign * maxLineLength; + shaping.left += -anchorAlign.horizontalAlign * maxLineLength; shaping.right = shaping.left + maxLineLength; } const Shaping getShaping(const std::u16string& logicalInput, const float maxWidth, const float lineHeight, - const style::TextAnchorType textAnchor, + const style::SymbolAnchorType textAnchor, const style::TextJustifyType textJustify, const float spacing, const Point& translate, diff --git a/src/mbgl/text/shaping.hpp b/src/mbgl/text/shaping.hpp index 00e4ec55f8..0a961849e5 100644 --- a/src/mbgl/text/shaping.hpp +++ b/src/mbgl/text/shaping.hpp @@ -32,7 +32,10 @@ private: float _angle; public: - static PositionedIcon shapeIcon(const ImagePosition&, const std::array& iconOffset, const float iconRotation); + static PositionedIcon shapeIcon(const ImagePosition&, + const std::array& iconOffset, + style::SymbolAnchorType iconAnchor, + const float iconRotation); const ImagePosition& image() const { return _image; } float top() const { return _top; } @@ -45,7 +48,7 @@ public: const Shaping getShaping(const std::u16string& string, float maxWidth, float lineHeight, - style::TextAnchorType textAnchor, + style::SymbolAnchorType textAnchor, style::TextJustifyType textJustify, float spacing, const Point& translate, diff --git a/test/text/quads.test.cpp b/test/text/quads.test.cpp index c4c1a7ac15..8eedd9bd2e 100644 --- a/test/text/quads.test.cpp +++ b/test/text/quads.test.cpp @@ -17,7 +17,7 @@ TEST(getIconQuads, normal) { style::Image::Impl("test", PremultipliedImage({1,1}), 1.0) }; - auto shapedIcon = PositionedIcon::shapeIcon(image, {{ -6.5f, -4.5f }}, 0); + auto shapedIcon = PositionedIcon::shapeIcon(image, {{ -6.5f, -4.5f }}, SymbolAnchorType::Center, 0); GeometryCoordinates line; Shaping shapedText; @@ -42,7 +42,7 @@ TEST(getIconQuads, style) { style::Image::Impl("test", PremultipliedImage({1,1}), 1.0) }; - auto shapedIcon = PositionedIcon::shapeIcon(image, {{ -9.5f, -9.5f }}, 0); + auto shapedIcon = PositionedIcon::shapeIcon(image, {{ -9.5f, -9.5f }}, SymbolAnchorType::Center, 0); GeometryCoordinates line; Shaping shapedText; -- cgit v1.2.1