프로젝트

일반

사용자정보

개정판 9005f973

ID9005f973b1a5b38dbee1f867bd6c2c6a9f593231
상위 f5407d37
하위 47048310

백흠경이(가) 11달 전에 추가함

Fix: Shift 키를 누르거나 Axis Lock이 적용되었을 때 X,Y 비율이 유지되도록 수정

Change-Id: I9605fc8ae3320a61bc9d97f7921679a5e4f22fee

차이점 보기:

MarkupToPDF/Controls/Etc/ImgControl.cs
19 19 

  		




  20
  20
  
    
namespace MarkupToPDF.Controls.Etc


  		




  21
  21
  
    
{


  		




  
  22
  
    
    [TemplatePart(Name = "PART_Image", Type = typeof(Image))]


  		




  22
  23
  
    
    public class ImgControl : CommentUserInfo, IDisposable, INormal, INotifyPropertyChanged, IViewBox, IMarkupCommonData


  		




  23
  24
  
    
    {


  		




  24
  25
  
    
        #region 초기선언


  		




  ......




  381
  382
  
    
            Point selected = MathSet.getNearPoint(path.PointSet, pt);


  		




  382
  383
  
    
            selected.X += dx;


  		




  383
  384
  
    
            selected.Y += dy;


  		




  384
  
  
    
            int i = 0;


  		




  385
  
  
    
            for (i = 0; i < (this as IPath).PointSet.Count; i++)


  		




  386
  
  
    
            {


  		




  387
  
  
    
                if (pt.Equals((this as IPath).PointSet[i]))


  		




  388
  
  
    
                {


  		




  389
  
  
    
                    path.PointSet[i] = selected;


  		




  390
  
  
    
                    break;


  		




  391
  
  
    
                }


  		




  392
  
  
    
            }


  		




  393
  385
  
    

  		




  394
  
  
    
            var OppositeP = (i + path.PointSet.Count / 2) % path.PointSet.Count;


  		




  395
  
  
    
            var PreviousP = (i + (path.PointSet.Count - 1)) % path.PointSet.Count;


  		




  396
  
  
    
            var NextP = (i + 1) % path.PointSet.Count;


  		




  
  386
  
    
            int idx = (this as IPath).PointSet.FindIndex(x => x.Equals(pt));


  		




  
  387
  
    

  		




  
  388
  
    
            var OppositeP = (idx + path.PointSet.Count / 2) % path.PointSet.Count;


  		




  
  389
  
    
            var PreviousP = (idx + (path.PointSet.Count - 1)) % path.PointSet.Count;


  		




  
  390
  
    
            var NextP = (idx + 1) % path.PointSet.Count;


  		




  397
  391
  
    
            if (bAxisLocked)


  		




  398
  392
  
    
            {


  		




  399
  
  
    
                double _dx = path.PointSet[i].X - path.PointSet[OppositeP].X;


  		




  400
  
  
    
                double _dy = path.PointSet[i].Y - path.PointSet[OppositeP].Y;


  		




  401
  
  
    
                double distance = Math.Max(Math.Abs(_dx), Math.Abs(_dy));


  		




  402
  
  
    

  		




  403
  
  
    
                var PreviousV = path.PointSet[PreviousP] - path.PointSet[OppositeP];


  		




  404
  
  
    
                PreviousV.Normalize();


  		




  405
  
  
    
                path.PointSet[PreviousP] = path.PointSet[OppositeP] + PreviousV * distance;


  		




  
  393
  
    
                var PrevV = path.PointSet[PreviousP] - path.PointSet[OppositeP];


  		




  
  394
  
    
                double PrevLength = PrevV.Length;


  		




  
  395
  
    
                PrevV.Normalize();


  		




  406
  396
  
    

  		




  407
  397
  
    
                var NextV = path.PointSet[NextP] - path.PointSet[OppositeP];


  		




  
  398
  
    
                double NextVLength = NextV.Length;


  		




  408
  399
  
    
                NextV.Normalize();


  		




  409
  
  
    
                path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * distance;


  		




  410
  400
  
    

  		




  411
  
  
    
                path.PointSet[i] = path.PointSet[OppositeP] + PreviousV * distance + NextV * distance;


  		




  
  401
  
    
                double _dx = selected.X - path.PointSet[OppositeP].X;


  		




  
  402
  
    
                double _dy = selected.Y - path.PointSet[OppositeP].Y;


  		




  
  403
  
    
                var dir = new Vector(_dx, _dy);


  		




  
  404
  
    
                if (PrevLength > NextVLength)


  		




  
  405
  
    
                {


  		




  
  406
  
    
                    double ratio = NextVLength / PrevLength;


  		




  
  407
  
    

  		




  
  408
  
    
                    double dot = MathSet.DotProduct(PrevV.X, PrevV.Y, dir.X, dir.Y);


  		




  
  409
  
    

  		




  
  410
  
    
                    path.PointSet[PreviousP] = path.PointSet[OppositeP] + PrevV * dot;


  		




  
  411
  
    
                    path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * dot * ratio;


  		




  
  412
  
    
                    path.PointSet[idx] = path.PointSet[OppositeP] + PrevV * dot + NextV * dot * ratio;


  		




  
  413
  
    
                }


  		




  
  414
  
    
                else


  		




  
  415
  
    
                {


  		




  
  416
  
    
                    double ratio = PrevLength / NextVLength;


  		




  
  417
  
    

  		




  
  418
  
    
                    double dot = MathSet.DotProduct(NextV.X, NextV.Y, dir.X, dir.Y);


  		




  
  419
  
    

  		




  
  420
  
    
                    path.PointSet[PreviousP] = path.PointSet[OppositeP] + PrevV * dot * ratio;


  		




  
  421
  
    
                    path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * dot;


  		




  
  422
  
    
                    path.PointSet[idx] = path.PointSet[OppositeP] + PrevV * dot * ratio + NextV * dot;


  		




  
  423
  
    
                }


  		




  412
  424
  
    
            }


  		




  413
  425
  
    
            else


  		




  414
  426
  
    
            {


  		




  415
  427
  
    
                var PreviousV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[PreviousP]);


  		




  416
  
  
    
                var l = MathSet.DotProduct(PreviousV.X, PreviousV.Y, path.PointSet[i].X - path.PointSet[OppositeP].X,


  		




  417
  
  
    
                    path.PointSet[i].Y - path.PointSet[OppositeP].Y);


  		




  
  428
  
    
                var l = MathSet.DotProduct(PreviousV.X, PreviousV.Y, path.PointSet[idx].X - path.PointSet[OppositeP].X,


  		




  
  429
  
    
                    path.PointSet[idx].Y - path.PointSet[OppositeP].Y);


  		




  418
  430
  
    
                path.PointSet[PreviousP] = new Point(path.PointSet[OppositeP].X + PreviousV.X * l, path.PointSet[OppositeP].Y + PreviousV.Y * l);


  		




  419
  431
  
    

  		




  420
  432
  
    
                var NextV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[NextP]);


  		




  421
  
  
    
                l = MathSet.DotProduct(NextV.X, NextV.Y, path.PointSet[i].X - path.PointSet[OppositeP].X, path.PointSet


  		




  422
  
  
    
                    [i].Y - path.PointSet[OppositeP].Y);


  		




  
  433
  
    
                l = MathSet.DotProduct(NextV.X, NextV.Y, path.PointSet[idx].X - path.PointSet[OppositeP].X, path.PointSet


  		




  
  434
  
    
                    [idx].Y - path.PointSet[OppositeP].Y);


  		




  423
  435
  
    
                path.PointSet[NextP] = new Point(path.PointSet[OppositeP].X + NextV.X * l, path.PointSet[OppositeP].Y + NextV.Y * l);


  		




  
  436
  
    

  		




  
  437
  
    
                path.PointSet[idx] = selected;


  		




  424
  438
  
    
            }


  		




  425
  439
  
    

  		




  426
  440
  
    
            this.UpdateControl();


  		












  

    
      MarkupToPDF/Controls/Etc/SignControl.cs
    
  





  22
  22
  
    
