AUI.cs

#region Header
/*
    ==============================================================================
      Author: Zoltan Hrabovszki <zh@openkeyword.de>

      Copyright © 2012, 2013, 2014, 2015 IT-Beratung Hrabovszki
      www.OpenKeyWord.de
    ============================================================================== 

    This file is part of OpenKeyWord.

    OpenKeyWord is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    OpenKeyWord is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with OpenKeyWord.  If not, see <http://www.gnu.org/licenses/>.

    Diese Datei ist Teil von OpenKeyWord.

    OpenKeyWord ist Freie Software: Sie können es unter den Bedingungen
    der GNU General Public License, wie von der Free Software Foundation,
    Version 3 der Lizenz oder (nach Ihrer Wahl) jeder späteren
    veröffentlichten Version, weiterverbreiten und/oder modifizieren.

    OpenKeyWord wird in der Hoffnung, dass es nützlich sein wird, aber
    OHNE JEDE GEWÄHRLEISTUNG, bereitgestellt; sogar ohne die implizite
    Gewährleistung der MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK.
    Siehe die GNU General Public License für weitere Details.

    Sie sollten eine Kopie der GNU General Public License zusammen mit 
    OpenKeyWord erhalten haben. Wenn nicht, siehe <http://www.gnu.org/licenses/>.
*/
#endregion Header

namespace OKW.GUI.AUI
{
    using System;
    using System.Collections.Generic;
    using System.Runtime.InteropServices;
    using System.Text;

    public class AutoItX_NONO
    {
        #region Fields

        public const int AU3_INTDEFAULT = -2147483647; // "Default" value for _some_ int parameters(largest negative number)
        public const int ERROR = 1;
        public const int SW_HIDE = 2;
        public const int SW_MAXIMIZE = 3;
        public const int SW_MINIMIZE = 4;
        public const int SW_RESTORE = 5;
        public const int SW_SHOW = 6;
        public const int SW_SHOWDEFAULT = 7;
        public const int SW_SHOWMAXIMIZED = 8;
        public const int SW_SHOWMINIMIZED = 9;
        public const int SW_SHOWMINNOACTIVE = 10;
        public const int SW_SHOWNA = 11;
        public const int SW_SHOWNOACTIVATE = 12;
        public const int SW_SHOWNORMAL = 13;
        public const int VERSION = 109;

        const string AUTOITX3_DLL = @"C:\Program Files(x86)\AutoIt3\AutoItX\AutoItX3.dll";

        #endregion Fields

        #region Methods

        public static void BlockInput(int flag)
        {
            AU3_BlockInput(flag);
        }

        public static int ControlClick(
            string fpsTitle,
            string vsText,
            string vsControl,
            string vsButton,
            int viNumClicks,
            int viX,
            int viY)
        {
            return AU3_ControlClick(fpsTitle, vsText, vsControl, vsButton, viNumClicks, viX, viY);
        }

        public static int ControlClick(string fpsTitle, string vsControl)
        {
            return AU3_ControlClick(fpsTitle, string.Empty, vsControl, string.Empty, 1, 0, 0);
        }

        public static int ControlDisable(string fpsTitle, string vsText, string vsControl)
        {
            return AU3_ControlDisable(fpsTitle, vsText, vsControl);
        }

        public static int ControlEnable(string fpsTitle, string vsText, string vsControl)
        {
            return AU3_ControlEnable(fpsTitle, vsText, vsControl);
        }

        public static int ControlFocus(string fpsTitle, string vsText, string vsControl)
        {
            return AU3_ControlFocus(fpsTitle, vsText, vsControl);
        }

        public static int ControlFocus(string fpsTitle, string vsControl)
        {
            return AU3_ControlFocus(fpsTitle, string.Empty, vsControl);
        }

        public static string ControlGetHandle(string fpsTitle, string vsText, string vsControl)
        {
            //----------------------------------------------------------------------
            // A number big enought to hold result, trailing bytes will be 0
            //----------------------------------------------------------------------
            byte[] RetText = new byte[50];

            AU3_ControlGetHandle(fpsTitle, vsText, vsControl, RetText, RetText.Length);

            //----------------------------------------------------------------------
            // May need to convert back to a string or int
            //----------------------------------------------------------------------
            return Encoding.ASCII.GetString(RetText).TrimEnd('\0');
        }

        public static Position2D ControlGetPos(string fpsTitle, string vsText, string vsControl)
        {
            Position2D pos;
            pos.X = AU3_ControlGetPosX(fpsTitle, vsText, vsControl);
            pos.Y = AU3_ControlGetPosY(fpsTitle, vsText, vsControl);
            pos.Height = AU3_ControlGetPosHeight(fpsTitle, vsText, vsControl);
            pos.Width = AU3_ControlGetPosWidth(fpsTitle, vsText, vsControl);

            return pos;
        }

        public static string ControlGetText(string fpsTitle, string vsText, string vsControl)
        {
            //----------------------------------------------------------------------
            // A number big enought to hold result, trailing bytes will be 0
            //----------------------------------------------------------------------
            byte[] byteRetText = new byte[10000];

            AU3_ControlGetText(fpsTitle, vsText, vsControl, byteRetText, byteRetText.Length);
            AU3_Sleep(1000);

            //----------------------------------------------------------------------
            // May need to convert back to a string or int
            //----------------------------------------------------------------------
            return Encoding.ASCII.GetString(byteRetText).TrimEnd('\0');
        }

        public static int ControlHide(string fpsTitle, string vsText, string vsControl)
        {
            return AU3_ControlHide(fpsTitle, vsText, vsControl);
        }

