MARKUS

using System;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using MarkupToPDF.Controls.Common;

namespace MarkupToPDF.Controls.Etc

{

    public class ImgControl : Control, IDisposable, INormal, INotifyPropertyChanged, IViewBox, IMarkupCommonData

    {

        #region 초기선언

        private const string PART_Image = "PART_Image";

        public Image Base_Image = null;

        #endregion

        static ImgControl()

        {

            DefaultStyleKeyProperty.OverrideMetadata(typeof(ImgControl), new FrameworkPropertyMetadata(typeof(ImgControl)));

            //Application.Current.Resources.MergedDictionaries.Add(Application.LoadComponent(new Uri("/MarkupToPDF;Component/Themes/generic.xaml")) as ResourceDictionary);

            ResourceDictionary dictionary = new ResourceDictionary();

            dictionary.Source = new Uri("/MarkupToPDF;component/themes/generic.xaml", UriKind.RelativeOrAbsolute);

            Application.Current.Resources.MergedDictionaries.Add(dictionary);

             //System.Diagnostics.Debug.WriteLine("resource Count :" + Application.Current.Resources.MergedDictionaries.Count);

        }

        public ImgControl()

        {

            this.DefaultStyleKey = typeof(ImgControl);

        }

        public void Dispose()

        {

            GC.Collect();

            GC.SuppressFinalize(this);

        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

        }

        public void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

        #region Dependency Properties

        public static readonly DependencyProperty IsSelectedProperty =

            DependencyProperty.Register("IsSelected", typeof(bool), typeof(ImgControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));

        public static readonly DependencyProperty ControlTypeProperty =

            DependencyProperty.Register("ControlType", typeof(ControlType), typeof(ImgControl), new FrameworkPropertyMetadata(ControlType.ImgControl));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

        "OverViewPathData", typeof(Geometry), typeof(ImgControl), null);

        public static readonly DependencyProperty ImageDataProperty = DependencyProperty.Register(

            "ImageData", typeof(ImageSource), typeof(ImgControl), new PropertyMetadata(null));

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

