User-driven applications

using System;
using System .Collections .Generic;
using System .Drawing;
using System .Windows .Forms;
using Microsoft .Win32;

using MoveGraphLibrary;

namespace UserDrivenApplications
{
    public enum FuncAuthor { Developer, User };

    public class FunctionDesigned
    {
        int version = 605;
        long id;
        string name;
        FuncAuthor origin;
        int iPredefined;                    // only for origin = FuncOrigin.FromDesigner
        double fX_L, fX_R, fY_T, fY_B;
        double fFrom, fTo, fStep;
        string str_Y;       // for Y(x) or Y(r)
        string str_X;       // used only for X(r)
        MSPlot msplot;
        List<Elem> Polish_Y = new List<Elem> ();
        List<Elem> Polish_X = new List<Elem> ();

        // -------------------------------------------------        constructor for Predefined functions
        public FunctionDesigned (string nm, int iNum, double xL, double xR, double yT, double yB)
        {
            id = Auxi_Common .UniqueID;
            name = CheckedName (nm);
            origin = FuncAuthor .Developer;
            iPredefined = iNum;
            fX_L = xL;
            fX_R = xR;
            fY_T = yT;
            fY_B = yB;
            str_X = "";
            str_Y = "";
            msplot = null;
        }
        // -------------------------------------------------        constructor for New functions Y(x)
        public FunctionDesigned (string nm, string strY, List<Elem> polishY, double xL, double xR, double yT, double yB)
        {
            id = Auxi_Common .UniqueID;
            name = CheckedName (nm);
            origin = FuncAuthor .User;
            iPredefined = -1;
            fX_L = xL;
            fX_R = xR;
            fY_T = yT;
            fY_B = yB;
            str_X = "";
            str_Y = strY;
            Polish_Y = polishY;
            msplot = null;
        }
        // -------------------------------------------------        constructor for New functions {X(r), Y(r)}
        public FunctionDesigned (string nm, string strX, string strY, List<Elem> polishX, List<Elem> polishY,
                               double xL, double xR, double yT, double yB, double from, double to, double step)
        {
            id = Auxi_Common .UniqueID;
            name = CheckedName (nm);
            origin = FuncAuthor .User;
            iPredefined = -1;
            fX_L = xL;
            fX_R = xR;
            fY_T = yT;
            fY_B = yB;
            fFrom = from;
            fTo = to;
            fStep = step;
            str_X = strX;
            str_Y = strY;
            Polish_X = polishX;
            Polish_Y = polishY;
            msplot = null;
        }
        // -------------------------------------------------        CheckedName
        public string CheckedName (string nm)
        {
            if (!string .IsNullOrEmpty (nm))
            {
                return (nm);
            }
            else
            {
                return ("No name");
            }
        }
        // -------------------------------------------------        ID
        public long ID
        {
            get { return (id); }
            set { id = value; }
        }
        // -------------------------------------------------        Name
        public string Name
        {
            get { return (name); }
        }
        // -------------------------------------------------        Origin
        public FuncAuthor Origin
        {
            get { return (origin); }
        }
        // -------------------------------------------------        PredefinedFunctionNumber
        public int PredefinedFunctionNumber
        {
            get { return (iPredefined); }
        }
        // -------------------------------------------------        YText
        public string YText
        {
            get { return (str_Y); }
        }
        // -------------------------------------------------        XText
        public string XText
        {
            get { return (str_X); }
        }
        // -------------------------------------------------        Arg_Left
        public double Arg_Left
        {
            get { return (fX_L); }
            set { fX_L = value; }
        }
        // -------------------------------------------------        Arg_Right
        public double Arg_Right
        {
            get { return (fX_R); }
            set { fX_R = value; }
        }
        // -------------------------------------------------        Val_Top
        public double Val_Top
        {
            get { return (fY_T); }
            set { fY_T = value; }
        }
        // -------------------------------------------------        Val_Bottom
        public double Val_Bottom
        {
            get { return (fY_B); }
            set { fY_B = value; }
        }
        // -------------------------------------------------        ValuesOnBorders
        public ValuesOnBorders ValuesOnBorders
        {
            get { return (new ValuesOnBorders (fX_L, fX_R, fY_T, fY_B)); }
        }
        // -------------------------------------------------        From
        public double From
        {
            get { return (fFrom); }
            set { fFrom = value; }
        }
        // -------------------------------------------------        To
        public double To
        {
            get { return (fTo); }
            set { fTo = value; }
        }
        // -------------------------------------------------        Step
        public double Step
        {
            get { return (fStep); }
            set { fStep = value; }
        }
        // -------------------------------------------------        ParamTrio
        public void ParamTrio (double from, double to, double step)
        {
            if (from != to && step != 0.0)
            {
                fFrom = from;
                fTo = to;
                fStep = step;
            }
        }
        // -------------------------------------------------        MSPlot
        public MSPlot MSPlot
        {
            get { return (msplot); }
            set { msplot = value; }
        }
        // -------------------------------------------------        Draw
        public void Draw (Graphics grfx, MSPlot plot, int iOnPlot)
        {
            MSPlotAuxi auxi = new MSPlotAuxi (iOnPlot, 0, 0, SegmentLocation .Partly_Inside);
            if (origin == FuncAuthor .Developer)
            {
                DrawPredefinedFunction (grfx, plot, auxi, iPredefined);
            }
            else
            {
                if (Polish_X .Count <= 0)
                {
                    if (Polish_Y .Count > 0)
                    {
                        plot .DrawYofX (grfx, auxi, Polish_Y);
                    }
                }
                else
                {
                    if (Polish_Y .Count > 0)
                    {
                        auxi .ParamTrio (fFrom, fTo, fStep);
                        plot .DrawParamFunc (grfx, auxi, Polish_X, Polish_Y);
                    }
                }
            }
        }
        // -------------------------------------------------        Draw
        public void DrawPredefinedFunction (Graphics grfx, MSPlot plot, MSPlotAuxi auxi, int iPredefFunc)
        {
            switch (iPredefFunc)
            {
                case 0:
                    plot .DrawYofX (grfx, auxi, Math .Sin);
                    break;
                case 1:
                    plot .DrawYofX (grfx, auxi, Math .Cos);
                    break;
                case 2:
                    plot .DrawYofX (grfx, auxi, Math .Tan);
                    break;
                case 3:
                    plot .DrawYofX (grfx, auxi, Trigon_0);
                    break;
                case 4:
                    plot .DrawYofX (grfx, auxi, Trigon_1);
                    break;
                case 5:
                    plot .DrawYofX (grfx, auxi, Sample_Func .RepeatDampedVibrations, new double [] { 3, 2, 11 });
                    break;
                case 6:
                    auxi .ParamTrio (0.0, 29.0, 0.02);
                    plot .DrawParamFunc (grfx, auxi, Sample_Func .ParamFunc_X_0, Sample_Func .ParamFunc_Y_0);
                    // x = t * cos (t * PI)    y = t * sin (1.5 * t * PI)
                    break;
                case 7:
                    auxi .ParamTrio (-10, 10, 0.02);
                    plot .DrawParamFunc (grfx, auxi, Sample_Func .ParamFunc_X_1, Sample_Func .ParamFunc_Y_1);
                    // x = t + 2*sin(2t)    y = t + 2*cos(5t)
                    break;
                case 8:
                    auxi .ParamTrio (0, 6.3, 0.02);
                    plot .DrawParamFunc (grfx, auxi, SinNx, new double [] { 5 }, CosNx, new double [] { 9 });
                    break;
                case 9:
                    plot .DrawYofX (grfx, auxi, Trigon_2);
                    // (1.7*sin(x) + 0.1*cos(x)) / tg(0.3*x)
                    break;
                case 10:
                    auxi .ParamTrio (-4, 4, 0.01);
                    plot .DrawParamFunc (grfx, auxi, Trigon_10X, Trigon_10Y);
                    // x = -0.2 + cos (r)    y = -0.2 * tg (r) + sin (r)
                    break;
            }
        }
        // -------------------------------------------------        Trigon_0
        // 2*sin(0.7*x - 0.9) +0.2*sin(20*x)
        public double Trigon_0 (double fx)
        {
            return (2.0 * Math .Sin (0.7 * fx - 0.9) + 0.2 * Math .Sin (20.0 * fx));
        }
        // -------------------------------------------------        Trigon_1
        // sin(x) + 0.6 * cos(4.5*x) -1.5
        public double Trigon_1 (double fx)
        {
            return (Math .Sin (fx) + 0.6 * Math .Cos (4.5 * fx) - 1.5);
        }
        // -------------------------------------------------        SinNx
        // sin(nx)
        public double SinNx (double fx, double [] coef)
        {
            return (Math .Sin (fx * coef [0]));
        }
        // -------------------------------------------------        CosNx
        // cos(nx)
        public double CosNx (double fx, double [] coef)
        {
            return (Math .Cos (fx * coef [0]));
        }
        // -------------------------------------------------        Trigon_2
        // (1.7*sin(x) + 0.1*cos(x)) / tg(0.3*x)
        public double Trigon_2 (double fx)
        {
            return ((1.7 * Math .Sin (fx) + 0.1 * Math .Cos (fx)) / Math .Tan (0.3 * fx));
        }
        // -------------------------------------------------        Trigon_10X
        // -0.2 + cos (r)
        public double Trigon_10X (double fr)
        {
            return (-0.2 + Math .Cos (fr));
        }
        // -------------------------------------------------        Trigon_10Y
        // -0.2 * tg (r) + sin (r)
        public double Trigon_10Y (double fr)
        {
            return (-0.2 * Math .Tan (fr) + Math .Sin (fr));
        }