        public static int ControlMove(string fpsTitle, string vsText, string vsControl, int vsX, int vsY)
        {
            int height = ControlGetPos(fpsTitle, vsText, vsControl).Height;
            int width = ControlGetPos(fpsTitle, vsText, vsControl).Width;
            return AU3_ControlMove(fpsTitle, vsText, vsControl, vsX, vsY, height, width);
        }

        public static int ControlMove(string fpsTitle, string vsText, string vsControl, int vsX, int vsY, int vsHeight, int vsWidth)
        {
            return AU3_ControlMove(fpsTitle, vsText, vsControl, vsX, vsY, vsHeight, vsWidth);
        }

        public static int ControlSend(string fpsTitle, string vsText, string vsControl, string vsSendText, int vsMode)
        {
            return AU3_ControlSend(fpsTitle, vsText, vsControl, vsSendText, vsMode);
        }

        public static int ControlShow(string fpsTitle, string vsText, string vsControl)
        {
            return AU3_ControlShow(fpsTitle, vsText, vsControl);
        }

        public static int MouseClick(string vsButton, int viX, int viY)
        {
            return MouseClick(vsButton, viX, viY, 1, 1);
        }

        public static int MouseClick(string vsButton)
        {
            int mousex = AU3_MouseGetPosX();
            int mousey = AU3_MouseGetPosY();
            return MouseClick(vsButton, mousex, mousey);
        }

        public static int MouseClick(string vsButton, int viX, int viY, int viClicks, int viSpeed)
        {
            //----------------------------------------------------------------------
            // MouseClick wasn't working with out first MouseMove call
            //----------------------------------------------------------------------
            AU3_MouseMove(viX, viY, 10);
            return AU3_MouseClick(vsButton, viX, viY, viClicks, viSpeed);
        }

        public static int MouseClickDrag(string vsButton, int viX1, int viY1, int viX2, int viY2, int viSpeed)
        {
            return AU3_MouseClickDrag(vsButton, viX1, viY1, viX2, viY2, viSpeed);
        }

        public static void MouseDown(string vsButton)
        {
            AU3_MouseDown(vsButton);
        }

        public static PointXY MouseGetPos()
        {
            PointXY point;
            point.X = AU3_MouseGetPosX();
            point.Y = AU3_MouseGetPosY();

            return point;
        }

        public static void MouseMove(int viX, int viY)
        {
            MouseMove(viX, viY, 1);
        }

        public static void MouseMove(int viX, int viY, int viSpeed)
        {
            AU3_MouseMove(viX, viY, viSpeed);
        }

        public static void MouseUp(string vsButton)
        {
            AU3_MouseUp(vsButton);
        }

        public static int PixelChecksum(int left, int top, int right, int bottom, int step)
        {

            int sum = 0;
            for (int viX = left; viX <= right; viX += step)
            {
                for (int viY = top; viY <= bottom; viY += step)
                {
                    sum += AU3_PixelGetColor(viX, viY);
                }
            }
            
            return sum;
        }

        public static int PixelChecksum(int left, int top, int right, int bottom)
        {
            return PixelChecksum(left, top, right, bottom, 10);
        }

        public static int PixelGetColor(int viX, int viY)
        {
            return AU3_PixelGetColor(viX, viY);
        }

        public static int PixelGetColor(int viX, int viY, IntPtr handle)
        {
            AU3_AutoItSetOption("PixelCoordMode", 2);
            return 0;
        }

        public static int[] PixelSearch(int left, int top, int right, int bottom, int color, int shade, int step)
        {
            // object coord = AU3_PixelSearch(left, top, right, bottom, color, shade, step);

            // Here we check to see if it found the pixel or not. It always returns a 1 in C# if it did not.
            // if (coord.ToString() != "1")
            // {
            //    //We have to turn "object coord" into a useable array since it contains the coordinates we need.
            //    object[] pixelCoord = (object[])coord;

            // //Now we cast the object array to integers so that we can use the data inside.
            // return new int[] {(int)pixelCoord[0],(int)pixelCoord[1] };
            // }
            return null;
        }

        public static void ProcessClose(string process)
        {
            AU3_ProcessClose(process);
        }

        public static bool ProcessExists(string process)
        {
            return AU3_ProcessExists(process) != 0;
        }

        public static void ProcessWait(string process, int timeout)
        {
            AU3_ProcessWait(process, timeout);
        }

        public static void ProcessWaitClose(string process, int timeout)
        {
            AU3_ProcessWaitClose(process, timeout);
        }

        public static void Run(string process)
        {
            Run(process, string.Empty);
        }

        public static void Run(string process, string dir)
        {
            Run(process, dir, SW_SHOWMAXIMIZED);
        }

        public static void Run(string process, string dir, int showflag)
        {
            AU3_Run(process, dir, showflag);
        }

        public static void Send(string text)
        {
            Send(text, 5, 5);
        }

        public static void Send(string text, int viSpeed)
        {
            Send(text, viSpeed, 5);
        }

        public static void Send(string text, int viSpeed, int downLen)
        {
            SetOptions("AuXWrapper.SendKeyDelay", viSpeed);
            SetOptions("AuXWrapper.SendKeyDownDelay", downLen);
            Send(0, text);
        }

        public static void Send(int viMode, string vsText)
        {
            AU3_Send(vsText, viMode);
        }

        public static void Send(string vsText, string fpsTitle, string vsControl)
        {
            //----------------------------------------------------------------------
            // Set control focus and then send text to that control
            //----------------------------------------------------------------------
            ControlFocus(fpsTitle, vsControl);
            Send(vsText);
        }

