From 25b850c3ba6bbe4736ced219f89e0e60cc963c9f Mon Sep 17 00:00:00 2001 From: Max Mitchell Date: Tue, 3 Mar 2026 12:33:44 -0800 Subject: [PATCH] Internal change. PiperOrigin-RevId: 878076947 --- ink/brush/BUILD.bazel | 1 + ink/brush/brush_behavior.cc | 36 ++++++++---- ink/brush/brush_behavior.h | 10 ++++ ink/brush/brush_family.cc | 7 ++- ink/brush/brush_family.h | 2 + ink/brush/brush_paint.cc | 10 ++-- ink/brush/brush_paint.h | 8 +++ ink/brush/easing_function.cc | 25 +++++---- ink/brush/easing_function.h | 2 + ink/brush/internal/jni/BUILD.bazel | 56 +++++++++++++++++++ ink/brush/internal/jni/brush_behavior_jni.cc | 5 ++ .../internal/jni/brush_behavior_native.cc | 6 ++ .../internal/jni/brush_behavior_native.h | 2 + .../internal/jni/brush_behavior_node_jni.cc | 48 ++++++++++++++++ .../jni/brush_behavior_node_native.cc | 49 ++++++++++++++++ .../internal/jni/brush_behavior_node_native.h | 11 ++++ ink/brush/internal/jni/brush_coat_jni.cc | 5 ++ ink/brush/internal/jni/brush_coat_native.cc | 6 ++ ink/brush/internal/jni/brush_coat_native.h | 2 + ink/brush/internal/jni/brush_family_jni.cc | 5 ++ ink/brush/internal/jni/brush_family_native.cc | 6 ++ ink/brush/internal/jni/brush_family_native.h | 1 + ink/brush/internal/jni/brush_paint_jni.cc | 38 +++++++++++++ ink/brush/internal/jni/brush_paint_native.cc | 40 +++++++++++++ ink/brush/internal/jni/brush_paint_native.h | 9 +++ ink/brush/internal/jni/brush_tip_jni.cc | 5 ++ ink/brush/internal/jni/brush_tip_native.cc | 5 ++ ink/brush/internal/jni/brush_tip_native.h | 2 + ink/brush/internal/jni/easing_function_jni.cc | 13 +++++ .../internal/jni/easing_function_native.cc | 13 +++++ .../internal/jni/easing_function_native.h | 4 ++ ink/brush/internal/jni/input_tool_type_jni.cc | 27 +++++++++ .../internal/jni/input_tool_type_native.cc | 34 +++++++++++ .../internal/jni/input_tool_type_native.h | 28 ++++++++++ ink/brush/internal/jni/self_overlap_jni.cc | 27 +++++++++ ink/brush/internal/jni/self_overlap_native.cc | 35 ++++++++++++ ink/brush/internal/jni/self_overlap_native.h | 28 ++++++++++ ink/strokes/input/BUILD.bazel | 1 + ink/strokes/input/stroke_input.cc | 13 +++++ ink/strokes/input/stroke_input.h | 3 + 40 files changed, 601 insertions(+), 27 deletions(-) create mode 100644 ink/brush/internal/jni/input_tool_type_jni.cc create mode 100644 ink/brush/internal/jni/input_tool_type_native.cc create mode 100644 ink/brush/internal/jni/input_tool_type_native.h create mode 100644 ink/brush/internal/jni/self_overlap_jni.cc create mode 100644 ink/brush/internal/jni/self_overlap_native.cc create mode 100644 ink/brush/internal/jni/self_overlap_native.h diff --git a/ink/brush/BUILD.bazel b/ink/brush/BUILD.bazel index 662e389d..c953cc94 100644 --- a/ink/brush/BUILD.bazel +++ b/ink/brush/BUILD.bazel @@ -279,6 +279,7 @@ cc_library( deps = [ ":easing_function", ":version", + "//ink/strokes/input:stroke_input", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:status_macros", "@abseil-cpp//absl/strings", diff --git a/ink/brush/brush_behavior.cc b/ink/brush/brush_behavior.cc index 72577188..8af47856 100644 --- a/ink/brush/brush_behavior.cc +++ b/ink/brush/brush_behavior.cc @@ -28,6 +28,7 @@ #include "absl/strings/str_join.h" #include "ink/brush/easing_function.h" #include "ink/brush/version.h" +#include "ink/strokes/input/stroke_input.h" namespace ink { @@ -448,8 +449,6 @@ absl::Status ValidateBrushBehavior(const BrushBehavior& behavior) { return absl::OkStatus(); } -namespace { - Version CalculateMinimumRequiredVersion(BrushBehavior::Source source) { switch (source) { case BrushBehavior::Source::kNormalizedPressure: @@ -550,11 +549,6 @@ Version CalculateMinimumRequiredVersion( return Version::kDevelopment(); } -Version CalculateMinimumRequiredVersion( - BrushBehavior::EnabledToolTypes enabled) { - return Version::k0Jetpack1_0_0(); -} - Version CalculateMinimumRequiredVersion(BrushBehavior::BinaryOp operation) { switch (operation) { case BrushBehavior::BinaryOp::kProduct: @@ -591,6 +585,10 @@ Version CalculateMinimumRequiredVersion( return Version::kDevelopment(); } +namespace { + +using ::ink::brush_internal::CalculateMinimumRequiredVersion; + Version CalculateMinimumRequiredVersion(BrushBehavior::SourceNode node) { return std::max( CalculateMinimumRequiredVersion(node.source_out_of_range_behavior), @@ -605,6 +603,24 @@ Version CalculateMinimumRequiredVersion(BrushBehavior::NoiseNode node) { return CalculateMinimumRequiredVersion(node.vary_over); } +Version CalculateMinimumRequiredVersion( + BrushBehavior::EnabledToolTypes enabled) { + return std::max({ + enabled.unknown + ? CalculateMinimumRequiredVersion(StrokeInput::ToolType::kUnknown) + : Version::k0Jetpack1_0_0(), + enabled.mouse + ? CalculateMinimumRequiredVersion(StrokeInput::ToolType::kMouse) + : Version::k0Jetpack1_0_0(), + enabled.touch + ? CalculateMinimumRequiredVersion(StrokeInput::ToolType::kTouch) + : Version::k0Jetpack1_0_0(), + enabled.stylus + ? CalculateMinimumRequiredVersion(StrokeInput::ToolType::kStylus) + : Version::k0Jetpack1_0_0(), + }); +} + Version CalculateMinimumRequiredVersion( BrushBehavior::ToolTypeFilterNode node) { return CalculateMinimumRequiredVersion(node.enabled_tool_types); @@ -615,7 +631,7 @@ Version CalculateMinimumRequiredVersion(BrushBehavior::DampingNode node) { } Version CalculateMinimumRequiredVersion(BrushBehavior::ResponseNode node) { - return brush_internal::CalculateMinimumRequiredVersion(node.response_curve); + return CalculateMinimumRequiredVersion(node.response_curve); } Version CalculateMinimumRequiredVersion(BrushBehavior::IntegralNode node) { @@ -641,14 +657,14 @@ Version CalculateMinimumRequiredVersion(BrushBehavior::PolarTargetNode node) { return CalculateMinimumRequiredVersion(node.target); } +} // namespace + Version CalculateMinimumRequiredVersion(const BrushBehavior::Node& node) { return std::visit( [](const auto& node) { return CalculateMinimumRequiredVersion(node); }, node); } -} // namespace - Version CalculateMinimumRequiredVersion(const BrushBehavior& behavior) { Version max_version = Version::k0Jetpack1_0_0(); for (const auto& node : behavior.nodes) { diff --git a/ink/brush/brush_behavior.h b/ink/brush/brush_behavior.h index 88701343..6f477fe2 100644 --- a/ink/brush/brush_behavior.h +++ b/ink/brush/brush_behavior.h @@ -759,6 +759,16 @@ absl::Status ValidateBrushBehaviorNode(const BrushBehavior::Node& node); // Calculates the minimum version of the Ink library that is required to use // this brush behavior. +Version CalculateMinimumRequiredVersion(BrushBehavior::Source source); +Version CalculateMinimumRequiredVersion(BrushBehavior::Target target); +Version CalculateMinimumRequiredVersion(BrushBehavior::PolarTarget target); +Version CalculateMinimumRequiredVersion(BrushBehavior::OutOfRange out_of_range); +Version CalculateMinimumRequiredVersion(BrushBehavior::BinaryOp operation); +Version CalculateMinimumRequiredVersion( + BrushBehavior::ProgressDomain progress_domain); +Version CalculateMinimumRequiredVersion( + BrushBehavior::Interpolation interpolation); +Version CalculateMinimumRequiredVersion(const BrushBehavior::Node& node); Version CalculateMinimumRequiredVersion(const BrushBehavior& behavior); std::string ToFormattedString(BrushBehavior::Source source); diff --git a/ink/brush/brush_family.cc b/ink/brush/brush_family.cc index 97612afc..b98e21e3 100644 --- a/ink/brush/brush_family.cc +++ b/ink/brush/brush_family.cc @@ -142,7 +142,8 @@ std::string BrushFamily::ToFormattedString() const { } Version BrushFamily::CalculateMinimumRequiredVersion() const { - Version max_version = Version::k0Jetpack1_0_0(); + Version max_version = + brush_internal::CalculateMinimumRequiredVersion(input_model_); for (const auto& coat : coats_) { max_version = std::max( max_version, brush_internal::CalculateMinimumRequiredVersion(coat)); @@ -192,6 +193,10 @@ absl::Status ValidateInputModel(const BrushFamily::InputModel& model) { model); } +Version CalculateMinimumRequiredVersion(const BrushFamily::InputModel& model) { + return Version::k0Jetpack1_0_0(); +} + std::string ToFormattedString(const BrushFamily::InputModel& model) { return std::visit([](const auto& model) { return ToFormattedString(model); }, model); diff --git a/ink/brush/brush_family.h b/ink/brush/brush_family.h index f0e57a03..a7c369bc 100644 --- a/ink/brush/brush_family.h +++ b/ink/brush/brush_family.h @@ -224,6 +224,8 @@ namespace brush_internal { absl::Status ValidateInputModel(const BrushFamily::InputModel& model); +Version CalculateMinimumRequiredVersion(const BrushFamily::InputModel& model); + std::string ToFormattedString(const BrushFamily::InputModel& model); } // namespace brush_internal diff --git a/ink/brush/brush_paint.cc b/ink/brush/brush_paint.cc index b0533b73..cbb845c5 100644 --- a/ink/brush/brush_paint.cc +++ b/ink/brush/brush_paint.cc @@ -303,8 +303,6 @@ absl::Status ValidateBrushPaint(const BrushPaint& paint) { return absl::OkStatus(); } -namespace { - Version CalculateMinimumRequiredVersion( BrushPaint::TextureOrigin texture_origin) { switch (texture_origin) { @@ -365,6 +363,10 @@ Version CalculateMinimumRequiredVersion(BrushPaint::SelfOverlap self_overlap) { return Version::kDevelopment(); } +namespace { + +using ::ink::brush_internal::CalculateMinimumRequiredVersion; + Version CalculateMinimumRequiredVersion( const BrushPaint::TilingTexture& layer) { return std::max({CalculateMinimumRequiredVersion(layer.origin), @@ -389,14 +391,14 @@ Version CalculateMinimumRequiredVersion( return CalculateMinimumRequiredVersion(layer.blend_mode); } +} // namespace + Version CalculateMinimumRequiredVersion(const BrushPaint::TextureLayer& layer) { return std::visit( [](const auto& layer) { return CalculateMinimumRequiredVersion(layer); }, layer); } -} // namespace - Version CalculateMinimumRequiredVersion(const BrushPaint& paint) { Version max_version = CalculateMinimumRequiredVersion(paint.self_overlap); for (const BrushPaint::TextureLayer& layer : paint.texture_layers) { diff --git a/ink/brush/brush_paint.h b/ink/brush/brush_paint.h index 8c46cf49..f3dc7fd5 100644 --- a/ink/brush/brush_paint.h +++ b/ink/brush/brush_paint.h @@ -334,6 +334,14 @@ absl::Status ValidateBrushPaintTextureLayer( // Calculates the minimum version of the Ink library that is required to use // this brush paint. Version CalculateMinimumRequiredVersion(const BrushPaint& paint); +Version CalculateMinimumRequiredVersion( + BrushPaint::TextureOrigin texture_origin); +Version CalculateMinimumRequiredVersion( + BrushPaint::TextureSizeUnit texture_size_unit); +Version CalculateMinimumRequiredVersion(BrushPaint::TextureWrap texture_wrap); +Version CalculateMinimumRequiredVersion(BrushPaint::BlendMode blend_mode); +Version CalculateMinimumRequiredVersion(BrushPaint::SelfOverlap self_overlap); +Version CalculateMinimumRequiredVersion(const BrushPaint::TextureLayer& layer); // Adds the mesh attribute IDs that are required to properly render a mesh // with this brush paint to the given `attribute_ids` set. Note that other diff --git a/ink/brush/easing_function.cc b/ink/brush/easing_function.cc index 0ca669dc..21fc28d1 100644 --- a/ink/brush/easing_function.cc +++ b/ink/brush/easing_function.cc @@ -170,6 +170,19 @@ Version CalculateMinimumRequiredVersion(const EasingFunction::Linear& linear) { return Version::k0Jetpack1_0_0(); } +Version CalculateMinimumRequiredVersion(const EasingFunction::Steps& steps) { + return brush_internal::CalculateMinimumRequiredVersion(steps.step_position); +} + +Version CalculateMinimumRequiredVersion( + const EasingFunction::Parameters& parameters) { + return std::visit( + [](auto&& params) { return CalculateMinimumRequiredVersion(params); }, + parameters); +} + +} // namespace + Version CalculateMinimumRequiredVersion( EasingFunction::StepPosition step_position) { switch (step_position) { @@ -182,18 +195,6 @@ Version CalculateMinimumRequiredVersion( return Version::kDevelopment(); } -Version CalculateMinimumRequiredVersion(const EasingFunction::Steps& steps) { - return CalculateMinimumRequiredVersion(steps.step_position); -} - -Version CalculateMinimumRequiredVersion( - const EasingFunction::Parameters& parameters) { - return std::visit( - [](auto&& params) { return CalculateMinimumRequiredVersion(params); }, - parameters); -} -} // namespace - Version CalculateMinimumRequiredVersion(const EasingFunction& easing_function) { return CalculateMinimumRequiredVersion(easing_function.parameters); } diff --git a/ink/brush/easing_function.h b/ink/brush/easing_function.h index 63efe14b..aaace56f 100644 --- a/ink/brush/easing_function.h +++ b/ink/brush/easing_function.h @@ -192,6 +192,8 @@ absl::Status ValidateEasingFunction(const EasingFunction& easing_function); // Calculates the minimum version of the Ink library that is required to use // this easing function. Version CalculateMinimumRequiredVersion(const EasingFunction& easing_function); +Version CalculateMinimumRequiredVersion( + EasingFunction::StepPosition step_position); std::string ToFormattedString(const EasingFunction& easing_function); std::string ToFormattedString(EasingFunction::Predefined predefined); diff --git a/ink/brush/internal/jni/BUILD.bazel b/ink/brush/internal/jni/BUILD.bazel index 62104419..e835c7ec 100644 --- a/ink/brush/internal/jni/BUILD.bazel +++ b/ink/brush/internal/jni/BUILD.bazel @@ -30,6 +30,8 @@ cc_library( ":brush_paint_jni", ":brush_tip_jni", ":easing_function_jni", + ":input_tool_type_jni", + ":self_overlap_jni", ":stock_brushes_jni", ], ) @@ -50,6 +52,8 @@ cc_library( ":brush_paint_native", ":brush_tip_native", ":easing_function_native", + ":input_tool_type_native", + ":self_overlap_native", ":stock_brushes_native", ], ) @@ -408,3 +412,55 @@ cc_library( "@abseil-cpp//absl/status", ], ) + +cc_library( + name = "input_tool_type_native", + srcs = ["input_tool_type_native.cc"], + hdrs = ["input_tool_type_native.h"], + deps = [ + "//ink/brush:version", + "//ink/strokes/input:stroke_input", + ], +) + +cc_library( + name = "input_tool_type_jni", + srcs = ["input_tool_type_jni.cc"], + tags = ["keep_dep"], + deps = [ + ":input_tool_type_native", + "//ink/jni/internal:jni_defines", + ] + select({ + "@platforms//os:android": [], + "//conditions:default": [ + "@rules_jni//jni", + ], + }), + alwayslink = 1, +) + +cc_library( + name = "self_overlap_native", + srcs = ["self_overlap_native.cc"], + hdrs = ["self_overlap_native.h"], + deps = [ + "//ink/brush:brush_paint", + "//ink/brush:version", + ], +) + +cc_library( + name = "self_overlap_jni", + srcs = ["self_overlap_jni.cc"], + tags = ["keep_dep"], + deps = [ + ":self_overlap_native", + "//ink/jni/internal:jni_defines", + ] + select({ + "@platforms//os:android": [], + "//conditions:default": [ + "@rules_jni//jni", + ], + }), + alwayslink = 1, +) diff --git a/ink/brush/internal/jni/brush_behavior_jni.cc b/ink/brush/internal/jni/brush_behavior_jni.cc index ab259644..b612b0ea 100644 --- a/ink/brush/internal/jni/brush_behavior_jni.cc +++ b/ink/brush/internal/jni/brush_behavior_jni.cc @@ -82,4 +82,9 @@ JNI_METHOD(brush, BrushBehaviorNative, jlong, newCopyOfNode) return BrushBehaviorNative_newCopyOfNode(native_pointer, index); } +JNI_METHOD(brush, BrushBehaviorNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jlong native_pointer) { + return BrushBehaviorNative_calculateMinimumRequiredVersion(native_pointer); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_behavior_native.cc b/ink/brush/internal/jni/brush_behavior_native.cc index 087cc248..87054b5e 100644 --- a/ink/brush/internal/jni/brush_behavior_native.cc +++ b/ink/brush/internal/jni/brush_behavior_native.cc @@ -27,6 +27,7 @@ namespace { using ::ink::BrushBehavior; +using ::ink::brush_internal::CalculateMinimumRequiredVersion; using ::ink::brush_internal::ValidateBrushBehaviorTopLevel; using ::ink::native::CastToBrushBehavior; using ::ink::native::CastToBrushBehaviorNode; @@ -107,4 +108,9 @@ int64_t BrushBehaviorNative_newCopyOfNode(int64_t native_ptr, int index) { CastToBrushBehavior(native_ptr).nodes[index]); } +int BrushBehaviorNative_calculateMinimumRequiredVersion(int64_t native_ptr) { + return CalculateMinimumRequiredVersion(CastToBrushBehavior(native_ptr)) + .value(); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_behavior_native.h b/ink/brush/internal/jni/brush_behavior_native.h index 233106f3..78db26a6 100644 --- a/ink/brush/internal/jni/brush_behavior_native.h +++ b/ink/brush/internal/jni/brush_behavior_native.h @@ -37,6 +37,8 @@ const char* BrushBehaviorNative_getDeveloperComment(int64_t native_ptr); int64_t BrushBehaviorNative_newCopyOfNode(int64_t native_ptr, int index); +int BrushBehaviorNative_calculateMinimumRequiredVersion(int64_t native_ptr); + #ifdef __cplusplus } // extern "C" #endif diff --git a/ink/brush/internal/jni/brush_behavior_node_jni.cc b/ink/brush/internal/jni/brush_behavior_node_jni.cc index 09d02345..c90ca1ac 100644 --- a/ink/brush/internal/jni/brush_behavior_node_jni.cc +++ b/ink/brush/internal/jni/brush_behavior_node_jni.cc @@ -278,4 +278,52 @@ JNI_METHOD(brush_behavior, PolarTargetNodeNative, jfloat, getMagnitudeRangeEnd) return PolarTargetNodeNative_getMagnitudeRangeEnd(node_native_pointer); } +JNI_METHOD(brush_behavior, NodeNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jlong native_pointer) { + return NodeNative_calculateMinimumRequiredVersion(native_pointer); +} + +JNI_METHOD(brush_behavior, SourceNodeNative, jint, + getSourceMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint source_int) { + return SourceNodeNative_getSourceMinimumRequiredVersion(source_int); +} + +JNI_METHOD(brush_behavior, TargetNodeNative, jint, + getTargetMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint target_int) { + return TargetNodeNative_getTargetMinimumRequiredVersion(target_int); +} + +JNI_METHOD(brush_behavior, PolarTargetNodeNative, jint, + getPolarTargetMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint target_int) { + return PolarTargetNodeNative_getPolarTargetMinimumRequiredVersion(target_int); +} + +JNI_METHOD(brush_behavior, BinaryOpNodeNative, jint, + getOperationMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint operation_int) { + return BinaryOpNodeNative_getOperationMinimumRequiredVersion(operation_int); +} + +JNI_METHOD(brush_behavior, InterpolationNodeNative, jint, + getInterpolationMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint interpolation_int) { + return InterpolationNodeNative_getInterpolationMinimumRequiredVersion( + interpolation_int); +} + +JNI_METHOD(brush_behavior, OutOfRangeNative, jint, + calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint out_of_range_int) { + return OutOfRangeNative_calculateMinimumRequiredVersion(out_of_range_int); +} + +JNI_METHOD(brush_behavior, ProgressDomainNative, jint, + calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint domain_int) { + return ProgressDomainNative_calculateMinimumRequiredVersion(domain_int); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_behavior_node_native.cc b/ink/brush/internal/jni/brush_behavior_node_native.cc index a1883292..40761774 100644 --- a/ink/brush/internal/jni/brush_behavior_node_native.cc +++ b/ink/brush/internal/jni/brush_behavior_node_native.cc @@ -24,6 +24,7 @@ namespace { using ::ink::BrushBehavior; +using ::ink::brush_internal::CalculateMinimumRequiredVersion; using ::ink::brush_internal::ValidateBrushBehaviorNode; using ::ink::native::CastToBrushBehaviorNode; using ::ink::native::CastToEasingFunction; @@ -401,4 +402,52 @@ float PolarTargetNodeNative_getMagnitudeRangeEnd(int64_t native_ptr) { .magnitude_range[1]; } +int NodeNative_calculateMinimumRequiredVersion(int64_t native_ptr) { + return CalculateMinimumRequiredVersion(CastToBrushBehaviorNode(native_ptr)) + .value(); +} + +int SourceNodeNative_getSourceMinimumRequiredVersion(int source_int) { + return CalculateMinimumRequiredVersion( + static_cast(source_int)) + .value(); +} + +int TargetNodeNative_getTargetMinimumRequiredVersion(int target_int) { + return CalculateMinimumRequiredVersion( + static_cast(target_int)) + .value(); +} + +int PolarTargetNodeNative_getPolarTargetMinimumRequiredVersion(int target_int) { + return CalculateMinimumRequiredVersion( + static_cast(target_int)) + .value(); +} + +int BinaryOpNodeNative_getOperationMinimumRequiredVersion(int operation_int) { + return CalculateMinimumRequiredVersion( + static_cast(operation_int)) + .value(); +} + +int InterpolationNodeNative_getInterpolationMinimumRequiredVersion( + int interpolation_int) { + return CalculateMinimumRequiredVersion( + static_cast(interpolation_int)) + .value(); +} + +int OutOfRangeNative_calculateMinimumRequiredVersion(int out_of_range_int) { + return CalculateMinimumRequiredVersion( + static_cast(out_of_range_int)) + .value(); +} + +int ProgressDomainNative_calculateMinimumRequiredVersion(int domain_int) { + return CalculateMinimumRequiredVersion( + static_cast(domain_int)) + .value(); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_behavior_node_native.h b/ink/brush/internal/jni/brush_behavior_node_native.h index 40b08d51..9b010b60 100644 --- a/ink/brush/internal/jni/brush_behavior_node_native.h +++ b/ink/brush/internal/jni/brush_behavior_node_native.h @@ -142,6 +142,17 @@ float PolarTargetNodeNative_getAngleRangeEnd(int64_t native_ptr); float PolarTargetNodeNative_getMagnitudeRangeStart(int64_t native_ptr); float PolarTargetNodeNative_getMagnitudeRangeEnd(int64_t native_ptr); +// Calculate minimum required version: +int NodeNative_calculateMinimumRequiredVersion(int64_t native_ptr); +int SourceNodeNative_getSourceMinimumRequiredVersion(int source_int); +int TargetNodeNative_getTargetMinimumRequiredVersion(int target_int); +int PolarTargetNodeNative_getPolarTargetMinimumRequiredVersion(int target_int); +int BinaryOpNodeNative_getOperationMinimumRequiredVersion(int operation_int); +int OutOfRangeNative_calculateMinimumRequiredVersion(int out_of_range_int); +int ProgressDomainNative_calculateMinimumRequiredVersion(int domain_int); +int InterpolationNodeNative_getInterpolationMinimumRequiredVersion( + int interpolation_int); + #ifdef __cplusplus } // extern "C" #endif diff --git a/ink/brush/internal/jni/brush_coat_jni.cc b/ink/brush/internal/jni/brush_coat_jni.cc index 18d73870..13fb3e33 100644 --- a/ink/brush/internal/jni/brush_coat_jni.cc +++ b/ink/brush/internal/jni/brush_coat_jni.cc @@ -72,4 +72,9 @@ JNI_METHOD(brush, BrushCoatNative, jlong, newCopyOfBrushPaintPreference) return BrushCoatNative_newCopyOfBrushPaintPreference(native_pointer, index); } +JNI_METHOD(brush, BrushCoatNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jlong native_pointer) { + return BrushCoatNative_calculateMinimumRequiredVersion(native_pointer); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_coat_native.cc b/ink/brush/internal/jni/brush_coat_native.cc index f55579ae..6f925767 100644 --- a/ink/brush/internal/jni/brush_coat_native.cc +++ b/ink/brush/internal/jni/brush_coat_native.cc @@ -31,6 +31,7 @@ using ::ink::BrushCoat; using ::ink::BrushPaint; using ::ink::MeshFormat; using ::ink::brush_internal::AddAttributeIdsRequiredByCoat; +using ::ink::brush_internal::CalculateMinimumRequiredVersion; using ::ink::native::CastToBrushCoat; using ::ink::native::CastToBrushPaint; using ::ink::native::CastToBrushTip; @@ -92,4 +93,9 @@ int64_t BrushCoatNative_newCopyOfBrushPaintPreference(int64_t native_pointer, CastToBrushCoat(native_pointer).paint_preferences[index]); } +int BrushCoatNative_calculateMinimumRequiredVersion(int64_t native_pointer) { + return CalculateMinimumRequiredVersion(CastToBrushCoat(native_pointer)) + .value(); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_coat_native.h b/ink/brush/internal/jni/brush_coat_native.h index 29d35a77..8d57d078 100644 --- a/ink/brush/internal/jni/brush_coat_native.h +++ b/ink/brush/internal/jni/brush_coat_native.h @@ -38,6 +38,8 @@ int BrushCoatNative_getBrushPaintPreferencesCount(int64_t native_pointer); int64_t BrushCoatNative_newCopyOfBrushPaintPreference(int64_t native_pointer, int index); +int BrushCoatNative_calculateMinimumRequiredVersion(int64_t native_pointer); + #ifdef __cplusplus } // extern "C" #endif diff --git a/ink/brush/internal/jni/brush_family_jni.cc b/ink/brush/internal/jni/brush_family_jni.cc index 14c786f1..ac2e04ed 100644 --- a/ink/brush/internal/jni/brush_family_jni.cc +++ b/ink/brush/internal/jni/brush_family_jni.cc @@ -139,4 +139,9 @@ JNI_METHOD(brush, InputModelNative, jint, getSlidingUpsamplingFrequencyHz) return InputModelNative_getSlidingUpsamplingFrequencyHz(native_pointer); } +JNI_METHOD(brush, InputModelNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject object, jlong native_pointer) { + return InputModelNative_calculateMinimumRequiredVersion(native_pointer); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_family_native.cc b/ink/brush/internal/jni/brush_family_native.cc index 132f307c..32e25ecc 100644 --- a/ink/brush/internal/jni/brush_family_native.cc +++ b/ink/brush/internal/jni/brush_family_native.cc @@ -34,6 +34,7 @@ using ::ink::BrushCoat; using ::ink::BrushFamily; using ::ink::Duration32; +using ::ink::brush_internal::CalculateMinimumRequiredVersion; using ::ink::native::CastToBrushCoat; using ::ink::native::CastToBrushFamily; using ::ink::native::CastToInputModel; @@ -196,4 +197,9 @@ int InputModelNative_getSlidingUpsamplingFrequencyHz(int64_t native_pointer) { static_cast(std::numeric_limits::max()))); } +int InputModelNative_calculateMinimumRequiredVersion(int64_t native_pointer) { + return CalculateMinimumRequiredVersion(CastToInputModel(native_pointer)) + .value(); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_family_native.h b/ink/brush/internal/jni/brush_family_native.h index b577337f..fd52a54c 100644 --- a/ink/brush/internal/jni/brush_family_native.h +++ b/ink/brush/internal/jni/brush_family_native.h @@ -64,6 +64,7 @@ void InputModelNative_free(int64_t native_pointer); int64_t InputModelNative_getSlidingWindowDurationMillis(int64_t native_pointer); int InputModelNative_getSlidingUpsamplingFrequencyHz(int64_t native_pointer); +int InputModelNative_calculateMinimumRequiredVersion(int64_t native_pointer); #ifdef __cplusplus } // extern "C" diff --git a/ink/brush/internal/jni/brush_paint_jni.cc b/ink/brush/internal/jni/brush_paint_jni.cc index 9d796feb..388702af 100644 --- a/ink/brush/internal/jni/brush_paint_jni.cc +++ b/ink/brush/internal/jni/brush_paint_jni.cc @@ -301,4 +301,42 @@ JNI_METHOD(brush, ColorFunctionNative, jlong, computeTransformedColorLong) color_space, &ComposeColorLongFromComponentsCallback); } +JNI_METHOD(brush, BrushPaintNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jlong native_pointer) { + return BrushPaintNative_calculateMinimumRequiredVersion(native_pointer); +} + +JNI_METHOD(brush, BrushPaintNative, jint, getBlendModeMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint blend_mode_int) { + return BrushPaintNative_getBlendModeMinimumRequiredVersion(blend_mode_int); +} + +JNI_METHOD(brush, BrushPaintNative, jint, getTextureWrapMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint wrap_int) { + return BrushPaintNative_getTextureWrapMinimumRequiredVersion(wrap_int); +} + +JNI_METHOD(brush, BrushPaintNative, jint, + getTextureOriginMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint origin_int) { + return BrushPaintNative_getTextureOriginMinimumRequiredVersion(origin_int); +} + +JNI_METHOD(brush, BrushPaintNative, jint, + getTextureSizeUnitMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint size_unit_int) { + return BrushPaintNative_getTextureSizeUnitMinimumRequiredVersion( + size_unit_int); +} + +JNI_METHOD(brush, TextureLayerNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jlong native_pointer) { + return TextureLayerNative_calculateMinimumRequiredVersion(native_pointer); +} + +JNI_METHOD(brush, ColorFunctionNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jlong native_pointer) { + return ColorFunctionNative_calculateMinimumRequiredVersion(native_pointer); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_paint_native.cc b/ink/brush/internal/jni/brush_paint_native.cc index 92157712..12157df4 100644 --- a/ink/brush/internal/jni/brush_paint_native.cc +++ b/ink/brush/internal/jni/brush_paint_native.cc @@ -44,6 +44,7 @@ using ::ink::ColorSpace; using ::ink::MeshFormat; using ::ink::Vec; using ::ink::brush_internal::AddAttributeIdsRequiredByPaint; +using ::ink::brush_internal::CalculateMinimumRequiredVersion; using ::ink::brush_internal::ValidateBrushPaint; using ::ink::brush_internal::ValidateBrushPaintTextureLayer; using ::ink::native::CastToBrushPaint; @@ -412,4 +413,43 @@ int64_t ColorFunctionNative_computeTransformedColorLong( compose_color_long_from_components_callback); } +int BrushPaintNative_calculateMinimumRequiredVersion(int64_t native_ptr) { + return CalculateMinimumRequiredVersion(CastToBrushPaint(native_ptr)).value(); +} + +int BrushPaintNative_getBlendModeMinimumRequiredVersion(int blend_mode_int) { + return CalculateMinimumRequiredVersion( + static_cast(blend_mode_int)) + .value(); +} + +int BrushPaintNative_getTextureWrapMinimumRequiredVersion(int wrap_int) { + return CalculateMinimumRequiredVersion( + static_cast(wrap_int)) + .value(); +} + +int BrushPaintNative_getTextureOriginMinimumRequiredVersion(int origin_int) { + return CalculateMinimumRequiredVersion( + static_cast(origin_int)) + .value(); +} + +int BrushPaintNative_getTextureSizeUnitMinimumRequiredVersion( + int size_unit_int) { + return CalculateMinimumRequiredVersion( + static_cast(size_unit_int)) + .value(); +} + +int TextureLayerNative_calculateMinimumRequiredVersion(int64_t native_ptr) { + return CalculateMinimumRequiredVersion(CastToTextureLayer(native_ptr)) + .value(); +} + +int ColorFunctionNative_calculateMinimumRequiredVersion(int64_t native_ptr) { + return CalculateMinimumRequiredVersion(CastToColorFunction(native_ptr)) + .value(); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_paint_native.h b/ink/brush/internal/jni/brush_paint_native.h index 9eead419..1cbc3925 100644 --- a/ink/brush/internal/jni/brush_paint_native.h +++ b/ink/brush/internal/jni/brush_paint_native.h @@ -152,6 +152,15 @@ int64_t ColorFunctionNative_computeTransformedColorLong( float, float, float)); +int BrushPaintNative_calculateMinimumRequiredVersion(int64_t native_ptr); +int BrushPaintNative_getBlendModeMinimumRequiredVersion(int blend_mode_int); +int BrushPaintNative_getTextureWrapMinimumRequiredVersion(int wrap_int); +int BrushPaintNative_getTextureOriginMinimumRequiredVersion(int origin_int); +int BrushPaintNative_getTextureSizeUnitMinimumRequiredVersion( + int size_unit_int); +int TextureLayerNative_calculateMinimumRequiredVersion(int64_t native_ptr); +int ColorFunctionNative_calculateMinimumRequiredVersion(int64_t native_ptr); + #ifdef __cplusplus } // extern "C" #endif diff --git a/ink/brush/internal/jni/brush_tip_jni.cc b/ink/brush/internal/jni/brush_tip_jni.cc index 4d5f03c4..e363ff8d 100644 --- a/ink/brush/internal/jni/brush_tip_jni.cc +++ b/ink/brush/internal/jni/brush_tip_jni.cc @@ -107,4 +107,9 @@ JNI_METHOD(brush, BrushTipNative, jlong, newCopyOfBrushBehavior) return BrushTipNative_newCopyOfBrushBehavior(native_pointer, index); } +JNI_METHOD(brush, BrushTipNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jlong native_pointer) { + return BrushTipNative_calculateMinimumRequiredVersion(native_pointer); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_tip_native.cc b/ink/brush/internal/jni/brush_tip_native.cc index a6ccd761..fe963900 100644 --- a/ink/brush/internal/jni/brush_tip_native.cc +++ b/ink/brush/internal/jni/brush_tip_native.cc @@ -32,6 +32,7 @@ using ::ink::BrushBehavior; using ::ink::BrushTip; using ::ink::Duration32; using ::ink::Vec; +using ::ink::brush_internal::CalculateMinimumRequiredVersion; using ::ink::brush_internal::ValidateBrushTip; using ::ink::native::CastToBrushBehavior; using ::ink::native::CastToBrushTip; @@ -117,4 +118,8 @@ int64_t BrushTipNative_newCopyOfBrushBehavior(int64_t native_ptr, int index) { return NewNativeBrushBehavior(CastToBrushTip(native_ptr).behaviors[index]); } +int BrushTipNative_calculateMinimumRequiredVersion(int64_t native_ptr) { + return CalculateMinimumRequiredVersion(CastToBrushTip(native_ptr)).value(); +} + } // extern "C" diff --git a/ink/brush/internal/jni/brush_tip_native.h b/ink/brush/internal/jni/brush_tip_native.h index 503bc5b8..1325868b 100644 --- a/ink/brush/internal/jni/brush_tip_native.h +++ b/ink/brush/internal/jni/brush_tip_native.h @@ -52,6 +52,8 @@ int BrushTipNative_getBehaviorCount(int64_t native_ptr); int64_t BrushTipNative_newCopyOfBrushBehavior(int64_t native_ptr, int index); +int BrushTipNative_calculateMinimumRequiredVersion(int64_t native_ptr); + #ifdef __cplusplus } // extern "C" #endif diff --git a/ink/brush/internal/jni/easing_function_jni.cc b/ink/brush/internal/jni/easing_function_jni.cc index 73dbef04..483f4a39 100644 --- a/ink/brush/internal/jni/easing_function_jni.cc +++ b/ink/brush/internal/jni/easing_function_jni.cc @@ -119,4 +119,17 @@ JNI_METHOD(brush_behavior, EasingFunctionNative, jint, getStepsPositionInt) return EasingFunctionNative_getStepsPositionInt(native_pointer); } +JNI_METHOD(brush_behavior, EasingFunctionNative, jint, + calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jlong native_pointer) { + return EasingFunctionNative_calculateMinimumRequiredVersion(native_pointer); +} + +JNI_METHOD(brush_behavior, EasingFunctionNative, jint, + getStepPositionMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint step_position_int) { + return EasingFunctionNative_getStepPositionMinimumRequiredVersion( + step_position_int); +} + } // extern "C" diff --git a/ink/brush/internal/jni/easing_function_native.cc b/ink/brush/internal/jni/easing_function_native.cc index ef4c460f..94a5b014 100644 --- a/ink/brush/internal/jni/easing_function_native.cc +++ b/ink/brush/internal/jni/easing_function_native.cc @@ -29,6 +29,7 @@ namespace { using ink::EasingFunction; using ink::Point; +using ink::brush_internal::CalculateMinimumRequiredVersion; using ink::native::CastToEasingFunction; using ink::native::DeleteNativeEasingFunction; using ink::native::NewNativeEasingFunction; @@ -185,4 +186,16 @@ int EasingFunctionNative_getStepsPositionInt(int64_t native_ptr) { .step_position); } +int EasingFunctionNative_calculateMinimumRequiredVersion(int64_t native_ptr) { + return CalculateMinimumRequiredVersion(CastToEasingFunction(native_ptr)) + .value(); +} + +int EasingFunctionNative_getStepPositionMinimumRequiredVersion( + int step_position_int) { + return CalculateMinimumRequiredVersion( + static_cast(step_position_int)) + .value(); +} + } // extern "C" diff --git a/ink/brush/internal/jni/easing_function_native.h b/ink/brush/internal/jni/easing_function_native.h index fceca7e2..be2e5666 100644 --- a/ink/brush/internal/jni/easing_function_native.h +++ b/ink/brush/internal/jni/easing_function_native.h @@ -88,6 +88,10 @@ float EasingFunctionNative_getLinearPointY(int64_t native_ptr, int index); int EasingFunctionNative_getStepsCount(int64_t native_ptr); int EasingFunctionNative_getStepsPositionInt(int64_t native_ptr); +int EasingFunctionNative_calculateMinimumRequiredVersion(int64_t native_ptr); +int EasingFunctionNative_getStepPositionMinimumRequiredVersion( + int step_position_int); + #ifdef __cplusplus } // extern "C" #endif diff --git a/ink/brush/internal/jni/input_tool_type_jni.cc b/ink/brush/internal/jni/input_tool_type_jni.cc new file mode 100644 index 00000000..7eedaad4 --- /dev/null +++ b/ink/brush/internal/jni/input_tool_type_jni.cc @@ -0,0 +1,27 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include + +#include "ink/brush/internal/jni/input_tool_type_native.h" +#include "ink/jni/internal/jni_defines.h" + +extern "C" { + +JNI_METHOD(brush, InputToolTypeNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint tool_type_int) { + return InputToolTypeNative_calculateMinimumRequiredVersion(tool_type_int); +} + +} // extern "C" diff --git a/ink/brush/internal/jni/input_tool_type_native.cc b/ink/brush/internal/jni/input_tool_type_native.cc new file mode 100644 index 00000000..5a216f69 --- /dev/null +++ b/ink/brush/internal/jni/input_tool_type_native.cc @@ -0,0 +1,34 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "ink/brush/internal/jni/input_tool_type_native.h" + +#include "ink/brush/version.h" +#include "ink/strokes/input/stroke_input.h" + +namespace { + +using ::ink::StrokeInput; + +} // namespace + +extern "C" { + +int InputToolTypeNative_calculateMinimumRequiredVersion(int tool_type_int) { + return ink::CalculateMinimumRequiredVersion( + static_cast(tool_type_int)) + .value(); +} + +} // extern "C" diff --git a/ink/brush/internal/jni/input_tool_type_native.h b/ink/brush/internal/jni/input_tool_type_native.h new file mode 100644 index 00000000..2f83e2a2 --- /dev/null +++ b/ink/brush/internal/jni/input_tool_type_native.h @@ -0,0 +1,28 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef INK_BRUSH_INTERNAL_JNI_INPUT_TOOL_TYPE_NATIVE_H_ +#define INK_BRUSH_INTERNAL_JNI_INPUT_TOOL_TYPE_NATIVE_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +int InputToolTypeNative_calculateMinimumRequiredVersion(int tool_type_int); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // INK_BRUSH_INTERNAL_JNI_INPUT_TOOL_TYPE_NATIVE_H_ diff --git a/ink/brush/internal/jni/self_overlap_jni.cc b/ink/brush/internal/jni/self_overlap_jni.cc new file mode 100644 index 00000000..22d4ccff --- /dev/null +++ b/ink/brush/internal/jni/self_overlap_jni.cc @@ -0,0 +1,27 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include + +#include "ink/brush/internal/jni/self_overlap_native.h" +#include "ink/jni/internal/jni_defines.h" + +extern "C" { + +JNI_METHOD(brush, SelfOverlapNative, jint, calculateMinimumRequiredVersion) +(JNIEnv* env, jobject thiz, jint self_overlap_int) { + return SelfOverlapNative_calculateMinimumRequiredVersion(self_overlap_int); +} + +} // extern "C" diff --git a/ink/brush/internal/jni/self_overlap_native.cc b/ink/brush/internal/jni/self_overlap_native.cc new file mode 100644 index 00000000..bc8db7f7 --- /dev/null +++ b/ink/brush/internal/jni/self_overlap_native.cc @@ -0,0 +1,35 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "ink/brush/internal/jni/self_overlap_native.h" + +#include "ink/brush/brush_paint.h" +#include "ink/brush/version.h" + +namespace { + +using ::ink::BrushPaint; +using ::ink::brush_internal::CalculateMinimumRequiredVersion; + +} // namespace + +extern "C" { + +int SelfOverlapNative_calculateMinimumRequiredVersion(int self_overlap_int) { + return CalculateMinimumRequiredVersion( + static_cast(self_overlap_int)) + .value(); +} + +} // extern "C" diff --git a/ink/brush/internal/jni/self_overlap_native.h b/ink/brush/internal/jni/self_overlap_native.h new file mode 100644 index 00000000..b75fc14b --- /dev/null +++ b/ink/brush/internal/jni/self_overlap_native.h @@ -0,0 +1,28 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef INK_BRUSH_INTERNAL_JNI_SELF_OVERLAP_NATIVE_H_ +#define INK_BRUSH_INTERNAL_JNI_SELF_OVERLAP_NATIVE_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +int SelfOverlapNative_calculateMinimumRequiredVersion(int self_overlap_int); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // INK_BRUSH_INTERNAL_JNI_SELF_OVERLAP_NATIVE_H_ diff --git a/ink/strokes/input/BUILD.bazel b/ink/strokes/input/BUILD.bazel index b204b950..f147888f 100644 --- a/ink/strokes/input/BUILD.bazel +++ b/ink/strokes/input/BUILD.bazel @@ -69,6 +69,7 @@ cc_library( srcs = ["stroke_input.cc"], hdrs = ["stroke_input.h"], deps = [ + "//ink/brush:version", "//ink/geometry:angle", "//ink/geometry:point", "//ink/types:duration", diff --git a/ink/strokes/input/stroke_input.cc b/ink/strokes/input/stroke_input.cc index 83669638..f876fd38 100644 --- a/ink/strokes/input/stroke_input.cc +++ b/ink/strokes/input/stroke_input.cc @@ -17,6 +17,7 @@ #include #include "absl/strings/str_cat.h" +#include "ink/brush/version.h" namespace ink { namespace stroke_input_internal { @@ -59,4 +60,16 @@ std::string ToFormattedString(const StrokeInput& input) { } } // namespace stroke_input_internal + +Version CalculateMinimumRequiredVersion(StrokeInput::ToolType tool_type) { + switch (tool_type) { + case StrokeInput::ToolType::kMouse: + case StrokeInput::ToolType::kTouch: + case StrokeInput::ToolType::kStylus: + case StrokeInput::ToolType::kUnknown: + return Version::k0Jetpack1_0_0(); + } + return Version::kDevelopment(); +} + } // namespace ink diff --git a/ink/strokes/input/stroke_input.h b/ink/strokes/input/stroke_input.h index 0b414be7..c82c8caa 100644 --- a/ink/strokes/input/stroke_input.h +++ b/ink/strokes/input/stroke_input.h @@ -18,6 +18,7 @@ #include #include +#include "ink/brush/version.h" #include "ink/geometry/angle.h" #include "ink/geometry/point.h" #include "ink/types/duration.h" @@ -101,6 +102,8 @@ std::string ToFormattedString(StrokeInput::ToolType tool_type); std::string ToFormattedString(const StrokeInput& input); } // namespace stroke_input_internal +Version CalculateMinimumRequiredVersion(StrokeInput::ToolType tool_type); + template void AbslStringify(Sink& sink, StrokeInput::ToolType tool_type) { sink.Append(stroke_input_internal::ToFormattedString(tool_type));