Exemplo n.º 1
0
        private static string[] SortByName3(string head, PadyamSubType padyamSubType, Rule[] rules)
        {
            string s  = "";
            string s2 = "";



            //if ( head != "" )
            {
                s = s + "<h1>" + head + "</h1>";
                s = s + "<ol>";

                s2 = s2 + "<li>" + head + "</li>";
                s2 = s2 + "<ol>";
            }

            foreach (Rule R in SortHelper.SortByName(rules))
            {
                s  = s + "<li  id='" + R.Identifier + "'>";
                s  = s + BuildHTMLRules(R, true);
                s  = s + "&nbsp; <a class='link' href='#TOP_" + R.Identifier + "'>[TOP]</a>";
                s  = s + "</li>";
                s2 = s2 + "<li id='TOP_" + R.Identifier + "'><a class='identifier' href='#" + R.Identifier + "'>" + R.Name + "</a></li>";
            }


            //if ( head != "" )
            {
                s  = s + "</ol>";
                s2 = s2 + "</ol>";
            }
            return(new string[] { s, s2 });
        }
Exemplo n.º 2
0
        public static string GetPadyamTypeString(PadyamType ruleType, PadyamSubType subType)
        {
            switch (ruleType)
            {
            case PadyamType.Jati:
                switch (subType)
                {
                case PadyamSubType.Akkara:
                    return("జాతి(అక్కరలు)");

                case PadyamSubType.Divpada:
                    return("జాతి(ద్విపదలు)");

                case PadyamSubType.Shatpada:
                    return("జాతి(షట్పదలు)");

                case PadyamSubType.Ragada:
                case PadyamSubType.Ragada2:
                    return("జాతి(రగడలు)");

                default:
                    return("జాతి");
                }

            case PadyamType.UpaJati:
                switch (subType)
                {
                case PadyamSubType.Sisamu:
                    return("ఉపజాతి(సీసములు)");

                default:
                    return("ఉపజాతి");
                }

            case PadyamType.Vruttam:
                switch (subType)
                {
                case PadyamSubType.VishamaVruttam:
                    return("విషమవృత్తం");

                case PadyamSubType.ArdhaVruttam:
                    return("అర్ధ సమవృత్తం");

                case PadyamSubType.DaMDakamu:
                    return("దండకము");

                default:
                    return("వృత్తం");
                }

            default:
                return("తెలియదు");
            }
        }
Exemplo n.º 3
0
        public string SortByName2(string head, PadyamSubType padyamSubType)
        {
            string s2 = "";

            s2 = s2 + "<h2 style='text-align:center;'>" + head + "</h2>";
            s2 = s2 + "<ol>";
            foreach (Rule R in SortHelper.SortByName(RuleHelper.GetRules2(padyamSubType)))
            {
                s2 = s2 + "<li id='h_" + R.Identifier + "'><a class='identifier'  title='" + R.Name + "'  href='?chandassu=" + R.Identifier + "'>" + R.ShortName + "</a></li>";
            }
            s2 = s2 + "</ol>";
            return(s2);
        }
Exemplo n.º 4
0
        internal string CSPadyamSubType(PadyamSubType padyamSubType)
        {
            switch (padyamSubType)
            {
            case PadyamSubType.Vruttam:
                return("PadyamSubType.Vruttam");

            case PadyamSubType.ArdhaVruttam:
                return("PadyamSubType.ArdhaVruttam");

            case PadyamSubType.VishamaVruttam:
                return("PadyamSubType.VishamaVruttam");
            }
            return("//");
        }
Exemplo n.º 5
0
        /// <summary>
        /// Gets all the Rules with given Padyam Sub Type
        /// </summary>
        /// <param name="C"></param>
        /// <returns></returns>
        public static Rule[] GetRules2(PadyamSubType C)
        {
            Rule[]      Rules = Manager.Rules();
            List <Rule> L     = new List <Rule>();

            foreach (Rule R in Rules)
            {
                if (R.PadyamSubType == C)
                {
                    L.Add(R);
                }
            }

            Rule[] Rules2 = new Rule[L.Count];
            for (int i = 0; i < L.Count; i++)
            {
                Rules2[i] = L[i];
            }

            return(Rules2);
        }
Exemplo n.º 6
0
 private static string[] SortByName2(string head, PadyamSubType padyamSubType)
 {
     return(SortByName3(head, padyamSubType, Helper.GetRules2(padyamSubType)));
 }
Exemplo n.º 7
0
 internal string CSPadyamSubType(PadyamSubType padyamSubType)
 {
     return("");
 }