        public static void SendRand(string vsText, int speedMin, int speedMax)
        {
            Random rand = new Random();
            for (int a = 0; a < vsText.Length; a++)
            {
                SetOptions("AuXWrapper.SendKeyDownDelay", rand.Next(10, 25));
                Console.WriteLine(Convert.ToString(vsText[a]));
                AU3_Send(vsText[a].ToString(), 0);
                /* Bing_Bot.Macro.delay(rand.Next(speedMin, speedMax));*/
            }
        }

        public static void SetOptions()
        {
            SetOptions(true, 250);
        }

        public static void SetOptions(string sOption, int iValue)
        {
            AU3_AutoItSetOption(sOption, iValue);
        }

        public static void SetOptions(bool vbWindowTitleExactMatch, int viSendKeyDelay)
        {
            //----------------------------------------------------------------------
            // WinTitleMatchMode
            // Alters the method that is used to match window titles during search operations.
            // 1 = Match the title from the start(default)
            // 2 = Match any substring in the title
            // 3 = Exact title match
            // 4 = Advanced mode, see Window Titles & Text(Advanced)
            // -1 to -4 = force lower case match according to other type of match.
            //----------------------------------------------------------------------
            if (vbWindowTitleExactMatch)
            {
                //----------------------------------------------------------------------
                // Match exact title when looking for windows
                //----------------------------------------------------------------------
                SetOptions("WinTitleMatchMode", 1);
            }
            else
            {
                //----------------------------------------------------------------------
                // Match any substring in the title when looking for windows
                //----------------------------------------------------------------------
                SetOptions("WinTitleMatchMode", 2);
            }

            //----------------------------------------------------------------------
            // SendKeyDelay
            // Alters the the length of the brief pause in between sent keystrokes.
            // Time in milliseconds to pause(default=5). Sometimes a value of 0
            //   does not work; use 1 instead.
            //----------------------------------------------------------------------
            SetOptions("SendKeyDelay", viSendKeyDelay);

            //----------------------------------------------------------------------
            // WinWaitDelay
            // Alters how long a script should briefly pause after a successful
            //   window-related operation. Time in milliseconds to pause(default=250).
            //----------------------------------------------------------------------
            SetOptions("WinWaitDelay", 250);

            //----------------------------------------------------------------------
            // WinDetectHiddenText
            // Specifies if hidden window text can be "seen" by the window matching functions.
            // 0 = Do not detect hidden text(default)
            // 1 = Detect hidden text
            //----------------------------------------------------------------------
            SetOptions("WinDetectHiddenText", 1);

            //----------------------------------------------------------------------
            // CaretCoordMode
            // Sets the way coords are used in the caret functions, either absolute
            //  coords or coords relative to the current active window:
            // 0 = relative coords to the active window
            // 1 = absolute screen coordinates(default)
            // 2 = relative coords to the client area of the active window
            //----------------------------------------------------------------------
            SetOptions("CaretCoordMode", 2);

            //----------------------------------------------------------------------
            // PixelCoordMode
            // Sets the way coords are used in the pixel functions, either absolute
            // coords or coords relative to the window defined by hwnd(default active window):
            // 0 = relative coords to the defined window
            // 1 = absolute screen coordinates(default)
            // 2 = relative coords to the client area of the defined window
            //----------------------------------------------------------------------
            SetOptions("PixelCoordMode", 2);

            //----------------------------------------------------------------------
            // MouseCoordMode
            // Sets the way coords are used in the mouse functions, either absolute
            //   coords or coords relative to the current active window:
            // 0 = relative coords to the active window
            // 1 = absolute screen coordinates(default)
            // 2 = relative coords to the client area of the active window
            //----------------------------------------------------------------------
            SetOptions("MouseCoordMode", 2);
        }

        public static void Sleep(int iMilliseconds)
        {
            AU3_Sleep(iMilliseconds);
        }

        public static void ToolTip(string sTip, int viX, int viY)
        {
            AU3_ToolTip(sTip, viX, viY);
        }

        public static void ToolTip(string sMessage)
        {
            //----------------------------------------------------------------------
            // Pad the message being displayed
            //----------------------------------------------------------------------
            if (!string.IsNullOrEmpty(sMessage))
            {
                sMessage = string.Format("\r\n      {0}      \r\n  ", sMessage);
            }

            //----------------------------------------------------------------------
            // Set the tooltip to display the message
            //----------------------------------------------------------------------
            ToolTip(sMessage, 0, 0);
        }

        public static void WinActivate(string fpsTitle)
        {
            AU3_WinActivate(fpsTitle, string.Empty);
        }

        public static void WinActivate(string fpsTitle, int waitactivetimeout)
        {
            AU3_WinActivate(fpsTitle, string.Empty);
            AU3_WinWaitActive(fpsTitle, string.Empty, waitactivetimeout);
            System.Threading.Thread.Sleep(1000);
        }

        public static void WinActivate(string fpsTitle, string vsText)
        {
            AU3_WinActivate(fpsTitle, vsText);
        }

        public static int WinExists(string fpsTitle)
        {
            return AU3_WinExists(fpsTitle, string.Empty);
        }

        public static int WinExists(string fpsTitle, string vsText)
        {
            return AU3_WinExists(fpsTitle, vsText);
        }

