private void textBoxSubgroup_TextChanged(object sender, RoutedEventArgs e)
        {
            string error = null;

            if (!_settingInternally)
            {
                MarkPresetChanged();
                // parse
                Rational[] subgroup      = null;
                Rational[] narrows       = null;
                string[]   textSubgroup  = DS.SplitSubgroupText(textBoxSubgroup.Text);
                bool       emptySubgroup = String.IsNullOrWhiteSpace(textSubgroup[0]);
                bool       emptyNarrows  = String.IsNullOrWhiteSpace(textSubgroup[1]);
                if (!emptySubgroup)
                {
                    subgroup = Rational.ParseRationals(textSubgroup[0], ".");
                    if (subgroup == null)
                    {
                        error = "Invalid subgroup format";
                    }
                }
                if (!emptyNarrows)
                {
                    narrows = Rational.ParseRationals(textSubgroup[1], ".");
                    narrows = NarrowUtils.ValidateNarrows(narrows);
                    if (narrows == null)
                    {
                        error = "Invalid narrows"; //!!! losing subgroup error
                    }
                }
                if (error == null)
                {
                    // parsed without errors
                    // update current settings
                    _drawerSettings.subgroup = subgroup;
                    _drawerSettings.narrows  = narrows;
                    // update drawer subgroup
                    _gridDrawer.SetSubgroup(_drawerSettings.limitPrimeIndex, subgroup, narrows);
                    // revalidate temperament
                    if (_drawerSettings.temperament != null)
                    {
                        _gridDrawer.SetTemperament(_drawerSettings.temperament); // GridDrawer also validates its temperament values
                        UpdateTemperamentRowsAfterValidation();
                    }

                    InvalidateView();
                }
            }
            //
            UpdateSubgroupTip(error);
            //
            upDownLimit.IsEnabled = _drawerSettings.subgroup == null;
        }
Example #2
0
        static void Test_Narrow()
        {
            Action <string> testNarrow = (text) => {
                string[] parts = text.Split(' ', StringSplitOptions.RemoveEmptyEntries);
                Rational r     = Rational.Parse(parts[0]);
                Rational b     = Rational.Parse(parts[1]);
                Rational exp   = Rational.Parse(parts[2]);
                Rational res   = NarrowUtils.MakeNarrow(r, b);
                Debug.WriteLine("{0,4} / base {1,-4} -> {2,-4} {3}", r, b, res,
                                res.Equals(exp) ? "Ok" : ("Expected " + exp.ToString()));
            };

            testNarrow("3 2     3/2");
            testNarrow("3 1/2   3/2");
            testNarrow("5 6     5/6");
        }
        // Read settings from controls - used on saving Preset
        protected DrawerSettings GetSettingsFromControls()
        {
            DrawerSettings s = new DrawerSettings {
            };

            // subgroup
            if (!String.IsNullOrWhiteSpace(textBoxSubgroup.Text))
            {
                string[] subgroupText = DS.SplitSubgroupText(textBoxSubgroup.Text);
                s.subgroup = Rational.ParseRationals(subgroupText[0]);
                s.narrows  = Rational.ParseRationals(subgroupText[1]);
                s.narrows  = NarrowUtils.ValidateNarrows(s.narrows);
            }
            // base & prime limit
            if (s.subgroup == null)
            {
                s.limitPrimeIndex = (int)upDownLimit.Value;
            }
            // generation
            s.harmonicityName    = (string)comboBoxDistance.SelectedItem;
            s.rationalCountLimit = (int)upDownCountLimit.Value;
            // temperament
            s.temperament        = _temperamentControls.GetTemperament();
            s.temperamentMeasure = (float)sliderTemperament.Value * 0.01f;
            // slope
            s.slopeOrigin     = Rational.Parse(textBoxSlopeOrigin.Text);
            s.slopeChainTurns = (float)upDownChainTurns.Value;
            // degrees
            //s.degreeCount = (int)upDownDegreeCount.Value;
            s.degreeThreshold = (float)upDownDegreeThreshold.Value;
            // selection
            s.selection = DS.ParseIntervals(textBoxSelection.Text);
            // grids
            s.edGrids = GridDrawer.EDGrid.Parse(textBoxEDGrids.Text);

            return(s);
        }
Example #4
0
        public static DrawerSettings Load(XmlReader r)
        {
            var s  = new DrawerSettings {
            };
            var ts = new List <Tempered>();

            while (r.Read())
            {
                if (r.NodeType == XmlNodeType.Element)
                {
                    switch (r.Name)
                    {
                    case "limitPrime": {
                        Rational limitPrime = Rational.Parse(r.ReadElementContentAsString());     // allow to be a rational
                        if (!limitPrime.IsDefault())
                        {
                            s.limitPrimeIndex = limitPrime.GetHighPrimeIndex();
                        }
                        break;
                    }

                    case "subgroup": {
                        s.subgroup = Rational.ParseRationals(r.ReadElementContentAsString());
                        break;
                    }

                    case "narrows": {
                        s.narrows = Rational.ParseRationals(r.ReadElementContentAsString());
                        s.narrows = NarrowUtils.ValidateNarrows(s.narrows);
                        break;
                    }

                    //
                    case "harmonicityName":     s.harmonicityName = r.ReadElementContentAsString();   break;

                    case "rationalCountLimit":  s.rationalCountLimit = r.ReadElementContentAsInt();      break;

                    //
                    case "slopeOrigin":         s.slopeOrigin = Rational.Parse(r.ReadElementContentAsString()); break;

                    case "slopeChainTurns":     s.slopeChainTurns = r.ReadElementContentAsFloat();    break;

                    //
                    //case "degreeCount":         s.degreeCount        = r.ReadElementContentAsInt();      break;
                    case "degreeThreshold":     s.degreeThreshold = r.ReadElementContentAsFloat();    break;

                    //
                    case "selection":           s.selection = ParseIntervals(r.ReadElementContentAsString()); break;

                    case "temper": {
                        var t = new Tempered {
                        };
                        t.rational = Rational.Parse(r.GetAttribute("rational"));
                        float.TryParse(r.GetAttribute("cents"), out t.cents);
                        ts.Add(t);
                        break;
                    }

                    case "temperamentMeasure":  s.temperamentMeasure = r.ReadElementContentAsFloat();    break;

                    case "edGrids":             s.edGrids = GridDrawer.EDGrid.Parse(r.ReadElementContentAsString()); break;

                    case "pointRadius":         s.pointRadiusLinear = r.ReadElementContentAsFloat();    break;
                    }
                }
            }
            if (ts.Count > 0)
            {
                s.temperament = ts.ToArray();
            }
            return(s);
        }