using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Automation.Provider;
using System.Windows.Automation.Peers;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Collections.Specialized;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Reflection;
using System.Text.RegularExpressions;
using Microsoft.Win32;

namespace VideoWallControl
{
    /**
     * class for basic data of window
     * 
     * 
     * */
    public class DisplayData
    {
       
        public double Left { get; set; }
        public double Top { get; set; }

        public double Width { get; set; }

        public double Height { get; set; }

        public double X0 { get; set; }
        public double Y0 { get; set; }
        public double X1 { get; set; }
        public double Y1 { get; set; }

        public int CurID { get; set; }
        public Display2 display;
        

    }
    /**
     * class for serialize/deserialize data of Layouts in/from json format
     * 
     * 
     * */
     
    [DataContract]
    public class SerializeLayer
    {
        [DataMember]
        public int Number { get; set; }

        //Coordinats LeftTop corner of window
        [DataMember]
        public double X0 { get; set; }
        [DataMember]
        public double Y0 { get; set; }

        //Coordinats RightBottom corner of window
        [DataMember]
        public double X1 { get; set; }
        [DataMember]
        public double Y1 { get; set; }

        //Number of input chanel
        [DataMember]
        public int Input { get; set; }
        //Id of win
        [DataMember]
        public int CurID { get; set; }

        //Display number of win
        [DataMember]
        public int CurNum { get; set; }
        [DataMember]
        //factors to convert the coordinate system
        public double FactX { get; set; }
        [DataMember]
        public double FactY { get; set; }

        public static SerializeLayer FromJson(string data)
        {
            SerializeLayer layer;
            var serializer = new DataContractJsonSerializer(typeof(SerializeLayer));
            using (var memoryStream = new MemoryStream(Encoding.Unicode.GetBytes(data)))
            {
                layer = serializer.ReadObject(memoryStream) as SerializeLayer;
            }
            return layer;
        }

        public static string ToJson(SerializeLayer layer)
        {
            string result;
            var serializer = new DataContractJsonSerializer(typeof(SerializeLayer));
            using (var memoryStream = new MemoryStream())
            {
                serializer.WriteObject(memoryStream, layer);
                result = Encoding.UTF8.GetString(memoryStream.ToArray(), 0, (int)memoryStream.Length);
            }
            return result;
        }
    }


    /**
         * class for serialize/deserialize saved Layouts in/from json format
         * 
         * 
         * */
    [DataContract]
    public class ListLayers
    {
        [DataMember]
        public string json_str { get; set; }
        [DataMember]
        public string layer_name { get; set; }

        public static ListLayers FromJson(string data)
        {
            ListLayers list;
            var serializer = new DataContractJsonSerializer(typeof(ListLayers));
            using(var memoryStream = new MemoryStream(Encoding.Unicode.GetBytes(data)))
            {
                list = serializer.ReadObject(memoryStream) as ListLayers;
            }
            return list;
        }

        public static string ToJson(ListLayers lst)
        {
            string result;
            var serializer = new DataContractJsonSerializer(typeof(ListLayers));
            using (var memoryStream = new MemoryStream())
            {
                serializer.WriteObject(memoryStream, lst);
                result = Encoding.UTF8.GetString(memoryStream.ToArray(), 0, (int)memoryStream.Length);
            }
            return result;
        }

    }

    static public class MySocket
    {
        static public Socket socket;
        static public IPEndPoint ieps;
    }

    
 
    public partial class MainWindow : Window
    {
        public VideoWallConfig config = new VideoWallConfig();
        public MainWindow winm;
        public ControllerSetting winControllerSettings;
        public InputSettings winInputSettings;
        public ProtokolManager prman;

        Display2 rect2;
        public Display2 tempDispl;
        Rectangle rct;
        Point point;
        public int start_chanal = 1;

        System.Windows.Media.Color colorFill;
        Brush brushFill;
        Pen drawPen;
        public int CountDisplay { get; set; }

        public List<Display2> list2 = new List<Display2>();
        public bool IsDrawing1 = false;
        public bool IsDrawing2 = false;
        public int LastDelDisplay = 0;
        public string WinCod = "";

        public WinPortSettings connection;

        public SerialPortCommunication PortCom;
        public double FactorX, FactorY;
        public string PathToLog;
        public bool COMportOK = true;
        public bool moveCBD = false;
        

        public int dsp_count = 0;
        string IPAdr;
        public bool rset = false;
        Brush btcolor = new SolidColorBrush(Color.FromArgb(255, 0, 172, 204));
        Style btStyle = new Style();

        Thread thread;
        private delegate void SetTextDeleg(string text);

        //list of windows drawn by on the video wall
        public Dictionary<int, Display2> displayList = new Dictionary<int, Display2>();

        //the list of number of windows to remove
        public List<int> listDel = new List<int>();

        public ConfigHelper2 conf;
        // список прямоугольных областей, кот представляют реальные мониторы на видеостене
        public List<RectangleGeometry> list_rect = new List<RectangleGeometry>();
        //список прямоугольников кот представляют мониторы занятые выводом видеокартинки,
        // это мониторы на кот выводится видокартинка
        public List<Rect> list_monitor = new List<Rect>();
        // части мониторов(прямоугольники) на кот выводится изображение, т.е. сетка 
        //из прямоугольных областей из кот состоит нарисованый мышкой дисплей
        public List<Rect> list_rectpart_displ = new List<Rect>();
        // список команд для удаления активных окон
        public Dictionary<int, string> listDelCmd = new Dictionary<int, string>();
        //коллекция окон и номеров карточек
        public Dictionary<int, List<string>> list_card = new Dictionary<int, List<string>>();

     //   public Dictionary<int, int> chwin = new Dictionary<int, int>();

        //Список всех мониторов видеостены ключ - номер монитора, значение - координаты вершин, 
        //нумерация начинается с 0(верхнего левого монитора) 
        public Dictionary<int, Rect> wall = new Dictionary<int, Rect>();
        //список включенных мониторов
        public Dictionary<int, Rect> monitors_on_displ = new Dictionary<int, Rect>(); 
        //список мониторов для вкл/откл
        public List<bool> mon_onoff = new List<bool>();
        //список команд для экспорта лэйаута
        public List<string> lstCmdExport = new List<string>();
        //список команд для создания окна
        public List<string> lstCreateWin = new List<string>();
        public bool listCmdCreateComplete = false;


        public DisplayData DD;
        public Dictionary<int, DisplayData> listOfDisp = new Dictionary<int, DisplayData>();

        public string[] layers = { "00", "00", "00", "00" };

        public int CountChildWin = 0;

        public bool LanConnect = false;
        public bool ComConnect = false;
        public bool flg_resize = false;

        public int out_nx0y0 = 0;
        public int out_nx1y0 = 0;
        public int out_nx0y1 = 0;
        public int out_nx1y1 = 0;

        //  public double[] MaxRect = new double[4];   
        public List<string> lstSerialData, lstSerialData2, lstSerialData3, lstSerialData4, lstSerialData5,
            lstSerialData6, lstSerialData7, lstSerialData8, lstSerialData9, lstSerialData10, lstSerialData11;

        public List<string> listLayers = new List<string>();

        public int selected_layer = 0;
        public int GlobalDelay = 8;

       
        List<RadioButton> rbmas = new List<RadioButton>();
   //     HashSet<RadioButton> rbset = new HashSet<RadioButton>();

