C# UIElement.RaiseEvent方法代码示例

        /////////////////////////////////////////////////////////////////////

        internal override void FireNotifications(UIElement uie, ContentElement ce, UIElement3D uie3D, bool oldValue)
        { 
            // This is all very sketchy...
            // 
            // Tablet can support multiple stylus devices concurrently.  They can each 
            // be over a different element.  They all update the IsStylusOver property,
            // which calls into here, but ends up using the "current" stylus device, 
            // instead of each using their own device.  Worse, all of these will end up
            // writing to the same bits in the UIElement.  They are going to step all over
            // each other.
            if(Stylus.CurrentStylusDevice == null) 
            {
                return; 
            } 

            StylusEventArgs stylusEventArgs = new StylusEventArgs(Stylus.CurrentStylusDevice, Environment.TickCount); 
            stylusEventArgs.RoutedEvent = oldValue ? Stylus.StylusLeaveEvent : Stylus.StylusEnterEvent;

            if (uie != null)
            { 
                uie.RaiseEvent(stylusEventArgs);
            } 
            else if (ce != null) 
            {
                ce.RaiseEvent(stylusEventArgs); 
            }
            else if (uie3D != null)
            {
                uie3D.RaiseEvent(stylusEventArgs); 
            }
        } 

        /// <summary>
        /// Removes the old content control from the visualizer
        /// </summary>
        /// <param name="oldContent"></param>
        public void TransitionEnded(UIElement oldContent)
        {
            if (oldContent == null) return;

            Children.Remove(oldContent);
            oldContent.RaiseEvent(LostFocusEventArgs);
        }

        static void RaiseAfterSelectionHighlightBrushChanged(UIElement uiElement, Brush newSelectionHighlightBrush)
        {
            if (uiElement == null)
                return;

            RoutedEventArgs newEventArgs = new RoutedEventArgs(AfterSelectionHighlightBrushChangedEvent);
            uiElement.RaiseEvent(newEventArgs);
        }

        /// <summary>
        /// 色変更を通知するイベントを発行します。
        /// </summary>
        public static void FireSelectedColorChangedEvent(UIElement issuer,
                                                         RoutedEvent routedEvent,
                                                         Color oldColor,
                                                         Color newColor)
        {
            var e = new RoutedPropertyChangedEventArgs<Color>(oldColor, newColor)
            {
                RoutedEvent = routedEvent,
            };

            issuer.RaiseEvent(e);
        }

        /////////////////////////////////////////////////////////////////////

        internal override void FireNotifications(UIElement uie, ContentElement ce, UIElement3D uie3D, bool oldValue)
        {
            // Before we fire the mouse event we need to figure if the notification is still relevant. 
            // This is because it is possible that the mouse state has changed during the previous 
            // property engine callout. Example: Consider a MessageBox being displayed during the 
            // IsMouseOver OnPropertyChanged override.
            
            bool shouldFireNotification = false;
            if (uie != null)
            {
                shouldFireNotification = (!oldValue && uie.IsMouseOver) || (oldValue && !uie.IsMouseOver);
            }
            else if (ce != null)
            {
                shouldFireNotification = (!oldValue && ce.IsMouseOver) || (oldValue && !ce.IsMouseOver);
            }
            else if (uie3D != null)
            {
                shouldFireNotification = (!oldValue && uie3D.IsMouseOver) || (oldValue && !uie3D.IsMouseOver);
            }

            if (shouldFireNotification)
            {
                MouseEventArgs mouseEventArgs = new MouseEventArgs(Mouse.PrimaryDevice, Environment.TickCount, Mouse.PrimaryDevice.StylusDevice);
                mouseEventArgs.RoutedEvent = oldValue ? Mouse.MouseLeaveEvent : Mouse.MouseEnterEvent;

                if (uie != null)
                {
                    uie.RaiseEvent(mouseEventArgs);
                }
                else if (ce != null)
                {
                    ce.RaiseEvent(mouseEventArgs);
                }
                else if (uie3D != null)
                {
                    uie3D.RaiseEvent(mouseEventArgs);
                }
            }
        }

 protected static bool RaiseEventPair(UIElement target, RoutedEvent previewEvent, RoutedEvent @event, RoutedEventArgs args)
 {
     if (target == null)
         throw new ArgumentNullException("target");
     if (previewEvent == null)
         throw new ArgumentNullException("previewEvent");
     if (@event == null)
         throw new ArgumentNullException("event");
     if (args == null)
         throw new ArgumentNullException("args");
     args.RoutedEvent = previewEvent;
     target.RaiseEvent(args);
     args.RoutedEvent = @event;
     target.RaiseEvent(args);
     return args.Handled;
 }

        public static void HandleLostMouseCapture(UIElement element,
            MouseEventArgs e,
            Func<bool> getter,
            Action<bool> setter,
            UIElement targetCapture,
            UIElement targetFocus)
        {
            if (getter() && targetCapture != null)
            {
                IntPtr capturedHwnd = IntPtr.Zero;
                bool isOurWindowCaptured = false;
                if (Mouse.Captured == null)
                {
                    // If we are losing capture to some other window
                    // then close all the popups.
                    capturedHwnd = NativeMethods.GetCapture();
                    if (capturedHwnd != IntPtr.Zero &&
                        !(isOurWindowCaptured = IsOurWindow(capturedHwnd, element)))
                    {
                        element.RaiseEvent(new RibbonDismissPopupEventArgs());
                        e.Handled = true;
                        return;
                    }
                }

                if (e.OriginalSource == targetCapture)
                {
                    if (Mouse.Captured == null)
                    {
                        PresentationSource mouseSource = Mouse.PrimaryDevice.ActiveSource;
                        if (mouseSource == null &&
                            (capturedHwnd == IntPtr.Zero ||
                            isOurWindowCaptured))
                        {
                            // If the active source is null and current captured
                            // is null, this capture loss is bacause of Mouse
                            // deactivation (because mouse is not on the window
                            // anymore). Hence reacquire capture and focus.
                            // Note that we do it only if the capture is not lost to
                            // some other window, and genuine closing of
                            // popups when both active source and current captured is
                            // null due to clicking some where else should be handled by
                            // click through event handler.
                            ReacquireCapture(targetCapture, targetFocus);
                            e.Handled = true;
                        }
                        else
                        {
                            setter(false);
                        }
                    }
                    else if (!RibbonHelper.IsAncestorOf(targetCapture, Mouse.Captured as DependencyObject))
                    {
                        setter(false);
                    }
                }
                else if (RibbonHelper.IsAncestorOf(targetCapture, e.OriginalSource as DependencyObject))
                {
                    if (Mouse.Captured == null)
                    {
                        // If a descendant of targetCapture is losing capture
                        // then take capture on targetCapture
                        ReacquireCapture(targetCapture, targetFocus);
                        e.Handled = true;
                    }
                    else if (!IsCaptureInSubtree(targetCapture))
                    {
                        // If a descendant of targetCapture is losing capture
                        // to an element outside targetCapture's subtree
                        // then call setter
                        setter(false);
                    }
                }
            }
        }

        private bool RaiseEvents(UIElement target, RoutedEventArgs e, params RoutedEvent[] routedEventArray)
        {
            foreach (var routedEvent in routedEventArray)
            {
                e.RoutedEvent = routedEvent;
                target.RaiseEvent(e);
                if (e.Handled)
                {
                    return true;
                }
            }

            return false;
        }

 private void ImitateMouseDownOn(UIElement element)
 {
     element.RaiseEvent(new MouseButtonEventArgs(Mouse.PrimaryDevice, Environment.TickCount, MouseButton.Left) { RoutedEvent = Button.MouseDownEvent } );
 }

 internal static void RaiseClearPropertyItemEvent( UIElement source, PropertyItemBase propertyItem, object item )
 {
   source.RaiseEvent( new PropertyItemEventArgs( PropertyGrid.ClearPropertyItemEvent, source, propertyItem, item ) );
 }

 public static void FireInvertedSelectedColorChangedEvent(UIElement issuer, RoutedEvent routedEvent,
     Color oldColor, Color newColor)
 {
     var newEventArgs = new RoutedPropertyChangedEventArgs<Color>(oldColor, newColor);
     newEventArgs.RoutedEvent = routedEvent;
     issuer.RaiseEvent(newEventArgs);
 }

        private static void SwitchCapture(HandPointer handPointer, UIElement oldElement, UIElement newElement)
        {
            handPointer.Captured = newElement;

            if (oldElement != null)
            {
                var lostArgs = CreateEventArgs(KinectRegion.HandPointerLostCaptureEvent, oldElement, handPointer);
                oldElement.RaiseEvent(lostArgs);
            }

            if (newElement != null)
            {
                var gotArgs = CreateEventArgs(KinectRegion.HandPointerGotCaptureEvent, newElement, handPointer);
                newElement.RaiseEvent(gotArgs);
            }
        }

        /// <summary>
        /// Notifies that a raw image has been captured and saves it to file
        /// if the SaveTo attached property has been set on element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="saveTo">The file path to save to.</param>
        /// <param name="cropTo">The crop to.</param>
        /// <returns>Information about the image capture.</returns>
        private static RawImageCapturedResult NotifyRawImageCaptured(UIElement element, string saveTo, Rectangle cropTo)
        {
            RawImageCapturedResult result = null;
            lock (syncRoot)
            {
                if (imageAvailable)
                {
                    // Stop processing raw images so normalizedImage
                    // is not changed while it is saved to a file.
                    DisableRawImage(contactTarget);

                    // Copy the normalizedImage byte array into a Bitmap object.
                    GCHandle h = GCHandle.Alloc(normalizedImage, GCHandleType.Pinned);
                    IntPtr ptr = h.AddrOfPinnedObject();
                    Bitmap imageBitmap = new Bitmap(
                        normalizedMetrics.Width,
                        normalizedMetrics.Height,
                        normalizedMetrics.Stride,
                        PixelFormat.Format8bppIndexed,
                        ptr);

                    // The preceding code converts the bitmap to an 8-bit indexed color image.
                    // The following code creates a grayscale palette for the bitmap.
                    Convert8bppBMPToGrayscale(imageBitmap);
                    cropTo = ScaleBoundingBox(cropTo, normalizedMetrics, appSize);

                    if (!cropTo.IsEmpty)
                    {
                        imageBitmap = CropImage(imageBitmap, cropTo);
                    }

                    // The bitmap is now available to work with
                    // (such as, save to a file, send to a processing API, and so on).
                    MemoryStream imageStream = new MemoryStream();
                    imageBitmap.Save(imageStream, System.Drawing.Imaging.ImageFormat.Jpeg);
                    imageStream.Position = 0;
                    BinaryReader imageReader = new BinaryReader(imageStream);
                    byte[] rawImage = new byte[imageStream.Length];
                    imageReader.Read(rawImage, 0, (int)imageStream.Length);

                    if (saveTo != null)
                    {
                        string imagePath = saveTo + "\\" + DateTime.Now.Ticks + ".jpg";
                        imageBitmap.Save(imagePath, System.Drawing.Imaging.ImageFormat.Jpeg);

                        Action raiseEvent = new Action(() =>
                        {
                            element.RaiseEvent(
                                new RawImageCapturedEventArgs(
                                    RawImageCapturedEvent,
                                    element,
                                    imagePath));
                        });

                        if (!dispatcher.CheckAccess())
                        {
                            dispatcher.Invoke(raiseEvent);
                        }
                        else
                        {
                            raiseEvent();
                        }

                        result = new RawImageCapturedResult(imagePath);
                    }
                    else
                    {
                        Action raiseEvent = new Action(() =>
                        {
                            element.RaiseEvent(
                                new RawImageCapturedEventArgs(
                                    RawImageCapturedEvent,
                                    element,
                                    rawImage));
                        });

                        if (!dispatcher.CheckAccess())
                        {
                            dispatcher.Invoke(raiseEvent);
                        }
                        else
                        {
                            raiseEvent();
                        }

                        result = new RawImageCapturedResult(rawImage);
                    }

                    // Re-enable collecting raw images.
                    EnableRawImage(contactTarget);
                }
            }
//.........这里部分代码省略.........

        // Forward to the next element
        void Forward(UIElement element, bool click)
        {
            Detach();
            if (click)
            {
                element.RaiseEvent(new RoutedEventArgs(Button.ClickEvent, null));
                element.UpdateLayout();
            }

            UIElement[] children = LogicalTreeHelper.GetChildren(element)
                .Cast<object>()
                .Where(x => x is UIElement)
                .Cast<UIElement>().ToArray();
            if (children.Length == 0) { Terminate(); return; }
                    
            childAdorner = GetTopLevelElement(children[0]) != GetTopLevelElement(element) ? 
                new KeyTipAdorner(children[0], element, this) :
                new KeyTipAdorner(element, element, this);

            if (childAdorner.keyTips.Count != 0)
            {
                Detach();
                childAdorner.Attach();
            }
            else
            {
                Terminate();
            }
        }

 /// <summary>
 /// Raise the Tunnel/Bubbling event pair 
 /// </summary>
 /// <param name="target">The UIElement to raise the event pair on</param>
 /// <param name="e">The Event args to follow the event</param>
 /// <param name="bubblingEvent">The Bubble event to raise after the Tunnel event</param>
 private void RaiseEventPair(UIElement target, RoutedEvent bubblingEvent, RoutedIdentifiedEventArgs e)
 {
     Debug.WriteLineIf(DebugSettings.DEBUG_EVENTS, "Raising "+e.RoutedEvent+"  on " + target + ". Name: " + (target is FrameworkElement ? ((FrameworkElement)target).Name : "?"));
     target.RaiseEvent(e);
     e.RoutedEvent = bubblingEvent;
     target.RaiseEvent(e);
 }