using UnityEngine;
using System.Globalization;
using UnityEngine.UI;
using System.Collections.Generic;

public class DOIT : MonoBehaviour
{
    public static bool Mousecheck()
    {
        bool mouseTF = false;
#if UNITY_EDITOR
        if (Input.mousePosition.x > 100 && Input.mousePosition.y > 60 && Input.mousePosition.x <= 860 && Input.mousePosition.y <= 385) { mouseTF = true; }
#else
        if (Input.mousePosition.x <= Screen.width*100/960 && Input.mousePosition.y <= Screen.height*60/460 && Input.mousePosition.x >= Screen.width - Screen.width*100/960 && Input.mousePosition.y >= Screen.height - Screen.height*75/460) {mouseTF = true;} 
#endif
        //print("X=====" + Input.mousePosition.x + "    Y==" + Input.mousePosition.y);
        return mouseTF;
    }
    public static void DELETEAllChild(string P)
    {
        foreach (Transform obj in GameObject.Find(P).gameObject.transform)
        {
            obj.gameObject.SetActive(true);
        }

        GameObject PAPA = GameObject.Find(P).gameObject;

        for (int i = PAPA.transform.childCount - 1; i >= 0; i--)
        {
            GameObject.DestroyImmediate(PAPA.transform.GetChild(i).gameObject);
        }
    }
    public static void ResetRoomSelect()
    {
        Material MAT = Resources.Load("MATERIALS/SHADEWALL") as Material;
        if (GameObject.Find("m1")) GameObject.Find("m1").GetComponent<MeshRenderer>().material = MAT;
        if (GameObject.Find("m2")) GameObject.Find("m2").GetComponent<MeshRenderer>().material = MAT;
        if (GameObject.Find("m3")) GameObject.Find("m3").GetComponent<MeshRenderer>().material = MAT;
        if (GameObject.Find("m4")) GameObject.Find("m4").GetComponent<MeshRenderer>().material = MAT;
        if (GameObject.Find("m5")) GameObject.Find("m5").GetComponent<MeshRenderer>().material = MAT;
        if (GameObject.Find("m6")) GameObject.Find("m6").GetComponent<MeshRenderer>().material = MAT;
        if (GameObject.Find("sceil")) GameObject.Find("sceil").GetComponent<MeshRenderer>().material = MAT;
        if (GameObject.Find("sfloor")) GameObject.Find("sfloor").GetComponent<MeshRenderer>().material = MAT;
        //PAINT.SEL = "";
    }

    public static void CloseALLPNL()
    {
        GameObject[] pnl;
        pnl = GameObject.FindGameObjectsWithTag("pnl");
        foreach (GameObject p in pnl) { p.gameObject.SetActive(false); }

        GameObject[] menu;
        menu = GameObject.FindGameObjectsWithTag("menu");
        foreach (GameObject m in menu) { m.gameObject.SetActive(false); }

        if (GameObject.Find("SAVEWEBpnl")) GameObject.Find("SAVEWEBpnl").transform.GetComponent<CanvasGroup>().alpha = 1;
        if (GameObject.Find("LOADpnl")) GameObject.Find("LOADpnl").transform.GetComponent<CanvasGroup>().alpha = 1;

        _G.SELECTED = "";
    }
    public static void CloseALLPNLONLY()
    {
        GameObject[] pnl;
        pnl = GameObject.FindGameObjectsWithTag("pnl");
        foreach (GameObject p in pnl) { p.gameObject.SetActive(false); }

        GameObject[] menu;
        menu = GameObject.FindGameObjectsWithTag("menu");
        foreach (GameObject m in menu) { m.gameObject.SetActive(false); }

        if (GameObject.Find("SAVEWEBpnl")) GameObject.Find("SAVEWEBpnl").transform.GetComponent<CanvasGroup>().alpha = 1;
        if (GameObject.Find("LOADpnl")) GameObject.Find("LOADpnl").transform.GetComponent<CanvasGroup>().alpha = 1;
    }
    public static void CloseALLMenu()
    {
        GameObject[] pnl;
        pnl = GameObject.FindGameObjectsWithTag("menu");
        foreach (GameObject p in pnl) { p.gameObject.SetActive(false); }
    }
    public static void disableActionsDropdown()
    {
        GameObject.Find("HIDER").transform.Find("SELECT").gameObject.SetActive(false);
    }

