string[] GetAllRunningApplicationFiles();

string[] files = BFS.Application.GetAllRunningApplicationFiles();

uint[] GetAllRunningApplicationIDs();

uint[] apps = BFS.Application.GetAllRunningApplicationIDs();

uint GetAppIDByFile(string file);

uint appID = BFS.Application.GetAppIDByFile("*excel.exe");

uint GetAppIDByWindow(IntPtr windowHandle);

uint appID = BFS.Application.GetAppIDByWindow(windowHandle);

string GetMainFileByAppID(uint appID);

string file = BFS.Application.GetMainFileByAppID(appID);

string GetMainFileByWildcard(string file);

string mainfile = GetMainFileByWildcard("*\Outlook.exe");

string GetMainFileByWindow(IntPtr windowHandle);

string file = BFS.Application.GetMainFileByWindow(windowHandle);

IntPtr GetMainWindowByAppID(uint appID);

IntPtr windowHandle = BFS.Application.GetMainWindowByAppID(appID);

IntPtr GetMainWindowByFile(string file);

IntPtr windowHandle = BFS.Application.GetMainWindowByFile("*excel.exe");

bool IsAppRunningByAppID(uint appID);

bool isRunning = BFS.Application.IsAppRunningByAppID(appID);

bool IsAppRunningByFile(string file);

bool isRunning = BFS.Application.IsAppRunningByFile("*excel.exe");

bool Kill(uint appID);

bool ok = BFS.Application.Kill(appID);

uint Start(string filename, string arguments);

uint appID = BFS.Application.Start("C:\\Games\\Main.exe", "-Mode=1");

bool WaitForExitByAppID(uint appID, uint waitMS);

bool exited = BFS.Application.WaitForExitByAppID(appID, 5000);

bool WaitForExitByFile(uint appID, uint waitMS);

bool exited = BFS.Application.WaitForExitByFile("*excel.exe", 5000);

bool AdjustVolumeDown();

bool ok = BFS.Audio.AdjustVolumeDown();

bool AdjustVolumeUp();

bool ok = BFS.Audio.AdjustVolumeUp();

bool GetApplicationMute(uint appID);

bool isMuted = BFS.Audio.GetApplicationMute(appID);

decimal GetApplicationVolume(uint appID);

decimal volume = BFS.Audio.SetApplicationVolume(appID);

string GetDefaultPlaybackCommunications();

string defaultName = BFS.Audio.GetDefaultPlaybackCommunications();

string GetDefaultPlaybackSounds();

string defaultName = BFS.Audio.GetDefaultPlaybackSounds();

string GetDefaultRecordingCommunications();

string defaultName = BFS.Audio.GetDefaultRecordingCommunications();

string GetDefaultRecordingSounds();

string defaultName = BFS.Audio.GetDefaultRecordingSounds();

bool GetMute();

bool muted = BFS.Audio.GetMute();

string[] GetPlaybackDevices();

string[] devices = GetPlaybackDevices();

string[] GetRecordingDevices();

string[] devices = GetRecordingDevices();

decimal GetVolume();

decimal volume = BFS.Audio.GetVolume();

bool PlayFile(string filename);

bool ok = BFS.Audio.PlayFile("C:\myfile.mp3");

bool PlayWAV(string filename);

bool ok = BFS.Audio.PlayWAV("C:\myfile.wav");

bool SetApplicationMute(uint appID, bool mute);

bool ok = BFS.Audio.SetApplicationMute(appID, true);

bool SetApplicationVolume(uint appID, decimal volume);

bool ok = BFS.Audio.SetApplicationVolume(appID, 0.5m);

bool SetApplicationVolumeMax(uint appID);

bool ok = BFS.Audio.SetApplicationVolumeMax(appID);

bool SetApplicationVolumeMin(uint appID);

bool ok = BFS.Audio.SetApplicationVolumeMin(appID);

bool SetDefaultPlaybackCommunications(string name);

bool ok = BFS.Audio.SetDefaultPlaybackCommunications("Main Speakers");

bool SetDefaultPlaybackSounds(string name);

bool ok = BFS.Audio.SetDefaultPlaybackSounds("Main Speakers");

bool SetDefaultRecordingCommunications(string name);

