codm/ligma-cheat/ligma-cheat/SDK/unityengine.dll/includes/unityengine/texteditor.h

#pragma once
#include <il2cpp/il2cpp.h>
namespace unityengine {

    class texteditor {
      public:
        template <typename T = std::uintptr_t> T &keyboardonscreen() {
            return *(T *)((std::uintptr_t)this + 0x8);
        }
        template <typename T = std::int32_t> T &controlid() {
            return *(T *)((std::uintptr_t)this + 0xC);
        }
        template <typename T = std::uintptr_t> T &style() {
            return *(T *)((std::uintptr_t)this + 0x10);
        }
        template <typename T = bool> T &multiline() {
            return *(T *)((std::uintptr_t)this + 0x14);
        }
        template <typename T = bool> T &hashorizontalcursorpos() {
            return *(T *)((std::uintptr_t)this + 0x15);
        }
        template <typename T = bool> T &ispasswordfield() {
            return *(T *)((std::uintptr_t)this + 0x16);
        }
        template <typename T = bool> T &m_hasfocus() {
            return *(T *)((std::uintptr_t)this + 0x17);
        }
        template <typename T = il2cpp_vec2> T &scrolloffset() {
            return *(T *)((std::uintptr_t)this + 0x18);
        }
        template <typename T = std::uintptr_t> T &m_content() {
            return *(T *)((std::uintptr_t)this + 0x20);
        }
        template <typename T = il2cpp_rect> T &m_position() {
            return *(T *)((std::uintptr_t)this + 0x24);
        }
        template <typename T = std::int32_t> T &m_cursorindex() {
            return *(T *)((std::uintptr_t)this + 0x34);
        }
        template <typename T = std::int32_t> T &m_selectindex() {
            return *(T *)((std::uintptr_t)this + 0x38);
        }
        template <typename T = bool> T &m_revealcursor() {
            return *(T *)((std::uintptr_t)this + 0x3C);
        }
        template <typename T = il2cpp_vec2> T &graphicalcursorpos() {
            return *(T *)((std::uintptr_t)this + 0x40);
        }
        template <typename T = il2cpp_vec2> T &graphicalselectcursorpos() {
            return *(T *)((std::uintptr_t)this + 0x48);
        }
        template <typename T = bool> T &m_mousedragselectswholewords() {
            return *(T *)((std::uintptr_t)this + 0x50);
        }
        template <typename T = std::int32_t> T &m_dblclickinitpos() {
            return *(T *)((std::uintptr_t)this + 0x54);
        }
        template <typename T = std::uintptr_t> T &m_dblclicksnap() {
            return *(T *)((std::uintptr_t)this + 0x58);
        }
        template <typename T = bool> T &m_bjustselected() {
            return *(T *)((std::uintptr_t)this + 0x59);
        }
        template <typename T = std::int32_t> T &m_ialtcursorpos() {
            return *(T *)((std::uintptr_t)this + 0x5C);
        }
        template <typename T = il2cpp_string *> T &oldtext() {
            return *(T *)((std::uintptr_t)this + 0x60);
        }
        template <typename T = std::int32_t> T &oldpos() {
            return *(T *)((std::uintptr_t)this + 0x64);
        }
        template <typename T = std::int32_t> T &oldselectpos() {
            return *(T *)((std::uintptr_t)this + 0x68);
        }