        public static string WinGetHandle(string fpsTitle)
        {
            // ----------------------------------------------------------------------
            // A number big enought to hold result, trailing bytes will be 0
            // ----------------------------------------------------------------------
            byte[] RetText = new byte[50];

            AU3_WinGetHandle(fpsTitle, string.Empty, RetText, RetText.Length);

            //----------------------------------------------------------------------
            // May need to convert back to a string or int
            //----------------------------------------------------------------------
            return Encoding.ASCII.GetString(RetText).TrimEnd('\0');
        }

        public static string WinGetText(string fpsTitle, string vsText)
        {
            //----------------------------------------------------------------------
            // A number big enought to hold result, trailing bytes will be 0
            //----------------------------------------------------------------------
            byte[] byteRetText = new byte[10000];

            AU3_WinGetText(fpsTitle, vsText, byteRetText, byteRetText.Length);

            // ----------------------------------------------------------------------
            // May need to convert back to a string or int
            // ----------------------------------------------------------------------
            return Encoding.ASCII.GetString(byteRetText).TrimEnd('\0');
        }

        public static string WinGetText(string fpsTitle)
        {
            return WinGetText(fpsTitle, string.Empty);
        }

        public static void WinMove(string fpsTitle, int viX, int viY)
        {
            int xLen = AU3_WinGetPosWidth(fpsTitle, string.Empty);
            int yLen = AU3_WinGetPosHeight(fpsTitle, string.Empty);
            WinMove(fpsTitle, viX, viY, xLen, yLen);
        }

        public static void WinMove(string fpsTitle, int viX, int viY, int viWidth, int viHeight)
        {
            AU3_WinMove(fpsTitle, string.Empty, viX, viY, viWidth, viHeight);
        }

        public static int WinWait(string fpsTitle)
        {
            return AU3_WinWait(fpsTitle, string.Empty, 3000);
        }

        public static int WinWaitActive(string fpsTitle, string vsText, int iTimeout)
        {
            return AU3_WinWaitActive(fpsTitle, vsText, iTimeout);
        }

        public static int WinWaitActive(string fpsTitle, int iTimeout)
        {
            return AU3_WinWaitActive(fpsTitle, string.Empty, iTimeout);
        }

        public static int WinWaitActive(string fpsTitle)
        {
            return AU3_WinWaitActive(fpsTitle, string.Empty, 3000);
        }

        public static void WinWaitActiveWindow(string fpsTitle)
        {
            // ----------------------------------------------------------------------
            // Wait for the window
            // ----------------------------------------------------------------------
            WinWait(fpsTitle);

            // ----------------------------------------------------------------------
            // Set the window as the active window
            // ----------------------------------------------------------------------
            WinActivate(fpsTitle);

            // ----------------------------------------------------------------------
            // Wait until the window is active, then proceed
            // ----------------------------------------------------------------------
            WinWaitActive(fpsTitle);
        }

        public Position2D WinGetPos(string fpsTitle, string vsText)
        {
            Position2D pos;
            pos.X = AU3_WinGetPosX(fpsTitle, vsText);
            pos.Y = AU3_WinGetPosY(fpsTitle, vsText);
            pos.Height = AU3_WinGetPosHeight(fpsTitle, vsText);
            pos.Width = AU3_WinGetPosWidth(fpsTitle, vsText);
            return pos;
        }

        // AU3_API long WINAPI AU3_AutoItSetOption(const char *szOption, long nValue);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_AutoItSetOption([MarshalAs(UnmanagedType.LPStr)] string Option, int Value);

        // AU3_API void WINAPI AU3_BlockInput(long nFlag);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_BlockInput(int Flag);

        // AU3_API long WINAPI AU3_CDTray(const char *szDrive, const char *szAction);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_CDTray(
            [MarshalAs(UnmanagedType.LPStr)] string Drive,
            [MarshalAs(UnmanagedType.LPStr)] string Action);

        // AU3_API void WINAPI AU3_ClipGet(char *szClip, int nBufSize);
        // Use like this:
        // byte[] returnclip = new byte[200]; //any sufficiently long lenght will do
        // AU3_ClipGet(returnclip, returnclip.Length);
        // clipdata = new ASCIIEncoding().GetString(returnclip);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_ClipGet(byte[] Clip, int BufSize);

        // AU3_API void WINAPI AU3_ClipPut(const char *szClip);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_ClipPut([MarshalAs(UnmanagedType.LPStr)] string Clip);