        public string CurRBName = "";
        public bool flagName = false;
        public bool login_ok = false;
        public bool cancel = false;

        public string CurrentUser;
        public List<string> users_list = new List<string>();

       public SchedulerFrm scheduler;
       public Dictionary<string, DateTime> startTimeDic = new Dictionary<string, DateTime>();
       public Dictionary<string, DateTime> endTimeDic = new Dictionary<string, DateTime>();

   //   public string time;
       System.Timers.Timer timer;
       public bool schedulerOnOff = false;
       public bool LayerFlag = false;


       public VideoWallModel videoWall;
       public int horizontalResolution;
       public int verticalResolution;
       public double Scale { get; set; }

        public MainWindow()
        {
            InitializeComponent();
            winm = this;
            colorFill = System.Windows.Media.Color.FromArgb(50, 245, 225, 19);
            brushFill = new SolidColorBrush(colorFill);
            CountDisplay = 0;

              //MySocket.ieps = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 5000);
            MySocket.ieps = new IPEndPoint(IPAddress.Parse("192.168.0.200"), 60090);
            MySocket.socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);


            //create a stream to read com port
            thread = new Thread(reciveDataThread);
            thread.Start();

            connection = new WinPortSettings(this);
            PortCom = new SerialPortCommunication(this);
            conf = new ConfigHelper2(this);
            prman = new ProtokolManager(this);
            // сначала все выходы отключены
         /*   for (int i = 0; i < 64; i++)
            {
                conf.OutOn.Add(i, false);
            }*/
            btStyle = btNet.Style;
            scheduler = new SchedulerFrm(this);
        }


        private void reciveDataThread()
        {
            while (true)
            {
                Socket Rsocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                IPEndPoint Myep = new IPEndPoint(IPAddress.Any, 6000);
                EndPoint My_ep = (EndPoint)Myep;
                Rsocket.Bind(My_ep);
                //MethodInvoker mi = new MethodInvoker(MyUDPReceiveSetting);
                while (true)
                {
                    Thread.Sleep(1);
                    try
                    {
                        byte[] data = new byte[1024];
                        Rsocket.ReceiveTimeout = 200;
                        int rlen = Rsocket.ReceiveFrom(data, ref My_ep);

                        if (rlen > 0)
                        {
                            byte[] My_CopyBuff = new byte[rlen];
                            for (int m = 0; m < rlen; m++)
                                My_CopyBuff[m] = data[m];
                            //   Debug.WriteLine(Encoding.Default.GetString(data, 0, rlen));

                            string message = Encoding.Default.GetString(data, 0, rlen);

                            //Rsocket.Close();
                            Dispatcher.BeginInvoke(new SetTextDeleg(data_reseived), new object[] { message });
                        }

                    }
                    catch
                    {
                    }
                }
            }
        }