            "UserID", typeof(string), typeof(ImgControl), new PropertyMetadata(null));

        public static readonly DependencyProperty FilePathProperty = DependencyProperty.Register(

            "FilePath", typeof(string), typeof(ImgControl), new PropertyMetadata(null));

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

            "StartPoint", typeof(Point), typeof(ImgControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

            "EndPoint", typeof(Point), typeof(ImgControl), new PropertyMetadata(new Point(100, 100), PointValueChanged));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

            "PointSet", typeof(List<Point>), typeof(ImgControl), new PropertyMetadata(new List<Point>()));

        public static readonly DependencyProperty TopRightPointProperty = DependencyProperty.Register(

             "TopRightPoint", typeof(Point), typeof(ImgControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty LeftBottomPointProperty = DependencyProperty.Register(

              "LeftBottomPoint", typeof(Point), typeof(ImgControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty AngleProperty = DependencyProperty.Register("Angle", typeof(double), typeof(ImgControl),

                        new PropertyMetadata((double)0.0, new PropertyChangedCallback(AngleValueChanged)));

        public static readonly DependencyProperty CenterXProperty = DependencyProperty.Register("CenterX", typeof(double), typeof(ImgControl),

                        new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty CenterYProperty = DependencyProperty.Register("CenterY", typeof(double), typeof(ImgControl),

                        new PropertyMetadata((double)0, OnCenterXYChanged));

        #endregion

        #region PropertyChanged Method

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ImgControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_Image != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                if (instance.IsSelected)

                {

                    //instance.Base_Image.Stroke = new SolidColorBrush(Colors.Blue);

                }

                else

                {

                    //instance.Base_Image.Stroke = new SolidColorBrush(Colors.Red);

                }

            }

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ImgControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_Image != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetImage();

            }

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ImgControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_Image != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetImage();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (ImgControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_Image != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.SetImage();

            }

        }

        #endregion

        #region Properties

        public double CenterX

        {

            get { return (double)GetValue(CenterXProperty); }

            set { SetValue(CenterXProperty, value); }

        }

        public string UserID

        {

            get { return (string)GetValue(UserIDProperty); }

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public double CenterY

        {

            get { return (double)GetValue(CenterYProperty); }

            set { SetValue(CenterYProperty, value); }

        }

        public string FilePath

        {

            get { return (string)GetValue(FilePathProperty); }

            set { SetValue(FilePathProperty, value); }

        }

        public Point EndPoint

        {

            get { return (Point)GetValue(EndPointProperty); }

            set

            {

                if (this.EndPoint != value)

                {

                    SetValue(EndPointProperty, value);

                    OnPropertyChanged("EndPoint");

                }

            }

        }

        public List<Point> PointSet

        {

            get { return (List<Point>)GetValue(PointSetProperty); }

            set { SetValue(PointSetProperty, value); }

        }

        public Point StartPoint

        {

            get { return (Point)GetValue(StartPointProperty); }

            set

            {

                if (this.StartPoint != value)

                {

                    SetValue(StartPointProperty, value);

                    OnPropertyChanged("StartPoint");

                }

            }

        }

        public Point TopRightPoint

        {

            get { return (Point)GetValue(TopRightPointProperty); }

            set

            {

                SetValue(TopRightPointProperty, value);

                OnPropertyChanged("TopRightPoint");

            }

        }

        public Point LeftBottomPoint

        {

            get { return (Point)GetValue(LeftBottomPointProperty); }

            set

            {

                SetValue(LeftBottomPointProperty, value);

                OnPropertyChanged("LeftBottomPoint");

            }

        }

        public double Angle

        {

            get { return (double)GetValue(AngleProperty); }

            set

            {

                if (this.Angle != value)

                {

                    SetValue(AngleProperty, value);

                }

            }

        }

        public ImageSource ImageData

        {

            get { return (ImageSource)this.GetValue(ImageDataProperty); }

            set { this.SetValue(ImageDataProperty, value); }

        }

         public bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

                OnPropertyChanged("IsSelected");

            }

        }

        public ControlType ControlType

        {

            set

            {

                SetValue(ControlTypeProperty, value);

                OnPropertyChanged("ControlType");

            }

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

        }

        public Geometry OverViewPathData

        {

            get { return (Geometry)GetValue(OverViewPathDataProperty); }

            set

            {

                SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        #endregion

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_Image = GetTemplateChild(PART_Image) as Image;

            Base_Image.Width = 0;

            Base_Image.Height = 0;

        }

        public void SetImage()

        {

            this.ApplyTemplate();

            Point mid = MathSet.FindCentroid(new List<Point>()

            {

                this.StartPoint,

                this.LeftBottomPoint,

                this.EndPoint,

                this.TopRightPoint,                

            });

            double AngleData = this.Angle * -1;

            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = MathSet.RotateAbout(mid, this.StartPoint, AngleData);

            LineSegment lineSegment0 = new LineSegment();

            lineSegment0.Point = MathSet.RotateAbout(mid, this.StartPoint, AngleData);

            pathFigure.Segments.Add(lineSegment0);

            LineSegment lineSegment1 = new LineSegment();

            lineSegment1.Point = MathSet.RotateAbout(mid, this.LeftBottomPoint, AngleData);

            pathFigure.Segments.Add(lineSegment1);

            LineSegment lineSegment2 = new LineSegment();

            lineSegment2.Point = MathSet.RotateAbout(mid, this.EndPoint, AngleData);

            pathFigure.Segments.Add(lineSegment2);

            LineSegment lineSegment3 = new LineSegment();

            lineSegment3.Point = MathSet.RotateAbout(mid, this.TopRightPoint, AngleData);

            pathFigure.Segments.Add(lineSegment3);

            PathGeometry pathGeometry = new PathGeometry();

            pathGeometry.Figures = new PathFigureCollection();

            pathFigure.IsClosed = true;

            pathGeometry.Figures.Add(pathFigure);

            this.Base_Image.Width = pathGeometry.Bounds.Width;

            this.Base_Image.Height = pathGeometry.Bounds.Height;

             this.Tag = pathGeometry;

            Canvas.SetLeft(this, MathSet.RotateAbout(mid, mid, AngleData).X - this.Base_Image.Width / 2);

            Canvas.SetTop(this, MathSet.RotateAbout(mid, mid, AngleData).Y - this.Base_Image.Height / 2);

        }

        public void updateControl()

        {

            this.StartPoint = new Point(this.PointSet[0].X, this.PointSet[0].Y);

            this.LeftBottomPoint = new Point(this.PointSet[1].X, this.PointSet[1].Y);

            this.TopRightPoint = new Point(this.PointSet[3].X, this.PointSet[3].Y);

            this.EndPoint = new Point(this.PointSet[2].X, this.PointSet[2].Y);

        }

        public double LineSize { get; set; }

        public Geometry PathData { get; set; }

    }

}