bool ok = BFS.Audio.SetDefaultRecordingCommunications("Main Microphone");

bool SetDefaultRecordingSounds(string name);

bool ok = BFS.Audio.SetDefaultRecordingSounds("Main Microphone");

bool SetMute(bool mute);

bool ok = BFS.Audio.SetMute(true);

bool SetVolume(decimal volume);

bool ok = BFS.Audio.SetVolume(0.5m);

bool SetVolumeMax();

bool ok = BFS.Audio.SetVolumeMax();

bool SetVolumeMin();

bool ok = BFS.Audio.SetVolumeMin();

bool ToggleMute();

bool ok = BFS.Audio.ToggleMute();

bool Clear();

bool ok = BFS.Clipboard.Clear();

bool Copy();

bool ok = BFS.Clipboard.Copy();

string CopyText();

string text = BFS.Clipboard.CopyText();

string GetText();

string text = BFS.Clipboard.GetText();

bool HasImage();

bool hasImage = BFS.Clipboard.HasImage();

bool HasText();

bool hasText = BFS.Clipboard.HasText();

bool Paste();

bool ok = BFS.Clipboard.Paste();

bool PasteText(string text);

bool ok = BFS.Clipboard.PasteText("My text.");

bool SetHTML(string html);

bool ok = BFS.Clipboard.SetHTML("<li>List Item</li>");

bool SetText(string text);

bool ok = BFS.Clipboard.SetText("My text.");

bool GetUserConfirm(string message);

bool isHappy = BFS.Dialog.GetUserConfirm("Are you happy?");

string GetUserInput(string title, string value);

string input = BFS.Dialog.GetUserInput("How old are you?", "preset value here");

string GetUserInputList(string title, string[] values);

string input = BFS.Dialog.GetUserInputList("Test", new string[] { "Item #1", "Item #2", "Item #3" });

string GetUserInputListViewWithFilter(string title, string[] values);

string input = BFS.Dialog.GetUserInputListViewWithFilter("Test", new string[] { "Item #1", "Item #2", "Item #3" });

void ShowMessageError(string message);

BFS.Dialog.ShowMessageInfo("An error has occurred!");

void ShowMessageErrorMonospaced(string message);

BFS.Dialog.ShowMessageErrorMonospaced("An error has occurred in monoospaced!");

void ShowMessageInfo(string message);

BFS.Dialog.ShowMessageInfo("This is a message!");

void ShowMessageInfoMonospaced(string message);

BFS.Dialog.ShowMessageInfoMonospaced("This is a monospaced message!");

void ShowTrayMessage(string message);

BFS.Dialog.ShowTrayMessage("My tray message!");

string GetAppExecutable();

string exe = BFS.General.GetAppExecutable();

string GetAppInstallPath();

string path = BFS.General.GetAppInstallPath();

bool GetAppIsProVersion();

bool isPro = BFS.General.GetAppIsProVersion();

string GetAppVersion();

string version = BFS.General.GetAppVersion();

bool IsDesktopLocked();

bool isLocked = BFS.General.IsDesktopLocked();

bool LockDesktop();

bool ok = BFS.General.LockDesktop();

void LogText(string text);

BFS.General.LogText("This will appear in your application log!");

bool SleepMonitors();

bool ok = BFS.General.SleepMonitors();

bool ThreadWait(uint waitMS);

bool ok = BFS.General.ThreadWait(500);

bool WakeMonitors();

bool ok = BFS.General.WakeMonitors();

int GetMousePositionX();

int mouseX = BFS.Input.GetMousePositionX();

int GetMousePositionY();

int mouseY = BFS.Input.GetMousePositionY();

bool IsKeyDown(string keys);

bool isKeyDown = BFS.Input.IsKeyDown("54;65");

bool IsMouseDown(string buttons);

bool isMouseDown = BFS.Input.IsMouseDown("1;");

bool LeftClickMouse();

bool ok = BFS.Input.LeftClickMouse();

bool MiddleClickMouse();

bool ok = BFS.Input.MiddleClickMouse()

bool RightClickMouse();

bool ok = BFS.Input.RightClickMouse()

bool SendKeyDown(string keys);

bool ok = BFS.Input.SendKeyDown("X"); //Press X