        private void data_reseived(string data)
        {
            switch (data)
            {
                case "<WIN_IDERR>":
                    {
                        StreamWriter sw;
                        sw = File.AppendText(PathToLog + "\\PortLog.txt");
                        sw.WriteLine("Read: " + data);
                        sw.WriteLine("");
                        sw.Close();
                        MessageBox.Show("Opened window IP already exists!", "Error opened window", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                    break;

                case "<WIN_FULL>":
                    {
                        StreamWriter sw;
                        sw = File.AppendText(PathToLog + "\\PortLog.txt");
                        sw.WriteLine("Read: " + data);
                        sw.WriteLine("");
                        sw.Close();
                        MessageBox.Show("All windows are full, can not open any more!", "Opened window", MessageBoxButton.OK, MessageBoxImage.Warning);
                    }
                    break;
                case "<NO_WINID>":
                    {
                        StreamWriter sw;
                        sw = File.AppendText(PathToLog + "\\PortLog.txt");
                        sw.WriteLine("Read: " + data);
                        sw.WriteLine("");
                        sw.Close();
                        MessageBox.Show("Such window is not existed!", "Closed window", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                    break;
                case "<OK>":
                    {
                        StreamWriter sw;
                        sw = File.AppendText(PathToLog + "\\PortLog.txt");
                        sw.WriteLine("Read: " + data);
                        sw.WriteLine("");
                        sw.Close();
                        // MessageBox.Show("All windows are full, can not open any more!", "Opened window", MessageBoxButton.OK, MessageBoxImage.Warning);
                    }
                    break;
                default:
                    {

                        //  lbLog.Items.Add(data);
                        string str = data.Trim('<', '>');
                        string[] strs = str.Split(',');

                        if (strs.Length > 0)
                        {
                            if ((strs[0] == "linkstate") && strs.Length == 2)
                            {
                                IPAdr = strs[1];
                                if (IPAdr == Properties.Settings.Default.IPAdress)
                                {
                                    MessageBox.Show("Connect Succssesfully!!!", "Connection", MessageBoxButton.OK, MessageBoxImage.Information);
                                }
                                else
                                {
                                    MessageBox.Show("No connection to the VideoWall controller!!! Check the connection IP address and IP port", "Connection Error", MessageBoxButton.OK, MessageBoxImage.Error);
                                }
                            }
                            else if (((strs[0] == "linkstate") && strs.Length == 4))
                            {
                                MessageBox.Show("Com port open!!!\n" + strs[1] + " " + strs[2] + " Baud rate =" + strs[3], "Connection",
                                    MessageBoxButton.OK, MessageBoxImage.Information);
                                //MessageBox.Show("Receive data: " + data,"Recive Data",MessageBoxButton.OK);
                            }

                        }

                    }
                    break;
            }


            //  MessageBox.Show("Reseive Data: " + data);
        }

        private void GetVideoWall()
        {
            int cnt = 0;
            foreach (RectangleGeometry rg in list_rect)
            {
                double x0, y0, w, h;
                x0 = rg.Rect.X * FactorX;
                y0 = rg.Rect.Y * FactorY;
                w = rg.Rect.Width * FactorX;
                h = rg.Rect.Height * FactorY;
                Rect r = new Rect(x0, y0, w, h);
                wall.Add(cnt, r);
                cnt++;
                mon_onoff.Add(false);
            }
        }


        //load the main form
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            
      // Login form create & show
       start:  Login loginFrm = new Login(this);
         
         loginFrm.ShowDialog();
                    
            if (login_ok)
            {
              // read configuration from user config file
                if (Properties.Settings.Default.Config1 != "")
                {
                    config = VideoWallConfig.FromJson(Properties.Settings.Default.Config1);
                }
                else
                {                    
                    config.Resolution = "1920x1080";
                    config.Column = 1;
                    config.Row = 1;
                    config.StartChanel = 1;
                    config.SingleDisplay = "Max 1 window";

                    horizontalResolution = 1920;
                    verticalResolution = 1080;
                }

                //Draw Grid on main form
                if (config.Column != 0)
                {
                  //  cbResolutions.Text = config.Resolution;


                    DrawingVisual v = new DrawingVisual();

                    DrawLinesSolid2(v, config.Column, config.Row);

                    DrawingVisual v2 = new DrawingVisual();
                    DrawLinesDash2(v2, config.Column, config.Row);
                }
                else
                {
                   // cbResolutions.Text = config.Resolution;


                    DrawingVisual v = new DrawingVisual();

                    DrawLinesSolid2(v, 1, 1);

                    DrawingVisual v2 = new DrawingVisual();
                    DrawLinesDash2(v2, 1, 1);
                }
                
                GetFactorsXY(config.Resolution);

            //    videoWall = new VideoWallModel(config.Row, config.Column, new System.Drawing.Size(horizontalResolution,verticalResolution));

             //   GetVideoWall();       

                start_chanal = config.StartChanel;
             
                long input = Properties.Settings.Default.InputSource;

                //draw label in left panel
                for (int i = 1; i <= input; i++)
                {
                    
                    Label lb = new Label();
                    lb.Content = "HDMI - " + i.ToString();

                    lb.Style = (Style)Application.Current.Resources["TreeViewButton"];
                    lb.MouseLeftButtonDown += new MouseButtonEventHandler(lb_click);
                    tviMachine.Items.Add(lb);
                                 

                }
                int t = config.StartChanel;
                if (t == 0) { t = 1; };
                (tviMachine.Items[t-1] as Label).Background = new SolidColorBrush(Color.FromArgb(255, 6, 183, 216));
             
                //draw radiobutton in right panel
                //string layers_list = Properties.Settings.Default.Layers;
                string layers_list;
                string myconf = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);

                if (File.Exists(myconf + @"\Layouts.config"))
                {
                    using (StreamReader sr = new StreamReader(myconf + @"\Layouts.config"))
                    {
                        layers_list = sr.ReadToEnd();
                    }

                    if ((layers_list != "") && (layers_list != "\"\""))
                    {
                        var serial_list = new DataContractJsonSerializer(typeof(List<string>));
                        using (var memstr = new MemoryStream(Encoding.Unicode.GetBytes(layers_list)))
                        {
                            listLayers = serial_list.ReadObject(memstr) as List<string>;
                        }
                    }
                }
            /*    else
                {
                    File.Create(myconf + @"\Layouts.config");

                }*/

                RadioPanel.Children.Clear();
               

                if (listLayers.Count > 0)
                {
                    for (int i = 0; i < listLayers.Count; i++)
                    {
                        RadioButton rb = new RadioButton();
                        ListLayers lst_l = new ListLayers();
                        lst_l = ListLayers.FromJson(listLayers[i]);

                        rb.Content = lst_l.layer_name.Remove(0, 1);
                        rb.Style = (Style)Application.Current.Resources["RadioButtonStyle"];
                        rb.Name = lst_l.layer_name;//"rb" + i.ToString();
                      //  rb.Name = "rb" + i.ToString();
                        rb.Tag = i;
                        rb.Checked += new RoutedEventHandler(rb_checked);
                      
                        rbmas.Add(rb);
                        RadioPanel.Children.Add(rb);
                    }

                }

                if(CurrentUser != "Administrator")
                {
                    btUser.IsEnabled = false;
                    BitmapImage bi3 = new BitmapImage();
                    bi3.BeginInit();
                    bi3.UriSource = new Uri("\\Components\\Images\\adduser2_d2.PNG", UriKind.Relative);
                    bi3.EndInit();
                    imgUs.Source = bi3;
                    lbUs.Opacity = 0.6;


                    btSettings.IsEnabled = false;
                    BitmapImage bi = new BitmapImage();
                    bi.BeginInit();
                    bi.UriSource = new Uri("\\Components\\Images\\004_d2.PNG", UriKind.Relative);
                    bi.EndInit();
                    imgSet.Source = bi;
                    lbSet.Opacity = 0.6;
                    
                    btVideoWall.IsEnabled = false;
                    BitmapImage bi2 = new BitmapImage();
                    bi2.BeginInit();
                    bi2.UriSource = new Uri("\\Components\\Images\\005_d2.PNG", UriKind.Relative);
                    bi2.EndInit();
                    imgVid.Source = bi2;
                    lbVid.Opacity = 0.6;

                    

                    btSaveLayer.Visibility = System.Windows.Visibility.Hidden;
                    btDelleteLayer.Visibility = System.Windows.Visibility.Hidden;
                }

            }
            else 
            {
                if (cancel == true)
                {
                   // MessageBox.Show("Wrong user name or password!!!", "Error user", MessageBoxButton.OK, MessageBoxImage.Error);
                    this.Close();
                }
                else
                {
                    MessageBox.Show("Wrong user name or password!!!", "Error user", MessageBoxButton.OK, MessageBoxImage.Error);
                    goto start;
                }
               
            }
                       
            //load tasks from user config file to sheduler form
            //start timer
            string TaskListStr = Properties.Settings.Default.TaskList;
            schedulerOnOff = Properties.Settings.Default.Scheduler;

            if((TaskListStr != "")&&(TaskListStr != "\"\""))
            {
                
                if (schedulerOnOff == true)
                {
                    timer = new System.Timers.Timer(1000);
                    timer.Elapsed += new System.Timers.ElapsedEventHandler(checkTime);
                    timer.Enabled = true;
                }
             /*   else
                {
                    timer.Enabled = false;
                }*/

                List<string> lstJson = new List<string>();
                var serial_list = new DataContractJsonSerializer(typeof(List<string>));
                using (var memstr = new MemoryStream(Encoding.Unicode.GetBytes(TaskListStr)))
                {
                    lstJson = serial_list.ReadObject(memstr) as List<string>;
                }
                startTimeDic.Clear();
                endTimeDic.Clear();

                foreach (string s in lstJson)
                {
                    SchedulerData sd = new SchedulerData();
                    sd = SchedulerData.FromJson(s);
                    startTimeDic.Add(sd.LayoutName, sd.StartDate);
                    endTimeDic.Add(sd.LayoutName, sd.EndDate);
                   
                }
            }

        }

        public bool work = false;

        //It enables or disables the layout according to the schedule
        public void checkTime(object sender, System.Timers.ElapsedEventArgs e)
        {
            DateTime dt = DateTime.Now;
          //  time = DateTime.Now.ToString();
            if (schedulerOnOff)
            {
                foreach (KeyValuePair<string, DateTime> keyValue in startTimeDic)
                {
                    foreach (KeyValuePair<string, DateTime> keyValue2 in endTimeDic)
                    {
                        if ((dt.CompareTo(keyValue.Value) >= 0) && (keyValue.Key == keyValue2.Key) && (dt.CompareTo(keyValue2.Value) < 0))
                        {
                            if (!work)
                            {
                                this.Dispatcher.Invoke(() =>
                                    {
                                        this.ChekedRB(keyValue.Key);
                                    });
                                work = true;
                            }
                        }
                        else
                        {
                            if (work)
                            {

                                work = false;
                            }

                        }

                    }

                }

                lbTest.Dispatcher.Invoke(() =>
                    {
                        lbTest.Content = DateTime.Now.ToString();
                    });
            }
         
        }

        //Loads and draws the window of the selected layout
        private void rb_checked(object sender, RoutedEventArgs e)
        {
            if (login_ok)
            {
                List<string> cards = new List<string>();
                PortCom.WriteData(ProtokolManager.Begin);
              
                foreach (int i in displayList.Keys)
                {
                    cards = list_card[i];
                    foreach (string str in cards)
                    {
                        PortCom.WriteData(str);
                        Thread.Sleep(GlobalDelay);
                        
                    }

                    workspace.Children.Remove(displayList[i]);
                    workspace.visuals.Remove(displayList[i]);

                }
                PortCom.WriteData(ProtokolManager.End);
                lstCmdExport.Add(ProtokolManager.End);
                
                lstCreateWin.Clear();

                listDel.Clear();
                listOfDisp.Clear();
                list_card.Clear();
                displayList.Clear();

                lstSerialData = new List<string>();
                foreach (RadioButton rb in rbmas)
                {
                    RadioButton rb_test = sender as RadioButton;

                    if ((rb.IsChecked == true) && (rb_test.Content == rb.Content))
                    {

                        selected_layer = rbmas.IndexOf(rb);

                    }
                }

                ListLayers newLayer = new ListLayers();
                newLayer = ListLayers.FromJson(listLayers[selected_layer]);

                var serializer = new DataContractJsonSerializer(typeof(List<string>));
                using (var memoryStream = new MemoryStream(Encoding.Unicode.GetBytes(newLayer.json_str)))
                {
                    lstSerialData = serializer.ReadObject(memoryStream) as List<string>;
                }


                foreach (string str in lstSerialData)
                {
                    SerializeLayer dsp = new SerializeLayer();
                    dsp = SerializeLayer.FromJson(str);
                    Display2 ndisp = new Display2(this);

                    ndisp.SetValue(Canvas.LeftProperty, dsp.X0 / dsp.FactX);
                    ndisp.SetValue(Canvas.TopProperty, dsp.Y0 / dsp.FactY);
                    ndisp.Width = (dsp.X1 - dsp.X0) / dsp.FactX;
                    ndisp.Height = (dsp.Y1 - dsp.Y0) / dsp.FactY;
                    config.StartChanel = dsp.Input;
                    ndisp.lbMachine.Content = config.StartChanel.ToString();
                    ndisp.SnapsToDevicePixels = true;
                    ndisp.CurID = dsp.CurID;
                    ndisp.CurNum = dsp.CurNum;

                    double sx, sy;
                    sx = ndisp.Width * FactorX;
                    sy = ndisp.Height * FactorY;
                    ndisp.lbSize.Content = "Size: [" + sx.ToString("F0") + "x" + sy.ToString("F0") + "]";
                    ndisp.lbLocation.Content = "Location: [" + (dsp.X0).ToString("F0") + "x" + (dsp.Y0).ToString("F0") + "]";
                    ndisp.Location.X = dsp.X0;
                    ndisp.Location.Y = dsp.Y0;
                    ndisp.Size.X = sx;
                    ndisp.Size.Y = sy;

                    if (!displayList.ContainsKey(ndisp.CurID))
                    {
                        if (listDel.Count == 0)
                        {
                            ndisp.CurNum = displayList.Count + 1;
                        }
                        else
                        {
                            ndisp.CurNum = listDel[0];
                            listDel.RemoveAt(0);
                            listDel.OrderBy(i => i);
                        }
                        ndisp.lbN.Content = "No " + ndisp.CurNum.ToString();
                        ndisp.Name = "Disp" + ndisp.CurNum.ToString();
                        displayList.Add(ndisp.CurID, ndisp);
                        workspace.Children.Add(ndisp);
                        workspace.visuals.Add(ndisp);

                        DD = new DisplayData();
                        DD.Left = Canvas.GetLeft(ndisp);
                        DD.Top = Canvas.GetTop(ndisp);

                        DD.display = ndisp;
                        DD.CurID = ndisp.CurID;
                        DD.Width = ndisp.Width;
                        DD.Height = ndisp.Height;

                        DD.X0 = ndisp.Location.X;
                        DD.Y0 = ndisp.Location.Y;
                        DD.X1 = DD.X0 + ndisp.Size.X;
                        DD.Y1 = DD.Y0 + ndisp.Size.Y;

                        if (!listOfDisp.ContainsKey(ndisp.CurID))
                        {
                            listOfDisp.Add(ndisp.CurID, DD);
                        }

                      CalcCoordinate(ndisp);
                        if(lstCreateWin.Count > 0)
                        {
                            listCmdCreateComplete = true;
                        }
                    }
                }
            }
        }


        private void lb_click(object sender, MouseButtonEventArgs e)
        {
            string selstr = "";

            Label lab = sender as Label;
            //Button lab = sender as Button;
            selstr = lab.Content.ToString();
            string[] ss = selstr.Split('-');
            DragDrop.DoDragDrop(TreeV, ss[1], DragDropEffects.Copy);

            /******************** TEST *********************/
            /*  MySocket.socket.Connect(MySocket.ieps);
              string message = "Test";
              byte[] msg = Encoding.ASCII.GetBytes(message);

              MySocket.socket.Send(msg);
           
              MySocket.socket.Shutdown(SocketShutdown.Both);
              MySocket.socket.Close();
             */
        }

        //calculates the coefficients for calculating the coordinates
        public void GetFactorsXY(string resolution)
        {
            string cnf = Properties.Settings.Default.CurrentConfig;
            if (Properties.Settings.Default.Config1 != "")
            {
                config = VideoWallConfig.FromJson(Properties.Settings.Default.Config1);
            }


            if (resolution != "")
            {

                string res = resolution;
                string[] resarr = res.Split('x');
                string wd = resarr[0];
                string he = resarr[1];

                FactorX = Double.Parse(wd) / (workspace.Width / config.Column);
                FactorY = Double.Parse(he) / (workspace.Width / config.Row);
                //for WallModel
                horizontalResolution = Int32.Parse(wd);
                verticalResolution = Int32.Parse(he);
            }
            else
            {
                string res = "1920x1080";
                string[] resarr = res.Split('x');
                string wd = resarr[0];
                string he = resarr[1];

                if ((config.Column == 0) || (config.Row == 0))
                {
                    config.Column = 1;
                    config.Row = 1;
                }

                FactorX = Double.Parse(wd) / (workspace.ActualWidth / config.Column);
                FactorY = Double.Parse(he) / (workspace.ActualHeight / config.Row);
                //for WallModel
                horizontalResolution = Int32.Parse(wd);
                verticalResolution = Int32.Parse(he);
            }

           
        }

        public void GetFactorsXY(string resolution, int columns, int rows)
        {
            if (resolution != null)
            {

                string res = resolution;
                string[] resarr = res.Split('x');
                string wd = resarr[0];
                string he = resarr[1];

                FactorX = Double.Parse(wd) / (workspace.Width / columns);
                FactorY = Double.Parse(he) / (workspace.Height / rows);
            }
            else
            {
                string res = "1280x1024";
                string[] resarr = res.Split('x');
                string wd = resarr[0];
                string he = resarr[1];


                FactorX = Double.Parse(wd) / (workspace.Width / columns);
                FactorY = Double.Parse(he) / (workspace.Height / rows);
            }
        }

        private void btSource_Click(object sender, RoutedEventArgs e)
        {
            // tviMachine.IsExpanded = true;

        }

        //call form port settings
        private void onSettings_Click(object sender, RoutedEventArgs e)
        {
            WinPortSettings winPortSettings = new WinPortSettings(this);
            winPortSettings.ShowDialog();

        }

        //call settings forms videowalls
        private void btVideoWall_Click(object sender, RoutedEventArgs e)
        {
            winControllerSettings = new ControllerSetting(winm);
            winControllerSettings.ShowDialog();
        }

        //closing the main form and the release of resources
        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            
            if (connection.serialP.IsOpen)
            {
                connection.serialP.Close();
            };
            PortCom.Close();
            connection.Close();
            thread.Abort();
            thread.Join(200);
            MySocket.socket.Close();
           if (timer != null)
           {
               timer.Stop();
           }
            if(scheduler != null)
            {
                scheduler.Close();
            }
        }

        //Processing pressing the left mouse button, a grid called the main form and 
        //the beginning of the drawing window
        private void workspace_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {

            if (IsDrawing1) return;
            IsDrawing1 = true;
            point = e.GetPosition((UIElement)sender);
            rct = new Rectangle();
            rct.SetValue(Canvas.LeftProperty, point.X);
            rct.SetValue(Canvas.TopProperty, point.Y);
            rct.Width = 30;
            rct.Height = 30;
            rct.Fill = Brushes.Transparent;
            rct.Stroke = Brushes.Black;
            rct.StrokeThickness = 0.3;
            workspace.Children.Add(rct);
            workspace.visuals.Add(rct);



        }

        bool recflg = false;
        //Processing mouse movements and the definition of the boundaries drawn by the window
        private void workspace_MouseMove(object sender, MouseEventArgs e)
        {

            if (!IsDrawing1) return;


            Point pointEnd = e.GetPosition(workspace);

           
            if ((point.X > pointEnd.X) && (Math.Abs(point.X - pointEnd.X) > 1))
            {
                recflg = false;
                workspace.Children.Remove(rct);
                workspace.visuals.Remove(rct);
                return;
            }
            else
            {
                rct.SetValue(Canvas.LeftProperty, point.X);
                recflg = true;
                rct.Width = Math.Abs(pointEnd.X - point.X);
                rct.Height = Math.Abs(pointEnd.Y - point.Y);
            }

            if ((point.Y > pointEnd.Y) && (Math.Abs(point.Y - pointEnd.Y) > 1))
            {
                recflg = false;
                workspace.Children.Remove(rct);
                workspace.visuals.Remove(rct);
                return;
            }
            else
            {
                rct.SetValue(Canvas.TopProperty, point.Y);
                recflg = true;
                rct.Width = Math.Abs(pointEnd.X - point.X);
                rct.Height = Math.Abs(pointEnd.Y - point.Y);
            }

        }


        public DisplayData start_over_dis = new DisplayData();
        bool intersect = false;
        //creation and drawing window to display the image on the video wall
        private void workspace_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            
            if (IsDrawing1)
            {
                if (RadioPanel.Children.Count > 0)
                {
                    foreach (RadioButton rb in RadioPanel.Children)
                    {
                        UnChekedRB(rb.Name);
                    }

                }

                if (recflg == true)
                {
                    IsDrawing1 = false;

                    rect2 = new Display2(winm);

                    rect2.Width = rct.Width;
                    rect2.Height = rct.Height;
                    rect2.SetValue(Canvas.LeftProperty, Canvas.GetLeft(rct));
                    rect2.SetValue(Canvas.TopProperty, Canvas.GetTop(rct));
                                     
                    rect2.lbMachine.Content = config.StartChanel.ToString();
                    rect2.SnapsToDevicePixels = true;
                    
                    double sx, sy;
                    sx = rect2.Width * FactorX;
                    sy = rect2.Height * FactorY;
                    rect2.lbSize.Content = "Size: [" + sx.ToString("F0") + "x" + sy.ToString("F0") + "]";
                    rect2.lbLocation.Content = "Location: [" + (point.X * FactorX).ToString("F0") + "x" + (point.Y * FactorY).ToString("F0") + "]";
                    rect2.Location.X = point.X * FactorX;
                    rect2.Location.Y = point.Y * FactorY;
                    rect2.Size.X = sx;
                    rect2.Size.Y = sy;

                   

                    if (!displayList.ContainsKey(rect2.CurID))
                    {
                                                
                        if (listDel.Count == 0)
                        {
                            rect2.CurNum = displayList.Count + 1;
                        }
                        else
                        {
                            rect2.CurNum = listDel[0];
                            listDel.RemoveAt(0);
                            listDel.OrderBy(i => i);
                        }
                        rect2.lbN.Content = "No " + rect2.CurNum.ToString();
                        rect2.Name = "Disp" + rect2.CurNum.ToString();
                        workspace.Children.Remove(rct);
                        workspace.visuals.Remove(rct);
                        displayList.Add(rect2.CurID, rect2);
                        workspace.Children.Add(rect2);
                        workspace.visuals.Add(rect2);

                      //  Thread.Sleep(GlobalDelay);

                        DD = new DisplayData();
                        DD.Left = Canvas.GetLeft(rect2);
                        DD.Top = Canvas.GetTop(rect2);

                        DD.display = rect2;
                        DD.CurID = rect2.CurID;
                        DD.Width = rect2.Width;
                        DD.Height = rect2.Height;

                        DD.X0 = rect2.Location.X;
                        DD.Y0 = rect2.Location.Y;
                        DD.X1 = DD.X0 + rect2.Size.X;
                        DD.Y1 = DD.Y0 + rect2.Size.Y;

                       
                        listOfDisp.Add(rect2.CurID, DD);
                   
                        CalcCoordinate(rect2);
                    }

                }
                else
                {
                    
                    IsDrawing1 = false;
                    rct = null;
                }
            }
            intersect = false;
        }

