/// <summary> /// Initializes a new instance of the class. /// </summary> /// <param name="monitorInfo">Active window info</param> /// <param name="widget">Scanner button that needs to be enabled/disabled</param> public CheckEnabledArgs(WindowActivityMonitorInfo monitorInfo, Widget widget) { Handled = false; Enabled = false; Widget = widget; MonitorInfo = monitorInfo; }
/// <summary> /// Initializes a new instance of the class. /// </summary> /// <param name="panelClass">The scanner to be activted</param> /// <param name="monitorInfo">Contextual info about app window</param> public PanelRequestEventArgs(String panelClass, WindowActivityMonitorInfo monitorInfo) { init(); PanelClass = panelClass; MonitorInfo = monitorInfo; }
public override void OnFocusChanged(WindowActivityMonitorInfo monitorInfo, ref bool handled) { Log.Debug(); setTextInterface(_textInterface); handled = true; }
public override void OnContextMenuRequest(WindowActivityMonitorInfo monitorInfo) { #if AUTO_SWITCH_SCANNER String panelClass = PanelClasses.None; if (!getPanel(monitorInfo, true, ref panelClass)) { if (isDesktopWindow(monitorInfo.FocusedElement)) { showPanel(this, new PanelRequestEventArgs("WindowsDesktopContextMenu", "Desktop", monitorInfo)); return; } } showPanel(this, new PanelRequestEventArgs(panelClass, "Explorer", monitorInfo)); #endif }
public override void OnFocusChanged(WindowActivityMonitorInfo monitorInfo, ref bool handled) { Log.Debug("OnFocus: " + monitorInfo.ToString()); base.OnFocusChanged(monitorInfo, ref handled); setTextInterface(textInterface); if (!_menuShown) { var arg = new PanelRequestEventArgs(PanelClasses.None, monitorInfo); handled = getPanel(arg); if (handled) { _menuShown = true; showPanel(this, arg); } } }
/// <summary> /// Invoked when the foreground window focus changes. Display the /// contextual menus for dialogs which will allow interaction with the dialog /// </summary> /// <param name="monitorInfo">Foreground window info</param> /// <param name="handled">set to true if handled</param> public override void OnFocusChanged(WindowActivityMonitorInfo monitorInfo, ref bool handled) { Log.Debug(); Log.Debug("prevHwnd: " + _prevHwnd + ", fgHwnd: " + monitorInfo.FgHwnd); if (autoSwitchScanners && _prevHwnd != monitorInfo.FgHwnd) { Log.Debug("They are not equal. Show dialog panel"); base.OnFocusChanged(monitorInfo, ref handled); showPanel(this, new PanelRequestEventArgs(PanelClasses.DialogContextMenu, monitorInfo.Title, monitorInfo)); _prevHwnd = monitorInfo.FgHwnd; } handled = true; }
public override void OnFocusChanged(WindowActivityMonitorInfo monitorInfo, ref bool handled) { Log.Debug("OnFocus: " + monitorInfo.ToString()); base.OnFocusChanged(monitorInfo, ref handled); if (monitorInfo.IsNewWindow) { showPanelOnFocusChanged(this, new PanelRequestEventArgs(PanelClasses.Alphabet, monitorInfo)); handled = true; } #if abc String panel = PanelClasses.None; handled = getPanel(monitorInfo, false, ref panel); if (handled) { showPanelOnFocusChanged(this, new PanelRequestEventArgs(panel, "Explorer", monitorInfo)); } #endif }
/// <summary> /// Invoked when the foreground window focus changes. Displays the /// scanner depending on the context. Also, if this is a new window that has /// come into focus, adds its contents to the word prediction temporary batch model for more /// contextual prediction of words /// </summary> /// <param name="monitorInfo">Foreground window info</param> /// <param name="handled">set to true if handled</param> public override void OnFocusChanged(WindowActivityMonitorInfo monitorInfo, ref bool handled) { Log.Debug(); if (String.Compare(monitorInfo.FocusedElement.Current.ClassName, DocClassName, true) == 0) { createMSWordTextInterface(); if (monitorInfo.IsNewFocusedElement) { showPanel(this, new PanelRequestEventArgs(PanelClasses.Alphabet, monitorInfo)); } if (monitorInfo.IsNewWindow) { loadWordPredictionContext(); } } else if (autoSwitchScanners) { if (isRecentDocuments(monitorInfo.FocusedElement)) { showPanel(this, new PanelRequestEventArgs(PanelClasses.DialogContextMenu, ScannerTitle, monitorInfo)); } else if (String.Compare(monitorInfo.FocusedElement.Current.ClassName, "NetUIToolWindow") == 0) { showPanel(this, new PanelRequestEventArgs(PanelClasses.MenuContextMenu, ScannerTitle, monitorInfo)); } else { handled = false; return; } } else if (!_scannerShown) { showPanel(this, new PanelRequestEventArgs(PanelClasses.Alphabet, monitorInfo)); _scannerShown = true; } handled = true; }
/// <summary> /// Displays the scanner appropriate for the element that is currently /// in focus in the Windows explorer window /// </summary> /// <param name="monitorInfo">Foreground window info</param> /// <param name="handled">set to true if handled</param> private void displayScanner(WindowActivityMonitorInfo monitorInfo, ref bool handled) { Log.Debug("KILLROY Entered"); if (monitorInfo.FocusedElement.Current.ControlType.ProgrammaticName == "ControlType.Edit") { Log.Debug("KILLROY controtype edit"); base.OnFocusChanged(monitorInfo, ref handled); showPanel(this, new PanelRequestEventArgs(PanelClasses.Alphabet, monitorInfo)); _scannerShown = true; } else// if (monitorInfo.IsNewWindow) { Log.Debug("KILLROY calling getmenu"); String panel = PanelClasses.None; handled = getMenu(monitorInfo, ref panel); if (handled) { showPanel(this, new PanelRequestEventArgs(panel, "Explorer", monitorInfo)); _scannerShown = true; } } #if abc else { Log.Debug("KILLROY *** FALL THROUGH> WILL NOT BE HANDLED"); //handled = true; } #endif }
/// <summary> /// Invoked when the foreground window focus changes. Depending on which /// element has focus in the acrobat reader window, display the appropriate /// scanner /// </summary> /// <param name="monitorInfo">Foreground window info</param> /// <param name="handled">set to true if handled</param> public override void OnFocusChanged(WindowActivityMonitorInfo monitorInfo, ref bool handled) { Log.Debug(); if (monitorInfo.IsNewWindow) { _scannerShown = false; } if (autoSwitchScanners) { if (!_scannerShown) { displayScanner(monitorInfo, ref handled); } else { handled = true; } } else { base.OnFocusChanged(monitorInfo, ref handled); if (!_scannerShown) { showPanel(this, new PanelRequestEventArgs(PanelClasses.Alphabet, monitorInfo)); _scannerShown = true; } handled = true; } }
/// <summary> /// Displays the scanner that is appropriate for the element in focus /// </summary> /// <param name="monitorInfo">Foreground window info</param> /// <param name="handled">set to true if handled</param> private void autoDisplayScanner(WindowActivityMonitorInfo monitorInfo, ref bool handled) { handled = true; if (_explorerElements.IsFavoritesWindow(monitorInfo.FocusedElement) || _explorerElements.IsHistoryWindow(monitorInfo.FocusedElement) || _explorerElements.IsFeedsWindow(monitorInfo.FocusedElement)) { if (!_scannerType.HasFlag(ScannerType.Favorites)) { var args = new PanelRequestEventArgs(PanelClasses.MenuContextMenu, ScannerTitle, monitorInfo) { UseCurrentScreenAsParent = true }; showPanel(this, args); _scannerType = ScannerType.Favorites; } } else if (_explorerElements.IsSearchControl(monitorInfo.FocusedElement) || _explorerElements.IsFindControl(monitorInfo.FocusedElement) || _explorerElements.IsAddressWindow(monitorInfo.FocusedElement)) { if (!_scannerType.HasFlag(ScannerType.Address)) { showPanel(this, new PanelRequestEventArgs(PanelClasses.Alphabet, monitorInfo)); _scannerType = ScannerType.Address; } } else if (!_scannerType.HasFlag(ScannerType.Other)) { showPanel(this, new PanelRequestEventArgs("InternetExplorerContextMenu", ScannerTitle, monitorInfo)); _scannerType = ScannerType.Other; } }
/// <summary> /// Invoked when the focus changes either in the active window or when the /// active window itself changes. /// </summary> /// <param name="monitorInfo">Info about focused element</param> public void OnFocusChanged(WindowActivityMonitorInfo monitorInfo) { _alphabetScannerCommon.OnFocusChanged(monitorInfo); }
public override void OnContextMenuRequest(WindowActivityMonitorInfo monitorInfo) { }
/// <summary> /// Is the active window the "Contacts" window? /// </summary> /// <param name="monitorInfo">Active window info</param> /// <returns>true if it is</returns> public bool IsNotesWindow(WindowActivityMonitorInfo monitorInfo) { return (monitorInfo.Title.StartsWith("Notes - ") && monitorInfo.Title.EndsWith("Microsoft Outlook")); }
/// <summary> /// Initialzies an instance of the class /// </summary> /// <param name="monitorInfo">Focused element info</param> public FocusChangedEventArgs(WindowActivityMonitorInfo monitorInfo) { WindowActivityInfo = monitorInfo; }
private static void getActiveWindow(bool flag = false) { AutomationElement focusedElement = null; try { IntPtr foregroundWindow = Windows.GetForegroundWindow(); var title = Windows.GetWindowTitle(foregroundWindow); Log.Debug("fgHwnd = " + ((foregroundWindow != IntPtr.Zero) ? foregroundWindow.ToString() : "null") + ", title: " + title); if (Windows.GetOSVersion() == Windows.WindowsVersion.Win10 && title.StartsWith("Jump List for")) { return; } focusedElement = AutomationElement.FocusedElement; Log.Debug("focusedElement is " + ((focusedElement != null) ? "not null" : "null")); Log.Debug("_currentfocusedElement is " + ((_currentFocusedElement != null) ? "not null" : "null")); bool elementChanged = true; var process = GetProcessForWindow(foregroundWindow); // check if anything changed. did the window focus change? // did focus change within the window? if (focusedElement != null && (_forceGetActiveWindow || flag || foregroundWindow != _currentHwnd || _currentFocusedElement == null || (elementChanged = IsDifferent(focusedElement, _currentFocusedElement)))) { //Log.Debug("Reason: _forceGetActiveWindow: " + _forceGetActiveWindow); //Log.Debug("Reason: flag: " + flag); //Log.Debug("Reason: fgHwnd != _currentHwnd : " + (fgHwnd != _currentHwnd)); //Log.Debug("Reason: _currentFocusedElement == null : " + (_currentFocusedElement == null)); //Log.Debug("Reason: elementChanged : " + elementChanged); if (_forceGetActiveWindow) { _forceGetActiveWindow = false; } if (EvtFocusChanged != null) { var monitorInfo = new WindowActivityMonitorInfo { FgHwnd = foregroundWindow, Title = title, FgProcess = process, FocusedElement = focusedElement, IsNewWindow = _currentHwnd != foregroundWindow }; if (flag) { monitorInfo.IsNewWindow = true; } if (monitorInfo.IsNewWindow || _currentFocusedElement == null || elementChanged) { monitorInfo.IsNewFocusedElement = true; } #if VERBOSE Log.Debug("#$#>>>>>>>>>>>>>>>> Triggering FOCUS changed event"); Log.Debug("#$# title: " + title); Log.Debug("#$# fgHwnd " + monitorInfo.FgHwnd); Log.Debug("#$# nativewinhandle: " + focusedElement.Current.NativeWindowHandle); Log.Debug("#$# Process: " + process.ProcessName); Log.Debug("#$# class: " + focusedElement.Current.ClassName); Log.Debug("#$# controltype: " + focusedElement.Current.ControlType.ProgrammaticName); Log.Debug("#$# automationid: " + focusedElement.Current.AutomationId); Log.Debug("#$# newWindow: " + monitorInfo.IsNewWindow); Log.Debug("#$# newFocusElement: " + monitorInfo.IsNewFocusedElement); Log.Debug("#$# IsMinimized : " + Windows.IsMinimized(monitorInfo.FgHwnd)); #endif if (monitorInfo.IsNewWindow) { AuditLog.Audit(new AuditEventActiveWindowChange(process.ProcessName, title)); } if (EvtFocusChanged != null) { EvtFocusChanged(monitorInfo); } _currentFocusedElement = focusedElement; } else { Log.Debug("EvtFocusChanged is null"); } } _currentHwnd = foregroundWindow; // raise the heartbeat event if (EvtWindowMonitorHeartbeat != null && focusedElement != null && _heartbeatToggle) { var monitorInfo = new WindowActivityMonitorInfo { FgHwnd = foregroundWindow, FocusedElement = focusedElement, Title = title, FgProcess = process }; EvtWindowMonitorHeartbeat(monitorInfo); } _heartbeatToggle = !_heartbeatToggle; } catch (Exception e) { Log.Debug("exception: " + e); _currentFocusedElement = null; } }
/// <summary> /// Invoked when the focus changes either in the active window or when the /// active window itself changes. Call this from the OnFocusChanged function /// in the Alphabet scanner /// </summary> /// <param name="inf">Info about focused element</param> public void OnFocusChanged(WindowActivityMonitorInfo info) { _scannerCommon.OnFocusChanged(info); }
/// <summary> /// Is the active window an open "Contact" window? /// </summary> /// <param name="monitorInfo">Active window info</param> /// <param name="subType">The focused Outlook window control element </param> /// <returns>true if it is</returns> public bool IsOpenContactWindow(WindowActivityMonitorInfo monitorInfo, ref OutlookControlSubType subType) { Log.Debug(); subType = OutlookControlSubType.Unknown; bool retVal = true; if (monitorInfo.FocusedElement == null) { return false; } var windowElement = AutomationElement.FromHandle(monitorInfo.FgHwnd); var element = (AgentUtils.FindElementByAutomationId(windowElement, "RichEdit20WPT", ControlType.Edit, "4481", "Company:") ?? AgentUtils.FindElementByAutomationId(windowElement, "RichEdit20WPT", ControlType.Edit, "4480", "Job Title:")) ?? AgentUtils.FindElementByAutomationId(windowElement, "RichEdit20WPT", ControlType.Edit, "4096", "FullName"); retVal = (element != null); if (retVal) { if (AgentUtils.IsElementByAutomationId(monitorInfo.FocusedElement, "_WwG", "ControlType.Pane", "", "Message")) { subType = OutlookControlSubType.ContactMessageField; } } Log.Debug("Returning " + retVal); return retVal; }
/// <summary> /// Invoked when the focus changes either in the active window or when the /// active window itself changes. /// </summary> /// <param name="monitorInfo">Info about focused element</param> /// <param name="handled">was this handled</param> public override void OnFocusChanged(WindowActivityMonitorInfo monitorInfo, ref bool handled) { Log.Debug("OnFocus: " + monitorInfo.ToString() + ", menushown: " + _scannerShown); base.OnFocusChanged(monitorInfo, ref handled); if (!_scannerShown && _launchAppScanner != null) { var arg = new PanelRequestEventArgs(PanelClasses.AlphabetMinimal, monitorInfo) { TargetPanel = _launchAppScanner, RequestArg = _launchAppScanner, UseCurrentScreenAsParent = true }; showPanel(this, arg); _scannerShown = true; } handled = true; }
/// <summary> /// Is the active window an open Outlook "Note" window? /// </summary> /// <param name="monitorInfo">Active window info</param> /// <param name="subType">The focused Outlook window control element </param> /// <returns>true if it is</returns> public bool IsOpenNoteWindow(WindowActivityMonitorInfo monitorInfo, ref OutlookControlSubType subType) { bool retVal = false; subType = OutlookControlSubType.Unknown; var element = AgentUtils.GetElementOrAncestorByAutomationId(monitorInfo.FocusedElement, "RichEdit20WPT", "ControlType.Edit", "4159"); if (element != null) { var name = element.Current.Name; retVal = (name == "Note text"); } if (retVal) { if (AgentUtils.IsElementByAutomationId(monitorInfo.FocusedElement, "RichEdit20WPT", "ControlType.Edit", "4159")) { subType = OutlookControlSubType.OpenNoteMessageBodyField; } } return retVal; }
/// <summary> /// Displays the contextual menu /// </summary> /// <param name="monitorInfo">Foreground window info</param> public override void OnContextMenuRequest(WindowActivityMonitorInfo monitorInfo) { //if (autoSwitchScanners) //{ // AgentManager.Instance.Keyboard.Send(Keys.F6); //} showPanel(this, new PanelRequestEventArgs("InternetExplorerContextMenu", ScannerTitle, monitorInfo)); }
/// <summary> /// Is the active window an open "Task" window? /// </summary> /// <param name="monitorInfo">Active window info</param> /// <param name="subType">The focused Outlook window control element </param> /// <returns>true if it is</returns> public bool IsOpenTaskWindow(WindowActivityMonitorInfo monitorInfo, ref OutlookControlSubType subType) { Log.Debug(); subType = OutlookControlSubType.Unknown; bool retVal = true; if (monitorInfo.FocusedElement == null) { return false; } var windowElement = AutomationElement.FromHandle(monitorInfo.FgHwnd); if (windowElement == null) { return false; } var element = (AgentUtils.FindElementByAutomationId(windowElement, "REComboBox20W", ControlType.ComboBox, "4481", "Status:") ?? AgentUtils.FindElementByAutomationId(windowElement, "REComboBox20W", ControlType.ComboBox, "4480", "Priority:")) ?? AgentUtils.FindElementByAutomationId(windowElement, "RichEdit20WPT", ControlType.Edit, "4112", "% Complete:"); retVal = (element != null); if (retVal) { if (AgentUtils.IsElementByAutomationId(monitorInfo.FocusedElement, "RichEdit20WPT", "ControlType.Edit", "4097", "Subject:")) { subType = OutlookControlSubType.TaskSubjectField; } else if (AgentUtils.IsElementByAutomationId(monitorInfo.FocusedElement, "_WwG", "ControlType.Pane", "", "Message")) { subType = OutlookControlSubType.TaskMessageBodyField; } } Log.Debug("Returning " + retVal); return retVal; }
public override void OnContextMenuRequest(WindowActivityMonitorInfo monitorInfo) { showPanel(this, new PanelRequestEventArgs(PanelClasses.UnsupportedAppContextMenu, monitorInfo)); }
/// <summary> /// Is the active window the Task window? /// </summary> /// <param name="monitorInfo">Active window info</param> /// <param name="subType">The focused Outlook window control element </param> /// <returns>true if it is</returns> public bool IsTasksWindow(WindowActivityMonitorInfo monitorInfo) { return ((monitorInfo.Title.StartsWith("Tasks - ") || monitorInfo.Title.StartsWith("To-Do List")) && monitorInfo.Title.EndsWith("Microsoft Outlook")); }
/// <summary> /// Displays the contextual menu /// </summary> /// <param name="monitorInfo">Foreground window info</param> public override void OnContextMenuRequest(WindowActivityMonitorInfo monitorInfo) { // Do a panel switch to the main document //AgentManager.Instance.Keyboard.Send(Keys.F6); showPanel(this, new PanelRequestEventArgs(ContextualMenuName, "Explorer", monitorInfo)); }
/// <summary> /// Is the active window the "Contacts" window? /// </summary> /// <param name="monitorInfo">Active window info</param> /// <param name="subType">The focused Outlook window control element </param> /// <returns>true if it is</returns> public OutlookWindowTypes IdentifyWindow(WindowActivityMonitorInfo monitorInfo, ref OutlookControlSubType subType) { var windowType = OutlookWindowTypes.Unknown; bool isNewEmail = false; subType = OutlookControlSubType.Unknown; if (IsEmailMsgWindow(monitorInfo, ref isNewEmail, ref subType)) { windowType = (isNewEmail) ? OutlookWindowTypes.NewEmailMessage : OutlookWindowTypes.EmailMessage; } else if (IsTasksWindow(monitorInfo)) { windowType = OutlookWindowTypes.Tasks; } else if (IsNotesWindow(monitorInfo)) { windowType = OutlookWindowTypes.Notes; } else if (IsContactsWindow(monitorInfo)) { windowType = OutlookWindowTypes.Contacts; } else if (IsCalendarWindow(monitorInfo)) { windowType = OutlookWindowTypes.Calendar; } else if (IsInboxWindow(monitorInfo)) { windowType = OutlookWindowTypes.Inbox; } else if (IsOpenNoteWindow(monitorInfo, ref subType)) { windowType = OutlookWindowTypes.OpenNote; } else if (IsOpenAppointmentWindow(monitorInfo, ref subType)) { windowType = OutlookWindowTypes.OpenAppointment; } else if (IsAppointmentSchedulingWindow(monitorInfo, ref subType)) { windowType = OutlookWindowTypes.AppointmentScheduling; } else if (IsOpenContactWindow(monitorInfo, ref subType)) { windowType = OutlookWindowTypes.OpenContact; } else if (IsOpenTaskWindow(monitorInfo, ref subType)) { windowType = OutlookWindowTypes.OpenTask; } else if (IsAddressBookWindow(monitorInfo, ref subType)) { windowType = OutlookWindowTypes.AddressBook; } else if (IsAddressBookDetailsWindow(monitorInfo)) { windowType = OutlookWindowTypes.AddressBookDetails; } return windowType; }
/// <summary> /// Gets the menu for the Explorer window in focus. Checks if the /// file explorer is active and returns the contextual menu name for it /// </summary> /// <param name="monitorInfo">fg window info</param> /// <param name="panelClass">returns the panel class of the menu</param> /// <returns>true if it found a menu for the window</returns> protected bool getMenu(WindowActivityMonitorInfo monitorInfo, ref String panelClass) { AutomationElement windowElement = getWindowElement(monitorInfo.FgHwnd); bool retVal = true; if (windowElement != null) { if (isFileExplorer(windowElement)) { Log.Debug("KILLROY isFileExploer is TRUE "); if (Windows.IsMinimized(monitorInfo.FgHwnd)) { retVal = false; } else { panelClass = ContextualMenuName; } } else { Log.Debug("KILLROY isFileExploer is FALSE"); retVal = false; } } else { Log.Debug("KILLROY windowElement is NULL"); } Log.Debug("KILLROY return from getmenu : " + retVal); return retVal; }
/// <summary> /// Get all the widgets whose "enabled" property is set to /// contextual in the config file. Decide the "enabled" state /// of these widgets depending on the context /// </summary> /// <param name="monitorInfo">Context info about active window</param> private void SetWidgetEnabledStates(WindowActivityMonitorInfo monitorInfo) { if (_syncLock.IsClosing()) { Log.Debug("Form is closing " + ScannerForm.Name); WindowActivityMonitor.EvtWindowMonitorHeartbeat -= WindowActivityMonitor_EvtWindowMonitorHeartbeat; return; } if (_rootWidget != null && Context.AppAgentMgr != null && !_syncLock.IsClosing() && Windows.GetVisible(ScannerForm)) { foreach (Widget widget in _rootWidget.WidgetLayout.ContextualWidgets) { ////Log.Debug("Widget: " + widget.Name + ", subclass: " + widget.SubClass); if (!String.IsNullOrEmpty(widget.SubClass)) { var arg = new CheckEnabledArgs(monitorInfo, widget); if (!_syncLock.IsClosing()) { _scannerPanel.CheckWidgetEnabled(arg); if (!arg.Handled) { Context.AppAgentMgr.CheckWidgetEnabled(arg); } widget.Enabled = arg.Handled ? arg.Enabled : widget.DefaultEnabled; } else { break; } ////Log.Debug("widget.Enabled set to : " + widget.Enabled + " for feature " + widget.SubClass); } } } }
/// <summary> /// Displays the contextual menu /// </summary> /// <param name="monitorInfo">Foreground window info</param> public override void OnContextMenuRequest(WindowActivityMonitorInfo monitorInfo) { showPanel(this, new PanelRequestEventArgs("MSWordContextMenu", ScannerTitle, monitorInfo)); }
/// <summary> /// Heartbeat handler from the windowactivitymonitor. Use this /// monitor to set the 'enabled' state of the widgets in the scanner /// based on the context. /// </summary> /// <param name="monitorInfo">active window context info</param> private void WindowActivityMonitor_EvtWindowMonitorHeartbeat(WindowActivityMonitorInfo monitorInfo) { try { SetWidgetEnabledStates(monitorInfo); } catch { } }
/// <summary> /// Not used /// </summary> /// <param name="monitorInfo"></param> public void OnFocusChanged(WindowActivityMonitorInfo monitorInfo) { }
/// <summary> /// Focus changed in the foreground application. Set widget /// enabled states /// </summary> /// <param name="monitorInfo"></param> public void OnFocusChanged(WindowActivityMonitorInfo monitorInfo) { SetWidgetEnabledStates(monitorInfo); }