bool SendKeyDownWithoutWait(string keys);

bool ok = BFS.Input.SendKeyDownWithoutWait("X"); //Press X

bool SendKeys(string keys);

bool ok = BFS.Input.SendKeys("%{X}"); //Sends Alt+X

bool SendKeysFast(string keys);

bool ok = BFS.Input.SendKeysFast("%{X}"); //Sends Alt+X

bool SendKeysFastWithoutWait(string keys);

bool ok = BFS.Input.SendKeysFastWithoutWait("%{X}"); //Sends Alt+X

bool SendKeysWithoutWait(string keys);

bool ok = BFS.Input.SendKeysWithoutWait("%{X}"); //Sends Alt+X

bool SendKeyUp(string keys);

bool ok = BFS.Input.SendKeyUp("X"); //Release X

bool SendKeyUpWithoutWait(string keys);

bool ok = BFS.Input.SendKeyUpWithoutWait("X"); //Release X

bool SendText(string text);

bool ok = BFS.Input.SendText("hello world"); //Types out 'hello world'

bool SetMousePosition(int x, int y);

bool ok = BFS.Input.SetMousePosition(100, 200); //Moves the mouse cursor to 100, 200

bool SetMousePositionRelative(int x, int y);

bool ok = BFS.Input.SetMousePositionRelative(10, 20); //Moves the mouse cursor right 10, down 20

bool SetMousePositionRelativeNoAcceleration(int x, int y);

bool ok = BFS.Input.SetMousePositionRelativeNoAcceleration(10, 20); //Moves the mouse cursor right 10, down 20

uint ShowMonitorSelector();

uint monitorID = BFS.Monitor.ShowMonitorSelector();

bool GetPasswordLocked();

bool isPasswordLocked = BFS.ScreenSaver.GetPasswordLocked();

int GetTimeoutMinutes();

int timeoutMinutes = BFS.ScreenSaver.GetTimeoutMinutes();

bool SetPasswordLocked(bool isPasswordLocked);

bool ok = BFS.ScreenSaver.SetPasswordLocked(true); //sets to need a password

bool SetTimeoutMinutes(int timeoutMinutes);

bool ok = BFS.ScreenSaver.SetTimeoutMinutes(60); //60 minutes

bool DeleteAllValues();

bool ok = BFS.ScriptSettings.DeleteAllValues();

bool DeleteValue(string name);

bool ok = BFS.ScriptSettings.DeleteValue("My Encrypted Setting");

string[] GetValueNames();

string[] names = GetValueNames();

string ReadValue(string name);

string value = BFS.ScriptSettings.ReadValue("My Setting");

bool ReadValueBool(string name);

bool value = BFS.ScriptSettings.ReadValueBool("My Setting");

string ReadValueEncrypted(string name);

string value = BFS.ScriptSettings.ReadValueEncrypted("My Encrypted Setting");

int ReadValueInt(string name);

int value = BFS.ScriptSettings.ReadValueInt("My Setting");

bool WriteValue(string name, string value);

bool ok = BFS.ScriptSettings.WriteValue("My Setting", "value goes here...");

bool WriteValueBool(string name, bool value);

bool ok = BFS.ScriptSettings.WriteValue("My Setting", true);

bool WriteValueEncrypted(string name, string value);

bool ok = BFS.ScriptSettings.WriteValueEncrypted("My Encrypted Setting", "value goes here...");

bool WriteValueInt(string name, int value);

bool ok = BFS.ScriptSettings.WriteValue("My Setting", 75);

bool TextToSpeech(string text);

bool ok = BFS.Speech.TextToSpeech("Hello, this is my voice!");

bool TextToSpeechWithVoice(string text, string voice);

bool ok = BFS.Speech.TextToSpeechWithVoice("Hello, this is my voice!", "Microsoft David Desktop - English (United States)");

bool IsWindowsTaskbarAutoHideEnabled();

bool isAutoHidden = BFS.Taskbar.IsWindowsTaskbarAutoHideEnabled();

bool SetWindowsTaskbarAutoHide(bool isAutoHidden);

bool ok = BFS.Taskbar.SetWindowsTaskbarAutoHide(true); //Sets the Windows taskbar to auto-hide