       //creation window
        private void CalcCoordinate(Display2 dsp)
        {
            conf.CreateWindows(dsp);

       /*     Rect r = new Rect(Canvas.GetLeft(dsp)*FactorX, Canvas.GetTop(dsp)*FactorY, dsp.Width*FactorX, dsp.Height*FactorY);
            foreach(KeyValuePair<int,Rect> kvp in wall)
            {
                Rect rct = new Rect();
                rct = kvp.Value;
                bool intersect = rct.IntersectsWith(r);
                if(intersect)
                {
                    monitors_on_displ.Add(kvp.Key, rct);
                    mon_onoff[kvp.Key] = true;
                }
            }*/
                    
        }



        /**
        //drawing the grid lines on the main form
         * 
         * column - column count in videowall
         * row - row count in videowall
         * 
         * */
        public void DrawLinesSolid2(DrawingVisual visual, int column, int row)
        {
            double wd = workspace.Width / column;
            double hd = workspace.Height / row;
            double w1 = workspace.ActualWidth / column;
            double h1 = workspace.ActualHeight / row;

            if (wd < hd)
            {
                double delta = (hd - wd) * column;
                workspace.Width = workspace.Width + delta;

            }
            else if (wd > hd)
            {
                double delta = (wd - hd) * column;
                workspace.Width = workspace.Width - delta;

            }

            using (DrawingContext dc = visual.RenderOpen())
            {
                Brush brush = Brushes.Black;
                drawPen = new Pen(brush, 0.5);

                dc.DrawLine(drawPen, new Point(0, 0), new Point(0, workspace.Height));
                dc.DrawLine(drawPen, new Point(workspace.Width, 0), new Point(workspace.Width, workspace.Height));
                dc.DrawLine(drawPen, new Point(0, 0), new Point(workspace.Width, 0));
                dc.DrawLine(drawPen, new Point(0, workspace.Height), new Point(workspace.Width, workspace.Height));

                List<double> list_x = new List<double>();
                List<double> list_y = new List<double>();
                list_x.Add(0.0);
                list_y.Add(0.0);

                for (int i = 0; i < column - 1; i++)
                {
                    dc.DrawLine(drawPen, new Point((workspace.Width / column) * (i + 1), 0),
                        new Point((workspace.Width / column) * (i + 1), workspace.Height));

                    list_x.Add((workspace.Width / column) * (i + 1));

                };
                //координаты Х границ мониторов
                list_x.Add(workspace.Width);
                for (int j = 0; j < row - 1; j++)
                {
                    dc.DrawLine(drawPen, new Point(0, (workspace.Height / row) * (j + 1)),
                        new Point(workspace.Width, (workspace.Height / row) * (j + 1)));
                    list_y.Add((workspace.Height / row) * (j + 1));
                }
                //координаты Y границ мониторов
                list_y.Add(workspace.Height);
                //  int cn = config.Column * config.Row;
                list_rect.Clear();


                for (int j = 0; j < list_y.Count - 1; j++)
                {
                    for (int i = 0; i < list_x.Count - 1; i++)
                    {
                        RectangleGeometry rect_g = new RectangleGeometry();
                        Rect rect = new Rect(list_x[i], list_y[j], list_x[i + 1] - list_x[i], list_y[j + 1] - list_y[j]);
                        rect_g.Rect = rect;
                        list_rect.Add(rect_g);

                    }
                }

                
               
            }

            workspace.AddVisual(visual);

        }


