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

void AddHistoryFileList(string[] paths)

BFS.ClipboardFusion.AddHistoryFileList(new string[]{"C:\test.txt", "C:\image.jpg"});

void AddHistoryImage(Bitmap image)

BFS.ClipboardFusion.AddHistoryImage(myImage);

void AddHistoryText(string text)

BFS.ClipboardFusion.AddHistoryText("text");

void AddLocalPinnedFileList(string[] paths);

BFS.ClipboardFusion.AddLocalPinnedFileList(files);

void AddLocalPinnedImage(Bitmap image);

BFS.ClipboardFusion.AddLocalPinnedImage(image);

void AddLocalPinnedText(string text);

BFS.ClipboardFusion.AddLocalPinnedText("text");

AddSelectedListFileList(string[] paths);

BFS.ClipboardFusion.AddSelectedListFileList(files);

AddSelectedListImage(Bitmap image);

BFS.ClipboardFusion.AddSelectedListImage(image);

AddSelectedListText(string text);

BFS.ClipboardFusion.AddSelectedListText("text");

string[] CFOGetAllPinnedText();

string[] allPinnedText = BFS.ClipboardFusion.CFOGetAllPinnedText();

string[] CFOGetAllSavedText();

string[] allSavedText = BFS.ClipboardFusion.CFOGetAllSavedText();

string CFOGetLastSavedText();

string text = BFS.ClipboardFusion.CFOGetLastSavedText();

string CFOGetPinnedText(int index);

string pinnedText = BFS.ClipboardFusion.CFOGetPinnedText();

string CFOGetSavedText(int index);

string text = BFS.ClipboardFusion.CFOGetSavedText(0); //Gets the first item

void CFORemovePinnedText(int index)

BFS.ClipboardFusion.CFORemovePinnedText(0);

void CFORemoveSavedText(int index)

BFS.ClipboardFusion.CFORemoveSavedText(0);

bool CFOSavePinnedText(string text)

BFS.ClipboardFusion.CFOSavePinnedText("text");

bool CFOSaveText(string text);

bool ok = BFS.ClipboardFusion.CFOSaveText("My text.");

void CFOSetPinnedText(int index, string text)

BFS.ClipboardFusion.CFOSetPinnedText(0, "text");

void CFOSetSavedText(int index, string text)

BFS.ClipboardFusion.CFOSetSavedText(0, "text");

bool ClearHistory();

bool ok = BFS.ClipboardFusion.ClearHistory();

Bitmap ConvertDibToBitmap(byte[] dib)

Bitmap bitmap = ConvertDibToBitmap(data);

byte[] ConvertToDib5(Bitmap bitmap)

byte[] dib = ConvertToDib5(bitmap);

string[] GetAllHistoryText();

string[] allText = BFS.ClipboardFusion.GetAllHistoryText();

string[] GetAllLocalPinnedText();

string[] allText = BFS.ClipboardFusion.GetAllLocalPinnedText();

string[] GetAllSelectedListText();

string[] allText = BFS.ClipboardFusion.GetAllSelectedListText();

int GetClipboardManagerSelectedIndex();

int selectedIndex = BFS.ClipboardFusion.GetClipboardManagerSelectedIndex();

string[] GetHistoryFileList(int index);

string[] files = BFS.ClipboardFusion.GetHistoryFileList(0);

Image GetHistoryImage(int index);

Image picture = BFS.ClipboardFusion.GetHistoryImage(0); //Gets the first image

bool GetHistoryIndexContainsFileList(int index);

bool hasFiles = BFS.ClipboardFusion.GetHistoryIndexContainsFileList(0);

bool GetHistoryIndexContainsImage(int index);

bool hasImage = BFS.ClipboardFusion.GetHistoryIndexContainsImage(0);

bool GetHistoryIndexContainsText(int index);

bool hasText = BFS.ClipboardFusion.GetHistoryIndexContainsText(0);

int GetHistoryItemCount();

int count = BFS.ClipboardFusion.GetHistoryItemCount();

string GetHistoryText(int index);

string text = BFS.ClipboardFusion.GetHistoryText(0); //Gets the first item

string GetLastHistoryText();

string text = BFS.ClipboardFusion.GetLastHistoryText();

string[] GetLocalPinnedFileList(int index);

string[] files = BFS.ClipboardFusion.GetLocalPinnedFileList(0);

Bitmap GetLocalPinnedImage(int index);

Bitmap image = BFS.ClipboardFusion.GetLocalPinnedImage(0);

bool GetLocalPinnedItemContainsFileList(int index);

bool hasData = BFS.ClipboardFusion.GetLocalPinnedItemContainsFileList(0);

bool GetLocalPinnedItemContainsImage(int index);

bool hasData = BFS.ClipboardFusion.GetLocalPinnedItemContainsImage(0);

bool GetLocalPinnedItemContainsText(int index);

bool hasData = BFS.ClipboardFusion.GetLocalPinnedItemContainsText(0);

GetLocalPinnedItemCount();

int count = BFS.ClipboardFusion.GetLocalPinnedItemCount();

string GetLocalPinnedText(int index);

string text = BFS.ClipboardFusion.GetLocalPinnedText(0);

string[] GetMacros();

string[] macros = BFS.ClipboardFusion.GetMacros();

BFS.ClipboardFusion.ClipboardManagerListEnum GetSelectedClipboardManagerList();

BFS.ClipboardFusion.ClipboardManagerListEnum selectedList = BFS.ClipboardFusion.GetSelectedClipboardManagerList();

