private void RotateThumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            this.designerItem = DataContext as ContentControl;

            if (this.designerItem != null)
            {
                this.canvas = VisualTreeHelper.GetParent(this.designerItem) as Canvas;

                if (this.canvas != null)
                {
                    this.centerPoint = this.designerItem.TranslatePoint(
                        new Point(this.designerItem.Width * this.designerItem.RenderTransformOrigin.X,
                                  this.designerItem.Height * this.designerItem.RenderTransformOrigin.Y),
                                  this.canvas);

                    Point startPoint = Mouse.GetPosition(this.canvas);
                    this.startVector = Point.Subtract(startPoint, this.centerPoint);

                    this.rotateTransform = this.designerItem.RenderTransform as RotateTransform;
                    if (this.rotateTransform == null)
                    {
                        this.designerItem.RenderTransform = new RotateTransform(0);
                        this.initialAngle = 0;
                    }
                    else
                    {
                        this.initialAngle = this.rotateTransform.Angle;
                    }
                }
            }
        }

        protected override void OnThumbDragStarted(DragStartedEventArgs e)
        {
            if (ThumbDragStarted != null)
                ThumbDragStarted(this, e);

            base.OnThumbDragStarted(e);
        }

        private void RotateThumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            adornedElement = this.AdornedElement as FrameworkElement;
            Thumb hitThumb = sender as Thumb;

            if (adornedElement == null || hitThumb == null) return;
            parentElement = adornedElement.Parent as FrameworkElement;

            if (parentElement != null)
            {
                this.centerPoint = adornedElement.TranslatePoint(
                                      new Point(adornedElement.Width * 0.5,
                                      adornedElement.Height * 0.5),
                                      parentElement);

                Point startPoint = Mouse.GetPosition(parentElement);
                this.startVector = Point.Subtract(startPoint, this.centerPoint);

                this.rotateTransform = adornedElement.RenderTransform as RotateTransform;
                if (this.rotateTransform == null)
                {
                    adornedElement.RenderTransform = new RotateTransform(
                            0, adornedElement.Width * 0.5, adornedElement.Height * 0.5);

                    this.initialAngle = 0;
                }
                else
                {
                    this.initialAngle = this.rotateTransform.Angle;
                }
            }
        }

 protected override void OnThumbDragStarted(DragStartedEventArgs e)
 {
     if (SliderDragStarted != null)
     {
         SliderDragStarted(this, e);
     }
 }

        private void ResizeThumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            this.designerItem = this.DataContext as ContentControl;

            if (this.designerItem != null)
            {
                this.canvas = VisualTreeHelper.GetParent(this.designerItem) as ContentPresenter;

                if (this.canvas != null)
                {
                    this.transformOrigin = this.designerItem.RenderTransformOrigin;

                    this.rotateTransform = this.designerItem.RenderTransform as RotateTransform;
                    if (this.rotateTransform != null)
                    {
                        this.angle = this.rotateTransform.Angle * Math.PI / 180.0;
                    }
                    else
                    {
                        this.angle = 0.0d;
                    }

                    AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this.canvas);
                    if (adornerLayer != null)
                    {
                        this.adorner = new SizeAdorner(this.designerItem);
                        adornerLayer.Add(this.adorner);
                    }
                }
            }
        }

        public DragablzDragStartedEventArgs(DragablzItem dragablzItem, DragStartedEventArgs dragStartedEventArgs)
            : base(dragablzItem)
        {
            if (dragStartedEventArgs == null) throw new ArgumentNullException("dragStartedEventArgs");

            _dragStartedEventArgs = dragStartedEventArgs;
        }

 /// <summary>
 /// The on thumb drag started.
 /// </summary>
 /// <param name="e">
 /// The e.
 /// </param>
 protected override void OnThumbDragStarted(DragStartedEventArgs e)
 {
     base.OnThumbDragStarted(e);
     var editableObject = this.DataContext as IEditableObject;
     if (editableObject != null)
     {
         editableObject.BeginEdit();
     }
 }

        private void MoveThumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            this.designerItem = DataContext as DesignerItem;

            if (this.designerItem != null)
            {
                this.designerCanvas = VisualTreeHelper.GetParent(this.designerItem) as DesignerCanvas;
            }
        }

        private void MoveThumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            this.designerItem = DataContext as ContentControl;

            if (this.designerItem != null)
            {
                this.rotateTransform = this.designerItem.RenderTransform as RotateTransform;
            }
        }

        private void MoveThumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            this.element = DataContext as BaseObject;

            if (this.element != null)
            {
                this.canvasWorkspace = VisualTreeHelper.GetParent(this.element) as CanvasWorkspace;
            }
        }

        // called when thumb drag started (window resize started)
        void Thumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            WindowThumb thumb = (WindowThumb)sender;

            // store settings of the window, will be used to resize and move the window
            _mouseStartPosition = PointToScreen(Mouse.GetPosition(_window));
            _windowStartPosition = new Point(_window.Left, _window.Top);
            _windowStartSize = new Size(_window.Width, _window.Height);
        }

        private void DragStartedExecute(DragStartedEventArgs e)
        {
            var thumb = e.OriginalSource as Thumb;
            if (thumb == null)
                return;

            ResizedVisual = thumb.DataContext as ISizeableVisualViewModel;
            DragStartX = e.HorizontalOffset;
            DragStartY = e.VerticalOffset;
        }

 private void NowPlayingElapsedSlider_DragStarted(object sender, DragStartedEventArgs e)
 {
     try
     {
         playbackController.BeginSeek();
     }
     catch (Exception ex)
     {
         log.Error("PlaybackView.NowPlayingElapsedSlider_DragStarted", ex);
     }
 }

        protected override void OnMouseDown(MouseButtonEventArgs e)
        {
            if (e.ChangedButton == Input.MouseButton.Left)
            {
                e.MouseDevice.Capture(this);
                dragStartPosition = e.AbsolutePosition;

                IsDragging = true;

                DragStartedEventArgs dragStartedEventArgs = new DragStartedEventArgs(DragStartedEvent, this);
                RaiseEvent(dragStartedEventArgs);

                e.Handled = dragStartedEventArgs.Handled;
            }
        }

        /// <summary>
        /// Dragging has started, see if VM is IDiagramLinkViewModel and notify of moving start.
        /// </summary>
        void DragThumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            diagramDesigner = DiagramHelper.GetDiagramDesigner(this);
            diagramDesignerVM = diagramDesigner.DataContext as IDiagramViewModel;

            selectedItem = null;
            selectedItemVM = null;

            edgePointVM = this.DataContext as IEdgePointViewModel;

            List<ISelectable> selection = diagramDesigner.SelectionService.CurrentSelection;
            if (selection.Count == 1)
            {
                foreach (ISelectable item in selection)
                {
                    if (item is DiagramDesignerItem)
                        if ((item as DiagramDesignerItem).IsDiagramLink)
                        {
                            selectedItem = item as DiagramDesignerItem;
                        }
                }

                // create control to display on the drag adorner
                dragCanvas = new Canvas();
                IDiagramLinkViewModel designerItem = selectedItem.DataContext as IDiagramLinkViewModel;
                selectedItemVM = designerItem;

                AddLinkAnchorAndShape(new PointD(designerItem.StartEdgePoint.X, designerItem.StartEdgePoint.Y),
                    new PointD(designerItem.EndEdgePoint.X, designerItem.EndEdgePoint.Y));

                // create drag adorner 
                if (diagramDesigner != null && selectedItemVM != null && selectedItem != null && edgePointVM != null)
                {
                    AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(diagramDesigner);
                    if (adornerLayer != null)
                    {
                        this.dragAdorner = new DragAdorner(diagramDesigner, dragCanvas, false, 1.0);
                        if (this.dragAdorner != null)
                        {
                            adornerLayer.Add(this.dragAdorner);
                            e.Handled = true;
                        }
                    }
                }
            }
            e.Handled = false;
        }

        private void ResizeThumb_DragStarted(object sender, DragStartedEventArgs e)
        {
            this.designerItem = DataContext as ContentControl;

            if (this.designerItem != null)
            {
                this.transformOrigin = this.designerItem.RenderTransformOrigin;
                RotateTransform rotateTransform = this.designerItem.RenderTransform as RotateTransform;

                if (rotateTransform != null)
                {
                    this.angle = rotateTransform.Angle * Math.PI / 180.0;
                }
                else
                {
                    this.angle = 0;
                }
            }
        }

        protected override void OnDragStarted(object sender, DragStartedEventArgs e)
        {
            if (Target != null)
            {
                var canvas = VisualTreeHelper.GetParent(Target) as MaskCanvas;
                if (canvas != null)
                {
                    transformOrigin = Target.RenderTransformOrigin;
                    rotateTransform = Target.GetRenderTransform<RotateTransform>();

                    if (rotateTransform != null)
                    {
                        angle = rotateTransform.Angle * Math.PI / 180;
                    }
                    else
                    {
                        angle = 0.0;
                    }
                }
            }
        }

        /// <summary>
        /// Setzt designerCanvas und workflowItemViewModel und stößt lock des aktuellen WorkflowIteman.
        /// Wird beim Start des Drags aufgerufen.
        /// </summary>
        /// <param name="sender">MoveThumb</param>
        /// <param name="e">Eventspezifische Infos</param>
        private void startDrag(object sender, DragStartedEventArgs e)
        {
            // hole ContentControl, das derzeit bewegt wird
            Control designerItem = (Control)DataContext;
            
            if (designerItem != null)
            {
                // hole Item von aktuell bewegtem ContentControl
                workflowItemViewModel = (WorkflowItemViewModel)designerItem.DataContext;

                // merke Koordinaten zu Beginn des Drags
                startLeft = workflowItemViewModel.Left;
                startTop = workflowItemViewModel.Top;

                // Lock workflowItem - falls Item nicht gesperrt werden kann -> designerCanvas = null
                try
                {
                    workflowItemViewModel.LockDrag();

                    // finde DesignerCanvas, damit Größenberechnung neu angestoßen werden kann
                    DependencyObject parent = VisualTreeHelper.GetParent(designerItem);
                    while (parent != null && !(parent is DesignerCanvas))
                    {
                        parent = VisualTreeHelper.GetParent(parent);
                    }
                    if (parent is DesignerCanvas)
                    {
                        designerCanvas = (DesignerCanvas)parent;
                    }
                }
                catch (Exception)
                {
                    WorkflowEditorDesignerCanvasErrorViewModel.Instance.Error = "Das Item konnte nicht gesperrt werden. Bitte noch einmal versuchen.";
                }
            }
        }

 private void ProgressSlider_OnDragStarted(object sender, DragStartedEventArgs e)
 {
     viewModel.OnStartDrag();
 }

 private void MoveThumb_DragStarted(object sender, DragStartedEventArgs e)
 {
     _wasMoved = false;
     DesignerCanvas.BeginChange();
 }