        /**
       //drawing the grid dash lines on the main form
        * 
        * column - column count in videowall
        * row - row count in videowall
        * 
        * */

        public void DrawLinesDash2(DrawingVisual visual, int column, int row)
        {
            using (DrawingContext dc = visual.RenderOpen())
            {
                Brush brush = Brushes.Black;
                Pen drawPen = new Pen(brush, 0.2);

                drawPen.DashStyle = DashStyles.Dash;


                for (int i = 0; i < column; i++)
                {
                    dc.DrawLine(drawPen, new Point((workspace.Width / column) * (i + 1) - ((workspace.Width / column) / 2), 0),
                        new Point((workspace.Width / column) * (i + 1) - ((workspace.Width / column) / 2), workspace.Height));

                };

                for (int j = 0; j < row; j++)
                {
                    dc.DrawLine(drawPen, new Point(0, (workspace.Height / row) * (j + 1) - ((workspace.Height / row) / 2)),
                        new Point(workspace.Width, (workspace.Height / row) * (j + 1) - ((workspace.Height / row) / 2)));
                }

            }
            workspace.AddVisual(visual);

        }

        //получение ключа словаря по его значению
        public int GetKeyByValue(int n)
        {
            foreach (var record in displayList)
            {
                if (record.Value.CurNum == n)
                    return record.Key;
            }
            return -1;
        }