        // AU3_API long WINAPI AU3_ControlClick(const char *szTitle, const char *szText, const char *szControl, const char *szButton, long nNumClicks, /*[in,defaultvalue(AU3_INTDEFAULT)]*/long nX, /*[in,defaultvalue(AU3_INTDEFAULT)]*/long nY);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlClick(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl,
            [MarshalAs(UnmanagedType.LPStr)] string Button,
            int NumClicks,
            int X,
            int Y);

        // AU3_API void WINAPI AU3_ControlCommand(const char *szTitle, const char *szText, const char *szControl, const char *szCommand, const char *szExtra, char *szResult, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_ControlCommand(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl,
            [MarshalAs(UnmanagedType.LPStr)] string Command,
            [MarshalAs(UnmanagedType.LPStr)] string Extra,
            [MarshalAs(UnmanagedType.LPStr)] byte[] Result,
            int BufSize);

        // AU3_API long WINAPI AU3_ControlDisable(const char *szTitle, const char *szText, const char *szControl);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlDisable(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl);

        // AU3_API long WINAPI AU3_ControlEnable(const char *szTitle, const char *szText, const char *szControl);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlEnable(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl);

        // AU3_API long WINAPI AU3_ControlFocus(const char *szTitle, const char *szText, const char *szControl);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlFocus(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl);

        // AU3_API void WINAPI AU3_ControlGetFocus(const char *szTitle, const char *szText, char *szControlWithFocus, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_ControlGetFocus(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            byte[] ControlWithFocus,
            int BufSize);

        // AU3_API void WINAPI AU3_ControlGetHandle(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, const char *szControl, char *szRetText, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_ControlGetHandle(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl,
            byte[] RetText,
            int BufSize);

        // AU3_API long WINAPI AU3_ControlGetPosHeight(const char *szTitle, const char *szText, const char *szControl);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlGetPosHeight(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl);

        // AU3_API long WINAPI AU3_ControlGetPosWidth(const char *szTitle, const char *szText, const char *szControl);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlGetPosWidth(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl);

        // AU3_API long WINAPI AU3_ControlGetPosX(const char *szTitle, const char *szText, const char *szControl);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlGetPosX(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl);

        // AU3_API long WINAPI AU3_ControlGetPosY(const char *szTitle, const char *szText, const char *szControl);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlGetPosY(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl);

        // AU3_API void WINAPI AU3_ControlGetText(const char *szTitle, const char *szText, const char *szControl, char *szControlText, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_ControlGetText(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl,
            byte[] ControlText,
            int BufSize);

        // AU3_API long WINAPI AU3_ControlHide(const char *szTitle, const char *szText, const char *szControl);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlHide(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl);

        // AU3_API void WINAPI AU3_ControlListView(const char *szTitle, const char *szText, const char *szControl, const char *szCommand, const char *szExtra1, const char *szExtra2, char *szResult, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_ControlListView(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl,
            [MarshalAs(UnmanagedType.LPStr)] string Command,
            [MarshalAs(UnmanagedType.LPStr)] string Extral1,
            [MarshalAs(UnmanagedType.LPStr)] string Extra2,
            byte[] Result,
            int BufSize);

        // AU3_API long WINAPI AU3_ControlMove(const char *szTitle, const char *szText, const char *szControl, long nX, long nY, /*[in,defaultvalue(-1)]*/long nWidth, /*[in,defaultvalue(-1)]*/long nHeight);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlMove(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl,
            int X,
            int Y,
            int Width,
            int Height);

        // AU3_API long WINAPI AU3_ControlSend(const char *szTitle, const char *szText, const char *szControl, const char *szSendText, /*[in,defaultvalue(0)]*/long nMode);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlSend(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl,
            [MarshalAs(UnmanagedType.LPStr)] string SendText,
            int Mode);

        // AU3_API long WINAPI AU3_ControlSetText(const char *szTitle, const char *szText, const char *szControl, const char *szControlText);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlSetText(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControlText);

        // AU3_API long WINAPI AU3_ControlShow(const char *szTitle, const char *szText, const char *szControl);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ControlShow(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl);

        // AU3_API void WINAPI AU3_ControlTreeView(const char *szTitle, const char *szText, const char *szControl, const char *szCommand, const char *szExtra1, const char *szExtra2, char *szResult, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_ControlTreeView(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string fpsControl,
            [MarshalAs(UnmanagedType.LPStr)] string Command,
            [MarshalAs(UnmanagedType.LPStr)] string Extra1,
            [MarshalAs(UnmanagedType.LPStr)] string Extra2,
            byte[] Result,
            int BufSize);

        // AU3_API void WINAPI AU3_DriveMapAdd(const char *szDevice, const char *szShare, long nFlags, /*[in,defaultvalue("")]*/const char *szUser, /*[in,defaultvalue("")]*/const char *szPwd, char *szResult, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_DriveMapAdd(
            [MarshalAs(UnmanagedType.LPStr)] string Device,
            [MarshalAs(UnmanagedType.LPStr)] string Share,
            int Flags,
            [MarshalAs(UnmanagedType.LPStr)] string User,
            [MarshalAs(UnmanagedType.LPStr)] string Pwd,
            byte[] Result,
            int BufSize);

        // AU3_API long WINAPI AU3_DriveMapDel(const char *szDevice);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_DriveMapDel([MarshalAs(UnmanagedType.LPStr)] string Device);

        // AU3_API void WINAPI AU3_DriveMapGet(const char *szDevice, char *szMapping, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_DriveMapDel(
            [MarshalAs(UnmanagedType.LPStr)] string Device,
            byte[] Mapping,
            int BufSize);

        // AU3_API long AU3_error(void);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_error();

        // AU3_API long WINAPI AU3_IniDelete(const char *szFilename, const char *szSection, const char *szKey);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_IniDelete(
            [MarshalAs(UnmanagedType.LPStr)] string Filename,
            [MarshalAs(UnmanagedType.LPStr)] string Section,
            [MarshalAs(UnmanagedType.LPStr)] string Key);

        // AU3_API void WINAPI AU3_IniRead(const char *szFilename, const char *szSection, const char *szKey, const char *szDefault, char *szValue, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_IniRead(
            [MarshalAs(UnmanagedType.LPStr)] string Filename,
            [MarshalAs(UnmanagedType.LPStr)] string Section,
            [MarshalAs(UnmanagedType.LPStr)] string Key,
            [MarshalAs(UnmanagedType.LPStr)] string Default,
            byte[] Value,
            int BufSize);

        // AU3_API void WINAPI AU3_Init(void);
        // Uncertain if this is needed
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_Init();

        // AU3_API long WINAPI AU3_IniWrite(const char *szFilename, const char *szSection, const char *szKey, const char *szValue);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_IniWrite(
            [MarshalAs(UnmanagedType.LPStr)] string Filename,
            [MarshalAs(UnmanagedType.LPStr)] string Section,
            [MarshalAs(UnmanagedType.LPStr)] string Key,
            [MarshalAs(UnmanagedType.LPStr)] string Value);

        // AU3_API long WINAPI AU3_IsAdmin(void);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_IsAdmin();

        // AU3_API long WINAPI AU3_MouseClick(/*[in,defaultvalue("LEFT")]*/const char *szButton, /*[in,defaultvalue(AU3_INTDEFAULT)]*/long nX, /*[in,defaultvalue(AU3_INTDEFAULT)]*/long nY, /*[in,defaultvalue(1)]*/long nClicks, /*[in,defaultvalue(-1)]*/long nSpeed);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_MouseClick(
            [MarshalAs(UnmanagedType.LPStr)] string Button,
            int x,
            int y,
            int clicks,
            int speed);

        // AU3_API long WINAPI AU3_MouseClickDrag(const char *szButton, long nX1, long nY1, long nX2, long nY2, /*[in,defaultvalue(-1)]*/long nSpeed);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_MouseClickDrag(
            [MarshalAs(UnmanagedType.LPStr)] string Button,
            int X1,
            int Y1,
            int X2,
            int Y2,
            int Speed);

        // AU3_API void WINAPI AU3_MouseDown(/*[in,defaultvalue("LEFT")]*/const char *szButton);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_MouseDown([MarshalAs(UnmanagedType.LPStr)] string Button);

        // AU3_API long WINAPI AU3_MouseGetCursor(void);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_MouseGetCursor();

        // AU3_API long WINAPI AU3_MouseGetPosX(void);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_MouseGetPosX();

        // AU3_API long WINAPI AU3_MouseGetPosY(void);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_MouseGetPosY();

        // AU3_API long WINAPI AU3_MouseMove(long nX, long nY, /*[in,defaultvalue(-1)]*/long nSpeed);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_MouseMove(int X, int Y, int Speed);

        // AU3_API void WINAPI AU3_MouseUp(/*[in,defaultvalue("LEFT")]*/const char *szButton);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_MouseUp([MarshalAs(UnmanagedType.LPStr)] string Button);

        // AU3_API void WINAPI AU3_MouseWheel(const char *szDirection, long nClicks);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_MouseWheel([MarshalAs(UnmanagedType.LPStr)] string Direction, int Clicks);

        // AU3_API long WINAPI AU3_Opt(const char *szOption, long nValue);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_Opt([MarshalAs(UnmanagedType.LPStr)] string Option, int Value);

        // AU3_API long WINAPI AU3_PixelChecksum(long nLeft, long nTop, long nRight, long nBottom, /*[in,defaultvalue(1)]*/long nStep);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_PixelChecksum(int Left, int Top, int Right, int Bottom, int Step);

        // AU3_API long WINAPI AU3_PixelGetColor(long nX, long nY);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_PixelGetColor(int X, int Y);

        // AU3_API void WINAPI AU3_PixelSearch(long nLeft, long nTop, long nRight, long nBottom, long nCol, /*default 0*/long nVar, /*default 1*/long nStep, LPPOINT pPointResult);
        // Use like this:
        // int[] result = {0,0};
        // try
        // {
        // AU3_PixelSearch(0, 0, 800, 000,0xFFFFFF, 0, 1, result);
        // }
        // catch { }
        // It will crash if the color is not found, have not be able to determin why
        // The AutoItX3Lib.AutoItX3Class version has similar problems and is the only function to return an object
        // so contortions are needed to get the data from it ie:
        // int[] result = {0,0};
        // object resultObj;
        // AutoItX3Lib.AutoItX3Class autoit = new AutoItX3Lib.AutoItX3Class();
        // resultObj = autoit.PixelSearch(0, 0, 800, 600, 0xFFFF00,0,1);
        // Type t = resultObj.GetType();
        // if (t == typeof(object[]))
        // {
        // object[] obj = (object[])resultObj;
        // result[0] = (int)obj[0];
        // result[1] = (int)obj[1];
        // }
        // When it fails it returns an object = 1 but when it succeeds it is object[X,Y]
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_PixelSearch(
            int Left,
            int Top,
            int Right,
            int Bottom,
            int Col,
            int Var,
            int Step,
            int[] PointResult);

        // AU3_API long WINAPI AU3_ProcessClose(const char *szProcess);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ProcessClose([MarshalAs(UnmanagedType.LPStr)] string Process);

        // AU3_API long WINAPI AU3_ProcessExists(const char *szProcess);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ProcessExists([MarshalAs(UnmanagedType.LPStr)] string Process);

        // AU3_API long WINAPI AU3_ProcessSetPriority(const char *szProcess, long nPriority);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ProcessSetPriority(
            [MarshalAs(UnmanagedType.LPStr)] string Process,
            int Priority);

        // AU3_API long WINAPI AU3_ProcessWait(const char *szProcess, /*[in,defaultvalue(0)]*/long nTimeout);
        // Not checked jde
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ProcessWait(
            [MarshalAs(UnmanagedType.LPStr)] string Process,
            int Timeout);

        // AU3_API long WINAPI AU3_ProcessWaitClose(const char *szProcess, /*[in,defaultvalue(0)]*/long nTimeout);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_ProcessWaitClose(
            [MarshalAs(UnmanagedType.LPStr)] string Process,
            int Timeout);

        // AU3_API long WINAPI AU3_RegDeleteKey(const char *szKeyname);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_RegDeleteKey([MarshalAs(UnmanagedType.LPStr)] string fpsKeyname);

        // AU3_API long WINAPI AU3_RegDeleteVal(const char *szKeyname, const char *szValuename);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_RegDeleteVal(
            [MarshalAs(UnmanagedType.LPStr)] string fpsKeyname,
            [MarshalAs(UnmanagedType.LPStr)] string ValueName);

        // AU3_API void WINAPI AU3_RegEnumKey(const char *szKeyname, long nInstance, char *szResult, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_RegEnumKey(
            [MarshalAs(UnmanagedType.LPStr)] string fpsKeyname,
            int Instance,
            byte[] Result,
            int BusSize);

        // AU3_API void WINAPI AU3_RegEnumVal(const char *szKeyname, long nInstance, char *szResult, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_RegEnumVal(
            [MarshalAs(UnmanagedType.LPStr)] string fpsKeyname,
            int Instance,
            byte[] Result,
            int BufSize);

        // AU3_API void WINAPI AU3_RegRead(const char *szKeyname, const char *szValuename, char *szRetText, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_RegRead(
            [MarshalAs(UnmanagedType.LPStr)] string fpsKeyname,
            [MarshalAs(UnmanagedType.LPStr)] string Valuename,
            byte[] RetText,
            int BufSize);

        // AU3_API long WINAPI AU3_RegWrite(const char *szKeyname, const char *szValuename, const char *szType, const char *szValue);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_RegWrite(
            [MarshalAs(UnmanagedType.LPStr)] string fpsKeyname,
            [MarshalAs(UnmanagedType.LPStr)] string Valuename,
            [MarshalAs(UnmanagedType.LPStr)] string Type,
            [MarshalAs(UnmanagedType.LPStr)] string Value);

        // AU3_API long WINAPI AU3_Run(const char *szRun, /*[in,defaultvalue("")]*/const char *szDir, /*[in,defaultvalue(1)]*/long nShowFlags);
        [DllImport(@"C:\Program Files(x86)\AutoIt3\AutoItX\AutoItX3.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_Run(
            [MarshalAs(UnmanagedType.LPStr)] string Run,
            [MarshalAs(UnmanagedType.LPStr)] string Dir,
            int ShowFlags);

        // AU3_API long WINAPI AU3_RunAsSet(const char *szUser, const char *szDomain, const char *szPassword, int nOptions);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_RunAsSet(
            [MarshalAs(UnmanagedType.LPStr)] string User,
            [MarshalAs(UnmanagedType.LPStr)] string Domain,
            [MarshalAs(UnmanagedType.LPStr)] string Password,
            int Options);

        // AU3_API long WINAPI AU3_RunWait(const char *szRun, /*[in,defaultvalue("")]*/const char *szDir, /*[in,defaultvalue(1)]*/long nShowFlags);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_RunWait(
            [MarshalAs(UnmanagedType.LPStr)]string Run,
            [MarshalAs(UnmanagedType.LPStr)]string Dir,
            int ShowFlags);

        // AU3_API void WINAPI AU3_Send(const char *szSendText, /*[in,defaultvalue(0)]*/long nMode);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_Send([MarshalAs(UnmanagedType.LPStr)] string SendText, int Mode);

        // AU3_API long WINAPI AU3_Shutdown(long nFlags);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_Shutdown(int Flags);

        // AU3_API void WINAPI AU3_Sleep(long nMilliseconds);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_Sleep(int Milliseconds);

        // AU3_API void WINAPI AU3_StatusbarGetText(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, /*[in,defaultvalue(1)]*/long nPart, char *szStatusText, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_StatusbarGetText(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            int Part,
            byte[] StatusText,
            int BufSize);

        // AU3_API void WINAPI AU3_ToolTip(const char *szTip, /*[in,defaultvalue(AU3_INTDEFAULT)]*/long nX, /*[in,defaultvalue(AU3_INTDEFAULT)]*/long nY);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_ToolTip([MarshalAs(UnmanagedType.LPStr)]string Tip, int X, int Y);

        // AU3_API void WINAPI AU3_WinActivate(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(@"C:\Program Files(x86)\AutoIt3\AutoItX\AutoItX3.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_WinActivate(
            [MarshalAs(UnmanagedType.LPStr)]string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)]string fpsText);

        // AU3_API long WINAPI AU3_WinActive(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(@"C:\Program Files(x86)\AutoIt3\AutoItX\AutoItX3.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinActive(
            [MarshalAs(UnmanagedType.LPStr)]string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)]string fpsText);

        // AU3_API long WINAPI AU3_WinClose(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(@"C:\Program Files(x86)\AutoIt3\AutoItX\AutoItX3.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinClose(
            [MarshalAs(UnmanagedType.LPStr)]string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText);

        // AU3_API long WINAPI AU3_WinExists(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(@"C:\Program Files(x86)\AutoIt3\AutoItX\AutoItX3.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinExists(
            [MarshalAs(UnmanagedType.LPStr)]string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)]string fpsText);

        // AU3_API long WINAPI AU3_WinGetCaretPosX(void);
        [DllImport(@"C:\Program Files(x86)\AutoIt3\AutoItX\AutoItX3.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinGetCaretPosX();

        // AU3_API long WINAPI AU3_WinGetCaretPosY(void);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinGetCaretPosY();

        // AU3_API void WINAPI AU3_WinGetClassList(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, char *szRetText, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_WinGetClassList(
            [MarshalAs(UnmanagedType.LPStr)]string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)]string fpsText,
            byte[] RetText,
            int BufSize);

        // AU3_API long WINAPI AU3_WinGetClientSizeHeight(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinGetClientSizeHeight(
            [MarshalAs(UnmanagedType.LPStr)]string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)]string fpsText);

        // AU3_API long WINAPI AU3_WinGetClientSizeWidth(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinGetClientSizeWidth(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText);

        // AU3_API void WINAPI AU3_WinGetHandle(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, char *szRetText, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_WinGetHandle(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            byte[] RetText,
            int BufSize);

        // AU3_API long WINAPI AU3_WinGetPosHeight(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinGetPosHeight(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText);

        // AU3_API long WINAPI AU3_WinGetPosWidth(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinGetPosWidth(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText);

        // AU3_API long WINAPI AU3_WinGetPosX(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinGetPosX(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText);

        // AU3_API long WINAPI AU3_WinGetPosY(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinGetPosY(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText);

        // AU3_API void WINAPI AU3_WinGetProcess(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, char *szRetText, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_WinGetProcess(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            byte[] RetText,
            int BufSize);

        // AU3_API long WINAPI AU3_WinGetState(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinGetState(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText);

        // AU3_API void WINAPI AU3_WinGetText(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, char *szRetText, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_WinGetText(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            byte[] RetText,
            int BufSize);

        // AU3_API void WINAPI AU3_WinGetTitle(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, char *szRetText, int nBufSize);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_WinGetTitle(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            byte[] RetText,
            int BufSize);

        // AU3_API long WINAPI AU3_WinKill(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinKill(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText);

        // AU3_API long WINAPI AU3_WinMenuSelectItem(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, const char *szItem1, const char *szItem2, const char *szItem3, const char *szItem4, const char *szItem5, const char *szItem6, const char *szItem7, const char *szItem8);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinMenuSelectItem(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string Item1,
            [MarshalAs(UnmanagedType.LPStr)] string Item2,
            [MarshalAs(UnmanagedType.LPStr)] string Item3,
            [MarshalAs(UnmanagedType.LPStr)] string Item4,
            [MarshalAs(UnmanagedType.LPStr)] string Item5,
            [MarshalAs(UnmanagedType.LPStr)] string Item6,
            [MarshalAs(UnmanagedType.LPStr)] string Item7,
            [MarshalAs(UnmanagedType.LPStr)] string Item8);

        // AU3_API void WINAPI AU3_WinMinimizeAll();
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_WinMinimizeAll();

        // AU3_API void WINAPI AU3_WinMinimizeAllUndo();
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern void AU3_WinMinimizeAllUndo();

        // AU3_API long WINAPI AU3_WinMove(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, long nX, long nY, /*[in,defaultvalue(-1)]*/long nWidth, /*[in,defaultvalue(-1)]*/long nHeight);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinMove(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            int fpiX,
            int fpiY,
            int fpiWidth,
            int fpiHeight);

        // AU3_API long WINAPI AU3_WinSetOnTop(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, long nFlag);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinMove(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            int Flags);

        // AU3_API long WINAPI AU3_WinSetState(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, long nFlags);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinSetState(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            int Flags);

        // AU3_API long WINAPI AU3_WinSetTitle(const char *szTitle,/*[in,defaultvalue("")]*/ const char *szText, const char *szNewTitle);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinSetTitle(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            [MarshalAs(UnmanagedType.LPStr)] string NewTitle);

        // AU3_API long WINAPI AU3_WinSetTrans(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, long nTrans);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinSetTrans(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            int Trans);

        // AU3_API long WINAPI AU3_WinWait(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, /*[in,defaultvalue(0)]*/long nTimeout);
        [DllImport(@"C:\Program Files(x86)\AutoIt3\AutoItX\AutoItX3.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinWait(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            int Timeout);

        // AU3_API long WINAPI AU3_WinWaitActive(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, /*[in,defaultvalue(0)]*/long nTimeout);
        [DllImport(@"C:\Program Files(x86)\AutoIt3\AutoItX\AutoItX3.dll", SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinWaitActive(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            int Timeout);

        // AU3_API long WINAPI AU3_WinWaitClose(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, /*[in,defaultvalue(0)]*/long nTimeout);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinWaitClose(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            int fpiTimeout);

        // AU3_API long WINAPI AU3_WinWaitNotActive(const char *szTitle, /*[in,defaultvalue("")]*/const char *szText, /*[in,defaultvalue(0)]*/long nTimeout);
        [DllImport(AUTOITX3_DLL, SetLastError = true, CharSet = CharSet.Auto)]
        private static extern int AU3_WinWaitNotActive(
            [MarshalAs(UnmanagedType.LPStr)] string fpsTitle,
            [MarshalAs(UnmanagedType.LPStr)] string fpsText,
            int Timeout);

        #endregion Methods

        #region Nested Types

        public struct PointXY
        {
            #region Fields

            public int X;
            public int Y;

            #endregion Fields
        }

        // These are used in a few functions to return multiple values(GetWinPos, MouseGetPos)
        public struct Position2D
        {
            #region Fields

            public int Height;
            public int Width;
            public int X;
            public int Y;

            #endregion Fields
        }

        #endregion Nested Types

        #region Other

        //----------------------------------------------------------------------
        // From memory optional parameters are not supported in DotNet so fill in all fields even if just "".
        // Be prepared to play around a bit with which fields need values and what those value are.
        //
        // The big advantage of using AutoItX3 like this is that you don't have to register
        //   the dll with windows and more importantly you get away from the many issues involved in
        //   publishing the application and the binding to the dll required.
        //
        // Get definitions by using "DLL Export Viewer" utility to get Properties Definitions
        //   "DLL Export Viewer" is from http://www.nirsoft.net
        //----------------------------------------------------------------------
        #endregion Other
    }
}