Beispiel #1
0
 private void RefreshOperation()
 {
     this.OperationFlag &= ~OperationMask.MoveFlag;
     foreach (VisualObject selectedObject in this.selectedObjects)
     {
         if (selectedObject.OperationFlag == OperationMask.NoneFlag)
         {
             ComControlNode comControlNode = this;
             int            operationFlag  = (int)comControlNode.OperationFlag;
             int            num            = 0;
             comControlNode.OperationFlag = (OperationMask)num;
             break;
         }
         if (selectedObject.IsTransformEnabled)
         {
             this.OperationFlag |= OperationMask.MoveFlag;
             break;
         }
     }
 }
Beispiel #2
0
        private void HandleRotation(PointF point)
        {
            PointF position = this.Position;
            PointF pointF;
            PointF pointF2;

            if (this.selectedParentObjects.Count <VisualObject>() == 1)
            {
                pointF  = this.selectedParentObjects.FirstOrDefault <VisualObject>().TransformToParent(this.lastMousePoint);
                pointF2 = this.selectedParentObjects.FirstOrDefault <VisualObject>().TransformToParent(point);
            }
            else
            {
                pointF  = this.canvasObject.TransformToSelf(this.lastMousePoint);
                pointF2 = this.canvasObject.TransformToSelf(point);
            }
            float num  = ComControlNode.CC_DEGREES_TO_RADIANS(this.RotationSkew.ScaleX);
            float num2 = ComControlNode.CC_DEGREES_TO_RADIANS(this.RotationSkew.ScaleY);
            float num3 = (float)(-(float)Math.Atan2((double)(pointF.Y - position.Y), (double)(pointF.X - position.X)));
            float num4 = (float)(-(float)Math.Atan2((double)(pointF2.Y - position.Y), (double)(pointF2.X - position.X)));

            if (this.isShiftDown)
            {
                num4 = ((num4 * num3 < 0f) ? (-num4) : num4);
                float num5 = ComControlNode.CC_RADIANS_TO_DEGREES(num4 - num3);
                this.lastRotation += num5;
                if (Math.Abs(this.lastRotation) >= 15f)
                {
                    float num6 = (float)((this.RotationSkew.ScaleX + this.lastRotation > 0f) ? 15 : -15);
                    float num7 = (float)((this.RotationSkew.ScaleY + this.lastRotation > 0f) ? 15 : -15);
                    this.RotationSkew = new ScaleValue();
                    this.lastRotation = 0f;
                }
            }
            else
            {
                num2 = ComControlNode.CC_RADIANS_TO_DEGREES(num2 + num4 - num3);
                num  = ComControlNode.CC_RADIANS_TO_DEGREES(num + num4 - num3);
                this.RotationSkew = new ScaleValue(num, num2, 0.1, -99999999.0, 99999999.0);
            }
        }
Beispiel #3
0
        private void HandleRotation(PointF point)
        {
            PointF position = this.Position;
            PointF pointF1;
            PointF pointF2;

            if (this.selectedParentObjects.Count <VisualObject>() == 1)
            {
                pointF1 = this.selectedParentObjects.FirstOrDefault <VisualObject>().TransformToParent(this.lastMousePoint);
                pointF2 = this.selectedParentObjects.FirstOrDefault <VisualObject>().TransformToParent(point);
            }
            else
            {
                pointF1 = this.canvasObject.TransformToSelf(this.lastMousePoint);
                pointF2 = this.canvasObject.TransformToSelf(point);
            }
            float radians1 = ComControlNode.CC_DEGREES_TO_RADIANS(this.RotationSkew.ScaleX);
            float radians2 = ComControlNode.CC_DEGREES_TO_RADIANS(this.RotationSkew.ScaleY);
            float num1     = (float)-Math.Atan2((double)pointF1.Y - (double)position.Y, (double)pointF1.X - (double)position.X);
            float num2     = (float)-Math.Atan2((double)pointF2.Y - (double)position.Y, (double)pointF2.X - (double)position.X);

            if (this.isShiftDown)
            {
                this.lastRotation += ComControlNode.CC_RADIANS_TO_DEGREES(((double)num2 * (double)num1 < 0.0 ? -num2 : num2) - num1);
                if ((double)Math.Abs(this.lastRotation) < 15.0)
                {
                    return;
                }
                float num3 = (double)this.RotationSkew.ScaleX + (double)this.lastRotation > 0.0 ? 15f : -15f;
                float num4 = (double)this.RotationSkew.ScaleY + (double)this.lastRotation > 0.0 ? 15f : -15f;
                this.RotationSkew = new ScaleValue();
                this.lastRotation = 0.0f;
            }
            else
            {
                float degrees = ComControlNode.CC_RADIANS_TO_DEGREES(radians2 + num2 - num1);
                this.RotationSkew = new ScaleValue(ComControlNode.CC_RADIANS_TO_DEGREES(radians1 + num2 - num1), degrees, 0.1, -99999999.0, 99999999.0);
            }
        }
