Simba 2.0 fixes/features.

RemoteInput/EIOS.cxx

@@ -436,13 +436,10 @@ EIOS* SimbaPluginTarget_RequestWithDebugImage(const char* initargs, void** image
         std::int32_t width = 0;
         std::int32_t height = 0;
         eios->control_center->get_target_dimensions(&width, &height);
-
+        eios->control_center->set_image_format(ImageFormat::BGRA);
+        eios->control_center->set_debug_graphics(true);
         *image = PLUGIN_SIMBA_METHODS.ExternalImage_Create(true);
-        PLUGIN_SIMBA_METHODS.ExternalImage_SetMemory(*image, EIOS_GetImageBuffer(eios), width, height);
-
-        PLUGIN_SIMBA_METHODS.ExternalImage_AddCallbackOnUnlock(*image, []{
-
-        });
+        PLUGIN_SIMBA_METHODS.ExternalImage_SetMemory(*image, eios->control_center->get_debug_image(), width, height);         
     }
 
     return eios;
@@ -458,28 +455,32 @@ void SimbaPluginTarget_GetDimensions(EIOS* eios, std::int32_t* width, std::int32
     EIOS_GetTargetDimensions(eios, width, height);
 }
 
-void SimbaPluginTarget_GetImageData(EIOS* eios, std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height, void** pColorBGRA, std::int32_t* data_width) noexcept
+bool SimbaPluginTarget_GetImageData(EIOS* eios, std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height, void** bgra, std::int32_t* data_width) noexcept
 {
-    std::uint8_t* image_buffer = EIOS_GetImageBuffer(eios);
-    *pColorBGRA = &image_buffer[y * width + x];
-    *data_width = width;
+    if (eios) 
+    {
+        *data_width = eios->control_center->get_target_width();
+        *bgra = &eios->control_center->get_image()[(y * (*data_width) + x) * 4];
+
+        return true;
+    } else {
+        return false;
+    }
 }
 
 bool SimbaPluginTarget_MousePressed(EIOS* eios, int mouse_button) noexcept
 {
     return EIOS_IsMouseButtonHeld(eios, mouse_button);
 }
 
-TPoint SimbaPluginTarget_MousePosition(EIOS* eios) noexcept
+void SimbaPluginTarget_MousePosition(EIOS* eios, std::int32_t* x, std::int32_t* y) noexcept
 {
-    std::int32_t x, y;
-    EIOS_GetMousePosition(eios, &x, &y);
-    return {x, y};
+    EIOS_GetMousePosition(eios, x, y);
 }
 
-void SimbaPluginTarget_Teleport(EIOS* eios, const TPoint &p) noexcept
+void SimbaPluginTarget_MouseTeleport(EIOS* eios, std::int32_t x, std::int32_t y) noexcept
 {
-    EIOS_MoveMouse(eios, p.x, p.y);
+    EIOS_MoveMouse(eios, x, y);
 }
 
 void SimbaPluginTarget_MouseUp(EIOS* eios, int mouse_button) noexcept
@@ -507,11 +508,11 @@ void SimbaPluginTarget_KeyUp(EIOS* eios, std::int32_t key) noexcept
     EIOS_ReleaseKey(eios, key);
 }
 
-void SimbaPluginTarget_KeySend(EIOS* eios, char key, std::int32_t key_down_time, std::int32_t key_up_time, std::int32_t modifier_down_time, std::int32_t modifier_up_time) noexcept
+void SimbaPluginTarget_KeySend(EIOS* eios, char* text, std::int32_t len, std::int32_t* sleeptimes) noexcept
 {
     if (eios)
     {
-        eios->control_center->send_key(key, key_down_time, key_up_time, modifier_down_time, modifier_up_time);
+        eios->control_center->key_send(text, len, sleeptimes);
     }
 }
 

RemoteInput/EIOS.hxx

@@ -78,41 +78,21 @@ EXPORT void STD_CALL EIOS_KillZombieClients() noexcept;
 EXPORT std::size_t STD_CALL EIOS_GetClients(bool unpaired_only) noexcept;
 EXPORT std::int32_t STD_CALL EIOS_GetClientPID(std::size_t index) noexcept;
 