        template <typename T = il2cpp_string *> T get_text() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C0A94))(
                this);
        }

        template <typename T = void> T set_text(il2cpp_string *_value) {
            return ((T(*)(texteditor *, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x59C0AC0))(this, _value);
        }

        template <typename T = il2cpp_rect> T get_position() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C0BF4))(
                this);
        }

        template <typename T = void> T set_position(il2cpp_rect _value) {
            return ((T(*)(texteditor *, il2cpp_rect))(il2cpp::il2cpp_base() +
                                                      0x59C0C04))(this, _value);
        }

        template <typename T = std::int32_t> T get_cursorindex() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C11A8))(
                this);
        }

        template <typename T = void> T set_cursorindex(std::int32_t _value) {
            return ((T(*)(texteditor *, std::int32_t))(
                il2cpp::il2cpp_base() + 0x59C11B0))(this, _value);
        }

        template <typename T = std::int32_t> T get_selectindex() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C11E4))(
                this);
        }

        template <typename T = void> T set_selectindex(std::int32_t _value) {
            return ((T(*)(texteditor *, std::int32_t))(
                il2cpp::il2cpp_base() + 0x59C11EC))(this, _value);
        }

        template <typename T = void> T clearcursorpos() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C11FC))(
                this);
        }

        template <typename T = void> T onfocus() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C1210))(
                this);
        }

        template <typename T = void> T onlostfocus() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C12FC))(
                this);
        }

        template <typename T = void> T grabgraphicalcursorpos() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C1310))(
                this);
        }

        template <typename T = bool> T handlekeyevent(std::uintptr_t _e) {
            return ((T(*)(texteditor *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                         0x59C13C4))(this, _e);
        }

        template <typename T = bool> T deletelineback() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C21E8))(
                this);
        }

        template <typename T = bool> T deletewordback() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C2590))(
                this);
        }

        template <typename T = bool> T deletewordforward() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C273C))(
                this);
        }

        template <typename T = bool> T _delete () {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C29D0))(
                this);
        }

        template <typename T = bool> T backspace() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C2A74))(
                this);
        }

        template <typename T = void> T selectall() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C127C))(
                this);
        }

        template <typename T = void> T selectnone() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C2B4C))(
                this);
        }

        template <typename T = bool> T get_hasselection() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C22EC))(
                this);
        }

        template <typename T = bool> T deleteselection() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C2304))(
                this);
        }

        template <typename T = void>
        T replaceselection(il2cpp_string *_replace) {
            return ((T(*)(texteditor *, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x59C2B80))(this, _replace);
        }

        template <typename T = void> T insert(char _c) {
            return ((T(*)(texteditor *, char))(il2cpp::il2cpp_base() +
                                               0x59C2C44))(this, _c);
        }

        template <typename T = void> T moveright() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C2C78))(
                this);
        }

        template <typename T = void> T moveleft() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C2E4C))(
                this);
        }

        template <typename T = void> T moveup() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C2EE0))(
                this);
        }

        template <typename T = void> T movedown() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C2FF0))(
                this);
        }

        template <typename T = void> T movelinestart() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C313C))(
                this);
        }

        template <typename T = void> T movelineend() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C3210))(
                this);
        }

        template <typename T = void> T movegraphicallinestart() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C32F0))(
                this);
        }

        template <typename T = void> T movegraphicallineend() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C33F0))(
                this);
        }

        template <typename T = void> T movetextstart() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C3504))(
                this);
        }

        template <typename T = void> T movetextend() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C354C))(
                this);
        }

        template <typename T = std::int32_t>
        T indexofendofline(std::int32_t _startindex) {
            return ((T(*)(texteditor *, std::int32_t))(
                il2cpp::il2cpp_base() + 0x59C35B8))(this, _startindex);
        }

        template <typename T = void> T moveparagraphforward() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C3614))(
                this);
        }

        template <typename T = void> T moveparagraphbackward() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C36D8))(
                this);
        }

        template <typename T = void>
        T movecursortoposition(il2cpp_vec2 _cursorposition) {
            return ((T(*)(texteditor *, il2cpp_vec2))(
                il2cpp::il2cpp_base() + 0x59C37C8))(this, _cursorposition);
        }

        template <typename T = void>
        T selecttoposition(il2cpp_vec2 _cursorposition) {
            return ((T(*)(texteditor *, il2cpp_vec2))(
                il2cpp::il2cpp_base() + 0x59C38D0))(this, _cursorposition);
        }

        template <typename T = void> T selectleft() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C3D98))(
                this);
        }

        template <typename T = void> T selectright() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C3E2C))(
                this);
        }

        template <typename T = void> T selectup() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C3EC0))(
                this);
        }

        template <typename T = void> T selectdown() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C3F54))(
                this);
        }

        template <typename T = void> T selecttextend() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4010))(
                this);
        }

        template <typename T = void> T selecttextstart() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4068))(
                this);
        }

        template <typename T = void> T mousedragselectswholewords(bool _on) {
            return ((T(*)(texteditor *, bool))(il2cpp::il2cpp_base() +
                                               0x59C40A4))(this, _on);
        }

        template <typename T = void> T dblclicksnap(std::uintptr_t _snapping) {
            return ((T(*)(texteditor *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x59C40B4))(this, _snapping);
        }

        template <typename T = std::int32_t>
        T getgraphicallinestart(std::int32_t _p) {
            return ((T(*)(texteditor *, std::int32_t))(il2cpp::il2cpp_base() +
                                                       0x59C336C))(this, _p);
        }

        template <typename T = std::int32_t>
        T getgraphicallineend(std::int32_t _p) {
            return ((T(*)(texteditor *, std::int32_t))(il2cpp::il2cpp_base() +
                                                       0x59C346C))(this, _p);
        }

        template <typename T = std::int32_t>
        T findnextseperator(std::int32_t _startpos) {
            return ((T(*)(texteditor *, std::int32_t))(
                il2cpp::il2cpp_base() + 0x59C40BC))(this, _startpos);
        }

        template <typename T = bool> static T isletterlikechar(char _c) {
            return ((T(*)(void *, char))(il2cpp::il2cpp_base() + 0x59C4174))(
                0, _c);
        }

        template <typename T = std::int32_t>
        T findprevseperator(std::int32_t _startpos) {
            return ((T(*)(texteditor *, std::int32_t))(
                il2cpp::il2cpp_base() + 0x59C422C))(this, _startpos);
        }

        template <typename T = void> T movewordright() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C42E0))(
                this);
        }

        template <typename T = void> T movetostartofnextword() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C438C))(
                this);
        }

        template <typename T = void> T movetoendofpreviousword() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4410))(
                this);
        }

        template <typename T = void> T selecttostartofnextword() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4494))(
                this);
        }

        template <typename T = void> T selecttoendofpreviousword() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C44E8))(
                this);
        }

        template <typename T = std::uintptr_t> T classifychar(char _c) {
            return ((T(*)(texteditor *, char))(il2cpp::il2cpp_base() +
                                               0x59C453C))(this, _c);
        }

        template <typename T = std::int32_t>
        T findstartofnextword(std::int32_t _p) {
            return ((T(*)(texteditor *, std::int32_t))(il2cpp::il2cpp_base() +
                                                       0x59C27EC))(this, _p);
        }

        template <typename T = std::int32_t>
        T findendofpreviousword(std::int32_t _p) {
            return ((T(*)(texteditor *, std::int32_t))(il2cpp::il2cpp_base() +
                                                       0x59C2664))(this, _p);
        }

        template <typename T = void> T movewordleft() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4648))(
                this);
        }

        template <typename T = void> T selectwordright() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C46E0))(
                this);
        }

        template <typename T = void> T selectwordleft() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4770))(
                this);
        }

        template <typename T = void> T expandselectgraphicallinestart() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4800))(
                this);
        }

        template <typename T = void> T expandselectgraphicallineend() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C48A4))(
                this);
        }

        template <typename T = void> T selectgraphicallinestart() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4948))(
                this);
        }

        template <typename T = void> T selectgraphicallineend() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C499C))(
                this);
        }

        template <typename T = void> T selectparagraphforward() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C49F0))(
                this);
        }

        template <typename T = void> T selectparagraphbackward() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4AB0))(
                this);
        }

        template <typename T = void> T selectcurrentword() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4BB8))(
                this);
        }

        template <typename T = std::int32_t>
        T findendofclassification(std::int32_t _p, std::int32_t _dir) {
            return ((T(*)(texteditor *, std::int32_t, std::int32_t))(
                il2cpp::il2cpp_base() + 0x59C3CCC))(this, _p, _dir);
        }

        template <typename T = void> T selectcurrentparagraph() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C4D28))(
                this);
        }

        template <typename T = void>
        T updatescrolloffsetifneeded(std::uintptr_t _evt) {
            return ((T(*)(texteditor *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x59C4DF4))(this, _evt);
        }

        template <typename T = void> T updatescrolloffset() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C0C7C))(
                this);
        }

        template <typename T = void> T drawcursor(il2cpp_string *_newtext) {
            return ((T(*)(texteditor *, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x59C4E58))(this, _newtext);
        }

        template <typename T = bool>
        T performoperation(std::uintptr_t _operation) {
            return ((T(*)(texteditor *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x59C1D00))(this, _operation);
        }

        template <typename T = void> T savebackup() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C56C0))(
                this);
        }

        template <typename T = bool> T cut() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C5434))(
                this);
        }

        template <typename T = void> T copy() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C5464))(
                this);
        }

        template <typename T = il2cpp_string *>
        static T replacenewlineswithspaces(il2cpp_string *_value) {
            return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
                                                    0x59C56E8))(0, _value);
        }

        template <typename T = bool> T paste() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C557C))(
                this);
        }

        template <typename T = void>
        static T mapkey(il2cpp_string *_key, std::uintptr_t _action) {
            return ((T(*)(void *, il2cpp_string *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x59C57C4))(0, _key, _action);
        }

        template <typename T = void> T initkeyactions() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C154C))(
                this);
        }

        template <typename T = void> T detectfocuschange() {
            return ((T(*)(texteditor *))(il2cpp::il2cpp_base() + 0x59C2D18))(
                this);
        }

        template <typename T = void> T clamptextindex(std::uintptr_t _index) {
            return ((T(*)(texteditor *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x59C0B08))(this, _index);
        }
    };

} // namespace unityengine