private void Fire_SystemKeyDown(KeyboardHookEventArgs kea) { if (SystemKeyDown != null) { SystemKeyDown(this, kea); } }
private void Fire_KeyUp(KeyboardHookEventArgs kea) { if (KeyUp != null) { KeyUp(this, kea); } }
void keyDown(object sender, KeyboardHookEventArgs e) { if (e.KeyboardState == KeyboardHook.KeyboardState.KeyDown && e.KeyboardData.VirtualCode == 0x72) //F3 virtual code { (new OptionsForm()).ShowDialog(); } }
private static void Hook_KeyDown(object sender, KeyboardHookEventArgs e) { IntPtr activeWnd = UnsafeNativeMethods.GetForegroundWindow(); IntPtr focus = UnsafeNativeMethods.GetFocus(); foreach (var hk in GetAvailableHotkey()) { // 핫키 보조키와 눌린 보조키가 없거나, 있는경우 마지막 키코드가 보조키여서는 안됨. // 핫키 대상이 글로벌이거나, 아닌경우 대상과 일치하는지 확인. if (((!hk.HasModifierKey && Keyboard.ModifierKeys == VKeys.None) || (hk.HasModifierKey && !Keyboard.IsModifierKey(e.KeyCode))) && (hk.IsGlobal || (!hk.IsGlobal && (hk.Target == activeWnd || hk.Target == focus)))) { var arg = new HotkeyEventArgs(activeWnd); if (hk.Target == focus && focus != IntPtr.Zero) { arg.Target = focus; } syncContext.Send((o) => hk.Action?.Invoke(hk, arg), null); if (arg.Handled && !hk.HasModifierKey && hk.SubKeys.Contains(e.KeyCode)) { e.Handled = true; } else { e.Handled = arg.Handled; } } } }
private void kHook_KeyDown(object sender, KeyboardHookEventArgs e) { switch (e.KeyString) { case "[LShiftKey]": _activeModifier = _activeModifier.Add(ModifierKey.Shift); break; case "[LControlKey]": _activeModifier = _activeModifier.Add(ModifierKey.Ctrl); break; case "[LMenu]": _activeModifier = _activeModifier.Add(ModifierKey.Alt); break; case "\\": _activeModifier = _activeModifier.Add(ModifierKey.Console); break; default: ProcessKey(e.Char); break; } }
protected virtual int KeyboardHookProc(int code, int wParam, ref Native.keyboardHookStruct lParam) { if (code >= 0 && KeyboardHookEvent != null) { var key = (Keys)lParam.vkCode; KeyboardEventType type; if ((wParam == (int)User32.WM.WM_KEYDOWN || wParam == (int)User32.WM.WM_SYSKEYDOWN)) { type = KeyboardEventType.KeyDown; } else if ((wParam == (int)User32.WM.WM_KEYUP || wParam == (int)User32.WM.WM_SYSKEYUP)) { type = KeyboardEventType.KeyUp; } else { return(Native.CallNextHookEx(_hookId, code, wParam, ref lParam)); } var args = new KeyboardHookEventArgs(type, key, wParam, lParam); KeyboardHookEvent(args); if (args.Handled) { return(1); } } return(Native.CallNextHookEx(_hookId, code, wParam, ref lParam)); }
private void KeyDown(KeyboardHookEventArgs e) { if (e.Key == Keys.Q && e.isCtrlPressed) { _fireOnKeyMatch?.Invoke(); } }
private void KeyDownHandler(KeyboardHookEventArgs e) { Log.Verbose().Write("KeyDownEvent Recognized."); // handle keydown event here // Such as by checking if e (KeyboardHookEventArgs) matches the key you're interested in Keys userHotKey; Enum.TryParse <Keys>(_settings.HotKey, out userHotKey); // helper variables: // get the modifier settings from settings class and evaluate if they match the // current pressed buttons var isCtrlModifierValid = _settings.UseCtrlKey == e.isCtrlPressed ? true : false; var isShiftModifierValid = _settings.UseShiftKey == e.isShiftPressed ? true : false; var isAltModifierValid = _settings.UseAltKey == e.isAltPressed ? true : false; var isWindModifierVaild = _settings.UseWindowsKey == e.isWinPressed ? true : false; // if all conditions are true and align with the settings show the Clipboard screen if (e.Key == userHotKey && isCtrlModifierValid && isShiftModifierValid && isAltModifierValid && isWindModifierVaild) { Log.Debug().Write("Conditions for show ClipBoard screen met."); showScreen(); } //control-v pressed if (e.Key == Keys.V && e.isCtrlPressed) { Log.Verbose().Write("Paste value triggered by CTRL + V."); recordPaste(); } }
private void TestKeyHandler_SequenceWithOptionalKeys_OneTry() { var sequenceHandler = new KeySequenceHandler( new KeyCombinationHandler(VirtualKeyCode.Print), new KeyOrCombinationHandler( new KeyCombinationHandler(VirtualKeyCode.Shift, VirtualKeyCode.KeyA), new KeyCombinationHandler(VirtualKeyCode.Shift, VirtualKeyCode.KeyB)) ) { Timeout = null }; bool result; // Print key result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.Print)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.Print)); Assert.False(result); // Shift KeyB result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.Shift)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.KeyB)); Assert.True(result); // Shift KeyB result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.KeyB)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.Shift)); Assert.False(result); }
private void OnKeyDown(KeyboardHookEventArgs args) { if (args.Key == Keys.Escape) { Close(); } }
private void TestKeyHandler_KeySequenceHandler_Right() { var sequenceHandler = new KeySequenceHandler( new KeyCombinationHandler(VirtualKeyCode.Print), new KeyCombinationHandler(VirtualKeyCode.Shift, VirtualKeyCode.KeyA)) { Timeout = null }; var result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.Print)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.Print)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.Control)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.Control)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.Control)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.Shift)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.KeyA)); Assert.True(result); }
private void TestKeyHandler_KeySequenceHandler_Wrong_Right() { var sequenceHandler = new KeySequenceHandler( new KeyCombinationHandler(VirtualKeyCode.Print), new KeyCombinationHandler(VirtualKeyCode.Shift, VirtualKeyCode.KeyA)) { // Prevent debug issues, we are not testing the timeout here! Timeout = null }; var result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.Print)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.Shift)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.KeyB)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.KeyB)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.Shift)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.Print)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.Shift)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyDown(VirtualKeyCode.KeyA)); Assert.True(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.KeyA)); Assert.False(result); result = sequenceHandler.Handle(KeyboardHookEventArgs.KeyUp(VirtualKeyCode.Shift)); Assert.False(result); Assert.False(sequenceHandler.HasKeysPressed); }
/// <include file='Internal.xml' path='Docs/KeyboardHook/HookCallback/*'/> protected override bool HookCallback(int code, UIntPtr wparam, IntPtr lparam) { if (KeyboardEvent == null) { return(false); } KeyboardEvents kEvent = (KeyboardEvents)wparam.ToUInt32(); if (kEvent != KeyboardEvents.KeyDown && kEvent != KeyboardEvents.KeyUp && kEvent != KeyboardEvents.SystemKeyDown && kEvent != KeyboardEvents.SystemKeyUp) { return(false); } KeyboardHookEventArgs kea = GetKeyboardReading(lparam); if (kea == null) { return(false); } KeyboardEvent(kEvent, kea); return(kea.Cancel); }
private void ShortCutHandler(KeyboardHookEventArgs e) { if (e.Key == Keys.F1 && e.isAltPressed) { trayTrayIcon_DoubleClick(null, null); } }
// Hook Event private void Hooker_HotkeyDown(object sender, KeyboardHookEventArgs e) { debugLog("[Event] Event " + e.Name + " launched"); // STOP and VOLUME Hotkeys if (e.Name == "HK_STOP") { stopSound(); return; } else if (e.Name == "HK_VOLUP") { changeVolume(true); return; } else if (e.Name == "HK_VOLDOWN") { changeVolume(false); return; } // Is Hook actually a song Name foreach (HKSound sound in soundFiles) { if (sound.name == e.Name) { playSoundAtPos(soundFiles.IndexOf(sound)); } } }
protected virtual void OnKeyUpIntercepted(KeyboardHookEventArgs e) { if (KeyUpIntercepted != null) { KeyUpIntercepted.Invoke(e); } }
/// <summary> /// Raises the KeyIntercepted event. /// </summary> /// <param name="e">An instance of KeyboardHookEventArgs</param> public void OnKeyIntercepted(KeyboardHookEventArgs e) { if (KeyIntercepted != null) { KeyIntercepted(e); } }
private void MouseAndKeyboardHookService_KeyboardAction(object sender, KeyboardHookEventArgs e) { if (e.State == KeyState.Pressed) { if (e.Key == Key.Return || e.Key == Key.Space && AcceptHotKeysCommand.CanExecute(null)) { AcceptHotKeysCommand.Execute(null); } } if (e.State == KeyState.Released) { if (e.Key == Key.Escape) { ChangeHotKeyPopupClosedCommand.Execute(null); return; } else if (e.Key == Key.Return || e.Key == Key.Space || e.Key == Key.Tab) { return; } _keyboardShortcut.Add(e.Key); DisplayedTemporaryKeyboardShortcut = KeyToString(_keyboardShortcut); AcceptHotKeysCommand.RaiseCanExecuteChanged(); } e.Handled = true; }
private void TestKeyHandler_KeyCombinationHandler_Repeat() { var keyCombinationHandler = new KeyCombinationHandler(VirtualKeyCode.Print); var keyPrintDown = new KeyboardHookEventArgs { Key = VirtualKeyCode.Print, IsKeyDown = true }; var keyPrintUp = new KeyboardHookEventArgs { Key = VirtualKeyCode.Print, IsKeyDown = false }; var result = keyCombinationHandler.Handle(keyPrintDown); Assert.True(result); result = keyCombinationHandler.Handle(keyPrintDown); Assert.False(result); // Key up again result = keyCombinationHandler.Handle(keyPrintUp); Assert.False(result); result = keyCombinationHandler.Handle(keyPrintDown); Assert.True(result); }
public static List <string> GetKeyboardHookEventArgsAsList(KeyboardHookEventArgs keyboardHookEventArgs, string keyStart = "[", string keyEnd = "]") { List <string> keys = new List <string>(); // modifier keys if (keyboardHookEventArgs.isShiftPressed) { keys.Add(keyStart + "Shift" + keyEnd); } if (keyboardHookEventArgs.isCtrlPressed) { keys.Add(keyStart + "Ctrl" + keyEnd); } if (keyboardHookEventArgs.isAltPressed) { keys.Add(keyStart + "Alt" + keyEnd); } if (keyboardHookEventArgs.isWinPressed) { keys.Add(keyStart + "Win" + keyEnd); } // actual hotkey if (keyboardHookEventArgs.Key != Keys.None) { keys.Add(keyStart + keyboardHookEventArgs.Key.ToString() + keyEnd); } return(keys); }
private void Fire_KeyDown(KeyboardHookEventArgs kea) { if (KeyDown != null) { KeyDown(this, kea); } }
private bool CompareKeyArgs(KeyboardHookEventArgs kea1, KeyboardHookEventArgs kea2) { if (kea1.Key != kea2.Key) { return(false); } if (kea1.Alt != kea2.Alt) { return(false); } if (kea1.Ctrl != kea2.Ctrl) { return(false); } if (kea1.Shift != kea2.Shift) { return(false); } if (kea1.CapsLock != kea2.CapsLock) { return(false); } if (kea1.Cancel != kea2.Cancel) { return(false); } return(true); }
private KeyboardHookEventArgs[] GenerateRandomKeyData() { System.Windows.Forms.Keys[] keys = new System.Windows.Forms.Keys[] { System.Windows.Forms.Keys.Escape, System.Windows.Forms.Keys.N, System.Windows.Forms.Keys.F10, System.Windows.Forms.Keys.C, System.Windows.Forms.Keys.Enter, System.Windows.Forms.Keys.R, System.Windows.Forms.Keys.NumPad2, System.Windows.Forms.Keys.Z }; Random rand = new Random(0); KeyboardHookEventArgs keyArgs; ArrayList keysList = new ArrayList(); for (int i = 0; i < 1000; i++) { System.Windows.Forms.Keys key = keys[rand.Next() % keys.Length]; bool alt = rand.Next() % 2 == 1; bool ctrl = rand.Next() % 2 == 1; bool shift = rand.Next() % 2 == 1; bool capsLock = rand.Next() % 2 == 1; keyArgs = new KeyboardHookEventArgs(key, alt, ctrl, shift, capsLock); keysList.Add(keyArgs); } return((KeyboardHookEventArgs[])keysList.ToArray(typeof(KeyboardHookEventArgs))); }
private void keyHook_OnKeyDown(object sender, KeyboardHookEventArgs e) { // If we're the active table, discard any keys sent to this table specifically, Core'll take care of things if (Settings.UseKeyboardControls && Core.ActiveTable == this) { e.discard = true; } }
/// <summary> /// Fires when a key is received /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void kh_OnKeyDown(object sender, KeyboardHookEventArgs e) { // Discard the key if we're the active table if (Settings.UseKeyboardControls && IsActiveTable && blockingKeys.Contains(e.keycode)) { e.discard = true; } }
private static void KeyDown(KeyboardHookEventArgs e) { if (e.Key != Settings.ImmediateResizeKey || (_rez != null && !_rez.IsDisposed)) { return; } _rez = new ImmResize(); _rez.Show(); }
protected virtual void OnKeyboardEvent(KeyboardEvents kEvent, KeyboardHookEventArgs kea) { if (KeyboardEvent == null) { return; } KeyboardEvent(kEvent, kea); }
private void KeyboardHookOnKeyDown(object sender, KeyboardHookEventArgs e) { if (!Visible || Form.ActiveForm != FindForm()) { return; } if (!followRT) { var colCount = rtGrid.ColumnCount; var rowCount = rtGrid.RowCount; var cellCount = colCount * rowCount; var tableIndex = rtGrid.CurrentCellAddress.Y * colCount + rtGrid.CurrentCellAddress.X; switch (e.Key) { case Keys.D: tableIndex = (tableIndex + 1) % cellCount; SetCurrentCell(tableIndex); break; case Keys.A: tableIndex = (tableIndex - 1 + cellCount) % cellCount; SetCurrentCell(tableIndex); break; case Keys.W: tableIndex = (tableIndex - colCount + cellCount) % cellCount; SetCurrentCell(tableIndex); break; case Keys.S: tableIndex = (tableIndex + colCount) % cellCount; SetCurrentCell(tableIndex); break; } } if (!onlineManager.FirmwareManager.IsOpened) { return; } switch (e.Key) { //case (Keys)(189): //case Keys.Subtract: case Keys.K: ChangeTableValue((ModifierKeys & Keys.Shift) == Keys.Shift ? -10 : -1); break; //case (Keys)(187): //case Keys.Add: case Keys.L: ChangeTableValue((ModifierKeys & Keys.Shift) == Keys.Shift ? 10 : 1); break; } }
// // Test methods // public bool TriggerKeyAction(KeyboardEvents keyEvent, KeyboardHookEventArgs kea) { if (!installed) { string msg = "Key trigger cannot be used when the hook is uninstalled."; throw new InvalidOperationException(msg); } return(OnKeyboardEvent(keyEvent, kea.Key, kea.Alt, kea.Ctrl, kea.Shift, kea.CapsLock)); }
private void Global_KeyUp(KeyboardHookEventArgs e) { if (!IsStarted || (int)e.Key != 32) { return; } IsStarted = false; MessageBox.Show("Stopped"); }
/// <summary> /// This function is an event handler for the KeyIntercepted. /// It intercepts ALL keys from the keyboard input from the buffer. /// </summary> /// <param name="keyboardEvents">Contains the Key Enum, and the Key Code</param> void KeyboardHookInstance_KeyIntercepted(KeyboardHookEventArgs keyboardEvents) { if (keyboardEvents.PressedKey == Keys.PrintScreen) { takeSnapShot(); } if (keyboardEvents.PressedKey == Keys.F8) { this.Visible = !this.Visible; } }
private void keyHook_OnKeyDown(object sender, KeyboardHookEventArgs e) { // If we're the active table, discard any keys sent to this table specifically, Core'll take care of things if (Settings.UseKeyboardControls && Core.ActiveTable == this) e.discard = true; }
/// <summary> /// Raises the KeyIntercepted event. /// </summary> /// <param name="e">An instance of KeyboardHookEventArgs</param> public void OnKeyIntercepted(KeyboardHookEventArgs e) { if (KeyIntercepted != null) KeyIntercepted(e); }
/// <summary> /// Used to show a balloon when typing. Hooked into KeyboardHook. /// </summary> private static void KeyboardEventBalloon(object sender, KeyboardHookEventArgs args) { if (!Pause) { char c = (char)args.AsciiCode; char d = args.FlagUp ? '↑' : '↓'; ShowBalloon("You Typed", "" + c + d, 0.5f); } }
/// <summary> /// Sends the keyboard events into the collector /// </summary> private static void KeyboardEventCollect(object sender, KeyboardHookEventArgs args) { if(Highlander.WaitOne()) { if (!Pause && activeSession) { double score = IDverify.KeyEvent(args); if (!openTrust && Verifiers.trainingUser && !alreadyLocked) { alreadyLocked = true; Lock("EndOpenTrust", ""); HF.openTrustWindow(); alreadyLocked = false; } if (score < 50) { if (!openTrust) { alreadyLocked = true; Lock("Failed", ""); HF.openTrustWindow(); IdentityVerifier.TrustValue = 70; failCount = 0; alreadyLocked = false; } else { if (score != failscore || score == 0) { failCount++; failscore = score; if (failCount == 100) { failCount = 0; if (File.Exists(Configuration.profilePath + @"\" + Verifiers.currentUser + Verifiers.keyboardNameCaptured /*+ Verifiers.contextChange*/ + @".xml")) { unlockFiles(); File.Delete(Configuration.profilePath + @"\" + Verifiers.currentUser + Verifiers.keyboardNameCaptured /*+ Verifiers.contextChange*/ + @".xml"); lockFiles(); Verifiers.keyboardChange = true; // Note the keyboard has not actually changed we are just using this to force the system into trainin mode --N } } } } ni.Icon = ActiveAuthenticationDesktopClient.Properties.Resources.ARed; } else if (score < 70) { failCount = 0; ni.Icon = ActiveAuthenticationDesktopClient.Properties.Resources.AYellow; } else { failCount = 0; ni.Icon = ActiveAuthenticationDesktopClient.Properties.Resources.AGreen; } Highlander.ReleaseMutex(); } } // Raises a flag if the keyboard in use changes --N if (Verifiers.keyboardNameCaptured != Verifiers.keyboardNameOnRecord) { Verifiers.keyboardNameOnRecord = Verifiers.keyboardNameCaptured; Verifiers.keyboardChange = true; IDverify.changeKeyboard(Verifiers.keyboardNameCaptured); } }
/// <summary> /// Fires when a key is received /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void kh_OnKeyDown(object sender, KeyboardHookEventArgs e) { // Discard the key if we're the active table if (Settings.UseKeyboardControls && IsActiveTable && blockingKeys.Contains(e.keycode)) e.discard = true; }
private IntPtr HookCallback( int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN) { int vkCode = Marshal.ReadInt32(lParam); //Console.WriteLine((Keys)vkCode); KeyboardHookEventArgs keyHook = new KeyboardHookEventArgs(vkCode); KeyIntercepted(keyHook); } return CallNextHookEx(_hookID, nCode, wParam, lParam); }
/// <summary> /// This method collects keystrokes and does magic to verify your identity! /// </summary> /// <param name="args">This is the KeyboardHookEventArgs that contains all info about the KSE</param> public double KeyEvent(KeyboardHookEventArgs args) { //Store the keyboardevents in the keyboard event table KeyboardEvents.Rows.Add(args.SID, "", args.KeyEvent, args.VkCode, (args.KeyEventTime-621355968000000000) / 10000); #if Recording KElog.Rows.Add(args.SID, "", args.KeyEvent, args.VkCode, (args.KeyEventTime - 621355968000000000) / 10000); #endif //Check if a full sample has been collected and if so ship it to the feature extractors if (KeyboardEvents.Rows.Count > 0 && KeyboardEvents.Rows.Count % Configuration.slidingWindowJump == 0)//if enough events have been collected for a microsample { #if Recording KELOG.WriteXml(Path.GetPathRoot(Environment.SystemDirectory)+@"Users\Azriel\Desktop\NEWKahona"); #endif //Get and assign the sampleID to each row string sampleId = Guid.NewGuid().ToString(); foreach (DataRow row in KeyboardEvents.Rows) row["SampleId"] = sampleId; #region FeatureExtractors //Create a dataset to store the feature extractor data DataSet extracted = new DataSet(); extracted.Clear(); foreach (FeatureExtractor fe in extractors) { //Run Feature Extractors extracted.Tables.Add(fe.extract(KeyboardEvents)); } //Create a table to hold the total feature extractor data DataTable features = new DataTable(); foreach (DataTable dt in extracted.Tables) { //Combine feature extractor tables features.Merge(dt); } microSamplesSent++; // Increment the sample counter to output how many samples have been sent when this user completes. if (microSamplesSent >= Configuration.numSkippedSamples) { sampleCount++; microSamplesSent = 0; } if (KeyboardEvents.Rows.Count >= Configuration.keyEventsPerSample) { //Slide the window down for (int i = 0; i < Configuration.slidingWindowJump; i++) { KeyboardEvents.Rows.RemoveAt(0); } } DataSet dsfeatures = new DataSet(); dsfeatures.Tables.Add(features); #endregion //Send the feature extractor scores into the verifiers DataSet verifierScores = verifiers.RunVerifier(dsfeatures); if (verifierScores.Tables[0].Rows.Count>0) { #if OutputScores //verifierScores.WriteXml(Path.GetPathRoot(Environment.SystemDirectory)+@"Users\Azriel\Desktop\Scores\VerifierScores\" + sampleCount.ToString() + microSamplesSent.ToString() + "scores.xml"); this appears to be here for verification purposes --N #endif //Send the verifier scores into the fuser DataTable Scores = Fuse_MajorityVoting(verifierScores); updateTrust((double)Scores.Rows[0]["Score"], (double)Scores.Rows[0]["Threshold"]); #if DEBUG Console.WriteLine("Score = " + ((double)Scores.Rows[0]["Score"]).ToString()); Console.WriteLine("Trust = " + TrustValue.ToString()); #endif return TrustValue; } } return TrustValue; }