    public static void AllTogchildfalse(GameObject O)
    {
        for (int i = 0; i < O.transform.childCount; i++)
        {
            O.transform.GetChild(i).GetComponent<Toggle>().isOn = false;
        }
    }
    public static void AllChildOff(GameObject O)
    {
        for (int i = 0; i < O.transform.childCount; i++)
        {
            O.transform.GetChild(i).gameObject.gameObject.SetActive(false);
        }
    }

    public static int getWA()//wall angle 
    {
        int ON = getint(_G.SELECTED);
        int Wallnum = int.Parse(_G.OBJs[ON][22].Substring(1, 1));
        int num = 0;
        GameObject wall = GameObject.Find("w" + Wallnum.ToString()).gameObject;
        Vector3 ANGLE = wall.transform.eulerAngles;
        num = (int)(ANGLE.y);
        return num;
    }

    public static float getPn(string p)//Position xyz of wall
    {
        int nO = getint(_G.SELECTED);
        int Wallnum = int.Parse(_G.OBJs[nO][22].Substring(1, 1));
        float num = 0;
        GameObject wall = GameObject.Find("w" + Wallnum.ToString()).gameObject;
        Vector3 pos = wall.transform.position;
        if (p == "x") num = pos.x;
        if (p == "y") num = pos.y;
        if (p == "z") num = pos.z;
        return num;
    }

    public static float getScenePos(string v, float w, float h, float d, float os)
    {
        float px = 0;
        float pz = 0;
        float ry = 0;
        float osx = 0;
        float osz = 0;

        if (_G.WallSELECTED == "floor") { px = 0; pz = 0; ry = 0; }

        if (_G.WallSELECTED.Substring(0, 1) == "w")
        {
            int wn = int.Parse(_G.WallSELECTED.Substring(1, _G.WallSELECTED.Length - 1));
            ry = _G.wa[wn - 1];
            if (ry == 0) { osx = 0; osz = -os; }
            if (ry == 45) { osx = -os * 0.707f; osz = -os * 0.707f; }
            if (ry == 90) { osx = -os; osz = 0; }
            if (ry == 135) { osx = -os * 0.707f; osz = +os * 0.707f; }
            if (ry == 180) { osx = 0; osz = os; }
            if (ry == 225) { osx = +os * 0.707f; osz = +os * 0.707f; }
            if (ry == 270) { osx = os; osz = 0; }
            if (ry == 315) { osx = os * 0.707f; osz = -os * 0.707f; }
            px = _G.wCP[wn - 1].x + osx;
            pz = _G.wCP[wn - 1].y + osz;
        }
        float value = 0;
        if (v == "px") value = px;
        if (v == "pz") value = pz;
        if (v == "ry") value = ry;
        return value;
    }

    public static string getColectionNamebyAbr(string str)
    {
        string N = "";
        if (str == "CO") N = "SENSATION";
        if (str == "BL") N = "FINESE";
        if (str == "EG") N = "ÉLÉGANCE";

        return N;
    }
    public static void AllTogdOff(GameObject O)
    {
        for (int i = 0; i < O.transform.childCount; i++)
        {
            O.transform.GetChild(i).GetComponent<Toggle>().isOn = false;
        }

    }

    public static int getint(string On)
    {
        int nO = int.Parse(On.Substring(4, On.Length - 4));
        return nO;
    }
    public static string getAbrCol(string str)
    {
        string c = "";
        if (str == "BROWN") c = "CO";
        if (str == "WHITE") c = "BL";
        if (str == "GRAY") c = "EG";
        return c;
    }
    public static string getCABCollectionNamebyColAbr(string CD)
    {
        string col = TRANS.This(CD);
        return col;
    }
    public static string getColorTextPNLbyDoorcab(string CD)
    {
        string num = CD.Substring(6, 1);
        string col = "TEXT10" + num + ",2,FFFFFF,r0,SG";
        return col;
    }