        Display2 dd;
        //the grid cleaning drawing
        public void btCleare_Click(object sender, RoutedEventArgs e)
        {

            foreach (var v in workspace.Children)
            {
                if (v is Display2)
                {
                    Display2 d = v as Display2;
                    ButtonAutomationPeer peer = new ButtonAutomationPeer(d.btClose);
                    IInvokeProvider invokeProv = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
                    invokeProv.Invoke();
                    listDel.Clear();
                    displayList.Clear();
                }

            }

            if (RadioPanel.Children.Count > 0)
            {
                foreach (RadioButton rb in RadioPanel.Children)
                {
                    UnChekedRB(rb.Name);
                }

            }
            
        }

        //fill each grid cell a new window to display the image on the video wall
        private void btNew_Click(object sender, RoutedEventArgs e)
        {
            string cnf = Properties.Settings.Default.CurrentConfig;
            switch (cnf)
            {
                case "Config1":
                    {
                        if (Properties.Settings.Default.Config1 != "")
                        {
                            config = VideoWallConfig.FromJson(Properties.Settings.Default.Config1);
                        }
                    }
                    break;
      
            };


            int count = config.Column * config.Row;
            
            list2 = new List<Display2>();

            Point[,] lp = new Point[config.Row, config.Column];
            int countD = config.Row * config.Column;
            int temp = 0;

            double x, y;

           
            for (int j = 0; j < config.Row; j++)
                for (int i = 0; i < config.Column; i++)
                {
                    x = (workspace.Height / config.Row) * i;
                    y = (workspace.Width / config.Column) * j;

                    Display2 d = new Display2(winm);
                    d.Width = workspace.Width / config.Column;
                    d.Height = workspace.Height / config.Row;
                    d.SetValue(Canvas.LeftProperty, x);
                    d.SetValue(Canvas.TopProperty, y);
                  //  d.lbMachine.Content = start_chanal.ToString();
                    d.lbMachine.Content = config.StartChanel.ToString();
                    double sx, sy;
                    sx = d.Width * FactorX;
                    sy = d.Height * FactorY;

                    d.lbSize.Content = "Size: [" + sx.ToString("F0") + "x" + sy.ToString("F0") + "]";
                    d.lbLocation.Content = "Location: [" + (x * FactorX).ToString("F0") + "x" + (y * FactorY).ToString("F0") + "]";
                    temp++;
                    d.CurNum = temp;
                    d.Name = "Disp" + d.CurNum.ToString();
                    d.lbN.Content = "No " + d.CurNum.ToString();
                    displayList.Add(d.CurID, d);
                    workspace.Children.Add(d);
                    workspace.visuals.Add(d);

                    int x0 = (int)(x * FactorX);
                    int y0 = (int)(y * FactorY);
                    int x1 = (int)(x0 + sx - 1);
                    int y1 = (int)(y0 + sy - 1);

                    conf.CreateWindows(x0, y0, x1, y1, d.CurNum);
                     d = null;

                                       
                }


            int cl = workspace.visuals.Count;


        }

        //the controller resets and cleaning the grid
        private void btInitMode_Click(object sender, RoutedEventArgs e)
        {
            rset = true;

            listDel.Clear();
            displayList.Clear();

            workspace.Children.Clear();
            workspace.visuals.Clear();

            //   connection.ShutAllPort();

            string cnf = Properties.Settings.Default.CurrentConfig;
            switch (cnf)
            {
                case "Config1":
                    {
                        if (Properties.Settings.Default.Config1 != "")
                        {
                            config = VideoWallConfig.FromJson(Properties.Settings.Default.Config1);
                        }
                    }
                    break;
            
            };

            if (config.Column != 0)
            {
                cbResolutions.Text = config.Resolution;


                DrawingVisual v = new DrawingVisual();

                DrawLinesSolid2(v, config.Column, config.Row);

                DrawingVisual v2 = new DrawingVisual();
                DrawLinesDash2(v2, config.Column, config.Row);
            }
            else
            {
                cbResolutions.Text = config.Resolution;


                DrawingVisual v = new DrawingVisual();

                DrawLinesSolid2(v, 1, 1);

                DrawingVisual v2 = new DrawingVisual();
                DrawLinesDash2(v2, 1, 1);
            }

            GetFactorsXY(cbResolutions.Text);

        }


      /*  private void cbResolutions_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if ((workspace != null) && (cbResolutions.SelectedIndex != -1))
            {
                GetFactorsXY(cbResolutions.Text);
            }
            config.Resolution = cbResolutions.Text;
            
      
        }*/