Exemplo n.º 8
0
        public static Rule[] GetRules2(PadyamSubType C)
        {
            switch (C)
            {
            case PadyamSubType.OtherUpaJati:
                return(new Rule[] { new aaTaveladi( ), new taeTageeti( ), });

            case PadyamSubType.Sisamu:
                return(new Rule[] { new sarvalaghusIsamu( ), new sarvalaghusIsamu2( ), new seesaM( ), new seesaM2( ), });

            case PadyamSubType.OtherJati:
                return(new Rule[] { new utsaahamu( ), new kandam( ), new taruvOja( ), new tripadi( ) });

            case PadyamSubType.Akkara:
                return(new Rule[] { new aMtaraakkara( ), new alpaakkara( ), new madhuraakkara( ), new madhyaakkara( ), new mahaaakkara( ), });

            case PadyamSubType.Divpada:
                return(new Rule[] { new dvipada( ), new dvipadamaalika( ), new maMjareedvipada( ) });

            case PadyamSubType.RareVruttam:
                return(new Rule[] {
                    new kshama(),
                    new khacharaplutamu(),
                    new geetaalaMbanamu(),
                    new gOvRsha(),
                    new gauri(),
                    new chaMchareekaatati(),
                    new chaMchareekaavaLi(),
                    new chaMdrakaLa(),
                    new chaMdralaekha(),
                    new chaMdraSree(),
                    new chaMdrika(),
                    new chaMdrika2(),
                    new chitrapadamu(),
                    new jalaMdharamu(),
                    new jaladamu(),
                    new jaladharamaala(),
                    new jalOddhatagati(),
                    new tanumadhyaavRttamu(),
                    new taraLamu(),
                    new turagavalgitavRttamu(),
                    new tvaritapadagati(),
                    new dRtavilaMbitamu(),
                    new dhRvakOkila(),
                    new nadi(),
                    new nadeepraghOshamu(),
                    new narkuTamu(),
                    new navanaMdini(),
                    new naaMdeemukhi(),
                    new naaree(),
                    new naareeplutavRttamu(),
                    new paadapamu(),
                    new padmakamu(),
                    new padmanaabhamu(),
                    new paalaaSadaLamu(),
                    new pRthiveevRttamu(),
                    new praguNa(),
                    new praNavamu(),
                    new prabhaatamu(),
                    new pramaaNi(),
                    new pramitaaksharamu(),
                    new praharaNakalita(),
                    new praharshiNi(),
                    new priyaMvada(),
                    new priyakaaMta(),
                    new phalasadanamu(),
                    new baMdhuramu(),
                    new balabhinmaNi(),
                    new bhaMbharagaanamu(),
                    new bhadrakamu(),
                    new bhadrakamu2(),
                    new bhadriNeevRttamu(),
                    new bhaaskaravilasitamu(),
                    new bhujaMgavijRMbhitamu(),
                    new bhujagaSiSirutamu(),
                    new bhootilakamu(),
                    new bhoonutamu(),
                    new maMgaLamahaaSree(),
                    new maMjubhaashiNi(),
                    new maMdaakraaMta(),
                    new maNikamalavilasitamu(),
                    new maNigaNanikaramu(),
                    new maNibhooshaNamu(),
                    new maNimaala(),
                    new maNiraMgamu(),
                    new matta(),
                    new mattamayooramu(),
                    new mattahaMsini(),
                    new madanavilasitamu(),
                    new madanamu(),
                    new madanaarta(),
                    new manOj_namu(),
                    new mayoorasaari(),
                    new malayajamu(),
                    new maeghavisphoorjitamu(),
                    new maedini(),
                    new vaaraaMgi(),
                    new mOhapralaapamu(),
                    new rati(),
                    new ratipriyavRttamu(),
                    new rathOddhatamu(),
                    new ramaNakamu(),
                    new raajahaMsa(),
                    new rugmavati(),
                    new ruchiramu(),
                    new lata(),
                    new layahaari(),
                    new laaTeeviTamu(),
                    new vaMSasthamu(),
                    new vanamaMjari(),
                    new vasaMtamaMjari(),
                    new vaatOrmi(),
                    new vaasaMti(),
                    new vichitramu(),
                    new vidyunmaala(),
                    new vidrumalata(),
                    new vibhootivRttamu(),
                    new viSvadaevi(),
                    new SarabhakreeDaa(),
                    new Saalini(),
                    new SikhariNi(),
                    new SuddhaviraaTi(),
                    new Syaeni(),
                    new Sree(),
                    new stree(),
                    new SreeramaNamu(),
                    new samaani(),
                    new sarasaaMkavRttamu(),
                    new sarasijamu(),
                    new saadhveevRttamu(),
                    new siMdhuravRttamu(),
                    new siMharaekha(),
                    new sukaaMti(),
                    new suMdari(),
                    new paMkti(),
                    new sugaMdhi(),
                    new tribhaMgi(),
                    new vinayaM(),
                    new biMbamu(),
                    new aMbuja(),
                    new madhumati(),
                    new madaraekha(),
                    new halamukhi(),
                    new upajaati(),
                    new iMdravaMSamu(),
                    new aparaajitamu(),
                    new asaMbaadha(),
                    new kamalavilasitamu(),
                    new sukaesaramu(),
                    new hariNi(),
                    new kusumitalataavaellita(),
                    new aMburuhamu(),
                    new aSvalalitamu(),
                    new ashTamoorti(),
                    new manOharamu(),
                    new aMgajaastramu(),
                    new varaaMgi(),
                    new rathagamanamanOharamu(),
                    new veeNaarachanamu()
                });

            case PadyamSubType.OtherVruttam:
                return(new Rule[] { new iMdravajramu(),
                                    new utpalamaala(),
                                    new upEMdravajramu(),
                                    new kaviraajaviraajitamu(),
                                    new krauMchapadaM(),
                                    new chaMpakamaala(),
                                    new taralamu(),
                                    new tOTakamu(), new tOvakamu(),
                                    new daMDakamu1(),
                                    new daMDakamu2(),
                                    new paMchaamaramu(),
                                    new bhujaMgaprayaatamu(),
                                    new bhootilakaM(),
                                    new maMgaLamahaaSrI(),
                                    new maMdaakraaMtamu(),
                                    new mattakOkilamu(),
                                    new maththEbhaM(),
                                    new mahaasragdhara(),
                                    new maanini(),
                                    new maalini(),
                                    new mEghavisphooritaM(),
                                    new layagraahi(),
                                    new layavibhaati(),
                                    new vanamayooramu(),
                                    new vasaMtatilakamu(),
                                    new saardhoolaM(),
                                    new SlOkamu(),
                                    new sragdhara(),
                                    new sragviNi(),
                                    new svaagatavRttamu(), });

            default:
                return(new Rule[] { });
            }
        }
Exemplo n.º 9
0
 private string AddEnum(string name, PadyamSubType val)
 {
     return(name + ":" + (int)val + ",");
 }