Example #1
0
        private void OnCopyOrbsByAspect(object sender, EventArgs e)
        {
            bool               isOK   = false;
            AspectType         atFrom = Utilities.FromStringToEnumType <AspectType>(cmbAspectFrom.SelectedValue.ToString(), "AT_");
            AspectType         atTo   = Utilities.FromStringToEnumType <AspectType>(cmbAspectTo.SelectedValue.ToString(), "AT_");
            OrbsCollectionData ocd    = OrbsCollection.Where(x => x.OrbsSystemName == CurrentSystem).FirstOrDefault();
            OrbsMapCollection  omc    = ocd.OrbsMapCollection.Where(x => x.MapType == MapType).FirstOrDefault();

            foreach (PlanetsAspectsOrbsPairsCollection papc in omc.PlanetsAspectsOrbsCollection)
            {
                tPlanetType    pt   = papc.PlanetType;
                AspectOrbsPair aop1 = papc.AspectOrbsCollection.Where(x => x.AspectType == atFrom).FirstOrDefault();
                if (aop1 != null)
                {
                    AspectOrbsPair aop2 = papc.AspectOrbsCollection.Where(x => x.AspectType == atTo).FirstOrDefault();
                    if (aop2 == null)
                    {
                        aop2            = new AspectOrbsPair();
                        aop2.AspectType = atTo;
                        papc.AspectOrbsCollection.Add(aop2);
                    }
                    aop2.OrbValue = aop1.OrbValue;
                    isOK          = true;
                }
            }
            if (isOK)
            {
                InitTable();
            }
        }
        protected void DrawData(Graphics g)
        {
            if (OrbsData != null && OrbsData.Count > 0)
            {
                Font f = new Font(FontFamily.GenericSansSerif, 10);

                for (int index = 0; index < OrbsData.Count; index++)
                {
                    PlanetsAspectsOrbsPairsCollection paoc = OrbsData[index];
                    for (int j = 0; j < Constants._aspects.Count; ++j)
                    {
                        string         saspect = Constants._aspects[j];
                        AspectType     at      = Utilities.FromStringToEnumType <AspectType>(saspect, "AT_");
                        AspectOrbsPair aop     = paoc.AspectOrbsCollection.Where(x => x.AspectType == at).FirstOrDefault();
                        if (aop == null)
                        {
                            continue;
                        }

                        double dVal = aop.OrbValue;
                        float  Y    = (index + 1) * _painter._Height_Grid_Cell + 5;
                        float  X    = (j + 1) * _painter._Width_Grid_Cell + 5;
                        g.DrawString(dVal.ToString(), f, Brushes.Black, new PointF(X, Y));
                    }
                }
            }
        }
        public double GetOrb(tAstroMapType amt, tPlanetType pt, AspectType at)
        {
            double orb = 1;

            AspectOrbsPair aop = GetAspectOrbsPair(amt, pt, at);

            if (aop != null)
            {
                orb = aop.OrbValue;
            }

            return(orb);
        }
Example #4
0
        public void SetOrb(tAstroMapType amt, tPlanetType pt1, AspectType at, double value)
        {
            OrbsMapCollection omc = null;

            omc = Data.OrbsMapCollection.Where(x => x.MapType == amt).FirstOrDefault();

            PlanetsAspectsOrbsPairsCollection paoc = omc.PlanetsAspectsOrbsCollection.Where(x => x.PlanetType == pt1).FirstOrDefault();

            if (paoc != null)
            {
                AspectOrbsPair aop = paoc.AspectOrbsCollection.Where(x => x.AspectType == at).FirstOrDefault();
                aop.OrbValue = value;
            }
        }
        protected AspectOrbsPair GetAspectOrbsPair(tAstroMapType amt, tPlanetType pt, AspectType at)
        {
            AspectOrbsPair aop = null;

            OrbsMapCollection omc = Data.OrbsMapCollection.Where(x => x.MapType == amt).First();

            if (omc != null)
            {
                PlanetsAspectsOrbsPairsCollection paopc = omc.PlanetsAspectsOrbsCollection.Where(x => x.PlanetType == pt).FirstOrDefault();
                if (paopc != null)
                {
                    aop = paopc.AspectOrbsCollection.Where(x => x.AspectType == at).First();
                }
            }
            return(aop);
        }