bool QueryIsMatch(string query, string text);

bool isMatch = BFS.Text.QueryIsMatch("test", "This is my test"); //this will return true because it matches TEST

string ScrubHtml(string text, bool isIgnorningEmptyTags);

string text = BFS.Text.ScrubHtml("HTML text", true);

string ScrubLineBreaks(string text);

string text = BFS.Text.ScrubLineBreaks("My text");

string ScrubLineBreaksAfter(string text);

string text = BFS.Text.ScrubLineBreaksAfter("My text");

string ScrubLineBreaksBefore(string text);

string text = BFS.Text.ScrubLineBreaksBefore("My text");

string ScrubTabs(string text);

string text = BFS.Text.ScrubTabs("My text");

string ScrubTabsAfter(string text);

string text = BFS.Text.ScrubTabsAfter("My text");

string ScrubTabsBefore(string text);

string text = BFS.Text.ScrubTabsBefore("My text");

string ScrubWhitespace(string text);

string text = BFS.Text.ScrubWhitespace("My text");

string ScrubWhitespaceAfter(string text);

string text = BFS.Text.ScrubWhitespaceAfter("My text");

string ScrubWhitespaceBefore(string text);

string text = BFS.Text.ScrubWhitespaceBefore("My text");

void ClearSpeechLog();

bool ok = BFS.VoiceBot.ClearSpeechLog();

string CurrentProfileName();

string profileName = BFS.VoiceBot.CurrentProfileName();

bool IsMacroRunning(string macroName);

BFS.VoiceBot.IsMacroRunning("current time");

void StartListening();

BFS.VoiceBot.StartListening();

void StopListening();

BFS.VoiceBot.StopListening();

void StopMacros();

BFS.VoiceBot.StopMacros();

void ChangeProfile(string profileName);

BFS.VoiceBotActions.ChangeProfile("Google Chrome");

void Delay(int ms);

BFS.VoiceBotActions.Delay(500);

void KeyDown(string keys);

BFS.VoiceBotActions.KeyDown("ctrl;49");

void KeyPress(string keys);

BFS.VoiceBotActions.KeyPress("ctrl;49");

void KeyToggle(string keys);

BFS.VoiceBotActions.KeyToggle("ctrl;49");

void KeyUp(string keys);

BFS.VoiceBotActions.KeyUp("ctrl;49");

void MouseClick(string button);

BFS.VoiceBotActions.MouseClick("1");

void MouseDoubleClick(string button);

BFS.VoiceBotActions.MouseDoubleClick("1");

void MouseDown(string button);

BFS.VoiceBotActions.MouseDown("1");

void MouseMoveAbsolute();

BFS.VoiceBotActions.MouseMoveAbsolute(50, 100);

void MouseMoveRelative();

BFS.VoiceBotActions.MouseMoveRelative(50, 100);

void MouseUp(string button);

BFS.VoiceBotActions.MouseUp("1");

void OpenFile(string filename);

BFS.VoiceBotActions.OpenFile(@"C:\files\myfile.txt");

void PlayRandomSound(string[] filenames);