    public static float xfzf(string xz, int Wallnum)
    {
        float f = 1;
        float Ww = 0;
        float a = 0;

        for (int i = 1; i < _G.NW + 1; i++)
        {
            if (Wallnum == i) { Ww = _G.wW[i - 1]; a = _G.wa[i - 1]; }
        }
        //print("Wallnum==="+Wallnum);
        //print("a==="+a);
        float xf = Mathf.Cos(a * Mathf.Deg2Rad);
        float zf = Mathf.Sin(a * Mathf.Deg2Rad);

        if (xz == "x") f = xf;
        if (xz == "z") f = zf;
        if (xz == "ww") f = Ww;

        return f;
    }
    //----------------------------------------------------------------------------------------------------------------------------//
    //---------------------------------------------------------Check------------------------------------------------------------//
    //----------------------------------------------------------------------------------------------------------------------------//
    public static void NoSelection(GameObject S)
    {
        for (int i = 0; i < S.transform.childCount; i++)
        {
            S.transform.GetChild(i).transform.GetComponent<Toggle>().isOn = false;
        }
    }

    //----------------------------------------------------------------------------------------------------------------------------//
    //---------------------------------------------------------EMPTY PANEL------------------------------------------------------------//
    //----------------------------------------------------------------------------------------------------------------------------//
    public static Color GetIsColor(string S)
    {
        Color c;
        c = GameObject.Find(S).transform.GetComponent<MeshRenderer>().material.color;
        return c;
    }
    public static void btnColor()
    {
        ColorBlock theColor;

        string Ncol = _G.Color1;//"1664B5";


        GameObject[] btn = GameObject.FindGameObjectsWithTag("btn");
        foreach (GameObject obj in btn)
        {
            theColor = obj.GetComponent<Button>().colors;
            theColor.highlightedColor = DOIT.CSc("575757", 150);//00FDFF
            theColor.normalColor = DOIT.CSc(Ncol, 255);
            theColor.pressedColor = DOIT.CSc("A9A9A9", 150);
            theColor.selectedColor = DOIT.CSc("A9A9A9", 150);
            obj.GetComponent<Button>().colors = theColor;
        }
        GameObject[] btnToggle = GameObject.FindGameObjectsWithTag("btnToggle");
        foreach (GameObject obj in btnToggle)
        {
            theColor = obj.GetComponent<Toggle>().colors;
            theColor.highlightedColor = DOIT.CSc("A9A9A9", 150);
            theColor.normalColor = DOIT.CSc(Ncol, 255);
            theColor.pressedColor = DOIT.CSc("A9A9A9", 150);
            theColor.selectedColor = DOIT.CSc("A9A9A9", 150);
            theColor.disabledColor = DOIT.CSc(Ncol, 255);
            obj.GetComponent<Toggle>().colors = theColor;
        }
        GameObject[] Checkers = GameObject.FindGameObjectsWithTag("checkmark");
        foreach (GameObject obj in Checkers)
        {
            obj.GetComponent<Image>().color = DOIT.CSc("FFFFFF", 255);
        }
        GameObject[] Checkers2 = GameObject.FindGameObjectsWithTag("checkmark2");
        foreach (GameObject obj in Checkers2)
        {
            obj.GetComponent<Image>().color = DOIT.CSc(Ncol, 255);
        }

        GameObject[] Images = GameObject.FindGameObjectsWithTag("image");
        foreach (GameObject obj in Images)
        {
            obj.GetComponent<Image>().color = DOIT.CSc(_G.Color2, 255);
        }

        GameObject[] TextColor = GameObject.FindGameObjectsWithTag("textcolor");
        foreach (GameObject obj in TextColor)
        {
            obj.GetComponent<Text>().color = DOIT.CSc(Ncol, 255);
        }
    }
    public static Texture2D GetTex(string tex)
    {
        string path = "STYLE/";
        if (tex.Substring(0, 4) == "CERA") path = "TEXTURES/FINISH/";
        if (tex.Substring(0, 4) == "COUN") path = "TEXTURES/FINISH/";
        if (tex.Substring(0, 4) == "SPLA") path = "TEXTURES/FINISH/";
        if (tex.Substring(0, 4) == "WOOD") path = "TEXTURES/FINISH/";
        if (tex.Substring(0, 4) == "OGEE") path = "ICONS/OGEE/";
        if (tex.Substring(0, 4) == "UNDE") path = "ICONS/UNDER/";
        if (tex.Substring(0, 4) == "COLO") path = "TEXTURES/GENERAL/";
        tex = tex.Replace("BCAB", "TEXT");
        tex = tex.Replace("PANE", "TEXT");
        tex = tex.Replace("KICK", "TEXT");
        tex = tex.Replace("FILL", "TEXT");
        tex = tex.Replace("HEAD", "TEXT");
        Texture2D T = Resources.Load<Texture2D>(path + tex) as Texture2D;
        return T;
    }
    public static Sprite GetSprite(string tex)
    {
        string path = "STYLE/";
        Sprite T = Resources.Load<Sprite>(path + tex) as Sprite;
        return T;
    }
    public static void setPosObj(string Oname)
    {
        int nO = getint(Oname);
        GameObject Obj = GameObject.Find(Oname).gameObject;
        Vector3 Pos = Obj.transform.position;
        _G.OBJs[nO][15] = (Pos.x).ToString();
        _G.OBJs[nO][16] = (Pos.y).ToString();
        _G.OBJs[nO][17] = (Pos.z).ToString();
    }

