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!");

bool DisableAllTaskbars();

bool ok = BFS.DisplayFusion.DisableAllTaskbars();

bool DisableTaskbar(uint monitorID);

bool ok = BFS.DisplayFusion.DisableTaskbar(1); //Disables the Taskbar on Monitor #1

bool EnableAllTaskbars();

bool ok = BFS.DisplayFusion.EnableAllTaskbars();

bool EnableTaskbar(uint monitorID);

bool ok = BFS.DisplayFusion.EnableTaskbar(1); //Enables the Taskbar on Monitor #1

bool EnableTaskbarOnSide(uint monitorID, string side);

bool ok = BFS.DisplayFusion.EnableTaskbarOnSide(1, "T"); //Enables the Taskbar on Monitor #1 on the Top side

string GetCurrentMonitorProfile();

string profileName = BFS.DisplayFusion.GetCurrentMonitorProfile();

string GetCurrentWallpaperProfile();

string profileName = BFS.DisplayFusion.GetCurrentWallpaperProfile();

string[] GetDesktopIconsProfiles();

string[] profiles = BFS.DisplayFusion.GetDesktopIconsProfiles();

string[] GetFunctions();

string[] functions = BFS.DisplayFusion.GetFunctions();

string[] GetMonitorProfiles();

string[] profiles = BFS.DisplayFusion.GetMonitorProfiles();

string[] GetWallpaperProfiles();

string[] profiles = BFS.DisplayFusion.GetWallpaperProfiles();

bool LoadDesktopIconsProfile(string name);

bool ok = BFS.DisplayFusion.LoadDesktopIconsProfile("My Home Icons");

bool LoadMonitorProfile(string name);

bool ok = BFS.DisplayFusion.LoadMonitorProfile("My 3 Monitors");

bool LoadMonitorProfileHideErrors(string name);

bool ok = BFS.DisplayFusion.LoadMonitorProfileHideErrors("My 3 Monitors");

bool LoadWallpaperProfile(string name);

bool ok = BFS.DisplayFusion.LoadWallpaperProfile("My 3 Wallpapers");

bool LoadWindowPositionProfile(string name);

bool ok = BFS.DisplayFusion.LoadWindowPositionProfile("My Profile");

IntPtr MirrorMonitor(uint monitorID);

IntPtr windowHandle = BFS.DisplayFusion.MirrorMonitor(2);

IntPtr MirrorMonitorNoBorder(uint monitorID);

IntPtr windowHandle = BFS.DisplayFusion.MirrorMonitorNoBorder(2);

IntPtr MirrorMonitorWithSplits(uint monitorID);

IntPtr windowHandle = BFS.DisplayFusion.MirrorMonitorWithSplits(2);

IntPtr MirrorMonitorWithSplitsNoBorder(uint monitorID);

IntPtr windowHandle = BFS.DisplayFusion.MirrorMonitorWithSplitsNoBorder(2);

IntPtr MirrorSelectedArea(int x, int y, int width, int height);

IntPtr windowHandle = BFS.DisplayFusion.MirrorSelectedArea(100, 100, 400, 400);

IntPtr MirrorSelectedAreaNoBorder(int x, int y, int width, int height);

IntPtr windowHandle = BFS.DisplayFusion.MirrorSelectedAreaNoBorder(100, 100, 400, 400);

IntPtr MirrorWindow(IntPtr windowHandle);

IntPtr windowHandle = BFS.DisplayFusion.MirrorWindow(myWindowHandle);

IntPtr MirrorWindowNoBorder(IntPtr windowHandle);

IntPtr windowHandle = BFS.DisplayFusion.MirrorWindowNoBorder(myWindowHandle);

bool ReloadSettings();

bool ok = BFS.DisplayFusion.ReloadSettings();

bool RunFunction(string name);

bool ok = BFS.DisplayFusion.RunFunction("My Other Function");

bool RunFunctionAndWait(string name);

bool ok = BFS.DisplayFusion.RunFunctionAndWait("My Other Function");

bool RunFunctionAndWaitWithWindowHandle(string name, IntPtr windowHandle);

bool ok = BFS.DisplayFusion.RunFunctionAndWaitWithWindowHandle("My Other Function", windowHandle);

bool RunFunctionWithWindowHandle(string name, IntPtr windowHandle);

bool ok = BFS.DisplayFusion.RunFunctionWithWindowHandle("My Other Function", windowHandle);

bool SaveDesktopIconsProfile(string name);

bool ok = BFS.DisplayFusion.SaveDesktopIconsProfile("My Home Icons");

bool SaveWindowPositionProfile(string name);

bool ok = BFS.DisplayFusion.SaveWindowPositionProfile("My Profile");

bool WallpaperFeatureDisable();

bool ok = BFS.DisplayFusion.WallpaperFeatureDisable();

bool WallpaperFeatureEnable();

bool ok = BFS.DisplayFusion.WallpaperFeatureEnable();

bool WallpaperFeatureToggle();

bool ok = BFS.DisplayFusion.WallpaperFeatureToggle();

bool WallpaperSlideshowPause();

bool ok = BFS.DisplayFusion.WallpaperSlideshowPause();

bool WallpaperSlideshowResume();

bool ok = BFS.DisplayFusion.WallpaperSlideshowResume();

bool WallpaperSlideshowToggle();

bool ok = BFS.DisplayFusion.WallpaperSlideshowToggle();

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

Rectangle[] GetMonitorBounds();

Rectangle[] bounds = BFS.Monitor.GetMonitorBounds();

Rectangle GetMonitorBoundsByID(uint monitorID);

Rectangle bounds = BFS.Monitor.GetMonitorBoundsByID(monitorID);