BFS.VoiceBotActions.PlayRandomSound(new string[] {"@"C:\sounds\mysound.mp3", @"C:\sounds\mysound1.mp3", @"C:\sounds\mysound2.mp3"});

void PlaySound(string filename);

BFS.VoiceBotActions.PlaySound(@"C:\sounds\mysound.mp3");

void RunMacro(string macroName);

BFS.VoiceBotActions.RunMacro("current time");

void ScrollMouseWheelDown();

BFS.VoiceBotActions.ScrollMouseWheelDown();

void ScrollMouseWheelUp();

BFS.VoiceBotActions.ScrollMouseWheelUp();

void StartProgram(string program);

BFS.VoiceBotActions.StartProgram(@"C:\Windows\explorer.exe");

void StartProgramWithParameters(string program, string[] parameters);

BFS.VoiceBotActions.StartProgramWithParameters(@"C:\Windows\explorer.exe", new string[] {"/e"});

void TextToSpeech(string text);

BFS.VoiceBotActions.TextToSpeech("Talk to me");

void TextToSpeechCustomstring text, int? volume, int? speed, string voiceName);

BFS.VoiceBotActions.TextToSpeechCustom("Talk to me", 100, null, "Microsoft Zira Desktop");

void TypeText(string text);

BFS.VoiceBotActions.TypeText("My text");

string DownloadString(string url);

string json = BFS.Web.DownloadString("https://www.server.com/file.json");

string GetDefaultBrowserExe();

string file = BFS.Web.GetDefaultBrowserExe();

bool OpenUrl(string url);

bool ok = BFS.Web.OpenUrl("http://www.binaryfortress.com");

IntPtr OpenUrlNewWindow(string url);

IntPtr windowHandle = BFS.Web.OpenUrlNewWindow("http://www.binaryfortress.com");

bool AddToWindowsTaskbar(IntPtr windowHandle);

bool ok = BFS.Window.AddToWindowsTaskbar(windowHandle);

string BuildWindowDebug(IntPtr windowHandle);

string debug = BFS.Window.BuildWindowDebug(windowHandle);

bool Close(IntPtr windowHandle);

bool ok = BFS.Window.Close(windowHandle);

bool DisableWindow(IntPtr windowHandle);

bool ok = BFS.Window.DisableWindow(windowHandle);

bool EnableWindow(IntPtr windowHandle);

bool ok = BFS.Window.EnableWindow(windowHandle);

bool Focus(IntPtr windowHandle);

bool ok = BFS.Window.Focus(windowHandle);

IntPtr[] GetAllWindowHandles();

IntPtr[] handles = BFS.Window.GetAllWindowHandles();

bool GetAlwaysOnTop(IntPtr windowHandle);

bool alwaysOnTop = BFS.Window.GetAlwaysOnTop(windowHandle);

Rectangle GetBounds(IntPtr windowHandle);

Rectangle bounds = BFS.Window.GetBounds(windowHandle);

IntPtr GetChildWindowByClass(IntPtr windowHandleParent, string windowClass);

IntPtr windowHandle = GetChildWindowByClass(windowHandleParent, "myclass");

string GetClass(IntPtr windowHandle);

string windowClass = BFS.Window.GetClass(windowHandle);

Rectangle GetClientRect(IntPtr windowHandle);

Rectangle client = BFS.Window.GetClientRect(windowHandle);

IntPtr GetFocusedWindow();

IntPtr windowHandle = BFS.Window.GetFocusedWindow();

IntPtr GetOwner(IntPtr windowHandle);

IntPtr handleOwner = BFS.Window.GetOwner(windowHandle);

IntPtr GetParent(IntPtr windowHandle);

IntPtr handleParent = BFS.Window.GetParent(windowHandle);

IntPtr GetParentRoot(IntPtr windowHandle);

IntPtr handleParentRoot = BFS.Window.GetParentRoot(windowHandle);

string GetText(IntPtr windowHandle);

string text = BFS.Window.GetText(windowHandle);

decimal GetTransparency(IntPtr windowHandle);

decimal percent = BFS.Window.GetTransparency(windowHandle);

IntPtr[] GetVisibleAndMinimizedWindowHandles();

IntPtr[] handles = BFS.Window.GetVisibleAndMinimizedWindowHandles();

IntPtr[] GetVisibleWindowHandles();

IntPtr[] handles = BFS.Window.GetVisibleWindowHandles();

IntPtr GetWindowByClass(string windowClass);

IntPtr windowHandle = BFS.Window.GetWindowByClass("mywindowclass");

IntPtr GetWindowByText(string windowText);

IntPtr windowHandle = BFS.Window.GetWindowByText("starts with*");

IntPtr GetWindowByTextExact(string windowText);

IntPtr windowHandle = BFS.Window.GetWindowByTextExact("my title text exactly");

IntPtr GetWindowProperty(IntPtr windowHandle, string propertyName);

IntPtr propertyValue = BFS.Window.GetWindowProperty(windowHandle, "MyProperty");

IntPtr[] GetWindowsByText(string windowText);

IntPtr[] windowHandles = BFS.Window.GetWindowsByText("starts with*");

IntPtr[] GetWindowsByTextExact(string windowText);

IntPtr[] windowHandles = BFS.Window.GetWindowsByTextExact("my window title");

BFS.WindowEnum.WindowStyle GetWindowStyle(IntPtr windowHandle);

BFS.WindowEnum.WindowStyle windowStyle = BFS.Window.GetWindowStyle(windowHandle);

BFS.WindowEnum.WindowStyleEx GetWindowStyleEx(IntPtr windowHandle);

BFS.WindowEnum.WindowStyleEx windowStyle = BFS.Window.GetWindowStyleEx(windowHandle);

IntPtr GetWindowUnderMouse();

IntPtr windowHandle = BFS.Window.GetWindowUnderMouse();

bool HasWindowStyle(BFS.WindowEnum.WindowStyle windowStyle, IntPtr windowHandle);

bool ok = BFS.Window.HasWindowStyle(windowStyle, windowHandle);

bool HasWindowStyleEx(BFS.WindowEnum.WindowStyleEx windowStyleEx, IntPtr windowHandle);

bool ok = BFS.Window.HasWindowStyleEx(windowStyle, windowHandle);

bool IsHung(IntPtr windowHandle);

bool isHung = BFS.Window.IsHung(windowHandle);

bool IsMaximized(IntPtr windowHandle);

bool isMaximized = BFS.Window.IsMaximized(windowHandle);

bool IsMinimized(IntPtr windowHandle);

bool isMinimized = BFS.Window.IsMinimized(windowHandle);

bool IsRestored(IntPtr windowHandle);

bool isRestored = BFS.Window.IsRestored(windowHandle);

bool IsVisible(IntPtr windowHandle);

bool isVisible = BFS.Window.IsVisible(windowHandle);

bool Maximize(IntPtr windowHandle);

bool ok = BFS.Window.Maximize(windowHandle);

bool Minimize(IntPtr windowHandle);

bool ok = BFS.Window.Minimize(windowHandle);

bool RemoveFromWindowsTaskbar(IntPtr windowHandle);

bool ok = BFS.Window.RemoveFromWindowsTaskbar(windowHandle);

bool RemoveWindowProperty(IntPtr windowHandle, string propertyName);

bool ok = BFS.Window.RemoveWindowProperty(windowHandle, "MyProperty");

bool Restore(IntPtr windowHandle);

bool ok = BFS.Window.Restore(windowHandle);

bool SetAlwaysOnTop(IntPtr windowHandle, bool alwaysOnTop);

bool ok = BFS.Window.SetAlwaysOnTop(windowHandle, true);

bool SetLocation(IntPtr windowHandle, int x, int y);

bool ok = BFS.Window.SetLocation(windowHandle, 200, 300);

bool SetOwner(IntPtr windowHandle, IntPtr windowHandleOwner);

bool ok = BFS.Window.SetOwner(windowHandle, windowHandleOwner);

bool SetSize(IntPtr windowHandle, int width, int height);

bool ok = BFS.Window.SetSize(windowHandle, 800, 600);

bool SetSizeAndLocation(IntPtr windowHandle, int x, int y, int width, int height);

bool ok = BFS.Window.SetSizeAndLocation(windowHandle, 200, 300, 800, 600);

bool SetText(IntPtr windowHandle, string text);

bool ok = BFS.Window.SetText(windowHandle, text);

bool SetTransparency(IntPtr windowHandle, decimal transparencyPercent);

bool ok = BFS.Window.SetTransparency(windowHandle, 50);

bool SetWindowProperty(IntPtr windowHandle, string propertyName, IntPtr propertyValue);

bool ok = BFS.Window.SetWindowProperty(windowHandle, "MyProperty", new IntPtr(67, "7.0.0+")

bool SetWindowStyle(BFS.WindowEnum.WindowStyle windowStyle, IntPtr windowHandle);

bool ok = BFS.Window.SetWindowStyle(windowStyle, windowHandle);

bool SetWindowStyleEx(BFS.WindowEnum.WindowStyleEx windowStyleEx, IntPtr windowHandle);

bool ok = BFS.Window.SetWindowStyleEx(windowStyle, windowHandle);

bool ShowDesktop(IntPtr windowHandle);

bool ok = BFS.Window.ShowDesktop();

bool ToggleAlwaysOnTop(IntPtr windowHandle);

bool ok = BFS.Window.ToggleAlwaysOnTop(windowHandle);