Beispiel #4
0
        private bool HandleScale(PointF point)
        {
            float  scaleX = this.Scale.ScaleX;
            float  scaleY = this.Scale.ScaleY;
            PointF anchorPointInPoints = this.CSCom.GetAnchorPointInPoints();
            PointF p      = this.TransformToSelf(ComControlNode.PointSub(point, anchorPointInPoints));
            PointF p2     = this.TransformToSelf(ComControlNode.PointSub(this.lastMousePoint, anchorPointInPoints));
            PointF pointF = ComControlNode.PointSub(p, p2);
            float  num    = pointF.X * scaleX;
            float  num2   = pointF.Y * scaleY;
            float  num3   = -num / anchorPointInPoints.X;
            float  num4   = num / (this.Size.X - anchorPointInPoints.X);
            float  num5   = -num2 / anchorPointInPoints.Y;
            float  num6   = num2 / (this.Size.Y - anchorPointInPoints.Y);
            float  num7   = 0f;
            float  num8   = 0f;

            switch (this.controlPointType)
            {
            case ControlPointType.POINT_LEFT_TOP:
                if (this.AnchorPoint.ScaleX != 0f)
                {
                    num7 = num3;
                }
                if (this.AnchorPoint.ScaleY != 1f)
                {
                    num8 = num6;
                }
                break;

            case ControlPointType.POINT_LEFT_BOTTOM:
                if (this.AnchorPoint.ScaleX != 0f)
                {
                    num7 = num3;
                }
                if (this.AnchorPoint.ScaleY != 0f)
                {
                    num8 = num5;
                }
                break;

            case ControlPointType.POINT_RIGHT_BOTTOM:
                if (this.AnchorPoint.ScaleX != 1f)
                {
                    num7 = num4;
                }
                if (this.AnchorPoint.ScaleY != 0f)
                {
                    num8 = num5;
                }
                break;

            case ControlPointType.POINT_RIGHT_TOP:
                if (this.AnchorPoint.ScaleX != 1f)
                {
                    num7 = num4;
                }
                if (this.AnchorPoint.ScaleY != 1f)
                {
                    num8 = num6;
                }
                break;

            case ControlPointType.POINT_LEFT_MIDDLE:
                if (this.AnchorPoint.ScaleX != 0f)
                {
                    num7 = num3;
                }
                break;

            case ControlPointType.POINT_MIDDLE_BOTTOM:
                if (this.AnchorPoint.ScaleY != 0f)
                {
                    num8 = num5;
                }
                break;

            case ControlPointType.POINT_RIGHT_MIDDLE:
                if (this.AnchorPoint.ScaleX != 1f)
                {
                    num7 = num4;
                }
                break;

            case ControlPointType.POINT_MIDDLE_TOP:
                if (this.AnchorPoint.ScaleY != 1f)
                {
                    num8 = num6;
                }
                break;
            }
            bool result;

            if ((double)Math.Abs(this.Scale.ScaleX + num7) < 0.01)
            {
                result = false;
            }
            else if ((double)Math.Abs(this.Scale.ScaleY + num8) < 0.01)
            {
                result = false;
            }
            else
            {
                if (this.isShiftDown || this.isScaleLocked)
                {
                    float num9  = this.Scale.ScaleY / this.Scale.ScaleX;
                    float num10 = this.Scale.ScaleX + num7;
                    this.Scale = new ScaleValue(num10, num10 * num9, 0.1, -99999999.0, 99999999.0);
                }
                else
                {
                    this.Scale = new ScaleValue(this.Scale.ScaleX + num7, this.Scale.ScaleY + num8, 0.1, -99999999.0, 99999999.0);
                }
                result = true;
            }
            return(result);
        }
