Пример #1
0
 /// -------------------------------------------------------------------
 /// <summary>
 /// Method that registers the event handler OnEvent()
 /// </summary>
 /// -------------------------------------------------------------------
 new public virtual void AddEventHandler()
 {
     base.AddEventHandler();
     Comment("Adding AddAutomationFocusChangedEventHandler");
     handler = new AutomationFocusChangedEventHandler(OnEvent);
     Automation.AddAutomationFocusChangedEventHandler(handler);
 }
Пример #2
0
        ///--------------------------------------------------------------------
        /// <summary>
        /// Register for events of interest.
        /// </summary>
        ///--------------------------------------------------------------------
        private void RegisterForEvents()
        {
            // Focus changes are global; we'll get cached properties for
            // all elements that receive focus.
            focusHandler =
                new AutomationFocusChangedEventHandler(OnFocusChange);
            Automation.AddAutomationFocusChangedEventHandler(focusHandler);

            // Register for events from descendants of the root element.
            // Only the events supported by a control will be registered.
            invokeHandler = new AutomationEventHandler(OnInvoke);
            Automation.AddAutomationEventHandler(
                InvokePattern.InvokedEvent,
                targetApp,
                TreeScope.Children,
                invokeHandler);
            rangevalueHandler =
                new AutomationPropertyChangedEventHandler(OnRangeValueChange);
            Automation.AddAutomationPropertyChangedEventHandler(
                targetApp,
                TreeScope.Children,
                rangevalueHandler,
                RangeValuePattern.ValueProperty);
            selectionHandler =
                new AutomationEventHandler(OnSelectionItemSelected);
            Automation.AddAutomationEventHandler(
                SelectionItemPattern.ElementSelectedEvent,
                targetApp,
                TreeScope.Descendants,
                selectionHandler);
        }
Пример #3
0
        public void SetFocusTest()
        {
            AutomationElement [] expectedFocusedElements = new AutomationElement [] {
                textbox3Element, button2Element
            };

            button2Element.SetFocus();
            AutomationFocusChangedEventHandler handler = (s, e) => actualFocusedElements.Add((AutomationElement)s);

            At.AddAutomationFocusChangedEventHandler(handler);
            actualFocusedElements.Clear();
            textbox3Element.SetFocus();
            Thread.Sleep(100);
            Assert.AreEqual(textbox3Element, AutomationElement.FocusedElement, "FocusedElement");
            button2Element.SetFocus();
            Thread.Sleep(100);
            Assert.AreEqual(button2Element, AutomationElement.FocusedElement, "FocusedElement");
            Thread.Sleep(1000);
            At.RemoveAutomationFocusChangedEventHandler(handler);
            Assert.AreEqual(expectedFocusedElements.Length, actualFocusedElements.Count, "Event handler count");
            for (int i = 0; i < actualFocusedElements.Count; i++)
            {
                Assert.AreEqual(expectedFocusedElements [i], actualFocusedElements [i], "Event handler sender #" + i);
            }
        }
Пример #4
0
        public void StopDodging()
        {
            try
            {
                if (!_state.TryingToDodge)
                {
                    throw new InvalidOperationException("could not stop dodging as the application was not dodging");
                }

                _state.StopDodging();

                if (_state.WaitingForUserToAssignDodge)
                {
                    _state.ToggleWaiting();
                }

                Hook.GlobalEvents().MouseDown -= OnGlobalMouseDown;
                Automation.RemoveAutomationFocusChangedEventHandler(_focusHandler);
                _focusHandler = null;
            }
            catch (Exception e)
            {
                throw e;
            }
        }
Пример #5
0
        private void SetupWindowHandling()
        {
#if !DEBUG
            AutomationFocusChangedEventHandler handler = SoundManager_OnWindowFocusChange;

            Automation.AddAutomationFocusChangedEventHandler(handler);
#endif
        }
Пример #6
0
 public void UnsubscribeFocusChange()
 {
     if (_focusChangedHandler != null)
     {
         Automation.RemoveAutomationFocusChangedEventHandler(_focusChangedHandler);
         _focusChangedHandler = null;
     }
 }
Пример #7
0
        // </Snippet1015>

        // <Snippet102>
        ///--------------------------------------------------------------------
        /// <summary>
        /// Set up table item event listeners.
        /// </summary>
        /// <remarks>
        /// The event listener is essentially a focus change listener.
        /// Since this is a global desktop listener, a filter would be required
        /// to ignore focus change events outside the table.
        /// </remarks>
        ///--------------------------------------------------------------------
        private void SetTableItemEventListeners()
        {
            AutomationFocusChangedEventHandler tableItemFocusChangedListener =
                new AutomationFocusChangedEventHandler(OnTableItemFocusChange);

            Automation.AddAutomationFocusChangedEventHandler(
                tableItemFocusChangedListener);
        }
