private void OnButtonUp(object sender, RoutedEventArgs evt) { ButtonEventArgs e = (ButtonEventArgs)evt; // Print the button code to the Visual Studio output window. Debug.Print(e.Button.ToString()); }
private void OnButtonUp(object sender, RoutedEventArgs evt) { ButtonEventArgs e = (ButtonEventArgs)evt; int button = (int)e.Button; this.OnAction(button); }
/// <summary> /// Add the event handlers for this element to the route. /// </summary> // REFACTOR -- do we need this to be public? public void AddToEventRoute(EventRoute route, RoutedEventArgs args) { if (route == null || args == null) throw new ArgumentNullException(); AddToEventRouteImpl(route, args); }
private void AddToEventRouteImpl(EventRoute route, RoutedEventArgs args) { // // add class listeners then instance listeners. // Hashtable store = _classEventHandlersStore; RoutedEvent evt = args._routedEvent; for (int repeat = 0; repeat < 2; repeat++) { if (store != null) { ArrayList eventListeners = (ArrayList)store[evt]; // Add all listeners for this UIElement if (eventListeners != null) { for (int i = 0, count = eventListeners.Count; i < count; i++) { RoutedEventHandlerInfo eventListener = (RoutedEventHandlerInfo)eventListeners[i]; route.Add(this, eventListener._handler, eventListener._handledEventsToo); } } } store = _instanceEventHandlersStore; } }
private static void OnTouchUpThunk(object sender, RoutedEventArgs e) { ((UIElement)sender).OnTouchUp((TouchEventArgs)e); }
private static void OnPreviewButtonUpThunk(object sender, RoutedEventArgs e) { ((UIElement)sender).OnPreviewButtonUp((ButtonEventArgs)e); }
private static void OnLostFocusThunk(object sender, RoutedEventArgs e) { ((UIElement)sender).OnLostFocus((FocusChangedEventArgs)e); }
private void OnGotFocus(object sender, RoutedEventArgs evt) { FocusChangedEventArgs e = (FocusChangedEventArgs)evt; _timeText.TextContent = (((DateTime.UtcNow - e.Timestamp).Ticks) / TimeSpan.TicksPerMillisecond).ToString() + "ms"; _buttonText.TextContent = e.RoutedEvent.Name; }
private static void OnButtonDownThunk(object sender, RoutedEventArgs e) { ((UIElement)sender).OnButtonDown((ButtonEventArgs)e); }
/// <summary> /// Raise the events specified by /// <see cref="RoutedEventArgs.RoutedEvent"/> /// </summary> /// <remarks> /// This method is a shorthand for /// This method walks up the visual tree, calling /// <see cref="UIElement.BuildRouteCore"/> /// on every <see cref="UIElement"/> <para/> /// <para/> /// /// NOTE: The RoutedEvent in RoutedEventArgs /// and EventRoute must be matched /// /// Once the route is built, it calls InvokeHandlers() /// </remarks> /// <param name="args"> /// <see cref="RoutedEventArgs"/> for the event to /// be raised /// </param> public void RaiseEvent(RoutedEventArgs args) { if (args == null) throw new ArgumentNullException(); EventRoute route = new EventRoute(args._routedEvent); // Set Source args.Source = this; // direct. if (args._routedEvent._routingStrategy == RoutingStrategy.Direct) { AddToEventRouteImpl(route, args); } else { int cElements = 0; UIElement uiElement = this; do { // Protect against infinite loops by limiting the number of elements // that we will process. if (cElements++ > MAX_ELEMENTS_IN_ROUTE) { throw new InvalidOperationException(/*SR.Get(SRID.TreeLoop) */); } uiElement.AddToEventRouteImpl(route, args); uiElement = uiElement._parent; } while (uiElement != null); } route.InvokeHandlers(this, args); // Reset Source to OriginalSource args.Source = args.OriginalSource; }
/// <summary> /// Handles a button click. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnButtonUp(object sender, RoutedEventArgs evt) { ButtonEventArgs e = (ButtonEventArgs)evt; // Any button will start the calibration process. mainWindow.CalibrateScreen(); // Print the button code to the Visual Studio output window. Debug.Print(e.Button.ToString()); }
/// <summary> /// Processes button input. /// </summary> /// <param name="sender">Generic sender. Not used.</param> /// <param name="e">Button event argument that holds information about /// the button that was pressed.</param> private void OnButtonUp(object sender, RoutedEventArgs evt) { ButtonEventArgs e = (ButtonEventArgs)evt; // Switch based on what button was pressed. switch (e.Button) { case Button.VK_UP: // Process the up button. _targetTemp++; // Increment the target temperature. UpdateUI(); // Update the user interface. break; case Button.VK_DOWN: // Process the down button. _targetTemp--; // Decrement the target temperature. UpdateUI(); // Update the user interface. break; case Button.VK_SELECT: // Process the select button. // Switch the temperature format between Celcius and // Fahrenheit. if (_tempMode == TempMode.Celcius) { // Set the new mode _tempMode = TempMode.Fahrenheit; // Modify the current target temperature. _targetTemp = System.Math.Round((_targetTemp * 1.8) + 32); } else { // Set the new mode. _tempMode = TempMode.Celcius; // Modify the current target temperature. _targetTemp = System.Math.Round((_targetTemp - 32) / 1.8); } // Update the user interface. UpdateUI(); break; } }
private void OnButtonUp(object sender, RoutedEventArgs evt) { ButtonEventArgs e = (ButtonEventArgs)evt; if (e.Button == Microsoft.SPOT.Hardware.Button.VK_UP) { // reset the time to an arbitrary value TimeService.SetUtcTime(128752416000000000); TimeService.SetTimeZoneOffset(-420); } else if (e.Button == Microsoft.SPOT.Hardware.Button.VK_SELECT) { // Perform a one time sync with the time server TimeServiceStatus status = TimeService.UpdateNow( TimeServerIPAddress, 10); TimeService.SetTimeZoneOffset(-420); // time origin } else if (e.Button == Microsoft.SPOT.Hardware.Button.VK_DOWN) { // start a scheduled periodic sync TimeServiceSettings settings = new TimeServiceSettings(); settings.PrimaryServer = TimeServerIPAddress; settings.RefreshTime = 10; // sycn every 10 seconds TimeService.Settings = settings; TimeService.Start(); TimeService.SetTimeZoneOffset(-420); // time origin } }
private void OnButtonUp(object sender, RoutedEventArgs routedEventArgs) { // Print the button code to the Visual Studio output window. Debug.Print(routedEventArgs.Source.ToString()); }
/// <summary> /// Invokes all the handlers that have been /// added to the route /// </summary> /// <remarks> /// NOTE: If the <see cref="RoutingStrategy"/> /// of the associated <see cref="RoutedEvent"/> /// is <see cref="RoutingStrategy.Bubble"/> /// the last handlers added are the /// last ones invoked <para/> /// However if the <see cref="RoutingStrategy"/> /// of the associated <see cref="RoutedEvent"/> /// is <see cref="RoutingStrategy.Tunnel"/>, /// the last handlers added are the /// first ones invoked. /// However the handlers for a particular object /// are always invoked in the order they were added /// regardless of whether its a tunnel or buble. /// /// </remarks> /// <param name="source"> /// <see cref="RoutedEventArgs.Source"/> /// that raised the RoutedEvent /// </param> /// <param name="args"> /// <see cref="RoutedEventArgs"/> that carry /// all the details specific to this RoutedEvent /// </param> internal void InvokeHandlers(object source, RoutedEventArgs args) { // Check RoutingStrategy to know the order of invocation if (args.RoutedEvent.RoutingStrategy == RoutingStrategy.Bubble || args.RoutedEvent.RoutingStrategy == RoutingStrategy.Direct) { // If the RoutingStrategy of the associated is // Bubble the handlers for the last target // added are the last ones invoked // Invoke class listeners for (int i = 0, count = _routeItemList.Count; i < count; i++) { RouteItem ri = ((RouteItem)_routeItemList[i]); args.InvokeHandler(ri); } } else { int endTargetIndex = _routeItemList.Count - 1; int startTargetIndex; // If the RoutingStrategy of the associated is // Tunnel the handlers for the last target // added are the first ones invoked while (endTargetIndex >= 0) { // For tunnel events we need to invoke handlers for the last target first. // However the handlers for that individual target must be fired in the right order. object currTarget = ((RouteItem)_routeItemList[endTargetIndex]).Target; for (startTargetIndex = endTargetIndex; startTargetIndex >= 0; startTargetIndex--) { if (((RouteItem)_routeItemList[startTargetIndex]).Target != currTarget) { if(startTargetIndex == endTargetIndex && endTargetIndex > 0) { endTargetIndex--; } else { break; } } } for (int i = startTargetIndex + 1; i <= endTargetIndex; i++) { RouteItem ri = ((RouteItem)_routeItemList[i]); args.InvokeHandler(ri); } endTargetIndex = startTargetIndex; } } }
private static void OnGenericEventThunk(object sender, RoutedEventArgs e) { ((UIElement)sender).OnGenericEvent((GenericEventArgs)e); }
private void OnButtonUp(object sender, RoutedEventArgs evt) { ButtonEventArgs e = (ButtonEventArgs)evt; const int timeZoneOffsetInMinutes = -8 * 60; switch (e.Button) { case Microsoft.SPOT.Hardware.Button.VK_UP: // Reset the time to an arbitrary value. TimeService.SetUtcTime(128752416000000000); TimeService.SetTimeZoneOffset(timeZoneOffsetInMinutes); break; case Microsoft.SPOT.Hardware.Button.VK_SELECT: // Perform a one time sync with the time server. TimeServiceStatus status = TimeService.UpdateNow(TimeServerIPAddress, 10); TimeService.SetTimeZoneOffset(timeZoneOffsetInMinutes); break; case Microsoft.SPOT.Hardware.Button.VK_DOWN: // Start a scheduled periodic sync. TimeServiceSettings settings = new TimeServiceSettings(); // Sync every 10 seconds. settings.PrimaryServer = TimeServerIPAddress; settings.RefreshTime = 10; TimeService.Settings = settings; TimeService.Start(); TimeService.SetTimeZoneOffset(timeZoneOffsetInMinutes); break; } }
private void OnButtonDown(object sender, RoutedEventArgs evt) { ButtonEventArgs e = (ButtonEventArgs)evt; _timeText.TextContent = (((DateTime.UtcNow - e.Timestamp).Ticks) / TimeSpan.TicksPerMillisecond).ToString() + "ms"; _buttonText.TextContent = e.RoutedEvent.Name + " : " + buttonNames[(int)e.Button]; }