namespace MarkupToPDF.Controls.Etc


  		




  23
  23
  
    
{


  		




  24
  24
  
    
    [TemplatePart(Name = "PART_Image", Type = typeof(Image))]


  		




  25
  
  
    
    public class SignControl : CommentUserInfo, IDisposable, INormal, INotifyPropertyChanged, IPath, IViewBox, IMarkupCommonData


  		




  
  25
  
    
    public class SignControl : CommentUserInfo, IDisposable, INormal, INotifyPropertyChanged, IViewBox


  		




  26
  26
  
    
    {


  		




  27
  27
  
    
        #region 초기선언


  		




  28
  28
  
    
        public string ProjectNO { get; set; }


  		




  ......




  360
  360
  
    
            Point selected = MathSet.getNearPoint(path.PointSet, pt);


  		




  361
  361
  
    
            selected.X += dx;


  		




  362
  362
  
    
            selected.Y += dy;


  		




  363
  
  
    
            int i = 0;


  		




  364
  
  
    
            for (i = 0; i < (this as IPath).PointSet.Count; i++)


  		




  365
  
  
    
            {


  		




  366
  
  
    
                if (pt.Equals((this as IPath).PointSet[i]))


  		




  367
  
  
    
                {


  		




  368
  
  
    
                    path.PointSet[i] = selected;


  		




  369
  
  
    
                    break;


  		




  370
  
  
    
                }


  		




  371
  
  
    
            }


  		




  372
  363
  
    

  		




  373
  
  
    
            var OppositeP = (i + path.PointSet.Count / 2) % path.PointSet.Count;


  		




  374
  
  
    
            var PreviousP = (i + (path.PointSet.Count - 1)) % path.PointSet.Count;


  		




  375
  
  
    
            var NextP = (i + 1) % path.PointSet.Count;


  		




  
  364
  
    
            int idx = (this as IPath).PointSet.FindIndex(x => x.Equals(pt));


  		




  
  365
  
    

  		




  
  366
  
    
            var OppositeP = (idx + path.PointSet.Count / 2) % path.PointSet.Count;


  		




  
  367
  
    
            var PreviousP = (idx + (path.PointSet.Count - 1)) % path.PointSet.Count;


  		




  
  368
  
    
            var NextP = (idx + 1) % path.PointSet.Count;


  		




  376
  369
  
    

  		




  377
  370
  
    
            if (bAxisLocked)


  		




  378
  371
  
    
            {


  		




  379
  
  
    
                double _dx = path.PointSet[i].X - path.PointSet[OppositeP].X;


  		




  380
  
  
    
                double _dy = path.PointSet[i].Y - path.PointSet[OppositeP].Y;


  		




  381
  
  
    
                double distance = Math.Max(Math.Abs(_dx), Math.Abs(_dy));


  		




  382
  
  
    

  		




  383
  
  
    
                var PreviousV = path.PointSet[PreviousP] - path.PointSet[OppositeP];


  		




  384
  
  
    
                PreviousV.Normalize();


  		




  385
  
  
    
                path.PointSet[PreviousP] = path.PointSet[OppositeP] + PreviousV * distance;


  		




  
  372
  
    
                var PrevV = path.PointSet[PreviousP] - path.PointSet[OppositeP];


  		




  
  373
  
    
                double PrevLength = PrevV.Length;


  		




  
  374
  
    
                PrevV.Normalize();


  		




  386
  375
  
    

  		




  387
  376
  
    
                var NextV = path.PointSet[NextP] - path.PointSet[OppositeP];


  		




  
  377
  
    
                double NextVLength = NextV.Length;


  		




  388
  378
  
    
                NextV.Normalize();


  		




  389
  
  
    
                path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * distance;


  		




  390
  379
  
    

  		




  391
  
  
    
                path.PointSet[i] = path.PointSet[OppositeP] + PreviousV * distance + NextV * distance;


  		




  
  380
  
    
                double _dx = selected.X - path.PointSet[OppositeP].X;


  		




  
  381
  
    
                double _dy = selected.Y - path.PointSet[OppositeP].Y;


  		




  
  382
  
    
                var dir = new Vector(_dx, _dy);


  		




  
  383
  
    
                if (PrevLength > NextVLength)


  		




  
  384
  
    
                {


  		




  
  385
  
    
                    double ratio = NextVLength / PrevLength;


  		




  
  386
  
    

  		




  
  387
  
    
                    double dot = MathSet.DotProduct(PrevV.X, PrevV.Y, dir.X, dir.Y);


  		




  
  388
  
    

  		




  
  389
  
    
                    path.PointSet[PreviousP] = path.PointSet[OppositeP] + PrevV * dot;


  		




  
  390
  
    
                    path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * dot * ratio;


  		




  
  391
  
    
                    path.PointSet[idx] = path.PointSet[OppositeP] + PrevV * dot + NextV * dot * ratio;


  		




  
  392
  
    
                }


  		




  
  393
  
    
                else


  		




  
  394
  
    
                {


  		




  
  395
  
    
                    double ratio = PrevLength / NextVLength;


  		




  
  396
  
    

  		




  
  397
  
    
                    double dot = MathSet.DotProduct(NextV.X, NextV.Y, dir.X, dir.Y);


  		




  
  398
  
    

  		




  
  399
  
    
                    path.PointSet[PreviousP] = path.PointSet[OppositeP] + PrevV * dot * ratio;


  		




  
  400
  
    
                    path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * dot;


  		




  
  401
  
    
                    path.PointSet[idx] = path.PointSet[OppositeP] + PrevV * dot * ratio + NextV * dot;


  		




  
  402
  
    
                }


  		




  392
  403
  
    
            }


  		




  393
  404
  
    
            else


  		




  394
  405
  
    
            {


  		




  395
  406
  
    
                var PreviousV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[PreviousP]);


  		




  396
  
  
    
                var l = MathSet.DotProduct(PreviousV.X, PreviousV.Y, path.PointSet[i].X - path.PointSet[OppositeP].X,


  		




  397
  
  
    
                    path.PointSet[i].Y - path.PointSet[OppositeP].Y);


  		




  
  407
  
    
                var l = MathSet.DotProduct(PreviousV.X, PreviousV.Y, path.PointSet[idx].X - path.PointSet[OppositeP].X,


  		




  
  408
  
    
                    path.PointSet[idx].Y - path.PointSet[OppositeP].Y);


  		




  398
  409
  
    
                path.PointSet[PreviousP] = new Point(path.PointSet[OppositeP].X + PreviousV.X * l, path.PointSet[OppositeP].Y + PreviousV.Y * l);


  		




  399
  410
  
    

  		




  400
  411
  
    
                var NextV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[NextP]);


  		




  401
  
  
    
                l = MathSet.DotProduct(NextV.X, NextV.Y, path.PointSet[i].X - path.PointSet[OppositeP].X, path.PointSet


  		




  402
  
  
    
                    [i].Y - path.PointSet[OppositeP].Y);


  		




  
  412
  
    
                l = MathSet.DotProduct(NextV.X, NextV.Y, path.PointSet[idx].X - path.PointSet[OppositeP].X, path.PointSet


  		




  
  413
  
    
                    [idx].Y - path.PointSet[OppositeP].Y);


  		




  403
  414
  
    
                path.PointSet[NextP] = new Point(path.PointSet[OppositeP].X + NextV.X * l, path.PointSet[OppositeP].Y + NextV.Y * l);


  		




  
  415
  
    

  		




  
  416
  
    
                path.PointSet[idx] = selected;


  		




  404
  417
  
    
            }


  		




  405
  418
  
    

  		




  406
  419
  
    
            this.UpdateControl();


  		












  

    
      MarkupToPDF/Controls/Etc/SymControlN.cs
    
  





  398
  398
  
    
            Point selected = MathSet.getNearPoint(path.PointSet, pt);


  		




  399
  399
  
    
            selected.X += dx;


  		




  400
  400
  
    
            selected.Y += dy;


  		




  401
  
  
    
            int i = 0;


  		




  402
  
  
    
            for (i = 0; i < (this as IPath).PointSet.Count; i++)


  		




  403
  
  
    
            {


  		




  404
  
  
    
                if (pt.Equals((this as IPath).PointSet[i]))


  		




  405
  
  
    
                {


  		




  406
  
  
    
                    path.PointSet[i] = selected;


  		




  407
  
  
    
                    break;


  		




  408
  
  
    
                }


  		




  409
  
  
    
            }


  		




  410
  401
  
    

  		




  411
  
  
    
            var OppositeP = (i + path.PointSet.Count / 2) % path.PointSet.Count;


  		




  412
  
  
    
            var PreviousP = (i + (path.PointSet.Count - 1)) % path.PointSet.Count;


  		




  413
  
  
    
            var NextP = (i + 1) % path.PointSet.Count;


  		




  
  402
  
    
            int idx = (this as IPath).PointSet.FindIndex(x => x.Equals(pt));


  		




  
  403
  
    

  		




  
  404
  
    
            var OppositeP = (idx + path.PointSet.Count / 2) % path.PointSet.Count;


  		




  
  405
  
    
            var PreviousP = (idx + (path.PointSet.Count - 1)) % path.PointSet.Count;


  		




  
  406
  
    
            var NextP = (idx + 1) % path.PointSet.Count;


  		




  414
  407
  
    
            if (bAxisLocked)


  		




  415
  408
  
    
            {


  		




  416
  
  
    
                double _dx = path.PointSet[i].X - path.PointSet[OppositeP].X;


  		




  417
  
  
    
                double _dy = path.PointSet[i].Y - path.PointSet[OppositeP].Y;


  		




  418
  
  
    
                double distance = Math.Max(Math.Abs(_dx), Math.Abs(_dy));


  		




  419
  
  
    

  		




  420
  
  
    
                var PreviousV = path.PointSet[PreviousP] - path.PointSet[OppositeP];


  		




  421
  
  
    
                PreviousV.Normalize();


  		




  422
  
  
    
                path.PointSet[PreviousP] = path.PointSet[OppositeP] + PreviousV * distance;


  		




  
  409
  
    
                var PrevV = path.PointSet[PreviousP] - path.PointSet[OppositeP];


  		




  
  410
  
    
                double PrevLength = PrevV.Length;


  		




  
  411
  
    
                PrevV.Normalize();


  		




  423
  412
  
    

  		




  424
  413
  
    
                var NextV = path.PointSet[NextP] - path.PointSet[OppositeP];


  		




  
  414
  
    
                double NextVLength = NextV.Length;


  		




  425
  415
  
    
                NextV.Normalize();


  		




  426
  
  
    
                path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * distance;


  		




  427
  416
  
    

  		




  428
  
  
    
                path.PointSet[i] = path.PointSet[OppositeP] + PreviousV * distance + NextV * distance;


  		




  
  417
  
    
                double _dx = selected.X - path.PointSet[OppositeP].X;


  		




  
  418
  
    
                double _dy = selected.Y - path.PointSet[OppositeP].Y;


  		




  
  419
  
    
                var dir = new Vector(_dx, _dy);


  		




  
  420
  
    
                if (PrevLength > NextVLength)


  		




  
  421
  
    
                {


  		




  
  422
  
    
                    double ratio = NextVLength / PrevLength;


  		




  
  423
  
    

  		




  
  424
  
    
                    double dot = MathSet.DotProduct(PrevV.X, PrevV.Y, dir.X, dir.Y);


  		




  
  425
  
    

  		




  
  426
  
    
                    path.PointSet[PreviousP] = path.PointSet[OppositeP] + PrevV * dot;


  		




  
  427
  
    
                    path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * dot * ratio;


  		




  
  428
  
    
                    path.PointSet[idx] = path.PointSet[OppositeP] + PrevV * dot + NextV * dot * ratio;


  		




  
  429
  
    
                }


  		




  
  430
  
    
                else


  		




  
  431
  
    
                {


  		




  
  432
  
    
                    double ratio = PrevLength / NextVLength;


  		




  
  433
  
    

  		




  
  434
  
    
                    double dot = MathSet.DotProduct(NextV.X, NextV.Y, dir.X, dir.Y);


  		




  
  435
  
    

  		




  
  436
  
    
                    path.PointSet[PreviousP] = path.PointSet[OppositeP] + PrevV * dot * ratio;


  		




  
  437
  
    
                    path.PointSet[NextP] = path.PointSet[OppositeP] + NextV * dot;


  		




  
  438
  
    
                    path.PointSet[idx] = path.PointSet[OppositeP] + PrevV * dot * ratio + NextV * dot;


  		




  
  439
  
    
                }


  		




  429
  440
  
    
            }


  		




  430
  441
  
    
            else


  		




  431
  442
  
    
            {


  		




  432
  443
  
    
                var PreviousV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[PreviousP]);


  		




  433
  
  
    
                var l = MathSet.DotProduct(PreviousV.X, PreviousV.Y, path.PointSet[i].X - path.PointSet[OppositeP].X,


  		




  434
  
  
    
                    path.PointSet[i].Y - path.PointSet[OppositeP].Y);


  		




  
  444
  
    
                var l = MathSet.DotProduct(PreviousV.X, PreviousV.Y, path.PointSet[idx].X - path.PointSet[OppositeP].X,


  		




  
  445
  
    
                    path.PointSet[idx].Y - path.PointSet[OppositeP].Y);


  		




  435
  446
  
    
                path.PointSet[PreviousP] = new Point(path.PointSet[OppositeP].X + PreviousV.X * l, path.PointSet[OppositeP].Y + PreviousV.Y * l);


  		




  436
  447
  
    

  		




  437
  448
  
    
                var NextV = MathSet.GetNormVectorBetween(path.PointSet[OppositeP], path.PointSet[NextP]);


  		




  438
  
  
    
                l = MathSet.DotProduct(NextV.X, NextV.Y, path.PointSet[i].X - path.PointSet[OppositeP].X, path.PointSet


  		




  439
  
  
    
                    [i].Y - path.PointSet[OppositeP].Y);


  		




  
  449
  
    
                l = MathSet.DotProduct(NextV.X, NextV.Y, path.PointSet[idx].X - path.PointSet[OppositeP].X, path.PointSet


  		




  
  450
  
    
                    [idx].Y - path.PointSet[OppositeP].Y);


  		




  440
  451
  
    
                path.PointSet[NextP] = new Point(path.PointSet[OppositeP].X + NextV.X * l, path.PointSet[OppositeP].Y + NextV.Y * l);


  		




  
  452
  
    

  		




  
  453
  
    
                path.PointSet[idx] = selected;


  		




  441
  454
  
    
            }


  		




  442
  455
  
    

  		




  443
  456
  
    
            this.UpdateControl();


  		












내보내기  Unified diff




         
        

    















   



  

  
  클립보드 이미지 추가
  (최대 크기: 500 MB)