Пример #8
0
        // </Snippet1015>

        // <Snippet102>
        ///--------------------------------------------------------------------
        /// <summary>
        /// Set up grid item event listeners.
        /// </summary>
        /// <param name="targetControl">
        /// The grid item container of interest.
        /// </param>
        ///--------------------------------------------------------------------
        private void SetGridItemEventListeners(AutomationElement targetControl)
        {
            AutomationFocusChangedEventHandler gridItemFocusChangedListener =
                new AutomationFocusChangedEventHandler(OnGridItemFocusChange);

            Automation.AddAutomationFocusChangedEventHandler(
                gridItemFocusChangedListener);
        }
        internal static void Add(
            AutomationFocusChangedEventHandler handlingDelegate)
        {
            var e            = new AutomationFocusChangedEventHandlerImpl(handlingDelegate: handlingDelegate);
            var cacheRequest = AutomationElement.DefaultCacheRequest.IUIAutomationCacheRequest;

            Boundary.UIAutomation(a: () => Automation.AutomationClass.AddFocusChangedEventHandler(cacheRequest: cacheRequest, handler: e));
            Add(instance: e);
        }
Пример #10
0
        /// <summary>
        /// Called by a client to remove a listener for focus changed events.
        /// </summary>
        /// <param name="eventHandler">The handler object that was passed to AddAutomationFocusChangedListener</param>
        ///
        /// <outside_see conditional="false">
        /// This API does not work inside the secure execution environment.
        /// <exception cref="System.Security.Permissions.SecurityPermission"/>
        /// </outside_see>
        public static void RemoveAutomationFocusChangedEventHandler(
            AutomationFocusChangedEventHandler eventHandler
            )
        {
            Misc.ValidateArgumentNonNull(eventHandler, "eventHandler");

            // Remove the client-side listener for for this event
            ClientEventManager.RemoveFocusListener(eventHandler);
        }
Пример #11
0
        private void OnGlobalMouseDown(object sender, MouseEventArgs e)
        {
            var pHandle = WindowFromPoint(e.Location);

            _state.UpdateProcess(pHandle);

            _focusHandler = new AutomationFocusChangedEventHandler(OnWindowsFocusChanged);
            Automation.AddAutomationFocusChangedEventHandler(_focusHandler);
        }
Пример #12
0
 public override void Start(IEventSink sink)
 {
     Validate.ArgumentNotNull(parameter: sink, parameterName: nameof(sink));
     Stop();
     this._sinkReference        = new WeakReference(target: sink);
     this._sinkReference.Target = sink;
     this._handlingDelegate     = Handler;
     Automation.AddAutomationFocusChangedEventHandler(eventHandler: this._handlingDelegate);
 }
Пример #13
0
        private void RegisterForEvents()
        {
            // Subscribe to events of interest.
            // Do this while a CacheRequest is activated, so that the AutomationElement passed
            // to the event handlers will have cached properties.
            CacheRequest cacheRequest = new CacheRequest();

            cacheRequest.Add(AutomationElement.NameProperty);
            cacheRequest.Add(AutomationElement.ControlTypeProperty);
            cacheRequest.TreeScope = TreeScope.Element;

            using (cacheRequest.Activate())
            {
                // Focus changes are global; we'll get cached properties for all elements that receive focus.
                AutomationFocusChangedEventHandler focusHandler =
                    new AutomationFocusChangedEventHandler(OnFocusChange);
                Automation.AddAutomationFocusChangedEventHandler(focusHandler);

                //foreach (AutomationElement element in controlStore)
                //{
                //    AutomationPattern[] automationPatterns = element.GetSupportedPatterns();
                //    foreach (AutomationPattern automationPattern in automationPatterns)
                //    {
                //        switch (automationPattern.ProgrammaticName)
                //        {
                //            case "InvokePatternIdentifiers.Pattern":
                //                AutomationEventHandler invokeHandler =
                //                    new AutomationEventHandler(OnInvoke);
                //                Automation.AddAutomationEventHandler(InvokePattern.InvokedEvent, element, TreeScope.Element, invokeHandler);
                //                break;
                //        }
                //    }
                //}
                //AutomationEventHandler invokeHandler = new AutomationEventHandler(OnInvoke);
                //Automation.AddAutomationEventHandler(InvokePattern.InvokedEvent,
                //    targetApp, TreeScope.Descendants, invokeHandler);
                foreach (AutomationElement element in controlStore)
                {
                    if ((bool)element.GetCurrentPropertyValue(AutomationElement.IsInvokePatternAvailableProperty))
                    {
                        AutomationEventHandler invokeHandler =
                            new AutomationEventHandler(OnInvoke);
                        Automation.AddAutomationEventHandler(InvokePattern.InvokedEvent,
                                                             element, TreeScope.Element, invokeHandler);
                    }
                    if ((bool)element.GetCurrentPropertyValue(AutomationElement.IsRangeValuePatternAvailableProperty))
                    {
                        //AutomationPropertyChangedEventHandler rangevalueHandler =
                        //    new AutomationPropertyChangedEventHandler(OnRangeValueChange);
                        //Automation.AddAutomationPropertyChangedEventHandler(
                        //    element, TreeScope.Element, rangevalueHandler, RangeValuePattern.
                        //Automation.AddAutomationEventHandler(InvokePattern.InvokedEvent,
                        //    element, TreeScope.Element, invokeHandler));
                    }
                }
            }
        }
