From d0fe27bf132d667eeee63809893c64740b2c49ac Mon Sep 17 00:00:00 2001 From: Danielku15 Date: Fri, 3 Nov 2023 20:22:02 +0100 Subject: [PATCH 1/2] Add getters for typeface information --- build/Build.LibAlphaSkia.cs | 3 +- lib/dotnet/AlphaSkia/AlphaSkiaTypeface.cs | 40 +++++++++++++- lib/dotnet/AlphaSkia/GlobalUsings.cs | 3 +- lib/dotnet/AlphaSkia/NativeMethods.cs | 13 +++++ ...net_alphatab_alphaskia_AlphaSkiaTypeface.h | 24 +++++++++ lib/java/jni/src/AlphaSkiaTypeface.cpp | 27 ++++++++++ .../alphatab/alphaskia/AlphaSkiaTypeface.java | 33 +++++++++++- lib/node/addon/addon.cpp | 54 +++++++++++++++++++ lib/node/alphaskia/src/AlphaSkiaTypeface.ts | 29 +++++++++- lib/node/alphaskia/src/addon.ts | 7 ++- wrapper/include/alphaskia.h | 12 ++++- wrapper/src/alphaskia_string.cpp | 23 ++++++++ wrapper/src/alphaskia_typeface.cpp | 46 +++++++++++----- 13 files changed, 291 insertions(+), 23 deletions(-) create mode 100644 wrapper/src/alphaskia_string.cpp diff --git a/build/Build.LibAlphaSkia.cs b/build/Build.LibAlphaSkia.cs index 5eb791e..dd3fcc5 100644 --- a/build/Build.LibAlphaSkia.cs +++ b/build/Build.LibAlphaSkia.cs @@ -81,7 +81,8 @@ partial class Build "../../wrapper/src/alphaskia_canvas.cpp", "../../wrapper/src/alphaskia_image.cpp", "../../wrapper/src/alphaskia_typeface.cpp", - "../../wrapper/src/alphaskia_data.cpp" + "../../wrapper/src/alphaskia_data.cpp", + "../../wrapper/src/alphaskia_string.cpp" ] if (is_win) { alphaskia_wrapper_sources += [ "../../wrapper/src/alphaskia.rc" ] diff --git a/lib/dotnet/AlphaSkia/AlphaSkiaTypeface.cs b/lib/dotnet/AlphaSkia/AlphaSkiaTypeface.cs index 4fce1b2..111e718 100644 --- a/lib/dotnet/AlphaSkia/AlphaSkiaTypeface.cs +++ b/lib/dotnet/AlphaSkia/AlphaSkiaTypeface.cs @@ -1,4 +1,6 @@ -namespace AlphaSkia; +using System.Text; + +namespace AlphaSkia; /// /// Represents a typeface to draw text. @@ -6,6 +8,40 @@ public sealed class AlphaSkiaTypeface : AlphaSkiaNative { private readonly AlphaSkiaData? _nativeData; + private string? _fontFamily; + + /// + /// Gets the name of the font family of this typeface. + /// + public string FamilyName + { + get + { + if (_fontFamily == null) + { + var skFamilyName = NativeMethods.alphaskia_typeface_get_family_name(Handle); + var skFamilyChars = NativeMethods.alphaskia_string_get_utf8(skFamilyName); + var skFamilyLength = NativeMethods.alphaskia_string_get_length(skFamilyName); + unsafe + { + _fontFamily = Encoding.UTF8.GetString((byte*)skFamilyChars.ToPointer(), (int)skFamilyLength); + } + NativeMethods.alphaskia_string_free(skFamilyName); + } + + return _fontFamily; + } + } + + /// + /// Gets a value indicating whether the typeface is bold. + /// + public bool IsBold => NativeMethods.alphaskia_typeface_is_bold(Handle) != 0; + + /// + /// Gets a value indicating whether the typeface is italic. + /// + public bool IsItalic => NativeMethods.alphaskia_typeface_is_italic(Handle) != 0; private AlphaSkiaTypeface(IntPtr handle, AlphaSkiaData? nativeData = null) : base(handle, NativeMethods.alphaskia_typeface_free) @@ -40,7 +76,7 @@ protected override void Dispose(bool disposing) return new AlphaSkiaTypeface(typeface, nativeData); } - + /// /// Creates a typeface using the provided information. /// diff --git a/lib/dotnet/AlphaSkia/GlobalUsings.cs b/lib/dotnet/AlphaSkia/GlobalUsings.cs index a0e9cbd..7655401 100644 --- a/lib/dotnet/AlphaSkia/GlobalUsings.cs +++ b/lib/dotnet/AlphaSkia/GlobalUsings.cs @@ -1,4 +1,5 @@ global using alphaskia_typeface_t = System.IntPtr; global using alphaskia_image_t = System.IntPtr; global using alphaskia_canvas_t = System.IntPtr; -global using alphaskia_data_t = System.IntPtr; \ No newline at end of file +global using alphaskia_data_t = System.IntPtr; +global using alphaskia_string_t = System.IntPtr; \ No newline at end of file diff --git a/lib/dotnet/AlphaSkia/NativeMethods.cs b/lib/dotnet/AlphaSkia/NativeMethods.cs index e4a75c7..155b311 100644 --- a/lib/dotnet/AlphaSkia/NativeMethods.cs +++ b/lib/dotnet/AlphaSkia/NativeMethods.cs @@ -24,9 +24,22 @@ internal static class NativeMethods [DllImport(AlphaSkiaNativeLibName, CallingConvention = CallingConvention.Cdecl)] public static extern void alphaskia_data_free(alphaskia_data_t data); + [DllImport(AlphaSkiaNativeLibName, CallingConvention = CallingConvention.Cdecl)] + public static extern IntPtr alphaskia_string_get_utf8(alphaskia_string_t str); + [DllImport(AlphaSkiaNativeLibName, CallingConvention = CallingConvention.Cdecl)] + public static extern ulong alphaskia_string_get_length(alphaskia_string_t str); + [DllImport(AlphaSkiaNativeLibName, CallingConvention = CallingConvention.Cdecl)] + public static extern void alphaskia_string_free(alphaskia_string_t str); + [DllImport(AlphaSkiaNativeLibName, CallingConvention = CallingConvention.Cdecl)] public static extern alphaskia_typeface_t alphaskia_typeface_register(alphaskia_data_t data); + [DllImport(AlphaSkiaNativeLibName, CallingConvention = CallingConvention.Cdecl)] + public static extern alphaskia_string_t alphaskia_typeface_get_family_name(alphaskia_typeface_t typeface); + [DllImport(AlphaSkiaNativeLibName, CallingConvention = CallingConvention.Cdecl)] + public static extern byte alphaskia_typeface_is_bold(alphaskia_typeface_t typeface); + [DllImport(AlphaSkiaNativeLibName, CallingConvention = CallingConvention.Cdecl)] + public static extern byte alphaskia_typeface_is_italic(alphaskia_typeface_t typeface); [DllImport(AlphaSkiaNativeLibName, CallingConvention = CallingConvention.Cdecl)] public static extern void alphaskia_typeface_free(alphaskia_typeface_t type_face); diff --git a/lib/java/jni/include/net_alphatab_alphaskia_AlphaSkiaTypeface.h b/lib/java/jni/include/net_alphatab_alphaskia_AlphaSkiaTypeface.h index 4d7c30e..3692251 100644 --- a/lib/java/jni/include/net_alphatab_alphaskia_AlphaSkiaTypeface.h +++ b/lib/java/jni/include/net_alphatab_alphaskia_AlphaSkiaTypeface.h @@ -7,6 +7,30 @@ #ifdef __cplusplus extern "C" { #endif +/* + * Class: net_alphatab_alphaskia_AlphaSkiaTypeface + * Method: isBold + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_net_alphatab_alphaskia_AlphaSkiaTypeface_isBold + (JNIEnv *, jobject); + +/* + * Class: net_alphatab_alphaskia_AlphaSkiaTypeface + * Method: isItalic + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_net_alphatab_alphaskia_AlphaSkiaTypeface_isItalic + (JNIEnv *, jobject); + +/* + * Class: net_alphatab_alphaskia_AlphaSkiaTypeface + * Method: loadFamilyName + * Signature: (J)Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_net_alphatab_alphaskia_AlphaSkiaTypeface_loadFamilyName + (JNIEnv *, jclass, jlong); + /* * Class: net_alphatab_alphaskia_AlphaSkiaTypeface * Method: release diff --git a/lib/java/jni/src/AlphaSkiaTypeface.cpp b/lib/java/jni/src/AlphaSkiaTypeface.cpp index 54aaa05..dcf7ae5 100644 --- a/lib/java/jni/src/AlphaSkiaTypeface.cpp +++ b/lib/java/jni/src/AlphaSkiaTypeface.cpp @@ -1,4 +1,5 @@ #include "../include/net_alphatab_alphaskia_AlphaSkiaTypeface.h" +#include "../include/JniHelper.h" #include "../../../../wrapper/include/alphaskia.h" extern "C" @@ -21,4 +22,30 @@ extern "C" env->ReleaseStringUTFChars(name, nativeName); return static_cast(reinterpret_cast(typeface)); } + + JNIEXPORT jboolean JNICALL Java_net_alphatab_alphaskia_AlphaSkiaTypeface_isBold(JNIEnv *env, jobject instance) + { + jlong handle = get_handle(env, instance); + uint8_t is_bold = alphaskia_typeface_is_bold(reinterpret_cast(handle)); + return static_cast(is_bold != 0); + } + + JNIEXPORT jboolean JNICALL Java_net_alphatab_alphaskia_AlphaSkiaTypeface_isItalic(JNIEnv *env, jobject instance) + { + jlong handle = get_handle(env, instance); + uint8_t is_italic = alphaskia_typeface_is_italic(reinterpret_cast(handle)); + return static_cast(is_italic != 0); + } + + JNIEXPORT jstring JNICALL Java_net_alphatab_alphaskia_AlphaSkiaTypeface_loadFamilyName(JNIEnv *env, jclass, jlong handle) + { + alphaskia_string_t family_name = alphaskia_typeface_get_family_name(reinterpret_cast(handle)); + + const char* family_name_chars = alphaskia_string_get_utf8(family_name); + jstring java_family_name = env->NewStringUTF(family_name_chars); + + alphaskia_string_free(family_name); + + return java_family_name; + } } \ No newline at end of file diff --git a/lib/java/main/src/main/java/net/alphatab/alphaskia/AlphaSkiaTypeface.java b/lib/java/main/src/main/java/net/alphatab/alphaskia/AlphaSkiaTypeface.java index 55bffd7..903fcbf 100644 --- a/lib/java/main/src/main/java/net/alphatab/alphaskia/AlphaSkiaTypeface.java +++ b/lib/java/main/src/main/java/net/alphatab/alphaskia/AlphaSkiaTypeface.java @@ -6,6 +6,32 @@ public class AlphaSkiaTypeface extends AlphaSkiaNative { private final AlphaSkiaData data; + private String familyName; + + /** + * Gets the name of the font family of this typeface. + * + * @return The name of the font family of this typeface + */ + public String getFamilyName() { + if(this.familyName == null){ + this.familyName = AlphaSkiaTypeface.loadFamilyName(this.handle); + } + return this.familyName; + } + + /** + * Gets a value indicating whether the typeface is bold. + * @return true if the font is bold, otherwise false. + */ + public native boolean isBold(); + + /** + * Gets a value indicating whether the typeface is italic. + * @return true if the font is italic, otherwise false. + */ + public native boolean isItalic(); + private AlphaSkiaTypeface(long handle, AlphaSkiaData data) { super(handle); this.data = data; @@ -21,10 +47,12 @@ public void close() { handle = 0; } + private static native String loadFamilyName(long handle); private native void release(long handle); /** * Register a new custom font from the given binary data containing the data of a font compatible with Skia (e.g. TTF). + * * @param data The raw binary data of the font. * @return The loaded typeface to use for text rendering or {@code null} if the loading failed. */ @@ -42,8 +70,9 @@ public static AlphaSkiaTypeface register(byte[] data) { /** * Creates a typeface using the provided information. - * @param name The name of the typeface. - * @param bold Whether the bold version of the typeface should be loaded. + * + * @param name The name of the typeface. + * @param bold Whether the bold version of the typeface should be loaded. * @param italic Whether the italic version of the typeface should be loaded. * @return The typeface if it can be found in the already loaded fonts or the system fonts, otherwise {@code null}. */ diff --git a/lib/node/addon/addon.cpp b/lib/node/addon/addon.cpp index a56fb60..a1c0506 100644 --- a/lib/node/addon/addon.cpp +++ b/lib/node/addon/addon.cpp @@ -276,6 +276,56 @@ static napi_value node_alphaskia_typeface_make_from_name(napi_env env, napi_call return wrapped; } +static napi_value node_alphaskia_typeface_get_family_name(napi_env env, napi_callback_info info) +{ + napi_status status(napi_ok); + + CHECK_ARGS(1); + GET_ARGUMENT_HANDLE(0, alphaskia_typeface_t, typeface); + alphaskia_string_t string = alphaskia_typeface_get_family_name(typeface); + + const char *utf8Bytes = alphaskia_string_get_utf8(string); + uint64_t stringLength = alphaskia_string_get_length(string); + + napi_value family_name; + status = napi_create_string_utf8(env, utf8Bytes, stringLength, &family_name); + ASSERT_STATUS(); + + alphaskia_string_free(string); + + return family_name; +} + +static napi_value node_alphaskia_typeface_is_bold(napi_env env, napi_callback_info info) +{ + napi_status status(napi_ok); + + CHECK_ARGS(1); + GET_ARGUMENT_HANDLE(0, alphaskia_typeface_t, typeface); + uint8_t is_bold = alphaskia_typeface_is_bold(typeface); + + napi_value node_is_bold; + status = napi_get_boolean(env, is_bold != 0, &node_is_bold); + ASSERT_STATUS(); + + return node_is_bold; +} + +static napi_value node_alphaskia_typeface_is_italic(napi_env env, napi_callback_info info) +{ + napi_status status(napi_ok); + + CHECK_ARGS(1); + GET_ARGUMENT_HANDLE(0, alphaskia_typeface_t, typeface); + uint8_t is_italic = alphaskia_typeface_is_italic(typeface); + + napi_value node_is_italic; + status = napi_get_boolean(env, is_italic != 0, &node_is_italic); + ASSERT_STATUS(); + + return node_is_italic; +} + static napi_value node_alphaskia_image_get_width(napi_env env, napi_callback_info info) { napi_status status(napi_ok); @@ -783,6 +833,10 @@ napi_value init(napi_env env, napi_value exports) EXPORT_NODE_FUNCTION(alphaskia_typeface_register); EXPORT_NODE_FUNCTION(alphaskia_typeface_free); EXPORT_NODE_FUNCTION(alphaskia_typeface_make_from_name); + EXPORT_NODE_FUNCTION(alphaskia_typeface_get_family_name); + EXPORT_NODE_FUNCTION(alphaskia_typeface_is_bold); + EXPORT_NODE_FUNCTION(alphaskia_typeface_is_italic); + EXPORT_NODE_FUNCTION(alphaskia_image_get_width); EXPORT_NODE_FUNCTION(alphaskia_image_get_height); EXPORT_NODE_FUNCTION(alphaskia_image_read_pixels); diff --git a/lib/node/alphaskia/src/AlphaSkiaTypeface.ts b/lib/node/alphaskia/src/AlphaSkiaTypeface.ts index a5b7737..e6e27e5 100644 --- a/lib/node/alphaskia/src/AlphaSkiaTypeface.ts +++ b/lib/node/alphaskia/src/AlphaSkiaTypeface.ts @@ -8,6 +8,33 @@ import { AlphaSkiaTypefaceHandle, loadAddon } from './addon'; export class AlphaSkiaTypeface extends AlphaSkiaNative { #data: AlphaSkiaData | undefined; + #familyName: string | undefined = undefined; + + /** + * Gets the name of the font family of this typeface. + */ + public get familyName(): string { + if (this.#familyName === undefined) { + this.#familyName = loadAddon().alphaskia_typeface_get_family_name(this.handle!); + } + + return this.#familyName; + } + + /** + * Gets a value indicating whether the typeface is bold. + */ + public get isBold(): boolean { + return loadAddon().alphaskia_typeface_is_bold(this.handle!); + } + + /** + * Gets a value indicating whether the typeface is italic. + */ + public get isItalic(): boolean { + return loadAddon().alphaskia_typeface_is_italic(this.handle!); + } + /** * @internal */ @@ -39,7 +66,7 @@ export class AlphaSkiaTypeface extends AlphaSkiaNative loadAddon().alphaskia_data_free(nativeData); return undefined; } - + return new AlphaSkiaTypeface(typeface, new AlphaSkiaData(nativeData)); } diff --git a/lib/node/alphaskia/src/addon.ts b/lib/node/alphaskia/src/addon.ts index 1a12825..6258fd7 100644 --- a/lib/node/alphaskia/src/addon.ts +++ b/lib/node/alphaskia/src/addon.ts @@ -76,8 +76,11 @@ export interface AlphaSkiaNodeAddon { alphaskia_data_free(data: AlphaSkiaDataHandle): void; alphaskia_typeface_register(data: AlphaSkiaDataHandle): AlphaSkiaTypefaceHandle | undefined; - alphaskia_typeface_free(type_face: AlphaSkiaTypefaceHandle): void; + alphaskia_typeface_free(typeface: AlphaSkiaTypefaceHandle): void; alphaskia_typeface_make_from_name(name: string, bold: boolean, italic: boolean): AlphaSkiaTypefaceHandle | undefined; + alphaskia_typeface_get_family_name(typeface: AlphaSkiaTypefaceHandle): string; + alphaskia_typeface_is_bold(typeface: AlphaSkiaTypefaceHandle): boolean; + alphaskia_typeface_is_italic(typeface: AlphaSkiaTypefaceHandle): boolean; alphaskia_image_get_width(image: AlphaSkiaImageHandle): number; alphaskia_image_get_height(image: AlphaSkiaImageHandle): number; @@ -111,7 +114,7 @@ export interface AlphaSkiaNodeAddon { alphaskia_canvas_fill(canvas: AlphaSkiaCanvasHandle): void; alphaskia_canvas_stroke(canvas: AlphaSkiaCanvasHandle): void; alphaskia_canvas_draw_image(canvas: AlphaSkiaCanvasHandle, image: AlphaSkiaImageHandle, x: number, y: number, w: number, h: number): void; - + alphaskia_canvas_fill_text(canvas: AlphaSkiaCanvasHandle, text: string, typeface: AlphaSkiaTypefaceHandle, font_size: number, x: number, y: number, text_align: AlphaSkiaTextAlign, baseline: AlphaSkiaTextBaseline): void; alphaskia_canvas_measure_text(canvas: AlphaSkiaCanvasHandle, text: string, typeface: AlphaSkiaTypefaceHandle, font_size: number): number; alphaskia_canvas_begin_rotate(canvas: AlphaSkiaCanvasHandle, center_x: number, center_y: number, angle: number): void; diff --git a/wrapper/include/alphaskia.h b/wrapper/include/alphaskia.h index 5987f07..81adcaf 100644 --- a/wrapper/include/alphaskia.h +++ b/wrapper/include/alphaskia.h @@ -28,10 +28,18 @@ extern "C" AS_API uint64_t alphaskia_data_get_length(alphaskia_data_t data); AS_API void alphaskia_data_free(alphaskia_data_t data); + typedef AS_API void *alphaskia_string_t; + AS_API const char* alphaskia_string_get_utf8(alphaskia_string_t string); + AS_API uint64_t alphaskia_string_get_length(alphaskia_string_t string); + AS_API void alphaskia_string_free(alphaskia_string_t string); + typedef AS_API void *alphaskia_typeface_t; AS_API alphaskia_typeface_t alphaskia_typeface_register(alphaskia_data_t data); - AS_API void alphaskia_typeface_free(alphaskia_typeface_t type_face); - AS_API alphaskia_typeface_t alphaskia_typeface_make_from_name(const char *name, uint8_t bold, uint8_t italic); + AS_API void alphaskia_typeface_free(alphaskia_typeface_t typeface); + AS_API alphaskia_typeface_t alphaskia_typeface_make_from_name(const char *family_name, uint8_t bold, uint8_t italic); + AS_API alphaskia_string_t alphaskia_typeface_get_family_name(alphaskia_typeface_t typeface); + AS_API uint8_t alphaskia_typeface_is_bold(alphaskia_typeface_t typeface); + AS_API uint8_t alphaskia_typeface_is_italic(alphaskia_typeface_t typeface); typedef AS_API void *alphaskia_image_t; AS_API int32_t alphaskia_image_get_width(alphaskia_image_t image); diff --git a/wrapper/src/alphaskia_string.cpp b/wrapper/src/alphaskia_string.cpp new file mode 100644 index 0000000..6398366 --- /dev/null +++ b/wrapper/src/alphaskia_string.cpp @@ -0,0 +1,23 @@ +#include "../include/alphaskia.h" +#include "../../externals/skia/include/core/SkString.h" + +extern "C" +{ + AS_API const char *alphaskia_string_get_utf8(alphaskia_string_t string) + { + sk_sp *skString = reinterpret_cast *>(string); + return (*skString)->c_str(); + } + + AS_API uint64_t alphaskia_string_get_length(alphaskia_string_t string) + { + sk_sp *skString = reinterpret_cast *>(string); + return static_cast((*skString)->size()); + } + + AS_API void alphaskia_string_free(alphaskia_string_t string) + { + sk_sp *skString = reinterpret_cast *>(string); + delete skString; + } +} \ No newline at end of file diff --git a/wrapper/src/alphaskia_typeface.cpp b/wrapper/src/alphaskia_typeface.cpp index e894ad1..9adc27e 100644 --- a/wrapper/src/alphaskia_typeface.cpp +++ b/wrapper/src/alphaskia_typeface.cpp @@ -7,38 +7,60 @@ extern "C" AS_API alphaskia_typeface_t alphaskia_typeface_register(alphaskia_data_t data) { sk_sp *skData = reinterpret_cast *>(data); - sk_sp skTypeFace = SkTypeface::MakeFromData(*skData, 0); - if (!skTypeFace) + sk_sp skTypeface = SkTypeface::MakeFromData(*skData, 0); + if (!skTypeface) { return nullptr; } - return reinterpret_cast(new sk_sp(skTypeFace)); + return reinterpret_cast(new sk_sp(skTypeface)); } - AS_API void alphaskia_typeface_free(alphaskia_typeface_t type_face) + AS_API void alphaskia_typeface_free(alphaskia_typeface_t typeface) { - if (!type_face) + if (!typeface) { return; } - sk_sp *skTypeFace = reinterpret_cast *>(type_face); - delete skTypeFace; + sk_sp *skTypeface = reinterpret_cast *>(typeface); + delete skTypeface; } - AS_API alphaskia_typeface_t alphaskia_typeface_make_from_name(const char *name, uint8_t bold, uint8_t italic) + AS_API alphaskia_typeface_t alphaskia_typeface_make_from_name(const char *family_name, uint8_t bold, uint8_t italic) { SkFontStyle style(bold ? SkFontStyle::kBold_Weight : SkFontStyle::kNormal_Weight, SkFontStyle::kNormal_Width, italic ? SkFontStyle::kItalic_Slant : SkFontStyle::kUpright_Slant); - sk_sp skTypeFace = SkTypeface::MakeFromName(name, style); - - if (!skTypeFace) + sk_sp skTypeface = SkTypeface::MakeFromName(family_name, style); + + if (!skTypeface) { return nullptr; } - return reinterpret_cast(new sk_sp(skTypeFace)); + return reinterpret_cast(new sk_sp(skTypeface)); + } + + AS_API alphaskia_string_t alphaskia_typeface_get_family_name(alphaskia_typeface_t typeface) + { + sk_sp *skTypeface = reinterpret_cast *>(typeface); + + sk_sp skFamilyName(new SkString()); + (*skTypeface)->getFamilyName(skFamilyName.get()); + + return reinterpret_cast(new sk_sp(skFamilyName)); + } + + AS_API uint8_t alphaskia_typeface_is_bold(alphaskia_typeface_t typeface) + { + sk_sp *skTypeface = reinterpret_cast *>(typeface); + return (*skTypeface)->isBold() ? 1 : 0; + } + + AS_API uint8_t alphaskia_typeface_is_italic(alphaskia_typeface_t typeface) + { + sk_sp *skTypeface = reinterpret_cast *>(typeface); + return (*skTypeface)->isItalic() ? 1 : 0; } } \ No newline at end of file From b15df43a589b3eea0779623d48c57bca93652aba Mon Sep 17 00:00:00 2001 From: Danielku15 Date: Fri, 3 Nov 2023 20:28:49 +0100 Subject: [PATCH 2/2] Use raw SkString ptr --- wrapper/src/alphaskia_string.cpp | 10 +++++----- wrapper/src/alphaskia_typeface.cpp | 6 +++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/wrapper/src/alphaskia_string.cpp b/wrapper/src/alphaskia_string.cpp index 6398366..9844de0 100644 --- a/wrapper/src/alphaskia_string.cpp +++ b/wrapper/src/alphaskia_string.cpp @@ -5,19 +5,19 @@ extern "C" { AS_API const char *alphaskia_string_get_utf8(alphaskia_string_t string) { - sk_sp *skString = reinterpret_cast *>(string); - return (*skString)->c_str(); + SkString *skString = reinterpret_cast(string); + return skString->c_str(); } AS_API uint64_t alphaskia_string_get_length(alphaskia_string_t string) { - sk_sp *skString = reinterpret_cast *>(string); - return static_cast((*skString)->size()); + SkString *skString = reinterpret_cast(string); + return static_cast(skString->size()); } AS_API void alphaskia_string_free(alphaskia_string_t string) { - sk_sp *skString = reinterpret_cast *>(string); + SkString *skString = reinterpret_cast(string); delete skString; } } \ No newline at end of file diff --git a/wrapper/src/alphaskia_typeface.cpp b/wrapper/src/alphaskia_typeface.cpp index 9adc27e..7e0d914 100644 --- a/wrapper/src/alphaskia_typeface.cpp +++ b/wrapper/src/alphaskia_typeface.cpp @@ -46,10 +46,10 @@ extern "C" { sk_sp *skTypeface = reinterpret_cast *>(typeface); - sk_sp skFamilyName(new SkString()); - (*skTypeface)->getFamilyName(skFamilyName.get()); + SkString* skFamilyName = new SkString(); + (*skTypeface)->getFamilyName(skFamilyName); - return reinterpret_cast(new sk_sp(skFamilyName)); + return reinterpret_cast(skFamilyName); } AS_API uint8_t alphaskia_typeface_is_bold(alphaskia_typeface_t typeface)