MARKUS

using KCOM.Common;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Runtime.Serialization.Formatters.Binary;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Shapes;

using Telerik.Windows.Controls;

namespace KCOM.Controls

{

    /// <summary>

    /// SignManager.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class SignManager : UserControl

    {

        public SignManager()

        {

            InitializeComponent();

            this.Loaded += SignManager_Loaded;

        }

        private async void SignManager_Loaded(object sender, RoutedEventArgs e)

        {

            var strokeData = await ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseTaskClient.GetSignStrokesAsync(App.ViewInfo.ProjectNO, App.ViewInfo.UserID);

            if(strokeData != null)

            {

                StringToStroke(strokeData);

            }

        }

        private void Reset_Click(object sender, RoutedEventArgs e)

        {

            txtInput.Text = "";

            txtInput.IsEnabled = true;

            SignCanvas.Strokes.Clear();

        }

        private async void Save_Click(object sender, RoutedEventArgs e)

        {

            //if (KCOM.VistaSecurity.IsAdmin())

            //{

            if (SignCanvas.Strokes.Count > 0)

            {

                var signImage = Convert.ToBase64String(SignatureToBitmapBytes());

                var pointes = SignCanvas.Strokes.Select(x => x.GetBounds());

                var _startX = pointes.Min(x => x.X);

                var _startY = pointes.Min(x => x.Y);

                var _actualWidth = pointes.Max(x => x.Right);

                _actualWidth = Math.Abs(_startX - _actualWidth);

                var _actualHeight = pointes.Max(x => x.Bottom);

                _actualHeight = Math.Abs(_startY - _actualHeight);

                var result = await ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseTaskClient.SetSignDataAsync(

                             App.ViewInfo.UserID, signImage, (int)_startX, (int)_startY, (int)_actualWidth, (int)_actualHeight);

                if (result > 0)

                {

                    var strokesData = Convert.ToBase64String(StrokesToString());

                    var result2 = await ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseTaskClient.SetSignStrokesAsync(

                                 App.ViewInfo.UserID,strokesData);

                    if (result2 > 0)

                    {

                        RadWindow.Alert(new DialogParameters()

                        {

                            Content = "Save Signature Completed."

                        });

                    }

                    //var signData = await ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseTaskClient.GetSignDataAsync(App.ViewInfo.ProjectNO, App.ViewInfo.UserID);

                    //SetPreview(signData);

                }

            };

            //}

            //else

            //{

            //    MessageBox.Show("어드민 권한 필요");

            //}

        }

        private void SetPreview(string imgStr)

        {

            byte[] imageBytes = System.Convert.FromBase64String(imgStr);

            BitmapImage returnImage = new BitmapImage();

            using (System.IO.MemoryStream stream = new System.IO.MemoryStream())

            {

                stream.WriteAsync(imageBytes, 0, imageBytes.Length);

                stream.Position = 0;

                System.Drawing.Image img = System.Drawing.Image.FromStream(stream);

                returnImage.BeginInit();

                System.IO.MemoryStream ms = new System.IO.MemoryStream();

                img.Save(ms, System.Drawing.Imaging.ImageFormat.Png);

                ms.Seek(0, System.IO.SeekOrigin.Begin);

                returnImage.StreamSource = ms;

                returnImage.EndInit();

                stream.Close();

            }

        }

        private byte[] SignatureToBitmapBytes()

        {

            RenderTargetBitmap rtb = new RenderTargetBitmap((int)SignCanvas.ActualWidth, (int)SignCanvas.ActualHeight, 96d, 96d, PixelFormats.Default);

            rtb.Render(SignCanvas);

            MemoryStream ms = new MemoryStream();

            System.Windows.Media.Imaging.PngBitmapEncoder encoder = new PngBitmapEncoder();

            BitmapFrame frame = BitmapFrame.Create(rtb);

            encoder.Frames.Add(frame);

            encoder.Save(ms);

            ms.Position = 0;

            byte[] bytes = new byte[ms.Length];

            ms.Read(bytes, 0, bytes.Length);

            return bytes;

        }

        private byte[] StrokesToString()

        {

            byte[] bytes = null;

            CustomStrokes customStrokes = new CustomStrokes();

            customStrokes.StrokeCollection = new Point[SignCanvas.Strokes.Count][];

            for (int i = 0; i < SignCanvas.Strokes.Count; i++)

            {

                customStrokes.StrokeCollection[i] = new Point[SignCanvas.Strokes[i].StylusPoints.Count];

                for (int j = 0; j < SignCanvas.Strokes[i].StylusPoints.Count; j++)

                {

                    customStrokes.StrokeCollection[i][j] = new Point();

                    customStrokes.StrokeCollection[i][j].X = SignCanvas.Strokes[i].StylusPoints[j].X;

                    customStrokes.StrokeCollection[i][j].Y = SignCanvas.Strokes[i].StylusPoints[j].Y;

                }

            }

            //Serialize

            using (MemoryStream ms = new MemoryStream())

            {

                BinaryFormatter bf = new BinaryFormatter();

                bf.Serialize(ms, customStrokes);

                ms.Position = 0;

                bytes = new byte[ms.Length];

                ms.Read(bytes, 0, bytes.Length);

            }

            return bytes;

        }

        private void StringToStroke(string strokesData)

        {

            try

            {

                //deserialize it

                BinaryFormatter bf = new BinaryFormatter();

                MemoryStream ms = new MemoryStream(Convert.FromBase64String(strokesData));

                CustomStrokes customStrokes = (CustomStrokes)bf.Deserialize(ms);

                //rebuilt it

                for (int i = 0; i < customStrokes.StrokeCollection.Length; i++)

                {

                    if (customStrokes.StrokeCollection[i] != null)

                    {

                        StylusPointCollection stylusCollection = new StylusPointCollection(customStrokes.StrokeCollection[i]);

                        Stroke stroke = new Stroke(stylusCollection);

                        StrokeCollection strokes = new StrokeCollection();

                        strokes.Add(stroke);

                        SignCanvas.Strokes.Add(strokes);

                    }

                }

            }

            catch (Exception ex)

            {

            }

        }

        private string GetSignData()

        {

            string result = "";

            try

            {

            }

            catch (Exception)

            {

                throw;

            }

            return result;

        }

        private void SignCanvas_SourceUpdated(object sender, DataTransferEventArgs e)

        {

            if(SignCanvas.Strokes.Count() > 0)

            {

                txtInput.IsEnabled = false;

            }

            else

            {

                txtInput.IsEnabled = true;

            }

        }

        private void SignCanvas_StrokeCollected(object sender, InkCanvasStrokeCollectedEventArgs e)

        {

            if (SignCanvas.Strokes.Count() > 0)

            {

                txtInput.IsEnabled = false;

            }

            else

            {

                txtInput.IsEnabled = true;

            }

        }

    }

    [Serializable]

    public sealed class CustomStrokes

    {

        public CustomStrokes() { }

        /// <summary>

        /// The first index is the stroke no.

        /// The second index is for the keep the 2D point.

        /// </summary>

        public Point[][] StrokeCollection;

    }

}