Example #6
0
        private void OnCopyOrbsByMap(object sender, EventArgs e)
        {
            bool               isOK     = false;
            tAstroMapType      typeFrom = Utilities.FromStringToEnumType <tAstroMapType>(cmbMapFrom.SelectedValue.ToString());
            tAstroMapType      typeTo   = Utilities.FromStringToEnumType <tAstroMapType>(cmbMapTo.SelectedValue.ToString());
            OrbsCollectionData ocd      = OrbsCollection.Where(x => x.OrbsSystemName == CurrentSystem).FirstOrDefault();
            OrbsMapCollection  mapFrom  = ocd.OrbsMapCollection.Where(x => x.MapType == typeFrom).FirstOrDefault();
            OrbsMapCollection  mapTo    = ocd.OrbsMapCollection.Where(x => x.MapType == typeTo).FirstOrDefault();

            if (mapFrom != null)
            {
                if (mapTo == null)
                {
                    mapTo         = new OrbsMapCollection();
                    mapTo.MapType = typeTo;
                    mapFrom.PlanetsAspectsOrbsCollection = new List <PlanetsAspectsOrbsPairsCollection>();
                    ocd.OrbsMapCollection.Add(mapTo);
                }
                foreach (PlanetsAspectsOrbsPairsCollection collectionFrom in mapFrom.PlanetsAspectsOrbsCollection)
                {
                    tPlanetType ptypeFrom = collectionFrom.PlanetType;
                    PlanetsAspectsOrbsPairsCollection collectionTo = mapTo.PlanetsAspectsOrbsCollection.Where(x => x.PlanetType == ptypeFrom).FirstOrDefault();
                    if (collectionTo == null)
                    {
                        collectionTo                      = new PlanetsAspectsOrbsPairsCollection();
                        collectionTo.PlanetType           = ptypeFrom;
                        collectionTo.AspectOrbsCollection = new List <AspectOrbsPair>();
                        mapTo.PlanetsAspectsOrbsCollection.Add(collectionTo);
                    }
                    foreach (AspectOrbsPair orbs in collectionFrom.AspectOrbsCollection)
                    {
                        AspectType     at      = orbs.AspectType;
                        double         dorbval = orbs.OrbValue;
                        AspectOrbsPair orb2    = collectionTo.AspectOrbsCollection.Where(x => x.AspectType == at).FirstOrDefault();
                        if (orb2 == null)
                        {
                            orb2 = new AspectOrbsPair()
                            {
                                AspectType = at
                            };
                            collectionTo.AspectOrbsCollection.Add(orb2);
                        }
                        orb2.OrbValue = dorbval;
                    }
                }
                isOK = true;
            }
            if (isOK)
            {
                InitTable();
                string tabname = Utilities.FromUpperCaseToLowerWithFirstCapital <tAstroMapType>(mapTo.MapType);
                int    ipos    = tabname.IndexOf(" ");
                if (ipos >= 0)
                {
                    tabname = tabname.Replace(" ", "");
                }
                tabname = $"tab{tabname}";
                TabPage tp = tabCollectionsOrbs.TabPages[tabname];
                tabCollectionsOrbs.SelectedTab = tp;
            }
        }
        private void OnDoubleCkickPanel(object sender, System.EventArgs e)
        {
            MouseEventArgs me = e as MouseEventArgs;

            int X = me.X;
            int Y = me.Y;

            int planet = Y / _painter._Height_Grid_Cell - 1;
            int aspect = X / _painter._Width_Grid_Cell - 1;

            string splanet = Utilities.FromUpperCaseToLowerWithFirstCapital <tPlanetType>(_painter._planets[planet]);
            string saspect = Constants._aspects[aspect];

            PlanetsAspectsOrbsPairsCollection aop = OrbsData.Where(X => X.PlanetType == _painter._planets[planet]).FirstOrDefault();

            if (aop == null)
            {
                aop                      = new PlanetsAspectsOrbsPairsCollection();
                aop.PlanetType           = _painter._planets[planet];
                aop.AspectOrbsCollection = new List <AspectOrbsPair>();
                OrbsData.Add(aop);
            }
            AspectType     at    = Utilities.FromStringToEnumType <AspectType>(Constants._aspects[aspect], "AT_");
            AspectOrbsPair orb   = aop.AspectOrbsCollection.Where(x => x.AspectType == at).FirstOrDefault();
            double         value = 0;

            if (orb == null)
            {
                orb = new AspectOrbsPair()
                {
                    AspectType = at,
                    OrbValue   = 0
                };
                aop.AspectOrbsCollection.Add(orb);
            }
            else
            {
                value = orb.OrbValue;
            }
            using (dlgOrbsEdit dlg = new dlgOrbsEdit(splanet, saspect, value))
            {
                if (dlg.ShowDialog() == DialogResult.OK)
                {
                    orb.OrbValue = dlg.OrbValue;
                    if (dlg.SameDown)
                    {
                        for (int i = planet; i < _painter._planets.Count; i++)
                        {
                            PlanetsAspectsOrbsPairsCollection aop2 = OrbsData.Where(X => X.PlanetType == _painter._planets[i]).FirstOrDefault();
                            if (aop2 == null)
                            {
                                aop2                      = new PlanetsAspectsOrbsPairsCollection();
                                aop2.PlanetType           = _painter._planets[i];
                                aop2.AspectOrbsCollection = new List <AspectOrbsPair>();
                                OrbsData.Add(aop2);
                            }

                            AspectType     at2  = Utilities.FromStringToEnumType <AspectType>(Constants._aspects[aspect], "AT_");
                            AspectOrbsPair orb2 = aop2.AspectOrbsCollection.Where(x => x.AspectType == at2).FirstOrDefault();
                            if (orb2 == null)
                            {
                                orb2            = new AspectOrbsPair();
                                orb2.AspectType = at2;
                                aop2.AspectOrbsCollection.Add(orb2);
                            }
                            orb2.OrbValue = dlg.OrbValue;
                        }
                    }
                    Refresh();
                }
            }
        }
        public void SetOrb(tAstroMapType amt, tPlanetType pt, AspectType at, double orb)
        {
            AspectOrbsPair aop = GetAspectOrbsPair(amt, pt, at);

            aop.OrbValue = orb;
        }