string[] GetSelectedListFileList(int index);

string files = BFS.ClipboardFusion.GetSelectedListFileList(0);

Bitmap GetSelectedListImage(int index);

Bitmap image = BFS.ClipboardFusion.GetSelectedListImage(0);

bool GetSelectedListItemContainsFileList(int index);

bool hasData = BFS.ClipboardFusion.GetSelectedListItemContainsFileList(0);

bool GetSelectedListItemContainsImage(int index);

bool hasData = BFS.ClipboardFusion.GetSelectedListItemContainsImage(0);

bool GetSelectedListItemContainsText(int index);

bool hasData = BFS.ClipboardFusion.GetSelectedListItemContainsText(0);

int GetSelectedListItemCount();

int count = BFS.ClipboardFusion.GetSelectedListItemCount();

string GetSelectedListText(int index);

string text = BFS.ClipboardFusion.GetSelectedListText(0);

bool IsAutoSyncEnabled();

bool enabled = BFS.ClipboardFusion.IsAutoSyncEnabled();

bool IsClipboardFusionSyncing()

bool isSyncing = BFS.ClipboardFusion.IsClipboardFusionSyncing();

bool IsClipboardListenerRunning()

bool isRunning = BFS.ClipboardFusion.IsClipboardListenerRunning();

bool IsOnlineEnabled();

bool enabled = BFS.ClipboardFusion.IsOnlineEnabled();

void PauseClipboardListener()

BFS.ClipboardFusion.PauseClipboardListener();

void RemoveHistoryItem(int index)

BFS.ClipboardFusion.RemoveHistoryItem(0);

void RemoveLocalPinnedItem(int index);

BFS.ClipboardFusion.RemoveLocalPinnedItem(0);

RemoveSelectedListItem(int index);

BFS.ClipboardFusion.RemoveSelectedListItem(0);

void ResumeClipboardListener()

BFS.ClipboardFusion.ResumeClipboardListener();

bool RunMacro(string macroName, string text, out string textOut);
bool BFS.ClipboardFusion.RunMacro(string macroName, string text, out string textOut, out string error);

string text;
bool ok = BFS.ClipboardFusion.RunMacro("My Macro", "Testing Text.", out text);

string text;
string error;
bool ok = BFS.ClipboardFusion.RunMacro("My Macro", "Testing Text.", out text, out error);

string RunTriggers(string text);

string text = BFS.ClipboardFusion.RunTriggers("text");

void SetAutoSyncEnabled(bool enabled);

BFS.ClipboardFusion.SetAutoSyncEnabled(enabled);

void SetClipboardWithHistoryItem(int index)

SetClipboardWithHistoryItem(0);

void SetClipboardWithLocalPinnedItem(int index)

SetClipboardWithLocalPinnedItem(0);

void SetClipboardWithOnlinePinnedItem(int index)

SetClipboardWithOnlinePinnedItem(0);

void SetClipboardWithOnlineRecentItem(int index)

SetClipboardWithOnlineRecentItem(0);

void SetClipboardWithSelectedList(int index)

SetClipboardWithSelectedList(0);

void SetHistoryFileList(int index, string[] paths)

BFS.ClipboardFusion.SetHistoryFileList(0, new string[]{"C:\test.txt", "C:\image.jpg"});

void SetHistoryImage(int index, Bitmap image)

BFS.ClipboardFusion.SetHistoryImage(0, myImage);

void SetHistoryText(int index, string text)

BFS.ClipboardFusion.SetHistoryText(0, "text");

void SetLocalPinnedFileList(int index, string[] paths);

BFS.ClipboardFusion.SetLocalPinnedFileList(0, paths);

void SetLocalPinnedImage(int index, Bitmap image);

BFS.ClipboardFusion.SetLocalPinnedImage(0, image);

void SetLocalPinnedText(int index, string text);

BFS.ClipboardFusion.SetLocalPinnedText(0, "text");

SetSelectedListFileList(int index, string[] paths);

BFS.ClipboardFusion.SetSelectedListFileList(0, files);

SetSelectedListImage(int index, Bitmap image);

BFS.ClipboardFusion.SetSelectedListImage(0, image);

SetSelectedListText(int index, string text);

BFS.ClipboardFusion.SetSelectedListText(0, "text");

void ShowLocalPinnedItemMenu(isFocusingQuery = false);

BFS.ClipboardFusion.ShowLocalPinnedItemMenu();

void ShowMacroMenu(isFocusingQuery = false);

BFS.ClipboardFusion.ShowMacroMenu();

void ShowOnlinePinnedItemMenu(isFocusingQuery = false);

BFS.ClipboardFusion.ShowOnlinePinnedItemMenu();

void ShowOnlineRecentItemMenu(isFocusingQuery = false);

BFS.ClipboardFusion.ShowOnlineRecentItemMenu();

void ShowPreviewPopup();

BFS.ClipboardFusion.ShowPreviewPopup();

void ShowQuickHistoryMenu(isFocusingQuery = false);

BFS.ClipboardFusion.ShowQuickHistoryMenu();

void ShowSettingsWindow();

BFS.ClipboardFusion.ShowSettingsWindow();

void ToggleOnlineEnabled();

BFS.ClipboardFusion.ToggleOnlineEnabled();

void ToggleTriggerCommandOverride();

BFS.ClipboardFusion.ToggleTriggerCommandOverride();

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

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