Rectangle GetMonitorBoundsByMouseCursor();

Rectangle bounds = BFS.Monitor.GetMonitorBoundsByMouseCursor();

Rectangle GetMonitorBoundsByRect(Rectangle rect);

Rectangle bounds = BFS.Monitor.GetMonitorBoundsByRect(rect);

Rectangle GetMonitorBoundsByWindow(IntPtr windowHandle);

Rectangle bounds = BFS.Monitor.GetMonitorBoundsByWindow(windowHandle);

Rectangle GetMonitorBoundsByXY(int x, int y);

Rectangle bounds = BFS.Monitor.GetMonitorBoundsByXY(x, y);

Rectangle[] GetMonitorBoundsNoSplits();

Rectangle[] bounds = BFS.Monitor.GetMonitorBoundsNoSplits();

int GetMonitorCountEnabled();

int count = BFS.Monitor.GetMonitorCountEnabled();

int GetMonitorCountEnabledAndDisabled();

int count = BFS.Monitor.GetMonitorCountEnabledAndDisabled();

int GetMonitorCountEnabledNoSplits();

int count = BFS.Monitor.GetMonitorCountEnabledNoSplits();

uint GetMonitorIDByRect(Rectangle rect);

uint monitorID = BFS.Monitor.GetMonitorIDByRect(rect);

uint GetMonitorIDByWindow(IntPtr windowHandle);

uint monitormonitorID = BFS.Monitor.GetMonitorIDByWindow(windowHandle);

uint GetMonitorIDByXY(int x, int y);

uint monitormonitorID = BFS.Monitor.GetMonitorIDByXY(x, y);

uint[] GetMonitorIDs();

uint[] ids = BFS.Monitor.GetMonitorIDs();

Rectangle GetMonitorWorkAreaByID(uint monitorID);

Rectangle area = BFS.Monitor.GetMonitorWorkAreaByID(monitorID);

Rectangle GetMonitorWorkAreaByMouseCursor();

Rectangle area = BFS.Monitor.GetMonitorWorkAreaByMouseCursor();

Rectangle GetMonitorWorkAreaByRect(Rectangle rect);

Rectangle area = BFS.Monitor.GetMonitorWorkAreaByRect(rect);

Rectangle GetMonitorWorkAreaByWindow(IntPtr windowHandle);

Rectangle area = BFS.Monitor.GetMonitorWorkAreaByWindow(windowHandle);

Rectangle GetMonitorWorkAreaByXY(int x, int y);

Rectangle area = BFS.Monitor.GetMonitorWorkAreaByXY(x, y);

Rectangle[] GetMonitorWorkAreas();

Rectangle[] workareas = BFS.Monitor.GetMonitorWorkAreas();

Rectangle GetPrimaryMonitorBounds();

Rectangle bounds = BFS.Monitor.GetPrimaryMonitorBounds();

uint GetPrimaryMonitorID();

uint monitormonitorID = BFS.Monitor.GetPrimaryMonitorID();

Rectangle GetPrimaryMonitorWorkArea();

Rectangle area = BFS.Monitor.GetPrimaryMonitorWorkArea();

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");

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[] GetVisibleWindowHandlesByMonitor(uint monitorID);

IntPtr[] windowHandles = BFS.Window.GetVisibleWindowHandlesByMonitor(2);

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 IsWindowRolledUpToHat(IntPtr windowHandle);

bool isRolledUp = BFS.Window.IsWindowRolledUpToHat(windowHandle);

bool IsWindowRolledUpToIcon(IntPtr windowHandle);

bool isRolledUp = BFS.Window.IsWindowRolledUpToIcon(windowHandle);

bool IsWindowRolledUpToTitleBar(IntPtr windowHandle);

bool isRolledUp = BFS.Window.IsWindowRolledUpToTitleBar(windowHandle);

bool Maximize(IntPtr windowHandle);

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

bool Minimize(IntPtr windowHandle);

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

bool MoveToBottomMonitorHalf(IntPtr windowHandle);

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

bool MoveToCentreMonitor(IntPtr windowHandle);

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

bool MoveToLeftMonitorHalf(IntPtr windowHandle);

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

bool MoveToMonitor(uint monitorID, IntPtr windowHandle);

bool ok = BFS.Window.MoveToMonitor(monitorID, windowHandle);

bool MoveToMonitorMaximized(uint monitorID, IntPtr windowHandle);

bool ok = BFS.Window.MoveToMonitorMaximized(monitorID, windowHandle);

bool MoveToMonitorResized(uint monitorID, IntPtr windowHandle);

bool ok = BFS.Window.MoveToMonitorResized(monitorID, windowHandle);

bool MoveToNextMonitor(IntPtr windowHandle);

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

bool MoveToNextMonitorMaximized(IntPtr windowHandle);

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

bool MoveToNextMonitorResized(IntPtr windowHandle);

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

bool MoveToPreviousMonitor(IntPtr windowHandle);

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

bool MoveToPreviousMonitorMaximized(IntPtr windowHandle);

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

bool MoveToPreviousMonitorResized(IntPtr windowHandle);

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

bool MoveToRightMonitorHalf(IntPtr windowHandle);

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

bool MoveToTopMonitorHalf(IntPtr windowHandle);

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

bool RemoveFromWindowsTaskbar(IntPtr windowHandle);

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

bool RemoveWindowHighlight(IntPtr windowHandle);

bool ok = BFS.Window.RemoveWindowHighlight(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 RollupWindowToHat(IntPtr windowHandle);

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

bool RollupWindowToIcon(IntPtr windowHandle);

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

bool RollupWindowToTitleBar(IntPtr windowHandle);

bool ok = BFS.Window.RollupWindowToTitleBar(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);