        //com port opening
        private void btCom_Click(object sender, RoutedEventArgs e)
        {
            if (connection.serialP.PortName != "\"\"")
            {
                if (!connection.serialP.IsOpen)
                {
                    connection.serialP.Open();
                    MessageBox.Show("COM Port Opened!!!");
                    ComConnect = true;

                    BitmapImage bi = new BitmapImage();
                    bi.BeginInit();
                    bi.UriSource = new Uri("\\Components\\Images\\001_l2.PNG", UriKind.Relative);
                    bi.EndInit();
                    imgCom.Source = bi;

                    //  btCom.Style = (Style)FindResource("ButtonCOMStyle2");

                    if (LanConnect == true)
                    {
                        thread.Abort();
                        thread.Join(200);
                        MySocket.socket.Shutdown(SocketShutdown.Both);
                        MySocket.socket.Close();
                        LanConnect = false;

                        //  imgCom.Source = null;

                        BitmapImage bi2 = new BitmapImage();
                        bi2.BeginInit();
                        bi2.UriSource = new Uri("\\Components\\Images\\002.PNG", UriKind.Relative);
                        bi2.EndInit();
                        imgLan.Source = bi2;
                        labNet.Margin = new Thickness(0, -4, 0, 0);
                        //  btNet.Style = (Style)FindResource("ButtonStyle");

                    }
                };

            }
        }


        Display2 currentDisplay;

        private void TreeV_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
        {
            string selstr = "";
            var sel = TreeV.SelectedValue;
            var selin = TreeV.SelectedItem;
            if (sel is Label)
             {
                selstr = (sel as Label).Content.ToString();
              
                for (int i = 0; i < tviMachine.Items.Count; i++)
                {
                    if (tviMachine.Items[i] != TreeV.SelectedValue)
                    {
                        (tviMachine.Items[i] as Label).Background = Brushes.White;
                       
                    }
                    else
                    {
                        (tviMachine.Items[i] as Label).Background = new SolidColorBrush(Color.FromArgb(255, 6, 183, 216));
                        
                    }
                }
            }
            else if (sel is TreeViewItem)
            {
                selstr = "HDMI-1";
            }
            string[] ss = selstr.Split('-');
            int nc = int.Parse(ss[1]);
            start_chanal = nc;
            config.StartChanel = nc;

            if (workspace.Children.Count > 0)
            {
                for (int i = 0; i <= workspace.Children.Count; i++)
                {
                    if (workspace.Children[i] is Display2)
                    {
                        currentDisplay = (Display2)workspace.Children[i];
                        break;
                    }
                }

            }
           
        }


        //off and closing com port
        private void btDisconnect_Click(object sender, RoutedEventArgs e)
        {

            // connection.CloseCom();
            if (connection.serialP.IsOpen)
            {
                connection.serialP.Close();
                ComConnect = false;
               
              //  btCom.Style = (Style)FindResource("ButtonStyle");
                BitmapImage bi2 = new BitmapImage();
                bi2.BeginInit();
                bi2.UriSource = new Uri("\\Components\\Images\\001.PNG", UriKind.Relative);
                bi2.EndInit();
                imgCom.Source = bi2;      
            };

            if (LanConnect)
            {
                thread.Abort();
                thread.Join(200);
                MySocket.socket.Shutdown(SocketShutdown.Both);
                MySocket.socket.Close();
                LanConnect = false;

                // btNet.Style = btStyle;
             //   btNet.Style = (Style)FindResource("ButtonStyle");
                BitmapImage bi = new BitmapImage();
                bi.BeginInit();
                bi.UriSource = new Uri("\\Components\\Images\\002.PNG", UriKind.Relative);
                bi.EndInit();
                imgLan.Source = bi;

            }
            //   btDisconnect.Style = (Style)FindResource("ButtonStyle2");

        }

        private void btnClear_Click(object sender, RoutedEventArgs e)
        {
          
        }
        //connect to net
        private void btNet_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                MySocket.ieps = new IPEndPoint(IPAddress.Parse(Properties.Settings.Default.IPAdress), Properties.Settings.Default.IPPort);
                MySocket.socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

                MySocket.socket.Connect(MySocket.ieps);
                MessageBox.Show("Lan connection opened!!!");
             