        const string nameMain = "FuncView_";
        // -------------------------------------------------        IntoRegistry
        public void IntoRegistry (RegistryKey regkey, string strF)
        {
            try
            {
                regkey .SetValue (nameMain + strF, new string [] {  version .ToString (),       // 0
                                                                    id .ToString (),                // 1
                                                                    name,                           // 2
                                                                    ((int) origin) .ToString (),    // 3
                                                                    iPredefined .ToString (),       // 4
                                                                    fX_L .ToString (),          // 5
                                                                    fX_R .ToString (),          // 6
                                                                    fY_T .ToString (),          // 7
                                                                    fY_B .ToString (),          // 8
                                                                    fFrom .ToString (),     // 9
                                                                    fTo .ToString (),       // 10
                                                                    fStep .ToString (),     // 11
                                                                    str_Y,              // 12
                                                                    str_X,              // 13
                                                                 },
                                                    RegistryValueKind .MultiString);
                msplot .IntoRegistry (regkey, strF);
            }
            catch
            {
            }
            finally
            {
            }
        }
        // -------------------------------------------------        FromRegistry
        public static FunctionDesigned FromRegistry (Form form, RegistryKey regkey, string strF)
        {
            try
            {
                string [] strs = (string []) regkey .GetValue (nameMain + strF);
                if (form == null ||
                    strs == null || strs .Length < 14 ||
                    Convert .ToInt32 (strs [0]) != 605 ||   // version
                    string .IsNullOrEmpty (strs [2]))       // name
                {
                    return (null);
                }
                FunctionDesigned func = null;
                FuncAuthor orig = (FuncAuthor) Convert .ToInt32 (strs [3]);
                if (orig == FuncAuthor .Developer)
                {
                    func = new FunctionDesigned (strs [2], Convert .ToInt32 (strs [4]),
                                                 Convert .ToDouble (strs [5]), Convert .ToDouble (strs [6]),
                                                 Convert .ToDouble (strs [7]), Convert .ToDouble (strs [8]));
                    if (func == null)
                    {
                        return (null);
                    }
                }
                else
                {
                    if (string .IsNullOrEmpty (strs [12]))
                    {
                        return (null);
                    }
                    List<Elem> polishY = new List<Elem> ();
                    int iErr, iErrPlace;
                    bool bCorrectFunc = FunctionInterpreter .Analyse (strs [12], ref polishY, out iErr, out iErrPlace);
                    if (!bCorrectFunc)
                    {
                        return (null);
                    }
                    if (string .IsNullOrEmpty (strs [13]))
                    {
                        func = new FunctionDesigned (strs [2], strs [12], polishY,
                                                     Convert .ToDouble (strs [5]), Convert .ToDouble (strs [6]),
                                                     Convert .ToDouble (strs [7]), Convert .ToDouble (strs [8]));
                        if (func == null)
                        {
                            return (null);
                        }
                    }
                    else
                    {
                        List<Elem> polishX = new List<Elem> ();
                        bCorrectFunc = FunctionInterpreter .Analyse (strs [13], ref polishX, out iErr, out iErrPlace);
                        if (!bCorrectFunc)
                        {
                            return (null);
                        }
                        func = new FunctionDesigned (strs [2], strs [13], strs [12], polishX, polishY,
                                                     Convert .ToDouble (strs [5]), Convert .ToDouble (strs [6]),
                                                     Convert .ToDouble (strs [7]), Convert .ToDouble (strs [8]),
                                                     Convert .ToDouble (strs [9]), Convert .ToDouble (strs [10]), Convert .ToDouble (strs [11]));
                    }
                    if (func == null)
                    {
                        return (null);
                    }
                }
                MSPlot plot = MSPlot .FromRegistry (form, regkey, strF);
                if (plot == null)
                {
                    return (null);
                }
                func .MSPlot = plot;
                func .ID = Convert .ToInt64 (strs [1]);
                return (func);
            }
            catch
            {
                return (null);
            }
            finally
            {
            }
        }
    }
}