    //----------------------------------------------------------------------------------------------------------------------------//
    //---------------------------------------------------------CONVERT------------------------------------------------------------//
    //----------------------------------------------------------------------------------------------------------------------------//
    public static string CNs(float M)//Convert number to string
    {
        string q = "0";
        if (_G.System == 1)
        {
            float Q;
            Q = M - Mathf.Floor(M);
            if (Q >= 0) { q = " ''"; }
            if (Q >= 0.062) { q = " 1/16''"; }
            if (Q >= 0.125) { q = " 1/8''"; }
            if (Q >= 0.187) { q = " 3/16''"; }
            if (Q >= 0.25) { q = " 1/4''"; }
            if (Q >= 0.312) { q = " 5/16''"; }
            if (Q >= 0.375) { q = " 3/8''"; }
            if (Q >= 0.437) { q = " 7/16''"; }
            if (Q >= 0.5) { q = " 1/2''"; }
            if (Q >= 0.562) { q = " 9/16''"; }
            if (Q >= 0.620) { q = " 5/8''"; }
            if (Q >= 0.687) { q = " 11/16''"; }
            if (Q >= 0.75) { q = " 3/4''"; }
            if (Q >= 0.812) { q = " 13/16''"; }
            if (Q >= 0.875) { q = " 7/8''"; }
            if (Q >= 0.925) { q = " 15/16''"; }
            if (Q >= 0.967) { q = " ''"; M += 1; }
            q = Mathf.Floor(M).ToString() + q;
        }
        else q = (Mathf.Floor(M * 2.54f * 10) / 10).ToString() + " cm";
        return q;
    }
    public static string CSs(string M)//Convert string to string
    {
        string q = M.Replace("''", "");
        q = q.Replace("cm", "");
        q = q.Replace(" ", "");
        return q;
    }