Пример #14
0
 public override void Stop()
 {
     if (!IsStarted)
     {
         return;
     }
     Automation.RemoveAutomationFocusChangedEventHandler(eventHandler: this._handlingDelegate);
     this._handlingDelegate = null;
     this._sinkReference    = null;
 }
Пример #15
0
        static void Main(string[] args)
        {
            InitTimer();
            flashWindow = new FlashWindow();
            AutomationFocusChangedEventHandler focusHandler = OnFocusChange;

            Automation.AddAutomationFocusChangedEventHandler(focusHandler);
            Automation.RemoveAutomationFocusChangedEventHandler(focusHandler);
            lastIP = GetIP();
            Application.Run();
        }
Пример #16
0
 public override void Observe()
 {
     try
     {
         _eventHandler = new AutomationFocusChangedEventHandler(OnEvent);
         Automation.AddAutomationFocusChangedEventHandler(_eventHandler);
     }
     catch (Exception ex)
     {
         System.Diagnostics.Debug.Print($"{ex.Message}");
     }
 }
Пример #17
0
        /// <summary>
        /// Called by a client to add a listener for focus changed events.
        /// </summary>
        /// <param name="eventHandler">Delegate to call when a focus change event occurs.</param>
        ///
        /// <outside_see conditional="false">
        /// This API does not work inside the secure execution environment.
        /// <exception cref="System.Security.Permissions.SecurityPermission"/>
        /// </outside_see>
        public static void AddAutomationFocusChangedEventHandler(
            AutomationFocusChangedEventHandler eventHandler
            )
        {
            Misc.ValidateArgumentNonNull(eventHandler, "eventHandler");

            // Add a client-side listener for for this event request
            EventListener l = new EventListener(AutomationElement.AutomationFocusChangedEvent,
                                                TreeScope.Subtree | TreeScope.Ancestors,
                                                null,
                                                CacheRequest.CurrentUiaCacheRequest);

            ClientEventManager.AddFocusListener(eventHandler, l);
        }
Пример #18
0
        public static void AddAutomationFocusChangedEventHandler(AutomationFocusChangedEventHandler eventHandler)
        {
            Utility.ValidateArgumentNonNull(eventHandler, "eventHandler");

            try
            {
                FocusEventListener listener = new FocusEventListener(eventHandler);
                Factory.AddFocusChangedEventHandler(CacheRequest.CurrentNativeCacheRequest, listener);
                ClientEventList.Add(listener);
            }
            catch (System.Runtime.InteropServices.COMException e)
            {
                Exception newEx; if (Utility.ConvertException(e, out newEx)) { throw newEx; } else { throw; }
            }
        }
Пример #19
0
        public static void RemoveAutomationFocusChangedEventHandler(AutomationFocusChangedEventHandler eventHandler)
        {
            ArgumentCheck.NotNull(eventHandler, "eventHandler");

            MUS.FocusChangedEventHandler sourceHandler;
            lock (focusHandlerMapping) {
                if (focusHandlerMapping.TryGetValue(eventHandler, out sourceHandler))
                {
                    focusHandlerMapping.Remove(eventHandler);
                    foreach (var source in SourceManager.GetAutomationSources())
                    {
                        source.RemoveAutomationFocusChangedEventHandler(sourceHandler);
                    }
                }
            }
        }
Пример #20
0
        public FocusMontorer()
        {
            RegistryKey browserKeys;

            //on 64bit the browsers are in a different location
            browserKeys = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\WOW6432Node\Clients\StartMenuInternet");
            if (browserKeys == null)
            {
                browserKeys = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Clients\StartMenuInternet");
            }

            browserNames = browserKeys.GetSubKeyNames();

            focusHandler = new AutomationFocusChangedEventHandler(OnFocusChangedHandler);
            Automation.AddAutomationFocusChangedEventHandler(focusHandler);
        }
Пример #21
0
        public void SubscribeToFocusChange()
        {
            Automation.RemoveAllEventHandlers();
            _focusHandler = new AutomationFocusChangedEventHandler(OnFocusChanged);
            //_clickEventHandler = new AutomationEventHandler(OnClickChanged);
            MinimizeMainWindow();
            Automation.AddAutomationFocusChangedEventHandler(_focusHandler);

            //SubscribeToInvoke(_lastTopLevelWindow);

            //while (true)
            //{
            //    System.Threading.Thread.Yield();
            //}

            //this.WindowState = WindowState.Maximized;
        }
