public static void MouseWheel(Canvas c, TransformGroup tg, MouseWheelEventArgs e)
        {
            int deltaValue;
            deltaValue = e.Delta;
            TranslateTransform tt = (TranslateTransform)tg.Children[1];
            ScaleTransform st = (ScaleTransform)tg.Children[0];
            double xSpot = e.GetPosition(c).X;
            double ySpot = e.GetPosition(c).Y;

            Double x = e.GetPosition(c).X - tt.X;
            Double y = e.GetPosition(c).Y - tt.Y;

            Double centerX = st.CenterX * (st.ScaleX - 1);
            Double centerY = st.CenterY * (st.ScaleY - 1);

            st.CenterX = x;
            st.CenterY = y;

            if (deltaValue > 0)
            {
                st.ScaleX *= 1.25;
                st.ScaleY *= 1.25;
            }
            else
            {

                st.ScaleX *= 0.75;
                st.ScaleY *= 0.75;
            }
        }

 void SeeThruListView_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
 {
     e.Handled = true;
     var e2 = new MouseWheelEventArgs(e.MouseDevice, e.Timestamp, e.Delta);
     e2.RoutedEvent = UIElement.MouseWheelEvent;
     RaiseEvent(e2);
 }

        void PlotControl_MouseWheel(object sender, MouseWheelEventArgs e)
        {
            bool control = (Keyboard.IsKeyDown(Key.LeftCtrl));
            bool shift = (Keyboard.IsKeyDown(Key.LeftShift));

            OnMouseWheel(e.GetPosition(pc), e.Delta, control, shift);
        }

        private static void PreviewMouseWheel(Object sender, MouseWheelEventArgs e)
        {
            if (Keyboard.Modifiers == ModifierKeys.Control)
            {
                Control zoomableControl = (Control)sender;

                double zoomAmount = (double)zoomableControl.GetValue(ZoomAmountProperty);
                double zoomMinimum = (double)zoomableControl.GetValue(ZoomMinimumProperty);
                double zoomMaximum = (double)zoomableControl.GetValue(ZoomMaximumProperty);

                if (e.Delta > 0)
                    zoomAmount *= 1.1;
                else
                    zoomAmount *= 0.90909090909090906;

                if (zoomAmount > zoomMaximum)
                    zoomAmount = zoomMaximum;
                else if (zoomAmount < zoomMinimum)
                    zoomAmount = zoomMinimum;

                zoomAmount = Math.Round(zoomAmount, 2);

                zoomableControl.SetValue(ZoomAmountProperty, zoomAmount);
            }
        }

 private void timelineView_MouseWheel_1(object sender, MouseWheelEventArgs e)
 {
     var delta = e.Delta < 0 ? 0.5 : -0.5;
     var newZoom = zoomSlider.Value + delta;
     if (zoomSlider.Minimum <= newZoom && newZoom <= zoomSlider.Maximum)
         zoomSlider.Value = newZoom;
 }

        private static void OnSelectorPreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            if (e.Delta == 0)
            {
                // nothing to do
                return;
            }

            var selector = (Selector)sender;
            // get or stored scrollviewer
            var lbScrollViewer = GetScrollViewer(selector);
            if (lbScrollViewer != null)
            {
                var scrollingLines = GetScrollingLines(selector);
                for (var i = 0; i < scrollingLines; i++)
                {
                    if (e.Delta < 0)
                    {
                        lbScrollViewer.LineDown();
                    }
                    else
                    {
                        lbScrollViewer.LineUp();
                    }
                }
                e.Handled = true;
            }
        }

        /// <summary>
        /// Handles the PreviewMouseWheel event of the ScrollViewer control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="MouseWheelEventArgs"/> instance containing the event data.</param>
        private void ScrollViewer_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            try
            {
                var scrollviewer = sender as ScrollViewer;
                if (e.Delta > 0)
                {
                    if (scrollviewer != null)
                    {
                        scrollviewer.LineUp();
                    }
                }
                else
                {
                    if (scrollviewer != null)
                    {
                        scrollviewer.LineDown();
                    }
                }

                e.Handled = true;
            }
            catch
            {
                // Do nothing.
            }
        }

        protected override void OnPreviewMouseWheel(MouseWheelEventArgs args)
        {
            base.OnPreviewMouseWheel(args);
            Transform temptransform;

               // Debug.WriteLine("Mouse wheel " + args.Delta);

               // ImageDisp.LayoutTransform=new ScaleTransform(2.0,2.0) ;

            if (args.Delta > 0)
               dScale+=0.10;

            if (args.Delta < 0)
            {
                dScale -= 0.10;
                if (dScale < 1.0)
                    dScale = 1.0;
            }

             //Debug.WriteLine(" dScale " +dScale);
             //Debug.WriteLine(" ImageDisp.LayoutTransform " + ImageDisp.LayoutTransform);
             ImageDisp.RenderTransform = new ScaleTransform(dScale, dScale,(double)(pixelwidth / 2.0f), (double)(pixelheight / 2.0f));
               ImageDisp.
             Debug.WriteLine("Transform");
             Debug.WriteLine("W " + bmpImage.PixelWidth + " H " + bmpImage.PixelHeight);
             Debug.WriteLine("Dpi X " + bmpImage.DpiX + " Dpi Y " + bmpImage.DpiY);
             Debug.WriteLine("Source X " + bmpImage.SourceRect.X + " Source Y " + bmpImage.SourceRect.Y);

               // ImageDisp.InvalidateMeasure();
            //ImageDisp.InvalidateVisual();
            //ImageDisp.
        }

 private void CProgressBar_MouseWheel(object sender, MouseWheelEventArgs e)
 {
     if (e.Delta > 0)
         Value += Maximum * 0.02;
     else
         Value -= Maximum * 0.02;
 }

        private void ItemsControl_MouseWheel(object sender, MouseWheelEventArgs e)
        {
            var x = Math.Pow(2, e.Delta / 3.0 / Mouse.MouseWheelDeltaForOneLine);
            _zoomableCanvas.Scale *= x;

            e.Handled = true;
        }

 public MouseWheelInputEventArgs(IMouseWheelController controller, MouseWheel wheel, MouseWheelEventArgs nativeEventArgs)
   : base(nativeEventArgs.MouseDevice, nativeEventArgs.Timestamp)
 {
   Controller = controller;
   Wheel = wheel;
   NativeEventArgs = nativeEventArgs;
 }

 protected override void OnMouseWheel(MouseWheelEventArgs e)
 {
     if (VerticalScrollBarVisibility != ScrollBarVisibility.Disabled)
     {
         base.OnMouseWheel(e);
     }
 }

 private void img_MouseWheel(object sender, MouseWheelEventArgs e)
 {
     if (e.Delta > 0)
         IncreaseZoom();
     else
         DecreaseZoom();
 }

 public void lbMatFile_MouseWheel(object sender, MouseWheelEventArgs e)
 {
     if (scrollViewer != null)
     {
         scrollViewer.ScrollToVerticalOffset(scrollViewer.VerticalOffset - e.Delta);
     }
 }

 public void scroll(object sender, MouseWheelEventArgs args)
 {
     if (!scrolling)
     {
         if (args.Delta < 120)
         {
             scrollAnimation.From = Canvas.GetTop(tasksItemsControl);
             if (space < tasksItemsControl.Items.Count)
             {
                 scrollAnimation.To = Canvas.GetTop(tasksItemsControl) - 98;
                 space++;
             }
         }
         else
         {
             scrollAnimation.From = Canvas.GetTop(tasksItemsControl);
             if (space > 0)
             {
                 scrollAnimation.To = Canvas.GetTop(tasksItemsControl) + 98;
                 space--;
             }
         }
         scrollAnimation.Completed += new EventHandler((o, a) =>
         {
             scrolling = false;
         });
         scrolling = true;
         tasksItemsControl.BeginAnimation(Canvas.TopProperty, scrollAnimation);
     }
 }

 public void controlMouseWheel(object sender, MouseWheelEventArgs args)
 {
     var img = sender as Image;
     if (img == null) return;
     var transform = (TransformGroup)img.RenderTransform;
     foreach (var child in transform.Children.OfType<ScaleTransform>())
     {
         var delta = args.Delta > 0 ? StepSize : -StepSize;
         var newScale = child.ScaleX + delta;
         if (newScale >= 1)
         {
             child.ScaleX = newScale;
             child.ScaleY = newScale;
             ((ImageParams)img.Tag).Scale = newScale;
         }
     }
     foreach (var translate in transform.Children.OfType<TranslateTransform>())
     {
         var scale = ((ImageParams)img.Tag).Scale;
         var relY = (img.ActualHeight * scale - img.ActualHeight) / 2;
         var relX = (img.ActualWidth * scale - MagicalNumberOfLogic.ActualWidth) / 2;
         if (translate.Y < -relY || translate.Y > relY)
         {
             var step = StepToOriginal(translate.Y, scale, StepSize);
             translate.Y -= step;
         }
         if (translate.X < -relX || translate.X > relX)
         {
             var step = StepToOriginal(translate.X, scale, StepSize);
             translate.X -= step;
         }
     }
 }

        /// <summary>
        /// When user tries to use mouse wheel there can be several cases.
        /// </summary>
        private void OnPreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            // Case 1: User scrolls the mouse wheel when Shift key is being held down. This 
            // action triggers a horizontal scroll on the library view (so that lengthy names 
            // can be revealed). Setting 'Handled' to 'false' allows the underlying scroll bar
            // to handle the mouse wheel event.
            if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift))
            {
                e.Handled = false;
                return;
            }

            // Case 2: If the mouse is outside of the library view, but mouse wheel messages 
            // get sent to it anyway. In such case there is nothing to change here. The 'Handled'
            // is not set to 'true' here because the mouse wheel messages should be routed to the 
            // ScrollViewer on tool-tip for further processing.
            if (!(sender as UIElement).IsMouseOver)
                return;

            // Case 3: Mouse wheel without any modifier keys, it scrolls the library view 
            // vertically. In this case 'VerticalOffset' is updated, 'Handled' is also set 
            // so that mouse wheel message routing ends here.
            ScrollViewer scv = (ScrollViewer)sender;
            scv.ScrollToVerticalOffset(scv.VerticalOffset - e.Delta);
            e.Handled = true;
        }

        private void TabControl_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            if (e.Delta > 0)
            {
                if (SelectedIndex < Items.Count - 1)
                    SelectedIndex++;
                else
                    SelectedIndex = 0;
            }
            else
            {

                if (SelectedIndex > 0)
                    SelectedIndex--;
                else
                    SelectedIndex = Items.Count - 1;
            }

            if (!_tabPanel.Children[SelectedIndex].IsEnabled)
            {
                if (_tabPanel.Children.OfType<TabItem>().All(x => !x.IsEnabled))
                {
                    SelectedIndex = -1;
                    return;
                }

                TabControl_PreviewMouseWheel(sender, e);
            }

            TabItem_PreviewMouseDown(sender, null);
            ChangeVisibility();
        }

		void ScaleElement_MouseWheel(object sender, MouseWheelEventArgs e) {
			if (Keyboard.Modifiers != ModifierKeys.Control)
				return;

			ZoomMouseWheel(e.Delta);
			e.Handled = true;
		}

        private static void HandlePreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            var scrollControl = sender as ScrollViewer;
            if (!e.Handled && sender != null && !reentrantList.Contains(e))
            {
                var previewEventArg = new MouseWheelEventArgs(e.MouseDevice, e.Timestamp, e.Delta)
                {
                    RoutedEvent = UIElement.PreviewMouseWheelEvent,
                    Source = sender
                };
                var originalSource = e.OriginalSource as UIElement;
                reentrantList.Add(previewEventArg);
                if (originalSource!=null) originalSource.RaiseEvent(previewEventArg);
                reentrantList.Remove(previewEventArg);
                // at this point if no one else handled the event in our children, we do our job

                if (!previewEventArg.Handled && ((e.Delta > 0 && scrollControl.VerticalOffset == 0)
                    || (e.Delta <= 0 && scrollControl.VerticalOffset >= scrollControl.ExtentHeight - scrollControl.ViewportHeight)))
                {
                    e.Handled = true;
                    var eventArg = new MouseWheelEventArgs(e.MouseDevice, e.Timestamp, e.Delta);
                    eventArg.RoutedEvent = UIElement.MouseWheelEvent;
                    eventArg.Source = sender;
                    var parent = (UIElement)((FrameworkElement)sender).Parent;
                    parent.RaiseEvent(eventArg);
                }
            }
        }