    public static string CSssys(string M)//Convert string to string
    {
        float mf = float.Parse(M);
        if (_G.System == 2)
        {
            mf = Mathf.Floor(mf * 2.54f);
            mf = (mf / 2.54f * 100) / 100;
        }
        M = mf.ToString();
        return M;
    }
    public static float CSn(string M)//Convert string to number
    {
        if (M == "") M = "0";
        float newM = 0;
        float newMcm = 0;
        int num = M.Length;
        if (M.Length > 10) M = M.Substring(0, 9);
        if (M.IndexOf("E") != -1) M = M.Substring(0, 4);
        M = M.Replace("''", "");
        M = M.Replace("'", "");
        M = M.Replace(" ", "");
        if (M.IndexOf("cm") != -1) { M = M.Replace("cm", ""); newMcm = float.Parse(M) / 2.54f; }

        if (_G.System == 1)
        {
            float add = 0;
            if (M.IndexOf("11/16") != -1) { M = M.Replace("11/16", ""); add = 0.6875f; }
            if (M.IndexOf("13/16") != -1) { M = M.Replace("13/16", ""); add = 0.8125f; }
            if (M.IndexOf("15/16") != -1) { M = M.Replace("15/16", ""); add = 0.9375f; }
            if (M.IndexOf("1/16") != -1) { M = M.Replace("1/16", ""); add = 0.0625f; }
            if (M.IndexOf("1/8") != -1) { M = M.Replace("1/8", ""); add = 0.125f; }
            if (M.IndexOf("3/16") != -1) { M = M.Replace("3/16", ""); add = 0.1875f; }
            if (M.IndexOf("1/4") != -1) { M = M.Replace("1/4", ""); add = 0.25f; }
            if (M.IndexOf("5/16") != -1) { M = M.Replace("5/16", ""); add = 0.3125f; }
            if (M.IndexOf("3/8") != -1) { M = M.Replace("3/8", ""); add = 0.375f; }
            if (M.IndexOf("7/16") != -1) { M = M.Replace("7/16", ""); add = 0.4375f; }
            if (M.IndexOf("1/2") != -1) { M = M.Replace("1/2", ""); add = 0.5f; }
            if (M.IndexOf("9/16") != -1) { M = M.Replace("9/16", ""); add = 0.5625f; }
            if (M.IndexOf("5/8") != -1) { M = M.Replace("5/8", ""); add = 0.625f; }
            if (M.IndexOf("3/4") != -1) { M = M.Replace("3/4", ""); add = 0.75f; }
            if (M.IndexOf("7/8") != -1) { M = M.Replace("7/8", ""); add = 0.875f; }
            if (M.IndexOf(" ''") != -1) { M = M.Replace(" ''", ""); add = 0; }
            if (M.IndexOf(" ''") != -1) { M = M.Replace(" ", ""); add = 0; }
            if (M.IndexOf("''") != -1) { M = M.Replace("''", ""); add = 0; }
            newM = float.Parse(M) + add;
            newM = Mathf.Round(newM * 10000) / 10000;
            newM = Grid.addGrid(newM);
        }
        if (_G.System == 2)
        {
            newM = float.Parse(M);
            if (newMcm != 0) newM = newMcm;
        }
        return newM;
    }//Fin	
    public static Color CSc(string C, byte a)//Convert string to color
    {
        byte r = byte.Parse(C.Substring(0, 2), NumberStyles.HexNumber);
        byte g = byte.Parse(C.Substring(2, 2), NumberStyles.HexNumber);
        byte b = byte.Parse(C.Substring(4, 2), NumberStyles.HexNumber);
        Color col = new Color32(r, g, b, a);
        return col;
    }
    public static Color CScf(string C)//Convert string to color
    {
        byte r = byte.Parse(C.Substring(0, 2), NumberStyles.HexNumber);
        byte g = byte.Parse(C.Substring(2, 2), NumberStyles.HexNumber);
        byte b = byte.Parse(C.Substring(4, 2), NumberStyles.HexNumber);
        Color col = new Color32(r, g, b, 50);
        return col;
    }
    public static void ColorModel(string col)
    {
        Color C = DOIT.CSc(col, 210);
        GameObject MODEL = GameObject.Find("MODEL").gameObject;
        foreach (Transform child in MODEL.transform)
        {
            child.transform.Find("Background").gameObject.GetComponent<Image>().color = C;
        }
    }


    public static void AddtoCodeSplashGlobal(int k, string str)
    {
        //print("str===" + str);
        GameObject[] Splash = GameObject.FindGameObjectsWithTag("splash");
        foreach (GameObject child in Splash)
        {
            int nO = getint(child.transform.parent.name);
            if (_G.OBJs[nO][0] != "null") _G.OBJs[nO][k] = str;
        }

    }
    public static void AddtoCodePNLGlobal(int k, string str)
    {
        for (var i = 0; i < _G.OBJnum + 1; i++)
        {
            if (_G.OBJs[i] != null)
            {
                if (_G.OBJs[i][2] == "Panel" && _G.OBJs[i][60] == "GLOBAL" && _G.OBJs[i][0] != "null")
                {
                    _G.OBJs[i][k] = str;
                }
            }
        }

    }