Beispiel #5
0
        private void HandleMouseMove(PointF point)
        {
            this.isMouseMoved = true;
            List <CSMatrix> list = new List <CSMatrix>();
            CSMatrix        anchorWorldMatrix = this.CSCom.GetAnchorWorldMatrix();

            this.Print(anchorWorldMatrix);
            CSMatrix cSMatrix = this.CSCom.Mat4Inverse(anchorWorldMatrix);

            this.Print(cSMatrix);
            for (int i = 0; i < this.selectedParentObjects.Count <VisualObject>(); i++)
            {
                VisualObject visualObject       = this.selectedParentObjects.ElementAt(i);
                CSMatrix     anchorWorldMatrix2 = visualObject.GetCSVisual().GetAnchorWorldMatrix();
                this.Print(anchorWorldMatrix2);
                CSMatrix cSMatrix2 = this.CSCom.Mat4Multiply(cSMatrix, anchorWorldMatrix2);
                this.Print(cSMatrix2);
                list.Add(cSMatrix2);
            }
            if (this.operationType == OperationType.OPERATION_ANCHOR_POINT)
            {
                this.HandleAnchorPoint(point);
                if (this.SelectedObjects.Count <VisualObject>() > 1)
                {
                    return;
                }
            }
            else if (this.operationType == OperationType.OPERATION_POSITION)
            {
                this.HandlePosition(point);
            }
            else if (this.operationType == OperationType.OPERATION_ROTATION)
            {
                this.HandleRotation(point);
            }
            else if (this.operationType == OperationType.OPERATION_SCALE)
            {
                if (!this.HandleScale(point))
                {
                    this.updateLastMousePoint = false;
                    return;
                }
            }
            else if (this.operationType == OperationType.OPERATION_SKEW)
            {
                this.HandleSkew(point);
            }
            CSMatrix anchorWorldMatrix3 = this.CSCom.GetAnchorWorldMatrix();

            this.Print(anchorWorldMatrix3);
            for (int i = 0; i < this.selectedParentObjects.Count <VisualObject>(); i++)
            {
                VisualObject visualObject = this.selectedParentObjects.ElementAt(i);
                VisualObject parent       = (visualObject as NodeObject).Parent;
                if (parent == null)
                {
                    parent = this.canvasObject;
                }
                CSMatrix cSMatrix3 = visualObject.GetCSVisual().GetParentWorldMatrix();
                this.Print(cSMatrix3);
                cSMatrix3 = this.CSCom.Mat4Inverse(cSMatrix3);
                this.Print(cSMatrix3);
                CSMatrix cSMatrix4 = this.CSCom.Mat4Multiply(anchorWorldMatrix3, list[i]);
                this.Print(cSMatrix4);
                CSMatrix cSMatrix2 = this.CSCom.Mat4Multiply(cSMatrix3, cSMatrix4);
                this.Print(cSMatrix2);
                MatrixNode matrixNode = this.CSCom.Mat4ToMatrixNode(cSMatrix2);
                if (!this.TestFloatEqual(visualObject.Position.X, matrixNode.CX, 0.001f) || !this.TestFloatEqual(visualObject.Position.Y, matrixNode.CY, 0.001f))
                {
                    if (!this.positionChanged)
                    {
                        this.positionChanged = this.NeedAutoCreateFirstFrame(visualObject, typeof(PositionFrame).Name);
                    }
                    visualObject.Position = new PointF(matrixNode.CX, matrixNode.CY);
                }
                if (!this.TestFloatEqual(visualObject.Scale.ScaleX, matrixNode.CScaleX, 0.001f) || !this.TestFloatEqual(visualObject.Scale.ScaleY, matrixNode.CScaleY, 0.001f))
                {
                    if (!this.scaleChanged)
                    {
                        this.scaleChanged = this.NeedAutoCreateFirstFrame(visualObject, typeof(ScaleFrame).Name);
                    }
                    visualObject.Scale = new ScaleValue(matrixNode.CScaleX, matrixNode.CScaleY, 0.1, -99999999.0, 99999999.0);
                }
                float      num          = this.SimplifyRotation(ComControlNode.CC_RADIANS_TO_DEGREES(-matrixNode.CSkewX));
                float      num2         = this.SimplifyRotation(ComControlNode.CC_RADIANS_TO_DEGREES(-matrixNode.CSkewY));
                ScaleValue rotationSkew = visualObject.RotationSkew;
                float      num3         = this.SimplifyRotation(rotationSkew.ScaleX);
                float      num4         = this.SimplifyRotation(rotationSkew.ScaleY);
                if (!this.TestFloatEqual(rotationSkew.ScaleX, num, 0.001f) || !this.TestFloatEqual(rotationSkew.ScaleY, num2, 0.001f))
                {
                    if (!this.rotationChanged)
                    {
                        this.rotationChanged = this.NeedAutoCreateFirstFrame(visualObject, typeof(RotationSkewFrame).Name);
                    }
                    float num5 = this.SimplifyRotationDif(num - num3);
                    float num6 = this.SimplifyRotationDif(num2 - num4);
                    rotationSkew.ScaleX      += num5;
                    rotationSkew.ScaleY      += num6;
                    visualObject.RotationSkew = rotationSkew;
                }
            }
        }
