From 23dae695036bce3270579daf6c7b0675dc9a693b Mon Sep 17 00:00:00 2001 From: Bergmann89 Date: Sat, 31 Oct 2015 22:56:39 +0100 Subject: [PATCH] * fixed library parameter (removed const where not needed) * implemented header and example for c * update submodle: TextSuite --- TextSuite | 2 +- header/examples/c/example.c | 169 ++++++++ header/examples/c/example.h | 10 + header/examples/c/helper.h | 11 + header/examples/c/main.c | 159 +++++++ header/libTextSuite.h | 809 ++++++++++++++++++++++++++++++++++++ header/ulibTextSuite.pas | 430 +++++++++---------- ultsChar.pas | 12 +- ultsContext.pas | 12 +- ultsFont.pas | 60 +-- ultsFontCreator.pas | 32 +- ultsImage.pas | 84 ++-- ultsPostProcessor.pas | 54 ++- ultsRenderer.pas | 39 +- ultsTextBlock.pas | 106 ++--- 15 files changed, 1571 insertions(+), 418 deletions(-) create mode 100644 header/examples/c/example.c create mode 100644 header/examples/c/example.h create mode 100644 header/examples/c/helper.h create mode 100644 header/examples/c/main.c create mode 100644 header/libTextSuite.h diff --git a/TextSuite b/TextSuite index 9ad90b9..d9d1f10 160000 --- a/TextSuite +++ b/TextSuite @@ -1 +1 @@ -Subproject commit 9ad90b9f7ca02386ea5ee359638c556ca9f457b4 +Subproject commit d9d1f100f3636836555e5a1aa0987b98d02c001f diff --git a/header/examples/c/example.c b/header/examples/c/example.c new file mode 100644 index 0000000..c72fb32 --- /dev/null +++ b/header/examples/c/example.c @@ -0,0 +1,169 @@ +#include +#include + +#include "example.h" +#include "helper.h" +#include "..\..\libTextSuite.h" + +#if _WIN64 +# define LIB_NAME "..\\..\\..\\libTextSuite-x86_64-win64.dll" +#elif _WIN32 +# define LIB_NAME "..\\..\\..\\libTextSuite-i386-win32.dll" +#elif __linux__ && (__amd64 || __x86_64 || _M_AMD64 || __ppc64__) +# define LIB_NAME "../../../libTextSuite-x86_64-linux.so" +#elif __linux__ && (__i386 || _X86_) +# define LIB_NAME "../../../libTextSuite-i386-linux.so" +#else +# error 'unknown operation system' +#endif + +lts_context_handle_t context; +lts_font_creator_handle_t creator; +lts_renderer_handle_t renderer; +lts_font_handle_t font; +lts_post_processor_handle_t pp; +lts_post_processor_handle_t ppFillPattern; +lts_post_processor_handle_t ppFillColor; +lts_post_processor_handle_t ppBorder; + +const char* TEST_TEXT = "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet."; +const wchar_t CHAR_RANGE_LOREM[] = { 'L', 'o', 'r', 'e', 'm', 0 }; +const wchar_t CHAR_RANGE_E[] = { 'e', 0 }; + +const uint8_t PATTER_DATA[] = { + 0xFF, 0xBF, 0x7F, 0xBF, + 0xBF, 0xFF, 0xBF, 0x7F, + 0x7F, 0xBF, 0xFF, 0xBF, + 0xBF, 0x7F, 0xBF, 0xFF +}; + +void WINAPI execute_post_proc(lts_char_handle_t charHandle, lts_image_handle_t imageHandle) +{ + lts_post_processor_execute(ppFillPattern, charHandle, imageHandle); + lts_post_processor_execute(ppFillColor, charHandle, imageHandle); + lts_post_processor_execute(ppBorder, charHandle, imageHandle); +} + +bool exampleInit() +{ + if (lts_initialize(LIB_NAME) != ltsErrNone) + { + showMessage("unable to initialize library"); + return false; + } + + context = lts_context_create(); + if (!context) + { + showMessage("unable to create text suite context"); + return false; + } + + renderer = lts_renderer_create(context, ltsRendererOpenGL, ltsFormatRGBA8); + if (!renderer) + { + showMessage("unable to create text suite renderer"); + return false; + } + + creator = lts_font_creator_create(context, ltsFontCreatorGDI); + if (!creator) + { + showMessage("unable to create text suite creator"); + return false; + } + + lts_post_processor_custom_data_t ppData; + ppData.args = NULL; + ppData.execute = &execute_post_proc; + pp = lts_post_processor_custom_create(context, &ppData); + if (!pp) + { + showMessage("unable to create custom post processor"); + return false; + } + + lts_image_handle_t img = lts_image_create(context); + lts_image_create_empty(img, ltsFormatAlpha8, 4, 4); + void* imgData = lts_image_get_data(img); + if (img) memcpy(imgData, &PATTER_DATA[0], 16); + ppFillPattern = lts_post_processor_fill_pattern_create(context, img, true, ltsPosition(0, 0), LTS_IMAGE_MODES_MODULATE_ALL, LTS_COLOR_CHANNELS_RGBA); + lts_post_processor_add_chars(ppFillPattern, ltsUsageInclude, &CHAR_RANGE_LOREM[0]); + + ppFillColor = lts_post_processor_fill_color_create(context, ltsColor4f(0.0, 0.0, 0.5, 1.0), LTS_IMAGE_MODES_REPLACE_ALL, LTS_COLOR_CHANNELS_RGB); + lts_post_processor_add_chars(ppFillColor, ltsUsageExclude, &CHAR_RANGE_E[0]); + + ppBorder = lts_post_processor_border_create(context, 3.0, 0.5, ltsColor4f(0.0, 0.5, 0.0, 1.0), true); + lts_post_processor_add_chars(ppBorder, ltsUsageInclude, &CHAR_RANGE_E[0]); + + font = lts_font_creator_get_font_by_file(creator, "../Prototype.ttf", 40, 0, ltsAANormal); + if (!font) + { + showMessage("unable to create text suite font"); + return false; + } + if (lts_font_set_post_processor(font, pp) != ltsErrNone) + { + showMessage("unable to set post processor"); + return false; + } + + return true; +} + +bool exampleRender(int width, int height) +{ + const lts_color4f_t color = { 1.0, 1.0, 1.0, 1.0 }; + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + lts_block_flags_t flags = 0; + FLAGS_SET(flags, ltsBlockFlagWordWrap); + lts_text_block_handle_t textBlock = lts_renderer_begin_block(renderer, 10, 10, width-20, height-20, flags); + if (!textBlock) + { + showMessage(lts_get_last_error_msg()); + return false; + } + if (lts_text_block_set_horz_align(textBlock, ltsHorzAlignJustify) != ltsErrNone) + { + showMessage("unable to set horizontal alignment"); + return false; + } + if (lts_text_block_set_font(textBlock, font) != ltsErrNone) + { + showMessage("unable to set font"); + return false; + } + if (lts_text_block_set_color(textBlock, color) != ltsErrNone) + { + showMessage("unable to set font"); + return false; + } + if (lts_text_block_text_out_a(textBlock, TEST_TEXT) != ltsErrNone) + { + showMessage("unable to print text"); + return false; + } + if (lts_renderer_end_block(renderer, textBlock) != ltsErrNone) + { + showMessage("unable to finish text block"); + return false; + } + //lts_text_block_destroy(textBlock); + glDisable(GL_BLEND); + + return true; +} + +void exampleFinish() +{ + lts_font_destroy(font); + lts_post_processor_destroy(ppBorder); + lts_post_processor_destroy(ppFillColor); + lts_post_processor_destroy(ppFillPattern); + lts_post_processor_destroy(pp); + lts_font_creator_destroy(creator); + lts_renderer_destroy(creator); + lts_context_destroy(context); + lts_finalize(); +} \ No newline at end of file diff --git a/header/examples/c/example.h b/header/examples/c/example.h new file mode 100644 index 0000000..2c2e587 --- /dev/null +++ b/header/examples/c/example.h @@ -0,0 +1,10 @@ +#ifndef EXAMPLE_H +#define EXAMPLE_H + +#include + +bool exampleInit(); +bool exampleRender(int width, int height); +void exampleFinish(); + +#endif /* EXAMPLE_H */ \ No newline at end of file diff --git a/header/examples/c/helper.h b/header/examples/c/helper.h new file mode 100644 index 0000000..165aaf3 --- /dev/null +++ b/header/examples/c/helper.h @@ -0,0 +1,11 @@ +#ifndef HELPER_H +#define HELPER_H + +#include + +extern HWND hwnd; + +inline void showMessage(const char* msg) + { MessageBox(hwnd, msg, "TextSuiteExample Error", MB_OK); }; + +#endif /* HELPER_H */ \ No newline at end of file diff --git a/header/examples/c/main.c b/header/examples/c/main.c new file mode 100644 index 0000000..a645c86 --- /dev/null +++ b/header/examples/c/main.c @@ -0,0 +1,159 @@ +#include +#include +#include + +#include "example.h" + +const char g_szClassName[] = "OpenGLWindowClass"; + +HDC hdc; +HGLRC hglrc; +HWND hwnd; +int done = 0; + +int screenw, screenh; + +void SysShutdown (void) +{ + done = 1; + exampleFinish(); + wglMakeCurrent(hdc, NULL); + wglDeleteContext(hglrc); + PostQuitMessage(0); +} + +void setPixelFormat() +{ + PIXELFORMATDESCRIPTOR pfd = + { + sizeof(PIXELFORMATDESCRIPTOR), + 1, + PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER, + PFD_TYPE_RGBA, + 32, + 0,0,0,0,0,0,0,0,0,0,0,0,0, // useles parameters + 16, + 0,0,0,0,0,0,0 + }; + int indexPixelFormat = ChoosePixelFormat(hdc, &pfd); + SetPixelFormat(hdc, indexPixelFormat, &pfd); +} + +LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + switch(msg) + { + case WM_CREATE: + if ((hdc = GetDC(hwnd)) == NULL) // get device context + { + MessageBox(hwnd, "Failed to Get the Window Device Context", "Device Context Error", MB_OK); + SysShutdown(); + break; + } + setPixelFormat(); + if ((hglrc = wglCreateContext(hdc)) == NULL) + { + MessageBox(hwnd, "Failed to Create the OpenGL Rendering Context", "OpenGL Rendering Context Error", MB_OK); + SysShutdown(); + break; + } + if (!wglMakeCurrent(hdc, hglrc)) + { + MessageBox(hwnd, "Failed to make OpenGL Rendering Context current", "OpenGL Rendering Context Error", MB_OK); + SysShutdown(); + break; + } + glDisable(GL_DEPTH_TEST); + glDisable(GL_CULL_FACE); + if (!exampleInit()) + { + SysShutdown(); + break; + } + break; + + case WM_SIZE: + screenw = LOWORD(lParam); + screenh = HIWORD(lParam); + break; + + case WM_PAINT: + glClearColor(1.0, 1.0, 1.0, 1.0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glViewport(0, 0, screenw, screenh); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, screenw, screenh, 0, -10, 10); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + if (!exampleRender(screenw, screenh)) + SysShutdown(); + + SwapBuffers(hdc); + break; + + case WM_CLOSE: + SysShutdown(); + DestroyWindow(hwnd); + break; + + case WM_DESTROY: + SysShutdown(); + PostQuitMessage(0); + break; + + default: + return DefWindowProc(hwnd, msg, wParam, lParam); + } + return 0; +} + +int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) +{ + WNDCLASSEX wc; + MSG Msg; + + wc.cbSize = sizeof(WNDCLASSEX); + wc.style = 0; + wc.lpfnWndProc = WndProc; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + wc.hInstance = hInstance; + wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); + wc.hCursor = LoadCursor(NULL, IDC_ARROW); + wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); + wc.lpszMenuName = NULL; + wc.lpszClassName = g_szClassName; + wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION); + + if(!RegisterClassEx(&wc)) + { + MessageBox(NULL, "Window Registration Failed!", "Error!", + MB_ICONEXCLAMATION | MB_OK); + return 0; + } + + if ((hwnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + g_szClassName, + "TextSuiteExample", + WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, CW_USEDEFAULT, 640, 480, + NULL, NULL, hInstance, NULL)) == NULL) + { + MessageBox(NULL, "Window Creation Failed!", "Error!", MB_ICONEXCLAMATION | MB_OK); + return 0; + } + + ShowWindow(hwnd, nCmdShow); + UpdateWindow(hwnd); + + while(GetMessage(&Msg, NULL, 0, 0) > 0 && done == 0) + { + TranslateMessage(&Msg); + DispatchMessage(&Msg); + } + return Msg.wParam; +} \ No newline at end of file diff --git a/header/libTextSuite.h b/header/libTextSuite.h new file mode 100644 index 0000000..b51cbd0 --- /dev/null +++ b/header/libTextSuite.h @@ -0,0 +1,809 @@ +#ifndef LIB_TEXT_SUITE_H +#define LIB_TEXT_SUITE_H + +#include +#include +#include + +#if __MINGW32__ +# define WINAPI __stdcall +#else +# define WINAPI +#endif + +#define STATIC_ASSERT(cond, msg) typedef char static_assertion_##msg[(cond)?1:-1] + +STATIC_ASSERT(sizeof(float) == 4, size_of_float_should_be_4); +STATIC_ASSERT(sizeof(wchar_t) == 2, size_of_wchar_t_should_be_4); + +/**********************************************************************************************************************************/ +/* public interface */ +/**********************************************************************************************************************************/ + +/* enumerations *******************************************************************************************************************/ +typedef enum +{ + ltsErrUnknown = -1, + ltsErrNone = 0, + + // misc + ltsErrNotInitialized = 1, + ltsErrInvalidEnum = 2, + ltsErrInvalidValue = 3, + ltsErrInvalidOperation = 4, + ltsErrInvalidType = 5, + + // invalid handles + ltsErrInvalidContextHandle = 100, + ltsErrInvalidRendererHandle = 101, + ltsErrInvalidTextBlockHandle = 102, + ltsErrInvalidFontHandle = 103, + ltsErrInvalidFontCreatorHandle = 104, + ltsErrInvalidImageHandle = 105, + ltsErrInvalidPostProcHandle = 106, + + // library + ltsErrInvalidLibName = 200, + ltsErrInvalidLibHandle = 201, + ltsErrInvalidMethodName = 202 +} +lts_error_code_t; +STATIC_ASSERT(sizeof(lts_error_code_t) == 4, size_of_lts_error_code_t_should_be_4); + +typedef enum +{ + ltsUTF8, + ltsISO_8859_1, + ltsISO_8859_2, + ltsISO_8859_3, + ltsISO_8859_4, + ltsISO_8859_5, + ltsISO_8859_6, + ltsISO_8859_7, + ltsISO_8859_8, + ltsISO_8859_9, + ltsISO_8859_10, + ltsISO_8859_11, + ltsISO_8859_13, + ltsISO_8859_14, + ltsISO_8859_15, + ltsISO_8859_16, + ltsISO_037, + ltsISO_437, + ltsISO_500, + ltsISO_737, + ltsISO_775, + ltsISO_850, + ltsISO_852, + ltsISO_855, + ltsISO_857, + ltsISO_860, + ltsISO_861, + ltsISO_862, + ltsISO_863, + ltsISO_864, + ltsISO_865, + ltsISO_866, + ltsISO_869, + ltsISO_874, + ltsISO_875, + ltsISO_1026, + ltsISO_1250, + ltsISO_1251, + ltsISO_1252, + ltsISO_1253, + ltsISO_1254, + ltsISO_1255, + ltsISO_1256, + ltsISO_1257, + ltsISO_1258 +} +lts_code_page_t; +STATIC_ASSERT(sizeof(lts_code_page_t) == 4, size_of_lts_code_page_t_should_be_4); + +typedef enum +{ + ltsFormatEmpty, + ltsFormatRGBA8, + ltsFormatLumAlpha8, + ltsFormatAlpha8, + ltsFormatLum8 +} +lts_format_t; +STATIC_ASSERT(sizeof(lts_format_t) == 4, size_of_lts_format_t_should_be_4); + +typedef enum +{ + ltsRendererUnknown, + ltsRendererOpenGL, + ltsRendererOpenGLES +} +lts_renderer_type_t; +STATIC_ASSERT(sizeof(lts_renderer_type_t) == 4, size_of_lts_renderer_type_t_should_be_4); + +typedef enum +{ + ltsFontCreatorUnknown, + ltsFontCreatorFreeType, + ltsFontCreatorGDI, + ltsFontCreatorCustom +} +lts_font_creator_type_t; +STATIC_ASSERT(sizeof(lts_font_creator_type_t) == 4, size_of_lts_font_creator_type_t_should_be_4); + +typedef enum +{ + ltsVertAlignTop, + ltsVertAlignCenter, + ltsVertAlignBottom +} +lts_vert_align_t; +STATIC_ASSERT(sizeof(lts_vert_align_t) == 4, size_of_lts_vert_align_t_should_be_4); + +typedef enum +{ + ltsHorzAlignLeft, + ltsHorzAlignCenter, + ltsHorzAlignRight, + ltsHorzAlignJustify +} +lts_horz_align_t; +STATIC_ASSERT(sizeof(lts_horz_align_t) == 4, size_of_lts_horz_align_t_should_be_4); + +typedef enum +{ + ltsClipNone, + ltsClipWordBorder, + ltsClipCharBorder, + ltsClipWordComplete, + ltsClipCharComplete +} +lts_clipping_t; +STATIC_ASSERT(sizeof(lts_clipping_t) == 4, size_of_lts_clipping_t_should_be_4); + +typedef enum +{ + ltsAANone, + ltsAANormal +} +lts_anti_aliasing_t; +STATIC_ASSERT(sizeof(lts_anti_aliasing_t) == 4, size_of_lts_anti_aliasing_t_should_be_4); + +typedef enum +{ + ltsUsageInclude, + ltsUsageExclude +} +lts_char_range_usage_t; +STATIC_ASSERT(sizeof(lts_char_range_usage_t) == 4, size_of_lts_char_range_usage_t_should_be_4); + +typedef enum +{ + ltsStreamOriginBegin = 0, + ltsStreamOriginCurrent = 1, + ltsStreamOriginEnd = 2 +} +lts_stream_origin_t; +STATIC_ASSERT(sizeof(lts_stream_origin_t) == 4, size_of_lts_stream_origin_t_should_be_4); + +typedef enum +{ + ltsModeIgnore, + ltsModeReplace, + ltsModeModulate +} +lts_image_mode_t; +STATIC_ASSERT(sizeof(lts_image_mode_t) == 4, size_of_lts_image_mode_t_should_be_4); + +/* flags **************************************************************************************************************************/ +#define FLAGS_MAKE(enum) (1 << enum) +#define FLAGS_SET(flags, enum) flags |= FLAGS_MAKE(enum) +#define FLAGS_UNSET(flags, enum) flags &= ~FLAGS_MAKE(enum) +#define FLAGS_CLEAR(flags) flags = 0 +#define FLAGS_IS_SET(flags, enum) (flags & FLAGS_MAKE(enum)) + +typedef enum +{ + ltsBlockFlagWordWrap +} +lts_block_flag_t; +typedef uint32_t lts_block_flags_t; +STATIC_ASSERT(sizeof(lts_block_flag_t) == 4, size_of_lts_block_flag_t_should_be_4); + +typedef enum +{ + ltsFontStyleBold, + ltsFontStyleItalic, + ltsFontStyleUnderline, + ltsFontStyleStrikeout, +} +lts_font_style_flag_t; +typedef uint32_t lts_font_style_flags_t; +STATIC_ASSERT(sizeof(lts_font_style_flag_t) == 4, size_of_lts_font_style_flag_t_should_be_4); + +typedef enum +{ + ltsColorChannelRed, + ltsColorChannelGreen, + ltsColorChannelBlue, + ltsColorChannelAlpha +} +lts_color_channel_flag_t; +typedef uint32_t lts_color_channel_flags_t; +STATIC_ASSERT(sizeof(lts_color_channel_flags_t) == 4, size_of_lts_color_channel_flag_t_should_be_4); + +/* structures *********************************************************************************************************************/ +typedef struct +{ + int32_t x; + int32_t y; +} +lts_position_t; +STATIC_ASSERT(sizeof(lts_position_t) == 8, size_of_lts_position_t_should_be_8); + +typedef union +{ + struct { lts_position_t top_left, bottom_right; }; + struct { int32_t left, top, right, bottom; }; +} +lts_rect_t; +STATIC_ASSERT(sizeof(lts_rect_t) == 16, size_of_lts_rect_t_should_be_16); + +typedef union +{ + struct { float r, g, b, a; }; + float arr[4]; +} +lts_color4f_t; +STATIC_ASSERT(sizeof(lts_color4f_t) == 16, size_of_lts_color4f_t_should_be_16); + +typedef struct +{ + lts_position_t glyph_origin; + lts_rect_t glyph_rect; + int32_t advance; +} +lts_glyph_metric_t; +STATIC_ASSERT(sizeof(lts_glyph_metric_t) == 28, size_of_lts_glyph_metric_t_should_be_28); + +typedef struct +{ + int32_t ascent; + int32_t descent; + int32_t external_leading; + int32_t base_line_offset; + int32_t char_spacing; + int32_t line_height; + int32_t line_spacing; +} +lts_text_metric_t; +STATIC_ASSERT(sizeof(lts_text_metric_t) == 28, size_of_lts_text_metric_t_should_be_28); + +typedef struct +{ + int32_t size; + lts_font_style_flags_t style; + lts_anti_aliasing_t anti_aliasing; + wchar_t default_char; + uint8_t __reserved[2]; + + int32_t ascent; + int32_t descent; + int32_t external_leading; + int32_t base_line_offset; + + int32_t underline_pos; + int32_t underline_size; + int32_t strikeout_pos; + int32_t strikeout_size; +} +lts_font_metric_t; +STATIC_ASSERT(sizeof(lts_font_metric_t) == 48, size_of_lts_font_metric_t_should_be_48); + +typedef float lts_vector4f_t[4]; +STATIC_ASSERT(sizeof(lts_vector4f_t) == 16, size_of_lts_vector4f_t_should_be_16); + +typedef lts_vector4f_t lts_matrix4f_t[4]; +STATIC_ASSERT(sizeof(lts_matrix4f_t) == 64, size_of_lts_matrix4f_t_should_be_64); + +typedef void* lts_handle_t; +typedef lts_handle_t lts_context_handle_t; +typedef lts_handle_t lts_renderer_handle_t; +typedef lts_handle_t lts_text_block_handle_t; +typedef lts_handle_t lts_font_creator_handle_t; +typedef lts_handle_t lts_font_handle_t; +typedef lts_handle_t lts_post_processor_handle_t; +typedef lts_handle_t lts_image_handle_t; +typedef lts_handle_t lts_char_handle_t; +typedef lts_image_mode_t lts_image_modes_t[4]; + +/* stream */ +typedef int (WINAPI *lts_stream_func_read_t)(void* args, void* buffer, int count); +typedef int (WINAPI *lts_stream_func_seek_t)(void* args, lts_stream_origin_t origin, int offset); +typedef struct +{ + void* args; + lts_stream_func_read_t read; + lts_stream_func_seek_t seek; +} +lts_stream_t; + +/* custom post processor */ +typedef void (WINAPI *lts_post_processor_execute_func_t)(lts_char_handle_t charHandle, lts_image_handle_t imageHandle); +typedef struct +{ + void* args; + lts_post_processor_execute_func_t execute; +} +lts_post_processor_custom_data_t; + +/* custom renderer */ +typedef void (WINAPI *lts_renderer_custom_begin_render_t) (void* args); +typedef void (WINAPI *lts_renderer_custom_end_render_t) (void* args); +typedef lts_position_t (WINAPI *lts_renderer_custom_get_draw_pos_t) (void* args); +typedef void (WINAPI *lts_renderer_custom_set_draw_pos_t) (lts_position_t value, void* args); +typedef void (WINAPI *lts_renderer_custom_move_draw_pos_t) (lts_position_t value, void* args); +typedef void (WINAPI *lts_renderer_custom_set_color_t) (lts_color4f_t value, void* args); +typedef void (WINAPI *lts_renderer_custom_render) (void* ref, int forcedWidth, void* args); +typedef void* (WINAPI *lts_renderer_custom_create_ref) (lts_char_handle_t charHandle, lts_image_handle_t imageHandle, void* args); +typedef void (WINAPI *lts_renderer_custom_free_ref) (void* ref, void* args); +typedef struct +{ + void* args; + + lts_renderer_custom_begin_render_t beginRender; + lts_renderer_custom_end_render_t endRender; + lts_renderer_custom_get_draw_pos_t getDrawPos; + lts_renderer_custom_set_draw_pos_t setDrawPos; + lts_renderer_custom_move_draw_pos_t moveDrawPos; + lts_renderer_custom_set_color_t setColor; + lts_renderer_custom_render render; + + lts_renderer_custom_create_ref createRef; + lts_renderer_custom_free_ref freeRef; +} +lts_renderer_custom_data_t; + +/* image */ +typedef void (WINAPI *lts_image_load_callback_t) (lts_image_handle_t handle, int x, int y, lts_color4f_t pixel, void* args); +typedef void (WINAPI *lts_image_blend_callback_t)(lts_image_handle_t handle, lts_color4f_t src, lts_color4f_t dst, lts_color4f_t result, void* args); + +/* callbacks **********************************************************************************************************************/ +lts_context_handle_t (WINAPI *lts_context_create) (); +lts_error_code_t (WINAPI *lts_context_get_code_page) (lts_context_handle_t handle, lts_code_page_t* value); +lts_error_code_t (WINAPI *lts_context_get_default_char) (lts_context_handle_t handle, wchar_t* value); +lts_error_code_t (WINAPI *lts_context_set_code_page) (lts_context_handle_t handle, lts_code_page_t value); +lts_error_code_t (WINAPI *lts_context_set_default_char) (lts_context_handle_t handle, wchar_t value); +wchar_t* (WINAPI *lts_context_ansi_to_wide) (lts_context_handle_t handle, const char* text); +lts_error_code_t (WINAPI *lts_context_destroy) (lts_context_handle_t handle); + +lts_renderer_handle_t (WINAPI *lts_renderer_create) (lts_context_handle_t handle, lts_renderer_type_t type, lts_format_t format); +lts_renderer_handle_t (WINAPI *lts_renderer_create_custom) (lts_context_handle_t handle, lts_format_t format, const lts_renderer_custom_data_t* data); +lts_text_block_handle_t (WINAPI *lts_renderer_begin_block) (lts_renderer_handle_t handle, int top, int left, int width, int height, lts_block_flags_t flags); +lts_error_code_t (WINAPI *lts_renderer_end_block) (lts_renderer_handle_t handle, lts_text_block_handle_t block); +lts_error_code_t (WINAPI *lts_renderer_abort_block) (lts_renderer_handle_t handle, lts_text_block_handle_t block); +int (WINAPI *lts_renderer_get_text_width_a) (lts_renderer_handle_t handle, lts_font_handle_t font, const char* text); +int (WINAPI *lts_renderer_get_text_width_w) (lts_renderer_handle_t handle, lts_font_handle_t font, const wchar_t* text); +lts_error_code_t (WINAPI *lts_renderer_destroy) (lts_renderer_handle_t handle); + +lts_font_creator_handle_t (WINAPI *lts_font_creator_create) (lts_context_handle_t handle, lts_font_creator_type_t type); +lts_font_handle_t (WINAPI *lts_font_creator_get_font_by_name) (lts_font_creator_handle_t handle, const char* fontname, int size, lts_font_style_flags_t style, lts_anti_aliasing_t antialiasing); +lts_font_handle_t (WINAPI *lts_font_creator_get_font_by_file) (lts_font_creator_handle_t handle, const char* filename, int size, lts_font_style_flags_t style, lts_anti_aliasing_t antialiasing); +lts_font_handle_t (WINAPI *lts_font_creator_get_font_by_stream) (lts_font_creator_handle_t handle, lts_stream_t* stream, int size, lts_font_style_flags_t style, lts_anti_aliasing_t antialiasing); +lts_error_code_t (WINAPI *lts_font_creator_destroy) (lts_font_creator_handle_t handle); + +lts_post_processor_handle_t (WINAPI *lts_font_get_post_processor) (lts_font_handle_t handle); +lts_error_code_t (WINAPI *lts_font_get_tab_width) (lts_font_handle_t handle, int* value); +lts_error_code_t (WINAPI *lts_font_get_char_spacing) (lts_font_handle_t handle, int* value); +lts_error_code_t (WINAPI *lts_font_get_line_spacing) (lts_font_handle_t handle, float* value); +lts_error_code_t (WINAPI *lts_font_get_metric) (lts_font_handle_t handle, lts_font_metric_t* value); +const char* (WINAPI *lts_font_get_fontname) (lts_font_handle_t handle); +const char* (WINAPI *lts_font_get_facename) (lts_font_handle_t handle); +const char* (WINAPI *lts_font_get_stylename) (lts_font_handle_t handle); +const char* (WINAPI *lts_font_get_fillname) (lts_font_handle_t handle); +const char* (WINAPI *lts_font_get_copyright) (lts_font_handle_t handle); +lts_error_code_t (WINAPI *lts_font_set_post_processor) (lts_font_handle_t handle, lts_post_processor_handle_t pp); +lts_error_code_t (WINAPI *lts_font_set_tab_width) (lts_font_handle_t handle, int value); +lts_error_code_t (WINAPI *lts_font_set_char_spacing) (lts_font_handle_t handle, int value); +lts_error_code_t (WINAPI *lts_font_set_line_spacing) (lts_font_handle_t handle, float value); +lts_error_code_t (WINAPI *lts_font_destroy) (lts_font_handle_t handle); + +lts_error_code_t (WINAPI *lts_text_block_get_rect) (lts_text_block_handle_t handle, lts_rect_t* value); +lts_error_code_t (WINAPI *lts_text_block_get_width) (lts_text_block_handle_t handle, int* value); +lts_error_code_t (WINAPI *lts_text_block_get_height) (lts_text_block_handle_t handle, int* value); +lts_error_code_t (WINAPI *lts_text_block_get_flags) (lts_text_block_handle_t handle, lts_block_flags_t* value); +lts_error_code_t (WINAPI *lts_text_block_get_top) (lts_text_block_handle_t handle, int* value); +lts_error_code_t (WINAPI *lts_text_block_get_left) (lts_text_block_handle_t handle, int* value); +lts_error_code_t (WINAPI *lts_text_block_get_vert_align) (lts_text_block_handle_t handle, lts_vert_align_t* value); +lts_error_code_t (WINAPI *lts_text_block_get_horz_align) (lts_text_block_handle_t handle, lts_horz_align_t* value); +lts_error_code_t (WINAPI *lts_text_block_get_clipping) (lts_text_block_handle_t handle, lts_clipping_t* value); +lts_error_code_t (WINAPI *lts_text_block_get_color) (lts_text_block_handle_t handle, lts_color4f_t value); +lts_error_code_t (WINAPI *lts_text_block_get_font) (lts_text_block_handle_t handle, lts_font_handle_t* value); +lts_error_code_t (WINAPI *lts_text_block_set_top) (lts_text_block_handle_t handle, int value); +lts_error_code_t (WINAPI *lts_text_block_set_left) (lts_text_block_handle_t handle, int value); +lts_error_code_t (WINAPI *lts_text_block_set_vert_align) (lts_text_block_handle_t handle, lts_vert_align_t value); +lts_error_code_t (WINAPI *lts_text_block_set_horz_align) (lts_text_block_handle_t handle, lts_horz_align_t value); +lts_error_code_t (WINAPI *lts_text_block_set_clipping) (lts_text_block_handle_t handle, lts_clipping_t value); +lts_error_code_t (WINAPI *lts_text_block_set_color) (lts_text_block_handle_t handle, lts_color4f_t value); +lts_error_code_t (WINAPI *lts_text_block_set_font) (lts_text_block_handle_t handle, lts_font_handle_t value); +int (WINAPI *lts_text_block_get_actual_height) (lts_text_block_handle_t handle); +int (WINAPI *lts_text_block_get_text_width_a) (lts_text_block_handle_t handle, const char* text); +int (WINAPI *lts_text_block_get_text_width_w) (lts_text_block_handle_t handle, const wchar_t* text); +lts_error_code_t (WINAPI *lts_text_block_text_out_a) (lts_text_block_handle_t handle, const char* text); +lts_error_code_t (WINAPI *lts_text_block_text_out_w) (lts_text_block_handle_t handle, const wchar_t* text); +lts_error_code_t (WINAPI *lts_text_block_destroy) (lts_text_block_handle_t handle); + +lts_image_handle_t (WINAPI *lts_image_create) (lts_context_handle_t handle); +lts_error_code_t (WINAPI *lts_image_is_empty) (lts_image_handle_t handle, bool* value); +int (WINAPI *lts_image_get_width) (lts_image_handle_t handle); +int (WINAPI *lts_image_get_height) (lts_image_handle_t handle); +int (WINAPI *lts_image_get_line_size) (lts_image_handle_t handle); +int (WINAPI *lts_image_get_data_size) (lts_image_handle_t handle); +lts_error_code_t (WINAPI *lts_image_get_format) (lts_image_handle_t handle, lts_format_t* value); +void* (WINAPI *lts_image_get_data) (lts_image_handle_t handle); +void* (WINAPI *lts_image_get_scanline) (lts_image_handle_t handle, int index); +lts_error_code_t (WINAPI *lts_image_get_pixel_at) (lts_image_handle_t handle, int x, int y, lts_color4f_t pixel); +lts_error_code_t (WINAPI *lts_image_assign) (lts_image_handle_t handle, lts_image_handle_t source); +lts_error_code_t (WINAPI *lts_image_create_empty) (lts_image_handle_t handle, lts_format_t format, int width, int height); +lts_error_code_t (WINAPI *lts_image_load_from_func) (lts_image_handle_t handle, lts_image_load_callback_t callback, void* args); +lts_error_code_t (WINAPI *lts_image_resize) (lts_image_handle_t handle, int width, int height, int x, int y); +lts_error_code_t (WINAPI *lts_image_fill_color) (lts_image_handle_t handle, lts_color4f_t color, lts_color_channel_flags_t mask, lts_image_modes_t modes); +lts_error_code_t (WINAPI *lts_image_fill_pattern) (lts_image_handle_t handle, lts_image_handle_t pattern, int x, int y, lts_color_channel_flags_t mask, lts_image_modes_t modes); +lts_error_code_t (WINAPI *lts_image_blend) (lts_image_handle_t handle, lts_image_handle_t source, int x, int y, lts_image_blend_callback_t callback, void* args); +lts_error_code_t (WINAPI *lts_image_blur) (lts_image_handle_t handle, float horzRad, float horzStr, float vertRad, float vertStr, lts_color_channel_flags_t mask); +lts_error_code_t (WINAPI *lts_image_destroy) (lts_image_handle_t handle); + +lts_error_code_t (WINAPI *lts_post_processor_add_range) (lts_post_processor_handle_t handle, lts_char_range_usage_t usage, wchar_t start, wchar_t stop); +lts_error_code_t (WINAPI *lts_post_processor_add_chars) (lts_post_processor_handle_t handle, lts_char_range_usage_t usage, const wchar_t* chars); +lts_error_code_t (WINAPI *lts_post_processor_clear_ranges) (lts_post_processor_handle_t handle); +lts_error_code_t (WINAPI *lts_post_processor_execute) (lts_post_processor_handle_t handle, lts_char_handle_t charHandle, lts_image_handle_t image); +lts_post_processor_handle_t (WINAPI *lts_post_processor_fill_color_create) (lts_post_processor_handle_t handle, lts_color4f_t color, lts_image_modes_t modes, lts_color_channel_flags_t channels); +lts_post_processor_handle_t (WINAPI *lts_post_processor_fill_pattern_create) (lts_post_processor_handle_t handle, lts_image_handle_t pattern, bool ownsPattern, lts_position_t position, lts_image_modes_t modes, lts_color_channel_flags_t channels); +lts_post_processor_handle_t (WINAPI *lts_post_processor_border_create) (lts_post_processor_handle_t handle, float width, float strength, lts_color4f_t color, bool keepSize); +lts_post_processor_handle_t (WINAPI *lts_post_processor_shadow_create) (lts_post_processor_handle_t handle, float radius, float strength, lts_position_t offset, lts_color4f_t color); +lts_post_processor_handle_t (WINAPI *lts_post_processor_custom_create) (lts_post_processor_handle_t handle, const lts_post_processor_custom_data_t* data); +lts_error_code_t (WINAPI *lts_post_processor_destroy) (lts_post_processor_handle_t handle); + +lts_error_code_t (WINAPI *lts_char_get_char_code) (lts_char_handle_t handle, wchar_t* value); +lts_error_code_t (WINAPI *lts_char_get_glyph_metric) (lts_char_handle_t handle, lts_glyph_metric_t* value); +lts_error_code_t (WINAPI *lts_char_set_glyph_metric) (lts_char_handle_t handle, lts_glyph_metric_t value); + +lts_error_code_t (WINAPI *lts_get_last_error_code) (); +const char* (WINAPI *lts_get_last_error_msg) (); + +/* constants **********************************************************************************************************************/ + lts_image_modes_t LTS_IMAGE_MODES_REPLACE_ALL = { + ltsModeReplace, + ltsModeReplace, + ltsModeReplace, + ltsModeReplace + }; + lts_image_modes_t LTS_IMAGE_MODES_MODULATE_ALPHA = { + ltsModeReplace, + ltsModeReplace, + ltsModeReplace, + ltsModeModulate + }; + lts_image_modes_t LTS_IMAGE_MODES_MODULATE_ALL = { + ltsModeModulate, + ltsModeModulate, + ltsModeModulate, + ltsModeModulate + }; + + lts_color_channel_flags_t LTS_COLOR_CHANNELS_RGB = + FLAGS_MAKE(ltsColorChannelRed) | + FLAGS_MAKE(ltsColorChannelGreen) | + FLAGS_MAKE(ltsColorChannelBlue); + lts_color_channel_flags_t LTS_COLOR_CHANNELS_RGBA = + FLAGS_MAKE(ltsColorChannelRed) | + FLAGS_MAKE(ltsColorChannelGreen) | + FLAGS_MAKE(ltsColorChannelBlue) | + FLAGS_MAKE(ltsColorChannelAlpha); + +/* helper *************************************************************************************************************************/ +inline lts_color4f_t ltsColor4f(float r, float g, float b, float a) + { lts_color4f_t ret = { r, g, b, a }; return ret; }; + +inline lts_position_t ltsPosition(int x, int y) + { lts_position_t ret = { x, y }; return ret; }; + +inline lts_rect_t ltsRect(int left, int top, int right, int bottom) + { lts_rect_t ret = { left, top, right, bottom }; return ret; }; + +inline lts_rect_t ltsRectFromPos(lts_position_t leftTop, lts_position_t bottomRight) + { lts_rect_t ret = { leftTop.x, leftTop.y, bottomRight.x, bottomRight.y }; return ret; }; + +/**********************************************************************************************************************************/ +/* internal initialization code */ +/**********************************************************************************************************************************/ +//#define LSF_DEBUG +#ifdef LSF_DEBUG +# include +#endif + +#if WIN32 || WIN64 || _WIN32 || _WIN64 +# include + +typedef HMODULE lib_handle_t; + +lib_handle_t open_lib(const char* name) + { return LoadLibrary(name); }; + +void* get_addr(lib_handle_t handle, const char* name) + { return GetProcAddress(handle, name); }; + +int close_lib(lib_handle_t handle) + { return FreeLibrary(handle); }; + +#elif LINUX || __linux__ +# include + +typedef void* lib_handle_t; + +lib_handle_t open_lib(const char* name) + { return dlopen(name, RTLD_LAZY); }; + +void* get_addr(lib_handle_t handle, const char* name) + { return dlsym(handle, name); }; + +int close_lib(lib_handle_t handle) + { return !dlclose(handle); }; + +#else +# error "unknown operation system" +#endif + +#ifndef LSF_DEBUG +# define LoadProc(proc, name) \ + proc = get_addr(handle, name); \ + if (!proc) \ + return ltsErrInvalidMethodName +#else +# define LoadProc(proc, name) \ + proc = get_addr(handle, name); \ + printf("load method '%s' (addr=0x%016x)\n", name, proc); \ + if (!proc) \ + return ltsErrInvalidMethodName +#endif + +lts_error_code_t (WINAPI *lts_initialize_intern)(); +lts_error_code_t (WINAPI *lts_finalize_intern) (); + +lib_handle_t handle = NULL; + +lts_error_code_t lts_initialize(const char* libname) +{ +#ifdef LSF_DEBUG + printf("loading library '%s'\n", libname); +#endif + + handle = open_lib(libname); + if (!handle) + return ltsErrInvalidLibName; + +#ifdef LSF_DEBUG + printf(" done (handle=0x%016x)\n", handle); +#endif + + LoadProc(lts_context_create, "ltsContextCreate"); + LoadProc(lts_context_get_code_page, "ltsContextGetCodePage"); + LoadProc(lts_context_get_default_char, "ltsContextGetDefaultChar"); + LoadProc(lts_context_set_code_page, "ltsContextSetCodePage"); + LoadProc(lts_context_set_default_char, "ltsContextSetDefaultChar"); + LoadProc(lts_context_ansi_to_wide, "ltsContextAnsiToWide"); + LoadProc(lts_context_destroy, "ltsContextDestroy"); + + LoadProc(lts_renderer_create, "ltsRendererCreate"); + LoadProc(lts_renderer_create_custom, "ltsRendererCustomCreate"); + LoadProc(lts_renderer_begin_block, "ltsRendererBeginBlock"); + LoadProc(lts_renderer_end_block, "ltsRendererEndBlock"); + LoadProc(lts_renderer_abort_block, "ltsRendererAbortBlock"); + LoadProc(lts_renderer_get_text_width_a, "ltsRendererGetTextWidthA"); + LoadProc(lts_renderer_get_text_width_w, "ltsRendererGetTextWidthW"); + LoadProc(lts_renderer_destroy, "ltsRendererDestroy"); + + LoadProc(lts_font_creator_create, "ltsFontCreatorCreate"); + LoadProc(lts_font_creator_get_font_by_name, "ltsFontCreatorGetFontByName"); + LoadProc(lts_font_creator_get_font_by_file, "ltsFontCreatorGetFontByFile"); + LoadProc(lts_font_creator_get_font_by_stream, "ltsFontCreatorGetFontByStream"); + LoadProc(lts_font_creator_destroy, "ltsFontCreatorDestroy"); + + LoadProc(lts_font_get_post_processor, "ltsFontGetPostProcessor"); + LoadProc(lts_font_get_tab_width, "ltsFontGetTabWidth"); + LoadProc(lts_font_get_char_spacing, "ltsFontGetCharSpacing"); + LoadProc(lts_font_get_line_spacing, "ltsFontGetLineSpacing"); + LoadProc(lts_font_get_metric, "ltsFontGetMetric"); + LoadProc(lts_font_get_fontname, "ltsFontGetFontname"); + LoadProc(lts_font_get_facename, "ltsFontGetFacename"); + LoadProc(lts_font_get_stylename, "ltsFontGetStylename"); + LoadProc(lts_font_get_fillname, "ltsFontGetFullname"); + LoadProc(lts_font_get_copyright, "ltsFontGetCopyright"); + LoadProc(lts_font_set_post_processor, "ltsFontSetPostProcessor"); + LoadProc(lts_font_set_tab_width, "ltsFontSetTabWidth"); + LoadProc(lts_font_set_char_spacing, "ltsFontSetCharSpacing"); + LoadProc(lts_font_set_line_spacing, "ltsFontSetLineSpacing"); + LoadProc(lts_font_destroy, "ltsFontDestroy"); + + LoadProc(lts_text_block_get_rect, "ltsTextBlockGetRect"); + LoadProc(lts_text_block_get_width, "ltsTextBlockGetWidth"); + LoadProc(lts_text_block_get_height, "ltsTextBlockGetHeight"); + LoadProc(lts_text_block_get_flags, "ltsTextBlockGetFlags"); + LoadProc(lts_text_block_get_top, "ltsTextBlockGetTop"); + LoadProc(lts_text_block_get_left, "ltsTextBlockGetLeft"); + LoadProc(lts_text_block_get_vert_align, "ltsTextBlockGetVertAlign"); + LoadProc(lts_text_block_get_horz_align, "ltsTextBlockGetHorzAlign"); + LoadProc(lts_text_block_get_clipping, "ltsTextBlockGetClipping"); + LoadProc(lts_text_block_get_color, "ltsTextBlockGetColor"); + LoadProc(lts_text_block_get_font, "ltsTextBlockGetFont"); + LoadProc(lts_text_block_set_top, "ltsTextBlockSetTop"); + LoadProc(lts_text_block_set_left, "ltsTextBlockSetLeft"); + LoadProc(lts_text_block_set_vert_align, "ltsTextBlockSetVertAlign"); + LoadProc(lts_text_block_set_horz_align, "ltsTextBlockSetHorzAlign"); + LoadProc(lts_text_block_set_clipping, "ltsTextBlockSetClipping"); + LoadProc(lts_text_block_set_color, "ltsTextBlockSetColor"); + LoadProc(lts_text_block_set_font, "ltsTextBlockSetFont"); + LoadProc(lts_text_block_get_actual_height, "ltsTextBlockGetActualHeight"); + LoadProc(lts_text_block_get_text_width_a, "ltsTextBlockGetTextWidthA"); + LoadProc(lts_text_block_get_text_width_w, "ltsTextBlockGetTextWidthW"); + LoadProc(lts_text_block_text_out_a, "ltsTextBlockTextOutA"); + LoadProc(lts_text_block_text_out_w, "ltsTextBlockTextOutW"); + LoadProc(lts_text_block_destroy, "ltsTextBlockDestroy"); + + LoadProc(lts_image_create, "ltsImageCreate"); + LoadProc(lts_image_is_empty, "ltsImageIsEmpty"); + LoadProc(lts_image_get_width, "ltsImageGetWidth"); + LoadProc(lts_image_get_height, "ltsImageGetHeight"); + LoadProc(lts_image_get_line_size, "ltsImageGetLineSize"); + LoadProc(lts_image_get_data_size, "ltsImageGetDataSize"); + LoadProc(lts_image_get_format, "ltsImageGetFormat"); + LoadProc(lts_image_get_data, "ltsImageGetData"); + LoadProc(lts_image_get_scanline, "ltsImageGetScanline"); + LoadProc(lts_image_get_pixel_at, "ltsImageGetPixelAt"); + LoadProc(lts_image_assign, "ltsImageAssign"); + LoadProc(lts_image_create_empty, "ltsImageCreateEmpty"); + LoadProc(lts_image_load_from_func, "ltsImageLoadFromFunc"); + LoadProc(lts_image_resize, "ltsImageResize"); + LoadProc(lts_image_fill_color, "ltsImageFillColor"); + LoadProc(lts_image_fill_pattern, "ltsImageFillPattern"); + LoadProc(lts_image_blend, "ltsImageBlend"); + LoadProc(lts_image_blur, "ltsImageBlur"); + LoadProc(lts_image_destroy, "ltsImageDestroy"); + + LoadProc(lts_post_processor_add_range, "ltsPostProcessorAddRange"); + LoadProc(lts_post_processor_add_chars, "ltsPostProcessorAddChars"); + LoadProc(lts_post_processor_clear_ranges, "ltsPostProcessorClearRanges"); + LoadProc(lts_post_processor_execute, "ltsPostProcessorExecute"); + LoadProc(lts_post_processor_fill_color_create, "ltsPostProcessorFillColorCreate"); + LoadProc(lts_post_processor_fill_pattern_create, "ltsPostProcessorFillPatterCreate"); + LoadProc(lts_post_processor_border_create, "ltsPostProcessorBorderCreate"); + LoadProc(lts_post_processor_shadow_create, "ltsPostProcessorShadowCreate"); + LoadProc(lts_post_processor_custom_create, "ltsPostProcessorCustomCreate"); + LoadProc(lts_post_processor_destroy, "ltsPostProcessorDestroy"); + + LoadProc(lts_char_get_char_code, "ltsCharGetCharCode"); + LoadProc(lts_char_get_glyph_metric, "ltsCharGetGlyphMetric"); + LoadProc(lts_char_set_glyph_metric, "ltsCharSetGlyphMetric"); + + LoadProc(lts_initialize_intern, "ltsInitialize"); + LoadProc(lts_get_last_error_code, "ltsGetLastErrorCode"); + LoadProc(lts_get_last_error_msg, "ltsGetLastErrorMsg"); + LoadProc(lts_finalize_intern, "ltsFinalize"); + + return lts_initialize_intern(); +} + +int lts_finalize(void) +{ + lts_error_code_t err = lts_finalize_intern(); + + lts_context_create = NULL; + lts_context_get_code_page = NULL; + lts_context_get_default_char = NULL; + lts_context_set_code_page = NULL; + lts_context_set_default_char = NULL; + lts_context_ansi_to_wide = NULL; + lts_context_destroy = NULL; + + lts_renderer_create = NULL; + lts_renderer_create_custom = NULL; + lts_renderer_begin_block = NULL; + lts_renderer_end_block = NULL; + lts_renderer_abort_block = NULL; + lts_renderer_get_text_width_a = NULL; + lts_renderer_get_text_width_w = NULL; + lts_renderer_destroy = NULL; + + lts_font_creator_create = NULL; + lts_font_creator_get_font_by_name = NULL; + lts_font_creator_get_font_by_file = NULL; + lts_font_creator_get_font_by_stream = NULL; + lts_font_creator_destroy = NULL; + + lts_font_get_post_processor = NULL; + lts_font_get_tab_width = NULL; + lts_font_get_char_spacing = NULL; + lts_font_get_line_spacing = NULL; + lts_font_get_metric = NULL; + lts_font_get_fontname = NULL; + lts_font_get_facename = NULL; + lts_font_get_stylename = NULL; + lts_font_get_fillname = NULL; + lts_font_get_copyright = NULL; + lts_font_set_post_processor = NULL; + lts_font_set_tab_width = NULL; + lts_font_set_char_spacing = NULL; + lts_font_set_line_spacing = NULL; + lts_font_destroy = NULL; + + lts_text_block_get_rect = NULL; + lts_text_block_get_width = NULL; + lts_text_block_get_height = NULL; + lts_text_block_get_flags = NULL; + lts_text_block_get_top = NULL; + lts_text_block_get_left = NULL; + lts_text_block_get_vert_align = NULL; + lts_text_block_get_horz_align = NULL; + lts_text_block_get_clipping = NULL; + lts_text_block_get_color = NULL; + lts_text_block_get_font = NULL; + lts_text_block_set_top = NULL; + lts_text_block_set_left = NULL; + lts_text_block_set_vert_align = NULL; + lts_text_block_set_horz_align = NULL; + lts_text_block_set_clipping = NULL; + lts_text_block_set_color = NULL; + lts_text_block_set_font = NULL; + lts_text_block_get_actual_height = NULL; + lts_text_block_get_text_width_a = NULL; + lts_text_block_get_text_width_w = NULL; + lts_text_block_text_out_a = NULL; + lts_text_block_text_out_w = NULL; + lts_text_block_destroy = NULL; + + lts_image_create = NULL; + lts_image_is_empty = NULL; + lts_image_get_width = NULL; + lts_image_get_height = NULL; + lts_image_get_line_size = NULL; + lts_image_get_data_size = NULL; + lts_image_get_format = NULL; + lts_image_get_data = NULL; + lts_image_get_scanline = NULL; + lts_image_get_pixel_at = NULL; + lts_image_assign = NULL; + lts_image_create_empty = NULL; + lts_image_load_from_func = NULL; + lts_image_resize = NULL; + lts_image_fill_color = NULL; + lts_image_fill_pattern = NULL; + lts_image_blend = NULL; + lts_image_blur = NULL; + lts_image_destroy = NULL; + + lts_post_processor_add_range = NULL; + lts_post_processor_add_chars = NULL; + lts_post_processor_clear_ranges = NULL; + lts_post_processor_execute = NULL; + lts_post_processor_fill_color_create = NULL; + lts_post_processor_fill_pattern_create = NULL; + lts_post_processor_border_create = NULL; + lts_post_processor_shadow_create = NULL; + lts_post_processor_custom_create = NULL; + lts_post_processor_destroy = NULL; + + lts_char_get_char_code = NULL; + lts_char_get_glyph_metric = NULL; + lts_char_set_glyph_metric = NULL; + + lts_initialize_intern = NULL; + lts_get_last_error_code = NULL; + lts_get_last_error_msg = NULL; + lts_finalize_intern = NULL; + + if (!close_lib(handle)) + return ltsErrInvalidLibHandle; + return err; +} + +#endif /* LIB_TEXT_SUITE_H */ \ No newline at end of file diff --git a/header/ulibTextSuite.pas b/header/ulibTextSuite.pas index 9cf8c05..7fa59fe 100644 --- a/header/ulibTextSuite.pas +++ b/header/ulibTextSuite.pas @@ -228,6 +228,7 @@ type Style: TltsFontStyles; AntiAliasing: TltsAntiAliasing; DefaultChar: WideChar; + __reserved: SmallInt; Ascent: Integer; Descent: Integer; @@ -329,218 +330,218 @@ type end; TltsImage = class; - TltsImageLoadFunc = procedure(const aImage: TltsImage; X, Y: Integer; var aPixel: TltsColor4f; aArgs: Pointer); - TltsImageBlendFunc = function (const aSrc, aDst: TltsColor4f; aArgs: Pointer): TltsColor4f; - - TltsImageLoadInternFunc = procedure(const aHandle: TltsImageHandle; const X, Y: Integer; var aPixel: TltsColor4f; aArgs: Pointer); stdcall; - TltsImageBlendInternFunc = function (const aHandle: TltsImageHandle; const aSrc, aDst: TltsColor4f; aArgs: Pointer): TltsColor4f; stdcall; - - TltsContextCreate = function(): TltsContextHandle; stdcall; - TltsContextGetCodePage = function(const aHandle: TltsContextHandle; out aCodePage: TltsCodePage): TltsErrorCode; stdcall; - TltsContextGetDefaultChar = function(const aHandle: TltsContextHandle; out aValue: WideChar): TltsErrorCode; stdcall; - TltsContextSetCodePage = function(const aHandle: TltsContextHandle; const aCodePage: TltsCodePage): TltsErrorCode; stdcall; - TltsContextSetDefaultChar = function(const aHandle: TltsContextHandle; const aValue: WideChar): TltsErrorCode; stdcall; - TltsContextAnsiToWide = function(const aHandle: TltsContextHandle; const aText: PAnsiChar): PWideChar; stdcall; - TltsContextDestroy = function(const aHandle: TltsContextHandle): TltsErrorCode; stdcall; - - TltsRendererCreate = function(const aHandle: TltsContextHandle; const aType: TltsRendererType; const aFormat: TltsFormat): TltsRendererHandle; stdcall; - TltsRendererCustomCreate = function(const aHandle: TltsContextHandle; const aFormat: TltsFormat; const aData: PltsRendererCustomData): TltsRendererHandle; stdcall; - TltsRendererBeginBlock = function(const aHandle: TltsRendererHandle; const aTop, aLeft, aWidth, aHeight: Integer; const aFlags: TltsBlockFlags): TltsTextBlockHandle; stdcall; - TltsRendererEndBlock = function(const aHandle: TltsRendererHandle; const aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; - TltsRendererAbortBlock = function(const aHandle: TltsRendererHandle; const aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; - TltsRendererGetTextWidthA = function(const aHandle: TltsRendererHandle; const aFont: TltsFontHandle; const aText: PAnsiChar): Integer; stdcall; - TltsRendererGetTextWidthW = function(const aHandle: TltsRendererHandle; const aFont: TltsFontHandle; const aText: PWideChar): Integer; stdcall; - TltsRendererDestroy = function(const aHandle: TltsRendererHandle): TltsErrorCode; stdcall; - - TltsFontCreatorCreate = function(const aHandle: TltsContextHandle; const aType: TltsFontCreatorType): TltsFontCreatorHandle; stdcall; - TltsFontCreatorGetFontByName = function(const aHandle: TltsFontCreatorHandle; const aFontname: PAnsiChar; const aSize: Integer; const aStyle: TltsFontStyles; const aAntiAliasing: TltsAntiAliasing): TltsFontHandle; stdcall; - TltsFontCreatorGetFontByFile = function(const aHandle: TltsFontCreatorHandle; const aFilename: PAnsiChar; const aSize: Integer; const aStyle: TltsFontStyles; const aAntiAliasing: TltsAntiAliasing): TltsFontHandle; stdcall; - TltsFontCreatorGetFontByStream = function(const aHandle: TltsFontCreatorHandle; const aStream: PltsStream; const aSize: Integer; const aStyle: TltsFontStyles; const aAntiAliasing: TltsAntiAliasing): TltsFontHandle; stdcall; - TltsFontCreatorDestroy = function(const aHandle: TltsFontCreatorHandle): TltsErrorCode; stdcall; - - TltsFontGetPostProcessor = function(const aHandle: TltsFontHandle): TltsPostProcessorHandle; stdcall; - TltsFontGetTabWidth = function(const aHandle: TltsFontHandle; out aValue: Integer): TltsErrorCode; stdcall; - TltsFontGetCharSpacing = function(const aHandle: TltsFontHandle; out aValue: Integer): TltsErrorCode; stdcall; - TltsFontGetLineSpacing = function(const aHandle: TltsFontHandle; out aValue: Single): TltsErrorCode; stdcall; - TltsFontGetMetric = function(const aHandle: TltsFontHandle; out aValue: TltsFontMetric): TltsErrorCode; stdcall; - TltsFontGetFontname = function(const aHandle: TltsFontHandle): PAnsiChar; stdcall; - TltsFontGetFacename = function(const aHandle: TltsFontHandle): PAnsiChar; stdcall; - TltsFontGetStylename = function(const aHandle: TltsFontHandle): PAnsiChar; stdcall; - TltsFontGetFullname = function(const aHandle: TltsFontHandle): PAnsiChar; stdcall; - TltsFontGetCopyright = function(const aHandle: TltsFontHandle): PAnsiChar; stdcall; - TltsFontSetPostProcessor = function(const aHandle: TltsFontHandle; const aValue: TltsPostProcessorHandle): TltsErrorCode; stdcall; - TltsFontSetTabWidth = function(const aHandle: TltsFontHandle; const aValue: Integer): TltsErrorCode; stdcall; - TltsFontSetCharSpacing = function(const aHandle: TltsFontHandle; const aValue: Integer): TltsErrorCode; stdcall; - TltsFontSetLineSpacing = function(const aHandle: TltsFontHandle; const aValue: Single): TltsErrorCode; stdcall; - TltsFontDestroy = function(const aHandle: TltsFontHandle): TltsErrorCode; stdcall; - - TltsTextBlockGetRect = function(const aHandle: TltsTextBlockHandle; out aValue: TltsRect): TltsErrorCode; stdcall; - TltsTextBlockGetWidth = function(const aHandle: TltsTextBlockHandle; out aValue: Integer): TltsErrorCode; stdcall; - TltsTextBlockGetHeight = function(const aHandle: TltsTextBlockHandle; out aValue: Integer): TltsErrorCode; stdcall; - TltsTextBlockGetFlags = function(const aHandle: TltsTextBlockHandle; out aValue: TltsBlockFlags): TltsErrorCode; stdcall; - TltsTextBlockGetTop = function(const aHandle: TltsTextBlockHandle; out aValue: Integer): TltsErrorCode; stdcall; - TltsTextBlockGetLeft = function(const aHandle: TltsTextBlockHandle; out aValue: Integer): TltsErrorCode; stdcall; - TltsTextBlockGetVertAlign = function(const aHandle: TltsTextBlockHandle; out aValue: TltsVertAlignment): TltsErrorCode; stdcall; - TltsTextBlockGetHorzAlign = function(const aHandle: TltsTextBlockHandle; out aValue: TltsHorzAlignment): TltsErrorCode; stdcall; - TltsTextBlockGetClipping = function(const aHandle: TltsTextBlockHandle; out aValue: TltsClipping): TltsErrorCode; stdcall; - TltsTextBlockGetColor = function(const aHandle: TltsTextBlockHandle; out aValue: TltsColor4f): TltsErrorCode; stdcall; - TltsTextBlockGetFont = function(const aHandle: TltsTextBlockHandle; out aValue: TltsFontHandle): TltsErrorCode; stdcall; - TltsTextBlockSetTop = function(const aHandle: TltsTextBlockHandle; const aValue: Integer): TltsErrorCode; stdcall; - TltsTextBlockSetLeft = function(const aHandle: TltsTextBlockHandle; const aValue: Integer): TltsErrorCode; stdcall; - TltsTextBlockSetVertAlign = function(const aHandle: TltsTextBlockHandle; const aValue: TltsVertAlignment): TltsErrorCode; stdcall; - TltsTextBlockSetHorzAlign = function(const aHandle: TltsTextBlockHandle; const aValue: TltsHorzAlignment): TltsErrorCode; stdcall; - TltsTextBlockSetClipping = function(const aHandle: TltsTextBlockHandle; const aValue: TltsClipping): TltsErrorCode; stdcall; - TltsTextBlockSetColor = function(const aHandle: TltsTextBlockHandle; const aValue: TltsColor4f): TltsErrorCode; stdcall; - TltsTextBlockSetFont = function(const aHandle: TltsTextBlockHandle; const aValue: TltsFontHandle): TltsErrorCode; stdcall; - TltsTextBlockGetActualHeight = function(const aHandle: TltsTextBlockHandle): Integer; stdcall; - TltsTextBlockGetTextWidthA = function(const aHandle: TltsTextBlockHandle; const aText: PAnsiChar): Integer; stdcall; - TltsTextBlockGetTextWidthW = function(const aHandle: TltsTextBlockHandle; const aText: PWideChar): Integer; stdcall; - TltsTextBlockTextOutA = function(const aHandle: TltsTextBlockHandle; const aText: PAnsiChar): TltsErrorCode; stdcall; - TltsTextBlockTextOutW = function(const aHandle: TltsTextBlockHandle; const aText: PWideChar): TltsErrorCode; stdcall; - TltsTextBlockDestroy = function(const aHandle: TltsTextBlockHandle): TltsErrorCode; stdcall; - - TltsImageCreate = function(const aContext: TltsContextHandle): TltsImageHandle; stdcall; - TltsImageIsEmpty = function(const aHandle: TltsImageHandle; out aValue: Boolean): TltsErrorCode; stdcall; - TltsImageGetWidth = function(const aHandle: TltsImageHandle): Integer; stdcall; - TltsImageGetHeight = function(const aHandle: TltsImageHandle): Integer; stdcall; - TltsImageGetLineSize = function(const aHandle: TltsImageHandle): Integer; stdcall; - TltsImageGetDataSize = function(const aHandle: TltsImageHandle): Integer; stdcall; - TltsImageGetFormat = function(const aHandle: TltsImageHandle; out aValue: TltsFormat): TltsErrorCode; stdcall; - TltsImageGetData = function(const aHandle: TltsImageHandle): Pointer; stdcall; - TltsImageGetScanline = function(const aHandle: TltsImageHandle; const aIndex: Integer): Pointer; stdcall; - TltsImageGetPixelAt = function(const aHandle: TltsImageHandle; const aX, aY: Integer; out aColor: TltsColor4f): TltsErrorCode; stdcall; - TltsImageAssign = function(const aHandle, aSource: TltsImageHandle): TltsErrorCode; stdcall; - TltsImageCreateEmpty = function(const aHandle: TltsImageHandle; const aFormat: TltsFormat; const aWidth, aHeight: Integer): TltsErrorCode; stdcall; - TltsImageLoadFromFunc = function(const aHandle: TltsImageHandle; const aCallback: TltsImageLoadInternFunc; aArgs: Pointer): TltsErrorCode; stdcall; - TltsImageResize = function(const aHandle: TltsImageHandle; const aWidth, aHeight, aX, aY: Integer): TltsErrorCode; stdcall; - TltsImageFillColor = function(const aHandle: TltsImageHandle; const aColor: TltsColor4f; const aMask: TltsColorChannels; const aModes: TltsImageModes): TltsErrorCode; stdcall; - TltsImageFillPattern = function(const aHandle, aPattern: TltsImageHandle; const aX, aY: Integer; const aMask: TltsColorChannels; const aModes: TltsImageModes): TltsErrorCode; stdcall; - TltsImageBlend = function(const aHandle, aSource: TltsImageHandle; const aX, aY: Integer; const aBlendFunc: TltsImageBlendInternFunc; aArgs: Pointer): TltsErrorCode; stdcall; - TltsImageBlur = function(const aHandle: TltsImageHandle; const aHorzRad, aHorzStr, aVertRad, aVertStr: Single; const aMask: TltsColorChannels): TltsErrorCode; stdcall; - TltsImageDestroy = function(const aHandle: TltsImageHandle): TltsErrorCode; stdcall; - - TltsPostProcessorAddRange = function(const aHandle: TltsPostProcessorHandle; const aUsage: TltsCharRangeUsage; const aStart, aStop: WideChar): TltsErrorCode; stdcall; - TltsPostProcessorAddChars = function(const aHandle: TltsPostProcessorHandle; const aUsage: TltsCharRangeUsage; const aChars: PWideChar): TltsErrorCode; stdcall; - TltsPostProcessorClearRanges = function(const aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; - TltsPostProcessorExecute = function (const aHandle: TltsPostProcessorHandle; const aChar: TltsCharHandle; const aImage: TltsImageHandle): TltsErrorCode; stdcall; - TltsPostProcessorFillColorCreate = function(const aContext: TltsContextHandle; const aColor: TltsColor4f; const aModes: TltsImageModes; const aChannels: TltsColorChannels): TltsPostProcessorHandle; stdcall; - TltsPostProcessorFillPatterCreate = function(const aContext: TltsContextHandle; const aPattern: TltsImageHandle; const aOwnsPatter: Boolean; const aPosition: TltsPosition; const aModes: TltsImageModes; const aChannels: TltsColorChannels): TltsPostProcessorHandle; stdcall; - TltsPostProcessorBorderCreate = function(const aContext: TltsContextHandle; const aWidth, aStrength: Single; const aColor: TltsColor4f; const aKeepSize: Boolean): TltsPostProcessorHandle; stdcall; - TltsPostProcessorShadowCreate = function(const aContext: TltsContextHandle; const aRadius, aStrength: Single; const aOffset: TltsPosition; const aColor: TltsColor4f): TltsPostProcessorHandle; stdcall; - TltsPostProcessorCustomCreate = function(const aContext: TltsContextHandle; const aData: PltsPostProcessorCustomData): TltsPostProcessorHandle; stdcall; - TltsPostProcessorDestroy = function(const aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; - - TltsCharGetCharCode = function(const aHandle: TltsCharHandle; out aValue: WideChar): TltsErrorCode; stdcall; - TltsCharGetGlyphMetric = function(const aHandle: TltsCharHandle; out aValue: TltsGlyphMetric): TltsErrorCode; stdcall; - TltsCharSetGlyphMetric = function(const aHandle: TltsCharHandle; const aValue: TltsGlyphMetric): TltsErrorCode; stdcall; - - TltsInitialize = function(): TltsErrorCode; stdcall; - TltsGetLastErrorCode = function(): TltsErrorCode; stdcall; - TltsGetLastErrorMsg = function(): PAnsiChar; stdcall; - TltsFinalize = function(): TltsErrorCode; stdcall; - -var - ltsContextCreate: TltsContextCreate; - ltsContextGetCodePage: TltsContextGetCodePage; - ltsContextGetDefaultChar: TltsContextGetDefaultChar; - ltsContextSetCodePage: TltsContextSetCodePage; - ltsContextSetDefaultChar: TltsContextSetDefaultChar; - ltsContextAnsiToWide: TltsContextAnsiToWide; - ltsContextDestroy: TltsContextDestroy; - - ltsRendererCreate: TltsRendererCreate; - ltsRendererCustomCreate: TltsRendererCustomCreate; - ltsRendererBeginBlock: TltsRendererBeginBlock; - ltsRendererEndBlock: TltsRendererEndBlock; - ltsRendererAbortBlock: TltsRendererAbortBlock; - ltsRendererGetTextWidthA: TltsRendererGetTextWidthA; - ltsRendererGetTextWidthW: TltsRendererGetTextWidthW; - ltsRendererDestroy: TltsRendererDestroy; - - ltsFontCreatorCreate: TltsFontCreatorCreate; - ltsFontCreatorGetFontByName: TltsFontCreatorGetFontByName; - ltsFontCreatorGetFontByFile: TltsFontCreatorGetFontByFile; - ltsFontCreatorGetFontByStream: TltsFontCreatorGetFontByStream; - ltsFontCreatorDestroy: TltsFontCreatorDestroy; - - ltsFontGetPostProcessor: TltsFontGetPostProcessor; - ltsFontGetTabWidth: TltsFontGetTabWidth; - ltsFontGetCharSpacing: TltsFontGetCharSpacing; - ltsFontGetLineSpacing: TltsFontGetLineSpacing; - ltsFontGetMetric: TltsFontGetMetric; - ltsFontGetFontname: TltsFontGetFontname; - ltsFontGetFacename: TltsFontGetFacename; - ltsFontGetStylename: TltsFontGetStylename; - ltsFontGetFullname: TltsFontGetFullname; - ltsFontGetCopyright: TltsFontGetCopyright; - ltsFontSetPostProcessor: TltsFontSetPostProcessor; - ltsFontSetTabWidth: TltsFontSetTabWidth; - ltsFontSetCharSpacing: TltsFontSetCharSpacing; - ltsFontSetLineSpacing: TltsFontSetLineSpacing; - ltsFontDestroy: TltsFontDestroy; - - ltsTextBlockGetRect: TltsTextBlockGetRect; - ltsTextBlockGetWidth: TltsTextBlockGetWidth; - ltsTextBlockGetHeight: TltsTextBlockGetHeight; - ltsTextBlockGetFlags: TltsTextBlockGetFlags; - ltsTextBlockGetTop: TltsTextBlockGetTop; - ltsTextBlockGetLeft: TltsTextBlockGetLeft; - ltsTextBlockGetVertAlign: TltsTextBlockGetVertAlign; - ltsTextBlockGetHorzAlign: TltsTextBlockGetHorzAlign; - ltsTextBlockGetClipping: TltsTextBlockGetClipping; - ltsTextBlockGetColor: TltsTextBlockGetColor; - ltsTextBlockGetFont: TltsTextBlockGetFont; - ltsTextBlockSetTop: TltsTextBlockSetTop; - ltsTextBlockSetLeft: TltsTextBlockSetLeft; - ltsTextBlockSetVertAlign: TltsTextBlockSetVertAlign; - ltsTextBlockSetHorzAlign: TltsTextBlockSetHorzAlign; - ltsTextBlockSetClipping: TltsTextBlockSetClipping; - ltsTextBlockSetColor: TltsTextBlockSetColor; - ltsTextBlockSetFont: TltsTextBlockSetFont; - ltsTextBlockGetActualHeight: TltsTextBlockGetActualHeight; - ltsTextBlockGetTextWidthA: TltsTextBlockGetTextWidthA; - ltsTextBlockGetTextWidthW: TltsTextBlockGetTextWidthW; - ltsTextBlockTextOutA: TltsTextBlockTextOutA; - ltsTextBlockTextOutW: TltsTextBlockTextOutW; - ltsTextBlockDestroy: TltsTextBlockDestroy; - - ltsImageCreate: TltsImageCreate; - ltsImageIsEmpty: TltsImageIsEmpty; - ltsImageGetWidth: TltsImageGetWidth; - ltsImageGetHeight: TltsImageGetHeight; - ltsImageGetLineSize: TltsImageGetLineSize; - ltsImageGetDataSize: TltsImageGetDataSize; - ltsImageGetFormat: TltsImageGetFormat; - ltsImageGetData: TltsImageGetData; - ltsImageGetScanline: TltsImageGetScanline; - ltsImageGetPixelAt: TltsImageGetPixelAt; - ltsImageAssign: TltsImageAssign; - ltsImageCreateEmpty: TltsImageCreateEmpty; - ltsImageLoadFromFunc: TltsImageLoadFromFunc; - ltsImageResize: TltsImageResize; - ltsImageFillColor: TltsImageFillColor; - ltsImageFillPattern: TltsImageFillPattern; - ltsImageBlend: TltsImageBlend; - ltsImageBlur: TltsImageBlur; - ltsImageDestroy: TltsImageDestroy; - - ltsPostProcessorAddRange: TltsPostProcessorAddRange; - ltsPostProcessorAddChars: TltsPostProcessorAddChars; - ltsPostProcessorClearRanges: TltsPostProcessorClearRanges; - ltsPostProcessorExecute: TltsPostProcessorExecute; - ltsPostProcessorFillColorCreate: TltsPostProcessorFillColorCreate; + TltsImageLoadFunc = procedure(aImage: TltsImage; X, Y: Integer; var aPixel: TltsColor4f; aArgs: Pointer); + TltsImageBlendFunc = function (aSrc, aDst: TltsColor4f; aArgs: Pointer): TltsColor4f; + + TltsImageLoadInternFunc = procedure(aHandle: TltsImageHandle; X, Y: Integer; var aPixel: TltsColor4f; aArgs: Pointer); stdcall; + TltsImageBlendInternFunc = function (aHandle: TltsImageHandle; aSrc, aDst: TltsColor4f; aArgs: Pointer): TltsColor4f; stdcall; + + TltsContextCreate = function(): TltsContextHandle; stdcall; + TltsContextGetCodePage = function(aHandle: TltsContextHandle; out aCodePage: TltsCodePage): TltsErrorCode; stdcall; + TltsContextGetDefaultChar = function(aHandle: TltsContextHandle; out aValue: WideChar): TltsErrorCode; stdcall; + TltsContextSetCodePage = function(aHandle: TltsContextHandle; aCodePage: TltsCodePage): TltsErrorCode; stdcall; + TltsContextSetDefaultChar = function(aHandle: TltsContextHandle; aValue: WideChar): TltsErrorCode; stdcall; + TltsContextAnsiToWide = function(aHandle: TltsContextHandle; aText: PAnsiChar): PWideChar; stdcall; + TltsContextDestroy = function(aHandle: TltsContextHandle): TltsErrorCode; stdcall; + + TltsRendererCreate = function(aHandle: TltsContextHandle; aType: TltsRendererType; aFormat: TltsFormat): TltsRendererHandle; stdcall; + TltsRendererCustomCreate = function(aHandle: TltsContextHandle; aFormat: TltsFormat; constref aData: TltsRendererCustomData): TltsRendererHandle; stdcall; + TltsRendererBeginBlock = function(aHandle: TltsRendererHandle; aTop, aLeft, aWidth, aHeight: Integer; aFlags: TltsBlockFlags): TltsTextBlockHandle; stdcall; + TltsRendererEndBlock = function(aHandle: TltsRendererHandle; aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; + TltsRendererAbortBlock = function(aHandle: TltsRendererHandle; aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; + TltsRendererGetTextWidthA = function(aHandle: TltsRendererHandle; aFont: TltsFontHandle; aText: PAnsiChar): Integer; stdcall; + TltsRendererGetTextWidthW = function(aHandle: TltsRendererHandle; aFont: TltsFontHandle; aText: PWideChar): Integer; stdcall; + TltsRendererDestroy = function(aHandle: TltsRendererHandle): TltsErrorCode; stdcall; + + TltsFontCreatorCreate = function(aHandle: TltsContextHandle; aType: TltsFontCreatorType): TltsFontCreatorHandle; stdcall; + TltsFontCreatorGetFontByName = function(aHandle: TltsFontCreatorHandle; aFontname: PAnsiChar; aSize: Integer; aStyle: TltsFontStyles; aAntiAliasing: TltsAntiAliasing): TltsFontHandle; stdcall; + TltsFontCreatorGetFontByFile = function(aHandle: TltsFontCreatorHandle; aFilename: PAnsiChar; aSize: Integer; aStyle: TltsFontStyles; aAntiAliasing: TltsAntiAliasing): TltsFontHandle; stdcall; + TltsFontCreatorGetFontByStream = function(aHandle: TltsFontCreatorHandle; aStream: PltsStream; aSize: Integer; aStyle: TltsFontStyles; aAntiAliasing: TltsAntiAliasing): TltsFontHandle; stdcall; + TltsFontCreatorDestroy = function(aHandle: TltsFontCreatorHandle): TltsErrorCode; stdcall; + + TltsFontGetPostProcessor = function(aHandle: TltsFontHandle): TltsPostProcessorHandle; stdcall; + TltsFontGetTabWidth = function(aHandle: TltsFontHandle; out aValue: Integer): TltsErrorCode; stdcall; + TltsFontGetCharSpacing = function(aHandle: TltsFontHandle; out aValue: Integer): TltsErrorCode; stdcall; + TltsFontGetLineSpacing = function(aHandle: TltsFontHandle; out aValue: Single): TltsErrorCode; stdcall; + TltsFontGetMetric = function(aHandle: TltsFontHandle; out aValue: TltsFontMetric): TltsErrorCode; stdcall; + TltsFontGetFontname = function(aHandle: TltsFontHandle): PAnsiChar; stdcall; + TltsFontGetFacename = function(aHandle: TltsFontHandle): PAnsiChar; stdcall; + TltsFontGetStylename = function(aHandle: TltsFontHandle): PAnsiChar; stdcall; + TltsFontGetFullname = function(aHandle: TltsFontHandle): PAnsiChar; stdcall; + TltsFontGetCopyright = function(aHandle: TltsFontHandle): PAnsiChar; stdcall; + TltsFontSetPostProcessor = function(aHandle: TltsFontHandle; aValue: TltsPostProcessorHandle): TltsErrorCode; stdcall; + TltsFontSetTabWidth = function(aHandle: TltsFontHandle; aValue: Integer): TltsErrorCode; stdcall; + TltsFontSetCharSpacing = function(aHandle: TltsFontHandle; aValue: Integer): TltsErrorCode; stdcall; + TltsFontSetLineSpacing = function(aHandle: TltsFontHandle; aValue: Single): TltsErrorCode; stdcall; + TltsFontDestroy = function(aHandle: TltsFontHandle): TltsErrorCode; stdcall; + + TltsTextBlockGetRect = function(aHandle: TltsTextBlockHandle; out aValue: TltsRect): TltsErrorCode; stdcall; + TltsTextBlockGetWidth = function(aHandle: TltsTextBlockHandle; out aValue: Integer): TltsErrorCode; stdcall; + TltsTextBlockGetHeight = function(aHandle: TltsTextBlockHandle; out aValue: Integer): TltsErrorCode; stdcall; + TltsTextBlockGetFlags = function(aHandle: TltsTextBlockHandle; out aValue: TltsBlockFlags): TltsErrorCode; stdcall; + TltsTextBlockGetTop = function(aHandle: TltsTextBlockHandle; out aValue: Integer): TltsErrorCode; stdcall; + TltsTextBlockGetLeft = function(aHandle: TltsTextBlockHandle; out aValue: Integer): TltsErrorCode; stdcall; + TltsTextBlockGetVertAlign = function(aHandle: TltsTextBlockHandle; out aValue: TltsVertAlignment): TltsErrorCode; stdcall; + TltsTextBlockGetHorzAlign = function(aHandle: TltsTextBlockHandle; out aValue: TltsHorzAlignment): TltsErrorCode; stdcall; + TltsTextBlockGetClipping = function(aHandle: TltsTextBlockHandle; out aValue: TltsClipping): TltsErrorCode; stdcall; + TltsTextBlockGetColor = function(aHandle: TltsTextBlockHandle; out aValue: TltsColor4f): TltsErrorCode; stdcall; + TltsTextBlockGetFont = function(aHandle: TltsTextBlockHandle; out aValue: TltsFontHandle): TltsErrorCode; stdcall; + TltsTextBlockSetTop = function(aHandle: TltsTextBlockHandle; aValue: Integer): TltsErrorCode; stdcall; + TltsTextBlockSetLeft = function(aHandle: TltsTextBlockHandle; aValue: Integer): TltsErrorCode; stdcall; + TltsTextBlockSetVertAlign = function(aHandle: TltsTextBlockHandle; aValue: TltsVertAlignment): TltsErrorCode; stdcall; + TltsTextBlockSetHorzAlign = function(aHandle: TltsTextBlockHandle; aValue: TltsHorzAlignment): TltsErrorCode; stdcall; + TltsTextBlockSetClipping = function(aHandle: TltsTextBlockHandle; aValue: TltsClipping): TltsErrorCode; stdcall; + TltsTextBlockSetColor = function(aHandle: TltsTextBlockHandle; aValue: TltsColor4f): TltsErrorCode; stdcall; + TltsTextBlockSetFont = function(aHandle: TltsTextBlockHandle; aValue: TltsFontHandle): TltsErrorCode; stdcall; + TltsTextBlockGetActualHeight = function(aHandle: TltsTextBlockHandle): Integer; stdcall; + TltsTextBlockGetTextWidthA = function(aHandle: TltsTextBlockHandle; aText: PAnsiChar): Integer; stdcall; + TltsTextBlockGetTextWidthW = function(aHandle: TltsTextBlockHandle; aText: PWideChar): Integer; stdcall; + TltsTextBlockTextOutA = function(aHandle: TltsTextBlockHandle; aText: PAnsiChar): TltsErrorCode; stdcall; + TltsTextBlockTextOutW = function(aHandle: TltsTextBlockHandle; aText: PWideChar): TltsErrorCode; stdcall; + TltsTextBlockDestroy = function(aHandle: TltsTextBlockHandle): TltsErrorCode; stdcall; + + TltsImageCreate = function(aContext: TltsContextHandle): TltsImageHandle; stdcall; + TltsImageIsEmpty = function(aHandle: TltsImageHandle; out aValue: Boolean): TltsErrorCode; stdcall; + TltsImageGetWidth = function(aHandle: TltsImageHandle): Integer; stdcall; + TltsImageGetHeight = function(aHandle: TltsImageHandle): Integer; stdcall; + TltsImageGetLineSize = function(aHandle: TltsImageHandle): Integer; stdcall; + TltsImageGetDataSize = function(aHandle: TltsImageHandle): Integer; stdcall; + TltsImageGetFormat = function(aHandle: TltsImageHandle; out aValue: TltsFormat): TltsErrorCode; stdcall; + TltsImageGetData = function(aHandle: TltsImageHandle): Pointer; stdcall; + TltsImageGetScanline = function(aHandle: TltsImageHandle; aIndex: Integer): Pointer; stdcall; + TltsImageGetPixelAt = function(aHandle: TltsImageHandle; aX, aY: Integer; out aColor: TltsColor4f): TltsErrorCode; stdcall; + TltsImageAssign = function(aHandle, aSource: TltsImageHandle): TltsErrorCode; stdcall; + TltsImageCreateEmpty = function(aHandle: TltsImageHandle; aFormat: TltsFormat; aWidth, aHeight: Integer): TltsErrorCode; stdcall; + TltsImageLoadFromFunc = function(aHandle: TltsImageHandle; aCallback: TltsImageLoadInternFunc; aArgs: Pointer): TltsErrorCode; stdcall; + TltsImageResize = function(aHandle: TltsImageHandle; aWidth, aHeight, aX, aY: Integer): TltsErrorCode; stdcall; + TltsImageFillColor = function(aHandle: TltsImageHandle; aColor: TltsColor4f; aMask: TltsColorChannels; aModes: TltsImageModes): TltsErrorCode; stdcall; + TltsImageFillPattern = function(aHandle, aPattern: TltsImageHandle; aX, aY: Integer; aMask: TltsColorChannels; aModes: TltsImageModes): TltsErrorCode; stdcall; + TltsImageBlend = function(aHandle, aSource: TltsImageHandle; aX, aY: Integer; aBlendFunc: TltsImageBlendInternFunc; aArgs: Pointer): TltsErrorCode; stdcall; + TltsImageBlur = function(aHandle: TltsImageHandle; aHorzRad, aHorzStr, aVertRad, aVertStr: Single; aMask: TltsColorChannels): TltsErrorCode; stdcall; + TltsImageDestroy = function(aHandle: TltsImageHandle): TltsErrorCode; stdcall; + + TltsPostProcessorAddRange = function(aHandle: TltsPostProcessorHandle; aUsage: TltsCharRangeUsage; aStart, aStop: WideChar): TltsErrorCode; stdcall; + TltsPostProcessorAddChars = function(aHandle: TltsPostProcessorHandle; aUsage: TltsCharRangeUsage; aChars: PWideChar): TltsErrorCode; stdcall; + TltsPostProcessorClearRanges = function(aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; + TltsPostProcessorExecute = function(aHandle: TltsPostProcessorHandle; aChar: TltsCharHandle; aImage: TltsImageHandle): TltsErrorCode; stdcall; + TltsPostProcessorFillColorCreate = function(aContext: TltsContextHandle; aColor: TltsColor4f; aModes: TltsImageModes; aChannels: TltsColorChannels): TltsPostProcessorHandle; stdcall; + TltsPostProcessorFillPatterCreate = function(aContext: TltsContextHandle; aPattern: TltsImageHandle; aOwnsPatter: Boolean; aPosition: TltsPosition; aModes: TltsImageModes; aChannels: TltsColorChannels): TltsPostProcessorHandle; stdcall; + TltsPostProcessorBorderCreate = function(aContext: TltsContextHandle; aWidth, aStrength: Single; aColor: TltsColor4f; aKeepSize: Boolean): TltsPostProcessorHandle; stdcall; + TltsPostProcessorShadowCreate = function(aContext: TltsContextHandle; aRadius, aStrength: Single; aOffset: TltsPosition; aColor: TltsColor4f): TltsPostProcessorHandle; stdcall; + TltsPostProcessorCustomCreate = function(aContext: TltsContextHandle; constref aData: TltsPostProcessorCustomData): TltsPostProcessorHandle; stdcall; + TltsPostProcessorDestroy = function(aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; + + TltsCharGetCharCode = function(aHandle: TltsCharHandle; out aValue: WideChar): TltsErrorCode; stdcall; + TltsCharGetGlyphMetric = function(aHandle: TltsCharHandle; out aValue: TltsGlyphMetric): TltsErrorCode; stdcall; + TltsCharSetGlyphMetric = function(aHandle: TltsCharHandle; aValue: TltsGlyphMetric): TltsErrorCode; stdcall; + + TltsInitialize = function(): TltsErrorCode; stdcall; + TltsGetLastErrorCode = function(): TltsErrorCode; stdcall; + TltsGetLastErrorMsg = function(): PAnsiChar; stdcall; + TltsFinalize = function(): TltsErrorCode; stdcall; + +var + ltsContextCreate: TltsContextCreate; + ltsContextGetCodePage: TltsContextGetCodePage; + ltsContextGetDefaultChar: TltsContextGetDefaultChar; + ltsContextSetCodePage: TltsContextSetCodePage; + ltsContextSetDefaultChar: TltsContextSetDefaultChar; + ltsContextAnsiToWide: TltsContextAnsiToWide; + ltsContextDestroy: TltsContextDestroy; + + ltsRendererCreate: TltsRendererCreate; + ltsRendererCustomCreate: TltsRendererCustomCreate; + ltsRendererBeginBlock: TltsRendererBeginBlock; + ltsRendererEndBlock: TltsRendererEndBlock; + ltsRendererAbortBlock: TltsRendererAbortBlock; + ltsRendererGetTextWidthA: TltsRendererGetTextWidthA; + ltsRendererGetTextWidthW: TltsRendererGetTextWidthW; + ltsRendererDestroy: TltsRendererDestroy; + + ltsFontCreatorCreate: TltsFontCreatorCreate; + ltsFontCreatorGetFontByName: TltsFontCreatorGetFontByName; + ltsFontCreatorGetFontByFile: TltsFontCreatorGetFontByFile; + ltsFontCreatorGetFontByStream: TltsFontCreatorGetFontByStream; + ltsFontCreatorDestroy: TltsFontCreatorDestroy; + + ltsFontGetPostProcessor: TltsFontGetPostProcessor; + ltsFontGetTabWidth: TltsFontGetTabWidth; + ltsFontGetCharSpacing: TltsFontGetCharSpacing; + ltsFontGetLineSpacing: TltsFontGetLineSpacing; + ltsFontGetMetric: TltsFontGetMetric; + ltsFontGetFontname: TltsFontGetFontname; + ltsFontGetFacename: TltsFontGetFacename; + ltsFontGetStylename: TltsFontGetStylename; + ltsFontGetFullname: TltsFontGetFullname; + ltsFontGetCopyright: TltsFontGetCopyright; + ltsFontSetPostProcessor: TltsFontSetPostProcessor; + ltsFontSetTabWidth: TltsFontSetTabWidth; + ltsFontSetCharSpacing: TltsFontSetCharSpacing; + ltsFontSetLineSpacing: TltsFontSetLineSpacing; + ltsFontDestroy: TltsFontDestroy; + + ltsTextBlockGetRect: TltsTextBlockGetRect; + ltsTextBlockGetWidth: TltsTextBlockGetWidth; + ltsTextBlockGetHeight: TltsTextBlockGetHeight; + ltsTextBlockGetFlags: TltsTextBlockGetFlags; + ltsTextBlockGetTop: TltsTextBlockGetTop; + ltsTextBlockGetLeft: TltsTextBlockGetLeft; + ltsTextBlockGetVertAlign: TltsTextBlockGetVertAlign; + ltsTextBlockGetHorzAlign: TltsTextBlockGetHorzAlign; + ltsTextBlockGetClipping: TltsTextBlockGetClipping; + ltsTextBlockGetColor: TltsTextBlockGetColor; + ltsTextBlockGetFont: TltsTextBlockGetFont; + ltsTextBlockSetTop: TltsTextBlockSetTop; + ltsTextBlockSetLeft: TltsTextBlockSetLeft; + ltsTextBlockSetVertAlign: TltsTextBlockSetVertAlign; + ltsTextBlockSetHorzAlign: TltsTextBlockSetHorzAlign; + ltsTextBlockSetClipping: TltsTextBlockSetClipping; + ltsTextBlockSetColor: TltsTextBlockSetColor; + ltsTextBlockSetFont: TltsTextBlockSetFont; + ltsTextBlockGetActualHeight: TltsTextBlockGetActualHeight; + ltsTextBlockGetTextWidthA: TltsTextBlockGetTextWidthA; + ltsTextBlockGetTextWidthW: TltsTextBlockGetTextWidthW; + ltsTextBlockTextOutA: TltsTextBlockTextOutA; + ltsTextBlockTextOutW: TltsTextBlockTextOutW; + ltsTextBlockDestroy: TltsTextBlockDestroy; + + ltsImageCreate: TltsImageCreate; + ltsImageIsEmpty: TltsImageIsEmpty; + ltsImageGetWidth: TltsImageGetWidth; + ltsImageGetHeight: TltsImageGetHeight; + ltsImageGetLineSize: TltsImageGetLineSize; + ltsImageGetDataSize: TltsImageGetDataSize; + ltsImageGetFormat: TltsImageGetFormat; + ltsImageGetData: TltsImageGetData; + ltsImageGetScanline: TltsImageGetScanline; + ltsImageGetPixelAt: TltsImageGetPixelAt; + ltsImageAssign: TltsImageAssign; + ltsImageCreateEmpty: TltsImageCreateEmpty; + ltsImageLoadFromFunc: TltsImageLoadFromFunc; + ltsImageResize: TltsImageResize; + ltsImageFillColor: TltsImageFillColor; + ltsImageFillPattern: TltsImageFillPattern; + ltsImageBlend: TltsImageBlend; + ltsImageBlur: TltsImageBlur; + ltsImageDestroy: TltsImageDestroy; + + ltsPostProcessorAddRange: TltsPostProcessorAddRange; + ltsPostProcessorAddChars: TltsPostProcessorAddChars; + ltsPostProcessorClearRanges: TltsPostProcessorClearRanges; + ltsPostProcessorExecute: TltsPostProcessorExecute; + ltsPostProcessorFillColorCreate: TltsPostProcessorFillColorCreate; ltsPostProcessorFillPatterCreate: TltsPostProcessorFillPatterCreate; - ltsPostProcessorBorderCreate: TltsPostProcessorBorderCreate; - ltsPostProcessorShadowCreate: TltsPostProcessorShadowCreate; - ltsPostProcessorCustomCreate: TltsPostProcessorCustomCreate; - ltsPostProcessorDestroy: TltsPostProcessorDestroy; + ltsPostProcessorBorderCreate: TltsPostProcessorBorderCreate; + ltsPostProcessorShadowCreate: TltsPostProcessorShadowCreate; + ltsPostProcessorCustomCreate: TltsPostProcessorCustomCreate; + ltsPostProcessorDestroy: TltsPostProcessorDestroy; - ltsCharGetCharCode: TltsCharGetCharCode; - ltsCharGetGlyphMetric: TltsCharGetGlyphMetric; - ltsCharSetGlyphMetric: TltsCharSetGlyphMetric; + ltsCharGetCharCode: TltsCharGetCharCode; + ltsCharGetGlyphMetric: TltsCharGetGlyphMetric; + ltsCharSetGlyphMetric: TltsCharSetGlyphMetric; - ltsGetLastErrorCode: TltsGetLastErrorCode; - ltsGetLastErrorMsg: TltsGetLastErrorMsg; + ltsGetLastErrorCode: TltsGetLastErrorCode; + ltsGetLastErrorMsg: TltsGetLastErrorMsg; procedure ltsInitialize(const aLibName: String); procedure ltsFinalize; @@ -1033,7 +1034,7 @@ type end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -procedure ltsImageLoadCallback(const aHandle: TltsImageHandle; const X, Y: Integer; var aPixel: TltsColor4f; aArgs: Pointer); stdcall; +procedure ltsImageLoadCallback(aHandle: TltsImageHandle; X, Y: Integer; var aPixel: TltsColor4f; aArgs: Pointer); stdcall; var p: PImageLoadArgs; begin @@ -1042,12 +1043,12 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageBlendCallback(const aHandle: TltsImageHandle; const aSrc, aDst: TltsColor4f; aArgs: Pointer): TltsColor4f; stdcall; +procedure ltsImageBlendCallback(aHandle: TltsImageHandle; aSrc, aDst: TltsColor4f; out aResult: TltsColor4f; aArgs: Pointer); stdcall; var p: PImageBlendArgs; begin p := PImageBlendArgs(aArgs); - result := p^.callback(aSrc, aDst, p^.args); + aResult := p^.callback(aSrc, aDst, p^.args); end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -1092,6 +1093,7 @@ begin ltsFontCreatorGetFontByFile := TltsFontCreatorGetFontByFile( LoadProc('ltsFontCreatorGetFontByFile')); ltsFontCreatorGetFontByStream := TltsFontCreatorGetFontByStream( LoadProc('ltsFontCreatorGetFontByStream')); ltsFontCreatorDestroy := TltsFontCreatorDestroy( LoadProc('ltsFontCreatorDestroy')); + ltsFontGetPostProcessor := TltsFontGetPostProcessor( LoadProc('ltsFontGetPostProcessor')); ltsFontGetTabWidth := TltsFontGetTabWidth( LoadProc('ltsFontGetTabWidth')); ltsFontGetCharSpacing := TltsFontGetCharSpacing( LoadProc('ltsFontGetCharSpacing')); @@ -1615,7 +1617,7 @@ var begin p.args := self; p.execute := @ltsPostProcessorExecuteCallback; - h := ltsPostProcessorCustomCreate(aContext.Handle, @p); + h := ltsPostProcessorCustomCreate(aContext.Handle, p); if not Assigned(h) then raise TltsException.Create(ltsGetLastErrorMsg(), ltsGetLastErrorCode()); inherited Create(h); @@ -2570,7 +2572,7 @@ begin d.Render := @ltsRendererCustomRender; d.CreatRef := @ltsRendererCustomCreateRef; d.FreeRef := @ltsRendererCustomFreeRef; - h := ltsRendererCustomCreate(aContext.Handle, aFormat, @d); + h := ltsRendererCustomCreate(aContext.Handle, aFormat, d); if not Assigned(h) then raise TltsException.Create(ltsGetLastErrorMsg(), ltsGetLastErrorCode()); inherited Create(h); diff --git a/ultsChar.pas b/ultsChar.pas index 02904d7..ea5d6b3 100644 --- a/ultsChar.pas +++ b/ultsChar.pas @@ -8,9 +8,9 @@ uses Classes, SysUtils, utsTextSuite, ultsTypes; -function ltsCharGetCharCode (const aHandle: TltsCharHandle; var aValue: WideChar): TltsErrorCode; stdcall; -function ltsCharGetGlyphMetric(const aHandle: TltsCharHandle; var aValue: TtsGlyphMetric): TltsErrorCode; stdcall; -function ltsCharSetGlyphMetric(const aHandle: TltsCharHandle; const aValue: TtsGlyphMetric): TltsErrorCode; stdcall; +function ltsCharGetCharCode (aHandle: TltsCharHandle; var aValue: WideChar): TltsErrorCode; stdcall; +function ltsCharGetGlyphMetric(aHandle: TltsCharHandle; var aValue: TtsGlyphMetric): TltsErrorCode; stdcall; +function ltsCharSetGlyphMetric(aHandle: TltsCharHandle; aValue: TtsGlyphMetric): TltsErrorCode; stdcall; implementation @@ -20,7 +20,7 @@ uses //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //ltsChar/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsCharGetCharCode(const aHandle: TltsCharHandle; var aValue: WideChar): TltsErrorCode; stdcall; +function ltsCharGetCharCode(aHandle: TltsCharHandle; var aValue: WideChar): TltsErrorCode; stdcall; var c: TtsChar; begin @@ -38,7 +38,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsCharGetGlyphMetric(const aHandle: TltsCharHandle; var aValue: TtsGlyphMetric): TltsErrorCode; stdcall; +function ltsCharGetGlyphMetric(aHandle: TltsCharHandle; var aValue: TtsGlyphMetric): TltsErrorCode; stdcall; var c: TtsChar; begin @@ -56,7 +56,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsCharSetGlyphMetric(const aHandle: TltsCharHandle; const aValue: TtsGlyphMetric): TltsErrorCode; stdcall; +function ltsCharSetGlyphMetric(aHandle: TltsCharHandle; aValue: TtsGlyphMetric): TltsErrorCode; stdcall; var c: TtsChar; begin diff --git a/ultsContext.pas b/ultsContext.pas index 4ed1dac..aa492fa 100644 --- a/ultsContext.pas +++ b/ultsContext.pas @@ -19,9 +19,9 @@ type function ltsContextCreate (): TltsContextHandle; stdcall; function ltsContextGetCodePage (const aHandle: TltsContextHandle; var aCodePage: TtsCodePage): TltsErrorCode; stdcall; function ltsContextGetDefaultChar (const aHandle: TltsContextHandle; var aValue: WideChar): TltsErrorCode; stdcall; - function ltsContextSetCodePage (const aHandle: TltsContextHandle; const aCodePage: TtsCodePage): TltsErrorCode; stdcall; - function ltsContextSetDefaultChar (const aHandle: TltsContextHandle; const aValue: WideChar): TltsErrorCode; stdcall; - function ltsContextAnsiToWide (const aHandle: TltsContextHandle; const aText: PAnsiChar): PWideChar; stdcall; + function ltsContextSetCodePage (const aHandle: TltsContextHandle; aCodePage: TtsCodePage): TltsErrorCode; stdcall; + function ltsContextSetDefaultChar (const aHandle: TltsContextHandle; aValue: WideChar): TltsErrorCode; stdcall; + function ltsContextAnsiToWide (const aHandle: TltsContextHandle; aText: PAnsiChar): PWideChar; stdcall; function ltsContextDestroy (const aHandle: TltsContextHandle): TltsErrorCode; stdcall; implementation @@ -100,7 +100,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsContextSetCodePage(const aHandle: TltsContextHandle; const aCodePage: TtsCodePage): TltsErrorCode; stdcall; +function ltsContextSetCodePage(const aHandle: TltsContextHandle; aCodePage: TtsCodePage): TltsErrorCode; stdcall; var c: TtsContext; begin @@ -123,7 +123,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsContextSetDefaultChar(const aHandle: TltsContextHandle; const aValue: WideChar): TltsErrorCode; stdcall; +function ltsContextSetDefaultChar(const aHandle: TltsContextHandle; aValue: WideChar): TltsErrorCode; stdcall; var c: TtsContext; begin @@ -141,7 +141,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsContextAnsiToWide(const aHandle: TltsContextHandle; const aText: PAnsiChar): PWideChar; stdcall; +function ltsContextAnsiToWide(const aHandle: TltsContextHandle; aText: PAnsiChar): PWideChar; stdcall; var c: TtsContext; w: PWideChar; diff --git a/ultsFont.pas b/ultsFont.pas index 2936e28..c1ffa09 100644 --- a/ultsFont.pas +++ b/ultsFont.pas @@ -9,24 +9,24 @@ uses utsTextSuite, ultsTypes; -function ltsFontGetPostProcessor (const aHandle: TltsFontHandle): TltsPostProcessorHandle; stdcall; -function ltsFontGetTabWidth (const aHandle: TltsFontHandle; var aValue: Integer): TltsErrorCode; stdcall; -function ltsFontGetCharSpacing (const aHandle: TltsFontHandle; var aValue: Integer): TltsErrorCode; stdcall; -function ltsFontGetLineSpacing (const aHandle: TltsFontHandle; var aValue: Single): TltsErrorCode; stdcall; -function ltsFontGetMetric (const aHandle: TltsFontHandle; var aValue: TtsFontMetric): TltsErrorCode; stdcall; +function ltsFontGetPostProcessor (aHandle: TltsFontHandle): TltsPostProcessorHandle; stdcall; +function ltsFontGetTabWidth (aHandle: TltsFontHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsFontGetCharSpacing (aHandle: TltsFontHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsFontGetLineSpacing (aHandle: TltsFontHandle; var aValue: Single): TltsErrorCode; stdcall; +function ltsFontGetMetric (aHandle: TltsFontHandle; var aValue: TtsFontMetric): TltsErrorCode; stdcall; -function ltsFontGetFontname (const aHandle: TltsFontHandle): PAnsiChar; stdcall; -function ltsFontGetFacename (const aHandle: TltsFontHandle): PAnsiChar; stdcall; -function ltsFontGetStylename (const aHandle: TltsFontHandle): PAnsiChar; stdcall; -function ltsFontGetFullname (const aHandle: TltsFontHandle): PAnsiChar; stdcall; -function ltsFontGetCopyright (const aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetFontname (aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetFacename (aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetStylename (aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetFullname (aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetCopyright (aHandle: TltsFontHandle): PAnsiChar; stdcall; -function ltsFontSetPostProcessor (const aHandle: TltsFontHandle; const aValue: TltsPostProcessorHandle): TltsErrorCode; stdcall; -function ltsFontSetTabWidth (const aHandle: TltsFontHandle; const aValue: Integer): TltsErrorCode; stdcall; -function ltsFontSetCharSpacing (const aHandle: TltsFontHandle; const aValue: Integer): TltsErrorCode; stdcall; -function ltsFontSetLineSpacing (const aHandle: TltsFontHandle; const aValue: Single): TltsErrorCode; stdcall; +function ltsFontSetPostProcessor (aHandle: TltsFontHandle; aValue: TltsPostProcessorHandle): TltsErrorCode; stdcall; +function ltsFontSetTabWidth (aHandle: TltsFontHandle; aValue: Integer): TltsErrorCode; stdcall; +function ltsFontSetCharSpacing (aHandle: TltsFontHandle; aValue: Integer): TltsErrorCode; stdcall; +function ltsFontSetLineSpacing (aHandle: TltsFontHandle; aValue: Single): TltsErrorCode; stdcall; -function ltsFontDestroy (const aHandle: TltsFontHandle): TltsErrorCode; stdcall; +function ltsFontDestroy (aHandle: TltsFontHandle): TltsErrorCode; stdcall; implementation @@ -36,7 +36,7 @@ uses //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Font////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetPostProcessor(const aHandle: TltsFontHandle): TltsPostProcessorHandle; stdcall; +function ltsFontGetPostProcessor(aHandle: TltsFontHandle): TltsPostProcessorHandle; stdcall; var f: TtsFont; begin @@ -53,7 +53,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetTabWidth(const aHandle: TltsFontHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsFontGetTabWidth(aHandle: TltsFontHandle; var aValue: Integer): TltsErrorCode; stdcall; var f: TtsFont; begin @@ -71,7 +71,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetCharSpacing(const aHandle: TltsFontHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsFontGetCharSpacing(aHandle: TltsFontHandle; var aValue: Integer): TltsErrorCode; stdcall; var f: TtsFont; begin @@ -89,7 +89,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetLineSpacing(const aHandle: TltsFontHandle; var aValue: Single): TltsErrorCode; stdcall; +function ltsFontGetLineSpacing(aHandle: TltsFontHandle; var aValue: Single): TltsErrorCode; stdcall; var f: TtsFont; begin @@ -107,7 +107,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetMetric(const aHandle: TltsFontHandle; var aValue: TtsFontMetric): TltsErrorCode; stdcall; +function ltsFontGetMetric(aHandle: TltsFontHandle; var aValue: TtsFontMetric): TltsErrorCode; stdcall; var f: TtsFont; begin @@ -125,7 +125,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetFontname(const aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetFontname(aHandle: TltsFontHandle): PAnsiChar; stdcall; var f: TtsFont; begin @@ -142,7 +142,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetFacename(const aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetFacename(aHandle: TltsFontHandle): PAnsiChar; stdcall; var f: TtsFont; begin @@ -159,7 +159,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetStylename(const aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetStylename(aHandle: TltsFontHandle): PAnsiChar; stdcall; var f: TtsFont; begin @@ -176,7 +176,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetFullname(const aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetFullname(aHandle: TltsFontHandle): PAnsiChar; stdcall; var f: TtsFont; begin @@ -193,7 +193,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontGetCopyright(const aHandle: TltsFontHandle): PAnsiChar; stdcall; +function ltsFontGetCopyright(aHandle: TltsFontHandle): PAnsiChar; stdcall; var f: TtsFont; begin @@ -210,7 +210,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontSetPostProcessor(const aHandle: TltsFontHandle; const aValue: TltsPostProcessorHandle): TltsErrorCode; stdcall; +function ltsFontSetPostProcessor(aHandle: TltsFontHandle; aValue: TltsPostProcessorHandle): TltsErrorCode; stdcall; var f: TtsFont; p: TtsPostProcessor; @@ -229,7 +229,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontSetTabWidth(const aHandle: TltsFontHandle; const aValue: Integer): TltsErrorCode; stdcall; +function ltsFontSetTabWidth(aHandle: TltsFontHandle; aValue: Integer): TltsErrorCode; stdcall; var f: TtsFont; begin @@ -247,7 +247,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontSetCharSpacing(const aHandle: TltsFontHandle; const aValue: Integer): TltsErrorCode; stdcall; +function ltsFontSetCharSpacing(aHandle: TltsFontHandle; aValue: Integer): TltsErrorCode; stdcall; var f: TtsFont; begin @@ -265,7 +265,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontSetLineSpacing(const aHandle: TltsFontHandle; const aValue: Single): TltsErrorCode; stdcall; +function ltsFontSetLineSpacing(aHandle: TltsFontHandle; aValue: Single): TltsErrorCode; stdcall; var f: TtsFont; begin @@ -283,7 +283,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontDestroy(const aHandle: TltsFontHandle): TltsErrorCode; stdcall; +function ltsFontDestroy(aHandle: TltsFontHandle): TltsErrorCode; stdcall; var f: TtsFont; begin diff --git a/ultsFontCreator.pas b/ultsFontCreator.pas index edcf54a..687f29a 100644 --- a/ultsFontCreator.pas +++ b/ultsFontCreator.pas @@ -9,14 +9,14 @@ uses utsTextSuite, ultsTypes; -function ltsFontCreatorCreate (const aHandle: TltsContextHandle; const aType: TltsFontCreatorType): TltsFontCreatorHandle; stdcall; -function ltsFontCreatorGetFontByName (const aHandle: TltsFontCreatorHandle; const aFontname: PAnsiChar; const aSize: Integer; - const aStyle: TtsFontStyles; const aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; -function ltsFontCreatorGetFontByFile (const aHandle: TltsFontCreatorHandle; const aFilename: PAnsiChar; const aSize: Integer; - const aStyle: TtsFontStyles; const aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; -function ltsFontCreatorGetFontByStream(const aHandle: TltsFontCreatorHandle; const aStream: PltsStream; const aSize: Integer; - const aStyle: TtsFontStyles; const aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; -function ltsFontCreatorDestroy (const aHandle: TltsFontCreatorHandle): TltsErrorCode; stdcall; +function ltsFontCreatorCreate (aHandle: TltsContextHandle; aType: TltsFontCreatorType): TltsFontCreatorHandle; stdcall; +function ltsFontCreatorGetFontByName (aHandle: TltsFontCreatorHandle; aFontname: PAnsiChar; aSize: Integer; + aStyle: TtsFontStyles; aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; +function ltsFontCreatorGetFontByFile (aHandle: TltsFontCreatorHandle; aFilename: PAnsiChar; aSize: Integer; + aStyle: TtsFontStyles; aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; +function ltsFontCreatorGetFontByStream(aHandle: TltsFontCreatorHandle; aStream: PltsStream; aSize: Integer; + aStyle: TtsFontStyles; aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; +function ltsFontCreatorDestroy (aHandle: TltsFontCreatorHandle): TltsErrorCode; stdcall; implementation @@ -58,7 +58,7 @@ end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //FontCreato/////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontCreatorCreate(const aHandle: TltsContextHandle; const aType: TltsFontCreatorType): TltsFontCreatorHandle; stdcall; +function ltsFontCreatorCreate(aHandle: TltsContextHandle; aType: TltsFontCreatorType): TltsFontCreatorHandle; stdcall; var c: TtsContext; fc: TtsFontCreator; @@ -87,8 +87,8 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontCreatorGetFontByName(const aHandle: TltsFontCreatorHandle; const aFontname: PAnsiChar; - const aSize: Integer; const aStyle: TtsFontStyles; const aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; +function ltsFontCreatorGetFontByName(aHandle: TltsFontCreatorHandle; aFontname: PAnsiChar; + aSize: Integer; aStyle: TtsFontStyles; aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; var fc: TtsFontCreator; f: TtsFont; @@ -113,8 +113,8 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontCreatorGetFontByFile(const aHandle: TltsFontCreatorHandle; const aFilename: PAnsiChar; - const aSize: Integer; const aStyle: TtsFontStyles; const aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; +function ltsFontCreatorGetFontByFile(aHandle: TltsFontCreatorHandle; aFilename: PAnsiChar; + aSize: Integer; aStyle: TtsFontStyles; aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; var fc: TtsFontCreator; f: TtsFont; @@ -139,8 +139,8 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontCreatorGetFontByStream(const aHandle: TltsFontCreatorHandle; const aStream: PltsStream; - const aSize: Integer; const aStyle: TtsFontStyles; const aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; +function ltsFontCreatorGetFontByStream(aHandle: TltsFontCreatorHandle; aStream: PltsStream; + aSize: Integer; aStyle: TtsFontStyles; aAntiAliasing: TtsAntiAliasing): TltsFontHandle; stdcall; var fc: TtsFontCreator; f: TtsFont; @@ -173,7 +173,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsFontCreatorDestroy(const aHandle: TltsFontCreatorHandle): TltsErrorCode; stdcall; +function ltsFontCreatorDestroy(aHandle: TltsFontCreatorHandle): TltsErrorCode; stdcall; var fc: TtsFontCreator; begin diff --git a/ultsImage.pas b/ultsImage.pas index c1f2361..01d1ea3 100644 --- a/ultsImage.pas +++ b/ultsImage.pas @@ -10,28 +10,28 @@ uses ultsTypes; type - TltsImageLoadFunc = procedure(const aHandle: TltsImageHandle; const X, Y: Integer; var aPixel: TtsColor4f; aArgs: Pointer); stdcall; - TltsImageBlendFunc = function (const aHandle: TltsImageHandle; const aSrc, aDst: TtsColor4f; aArgs: Pointer): TtsColor4f; stdcall; - -function ltsImageCreate (const aContext: TltsContextHandle): TltsImageHandle; stdcall; -function ltsImageIsEmpty (const aHandle: TltsImageHandle; var aValue: Boolean): TltsErrorCode; stdcall; -function ltsImageGetWidth (const aHandle: TltsImageHandle): Integer; stdcall; -function ltsImageGetHeight (const aHandle: TltsImageHandle): Integer; stdcall; -function ltsImageGetLineSize (const aHandle: TltsImageHandle): Integer; stdcall; -function ltsImageGetDataSize (const aHandle: TltsImageHandle): Integer; stdcall; -function ltsImageGetFormat (const aHandle: TltsImageHandle; var aValue: TtsFormat): TltsErrorCode; stdcall; -function ltsImageGetData (const aHandle: TltsImageHandle): Pointer; stdcall; -function ltsImageGetScanline (const aHandle: TltsImageHandle; const aIndex: Integer): Pointer; stdcall; -function ltsImageGetPixelAt (const aHandle: TltsImageHandle; const aX, aY: Integer; var aColor: TtsColor4f): TltsErrorCode; stdcall; -function ltsImageAssign (const aHandle, aSource: TltsImageHandle): TltsErrorCode; stdcall; -function ltsImageCreateEmpty (const aHandle: TltsImageHandle; const aFormat: TtsFormat; const aWidth, aHeight: Integer): TltsErrorCode; stdcall; -function ltsImageLoadFromFunc (const aHandle: TltsImageHandle; const aCallback: TltsImageLoadFunc; aArgs: Pointer): TltsErrorCode; stdcall; -function ltsImageResize (const aHandle: TltsImageHandle; const aWidth, aHeight, aX, aY: Integer): TltsErrorCode; stdcall; -function ltsImageFillColor (const aHandle: TltsImageHandle; const aColor: TtsColor4f; const aMask: TtsColorChannels; const aModes: TtsImageModes): TltsErrorCode; stdcall; -function ltsImageFillPattern (const aHandle, aPattern: TltsImageHandle; const aX, aY: Integer; const aMask: TtsColorChannels; const aModes: TtsImageModes): TltsErrorCode; stdcall; -function ltsImageBlend (const aHandle, aSource: TltsImageHandle; const aX, aY: Integer; const aBlendFunc: TltsImageBlendFunc; aArgs: Pointer): TltsErrorCode; stdcall; -function ltsImageBlur (const aHandle: TltsImageHandle; const aHorzRad, aHorzStr, aVertRad, aVertStr: Single; const aMask: TtsColorChannels): TltsErrorCode; stdcall; -function ltsImageDestroy (const aHandle: TltsImageHandle): TltsErrorCode; stdcall; + TltsImageLoadFunc = procedure(aHandle: TltsImageHandle; X, Y: Integer; var aPixel: TtsColor4f; aArgs: Pointer); stdcall; + TltsImageBlendFunc = procedure(aHandle: TltsImageHandle; aSrc, aDst: TtsColor4f; out aResult: TtsColor4f; aArgs: Pointer); stdcall; + +function ltsImageCreate (aContext: TltsContextHandle): TltsImageHandle; stdcall; +function ltsImageIsEmpty (aHandle: TltsImageHandle; var aValue: Boolean): TltsErrorCode; stdcall; +function ltsImageGetWidth (aHandle: TltsImageHandle): Integer; stdcall; +function ltsImageGetHeight (aHandle: TltsImageHandle): Integer; stdcall; +function ltsImageGetLineSize (aHandle: TltsImageHandle): Integer; stdcall; +function ltsImageGetDataSize (aHandle: TltsImageHandle): Integer; stdcall; +function ltsImageGetFormat (aHandle: TltsImageHandle; var aValue: TtsFormat): TltsErrorCode; stdcall; +function ltsImageGetData (aHandle: TltsImageHandle): Pointer; stdcall; +function ltsImageGetScanline (aHandle: TltsImageHandle; aIndex: Integer): Pointer; stdcall; +function ltsImageGetPixelAt (aHandle: TltsImageHandle; aX, aY: Integer; var aColor: TtsColor4f): TltsErrorCode; stdcall; +function ltsImageAssign (aHandle, aSource: TltsImageHandle): TltsErrorCode; stdcall; +function ltsImageCreateEmpty (aHandle: TltsImageHandle; aFormat: TtsFormat; aWidth, aHeight: Integer): TltsErrorCode; stdcall; +function ltsImageLoadFromFunc (aHandle: TltsImageHandle; aCallback: TltsImageLoadFunc; aArgs: Pointer): TltsErrorCode; stdcall; +function ltsImageResize (aHandle: TltsImageHandle; aWidth, aHeight, aX, aY: Integer): TltsErrorCode; stdcall; +function ltsImageFillColor (aHandle: TltsImageHandle; aColor: TtsColor4f; aMask: TtsColorChannels; aModes: TtsImageModes): TltsErrorCode; stdcall; +function ltsImageFillPattern (aHandle, aPattern: TltsImageHandle; aX, aY: Integer; aMask: TtsColorChannels; aModes: TtsImageModes): TltsErrorCode; stdcall; +function ltsImageBlend (aHandle, aSource: TltsImageHandle; aX, aY: Integer; aBlendFunc: TltsImageBlendFunc; aArgs: Pointer): TltsErrorCode; stdcall; +function ltsImageBlur (aHandle: TltsImageHandle; aHorzRad, aHorzStr, aVertRad, aVertStr: Single; aMask: TtsColorChannels): TltsErrorCode; stdcall; +function ltsImageDestroy (aHandle: TltsImageHandle): TltsErrorCode; stdcall; implementation @@ -66,13 +66,13 @@ var p: PBlendArgs; begin p := PBlendArgs(aArgs); - result := p^.callback(p^.handle, aSrc, aDst, p^.args); + p^.callback(p^.handle, aSrc, aDst, result, p^.args); end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //ltsImage////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageCreate(const aContext: TltsContextHandle): TltsImageHandle; stdcall; +function ltsImageCreate(aContext: TltsContextHandle): TltsImageHandle; stdcall; var img: TtsImage; c: TtsContext; @@ -93,7 +93,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageIsEmpty(const aHandle: TltsImageHandle; var aValue: Boolean): TltsErrorCode; stdcall; +function ltsImageIsEmpty(aHandle: TltsImageHandle; var aValue: Boolean): TltsErrorCode; stdcall; var img: TtsImage; begin @@ -111,7 +111,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageGetWidth(const aHandle: TltsImageHandle): Integer; stdcall; +function ltsImageGetWidth(aHandle: TltsImageHandle): Integer; stdcall; var img: TtsImage; begin @@ -128,7 +128,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageGetHeight(const aHandle: TltsImageHandle): Integer; stdcall; +function ltsImageGetHeight(aHandle: TltsImageHandle): Integer; stdcall; var img: TtsImage; begin @@ -145,7 +145,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageGetLineSize(const aHandle: TltsImageHandle): Integer; stdcall; +function ltsImageGetLineSize(aHandle: TltsImageHandle): Integer; stdcall; var img: TtsImage; begin @@ -162,7 +162,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageGetDataSize(const aHandle: TltsImageHandle): Integer; stdcall; +function ltsImageGetDataSize(aHandle: TltsImageHandle): Integer; stdcall; var img: TtsImage; begin @@ -179,7 +179,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageGetFormat(const aHandle: TltsImageHandle; var aValue: TtsFormat): TltsErrorCode; stdcall; +function ltsImageGetFormat(aHandle: TltsImageHandle; var aValue: TtsFormat): TltsErrorCode; stdcall; var img: TtsImage; begin @@ -197,7 +197,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageGetData(const aHandle: TltsImageHandle): Pointer; stdcall; +function ltsImageGetData(aHandle: TltsImageHandle): Pointer; stdcall; var img: TtsImage; begin @@ -214,7 +214,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageGetScanline(const aHandle: TltsImageHandle; const aIndex: Integer): Pointer; stdcall; +function ltsImageGetScanline(aHandle: TltsImageHandle; aIndex: Integer): Pointer; stdcall; var img: TtsImage; begin @@ -234,7 +234,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageGetPixelAt(const aHandle: TltsImageHandle; const aX, aY: Integer; var aColor: TtsColor4f): TltsErrorCode; stdcall; +function ltsImageGetPixelAt(aHandle: TltsImageHandle; aX, aY: Integer; var aColor: TtsColor4f): TltsErrorCode; stdcall; var img: TtsImage; begin @@ -256,7 +256,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageAssign(const aHandle, aSource: TltsImageHandle): TltsErrorCode; stdcall; +function ltsImageAssign(aHandle, aSource: TltsImageHandle): TltsErrorCode; stdcall; var img, src: TtsImage; begin @@ -274,7 +274,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageCreateEmpty(const aHandle: TltsImageHandle; const aFormat: TtsFormat; const aWidth, aHeight: Integer): TltsErrorCode; stdcall; +function ltsImageCreateEmpty(aHandle: TltsImageHandle; aFormat: TtsFormat; aWidth, aHeight: Integer): TltsErrorCode; stdcall; var img: TtsImage; begin @@ -301,7 +301,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageLoadFromFunc(const aHandle: TltsImageHandle; const aCallback: TltsImageLoadFunc; aArgs: Pointer): TltsErrorCode; stdcall; +function ltsImageLoadFromFunc(aHandle: TltsImageHandle; aCallback: TltsImageLoadFunc; aArgs: Pointer): TltsErrorCode; stdcall; var img: TtsImage; la: TLoadArgs; @@ -324,7 +324,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageResize(const aHandle: TltsImageHandle; const aWidth, aHeight, aX, aY: Integer): TltsErrorCode; stdcall; +function ltsImageResize(aHandle: TltsImageHandle; aWidth, aHeight, aX, aY: Integer): TltsErrorCode; stdcall; var img: TtsImage; begin @@ -349,7 +349,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageFillColor(const aHandle: TltsImageHandle; const aColor: TtsColor4f; const aMask: TtsColorChannels; const aModes: TtsImageModes): TltsErrorCode; stdcall; +function ltsImageFillColor(aHandle: TltsImageHandle; aColor: TtsColor4f; aMask: TtsColorChannels; aModes: TtsImageModes): TltsErrorCode; stdcall; var img: TtsImage; begin @@ -367,7 +367,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageFillPattern(const aHandle, aPattern: TltsImageHandle; const aX, aY: Integer; const aMask: TtsColorChannels; const aModes: TtsImageModes): TltsErrorCode; stdcall; +function ltsImageFillPattern(aHandle, aPattern: TltsImageHandle; aX, aY: Integer; aMask: TtsColorChannels; aModes: TtsImageModes): TltsErrorCode; stdcall; var img, pattern: TtsImage; begin @@ -385,7 +385,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageBlend(const aHandle, aSource: TltsImageHandle; const aX, aY: Integer; const aBlendFunc: TltsImageBlendFunc; aArgs: Pointer): TltsErrorCode; stdcall; +function ltsImageBlend(aHandle, aSource: TltsImageHandle; aX, aY: Integer; aBlendFunc: TltsImageBlendFunc; aArgs: Pointer): TltsErrorCode; stdcall; var img, src: TtsImage; ba: TBlendArgs; @@ -408,7 +408,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageBlur(const aHandle: TltsImageHandle; const aHorzRad, aHorzStr, aVertRad, aVertStr: Single; const aMask: TtsColorChannels): TltsErrorCode; stdcall; +function ltsImageBlur(aHandle: TltsImageHandle; aHorzRad, aHorzStr, aVertRad, aVertStr: Single; aMask: TtsColorChannels): TltsErrorCode; stdcall; var img: TtsImage; horz, vert: TtsKernel1D; @@ -435,7 +435,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsImageDestroy(const aHandle: TltsImageHandle): TltsErrorCode; stdcall; +function ltsImageDestroy(aHandle: TltsImageHandle): TltsErrorCode; stdcall; var img: TtsImage; begin diff --git a/ultsPostProcessor.pas b/ultsPostProcessor.pas index 0ca4b5f..ece9450 100644 --- a/ultsPostProcessor.pas +++ b/ultsPostProcessor.pas @@ -25,21 +25,21 @@ type constructor Create(const aContext: TtsContext; const aData: TltsPostProcessorCustomData); end; -function ltsPostProcessorAddRange (const aHandle: TltsPostProcessorHandle; const aUsage: TtsCharRangeUsage; const aStart, aStop: WideChar): TltsErrorCode; stdcall; -function ltsPostProcessorAddChars (const aHandle: TltsPostProcessorHandle; const aUsage: TtsCharRangeUsage; const aChars: PWideChar): TltsErrorCode; stdcall; -function ltsPostProcessorClearRanges (const aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; -function ltsPostProcessorExecute (const aHandle: TltsPostProcessorHandle; const aChar: TltsCharHandle; const aImage: TltsImageHandle): TltsErrorCode; stdcall; +function ltsPostProcessorAddRange (aHandle: TltsPostProcessorHandle; aUsage: TtsCharRangeUsage; aStart, aStop: WideChar): TltsErrorCode; stdcall; +function ltsPostProcessorAddChars (aHandle: TltsPostProcessorHandle; aUsage: TtsCharRangeUsage; aChars: PWideChar): TltsErrorCode; stdcall; +function ltsPostProcessorClearRanges (aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; +function ltsPostProcessorExecute (aHandle: TltsPostProcessorHandle; aChar: TltsCharHandle; aImage: TltsImageHandle): TltsErrorCode; stdcall; -function ltsPostProcessorFillColorCreate (const aContext: TltsContextHandle; const aColor: TtsColor4f; - const aModes: TtsImageModes; const aChannels: TtsColorChannels): TltsPostProcessorHandle; stdcall; -function ltsPostProcessorFillPatterCreate (const aContext: TltsContextHandle; const aPattern: TltsImageHandle; const aOwnsPatter: Boolean; - const aPosition: TtsPosition; const aModes: TtsImageModes; const aChannels: TtsColorChannels): TltsPostProcessorHandle; stdcall; -function ltsPostProcessorBorderCreate (const aContext: TltsContextHandle; const aWidth, aStrength: Single; - const aColor: TtsColor4f; const aKeepSize: Boolean): TltsPostProcessorHandle; stdcall; -function ltsPostProcessorShadowCreate (const aContext: TltsContextHandle; const aRadius, aStrength: Single; - const aOffset: TtsPosition; const aColor: TtsColor4f): TltsPostProcessorHandle; stdcall; -function ltsPostProcessorCustomCreate (const aContext: TltsContextHandle; const aData: PltsPostProcessorCustomData): TltsPostProcessorHandle; stdcall; -function ltsPostProcessorDestroy (const aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; +function ltsPostProcessorFillColorCreate (aContext: TltsContextHandle; aColor: TtsColor4f; + aModes: TtsImageModes; aChannels: TtsColorChannels): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorFillPatterCreate (aContext: TltsContextHandle; aPattern: TltsImageHandle; aOwnsPatter: Boolean; + aPosition: TtsPosition; aModes: TtsImageModes; aChannels: TtsColorChannels): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorBorderCreate (aContext: TltsContextHandle; aWidth, aStrength: Single; + aColor: TtsColor4f; aKeepSize: Boolean): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorShadowCreate (aContext: TltsContextHandle; aRadius, aStrength: Single; + aOffset: TtsPosition; aColor: TtsColor4f): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorCustomCreate (aContext: TltsContextHandle; constref aData: TltsPostProcessorCustomData): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorDestroy (aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; implementation @@ -49,7 +49,7 @@ uses //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //ltsPostProcessor////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorAddRange(const aHandle: TltsPostProcessorHandle; const aUsage: TtsCharRangeUsage; const aStart, aStop: WideChar): TltsErrorCode; stdcall; +function ltsPostProcessorAddRange(aHandle: TltsPostProcessorHandle; aUsage: TtsCharRangeUsage; aStart, aStop: WideChar): TltsErrorCode; stdcall; var pp: TtsPostProcessor; begin @@ -67,7 +67,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorAddChars(const aHandle: TltsPostProcessorHandle; const aUsage: TtsCharRangeUsage; const aChars: PWideChar): TltsErrorCode; stdcall; +function ltsPostProcessorAddChars(aHandle: TltsPostProcessorHandle; aUsage: TtsCharRangeUsage; aChars: PWideChar): TltsErrorCode; stdcall; var pp: TtsPostProcessor; begin @@ -85,7 +85,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorClearRanges(const aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; +function ltsPostProcessorClearRanges(aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; var pp: TtsPostProcessor; begin @@ -103,7 +103,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorExecute(const aHandle: TltsPostProcessorHandle; const aChar: TltsCharHandle; const aImage: TltsImageHandle): TltsErrorCode; stdcall; +function ltsPostProcessorExecute(aHandle: TltsPostProcessorHandle; aChar: TltsCharHandle; aImage: TltsImageHandle): TltsErrorCode; stdcall; var pp: TtsPostProcessor; c: TtsChar; @@ -125,7 +125,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorFillColorCreate(const aContext: TltsContextHandle; const aColor: TtsColor4f; const aModes: TtsImageModes; const aChannels: TtsColorChannels): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorFillColorCreate(aContext: TltsContextHandle; aColor: TtsColor4f; aModes: TtsImageModes; aChannels: TtsColorChannels): TltsPostProcessorHandle; stdcall; var c: TtsContext; pp: TtsPostProcessor; @@ -146,7 +146,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorFillPatterCreate(const aContext: TltsContextHandle; const aPattern: TltsImageHandle; const aOwnsPatter: Boolean; const aPosition: TtsPosition; const aModes: TtsImageModes; const aChannels: TtsColorChannels): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorFillPatterCreate(aContext: TltsContextHandle; aPattern: TltsImageHandle; aOwnsPatter: Boolean; aPosition: TtsPosition; aModes: TtsImageModes; aChannels: TtsColorChannels): TltsPostProcessorHandle; stdcall; var c: TtsContext; img: TtsImage; @@ -169,7 +169,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorBorderCreate(const aContext: TltsContextHandle; const aWidth, aStrength: Single; const aColor: TtsColor4f; const aKeepSize: Boolean): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorBorderCreate(aContext: TltsContextHandle; aWidth, aStrength: Single; aColor: TtsColor4f; aKeepSize: Boolean): TltsPostProcessorHandle; stdcall; var c: TtsContext; pp: TtsPostProcessor; @@ -190,7 +190,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorShadowCreate(const aContext: TltsContextHandle; const aRadius, aStrength: Single; const aOffset: TtsPosition; const aColor: TtsColor4f): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorShadowCreate(aContext: TltsContextHandle; aRadius, aStrength: Single; aOffset: TtsPosition; aColor: TtsColor4f): TltsPostProcessorHandle; stdcall; var c: TtsContext; pp: TtsPostProcessor; @@ -211,17 +211,15 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorCustomCreate(const aContext: TltsContextHandle; const aData: PltsPostProcessorCustomData): TltsPostProcessorHandle; stdcall; +function ltsPostProcessorCustomCreate(aContext: TltsContextHandle; constref aData: TltsPostProcessorCustomData): TltsPostProcessorHandle; stdcall; var c: TtsContext; pp: TtsPostProcessor; begin try result := nil; - if not Assigned(aData) then begin - SetLastError(ltsErrInvalidValue, 'parameter ''aData'' is not assigned'); - end else if CheckContextHandle(aContext, c) then begin - pp := TltsPostProcessorCustom.Create(c, aData^); + if CheckContextHandle(aContext, c) then begin + pp := TltsPostProcessorCustom.Create(c, aData); AddReference(ltsObjTypePostProcessor, pp); result := pp; end; @@ -234,7 +232,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsPostProcessorDestroy(const aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; +function ltsPostProcessorDestroy(aHandle: TltsPostProcessorHandle): TltsErrorCode; stdcall; var pp: TtsPostProcessor; begin diff --git a/ultsRenderer.pas b/ultsRenderer.pas index fff16f3..6117777 100644 --- a/ultsRenderer.pas +++ b/ultsRenderer.pas @@ -37,14 +37,14 @@ type FreeRef: TltsRendererCustomFreeRef; end; -function ltsRendererCreate (const aHandle: TltsContextHandle; const aType: TltsRendererType; const aFormat: TtsFormat): TltsRendererHandle; stdcall; -function ltsRendererCustomCreate (const aHandle: TltsContextHandle; const aFormat: TtsFormat; const aData: PltsRendererCustomData): TltsRendererHandle; stdcall; -function ltsRendererBeginBlock (const aHandle: TltsRendererHandle; const aTop, aLeft, aWidth, aHeight: Integer; const aFlags: TtsBlockFlags): TltsTextBlockHandle; stdcall; -function ltsRendererEndBlock (const aHandle: TltsRendererHandle; const aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; -function ltsRendererAbortBlock (const aHandle: TltsRendererHandle; const aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; -function ltsRendererGetTextWidthA(const aHandle: TltsRendererHandle; const aFont: TltsFontHandle; const aText: PAnsiChar): Integer; stdcall; -function ltsRendererGetTextWidthW(const aHandle: TltsRendererHandle; const aFont: TltsFontHandle; const aText: PWideChar): Integer; stdcall; -function ltsRendererDestroy (const aHandle: TltsRendererHandle): TltsErrorCode; stdcall; +function ltsRendererCreate (aHandle: TltsContextHandle; aType: TltsRendererType; aFormat: TtsFormat): TltsRendererHandle; stdcall; +function ltsRendererCustomCreate (aHandle: TltsContextHandle; aFormat: TtsFormat; constref aData: TltsRendererCustomData): TltsRendererHandle; stdcall; +function ltsRendererBeginBlock (aHandle: TltsRendererHandle; aTop, aLeft, aWidth, aHeight: Integer; aFlags: TtsBlockFlags): TltsTextBlockHandle; stdcall; +function ltsRendererEndBlock (aHandle: TltsRendererHandle; aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; +function ltsRendererAbortBlock (aHandle: TltsRendererHandle; aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; +function ltsRendererGetTextWidthA(aHandle: TltsRendererHandle; aFont: TltsFontHandle; aText: PAnsiChar): Integer; stdcall; +function ltsRendererGetTextWidthW(aHandle: TltsRendererHandle; aFont: TltsFontHandle; aText: PWideChar): Integer; stdcall; +function ltsRendererDestroy (aHandle: TltsRendererHandle): TltsErrorCode; stdcall; implementation @@ -212,7 +212,7 @@ end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Renderer////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsRendererCreate(const aHandle: TltsContextHandle; const aType: TltsRendererType; const aFormat: TtsFormat): TltsRendererHandle; stdcall; +function ltsRendererCreate(aHandle: TltsContextHandle; aType: TltsRendererType; aFormat: TtsFormat): TltsRendererHandle; stdcall; var c: TtsContext; r: TtsRenderer; @@ -245,7 +245,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsRendererCustomCreate(const aHandle: TltsContextHandle; const aFormat: TtsFormat; const aData: PltsRendererCustomData): TltsRendererHandle; stdcall; +function ltsRendererCustomCreate(aHandle: TltsContextHandle; aFormat: TtsFormat; constref aData: TltsRendererCustomData): TltsRendererHandle; stdcall; var c: TtsContext; r: TtsRenderer; @@ -255,17 +255,12 @@ begin if not CheckContextHandle(aHandle, c) then exit; - if not Assigned(aData) then begin - SetLastError(ltsErrInvalidValue, Format('prameter ''aData'' is not assigned', [aFormat])); - exit; - end; - if not ValidateFormat(aFormat) then begin SetLastError(ltsErrInvalidEnum, Format('%d is not a valid format', [aFormat])); exit; end; - r := TltsRendererCustom.Create(c, aFormat, aData^); + r := TltsRendererCustom.Create(c, aFormat, aData); AddReference(ltsObjTypeRenderer, r); result := r; except @@ -277,7 +272,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsRendererBeginBlock(const aHandle: TltsRendererHandle; const aTop, aLeft, aWidth, aHeight: Integer; const aFlags: TtsBlockFlags): TltsTextBlockHandle; stdcall; +function ltsRendererBeginBlock(aHandle: TltsRendererHandle; aTop, aLeft, aWidth, aHeight: Integer; aFlags: TtsBlockFlags): TltsTextBlockHandle; stdcall; var r: TtsRenderer; b: TtsTextBlock; @@ -298,7 +293,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsRendererEndBlock(const aHandle: TltsRendererHandle; const aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; +function ltsRendererEndBlock(aHandle: TltsRendererHandle; aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; var r: TtsRenderer; b: TtsTextBlock; @@ -319,7 +314,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsRendererAbortBlock(const aHandle: TltsRendererHandle; const aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; +function ltsRendererAbortBlock(aHandle: TltsRendererHandle; aBlock: TltsTextBlockHandle): TltsErrorCode; stdcall; var r: TtsRenderer; b: TtsTextBlock; @@ -340,7 +335,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsRendererGetTextWidthA(const aHandle: TltsRendererHandle; const aFont: TltsFontHandle; const aText: PAnsiChar): Integer; stdcall; +function ltsRendererGetTextWidthA(aHandle: TltsRendererHandle; aFont: TltsFontHandle; aText: PAnsiChar): Integer; stdcall; var r: TtsRenderer; f: TtsFont; @@ -358,7 +353,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsRendererGetTextWidthW(const aHandle: TltsRendererHandle; const aFont: TltsFontHandle; const aText: PWideChar): Integer; stdcall; +function ltsRendererGetTextWidthW(aHandle: TltsRendererHandle; aFont: TltsFontHandle; aText: PWideChar): Integer; stdcall; var r: TtsRenderer; f: TtsFont; @@ -376,7 +371,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsRendererDestroy(const aHandle: TltsRendererHandle): TltsErrorCode; stdcall; +function ltsRendererDestroy(aHandle: TltsRendererHandle): TltsErrorCode; stdcall; var r: TtsRenderer; begin diff --git a/ultsTextBlock.pas b/ultsTextBlock.pas index a97d709..5568ab6 100644 --- a/ultsTextBlock.pas +++ b/ultsTextBlock.pas @@ -9,35 +9,35 @@ uses utsTextSuite, ultsTypes; -function ltsTextBlockGetRect (const aHandle: TltsTextBlockHandle; var aValue: TtsRect): TltsErrorCode; stdcall; -function ltsTextBlockGetWidth (const aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; -function ltsTextBlockGetHeight (const aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; -function ltsTextBlockGetFlags (const aHandle: TltsTextBlockHandle; var aValue: TtsBlockFlags): TltsErrorCode; stdcall; - -function ltsTextBlockGetTop (const aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; -function ltsTextBlockGetLeft (const aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; -function ltsTextBlockGetVertAlign (const aHandle: TltsTextBlockHandle; var aValue: TtsVertAlignment): TltsErrorCode; stdcall; -function ltsTextBlockGetHorzAlign (const aHandle: TltsTextBlockHandle; var aValue: TtsHorzAlignment): TltsErrorCode; stdcall; -function ltsTextBlockGetClipping (const aHandle: TltsTextBlockHandle; var aValue: TtsClipping): TltsErrorCode; stdcall; -function ltsTextBlockGetColor (const aHandle: TltsTextBlockHandle; var aValue: TtsColor4f): TltsErrorCode; stdcall; -function ltsTextBlockGetFont (const aHandle: TltsTextBlockHandle; var aValue: TltsFontHandle): TltsErrorCode; stdcall; - -function ltsTextBlockSetTop (const aHandle: TltsTextBlockHandle; const aValue: Integer): TltsErrorCode; stdcall; -function ltsTextBlockSetLeft (const aHandle: TltsTextBlockHandle; const aValue: Integer): TltsErrorCode; stdcall; -function ltsTextBlockSetVertAlign (const aHandle: TltsTextBlockHandle; const aValue: TtsVertAlignment): TltsErrorCode; stdcall; -function ltsTextBlockSetHorzAlign (const aHandle: TltsTextBlockHandle; const aValue: TtsHorzAlignment): TltsErrorCode; stdcall; -function ltsTextBlockSetClipping (const aHandle: TltsTextBlockHandle; const aValue: TtsClipping): TltsErrorCode; stdcall; -function ltsTextBlockSetColor (const aHandle: TltsTextBlockHandle; const aValue: TtsColor4f): TltsErrorCode; stdcall; -function ltsTextBlockSetFont (const aHandle: TltsTextBlockHandle; const aValue: TltsFontHandle): TltsErrorCode; stdcall; - -function ltsTextBlockGetActualHeight(const aHandle: TltsTextBlockHandle): Integer; stdcall; -function ltsTextBlockGetTextWidthA (const aHandle: TltsTextBlockHandle; const aText: PAnsiChar): Integer; stdcall; -function ltsTextBlockGetTextWidthW (const aHandle: TltsTextBlockHandle; const aText: PWideChar): Integer; stdcall; - -function ltsTextBlockTextOutA (const aHandle: TltsTextBlockHandle; const aText: PAnsiChar): TltsErrorCode; stdcall; -function ltsTextBlockTextOutW (const aHandle: TltsTextBlockHandle; const aText: PWideChar): TltsErrorCode; stdcall; - -function ltsTextBlockDestroy (const aHandle: TltsTextBlockHandle): TltsErrorCode; stdcall; +function ltsTextBlockGetRect (aHandle: TltsTextBlockHandle; var aValue: TtsRect): TltsErrorCode; stdcall; +function ltsTextBlockGetWidth (aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockGetHeight (aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockGetFlags (aHandle: TltsTextBlockHandle; var aValue: TtsBlockFlags): TltsErrorCode; stdcall; + +function ltsTextBlockGetTop (aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockGetLeft (aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockGetVertAlign (aHandle: TltsTextBlockHandle; var aValue: TtsVertAlignment): TltsErrorCode; stdcall; +function ltsTextBlockGetHorzAlign (aHandle: TltsTextBlockHandle; var aValue: TtsHorzAlignment): TltsErrorCode; stdcall; +function ltsTextBlockGetClipping (aHandle: TltsTextBlockHandle; var aValue: TtsClipping): TltsErrorCode; stdcall; +function ltsTextBlockGetColor (aHandle: TltsTextBlockHandle; var aValue: TtsColor4f): TltsErrorCode; stdcall; +function ltsTextBlockGetFont (aHandle: TltsTextBlockHandle; var aValue: TltsFontHandle): TltsErrorCode; stdcall; + +function ltsTextBlockSetTop (aHandle: TltsTextBlockHandle; aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockSetLeft (aHandle: TltsTextBlockHandle; aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockSetVertAlign (aHandle: TltsTextBlockHandle; aValue: TtsVertAlignment): TltsErrorCode; stdcall; +function ltsTextBlockSetHorzAlign (aHandle: TltsTextBlockHandle; aValue: TtsHorzAlignment): TltsErrorCode; stdcall; +function ltsTextBlockSetClipping (aHandle: TltsTextBlockHandle; aValue: TtsClipping): TltsErrorCode; stdcall; +function ltsTextBlockSetColor (aHandle: TltsTextBlockHandle; aValue: TtsColor4f): TltsErrorCode; stdcall; +function ltsTextBlockSetFont (aHandle: TltsTextBlockHandle; aValue: TltsFontHandle): TltsErrorCode; stdcall; + +function ltsTextBlockGetActualHeight(aHandle: TltsTextBlockHandle): Integer; stdcall; +function ltsTextBlockGetTextWidthA (aHandle: TltsTextBlockHandle; aText: PAnsiChar): Integer; stdcall; +function ltsTextBlockGetTextWidthW (aHandle: TltsTextBlockHandle; aText: PWideChar): Integer; stdcall; + +function ltsTextBlockTextOutA (aHandle: TltsTextBlockHandle; aText: PAnsiChar): TltsErrorCode; stdcall; +function ltsTextBlockTextOutW (aHandle: TltsTextBlockHandle; aText: PWideChar): TltsErrorCode; stdcall; + +function ltsTextBlockDestroy (aHandle: TltsTextBlockHandle): TltsErrorCode; stdcall; implementation @@ -47,7 +47,7 @@ uses //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //TextBlock///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetRect(const aHandle: TltsTextBlockHandle; var aValue: TtsRect): TltsErrorCode; stdcall; +function ltsTextBlockGetRect(aHandle: TltsTextBlockHandle; var aValue: TtsRect): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -65,7 +65,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetWidth(const aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockGetWidth(aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -83,7 +83,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetHeight(const aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockGetHeight(aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -101,7 +101,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetFlags(const aHandle: TltsTextBlockHandle; var aValue: TtsBlockFlags): TltsErrorCode; stdcall; +function ltsTextBlockGetFlags(aHandle: TltsTextBlockHandle; var aValue: TtsBlockFlags): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -119,7 +119,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetTop(const aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockGetTop(aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -137,7 +137,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetLeft(const aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockGetLeft(aHandle: TltsTextBlockHandle; var aValue: Integer): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -155,7 +155,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetVertAlign(const aHandle: TltsTextBlockHandle; var aValue: TtsVertAlignment): TltsErrorCode; stdcall; +function ltsTextBlockGetVertAlign(aHandle: TltsTextBlockHandle; var aValue: TtsVertAlignment): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -173,7 +173,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetHorzAlign(const aHandle: TltsTextBlockHandle; var aValue: TtsHorzAlignment): TltsErrorCode; stdcall; +function ltsTextBlockGetHorzAlign(aHandle: TltsTextBlockHandle; var aValue: TtsHorzAlignment): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -191,7 +191,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetClipping(const aHandle: TltsTextBlockHandle; var aValue: TtsClipping): TltsErrorCode; stdcall; +function ltsTextBlockGetClipping(aHandle: TltsTextBlockHandle; var aValue: TtsClipping): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -209,7 +209,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetColor(const aHandle: TltsTextBlockHandle; var aValue: TtsColor4f): TltsErrorCode; stdcall; +function ltsTextBlockGetColor(aHandle: TltsTextBlockHandle; var aValue: TtsColor4f): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -227,7 +227,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetFont(const aHandle: TltsTextBlockHandle; var aValue: TltsFontHandle): TltsErrorCode; stdcall; +function ltsTextBlockGetFont(aHandle: TltsTextBlockHandle; var aValue: TltsFontHandle): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -245,7 +245,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockSetTop(const aHandle: TltsTextBlockHandle; const aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockSetTop(aHandle: TltsTextBlockHandle; aValue: Integer): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -263,7 +263,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockSetLeft(const aHandle: TltsTextBlockHandle; const aValue: Integer): TltsErrorCode; stdcall; +function ltsTextBlockSetLeft(aHandle: TltsTextBlockHandle; aValue: Integer): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -281,7 +281,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockSetVertAlign(const aHandle: TltsTextBlockHandle; const aValue: TtsVertAlignment): TltsErrorCode; stdcall; +function ltsTextBlockSetVertAlign(aHandle: TltsTextBlockHandle; aValue: TtsVertAlignment): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -299,7 +299,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockSetHorzAlign(const aHandle: TltsTextBlockHandle; const aValue: TtsHorzAlignment): TltsErrorCode; stdcall; +function ltsTextBlockSetHorzAlign(aHandle: TltsTextBlockHandle; aValue: TtsHorzAlignment): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -317,7 +317,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockSetClipping(const aHandle: TltsTextBlockHandle; const aValue: TtsClipping): TltsErrorCode; stdcall; +function ltsTextBlockSetClipping(aHandle: TltsTextBlockHandle; aValue: TtsClipping): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -335,7 +335,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockSetColor(const aHandle: TltsTextBlockHandle; const aValue: TtsColor4f): TltsErrorCode; stdcall; +function ltsTextBlockSetColor(aHandle: TltsTextBlockHandle; aValue: TtsColor4f): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -353,7 +353,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockSetFont(const aHandle: TltsTextBlockHandle; const aValue: TltsFontHandle): TltsErrorCode; stdcall; +function ltsTextBlockSetFont(aHandle: TltsTextBlockHandle; aValue: TltsFontHandle): TltsErrorCode; stdcall; var b: TtsTextBlock; f: TtsFont; @@ -372,7 +372,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetActualHeight(const aHandle: TltsTextBlockHandle): Integer; stdcall; +function ltsTextBlockGetActualHeight(aHandle: TltsTextBlockHandle): Integer; stdcall; var b: TtsTextBlock; begin @@ -389,7 +389,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetTextWidthA(const aHandle: TltsTextBlockHandle; const aText: PAnsiChar): Integer; stdcall; +function ltsTextBlockGetTextWidthA(aHandle: TltsTextBlockHandle; aText: PAnsiChar): Integer; stdcall; var b: TtsTextBlock; begin @@ -406,7 +406,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockGetTextWidthW(const aHandle: TltsTextBlockHandle; const aText: PWideChar): Integer; stdcall; +function ltsTextBlockGetTextWidthW(aHandle: TltsTextBlockHandle; aText: PWideChar): Integer; stdcall; var b: TtsTextBlock; begin @@ -423,7 +423,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockTextOutA(const aHandle: TltsTextBlockHandle; const aText: PAnsiChar): TltsErrorCode; stdcall; +function ltsTextBlockTextOutA(aHandle: TltsTextBlockHandle; aText: PAnsiChar): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -441,7 +441,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockTextOutW(const aHandle: TltsTextBlockHandle; const aText: PWideChar): TltsErrorCode; stdcall; +function ltsTextBlockTextOutW(aHandle: TltsTextBlockHandle; aText: PWideChar): TltsErrorCode; stdcall; var b: TtsTextBlock; begin @@ -459,7 +459,7 @@ begin end; //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -function ltsTextBlockDestroy(const aHandle: TltsTextBlockHandle): TltsErrorCode; stdcall; +function ltsTextBlockDestroy(aHandle: TltsTextBlockHandle): TltsErrorCode; stdcall; var b: TtsTextBlock; begin