    //TEXTURE
    public static Texture2D Rotate(Texture2D image)
    {
        Texture2D Tex2D = new Texture2D(image.height, image.width);
        for (int y = 0; y < image.height; ++y)
        {
            for (int x = 0; x < image.width; ++x)
            {
                Tex2D.SetPixel(y, image.width - 1 - x, image.GetPixel(x, y));
            }
        }
        Tex2D.Apply();
        return Tex2D;
    }
    public static void SPLITcol(int nO, int n, string col)
    {
        string[] C = _G.OBJs[nO][n].Split(","[0]);
        C[2] = col;
        _G.OBJs[nO][n] = C[0] + "," + C[1] + "," + C[2] + "," + C[3] + "," + C[4];
    }
    public static bool exist(int i)
    {
        bool e = false;
        if (_G.OBJs[i] != null)
        {
            if (_G.OBJs[i][0] != "null")
            {
                //print("name===" + _G.OBJs[i][0]);
                if (GameObject.Find(_G.OBJs[i][0]))
                {
                    if (GameObject.Find(_G.OBJs[i][0]).gameObject.activeSelf == true) e = true;
                }
            }
        }
        return e;
    }

    public static float GetRn(string r)
    {
        float R = 0;
        if (r == "r0") R = 0;
        if (r == "r45") R = 45;
        if (r == "r9") R = 90;
        return R;
    }


    public static float ConvertStringToNumber(string M)
    {
        if (M.Contains("E")) { M = "0"; }

        //print("M===="+M);
        //4 1/2
        //4.5
        //41/2
        //4.5"
        //4.5 "
        //4.5cm
        //4.5 cm
        //4e...


        if (string.IsNullOrWhiteSpace(M) || M.Equals("none", StringComparison.OrdinalIgnoreCase))
        {
            //Debug.Log(M + " value. Value is set to 0.");
            return 0f;
        }

        if (M.Length > 10) M = M[..9];
        if (M.IndexOf("E") != -1) M = M[..4];

        float add = 0;
        Dictionary<string, float> fractions = new()
            {
                { "15/16", 0.9375f },
                { "13/16", 0.8125f },
                { "11/16", 0.6875f },
                { "7/8", 0.875f },
                { "3/4", 0.75f },
                { "5/8", 0.625f },
                { "9/16", 0.5625f },
                { "1/2", 0.5f },
                { "7/16", 0.4375f },
                { "3/8", 0.375f },
                { "5/16", 0.3125f },
                { "1/4", 0.25f },
                { "3/16", 0.1875f },
                { "1/8", 0.125f },
                { "1/16", 0.0625f },
                { " ''", 0 },
                { " ", 0 },
                { "''", 0 }
            };

        // Check for fractions in the input and update the fraction adder.
        foreach (var fraction in fractions)
        {
            if (M.IndexOf(fraction.Key) != -1)
            {
                M = M.Replace(fraction.Key, "");
                add = fraction.Value;
                break;
            }
        }
        M = M.Replace((char)8203, '\0');

        if (M.IndexOf("cm") != -1)
        {
            M = M.Replace("cm", "");
            float centimeters = float.Parse(M);
            return centimeters / 2.54f;
        }

        float newM = 0;
        // else check for inch conversion
        M = M.Replace("''", "");
        M = M.Replace("'", "");
        M = M.Replace(" ", "_");
        float fact = 1;
        if (M.IndexOf("-") != -1) { fact = -1; }
        M = M.Replace("-", "");

        string Entity = M;
        if (M.IndexOf("_") != -1)
        {
            string[] split = M.Split('_');
            Entity = split[0];

            M = split[1];
        }

        //print("Entity===="+Entity);
        if (string.IsNullOrEmpty(Entity)) Entity = "0";

        newM = float.Parse(Entity, System.Globalization.NumberStyles.Float) + add;
        //newM = float.Parse(M, System.Globalization.NumberStyles.Float) + add;
        newM = (Mathf.Round(newM * 10000) / 10000) * fact;

        return newM;
    }
    public static float TryConvertStringToNumber(string M, out int system)
    {
        if (M.Contains("\'") || M.Contains("\""))
        {
            system = 1;
        }
        else if (M.Contains("cm"))
        {
            system = 2;
        }
        else // invalid system
        {
            system = 0;
        }

        return ConvertStringToNumber(M);
    }
        public static string ConvertNumberToString(float number)
    {
        string str=number.ToString("G");
        if (str.Contains("E")){number = 0;}

        string q = "0";
        if (_G.System == 1)
        {
            float Q = number - Mathf.Floor(number);
            if (Q >= 0) { q = " ''"; }
            if (Q >= 0.062) { q = " 1/16''"; }
            if (Q >= 0.125) { q = " 1/8''"; }
            if (Q >= 0.187) { q = " 3/16''"; }
            if (Q >= 0.220) { q = " 1/4''"; }
            if (Q >= 0.312) { q = " 5/16''"; }
            if (Q >= 0.370) { q = " 3/8''"; }
            if (Q >= 0.400) { q = " 7/16''"; }
            if (Q >= 0.475) { q = " 1/2''"; }
            if (Q >= 0.562) { q = " 9/16''"; }
            if (Q >= 0.620) { q = " 5/8''"; }
            if (Q >= 0.687) { q = " 11/16''"; }
            if (Q >= 0.725) { q = " 3/4''"; }
            if (Q >= 0.812) { q = " 13/16''"; }
            if (Q >= 0.875) { q = " 7/8''"; }
            if (Q >= 0.925) { q = " 15/16''"; }
            if (Q >= 0.967) { q = " ''"; number += 1; }

            q = Mathf.Floor(number).ToString() + q.ToString();
        }
        else
        {
            number = Mathf.Round(number * 2.54f * 100) / 100;
            q = number.ToString("F2") + " cm";
        }
        return q;
    }
 