Beispiel #6
0
        private void HandleMouseMove(PointF point)
        {
            this.isMouseMoved = true;
            List <CSMatrix> csMatrixList       = new List <CSMatrix>();
            CSMatrix        anchorWorldMatrix1 = this.CSCom.GetAnchorWorldMatrix();

            this.Print(anchorWorldMatrix1);
            CSMatrix csMatrix1 = this.CSCom.Mat4Inverse(anchorWorldMatrix1);

            this.Print(csMatrix1);
            for (int index = 0; index < this.selectedParentObjects.Count <VisualObject>(); ++index)
            {
                CSMatrix anchorWorldMatrix2 = this.selectedParentObjects.ElementAt <VisualObject>(index).GetCSVisual().GetAnchorWorldMatrix();
                this.Print(anchorWorldMatrix2);
                CSMatrix m = this.CSCom.Mat4Multiply(csMatrix1, anchorWorldMatrix2);
                this.Print(m);
                csMatrixList.Add(m);
            }
            if (this.operationType == OperationType.OPERATION_ANCHOR_POINT)
            {
                this.HandleAnchorPoint(point);
                if (this.SelectedObjects.Count <VisualObject>() > 1)
                {
                    return;
                }
            }
            else if (this.operationType == OperationType.OPERATION_POSITION)
            {
                this.HandlePosition(point);
            }
            else if (this.operationType == OperationType.OPERATION_ROTATION)
            {
                this.HandleRotation(point);
            }
            else if (this.operationType == OperationType.OPERATION_SCALE)
            {
                if (!this.HandleScale(point))
                {
                    this.updateLastMousePoint = false;
                    return;
                }
            }
            else if (this.operationType == OperationType.OPERATION_SKEW)
            {
                this.HandleSkew(point);
            }
            CSMatrix anchorWorldMatrix3 = this.CSCom.GetAnchorWorldMatrix();

            this.Print(anchorWorldMatrix3);
            for (int index = 0; index < this.selectedParentObjects.Count <VisualObject>(); ++index)
            {
                VisualObject node = this.selectedParentObjects.ElementAt <VisualObject>(index);
                if ((VisualObject)(node as NodeObject).Parent == null)
                {
                    VisualObject canvasObject = this.canvasObject;
                }
                CSMatrix parentWorldMatrix = node.GetCSVisual().GetParentWorldMatrix();
                this.Print(parentWorldMatrix);
                CSMatrix csMatrix2 = this.CSCom.Mat4Inverse(parentWorldMatrix);
                this.Print(csMatrix2);
                CSMatrix csMatrix3 = this.CSCom.Mat4Multiply(anchorWorldMatrix3, csMatrixList[index]);
                this.Print(csMatrix3);
                CSMatrix csMatrix4 = this.CSCom.Mat4Multiply(csMatrix2, csMatrix3);
                this.Print(csMatrix4);
                MatrixNode matrixNode = this.CSCom.Mat4ToMatrixNode(csMatrix4);
                if (!this.TestFloatEqual(node.Position.X, matrixNode.CX, 1f / 1000f) || !this.TestFloatEqual(node.Position.Y, matrixNode.CY, 1f / 1000f))
                {
                    if (!this.positionChanged)
                    {
                        this.positionChanged = this.NeedAutoCreateFirstFrame(node, typeof(PositionFrame).Name);
                    }
                    node.Position = new PointF(matrixNode.CX, matrixNode.CY);
                }
                if (!this.TestFloatEqual(node.Scale.ScaleX, matrixNode.CScaleX, 1f / 1000f) || !this.TestFloatEqual(node.Scale.ScaleY, matrixNode.CScaleY, 1f / 1000f))
                {
                    if (!this.scaleChanged)
                    {
                        this.scaleChanged = this.NeedAutoCreateFirstFrame(node, typeof(ScaleFrame).Name);
                    }
                    node.Scale = new ScaleValue(matrixNode.CScaleX, matrixNode.CScaleY, 0.1, -99999999.0, 99999999.0);
                }
                float      v2_1         = this.SimplifyRotation(ComControlNode.CC_RADIANS_TO_DEGREES(-matrixNode.CSkewX));
                float      v2_2         = this.SimplifyRotation(ComControlNode.CC_RADIANS_TO_DEGREES(-matrixNode.CSkewY));
                ScaleValue rotationSkew = node.RotationSkew;
                float      num1         = this.SimplifyRotation(rotationSkew.ScaleX);
                float      num2         = this.SimplifyRotation(rotationSkew.ScaleY);
                if (!this.TestFloatEqual(rotationSkew.ScaleX, v2_1, 1f / 1000f) || !this.TestFloatEqual(rotationSkew.ScaleY, v2_2, 1f / 1000f))
                {
                    if (!this.rotationChanged)
                    {
                        this.rotationChanged = this.NeedAutoCreateFirstFrame(node, typeof(RotationSkewFrame).Name);
                    }
                    float num3 = this.SimplifyRotationDif(v2_1 - num1);
                    float num4 = this.SimplifyRotationDif(v2_2 - num2);
                    rotationSkew.ScaleX += num3;
                    rotationSkew.ScaleY += num4;
                    node.RotationSkew    = rotationSkew;
                }
            }
        }