-#ifdef __cplusplus
-}
-#endif
-
-typedef struct
-{
-    std::int32_t x;
-    std::int32_t y;
-} __attribute__((__packed__)) TPoint;
-
-class TSimbaExternalImage
-{
-public:
-    TSimbaExternalImage() {}
-    ~TSimbaExternalImage() {}
-};
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
+// New in Simba 2.0 https://villavu.github.io/Simba/tutorials/plugins/plugin-target.html
 EXPORT EIOS* SimbaPluginTarget_Request(const char* initargs) noexcept;
 EXPORT EIOS* SimbaPluginTarget_RequestWithDebugImage(const char* initargs, void** image) noexcept;
 EXPORT void SimbaPluginTarget_Release(EIOS* eios) noexcept;
 EXPORT void SimbaPluginTarget_GetDimensions(EIOS* eios, std::int32_t* width, std::int32_t* height) noexcept;
-EXPORT void SimbaPluginTarget_GetImageData(EIOS* eios, std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height, void** pColorBGRA, std::int32_t* data_width) noexcept;
+EXPORT bool SimbaPluginTarget_GetImageData(EIOS* eios, std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height, void** bgra, std::int32_t* data_width) noexcept;
 EXPORT bool SimbaPluginTarget_MousePressed(EIOS* eios, int mouse_button) noexcept;
-EXPORT TPoint SimbaPluginTarget_MousePosition(EIOS* eios) noexcept;
-EXPORT void SimbaPluginTarget_Teleport(EIOS* eios, const TPoint &p) noexcept;
+EXPORT void SimbaPluginTarget_MousePosition(EIOS* eios, std::int32_t* x, std::int32_t* y) noexcept;
+EXPORT void SimbaPluginTarget_MouseTeleport(EIOS* eios, std::int32_t x, std::int32_t y) noexcept;
 EXPORT void SimbaPluginTarget_MouseUp(EIOS* eios, int mouse_button) noexcept;
 EXPORT void SimbaPluginTarget_MouseDown(EIOS* eios, int mouse_button) noexcept;
 EXPORT void SimbaPluginTarget_MouseScroll(EIOS* eios, int scrolls) noexcept;
 EXPORT void SimbaPluginTarget_KeyDown(EIOS* eios, std::int32_t key) noexcept;
 EXPORT void SimbaPluginTarget_KeyUp(EIOS* eios, std::int32_t key) noexcept;
-EXPORT void SimbaPluginTarget_KeySend(EIOS* eios, char key, std::int32_t key_down_time, std::int32_t key_up_time, std::int32_t modifier_down_time, std::int32_t modifier_up_time) noexcept;
+EXPORT void SimbaPluginTarget_KeySend(EIOS* eios, char* text, std::int32_t len, std::int32_t* sleeptimes) noexcept;
 EXPORT bool SimbaPluginTarget_KeyPressed(EIOS* eios, std::int32_t key) noexcept;
 
 #ifdef __cplusplus

RemoteInput/EIOSTypes.hxx

@@ -39,6 +39,7 @@ enum class EIOSCommand: std::uint32_t
     IS_MOUSE_HELD,
     SEND_STRING,
     SEND_KEY,
+    KEY_SEND,
     HOLD_KEY,
     RELEASE_KEY,
     IS_KEY_HELD,

RemoteInput/Plugin/ControlCenter.cxx

@@ -333,6 +333,19 @@ void ControlCenter::process_command() noexcept
         }
             break;
 
+        case EIOSCommand::KEY_SEND:
+        {
+            std::string string = stream.read<std::string>();
+            std::vector<std::int32_t> sleeps;
+
+            // Simba sends string.length*4 of sleep times to control the speed of typing
+            sleeps.resize(string.length() * 4);
+            stream.read(sleeps.data(), (string.length() * 4) * sizeof(int32_t));
+
+            io_controller->key_send(string, sleeps);
+        }
+            break;
+
         case EIOSCommand::HOLD_KEY:
         {
             std::int32_t keycode = stream.read<std::int32_t>();
@@ -1474,6 +1487,15 @@ void ControlCenter::send_key(char key, std::int32_t key_down_time, std::int32_t
     });
 }
 
