diff --git a/lime/media/AudioBuffer.hx b/lime/media/AudioBuffer.hx index 4559080c4..704a24e30 100644 --- a/lime/media/AudioBuffer.hx +++ b/lime/media/AudioBuffer.hx @@ -30,6 +30,10 @@ import lime.media.fmod.FMODSound; @:access(lime._backend.native.NativeCFFI) @:access(lime.Assets) +#if hl +@:keep +#end + #if !lime_debug @:fileXml('tags="haxe,release"') @:noDebug diff --git a/lime/ui/Window.hx b/lime/ui/Window.hx index 6efa1a883..3e0c49fdf 100644 --- a/lime/ui/Window.hx +++ b/lime/ui/Window.hx @@ -17,6 +17,10 @@ import flash.display.Stage; typedef Stage = Dynamic; #end +#if hl +@:keep +#end + #if !lime_debug @:fileXml('tags="haxe,release"') @:noDebug diff --git a/project/include/app/ApplicationEvent.h b/project/include/app/ApplicationEvent.h index 78a2aca29..57eeaf122 100644 --- a/project/include/app/ApplicationEvent.h +++ b/project/include/app/ApplicationEvent.h @@ -2,6 +2,7 @@ #define LIME_APP_APPLICATION_EVENT_H +#include #include @@ -16,6 +17,15 @@ namespace lime { }; + struct HL_ApplicationEvent { + + hl_type* t; + int deltaTime; + ApplicationEventType type; + + }; + + class ApplicationEvent { public: diff --git a/project/include/graphics/ImageBuffer.h b/project/include/graphics/ImageBuffer.h index 410ccb7b5..cf160f793 100644 --- a/project/include/graphics/ImageBuffer.h +++ b/project/include/graphics/ImageBuffer.h @@ -21,12 +21,13 @@ namespace lime { bool premultiplied; bool transparent; int width; - void* __srcBitmapData; - void* __srcCanvas; - void* __srcContext; - void* __srcCustom; - void* __srcImage; - void* __srcImageData; + + vdynamic* __srcBitmapData; + vdynamic* __srcCanvas; + vdynamic* __srcContext; + vdynamic* __srcCustom; + vdynamic* __srcImage; + vdynamic* __srcImageData; }; diff --git a/project/include/graphics/RenderEvent.h b/project/include/graphics/RenderEvent.h index 1e761ef06..70591bdab 100644 --- a/project/include/graphics/RenderEvent.h +++ b/project/include/graphics/RenderEvent.h @@ -2,6 +2,7 @@ #define LIME_GRAPHICS_RENDER_EVENT_H +#include #include @@ -17,6 +18,14 @@ namespace lime { }; + struct HL_RenderEvent { + + hl_type* t; + RenderEventType type; + + }; + + class RenderEvent { public: diff --git a/project/include/math/Rectangle.h b/project/include/math/Rectangle.h index 0324c20fc..350caf484 100644 --- a/project/include/math/Rectangle.h +++ b/project/include/math/Rectangle.h @@ -11,7 +11,7 @@ namespace lime { struct HL_Rectangle { - hl_type* type; + hl_type* t; double height; double width; double x; diff --git a/project/include/math/Vector2.h b/project/include/math/Vector2.h index 4f2beb4ed..fcd113b25 100644 --- a/project/include/math/Vector2.h +++ b/project/include/math/Vector2.h @@ -2,12 +2,23 @@ #define LIME_MATH_VECTOR2_H +#include #include namespace lime { + struct HL_Vector2 { + + hl_type* t; + double length; + double x; + double y; + + }; + + class Vector2 { diff --git a/project/include/media/AudioBuffer.h b/project/include/media/AudioBuffer.h index 6817b3968..6b0480fad 100644 --- a/project/include/media/AudioBuffer.h +++ b/project/include/media/AudioBuffer.h @@ -29,6 +29,25 @@ namespace lime { + struct HL_AudioBuffer { + + hl_type* t; + int bitsPerSample; + int channels; + HL_ArrayBufferView* data; + int sampleRate; + + vdynamic* __srcAudio; + vdynamic* __srcBuffer; + vdynamic* __srcCustom; + vdynamic* __srcFMODSound; + vdynamic* __srcHowl; + vdynamic* __srcSound; + vdynamic* __srcVorbisFile; + + }; + + class AudioBuffer { diff --git a/project/include/system/CFFIPointer.h b/project/include/system/CFFIPointer.h index bf74f3c7a..0a16d2c3e 100644 --- a/project/include/system/CFFIPointer.h +++ b/project/include/system/CFFIPointer.h @@ -24,10 +24,12 @@ namespace lime { }; + typedef void (*hl_finalizer)(void* v); + value CFFIPointer (void* ptr, hx::finalizer finalizer = 0); value CFFIPointer (value handle, hx::finalizer finalizer = 0); - HL_CFFIPointer* HLCFFIPointer (void* ptr, hx::finalizer finalizer = 0); + HL_CFFIPointer* HLCFFIPointer (void* ptr, hl_finalizer finalizer = 0); } diff --git a/project/include/system/ClipboardEvent.h b/project/include/system/ClipboardEvent.h index 3c4c4fb0d..531356218 100644 --- a/project/include/system/ClipboardEvent.h +++ b/project/include/system/ClipboardEvent.h @@ -2,6 +2,7 @@ #define LIME_SYSTEM_CLIPBOARD_EVENT_H +#include #include @@ -15,6 +16,14 @@ namespace lime { }; + struct HL_ClipboardEvent { + + hl_type* t; + ClipboardEventType type; + + }; + + class ClipboardEvent { public: diff --git a/project/include/system/SensorEvent.h b/project/include/system/SensorEvent.h index fbaee6e28..602612d4c 100644 --- a/project/include/system/SensorEvent.h +++ b/project/include/system/SensorEvent.h @@ -2,6 +2,7 @@ #define LIME_SYSTEM_SENSOR_EVENT_H +#include #include @@ -15,6 +16,18 @@ namespace lime { }; + struct HL_SensorEvent { + + hl_type* t; + int id; + double x; + double y; + double z; + SensorEventType type; + + }; + + class SensorEvent { public: diff --git a/project/include/ui/DropEvent.h b/project/include/ui/DropEvent.h index 50e7c900f..3fcaa629a 100644 --- a/project/include/ui/DropEvent.h +++ b/project/include/ui/DropEvent.h @@ -2,6 +2,7 @@ #define LIME_UI_DROP_EVENT_H +#include #include @@ -15,6 +16,15 @@ namespace lime { }; + struct HL_DropEvent { + + hl_type* t; + vbyte* file; + DropEventType type; + + }; + + class DropEvent { public: diff --git a/project/include/ui/GamepadEvent.h b/project/include/ui/GamepadEvent.h index c77a39656..82979fcc8 100644 --- a/project/include/ui/GamepadEvent.h +++ b/project/include/ui/GamepadEvent.h @@ -2,6 +2,7 @@ #define LIME_UI_GAMEPAD_EVENT_H +#include #include @@ -19,6 +20,18 @@ namespace lime { }; + struct HL_GamepadEvent { + + hl_type* t; + int axis; + int button; + int id; + GamepadEventType type; + double value; + + }; + + class GamepadEvent { public: diff --git a/project/include/ui/JoystickEvent.h b/project/include/ui/JoystickEvent.h index b783472d2..acd60576c 100644 --- a/project/include/ui/JoystickEvent.h +++ b/project/include/ui/JoystickEvent.h @@ -2,6 +2,7 @@ #define LIME_UI_JOYSTICK_EVENT_H +#include #include @@ -21,6 +22,19 @@ namespace lime { }; + struct HL_JoystickEvent { + + hl_type* t; + int id; + int index; + JoystickEventType type; + int value; + double x; + double y; + + }; + + class JoystickEvent { public: diff --git a/project/include/ui/KeyEvent.h b/project/include/ui/KeyEvent.h index 6c7c33b88..7ea7b96cc 100644 --- a/project/include/ui/KeyEvent.h +++ b/project/include/ui/KeyEvent.h @@ -2,6 +2,7 @@ #define LIME_UI_KEY_EVENT_H +#include #include #include @@ -17,6 +18,17 @@ namespace lime { }; + struct HL_KeyEvent { + + hl_type* t; + int keyCode; + int modifier; + KeyEventType type; + int windowID; + + }; + + class KeyEvent { public: diff --git a/project/include/ui/MouseEvent.h b/project/include/ui/MouseEvent.h index 5f2cc6f83..097405d20 100644 --- a/project/include/ui/MouseEvent.h +++ b/project/include/ui/MouseEvent.h @@ -2,6 +2,7 @@ #define LIME_UI_MOUSE_EVENT_H +#include #include #include @@ -19,6 +20,20 @@ namespace lime { }; + struct HL_MouseEvent { + + hl_type* t; + int button; + double movementX; + double movementY; + MouseEventType type; + int windowID; + double x; + double y; + + }; + + class MouseEvent { public: diff --git a/project/include/ui/TextEvent.h b/project/include/ui/TextEvent.h index d63b967df..4a55dc1c7 100644 --- a/project/include/ui/TextEvent.h +++ b/project/include/ui/TextEvent.h @@ -2,6 +2,7 @@ #define LIME_UI_TEXT_EVENT_H +#include #include #include @@ -17,6 +18,19 @@ namespace lime { }; + struct HL_TextEvent { + + hl_type* t; + int id; + int length; + int start; + vbyte* text; + TextEventType type; + int windowID; + + }; + + class TextEvent { public: diff --git a/project/include/ui/TouchEvent.h b/project/include/ui/TouchEvent.h index 9b3ca9a44..6374f2889 100644 --- a/project/include/ui/TouchEvent.h +++ b/project/include/ui/TouchEvent.h @@ -2,6 +2,7 @@ #define LIME_UI_TOUCH_EVENT_H +#include #include #include @@ -18,6 +19,21 @@ namespace lime { }; + struct HL_TouchEvent { + + hl_type* t; + int device; + double dx; + double dy; + int id; + double pressure; + TouchEventType type; + double x; + double y; + + }; + + class TouchEvent { public: diff --git a/project/include/ui/Window.h b/project/include/ui/Window.h index 027e358c8..a11e51a7a 100644 --- a/project/include/ui/Window.h +++ b/project/include/ui/Window.h @@ -6,6 +6,7 @@ #undef CreateWindow #endif +#include #include #include #include @@ -15,6 +16,57 @@ namespace lime { + // struct HL_Window { + + // hl_type* t; + // HL_Application* application; + // bool borderless; + // vdynamic* config; + // vdynamic* display; + // int id; + // vdynamic* onActivate; + // vdynamic* onClose; + // vdynamic* onCreate; + // vdynamic* onDeactivate; + // vdynamic* onDropFile; + // vdynamic* onEnter; + // vdynamic* onFocusIn; + // vdynamic* onFocusOut; + // vdynamic* onFullscreen; + // vdynamic* onKeyDown; + // vdynamic* onKeyUp; + // vdynamic* onLeave; + // vdynamic* onMinimize; + // vdynamic* onMouseDown; + // vdynamic* onMouseMove; + // vdynamic* onMouseMoveRelative; + // vdynamic* onMouseUp; + // vdynamic* onMouseWheel; + // vdynamic* onMove; + // vdynamic* onResize; + // vdynamic* onRestore; + // vdynamic* onTextEdit; + // vdynamic* onTextInput; + // HL_Renderer* renderer; + // double scale; + // vdynamic* stage; + + // vdynamic* backend; + // bool __borderless; + // bool __fullscreen; + // int __height; + // bool __maximized; + // bool __minimized; + // bool __resizable; + // double __scale; + // vbyte* __title; + // int __width; + // int __x; + // int __y; + + // }; + + class Window { diff --git a/project/include/ui/WindowEvent.h b/project/include/ui/WindowEvent.h index c5e94503e..77fd552bb 100644 --- a/project/include/ui/WindowEvent.h +++ b/project/include/ui/WindowEvent.h @@ -2,6 +2,7 @@ #define LIME_UI_WINDOW_EVENT_H +#include #include #include @@ -27,6 +28,19 @@ namespace lime { }; + struct HL_WindowEvent { + + hl_type* t; + int height; + WindowEventType type; + int width; + int windowID; + int x; + int y; + + }; + + class WindowEvent { public: diff --git a/project/src/ExternalInterface.cpp b/project/src/ExternalInterface.cpp index 9c4082f8b..f4611c8fc 100644 --- a/project/src/ExternalInterface.cpp +++ b/project/src/ExternalInterface.cpp @@ -68,6 +68,13 @@ namespace lime { } + void hl_gc_application (Application* application) { + + delete application; + + } + + void gc_file_watcher (value handle) { #ifdef LIME_EFSW @@ -78,6 +85,15 @@ namespace lime { } + void hl_gc_file_watcher (FileWatcher* watcher) { + + #ifdef LIME_EFSW + delete watcher; + #endif + + } + + void gc_font (value handle) { #ifdef LIME_FREETYPE @@ -88,6 +104,15 @@ namespace lime { } + void hl_gc_font (Font* font) { + + #ifdef LIME_FREETYPE + delete font; + #endif + + } + + void gc_renderer (value handle) { Renderer* renderer = (Renderer*)val_data (handle); @@ -96,6 +121,13 @@ namespace lime { } + void hl_gc_renderer (Renderer* renderer) { + + delete renderer; + + } + + void gc_text_layout (value handle) { #ifdef LIME_HARFBUZZ @@ -106,6 +138,15 @@ namespace lime { } + void hl_gc_text_layout (TextLayout* text) { + + #ifdef LIME_HARFBUZZ + delete text; + #endif + + } + + void gc_window (value handle) { Window* window = (Window*)val_data (handle); @@ -114,6 +155,13 @@ namespace lime { } + void hl_gc_window (Window* window) { + + delete window; + + } + + std::wstring* hxstring_to_wstring (HxString val) { if (val.c_str ()) { @@ -143,7 +191,7 @@ namespace lime { Application* application = CreateApplication (); // Application::callback = new ValuePointer (callback); - return HLCFFIPointer (application, gc_application); + return HLCFFIPointer (application, (hl_finalizer)hl_gc_application); } @@ -156,6 +204,14 @@ namespace lime { } + HL_PRIM void hl_lime_application_event_manager_register (vclosure* callback, HL_ApplicationEvent* eventObject) { + + // ApplicationEvent::callback = new AutoGCRoot (callback); + // ApplicationEvent::eventObject = new AutoGCRoot (eventObject); + + } + + int lime_application_exec (value application) { Application* app = (Application*)val_data (application); @@ -236,23 +292,15 @@ namespace lime { } - value lime_audio_load (value data, value buffer) { + value lime_audio_load_bytes (value data, value buffer) { Resource resource; Bytes bytes; AudioBuffer audioBuffer = AudioBuffer (buffer); - if (val_is_string (data)) { - - resource = Resource (val_string (data)); - - } else { - - bytes.Set (data); - resource = Resource (&bytes); - - } + bytes.Set (data); + resource = Resource (&bytes); if (WAV::Decode (&resource, &audioBuffer)) { @@ -273,6 +321,106 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_audio_load_bytes (HL_Bytes* data, HL_AudioBuffer* buffer) { + + // Resource resource; + // Bytes bytes; + + // AudioBuffer audioBuffer = AudioBuffer (buffer); + + // bytes.Set (data); + // resource = Resource (&bytes); + + // if (WAV::Decode (&resource, &audioBuffer)) { + + // return audioBuffer.Value (); + + // } + + // #ifdef LIME_OGG + // if (OGG::Decode (&resource, &audioBuffer)) { + + // return audioBuffer.Value (); + + // } + // #endif + + return 0; + + } + + + value lime_audio_load_file (value data, value buffer) { + + Resource resource; + Bytes bytes; + + AudioBuffer audioBuffer = AudioBuffer (buffer); + + resource = Resource (val_string (data)); + + if (WAV::Decode (&resource, &audioBuffer)) { + + return audioBuffer.Value (); + + } + + #ifdef LIME_OGG + if (OGG::Decode (&resource, &audioBuffer)) { + + return audioBuffer.Value (); + + } + #endif + + return alloc_null (); + + } + + + HL_PRIM vdynamic* hl_lime_audio_load_file (vbyte* data, HL_AudioBuffer* buffer) { + + // Resource resource; + // Bytes bytes; + + // AudioBuffer audioBuffer = AudioBuffer (buffer); + + // resource = Resource (val_string (data)); + + // if (WAV::Decode (&resource, &audioBuffer)) { + + // return audioBuffer.Value (); + + // } + + // #ifdef LIME_OGG + // if (OGG::Decode (&resource, &audioBuffer)) { + + // return audioBuffer.Value (); + + // } + // #endif + + return 0; + + } + + + value lime_audio_load (value data, value buffer) { + + if (val_is_string (data)) { + + return lime_audio_load_file (data, buffer); + + } else { + + return lime_audio_load_bytes (data, buffer); + + } + + } + + value lime_bytes_from_data_pointer (double data, int length) { uintptr_t ptr = (uintptr_t)data; @@ -345,6 +493,14 @@ namespace lime { } + HL_PRIM void hl_lime_clipboard_event_manager_register (vclosure* callback, HL_ClipboardEvent* eventObject) { + + // ClipboardEvent::callback = new AutoGCRoot (callback); + // ClipboardEvent::eventObject = new AutoGCRoot (eventObject); + + } + + value lime_clipboard_get_text () { if (Clipboard::HasText ()) { @@ -366,6 +522,28 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_clipboard_get_text () { + + if (Clipboard::HasText ()) { + + const char* text = Clipboard::GetText (); + // char* _text = malloc (strlen (text) + 1); + // strpy (text, _text); + + // // TODO: Should we free for all backends? (SDL requires it) + + // free ((char*)text); + return (vbyte*)text; + + } else { + + return 0; + + } + + } + + void lime_clipboard_set_text (HxString text) { Clipboard::SetText (text.c_str ()); @@ -373,6 +551,13 @@ namespace lime { } + HL_PRIM void hl_lime_clipboard_set_text (vbyte* text) { + + Clipboard::SetText ((const char*)text); + + } + + double lime_data_pointer_offset (double pointer, int offset) { return (uintptr_t)pointer + offset; @@ -396,6 +581,23 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_deflate_compress (HL_Bytes* buffer, HL_Bytes* bytes) { + + // #ifdef LIME_ZLIB + // Bytes data (buffer); + // Bytes result (bytes); + + // Zlib::Compress (DEFLATE, &data, &result); + + // return result.Value (); + // #else + // return alloc_null(); + // #endif + return 0; + + } + + value lime_deflate_decompress (value buffer, value bytes) { #ifdef LIME_ZLIB @@ -412,6 +614,23 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_deflate_decompress (HL_Bytes* buffer, HL_Bytes* bytes) { + + // #ifdef LIME_ZLIB + // Bytes data (buffer); + // Bytes result (bytes); + + // Zlib::Decompress (DEFLATE, &data, &result); + + // return result.Value (); + // #else + // return alloc_null (); + // #endif + return 0; + + } + + void lime_drop_event_manager_register (value callback, value eventObject) { DropEvent::callback = new AutoGCRoot (callback); @@ -420,6 +639,14 @@ namespace lime { } + HL_PRIM void hl_lime_drop_event_manager_register (vclosure* callback, HL_DropEvent* eventObject) { + + // DropEvent::callback = new AutoGCRoot (callback); + // DropEvent::eventObject = new AutoGCRoot (eventObject); + + } + + value lime_file_dialog_open_directory (HxString title, HxString filter, HxString defaultPath) { #ifdef LIME_TINYFILEDIALOGS @@ -453,6 +680,41 @@ namespace lime { } + + HL_PRIM vbyte* hl_lime_file_dialog_open_directory (vbyte* title, vbyte* filter, vbyte* defaultPath) { + + // #ifdef LIME_TINYFILEDIALOGS + + // std::wstring* _title = hxstring_to_wstring (title); + // std::wstring* _filter = hxstring_to_wstring (filter); + // std::wstring* _defaultPath = hxstring_to_wstring (defaultPath); + + // std::wstring* path = FileDialog::OpenDirectory (_title, _filter, _defaultPath); + + // if (_title) delete _title; + // if (_filter) delete _filter; + // if (_defaultPath) delete _defaultPath; + + // if (path) { + + // value _path = alloc_wstring (path->c_str ()); + // delete path; + // return _path; + + // } else { + + // delete path; + // return alloc_null (); + + // } + + // #endif + + return 0; + + } + + value lime_file_dialog_open_file (HxString title, HxString filter, HxString defaultPath) { #ifdef LIME_TINYFILEDIALOGS @@ -487,6 +749,40 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_file_dialog_open_file (vbyte* title, vbyte* filter, vbyte* defaultPath) { + + // #ifdef LIME_TINYFILEDIALOGS + + // std::wstring* _title = hxstring_to_wstring (title); + // std::wstring* _filter = hxstring_to_wstring (filter); + // std::wstring* _defaultPath = hxstring_to_wstring (defaultPath); + + // std::wstring* path = FileDialog::OpenFile (_title, _filter, _defaultPath); + + // if (_title) delete _title; + // if (_filter) delete _filter; + // if (_defaultPath) delete _defaultPath; + + // if (path) { + + // value _path = alloc_wstring (path->c_str ()); + // delete path; + // return _path; + + // } else { + + // delete path; + // return alloc_null (); + + // } + + // #endif + + return 0; + + } + + value lime_file_dialog_open_files (HxString title, HxString filter, HxString defaultPath) { #ifdef LIME_TINYFILEDIALOGS @@ -520,6 +816,39 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_file_dialog_open_files (vbyte* title, vbyte* filter, vbyte* defaultPath) { + + // #ifdef LIME_TINYFILEDIALOGS + + // std::wstring* _title = hxstring_to_wstring (title); + // std::wstring* _filter = hxstring_to_wstring (filter); + // std::wstring* _defaultPath = hxstring_to_wstring (defaultPath); + + // std::vector files; + + // FileDialog::OpenFiles (&files, _title, _filter, _defaultPath); + // value result = alloc_array (files.size ()); + + // if (_title) delete _title; + // if (_filter) delete _filter; + // if (_defaultPath) delete _defaultPath; + + // for (int i = 0; i < files.size (); i++) { + + // val_array_set_i (result, i, alloc_wstring (files[i]->c_str ())); + // delete files[i]; + + // } + + // #else + // value result = alloc_array (0); + // #endif + + return 0; + + } + + value lime_file_dialog_save_file (HxString title, HxString filter, HxString defaultPath) { #ifdef LIME_TINYFILEDIALOGS @@ -554,6 +883,40 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_file_dialog_save_file (vbyte* title, vbyte* filter, vbyte* defaultPath) { + + // #ifdef LIME_TINYFILEDIALOGS + + // std::wstring* _title = hxstring_to_wstring (title); + // std::wstring* _filter = hxstring_to_wstring (filter); + // std::wstring* _defaultPath = hxstring_to_wstring (defaultPath); + + // std::wstring* path = FileDialog::SaveFile (_title, _filter, _defaultPath); + + // if (_title) delete _title; + // if (_filter) delete _filter; + // if (_defaultPath) delete _defaultPath; + + // if (path) { + + // value _path = alloc_wstring (path->c_str ()); + // delete path; + // return _path; + + // } else { + + // delete path; + // return alloc_null (); + + // } + + // #endif + + return 0; + + } + + value lime_file_watcher_create (value callback) { #ifdef LIME_EFSW @@ -566,6 +929,19 @@ namespace lime { } + HL_PRIM HL_CFFIPointer* hl_lime_file_watcher_create (vclosure* callback) { + + // #ifdef LIME_EFSW + // FileWatcher* watcher = new FileWatcher (callback); + // return CFFIPointer (watcher, gc_file_watcher); + // #else + // return alloc_null (); + // #endif + return 0; + + } + + value lime_file_watcher_add_directory (value handle, value path, bool recursive) { #ifdef LIME_EFSW @@ -575,6 +951,17 @@ namespace lime { return alloc_int (0); #endif + } + + + HL_PRIM int hl_lime_file_watcher_add_directory (HL_CFFIPointer* handle, vbyte* path, bool recursive) { + + #ifdef LIME_EFSW + FileWatcher* watcher = (FileWatcher*)handle->ptr; + return watcher->AddDirectory ((const char*)path, recursive); + #else + return 0; + #endif } @@ -589,6 +976,16 @@ namespace lime { } + HL_PRIM void hl_lime_file_watcher_remove_directory (HL_CFFIPointer* handle, int watchID) { + + #ifdef LIME_EFSW + FileWatcher* watcher = (FileWatcher*)handle->ptr; + watcher->RemoveDirectory (watchID); + #endif + + } + + void lime_file_watcher_update (value handle) { #ifdef LIME_EFSW @@ -599,13 +996,35 @@ namespace lime { } + HL_PRIM void hl_lime_file_watcher_update (HL_CFFIPointer* handle) { + + #ifdef LIME_EFSW + FileWatcher* watcher = (FileWatcher*)handle->ptr; + watcher->Update (); + #endif + + } + + int lime_font_get_ascender (value fontHandle) { #ifdef LIME_FREETYPE Font *font = (Font*)val_data (fontHandle); return font->GetAscender (); #else - return alloc_null (); + return 0; + #endif + + } + + + HL_PRIM int hl_lime_font_get_ascender (HL_CFFIPointer* fontHandle) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + return font->GetAscender (); + #else + return 0; #endif } @@ -617,7 +1036,19 @@ namespace lime { Font *font = (Font*)val_data (fontHandle); return font->GetDescender (); #else - return alloc_null (); + return 0; + #endif + + } + + + HL_PRIM int hl_lime_font_get_descender (HL_CFFIPointer* fontHandle) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + return font->GetDescender (); + #else + return 0; #endif } @@ -638,6 +1069,19 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_font_get_family_name (HL_CFFIPointer* fontHandle) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + wchar_t *name = font->GetFamilyName (); + return (vbyte*)name; + #else + return 0; + #endif + + } + + int lime_font_get_glyph_index (value fontHandle, HxString character) { #ifdef LIME_FREETYPE @@ -650,6 +1094,18 @@ namespace lime { } + HL_PRIM int hl_lime_font_get_glyph_index (HL_CFFIPointer* fontHandle, vbyte* character) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + return font->GetGlyphIndex ((char*)character); + #else + return -1; + #endif + + } + + value lime_font_get_glyph_indices (value fontHandle, HxString characters) { #ifdef LIME_FREETYPE @@ -662,6 +1118,18 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_font_get_glyph_indices (HL_CFFIPointer* fontHandle, vbyte* characters) { + + // #ifdef LIME_FREETYPE + // Font *font = (Font*)fontHandle->ptr; + // return font->GetGlyphIndices ((char*)characters); + // #else + return 0; + // #endif + + } + + value lime_font_get_glyph_metrics (value fontHandle, int index) { #ifdef LIME_FREETYPE @@ -674,13 +1142,37 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_font_get_glyph_metrics (HL_CFFIPointer* fontHandle, int index) { + + // #ifdef LIME_FREETYPE + // Font *font = (Font*)fontHandle->ptr; + // return font->GetGlyphMetrics (index); + // #else + return 0; + // #endif + + } + + int lime_font_get_height (value fontHandle) { #ifdef LIME_FREETYPE Font *font = (Font*)val_data (fontHandle); return font->GetHeight (); #else - return alloc_null (); + return 0; + #endif + + } + + + HL_PRIM int hl_lime_font_get_height (HL_CFFIPointer* fontHandle) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + return font->GetHeight (); + #else + return 0; #endif } @@ -692,7 +1184,19 @@ namespace lime { Font *font = (Font*)val_data (fontHandle); return font->GetNumGlyphs (); #else - return alloc_null (); + return 0; + #endif + + } + + + HL_PRIM int hl_lime_font_get_num_glyphs (HL_CFFIPointer* fontHandle) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + return font->GetNumGlyphs (); + #else + return 0; #endif } @@ -704,7 +1208,19 @@ namespace lime { Font *font = (Font*)val_data (fontHandle); return font->GetUnderlinePosition (); #else - return alloc_null (); + return 0; + #endif + + } + + + HL_PRIM int hl_lime_font_get_underline_position (HL_CFFIPointer* fontHandle) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + return font->GetUnderlinePosition (); + #else + return 0; #endif } @@ -716,7 +1232,19 @@ namespace lime { Font *font = (Font*)val_data (fontHandle); return font->GetUnderlineThickness (); #else - return alloc_null (); + return 0; + #endif + + } + + + HL_PRIM int hl_lime_font_get_underline_thickness (HL_CFFIPointer* fontHandle) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + return font->GetUnderlineThickness (); + #else + return 0; #endif } @@ -728,28 +1256,32 @@ namespace lime { Font *font = (Font*)val_data (fontHandle); return font->GetUnitsPerEM (); #else - return alloc_null (); + return 0; #endif } - value lime_font_load (value data) { + HL_PRIM int hl_lime_font_get_units_per_em (HL_CFFIPointer* fontHandle) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + return font->GetUnitsPerEM (); + #else + return 0; + #endif + + } + + + value lime_font_load_bytes (value data) { #ifdef LIME_FREETYPE Resource resource; Bytes bytes; - if (val_is_string (data)) { - - resource = Resource (val_string (data)); - - } else { - - bytes.Set (data); - resource = Resource (&bytes); - - } + bytes.Set (data); + resource = Resource (&bytes); Font *font = new Font (&resource, 0); @@ -773,6 +1305,112 @@ namespace lime { } + HL_PRIM HL_CFFIPointer* hl_lime_font_load_bytes (HL_Bytes* data) { + + // #ifdef LIME_FREETYPE + // Resource resource; + // Bytes bytes; + + // bytes.Set (data); + // resource = Resource (&bytes); + + // Font *font = new Font (&resource, 0); + + // if (font) { + + // if (font->face) { + + // return CFFIPointer (font, gc_font); + + // } else { + + // delete font; + + // } + + // } + // #endif + + return 0; + + } + + + value lime_font_load_file (value data) { + + #ifdef LIME_FREETYPE + Resource resource; + Bytes bytes; + + resource = Resource (val_string (data)); + + Font *font = new Font (&resource, 0); + + if (font) { + + if (font->face) { + + return CFFIPointer (font, gc_font); + + } else { + + delete font; + + } + + } + #endif + + return alloc_null (); + + } + + + HL_PRIM HL_CFFIPointer* hl_lime_font_load_file (vbyte* data) { + + // #ifdef LIME_FREETYPE + // Resource resource; + // Bytes bytes; + + // resource = Resource (val_string (data)); + + // Font *font = new Font (&resource, 0); + + // if (font) { + + // if (font->face) { + + // return CFFIPointer (font, gc_font); + + // } else { + + // delete font; + + // } + + // } + // #endif + + return 0; + + } + + + value lime_font_load (value data) { + + if (val_is_string (data)) { + + return lime_font_load_file (data); + + } else { + + return lime_font_load_bytes (data); + + } + + } + + value lime_font_outline_decompose (value fontHandle, int size) { #ifdef LIME_FREETYPE @@ -785,6 +1423,18 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_font_outline_decompose (HL_CFFIPointer* fontHandle, int size) { + + // #ifdef LIME_FREETYPE + // Font *font = (Font*)fontHandle->ptr; + // return font->Decompose (size); + // #else + return 0; + // #endif + + } + + bool lime_font_render_glyph (value fontHandle, int index, value data) { #ifdef LIME_FREETYPE @@ -798,6 +1448,19 @@ namespace lime { } + HL_PRIM bool hl_lime_font_render_glyph (HL_CFFIPointer* fontHandle, int index, HL_Bytes* data) { + + // #ifdef LIME_FREETYPE + // Font *font = (Font*)val_data (fontHandle); + // Bytes bytes (data); + // return font->RenderGlyph (index, &bytes); + // #else + return false; + // #endif + + } + + bool lime_font_render_glyphs (value fontHandle, value indices, value data) { #ifdef LIME_FREETYPE @@ -811,6 +1474,19 @@ namespace lime { } + HL_PRIM bool hl_lime_font_render_glyphs (HL_CFFIPointer* fontHandle, vdynamic* indices, HL_Bytes* data) { + + // #ifdef LIME_FREETYPE + // Font *font = (Font*)val_data (fontHandle); + // Bytes bytes (data); + // return font->RenderGlyphs (indices, &bytes); + // #else + return false; + // #endif + + } + + void lime_font_set_size (value fontHandle, int fontSize) { #ifdef LIME_FREETYPE @@ -821,6 +1497,16 @@ namespace lime { } + HL_PRIM void hl_lime_font_set_size (HL_CFFIPointer* fontHandle, int fontSize) { + + #ifdef LIME_FREETYPE + Font *font = (Font*)fontHandle->ptr; + font->SetSize (fontSize); + #endif + + } + + void lime_gamepad_add_mappings (value mappings) { int length = val_array_size (mappings); @@ -834,6 +1520,19 @@ namespace lime { } + HL_PRIM void hl_lime_gamepad_add_mappings (vdynamic* mappings) { + + // int length = val_array_size (mappings); + + // for (int i = 0; i < length; i++) { + + // Gamepad::AddMapping (val_string (val_array_i (mappings, i))); + + // } + + } + + void lime_gamepad_event_manager_register (value callback, value eventObject) { GamepadEvent::callback = new AutoGCRoot (callback); @@ -842,6 +1541,14 @@ namespace lime { } + HL_PRIM void hl_lime_gamepad_event_manager_register (vclosure* callback, HL_GamepadEvent* eventObject) { + + // GamepadEvent::callback = new AutoGCRoot (callback); + // GamepadEvent::eventObject = new AutoGCRoot (eventObject); + + } + + value lime_gamepad_get_device_guid (int id) { const char* guid = Gamepad::GetDeviceGUID (id); @@ -861,6 +1568,26 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_gamepad_get_device_guid (int id) { + + const char* guid = Gamepad::GetDeviceGUID (id); + + if (guid) { + + // value result = alloc_string (guid); + // delete guid; + // return result; + return (vbyte*)guid; + + } else { + + return 0; + + } + + } + + value lime_gamepad_get_device_name (int id) { const char* name = Gamepad::GetDeviceName (id); @@ -869,6 +1596,13 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_gamepad_get_device_name (int id) { + + return (vbyte*)Gamepad::GetDeviceName (id); + + } + + value lime_gzip_compress (value buffer, value bytes) { #ifdef LIME_ZLIB @@ -885,6 +1619,22 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_gzip_compress (HL_Bytes* buffer, HL_Bytes* bytes) { + + // #ifdef LIME_ZLIB + // Bytes data (buffer); + // Bytes result (bytes); + + // Zlib::Compress (GZIP, &data, &result); + + // return result.Value (); + // #else + return 0; + // #endif + + } + + value lime_gzip_decompress (value buffer, value bytes) { #ifdef LIME_ZLIB @@ -901,6 +1651,22 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_gzip_decompress (HL_Bytes* buffer, HL_Bytes* bytes) { + + // #ifdef LIME_ZLIB + // Bytes data (buffer); + // Bytes result (bytes); + + // Zlib::Decompress (GZIP, &data, &result); + + // return result.Value (); + // #else + return 0; + // #endif + + } + + void lime_haptic_vibrate (int period, int duration) { #ifdef IPHONE @@ -910,6 +1676,15 @@ namespace lime { } + HL_PRIM void hl_lime_haptic_vibrate (int period, int duration) { + + #ifdef IPHONE + Haptic::Vibrate (period, duration); + #endif + + } + + value lime_image_encode (value buffer, int type, int quality, value bytes) { ImageBuffer imageBuffer = ImageBuffer (buffer); @@ -948,23 +1723,53 @@ namespace lime { } - value lime_image_load (value data, value buffer) { + HL_PRIM vdynamic* hl_lime_image_encode (HL_ImageBuffer* buffer, int type, int quality, HL_Bytes* bytes) { + + // ImageBuffer imageBuffer = ImageBuffer (buffer); + // Bytes data = Bytes (bytes); + + // switch (type) { + + // case 0: + + // #ifdef LIME_PNG + // if (PNG::Encode (&imageBuffer, &data)) { + + // return data.Value (); + + // } + // #endif + // break; + + // case 1: + + // #ifdef LIME_JPEG + // if (JPEG::Encode (&imageBuffer, &data, quality)) { + + // return data.Value (); + + // } + // #endif + // break; + + // default: break; + + // } + + return 0; + + } + + + value lime_image_load_bytes (value data, value buffer) { Resource resource; Bytes bytes; ImageBuffer imageBuffer = ImageBuffer (buffer); - if (val_is_string (data)) { - - resource = Resource (val_string (data)); - - } else { - - bytes.Set (data); - resource = Resource (&bytes); - - } + bytes.Set (data); + resource = Resource (&bytes); #ifdef LIME_PNG if (PNG::Decode (&resource, &imageBuffer)) { @@ -987,6 +1792,112 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_image_load_bytes (HL_Bytes* data, HL_ImageBuffer* buffer) { + + // Resource resource; + // Bytes bytes; + + // ImageBuffer imageBuffer = ImageBuffer (buffer); + + // bytes.Set (data); + // resource = Resource (&bytes); + + // #ifdef LIME_PNG + // if (PNG::Decode (&resource, &imageBuffer)) { + + // return imageBuffer.Value (); + + // } + // #endif + + // #ifdef LIME_JPEG + // if (JPEG::Decode (&resource, &imageBuffer)) { + + // return imageBuffer.Value (); + + // } + // #endif + + return 0; + + } + + + value lime_image_load_file (value data, value buffer) { + + Resource resource; + Bytes bytes; + + ImageBuffer imageBuffer = ImageBuffer (buffer); + + resource = Resource (val_string (data)); + + #ifdef LIME_PNG + if (PNG::Decode (&resource, &imageBuffer)) { + + return imageBuffer.Value (); + + } + #endif + + #ifdef LIME_JPEG + if (JPEG::Decode (&resource, &imageBuffer)) { + + return imageBuffer.Value (); + + } + #endif + + return alloc_null (); + + } + + + HL_PRIM vdynamic* hl_lime_image_load_file (vbyte* data, HL_ImageBuffer* buffer) { + + // Resource resource; + // Bytes bytes; + + // ImageBuffer imageBuffer = ImageBuffer (buffer); + + // resource = Resource (val_string (data)); + + // #ifdef LIME_PNG + // if (PNG::Decode (&resource, &imageBuffer)) { + + // return imageBuffer.Value (); + + // } + // #endif + + // #ifdef LIME_JPEG + // if (JPEG::Decode (&resource, &imageBuffer)) { + + // return imageBuffer.Value (); + + // } + // #endif + + return 0; + + } + + + value lime_image_load (value data, value buffer) { + + if (val_is_string (data)) { + + return lime_image_load_file (data, buffer); + + } else { + + return lime_image_load_bytes (data, buffer); + + } + + } + + void lime_image_data_util_color_transform (value image, value rect, value colorMatrix) { Image _image = Image (image); @@ -997,6 +1908,16 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_color_transform (HL_Image* image, HL_Rectangle* rect, HL_ArrayBufferView* colorMatrix) { + + // Image _image = Image (image); + // Rectangle _rect = Rectangle (rect); + // ColorMatrix _colorMatrix = ColorMatrix (colorMatrix); + // ImageDataUtil::ColorTransform (&_image, &_rect, &_colorMatrix); + + } + + void lime_image_data_util_copy_channel (value image, value sourceImage, value sourceRect, value destPoint, int srcChannel, int destChannel) { Image _image = Image (image); @@ -1008,6 +1929,17 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_copy_channel (HL_Image* image, HL_Image* sourceImage, HL_Rectangle* sourceRect, HL_Vector2* destPoint, int srcChannel, int destChannel) { + + // Image _image = Image (image); + // Image _sourceImage = Image (sourceImage); + // Rectangle _sourceRect = Rectangle (sourceRect); + // Vector2 _destPoint = Vector2 (destPoint); + // ImageDataUtil::CopyChannel (&_image, &_sourceImage, &_sourceRect, &_destPoint, srcChannel, destChannel); + + } + + void lime_image_data_util_copy_pixels (value image, value sourceImage, value sourceRect, value destPoint, value alphaImage, value alphaPoint, bool mergeAlpha) { Image _image = Image (image); @@ -1031,6 +1963,29 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_copy_pixels (HL_Image* image, HL_Image* sourceImage, HL_Rectangle* sourceRect, HL_Vector2* destPoint, HL_Image* alphaImage, HL_Vector2* alphaPoint, bool mergeAlpha) { + + // Image _image = Image (image); + // Image _sourceImage = Image (sourceImage); + // Rectangle _sourceRect = Rectangle (sourceRect); + // Vector2 _destPoint = Vector2 (destPoint); + + // if (val_is_null (alphaImage)) { + + // ImageDataUtil::CopyPixels (&_image, &_sourceImage, &_sourceRect, &_destPoint, 0, 0, mergeAlpha); + + // } else { + + // Image _alphaImage = Image (alphaImage); + // Vector2 _alphaPoint = Vector2 (alphaPoint); + + // ImageDataUtil::CopyPixels (&_image, &_sourceImage, &_sourceRect, &_destPoint, &_alphaImage, &_alphaPoint, mergeAlpha); + + // } + + } + + void lime_image_data_util_fill_rect (value image, value rect, int rg, int ba) { Image _image = Image (image); @@ -1060,6 +2015,15 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_flood_fill (HL_Image* image, int x, int y, int rg, int ba) { + + Image _image = Image (image); + int32_t color = (rg << 16) | ba; + ImageDataUtil::FloodFill (&_image, x, y, color); + + } + + void lime_image_data_util_get_pixels (value image, value rect, int format, value bytes) { Image _image = Image (image); @@ -1071,6 +2035,17 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_get_pixels (HL_Image* image, HL_Rectangle* rect, int format, HL_Bytes* bytes) { + + // Image _image = Image (image); + // Rectangle _rect = Rectangle (rect); + // PixelFormat _format = (PixelFormat)format; + // Bytes pixels = Bytes (bytes); + // ImageDataUtil::GetPixels (&_image, &_rect, _format, &pixels); + + } + + void lime_image_data_util_merge (value image, value sourceImage, value sourceRect, value destPoint, int redMultiplier, int greenMultiplier, int blueMultiplier, int alphaMultiplier) { Image _image = Image (image); @@ -1082,6 +2057,17 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_merge (HL_Image* image, HL_Image* sourceImage, HL_Rectangle* sourceRect, HL_Vector2* destPoint, int redMultiplier, int greenMultiplier, int blueMultiplier, int alphaMultiplier) { + + // Image _image = Image (image); + // Image _sourceImage = Image (sourceImage); + // Rectangle _sourceRect = Rectangle (sourceRect); + // Vector2 _destPoint = Vector2 (destPoint); + // ImageDataUtil::Merge (&_image, &_sourceImage, &_sourceRect, &_destPoint, redMultiplier, greenMultiplier, blueMultiplier, alphaMultiplier); + + } + + void lime_image_data_util_multiply_alpha (value image) { Image _image = Image (image); @@ -1090,6 +2076,14 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_multiply_alpha (HL_Image* image) { + + Image _image = Image (image); + ImageDataUtil::MultiplyAlpha (&_image); + + } + + void lime_image_data_util_resize (value image, value buffer, int width, int height) { Image _image = Image (image); @@ -1099,6 +2093,15 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_resize (HL_Image* image, HL_ImageBuffer* buffer, int width, int height) { + + Image _image = Image (image); + ImageBuffer _buffer = ImageBuffer (buffer); + ImageDataUtil::Resize (&_image, &_buffer, width, height); + + } + + void lime_image_data_util_set_format (value image, int format) { Image _image = Image (image); @@ -1108,6 +2111,15 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_set_format (HL_Image* image, int format) { + + Image _image = Image (image); + PixelFormat _format = (PixelFormat)format; + ImageDataUtil::SetFormat (&_image, _format); + + } + + void lime_image_data_util_set_pixels (value image, value rect, value bytes, int offset, int format, int endian) { Image _image = Image (image); @@ -1120,6 +2132,18 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_set_pixels (HL_Image* image, HL_Rectangle* rect, HL_Bytes* bytes, int offset, int format, int endian) { + + Image _image = Image (image); + Rectangle _rect = Rectangle (rect); + Bytes _bytes (bytes); + PixelFormat _format = (PixelFormat)format; + Endian _endian = (Endian)endian; + ImageDataUtil::SetPixels (&_image, &_rect, &_bytes, offset, _format, _endian); + + } + + int lime_image_data_util_threshold (value image, value sourceImage, value sourceRect, value destPoint, int operation, int thresholdRG, int thresholdBA, int colorRG, int colorBA, int maskRG, int maskBA, bool copySource) { Image _image = Image (image); @@ -1133,6 +2157,21 @@ namespace lime { } + + HL_PRIM int hl_lime_image_data_util_threshold (HL_Image* image, HL_Image* sourceImage, HL_Rectangle* sourceRect, HL_Vector2* destPoint, int operation, int thresholdRG, int thresholdBA, int colorRG, int colorBA, int maskRG, int maskBA, bool copySource) { + + // Image _image = Image (image); + // Image _sourceImage = Image (sourceImage); + // Rectangle _sourceRect = Rectangle (sourceRect); + // Vector2 _destPoint = Vector2 (destPoint); + // int32_t threshold = (thresholdRG << 16) | thresholdBA; + // int32_t color = (colorRG << 16) | colorBA; + // int32_t mask = (maskRG << 16) | maskBA; + // return ImageDataUtil::Threshold (&_image, &_sourceImage, &_sourceRect, &_destPoint, operation, threshold, color, mask, copySource); + + } + + void lime_image_data_util_unmultiply_alpha (value image) { Image _image = Image (image); @@ -1141,6 +2180,14 @@ namespace lime { } + HL_PRIM void hl_lime_image_data_util_unmultiply_alpha (HL_Image* image) { + + Image _image = Image (image); + ImageDataUtil::UnmultiplyAlpha (&_image); + + } + + double lime_jni_getenv () { #ifdef ANDROID @@ -1152,6 +2199,17 @@ namespace lime { } + HL_PRIM double hl_lime_jni_getenv () { + + #ifdef ANDROID + return (uintptr_t)JNI::GetEnv (); + #else + return 0; + #endif + + } + + void lime_joystick_event_manager_register (value callback, value eventObject) { JoystickEvent::callback = new AutoGCRoot (callback); @@ -1160,6 +2218,14 @@ namespace lime { } + HL_PRIM void hl_lime_joystick_event_manager_register (vclosure* callback, HL_JoystickEvent* eventObject) { + + // JoystickEvent::callback = new AutoGCRoot (callback); + // JoystickEvent::eventObject = new AutoGCRoot (eventObject); + + } + + value lime_joystick_get_device_guid (int id) { const char* guid = Joystick::GetDeviceGUID (id); @@ -1168,6 +2234,13 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_joystick_get_device_guid (int id) { + + return (vbyte*)Joystick::GetDeviceGUID (id); + + } + + value lime_joystick_get_device_name (int id) { const char* name = Joystick::GetDeviceName (id); @@ -1176,6 +2249,13 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_joystick_get_device_name (int id) { + + return (vbyte*)Joystick::GetDeviceName (id); + + } + + int lime_joystick_get_num_axes (int id) { return Joystick::GetNumAxes (id); @@ -1183,6 +2263,13 @@ namespace lime { } + HL_PRIM int hl_lime_joystick_get_num_axes (int id) { + + return Joystick::GetNumAxes (id); + + } + + int lime_joystick_get_num_buttons (int id) { return Joystick::GetNumButtons (id); @@ -1190,6 +2277,13 @@ namespace lime { } + HL_PRIM int hl_lime_joystick_get_num_buttons (int id) { + + return Joystick::GetNumButtons (id); + + } + + int lime_joystick_get_num_hats (int id) { return Joystick::GetNumHats (id); @@ -1197,6 +2291,13 @@ namespace lime { } + HL_PRIM int hl_lime_joystick_get_num_hats (int id) { + + return Joystick::GetNumHats (id); + + } + + int lime_joystick_get_num_trackballs (int id) { return Joystick::GetNumTrackballs (id); @@ -1204,6 +2305,13 @@ namespace lime { } + HL_PRIM int hl_lime_joystick_get_num_trackballs (int id) { + + return Joystick::GetNumTrackballs (id); + + } + + value lime_jpeg_decode_bytes (value data, bool decodeData, value buffer) { ImageBuffer imageBuffer (buffer); @@ -1224,6 +2332,26 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_jpeg_decode_bytes (HL_Bytes* data, bool decodeData, HL_ImageBuffer* buffer) { + + // ImageBuffer imageBuffer (buffer); + + // Bytes bytes (data); + // Resource resource = Resource (&bytes); + + // #ifdef LIME_JPEG + // if (JPEG::Decode (&resource, &imageBuffer, decodeData)) { + + // return imageBuffer.Value (); + + // } + // #endif + + return 0; + + } + + value lime_jpeg_decode_file (HxString path, bool decodeData, value buffer) { ImageBuffer imageBuffer (buffer); @@ -1242,6 +2370,24 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_jpeg_decode_file (vbyte* path, bool decodeData, HL_ImageBuffer* buffer) { + + // ImageBuffer imageBuffer (buffer); + // Resource resource = Resource (path.c_str ()); + + // #ifdef LIME_JPEG + // if (JPEG::Decode (&resource, &imageBuffer, decodeData)) { + + // return imageBuffer.Value (); + + // } + // #endif + + return 0; + + } + + float lime_key_code_from_scan_code (float scanCode) { return KeyCode::FromScanCode (scanCode); @@ -1249,6 +2395,13 @@ namespace lime { } + HL_PRIM float hl_lime_key_code_from_scan_code (float scanCode) { + + return KeyCode::FromScanCode (scanCode); + + } + + float lime_key_code_to_scan_code (float keyCode) { return KeyCode::ToScanCode (keyCode); @@ -1256,6 +2409,13 @@ namespace lime { } + HL_PRIM float hl_lime_key_code_to_scan_code (float keyCode) { + + return KeyCode::ToScanCode (keyCode); + + } + + void lime_key_event_manager_register (value callback, value eventObject) { KeyEvent::callback = new AutoGCRoot (callback); @@ -1264,6 +2424,14 @@ namespace lime { } + HL_PRIM void hl_lime_key_event_manager_register (vclosure* callback, HL_KeyEvent* eventObject) { + + // KeyEvent::callback = new AutoGCRoot (callback); + // KeyEvent::eventObject = new AutoGCRoot (eventObject); + + } + + value lime_locale_get_system_locale () { std::string* locale = Locale::GetSystemLocale (); @@ -1283,6 +2451,28 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_locale_get_system_locale () { + + std::string* locale = Locale::GetSystemLocale (); + + if (!locale) { + + return 0; + + } else { + + // value result = alloc_string (locale->c_str ()); + // delete locale; + + // TODO: Copy string + + return (vbyte*)locale->c_str (); + + } + + } + + value lime_lzma_compress (value buffer, value bytes) { #ifdef LIME_LZMA @@ -1299,6 +2489,22 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_lzma_compress (HL_Bytes* buffer, HL_Bytes* bytes) { + + // #ifdef LIME_LZMA + // Bytes data (buffer); + // Bytes result (bytes); + + // LZMA::Compress (&data, &result); + + // return result.Value (); + // #else + return 0; + // #endif + + } + + value lime_lzma_decompress (value buffer, value bytes) { #ifdef LIME_LZMA @@ -1315,6 +2521,22 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_lzma_decompress (HL_Bytes* buffer, HL_Bytes* bytes) { + + // #ifdef LIME_LZMA + // Bytes data (buffer); + // Bytes result (bytes); + + // LZMA::Decompress (&data, &result); + + // return result.Value (); + // #else + return 0; + // #endif + + } + + void lime_mouse_event_manager_register (value callback, value eventObject) { MouseEvent::callback = new AutoGCRoot (callback); @@ -1323,6 +2545,14 @@ namespace lime { } + HL_PRIM void hl_lime_mouse_event_manager_register (vclosure* callback, HL_MouseEvent* eventObject) { + + // MouseEvent::callback = new AutoGCRoot (callback); + // MouseEvent::eventObject = new AutoGCRoot (eventObject); + + } + + void lime_mouse_hide () { Mouse::Hide (); @@ -1330,6 +2560,13 @@ namespace lime { } + HL_PRIM void hl_lime_mouse_hide () { + + Mouse::Hide (); + + } + + void lime_mouse_set_cursor (int cursor) { Mouse::SetCursor ((MouseCursor)cursor); @@ -1337,6 +2574,13 @@ namespace lime { } + HL_PRIM void hl_lime_mouse_set_cursor (int cursor) { + + Mouse::SetCursor ((MouseCursor)cursor); + + } + + void lime_mouse_set_lock (bool lock) { Mouse::SetLock (lock); @@ -1344,6 +2588,13 @@ namespace lime { } + HL_PRIM void hl_lime_mouse_set_lock (bool lock) { + + Mouse::SetLock (lock); + + } + + void lime_mouse_show () { Mouse::Show (); @@ -1351,6 +2602,13 @@ namespace lime { } + HL_PRIM void hl_lime_mouse_show () { + + Mouse::Show (); + + } + + void lime_mouse_warp (int x, int y, value window) { Window* windowRef = 0; @@ -1366,6 +2624,21 @@ namespace lime { } + HL_PRIM void hl_lime_mouse_warp (int x, int y, HL_CFFIPointer* window) { + + Window* windowRef = 0; + + if (window) { + + windowRef = (Window*)window->ptr; + + } + + Mouse::Warp (x, y, windowRef); + + } + + void lime_neko_execute (HxString module) { #ifdef LIME_NEKO @@ -1394,6 +2667,25 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_png_decode_bytes (HL_Bytes* data, bool decodeData, HL_ImageBuffer* buffer) { + + // ImageBuffer imageBuffer (buffer); + // Bytes bytes (data); + // Resource resource = Resource (&bytes); + + // #ifdef LIME_PNG + // if (PNG::Decode (&resource, &imageBuffer, decodeData)) { + + // return imageBuffer.Value (); + + // } + // #endif + + return 0; + + } + + value lime_png_decode_file (HxString path, bool decodeData, value buffer) { ImageBuffer imageBuffer (buffer); @@ -1412,6 +2704,24 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_png_decode_file (vbyte* path, bool decodeData, HL_Bytes* buffer) { + + // ImageBuffer imageBuffer (buffer); + // Resource resource = Resource (path.c_str ()); + + // #ifdef LIME_PNG + // if (PNG::Decode (&resource, &imageBuffer, decodeData)) { + + // return imageBuffer.Value (); + + // } + // #endif + + return 0; + + } + + void lime_render_event_manager_register (value callback, value eventObject) { RenderEvent::callback = new AutoGCRoot (callback); @@ -1420,6 +2730,14 @@ namespace lime { } + HL_PRIM void hl_lime_render_event_manager_register (vclosure* callback, HL_RenderEvent* eventObject) { + + // RenderEvent::callback = new AutoGCRoot (callback); + // RenderEvent::eventObject = new AutoGCRoot (eventObject); + + } + + value lime_renderer_create (value window) { Renderer* renderer = CreateRenderer ((Window*)val_data (window)); @@ -1428,6 +2746,14 @@ namespace lime { } + HL_PRIM HL_CFFIPointer* hl_lime_renderer_create (HL_CFFIPointer* window) { + + Renderer* renderer = CreateRenderer ((Window*)window->ptr); + return HLCFFIPointer (renderer, (hl_finalizer)hl_gc_renderer); + + } + + void lime_renderer_flip (value renderer) { ((Renderer*)val_data (renderer))->Flip (); @@ -1435,6 +2761,13 @@ namespace lime { } + HL_PRIM void hl_lime_renderer_flip (HL_CFFIPointer* renderer) { + + ((Renderer*)renderer->ptr)->Flip (); + + } + + double lime_renderer_get_context (value renderer) { Renderer* targetRenderer = (Renderer*)val_data (renderer); @@ -1443,6 +2776,14 @@ namespace lime { } + HL_PRIM double hl_lime_renderer_get_context (HL_CFFIPointer* renderer) { + + Renderer* targetRenderer = (Renderer*)renderer->ptr; + return (uintptr_t)targetRenderer->GetContext (); + + } + + double lime_renderer_get_scale (value renderer) { Renderer* targetRenderer = (Renderer*)val_data (renderer); @@ -1451,6 +2792,14 @@ namespace lime { } + HL_PRIM double hl_lime_renderer_get_scale (HL_CFFIPointer* renderer) { + + Renderer* targetRenderer = (Renderer*)renderer->ptr; + return targetRenderer->GetScale (); + + } + + value lime_renderer_get_type (value renderer) { Renderer* targetRenderer = (Renderer*)val_data (renderer); @@ -1460,6 +2809,14 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_renderer_get_type (HL_CFFIPointer* renderer) { + + Renderer* targetRenderer = (Renderer*)renderer->ptr; + return (vbyte*)targetRenderer->Type (); + + } + + value lime_renderer_lock (value renderer) { return ((Renderer*)val_data (renderer))->Lock (); @@ -1467,6 +2824,14 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_renderer_lock (HL_CFFIPointer* renderer) { + + // return ((Renderer*)renderer->ptr)->Lock (); + return 0; + + } + + void lime_renderer_make_current (value renderer) { ((Renderer*)val_data (renderer))->MakeCurrent (); @@ -1474,6 +2839,13 @@ namespace lime { } + HL_PRIM void hl_lime_renderer_make_current (HL_CFFIPointer* renderer) { + + ((Renderer*)renderer->ptr)->MakeCurrent (); + + } + + value lime_renderer_read_pixels (value renderer, value rect, value imageBuffer) { Renderer* targetRenderer = (Renderer*)val_data (renderer); @@ -1495,6 +2867,28 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_renderer_read_pixels (HL_CFFIPointer* renderer, HL_Rectangle* rect, HL_ImageBuffer* imageBuffer) { + + // Renderer* targetRenderer = (Renderer*)renderer->ptr; + // ImageBuffer buffer (imageBuffer); + + // if (rect) { + + // Rectangle _rect = Rectangle (rect); + // targetRenderer->ReadPixels (&buffer, &_rect); + + // } else { + + // targetRenderer->ReadPixels (&buffer, NULL); + + // } + + // return buffer.Value (); + return 0; + + } + + void lime_renderer_unlock (value renderer) { ((Renderer*)val_data (renderer))->Unlock (); @@ -1502,6 +2896,13 @@ namespace lime { } + HL_PRIM void hl_lime_renderer_unlock (HL_CFFIPointer* renderer) { + + ((Renderer*)renderer->ptr)->Unlock (); + + } + + void lime_sensor_event_manager_register (value callback, value eventObject) { SensorEvent::callback = new AutoGCRoot (callback); @@ -1510,6 +2911,14 @@ namespace lime { } + HL_PRIM void hl_lime_sensor_event_manager_register (vclosure* callback, HL_SensorEvent* eventObject) { + + // SensorEvent::callback = new AutoGCRoot (callback); + // SensorEvent::eventObject = new AutoGCRoot (eventObject); + + } + + bool lime_system_get_allow_screen_timeout () { return System::GetAllowScreenTimeout (); @@ -1517,6 +2926,13 @@ namespace lime { } + HL_PRIM bool hl_lime_system_get_allow_screen_timeout () { + + return System::GetAllowScreenTimeout (); + + } + + value lime_system_get_device_model () { std::wstring* model = System::GetDeviceModel (); @@ -1536,6 +2952,28 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_system_get_device_model () { + + std::wstring* model = System::GetDeviceModel (); + + if (model) { + + // TODO: Copy string + return (vbyte*)model->c_str (); + + // value result = alloc_wstring (model->c_str ()); + // delete model; + // return result; + + } else { + + return 0; + + } + + } + + value lime_system_get_device_vendor () { std::wstring* vendor = System::GetDeviceVendor (); @@ -1555,6 +2993,28 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_system_get_device_vendor () { + + std::wstring* vendor = System::GetDeviceVendor (); + + if (vendor) { + + // TODO: Copy string + return (vbyte*)vendor->c_str (); + + // value result = alloc_wstring (vendor->c_str ()); + // delete vendor; + // return result; + + } else { + + return 0; + + } + + } + + value lime_system_get_directory (int type, HxString company, HxString title) { std::wstring* path = System::GetDirectory ((SystemDirectory)type, company.c_str (), title.c_str ()); @@ -1574,6 +3034,28 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_system_get_directory (int type, vbyte* company, vbyte* title) { + + std::wstring* path = System::GetDirectory ((SystemDirectory)type, (char*)company, (char*)title); + + if (path) { + + // TODO: Copy string + return (vbyte*)path->c_str (); + + // value result = alloc_wstring (path->c_str ()); + // delete path; + // return result; + + } else { + + return 0; + + } + + } + + value lime_system_get_display (int id) { return System::GetDisplay (id); @@ -1581,6 +3063,14 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_system_get_display (int id) { + + // return System::GetDisplay (id); + return 0; + + } + + bool lime_system_get_ios_tablet () { #ifdef IPHONE @@ -1592,6 +3082,17 @@ namespace lime { } + HL_PRIM bool hl_lime_system_get_ios_tablet () { + + #ifdef IPHONE + return System::GetIOSTablet (); + #else + return false; + #endif + + } + + int lime_system_get_num_displays () { return System::GetNumDisplays (); @@ -1599,6 +3100,13 @@ namespace lime { } + HL_PRIM int hl_lime_system_get_num_displays () { + + return System::GetNumDisplays (); + + } + + value lime_system_get_platform_label () { std::wstring* label = System::GetPlatformLabel (); @@ -1618,6 +3126,28 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_system_get_platform_label () { + + std::wstring* label = System::GetPlatformLabel (); + + if (label) { + + // TODO: Copy string + return (vbyte*)label->c_str (); + + // value result = alloc_wstring (label->c_str ()); + // delete label; + // return result; + + } else { + + return 0; + + } + + } + + value lime_system_get_platform_name () { std::wstring* name = System::GetPlatformName (); @@ -1630,7 +3160,29 @@ namespace lime { } else { - return alloc_null (); + return 0; + + } + + } + + + HL_PRIM vbyte* hl_lime_system_get_platform_name () { + + std::wstring* name = System::GetPlatformName (); + + if (name) { + + // TODO: Copy string + return (vbyte*)name->c_str (); + + // value result = alloc_wstring (name->c_str ()); + // delete name; + // return result; + + } else { + + return 0; } @@ -1656,6 +3208,28 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_system_get_platform_version () { + + std::wstring* version = System::GetPlatformVersion (); + + if (version) { + + // TODO: Copy string + return (vbyte*)version->c_str (); + + // value result = alloc_wstring (version->c_str ()); + // delete version; + // return result; + + } else { + + return 0; + + } + + } + + double lime_system_get_timer () { return System::GetTimer (); @@ -1663,6 +3237,13 @@ namespace lime { } + HL_PRIM double hl_lime_system_get_timer () { + + return System::GetTimer (); + + } + + int lime_system_get_windows_console_mode (int handleType) { #ifdef HX_WINDOWS @@ -1674,6 +3255,17 @@ namespace lime { } + HL_PRIM int hl_lime_system_get_windows_console_mode (int handleType) { + + #ifdef HX_WINDOWS + return System::GetWindowsConsoleMode (handleType); + #else + return 0; + #endif + + } + + void lime_system_open_file (HxString path) { #ifdef IPHONE @@ -1683,6 +3275,15 @@ namespace lime { } + HL_PRIM void hl_lime_system_open_file (vbyte* path) { + + #ifdef IPHONE + System::OpenFile ((char*)path); + #endif + + } + + void lime_system_open_url (HxString url, HxString target) { #ifdef IPHONE @@ -1692,6 +3293,15 @@ namespace lime { } + HL_PRIM void hl_lime_system_open_url (vbyte* url, vbyte* target) { + + #ifdef IPHONE + System::OpenURL ((char*)url, (char*)target); + #endif + + } + + bool lime_system_set_allow_screen_timeout (bool allow) { return System::SetAllowScreenTimeout (allow); @@ -1699,6 +3309,13 @@ namespace lime { } + HL_PRIM bool hl_lime_system_set_allow_screen_timeout (bool allow) { + + return System::SetAllowScreenTimeout (allow); + + } + + bool lime_system_set_windows_console_mode (int handleType, int mode) { #ifdef HX_WINDOWS @@ -1710,6 +3327,17 @@ namespace lime { } + HL_PRIM bool hl_lime_system_set_windows_console_mode (int handleType, int mode) { + + #ifdef HX_WINDOWS + return System::SetWindowsConsoleMode (handleType, mode); + #else + return false; + #endif + + } + + void lime_text_event_manager_register (value callback, value eventObject) { TextEvent::callback = new AutoGCRoot (callback); @@ -1718,9 +3346,17 @@ namespace lime { } + HL_PRIM void hl_lime_text_event_manager_register (vclosure* callback, HL_TextEvent* eventObject) { + + // TextEvent::callback = new AutoGCRoot (callback); + // TextEvent::eventObject = new AutoGCRoot (eventObject); + + } + + value lime_text_layout_create (int direction, HxString script, HxString language) { - #if defined(LIME_FREETYPE) && defined(LIME_HARFBUZZ) + #if defined (LIME_FREETYPE) && defined (LIME_HARFBUZZ) TextLayout *text = new TextLayout (direction, script.c_str (), language.c_str ()); return CFFIPointer (text, gc_text_layout); @@ -1734,9 +3370,25 @@ namespace lime { } + HL_PRIM HL_CFFIPointer* hl_lime_text_layout_create (int direction, vbyte* script, vbyte* language) { + + #if defined (LIME_FREETYPE) && defined (LIME_HARFBUZZ) + + TextLayout *text = new TextLayout (direction, (char*)script, (char*)language); + return HLCFFIPointer (text, (hl_finalizer)hl_gc_text_layout); + + #else + + return 0; + + #endif + + } + + value lime_text_layout_position (value textHandle, value fontHandle, int size, HxString textString, value data) { - #if defined(LIME_FREETYPE) && defined(LIME_HARFBUZZ) + #if defined (LIME_FREETYPE) && defined (LIME_HARFBUZZ) TextLayout *text = (TextLayout*)val_data (textHandle); Font *font = (Font*)val_data (fontHandle); @@ -1751,9 +3403,26 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_text_layout_position (HL_CFFIPointer* textHandle, HL_CFFIPointer* fontHandle, int size, vbyte* textString, HL_Bytes* data) { + + // #if defined(LIME_FREETYPE) && defined(LIME_HARFBUZZ) + + // TextLayout *text = (TextLayout*)val_data (textHandle); + // Font *font = (Font*)val_data (fontHandle); + // Bytes bytes (data); + // text->Position (font, size, textString.c_str (), &bytes); + // return bytes.Value (); + + // #endif + + return 0; + + } + + void lime_text_layout_set_direction (value textHandle, int direction) { - #if defined(LIME_FREETYPE) && defined(LIME_HARFBUZZ) + #if defined (LIME_FREETYPE) && defined (LIME_HARFBUZZ) TextLayout *text = (TextLayout*)val_data (textHandle); text->SetDirection (direction); #endif @@ -1761,9 +3430,19 @@ namespace lime { } + HL_PRIM void hl_lime_text_layout_set_direction (HL_CFFIPointer* textHandle, int direction) { + + #if defined (LIME_FREETYPE) && defined (LIME_HARFBUZZ) + TextLayout *text = (TextLayout*)textHandle->ptr; + text->SetDirection (direction); + #endif + + } + + void lime_text_layout_set_language (value textHandle, HxString language) { - #if defined(LIME_FREETYPE) && defined(LIME_HARFBUZZ) + #if defined (LIME_FREETYPE) && defined (LIME_HARFBUZZ) TextLayout *text = (TextLayout*)val_data (textHandle); text->SetLanguage (language.c_str ()); #endif @@ -1771,9 +3450,19 @@ namespace lime { } + HL_PRIM void hl_lime_text_layout_set_language (HL_CFFIPointer* textHandle, vbyte* language) { + + #if defined (LIME_FREETYPE) && defined (LIME_HARFBUZZ) + TextLayout *text = (TextLayout*)textHandle->ptr; + text->SetLanguage ((char*)language); + #endif + + } + + void lime_text_layout_set_script (value textHandle, HxString script) { - #if defined(LIME_FREETYPE) && defined(LIME_HARFBUZZ) + #if defined (LIME_FREETYPE) && defined (LIME_HARFBUZZ) TextLayout *text = (TextLayout*)val_data (textHandle); text->SetScript (script.c_str ()); #endif @@ -1781,6 +3470,16 @@ namespace lime { } + HL_PRIM void hl_lime_text_layout_set_script (HL_CFFIPointer* textHandle, vbyte* script) { + + #if defined (LIME_FREETYPE) && defined (LIME_HARFBUZZ) + TextLayout *text = (TextLayout*)textHandle->ptr; + text->SetScript ((char*)script); + #endif + + } + + void lime_touch_event_manager_register (value callback, value eventObject) { TouchEvent::callback = new AutoGCRoot (callback); @@ -1789,6 +3488,14 @@ namespace lime { } + HL_PRIM void hl_lime_touch_event_manager_register (vclosure* callback, HL_TouchEvent* eventObject) { + + // TouchEvent::callback = new AutoGCRoot (callback); + // TouchEvent::eventObject = new AutoGCRoot (eventObject); + + } + + void lime_window_alert (value window, HxString message, HxString title) { Window* targetWindow = (Window*)val_data (window); @@ -1832,7 +3539,7 @@ namespace lime { HL_PRIM HL_CFFIPointer* hl_lime_window_create (HL_CFFIPointer* application, int width, int height, int flags, vbyte* title) { Window* window = CreateWindow ((Application*)application->ptr, width, height, flags, (const char*)title); - return HLCFFIPointer (window, gc_window); + return HLCFFIPointer (window, (hl_finalizer)hl_gc_window); } @@ -1845,6 +3552,14 @@ namespace lime { } + HL_PRIM void hl_lime_window_event_manager_register (vclosure* callback, HL_WindowEvent* eventObject) { + + // WindowEvent::callback = new AutoGCRoot (callback); + // WindowEvent::eventObject = new AutoGCRoot (eventObject); + + } + + void lime_window_focus (value window) { Window* targetWindow = (Window*)val_data (window); @@ -1887,6 +3602,17 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_window_get_display_mode (HL_CFFIPointer* window) { + + // Window* targetWindow = (Window*)window->ptr; + // DisplayMode displayMode; + // targetWindow->GetDisplayMode (&displayMode); + // return displayMode.Value (); + return 0; + + } + + bool lime_window_get_enable_text_events (value window) { Window* targetWindow = (Window*)val_data (window); @@ -2042,6 +3768,18 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_window_set_display_mode (HL_CFFIPointer* window, vdynamic* displayMode) { + + // Window* targetWindow = (Window*)val_data (window); + // DisplayMode _displayMode (displayMode); + // targetWindow->SetDisplayMode (&_displayMode); + // targetWindow->GetDisplayMode (&_displayMode); + // return _displayMode.Value (); + return 0; + + } + + void lime_window_set_enable_text_events (value window, bool enabled) { Window* targetWindow = (Window*)val_data (window); @@ -2066,6 +3804,14 @@ namespace lime { } + HL_PRIM bool hl_lime_window_set_fullscreen (HL_CFFIPointer* window, bool fullscreen) { + + Window* targetWindow = (Window*)window->ptr; + return targetWindow->SetFullscreen (fullscreen); + + } + + void lime_window_set_icon (value window, value buffer) { Window* targetWindow = (Window*)val_data (window); @@ -2075,6 +3821,15 @@ namespace lime { } + HL_PRIM void hl_lime_window_set_icon (HL_CFFIPointer* window, HL_ImageBuffer* buffer) { + + Window* targetWindow = (Window*)window->ptr; + ImageBuffer imageBuffer = ImageBuffer (buffer); + targetWindow->SetIcon (&imageBuffer); + + } + + bool lime_window_set_maximized (value window, bool maximized) { Window* targetWindow = (Window*)val_data(window); @@ -2083,6 +3838,14 @@ namespace lime { } + HL_PRIM bool hl_lime_window_set_maximized (HL_CFFIPointer* window, bool maximized) { + + Window* targetWindow = (Window*)window->ptr; + return targetWindow->SetMaximized (maximized); + + } + + bool lime_window_set_minimized (value window, bool minimized) { Window* targetWindow = (Window*)val_data (window); @@ -2091,6 +3854,14 @@ namespace lime { } + HL_PRIM bool hl_lime_window_set_minimized (HL_CFFIPointer* window, bool minimized) { + + Window* targetWindow = (Window*)window->ptr; + return targetWindow->SetMinimized (minimized); + + } + + bool lime_window_set_resizable (value window, bool resizable) { Window* targetWindow = (Window*)val_data (window); @@ -2099,6 +3870,14 @@ namespace lime { } + HL_PRIM bool hl_lime_window_set_resizable (HL_CFFIPointer* window, bool resizable) { + + Window* targetWindow = (Window*)window->ptr; + return targetWindow->SetResizable (resizable); + + } + + value lime_window_set_title (value window, HxString title) { Window* targetWindow = (Window*)val_data (window); @@ -2125,6 +3904,33 @@ namespace lime { } + HL_PRIM vbyte* hl_lime_window_set_title (HL_CFFIPointer* window, vbyte* title) { + + Window* targetWindow = (Window*)window->ptr; + const char* result = targetWindow->SetTitle ((char*)title); + + if (result) { + + // value _result = alloc_string (result); + + // if (result != title.c_str ()) { + + // free ((char*) result); + + // } + + // return _result; + return (vbyte*)result; + + } else { + + return 0; + + } + + } + + value lime_zlib_compress (value buffer, value bytes) { #ifdef LIME_ZLIB @@ -2141,6 +3947,22 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_zlib_compress (HL_Bytes* buffer, HL_Bytes* bytes) { + + // #ifdef LIME_ZLIB + // Bytes data (buffer); + // Bytes result (bytes); + + // Zlib::Compress (ZLIB, &data, &result); + + // return result.Value (); + // #else + return 0; + // #endif + + } + + value lime_zlib_decompress (value buffer, value bytes) { #ifdef LIME_ZLIB @@ -2157,6 +3979,22 @@ namespace lime { } + HL_PRIM vdynamic* hl_lime_zlib_decompress (HL_Bytes* buffer, HL_Bytes* bytes) { + + // #ifdef LIME_ZLIB + // Bytes data (buffer); + // Bytes result (bytes); + + // Zlib::Decompress (ZLIB, &data, &result); + + // return result.Value (); + // #else + return 0; + // #endif + + } + + DEFINE_PRIME0 (lime_application_create); DEFINE_PRIME2v (lime_application_event_manager_register); DEFINE_PRIME1 (lime_application_exec); diff --git a/project/src/system/CFFIPointer.cpp b/project/src/system/CFFIPointer.cpp index eb366f1d6..6952cbc6b 100644 --- a/project/src/system/CFFIPointer.cpp +++ b/project/src/system/CFFIPointer.cpp @@ -40,12 +40,12 @@ namespace lime { } - HL_CFFIPointer* HLCFFIPointer (void* handle, hx::finalizer finalizer) { + HL_CFFIPointer* HLCFFIPointer (void* handle, hl_finalizer finalizer) { if (handle) { HL_CFFIPointer* pointer = (HL_CFFIPointer*)hl_gc_alloc_finalizer (sizeof (HL_CFFIPointer)); - pointer->finalizer = finalizer ? finalizer : 0; + pointer->finalizer = finalizer ? (void*)finalizer : 0; pointer->ptr = handle; return pointer;