Пример #22
0
        public void BasicFocusTest()
        {
            // TODO:
            //Currently FocusTest.BasicFocusTest can pass on Windows, but can't on Linux. The failure reason is that:
            //on Windows, call InvokePattern.Invoke will make corresponding button focused, so we also assert this behavior in the test,
            //however our implementation will not make the button focused after InvokePattern.Invoke.

            AutomationElement [] expectedFocusedElements;
            if (Atspi)
            {
                expectedFocusedElements = new AutomationElement [] {
                    btnRunElement, textbox3Element,
                    btnRunElement, button2Element,
                }
            }
            ;
            else
            {
                expectedFocusedElements = new AutomationElement [] {
                    txtCommandElement, textbox3Element,
                    txtCommandElement, button2Element,
                }
            };

            AutomationFocusChangedEventHandler handler = (s, e) => actualFocusedElements.Add((AutomationElement)s);

            At.AddAutomationFocusChangedEventHandler(handler);
            RunCommand("focus textBox3");
            Assert.AreEqual(textbox3Element, AutomationElement.FocusedElement, "FocusedElement");
            RunCommand("focus button2");
            Assert.AreEqual(button2Element, AutomationElement.FocusedElement, "FocusedElement");
            At.RemoveAutomationFocusChangedEventHandler(handler);
            RunCommand("focus textBox3");
            Assert.AreEqual(textbox3Element, AutomationElement.FocusedElement, "FocusedElement");

            At.AddAutomationFocusChangedEventHandler(handler);
            At.RemoveAllEventHandlers();
            RunCommand("focus button2");
            Assert.AreEqual(button2Element, AutomationElement.FocusedElement, "FocusedElement");

            Assert.AreEqual(expectedFocusedElements.Length, actualFocusedElements.Count, "Event handler count");
            for (int i = 0; i < actualFocusedElements.Count; i++)
            {
                Assert.AreEqual(expectedFocusedElements [i], actualFocusedElements [i], "Event handler sender #" + i);
            }
        }