+void ControlCenter::key_send(const char* string, std::int32_t len, std::int32_t* sleeptimes) const noexcept
+{
+    send_command([string, len, sleeptimes](Stream &stream, ImageData* image_data) {
+        image_data->set_command(EIOSCommand::KEY_SEND);
+        image_data->data_stream() << std::string(string, len);
+        stream.write(sleeptimes, (len * 4) * sizeof(int32_t));
+    });    
+}
+
 void ControlCenter::hold_key(std::int32_t key) const noexcept
 {
     send_command([key](Stream &stream, ImageData* image_data) {

RemoteInput/Plugin/ControlCenter.hxx

@@ -106,6 +106,7 @@ public:
     bool is_mouse_held(std::int32_t button) const noexcept;
     void send_string(const char* string, std::int32_t keywait, std::int32_t keymodwait) const noexcept;
     void send_key(char key, std::int32_t key_down_time, std::int32_t key_up_time, std::int32_t modifier_down_time, std::int32_t modifier_up_time) const noexcept;
+    void key_send(const char* string, std::int32_t len, std::int32_t* sleeptimes) const noexcept;
     void hold_key(std::int32_t key) const noexcept;
     void release_key(std::int32_t key) const noexcept;
     bool is_key_held(std::int32_t key) const noexcept;

RemoteInput/Plugin/InputOutput.cxx

@@ -679,6 +679,120 @@ void InputOutput::send_key(char key, std::int32_t key_down_time, std::int32_t ke
     }
 }
 
+void InputOutput::key_send(std::string string, std::vector<std::int32_t> sleeptimes) const noexcept
+{
+    extern std::unique_ptr<ControlCenter> control_center;
+    if (!control_center)
+    {
+        return;
+    }
+
+    java::Component receiver = control_center->reflect_canvas();
+    JNIEnv* env = receiver.getEnv();
+
+    if (!this->has_focus(&receiver))
+    {
+        this->gain_focus(&receiver);
+    }
+
+    bool isShiftDown = false;
+    std::int32_t sleepindex = 0;
+
+    for (std::size_t i = 0; i < string.length(); ++i)
+    {
+        char c = string[i];
+        char n = i == string.length() - 1 ? '\0' : string[i + 1];
+        std::int32_t modifiers = this->ModifiersForChar(c);
+
+        //Modifier Key
+        if (modifiers & java::InputEvent::InputEventMasks::SHIFT_DOWN_MASK)
+        {
+            if (!isShiftDown)
+            {
+                isShiftDown = true;
+
+                std::int32_t code = VK_LSHIFT;
+                std::int64_t when = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+                std::int32_t modifiers = java::InputEvent::InputEventMasks::SHIFT_DOWN_MASK;
+                std::int32_t keycode = GetJavaKeyCode(code);
+                std::int32_t location = GetKeyLocation(code);
+
+                java::KeyEvent::Post(env,
+                                     &receiver,
+                                     java::KeyEvent::KeyCodes::KEY_PRESSED,
+                                     when,
+                                     modifiers,
+                                     keycode,
+                                     static_cast<jchar>(java::KeyEvent::KeyCodes::CHAR_UNDEFINED),
+                                     location);
+
+                yield_thread(std::chrono::milliseconds(sleeptimes[sleepindex++]));
+            }
+        }
+
+        //Character Key
+        std::int32_t code = static_cast<std::int32_t>(c);
+        std::int64_t when = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+        std::int32_t keycode = CharToJavaKeyCode(code);
+        std::int32_t location = GetKeyLocation(code);
+
+        java::KeyEvent::Post(env,
+                             &receiver,
+                             java::KeyEvent::KeyCodes::KEY_PRESSED,
+                             when,
+                             modifiers,
+                             keycode,
+                             static_cast<jchar>(c),
+                             location);
+
+        java::KeyEvent::Post(env,
+                             &receiver,
+                             java::KeyEvent::KeyCodes::KEY_TYPED,
+                             when,
+                             modifiers,
+                             0,
+                             static_cast<jchar>(c),
+                             java::KeyEvent::KeyCodes::KEY_LOCATION_UNKNOWN);
+
+        yield_thread(std::chrono::milliseconds(sleeptimes[sleepindex++]));
+        when = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+
+        java::KeyEvent::Post(env,
+                             &receiver,
+                             java::KeyEvent::KeyCodes::KEY_RELEASED,
+                             when,
+                             modifiers,
+                             keycode,
+                             static_cast<jchar>(c),
+                             location);
+
+        yield_thread(std::chrono::milliseconds(sleeptimes[sleepindex++]));
+
+        //Modifier Key
+        if ((isShiftDown && i == string.length() - 1) || (n != '\0' && !(this->ModifiersForChar(n) & java::InputEvent::InputEventMasks::SHIFT_DOWN_MASK)))
+        {
+            isShiftDown = false;
+
+            std::int32_t code = VK_LSHIFT;
+            std::int64_t when = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+            std::int32_t modifiers = java::InputEvent::InputEventMasks::SHIFT_DOWN_MASK;
+            std::int32_t keycode = GetJavaKeyCode(code);
+            std::int32_t location = GetKeyLocation(code);
+
+            java::KeyEvent::Post(env,
+                                 &receiver,
+                                 java::KeyEvent::KeyCodes::KEY_RELEASED,
+                                 when,
+                                 modifiers,
+                                 keycode,
+                                 static_cast<jchar>(java::KeyEvent::KeyCodes::CHAR_UNDEFINED),
+                                 location);
+
+            yield_thread(std::chrono::milliseconds(sleeptimes[sleepindex++]));
+        }
+    }
+}
+
 bool InputOutput::has_focus() const noexcept
 {
     extern std::unique_ptr<ControlCenter> control_center;

RemoteInput/Plugin/InputOutput.hxx

@@ -79,7 +79,8 @@ public:
     bool is_key_held(std::int32_t code) const noexcept;
     void send_string(std::string string, std::int32_t keywait, std::int32_t keymodwait) const noexcept;
     void send_key(char key, std::int32_t key_down_time, std::int32_t key_up_time, std::int32_t modifier_down_time, std::int32_t modifier_up_time) const noexcept;
-
+    void key_send(std::string string, std::vector<std::int32_t> sleeptimes) const noexcept;
+
     void get_mouse_position(std::int32_t* x, std::int32_t* y) noexcept;
     void get_real_mouse_position(std::int32_t* x, std::int32_t* y) const noexcept;
     void move_mouse(std::int32_t x, std::int32_t y) noexcept;

RemoteInput/Plugin/TMemoryManager.hxx

@@ -103,6 +103,7 @@ STRUCT_PACK(typedef struct
     void(*RaiseException)(const char* message);
 
     void* (*GetTypeInfo)(void* Compiler, const char* Type);
+    void* (*GetTypeInfoSize)(void* TypeInfo);
     std::size_t (*GetTypeInfoFieldOffset)(void* TypeInfo, const char* FieldName);
 
     void* (*AllocateRawArray)(std::size_t element_size, std::size_t length);
@@ -111,17 +112,15 @@ STRUCT_PACK(typedef struct
     void* (*AllocateArray)(void* TypeInfo, std::size_t length);
     void* (*AllocateString)(const char* data);
     void* (*AllocateUnicodeString)(const wchar_t* data);
+
     void (*SetArrayLength)(void* TypeInfo, void** var, std::size_t new_len);
     std::size_t (*GetArrayLength)(void* array);
 
-    void* (*ExternalImage_Create)(bool FreeOnTerminate);
+    void* (*ExternalImage_Create)(bool AutoResize);
     void (*ExternalImage_SetMemory)(void* img, void* bgra_data, std::int32_t width, std::int32_t height);
-    bool (*ExternalImage_TryLock)(void* image);
-    void (*ExternalImage_Lock)(void* image);
-    void (*ExternalImage_UnLock)(void* image);
-
-    void (*ExternalImage_AddCallbackOnUnlock)(void* img, void (*callback)());
-    void (*ExternalImage_RemoveCallbackOnUnlock)(void* img, void (*callback)());
+    void (*ExternalImage_Resize)(void* img, std::int32_t new_width, std::int32_t new_height);
+    void (*ExternalImage_SetUserData)(void* img, void* userdata);
+    void* (*ExternalImage_GetUserData)(void* img);
 }) TSimbaMethodsExtended;
 
 #endif // TMEMORYMANAGER_HXX_INCLUDED