                if (!LanConnect)
                {
                    LanConnect = true;
                   
                   // btNet.Style = (Style)FindResource("ButtonStyle2");
                    BitmapImage bi = new BitmapImage();
                    bi.BeginInit();
                    bi.UriSource = new Uri("\\Components\\Images\\002_r3.PNG", UriKind.Relative);
                    bi.EndInit();
                    imgLan.Source = bi;
                    labNet.Margin = new Thickness(0, -7, 0, 0);
                    if (ComConnect)
                    {
                        connection.serialP.Close();
                        ComConnect = false;
                      //  btCom.Style = (Style)FindResource("ButtonStyle");
                        BitmapImage bi2 = new BitmapImage();
                        bi2.BeginInit();
                        bi2.UriSource = new Uri("\\Components\\Images\\001.PNG", UriKind.Relative);
                        bi2.EndInit();
                        imgCom.Source = bi2;   
                    }
                }
                //   btDisconnect.Style = (Style)FindResource("ButtonStyle");

            }
            catch (Exception ex)
            {
                MessageBox.Show("Lan connection error!!!/nEerror string " + ex.ToString(), "LAN error", MessageBoxButton.OK, MessageBoxImage.Error);

            }
            //string message = "Test";
            // byte[] msg = Encoding.ASCII.GetBytes(message);

            //  MySocket.socket.Send(msg);


        }
          
        //show form for change input
        private void btnInput_Click(object sender, RoutedEventArgs e)
        {
            winInputSettings = new InputSettings(winm);
            winInputSettings.ShowDialog();
        }

        //Processing mouse movements over logo
        private void btSource_MouseEnter(object sender, MouseEventArgs e)
        {
            Button btn = sender as Button;
            Image img = new Image();
            Uri uri = new Uri("pack://application:,,,/Components/Images/logosmartavi-hover.png");
            BitmapImage bitmap = new BitmapImage(uri);
            img.Source = bitmap;
            btn.Content = img;
            img.Width = 163;
            img.Height = 28;
        }

      
        private void btSource_MouseLeave(object sender, MouseEventArgs e)
        {
            Button btn = sender as Button;
            Image img = new Image();
            Uri uri = new Uri("pack://application:,,,/Components/Images/logosmartavi.png");
            BitmapImage bitmap = new BitmapImage(uri);
            img.Source = bitmap;
            btn.Content = img;
            img.Width = 163;
            img.Height = 28;
        }


        private void btSource_Click_1(object sender, RoutedEventArgs e)
        {
            System.Diagnostics.Process.Start("http://www.smartavi.com/");
        }

     /*   private void btMonitor_Click(object sender, RoutedEventArgs e)
        {
          
            PortCom.Show();
          
        }*/

        //saving layouts
        private void btSaveLayer_Click(object sender, RoutedEventArgs e)
        {
            int col = config.Column;
            int row = config.Row;
            string serialize_disp;
            InputBox inpBox = new InputBox(this);

            if (inpBox.ShowDialog() == true)
            {

                int num = 0;
                lstSerialData11 = new List<string>();
                foreach (UIElement el in workspace.Children)
                {
                    if (el is Display2)
                    {
                        num++;
                        double x0 = Canvas.GetLeft(el) * FactorX;
                        double y0 = Canvas.GetTop(el) * FactorY;
                        double x1 = x0 + (el as Display2).Width * FactorX;
                        double y1 = y0 + (el as Display2).Height * FactorY;
                        int cur_num = (el as Display2).CurNum;
                        int cur_id = (el as Display2).CurID;
                        int chanel = int.Parse((el as Display2).lbMachine.Content.ToString());

                        SerializeLayer lay = new SerializeLayer();
                        lay.Number = num;
                        lay.X0 = x0;
                        lay.Y0 = y0;
                        lay.X1 = x1;
                        lay.Y1 = y1;
                        lay.CurID = cur_id;
                        lay.CurNum = cur_num;
                        lay.Input = chanel;
                        lay.FactX = FactorX;
                        lay.FactY = FactorY;

                        serialize_disp = SerializeLayer.ToJson(lay);
                        //список окон в текущем слое
                        lstSerialData11.Add(serialize_disp);


                    }
                }
                //List -> JSON
                String json_str;
                var serializer = new DataContractJsonSerializer(typeof(List<string>));
                ListLayers lst_lay = new ListLayers();

                using (var memoryStream = new MemoryStream())
                {
                    serializer.WriteObject(memoryStream, lstSerialData11);
                    json_str = Encoding.UTF8.GetString(memoryStream.ToArray(), 0, (int)memoryStream.Length);
                    
                    lst_lay.json_str = json_str;
                    string str = "a"+inpBox.txt.Text;
                    string pattern = @"[^a-zA-Z0-9]";
                    Regex rgx = new Regex(pattern);
                    string result = rgx.Replace(str, "_");

                    lst_lay.layer_name = result;
                 //   lst_lay.layer_name = "a"+inpBox.txt.Text;

                }

                string list_radiobt = ListLayers.ToJson(lst_lay);

                if (!listLayers.Contains(list_radiobt))
                {
                    listLayers.Add(list_radiobt);
                }
              

                String layers_jsstr;

                var serial_layers = new DataContractJsonSerializer(typeof(List<string>));
                using (var memstrm = new MemoryStream())
                {
                    serial_layers.WriteObject(memstrm, listLayers);
                    layers_jsstr = Encoding.UTF8.GetString(memstrm.ToArray(), 0, (int)memstrm.Length);
                }

                string myconf = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
                using(StreamWriter outfile = new StreamWriter(myconf + @"\Layouts.config"))
                {
                    outfile.WriteLine(layers_jsstr);
                }

            //    Properties.Settings.Default.Layers = layers_jsstr;

            //    Properties.Settings.Default.Save();
                lstSerialData11.Clear();
                MessageBox.Show("Layout saved!", "Save Layout", MessageBoxButton.OK, MessageBoxImage.Information);

                string layers_list;

                using(StreamReader sr = new StreamReader(myconf + @"\Layouts.config"))
                {
                    layers_list = sr.ReadToEnd();
                }

              //  string layers_list = Properties.Settings.Default.Layers;
                if ((layers_list != "") && (layers_list != "\"\""))
                {
                    var serial_list = new DataContractJsonSerializer(typeof(List<string>));
                    using (var memstr = new MemoryStream(Encoding.Unicode.GetBytes(layers_list)))
                    {
                        listLayers = serial_list.ReadObject(memstr) as List<string>;
                    }
                }

                RadioPanel.Children.Clear();
                ListLayers myclass = new ListLayers();
           /*     foreach (string s in listLayers)
                {
                    myclass = ListLayers.FromJson(s);

                }*/
                            

                if (listLayers.Count > 0)
                {
                    for (int i = 0; i < listLayers.Count; i++)
                    {
                        if (i == (listLayers.Count - 1))
                        {
                            RadioButton rb = new RadioButton();
                            myclass = ListLayers.FromJson(listLayers[i]);
                          //  rb.Content = "Layer " + i.ToString();
                            rb.Content = myclass.layer_name.Remove(0,1);
                            rb.Style = (Style)Application.Current.Resources["RadioButtonStyle"];
                            rb.Name = "rb" + i.ToString();
                            rb.Tag = i;
                            rb.Checked += new RoutedEventHandler(rb_checked);

                            rbmas.Add(rb);

                        }
                    }



                    foreach (RadioButton r in rbmas)
                    {
                        RadioPanel.Children.Add(r);
                    }

                }
            }
            else
            {

            }

        }


        //delete layouts
        private void btDelleteLayer_Click(object sender, RoutedEventArgs e)
        {
        
            lstSerialData = new List<string>();
           // int sel_l = 0;
            int ind = 0;
            foreach (RadioButton rb in rbmas)
            {
                
                if ((rb != null) && (rb.IsChecked == true))
                {
                 //   sel_l = (int)rb.Tag;
                 
                    RadioPanel.Children.Remove(rb);
                    ind = rbmas.IndexOf(rb);
                   
                }
            }
         
            listLayers.RemoveAt(ind);
            rbmas.RemoveAt(ind);
            
            string layers_jsstr;

            var serial_layers = new DataContractJsonSerializer(typeof(List<string>));
            using (var memstrm = new MemoryStream())
            {
                serial_layers.WriteObject(memstrm, listLayers);
                layers_jsstr = Encoding.UTF8.GetString(memstrm.ToArray(), 0, (int)memstrm.Length);
            }

            string myconf = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
            using (StreamWriter outfile = new StreamWriter(myconf + @"\Layouts.config"))
            {
                outfile.WriteLine(layers_jsstr);
            }
            
            //Properties.Settings.Default.Layers = layers_jsstr;

           // Properties.Settings.Default.Save();
            MessageBox.Show("Layout deleted!", "Delete Layout", MessageBoxButton.OK, MessageBoxImage.Information);
        }

       
        private void txtDelay_TextChanged(object sender, TextChangedEventArgs e)
        {
          //  GlobalDelay = int.Parse(txtDelay.Text);
        }

        //md5 encryption strings
        public string GetHashString(string s)
        {
            byte[] bytes = Encoding.Unicode.GetBytes(s);

            MD5CryptoServiceProvider CSP = new MD5CryptoServiceProvider();

            byte[] byteHash = CSP.ComputeHash(bytes);

            string hash = string.Empty;

            foreach (byte b in byteHash)
            {
                hash += string.Format("{0:x2}", b);
            }

            return hash;
        }

        // user registration form show
        private void btUser_Click(object sender, RoutedEventArgs e)
        {
          RegisterUser frmRegisterUser = new RegisterUser(this);

          frmRegisterUser.ShowDialog();
           
        }

        //shceduler form show
        private void btSheduler_Click(object sender, RoutedEventArgs e)
        {
            SchedulerFrm scheduler = new SchedulerFrm(this);
            scheduler.ShowDialog();
        }

        //checked on radiobotton layout on its name
     public void ChekedRB(string name)
     {
         var sel_rb = RadioPanel.Children.OfType<RadioButton>().FirstOrDefault(rb => rb.Name == name);
         if (sel_rb != null)
         {
             (sel_rb as RadioButton).IsChecked = true;
         }
     }
     //checked off radiobotton layout on its name
     private void UnChekedRB(string name)
     {
         var sel_rb = RadioPanel.Children.OfType<RadioButton>().FirstOrDefault(rb => rb.Name == name);
         (sel_rb as RadioButton).IsChecked = false;
        
     }

     private void btExportLayer_Click(object sender, RoutedEventArgs e)
     {
         
         if(listCmdCreateComplete == true)
         {
             int i = lstCreateWin.Count;
             string[] arr = new string[i];

             lstCreateWin.CopyTo(arr);

             SaveFileDialog dialog = new SaveFileDialog()
             {
                 Filter = "Text Files(*.txt)|*.txt|All(*.*)|*"
             };
             if(dialog.ShowDialog() == true)
             {
                 File.WriteAllLines(dialog.FileName, arr);

             }
             listCmdCreateComplete = false;
         }
     }

    

    }
 
   
}