Пример #23
0
        /// <summary>
        /// Main method
        /// </summary>
        static void Main(string[] args)
        {
#if DEBUG
            ShowWindow(GetConsoleWindow(), CONSOLE_SHOW);
#else
            ShowWindow(GetConsoleWindow(), CONSOLE_HIDE);
#endif
            hand            = new Hand();
            hand.closed     = false;
            engagedBodyId   = 0;
            engagedHandType = HandType.NONE;
            memStream       = new MemoryStream();
            serializer      = new DataContractJsonSerializer(typeof(Hand));
            streamReader    = new StreamReader(memStream);

            try
            {
                InitializeConnection();
                InitilizeKinect();

                AutomationFocusChangedEventHandler focusHandler = OnFocusChange;
                Automation.AddAutomationFocusChangedEventHandler(focusHandler);

                MessageBox.Show("The program is running in the background, you can now controll nunuStudio´s activities with your hand. \n"
                                + "This program will always be on focus, so it can be annoying when working with other applications. \n"
                                + "To finish it, just close this window. The most easy way is to right click on this window in the taskbar and click close.", "Kinect Hand Motion",
                                MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                Automation.RemoveAutomationFocusChangedEventHandler(focusHandler);
            }
            catch (Exception)
            {
                System.Environment.Exit(1);
            }

            Stop();

            MessageBox.Show(new Form()
            {
                TopMost = true
            }, "Closed Successfully", "Kinect Hand Motion",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
Пример #24
0
        public static void AddAutomationFocusChangedEventHandler(AutomationFocusChangedEventHandler eventHandler)
        {
            ArgumentCheck.NotNull(eventHandler, "eventHandler");

            MUS.FocusChangedEventHandler sourceHandler;
            //according to the spec, all static methods in the UIA lib shall be thread safe.
            lock (focusHandlerMapping) {
                if (!focusHandlerMapping.TryGetValue(eventHandler, out sourceHandler))
                {
                    sourceHandler = (element, objectId, childId) => eventHandler(
                        SourceManager.GetOrCreateAutomationElement(element),
                        new AutomationFocusChangedEventArgs(objectId, childId));
                    focusHandlerMapping.Add(eventHandler, sourceHandler);
                }
            }
            foreach (var source in SourceManager.GetAutomationSources())
            {
                source.AddAutomationFocusChangedEventHandler(sourceHandler);
            }
        }
Пример #25
0
        /// <summary>
        /// Program entry method
        /// </summary>
        private static void Main(string[] args)
        {
            //check if the program is already running
            Process[] _procRunning = Process.GetProcessesByName("AltF4");

            if (_procRunning.Length > 1)
            {
                Environment.Exit(0);
            }

            //Add event handlers
            AutomationFocusChangedEventHandler focusHandler = OnFocusChanged;

            Automation.AddAutomationFocusChangedEventHandler(focusHandler);

            AltF4Handler.Get().OnAltF4 += OnAltF4;

            //Start program loop
            Application.Run();
        }
Пример #26
0
        public static void RemoveAutomationFocusChangedEventHandler(AutomationFocusChangedEventHandler eventHandler)
        {
            Utility.ValidateArgumentNonNull(eventHandler, "eventHandler");

            try
            {
                FocusEventListener listener = (FocusEventListener)ClientEventList.Remove(AutomationElement.AutomationFocusChangedEvent, null, eventHandler);
                Factory.RemoveFocusChangedEventHandler(listener);
            }
            catch (System.Runtime.InteropServices.COMException e)
            {
                Exception newEx; if (Utility.ConvertException(e, out newEx))
                {
                    throw newEx;
                }
                else
                {
                    throw;
                }
            }
        }
Пример #27
0
 public static void AddAutomationFocusChangedEventHandler(AutomationFocusChangedEventHandler eventHandler)
 {
     Utility.ValidateArgumentNonNull(eventHandler, "eventHandler");
     try
     {
         FocusEventListener listener = new FocusEventListener(eventHandler);
         Factory.AddFocusChangedEventHandler(CacheRequest.CurrentNativeCacheRequest, listener);
         ClientEventList.Add(listener);
     }
     catch (System.Runtime.InteropServices.COMException e)
     {
         Exception newEx; if (Utility.ConvertException(e, out newEx))
         {
             throw newEx;
         }
         else
         {
             throw;
         }
     }
 }
Пример #28
0
        public Form1()
        {
            InitializeComponent();

            AutomationFocusChangedEventHandler focusHandler = OnFocusChanged;

            Automation.AddAutomationFocusChangedEventHandler(focusHandler);
            flowLayoutActiveAlerts.VerticalScroll.Enabled = true;
            alertButton.MouseClick += AlertButton_MouseClick; //Add a handler so i can do stuff with clicks

            //flowLayoutActiveAlerts.scr

            // Create user and session
            superUser    = new User();
            superSession = new Session(superUser);


            try { lblUserIP.Text = "Your IP: " + MyUtils.GetIPAddress(); } catch (Exception error)
            {
                lblUserIP.Text = "Your IP: " + MyUtils.getIP();
            }
        }
Пример #29
0
        private void materialRaisedButton1_Click(object sender, EventArgs e)
        {
            if (timer1.Enabled == true)
            {
                timer1.Enabled = false;
            }
            else
            {
                timer1.Enabled = true;
            }
            AutomationFocusChangedEventHandler focusHandler = OnFocusChanged;

            Automation.AddAutomationFocusChangedEventHandler(focusHandler);
            if (ActivityLog.Count > 0)
            {
                foreach (appLog log in ActivityLog)
                {
                    log.makeTime();
                }
                //richTextBox1.Text = JsonConvert.SerializeObject(ActivityLog, Formatting.Indented);
                sendShitToFirebase();
            }
        }
Пример #30
0
        /// <summary>
        /// Called by a client to add a listener for focus changed events.
        /// </summary>
        /// <param name="eventHandler">Delegate to call when a focus change event occurs.</param>
        /// 
        /// <outside_see conditional="false">
        /// This API does not work inside the secure execution environment.
        /// <exception cref="System.Security.Permissions.SecurityPermission"/>
        /// </outside_see>
        public static void AddAutomationFocusChangedEventHandler(
            AutomationFocusChangedEventHandler eventHandler
            )
        {
            Misc.ValidateArgumentNonNull(eventHandler, "eventHandler" );

            // Add a client-side listener for for this event request
            EventListener l = new EventListener(AutomationElement.AutomationFocusChangedEvent, 
                                                TreeScope.Subtree | TreeScope.Ancestors, 
                                                null,
                                                CacheRequest.CurrentUiaCacheRequest);
            ClientEventManager.AddFocusListener(eventHandler, l);
        }
Пример #31
0
        /// <summary>
        /// Called by a client to remove a listener for focus changed events.
        /// </summary>
        /// <param name="eventHandler">The handler object that was passed to AddAutomationFocusChangedListener</param>
        /// 
        /// <outside_see conditional="false">
        /// This API does not work inside the secure execution environment.
        /// <exception cref="System.Security.Permissions.SecurityPermission"/>
        /// </outside_see>
        public static void RemoveAutomationFocusChangedEventHandler(
            AutomationFocusChangedEventHandler eventHandler
            )
        {
            Misc.ValidateArgumentNonNull(eventHandler, "eventHandler" );

            //CASRemoval:AutomationPermission.Demand( AutomationPermissionFlag.Read );

            // Remove the client-side listener for for this event
            ClientEventManager.RemoveFocusListener(eventHandler);
        }
Пример #32
0
 public override void Add(WrappedEventHandler handler, AutomationElementWrapper element)
 {
     _handler = (o, e) => handler(element, e);
     Automation.AddAutomationFocusChangedEventHandler(_handler);
 }
Пример #33
0
        public static void RemoveAutomationFocusChangedEventHandler(AutomationFocusChangedEventHandler eventHandler)
        {
            Utility.ValidateArgumentNonNull(eventHandler, "eventHandler");

            try
            {
                FocusEventListener listener = (FocusEventListener)ClientEventList.Remove(AutomationElement.AutomationFocusChangedEvent, null, eventHandler);
                Factory.RemoveFocusChangedEventHandler(listener);
            }
            catch (System.Runtime.InteropServices.COMException e)
            {
                Exception newEx; if (Utility.ConvertException(e, out newEx)) { throw newEx; } else { throw; }
            }
        }
Пример #34
0
 /// -------------------------------------------------------------------
 /// <summary>
 /// Method that registers the event handler OnEvent()
 /// </summary>
 /// -------------------------------------------------------------------
 new public virtual void AddEventHandler()
 {
     base.AddEventHandler();
     Comment("Adding AddAutomationFocusChangedEventHandler");
     handler = new AutomationFocusChangedEventHandler(OnEvent);
     Automation.AddAutomationFocusChangedEventHandler(handler);
 }
Пример #35
0
 /// <summary>
 /// Create an event handler and register it.
 /// </summary>
 public void SubscribeToFocusChange()
 {
     focusHandler = new AutomationFocusChangedEventHandler(OnFocusChange);
     Automation.AddAutomationFocusChangedEventHandler(focusHandler);
 }
Пример #36
0
 public FocusEventListener(AutomationFocusChangedEventHandler handler) :
     base(AutomationElement.AutomationFocusChangedEvent.Id, null, handler)
 {
     Debug.Assert(handler != null);
     this._focusHandler = handler;
 }
Пример #37
0
		public static void RemoveAutomationFocusChangedEventHandler (AutomationFocusChangedEventHandler eventHandler)
		{
			ArgumentCheck.NotNull (eventHandler, "eventHandler");

			MUS.FocusChangedEventHandler sourceHandler;
			lock (focusHandlerMapping) {
				if (focusHandlerMapping.TryGetValue (eventHandler, out sourceHandler)) {
					focusHandlerMapping.Remove (eventHandler);
					foreach (var source in SourceManager.GetAutomationSources ())
						source.RemoveAutomationFocusChangedEventHandler (sourceHandler);
				}
			}
		}
Пример #38
0
		public static void AddAutomationFocusChangedEventHandler (AutomationFocusChangedEventHandler eventHandler)
		{
			ArgumentCheck.NotNull (eventHandler, "eventHandler");

			MUS.FocusChangedEventHandler sourceHandler;
			//according to the spec, all static methods in the UIA lib shall be thread safe.
			lock (focusHandlerMapping) {
				if (!focusHandlerMapping.TryGetValue (eventHandler, out sourceHandler)) {
					sourceHandler = (element, objectId, childId) => eventHandler (
						SourceManager.GetOrCreateAutomationElement (element),
						new AutomationFocusChangedEventArgs (objectId, childId));
					focusHandlerMapping.Add (eventHandler, sourceHandler);
				}
			}
			foreach (var source in SourceManager.GetAutomationSources ())
				source.AddAutomationFocusChangedEventHandler (sourceHandler);
		}
Пример #39
0
        /// -------------------------------------------------------------------
        /// <summary>
        /// Call SetFocus() and verify the it does get focus by verifying
        /// that the event does occur.  Even if you are not testing for events,
        /// we use the event handler to determine that the element got
        /// the focus.
        /// </summary>
        /// -------------------------------------------------------------------
        internal void TSC_SetFocusVerifyWithEvent(AutomationElement element, CheckType checkType)
        {
            AutomationFocusChangedEventHandler handler = null;
            bool fired = false;

            try
            {
                m_FocusEvents = new ArrayList();
                Comment("Adding AutomationFocusChangedEventHandler");
                handler = new AutomationFocusChangedEventHandler(OnFocusChanged);

                Automation.AddAutomationFocusChangedEventHandler(handler);

                Comment("Calling SetFocus() on " + Library.GetUISpyLook(element));

                // Set the notifier 
                m_NotifiedEvent.Reset();

                element.SetFocus();

                Comment("Wait 1 second for event to happen");
                m_NotifiedEvent.WaitOne(1000, false);
                Comment("Stopped waiting for event to happen");

                Comment("Calling RemoveAutomationFocusChangedEventHandler()");
                Automation.RemoveAutomationFocusChangedEventHandler(handler);
                Comment("Called RemoveAutomationFocusChangedEventHandler()");

                try
                {
                    // Lock this so we don't get anymore events fired.
#pragma warning suppress 6517
                    lock (this)
                    {
                        foreach (AutomationElement tempElement in m_FocusEvents)
                        {
                            AutomationElement el = tempElement;
                            Comment("History of events fired: " + el.Current.Name);

                            // Check to see if any of the elements are the element, or one of the children
                            while (!Automation.Compare(el, AutomationElement.RootElement) && !Automation.Compare(el, element))
                                el = TreeWalker.ControlViewWalker.GetParent(el);

                            if (Automation.Compare(el, element))
                            {
                                fired = true;
                                break;
                            }
                        }
                    }
                }
                finally
                {

                }
            }
            finally
            {

            }
            if (!fired)
                ThrowMe(CheckType.Verification, "Element or one of it's children did not fire the FocusChange event");

            m_TestStep++;
        }
Пример #40
0
 public static IDisposable ToFocusChangedEvent(AutomationFocusChangedEventHandler handler)
 {
     Automation.AddAutomationFocusChangedEventHandler(handler);
     return(Disposable.Create(() => Automation.RemoveAutomationFocusChangedEventHandler(handler)));
 }
Пример #41
0
 public FocusEventListener(AutomationFocusChangedEventHandler handler) :
     base(AutomationElement.AutomationFocusChangedEvent.Id, null, handler)
 {
     Debug.Assert(handler != null);
     this._focusHandler = handler;
 }
Пример #42
0
 /// <summary>
 ///     Subscribe to UI Automation events.
 /// </summary>
 /// <remarks>
 ///     Do not call from the UI thread.
 /// </remarks>
 private void StartListening()
 {
     _focusHandler = OnFocusChanged;
     Automation.AddAutomationFocusChangedEventHandler(_focusHandler);
 }
Пример #43
0
        protected internal void SubscribeToEvents(HasControlInputCmdletBase cmdlet,
                                                  AutomationElement inputObject,
                                                  AutomationEvent eventType,
                                                  AutomationProperty prop)
        {
            AutomationEventHandler uiaEventHandler;
            AutomationPropertyChangedEventHandler uiaPropertyChangedEventHandler;
            StructureChangedEventHandler uiaStructureChangedEventHandler;
            AutomationFocusChangedEventHandler uiaFocusChangedEventHandler;

            // 20130109
            if (null == CurrentData.Events) {
                CurrentData.InitializeEventCollection();
            }

            try {

                CacheRequest cacheRequest = new CacheRequest();
                cacheRequest.AutomationElementMode = AutomationElementMode.Full; //.None;
                cacheRequest.TreeFilter = Automation.RawViewCondition;
                cacheRequest.Add(AutomationElement.NameProperty);
                cacheRequest.Add(AutomationElement.AutomationIdProperty);
                cacheRequest.Add(AutomationElement.ClassNameProperty);
                cacheRequest.Add(AutomationElement.ControlTypeProperty);
                //cacheRequest.Add(AutomationElement.ProcessIdProperty);
                // cache patterns?

                // cacheRequest.Activate();
                cacheRequest.Push();

                switch (eventType.ProgrammaticName) {
                    case "InvokePatternIdentifiers.InvokedEvent":
                        this.WriteVerbose(cmdlet, "subscribing to the InvokedEvent handler");
                        Automation.AddAutomationEventHandler(
                            InvokePattern.InvokedEvent,
                            inputObject,
                            TreeScope.Element, // TreeScope.Subtree, // TreeScope.Element,
                            // uiaEventHandler = new AutomationEventHandler(OnUIAutomationEvent));
                            //uiaEventHandler = new AutomationEventHandler(handler));
                            //uiaEventHandler = new AutomationEventHandler(((EventCmdletBase)cmdlet).AutomationEventHandler));
                            uiaEventHandler = new AutomationEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "TextPatternIdentifiers.TextChangedEvent":
                        this.WriteVerbose(cmdlet, "subscribing to the TextChangedEvent handler");
                        Automation.AddAutomationEventHandler(
                            TextPattern.TextChangedEvent,
                            inputObject,
                            TreeScope.Element,
                            // uiaEventHandler = new AutomationEventHandler(OnUIAutomationEvent));
                            //uiaEventHandler = new AutomationEventHandler(handler));
                            //uiaEventHandler = new AutomationEventHandler(((EventCmdletBase)cmdlet).AutomationEventHandler));
                            uiaEventHandler = new AutomationEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "TextPatternIdentifiers.TextSelectionChangedEvent":
                        this.WriteVerbose(cmdlet, "subscribing to the TextSelectionChangedEvent handler");
                        Automation.AddAutomationEventHandler(
                            TextPattern.TextSelectionChangedEvent,
                            inputObject,
                            TreeScope.Element,
                            // uiaEventHandler = new AutomationEventHandler(OnUIAutomationEvent));
                            //uiaEventHandler = new AutomationEventHandler(handler));
                            //uiaEventHandler = new AutomationEventHandler(((EventCmdletBase)cmdlet).AutomationEventHandler));
                            uiaEventHandler = new AutomationEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "WindowPatternIdentifiers.WindowOpenedProperty":
                        this.WriteVerbose(cmdlet, "subscribing to the WindowOpenedEvent handler");
                        Automation.AddAutomationEventHandler(
                            WindowPattern.WindowOpenedEvent,
                            inputObject,
                            TreeScope.Subtree,
                            // uiaEventHandler = new AutomationEventHandler(OnUIAutomationEvent));
                            //uiaEventHandler = new AutomationEventHandler(handler));
                            //uiaEventHandler = new AutomationEventHandler(((EventCmdletBase)cmdlet).AutomationEventHandler));
                            uiaEventHandler = new AutomationEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "AutomationElementIdentifiers.AutomationPropertyChangedEvent":
                        if (prop != null) {
                            this.WriteVerbose(cmdlet, "subscribing to the AutomationPropertyChangedEvent handler");
                            Automation.AddAutomationPropertyChangedEventHandler(
                                inputObject,
                                TreeScope.Subtree,
                                uiaPropertyChangedEventHandler =
                                    // new AutomationPropertyChangedEventHandler(OnUIAutomationPropertyChangedEvent),
                                    //new AutomationPropertyChangedEventHandler(handler),
                                    //new AutomationPropertyChangedEventHandler(((EventCmdletBase)cmdlet).AutomationPropertyChangedEventHandler),
                                    new AutomationPropertyChangedEventHandler(cmdlet.AutomationPropertyChangedEventHandler),
                                prop);
                            UIAHelper.WriteEventToCollection(cmdlet, uiaPropertyChangedEventHandler);
                            // 20130327
                            //this.WriteObject(cmdlet, uiaPropertyChangedEventHandler);
                            if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaPropertyChangedEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        }
                        break;
                    case "AutomationElementIdentifiers.StructureChangedEvent":
                        this.WriteVerbose(cmdlet, "subscribing to the StructureChangedEvent handler");
                        Automation.AddStructureChangedEventHandler(
                            inputObject,
                            TreeScope.Subtree,
                            uiaStructureChangedEventHandler =
                            // new StructureChangedEventHandler(OnUIStructureChangedEvent));
                            //new StructureChangedEventHandler(handler));
                            //new StructureChangedEventHandler(((EventCmdletBase)cmdlet).StructureChangedEventHandler));
                            new StructureChangedEventHandler(cmdlet.StructureChangedEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaStructureChangedEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaStructureChangedEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaStructureChangedEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "WindowPatternIdentifiers.WindowClosedProperty":
                        this.WriteVerbose(cmdlet, "subscribing to the WindowClosedEvent handler");
                        Automation.AddAutomationEventHandler(
                            WindowPattern.WindowClosedEvent,
                            inputObject,
                            TreeScope.Subtree,
                            // uiaEventHandler = new AutomationEventHandler(OnUIAutomationEvent));
                            //uiaEventHandler = new AutomationEventHandler(handler));
                            //uiaEventHandler = new AutomationEventHandler(((EventCmdletBase)cmdlet).AutomationEventHandler));
                            uiaEventHandler = new AutomationEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "AutomationElementIdentifiers.MenuClosedEvent":
                        this.WriteVerbose(cmdlet, "subscribing to the MenuClosedEvent handler");
                        Automation.AddAutomationEventHandler(
                            AutomationElement.MenuClosedEvent,
                            inputObject,
                            TreeScope.Subtree,
                            uiaEventHandler = new AutomationEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "AutomationElementIdentifiers.MenuOpenedEvent":
                        this.WriteVerbose(cmdlet, "subscribing to the MenuOpenedEvent handler");
                        Automation.AddAutomationEventHandler(
                            AutomationElement.MenuOpenedEvent,
                            inputObject,
                            TreeScope.Subtree,
                            uiaEventHandler = new AutomationEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "AutomationElementIdentifiers.ToolTipClosedEvent":
                        this.WriteVerbose(cmdlet, "subscribing to the ToolTipClosedEvent handler");
                        Automation.AddAutomationEventHandler(
                            AutomationElement.ToolTipClosedEvent,
                            inputObject,
                            TreeScope.Subtree,
                            uiaEventHandler = new AutomationEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "AutomationElementIdentifiers.ToolTipOpenedEvent":
                        this.WriteVerbose(cmdlet, "subscribing to the ToolTipOpenedEvent handler");
                        Automation.AddAutomationEventHandler(
                            AutomationElement.ToolTipOpenedEvent,
                            inputObject,
                            TreeScope.Subtree,
                            uiaEventHandler = new AutomationEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    case "AutomationElementIdentifiers.AutomationFocusChangedEvent":
                        WriteVerbose(cmdlet, "subscribing to the AutomationFocusChangedEvent handler");
                        Automation.AddAutomationFocusChangedEventHandler(
                            //AutomationElement.AutomationFocusChangedEvent,
                            //inputObject,
                            //System.Windows.Automation.AutomationElement.RootElement,
                            //TreeScope.Subtree,
                            uiaFocusChangedEventHandler = new AutomationFocusChangedEventHandler(cmdlet.AutomationEventHandler));
                        UIAHelper.WriteEventToCollection(cmdlet, uiaFocusChangedEventHandler);
                        // 20130327
                        //this.WriteObject(cmdlet, uiaFocusChangedEventHandler);
                        if (cmdlet.PassThru) { cmdlet.WriteObject(cmdlet, uiaFocusChangedEventHandler); } else { cmdlet.WriteObject(cmdlet, true); }
                        break;
                    default:
                        this.WriteVerbose(cmdlet,
                                     "the following event has not been subscribed to: " +
                                     eventType.ProgrammaticName);
                        break;
                }
                this.WriteVerbose(cmdlet, "on the object " + inputObject.Current.Name);
                cacheRequest.Pop();

            }
            catch (Exception e) {
            // try {
            // ErrorRecord err = new ErrorRecord(
            // e,
            // "RegisteringEvent",
            // ErrorCategory.OperationStopped,
            // inputObject);
            // err.ErrorDetails =
            // new ErrorDetails("Unable to register event handler " +
            //  // handler.ToString());
            // eventType.ProgrammaticName +
            // " for " +
            // inputObject.Current.Name);
            //  // this.OnSuccessAction.ToString());
            // WriteError(this, err, false);
            // }
            // catch {
            // ErrorRecord err = new ErrorRecord(
            // e,
            // "RegisteringEvent",
            // ErrorCategory.OperationStopped,
            // inputObject);
            // err.ErrorDetails =
            // new ErrorDetails("Unable to register event handler " +
            // eventType.ProgrammaticName);;
            // WriteError(this, err, false);
            // }

                WriteVerbose(cmdlet,
                              "Unable to register event handler " +
                              eventType.ProgrammaticName +
                              " for " +
                              inputObject.Current.Name);
                 WriteVerbose(cmdlet,
                              e.Message);
            }
        }
Пример #44
0
 public void SubscribeToFocusChange()
 {
     _focusChangedHandler = new AutomationFocusChangedEventHandler(OnFocusChange);
     Automation.AddAutomationFocusChangedEventHandler(_focusChangedHandler);
 }