    // public static void SaveObjectPositionInData(string Oname)
    // {
    //     if (string.IsNullOrEmpty(Oname))
    //     {
    //         Debug.LogError("object name is null or empty and should not");
    //         return;
    //     }

    //     SaveObjectPositionInData(SceneModeManager.GetObjectInScene(Oname));
    // }
    public static void SaveObjectPositionInData(GameObject obj)
    {
        if (obj == null)
        {
            Debug.LogError("object is null and should not");
            return;
        }

        SaveObjectPositionInData(obj.transform);
    }
    public static void SaveObjectPositionInData(Transform obj)
    {
        if (obj == null)
        {
            Debug.Log("No Selected On SetPosObj for " + obj);
            return;
        }

        int nO = Get.GetObjectIndex(obj.name);
        Vector3 Pos = obj.position;
        Vector3 A = obj.eulerAngles;

        _G.OBJs[nO][15] = (Pos.x).ToString();
        _G.OBJs[nO][16] = (Pos.y).ToString();
        _G.OBJs[nO][17] = (Pos.z).ToString();

        _G.OBJs[nO][18] = Mathf.Round(A.x).ToString();
        _G.OBJs[nO][19] = Mathf.Round(A.y).ToString();
        _G.OBJs[nO][20] = Mathf.Round(A.z).ToString();
    }
    static public Vector3 GetObjectPositionFromData(string objectName)
    {
        int nO = Get.GetObjectIndex(objectName);
        float x = ConvertStringToNumber(_G.OBJs[nO][15]);
        float y = ConvertStringToNumber(_G.OBJs[nO][16]);
        float z = ConvertStringToNumber(_G.OBJs[nO][17]);

        return new Vector3(x, y, z);
    }
    static public Vector3 GetPosObj(string Oname)
    {
        int nO = Get.GetObjectIndex(Oname);
        float x = ConvertStringToNumber(_G.OBJs[nO][15]);
        float y = ConvertStringToNumber(_G.OBJs[nO][16]);
        float z = ConvertStringToNumber(_G.OBJs[nO][17]);
        return new Vector3(x, y, z);
    }
    
 
}