Example #1
0
        /// <summary>
        /// Метод, рисующий линии черной клавиши для эскиза.
        /// </summary>
        /// <param name="sketch">Указатель на эскиз.</param>
        /// <param name="data">Указатель на данные.</param>
        /// <param name="currentKey">Текущая клавиша.</param>
        private KeyCreatorBase KeyLineDraw(ksDocument2D sketch, KeyNote currentKey)
        {
            switch (currentKey)
            {
            case KeyNote.Db:
            {
                return(new KeyCreatorDb(sketch, _marginLeft));
            }

            case KeyNote.Eb:
            {
                return(new KeyCreatorEb(sketch, _marginLeft));
            }

            case KeyNote.Gb:
            {
                return(new KeyCreatorGb(sketch, _marginLeft));
            }

            case KeyNote.Ab:
            {
                return(new KeyCreatorAb(sketch, _marginLeft));
            }

            case KeyNote.Bb:
            {
                return(new KeyCreatorBb(sketch, _marginLeft));
            }

            default:
            {
                throw new Exception("TODO");
            }
            }
        }
Example #2
0
        /// <summary>
        /// Метод, строящий клавиатурную секцию.
        /// </summary>
        /// <param name="document3D">Указатель на активный документ КОМПАС-3D.</param>
        /// <param name="data">Указатель на данные.</param>
        public override void Build(ksDocument3D document3D,
                                   KeyboardParametersStorage data)
        {
            if (document3D == null || data == null)
            {
                throw new NullReferenceException("Метод ссылается на null объект.");
            }

            // Текущая обрабатываемая клавиша.
            KeyNote currentKey = SetCurrentNote(data);

            KeyBuild(document3D, data, currentKey);
        }
Example #3
0
        void KeyBuild(ksDocument3D document3D,
                      KeyboardParametersStorage data, KeyNote currentKey)
        {
            switch (data.KeyboardType)
            {
            case KeyboardType.Piano:
            {
                KeyPartBuild(document3D, data, currentKey, true,
                             _keyboardHeight, KeyLevel.Middle);

                KeyPartBuild(document3D, data, currentKey, true, 1.5);

                // Если первая клавиша ДО (C), то первая черная клавиша -
                // РЕ -БЕМОЛЬ (Db).
                // Если первая клавиша ЛЯ (A), то первая черная клавиша -
                // СИ -БЕМОЛЬ (Bb).
                //
                if (currentKey == KeyNote.C)
                {
                    currentKey = KeyNote.Db;
                }
                else
                {
                    if (currentKey == KeyNote.A)
                    {
                        currentKey = KeyNote.Bb;
                    }
                }

                KeyPartBuild(document3D, data, currentKey, false,
                             _keyboardHeight);
                break;
            }

            case KeyboardType.Synth:
            {
                KeyPartBuild(document3D, data, currentKey, true,
                             _keyboardHeight, KeyLevel.Bottom);

                KeyPartBuild(document3D, data, currentKey, true, 2.0,
                             KeyLevel.Middle);

                KeyPartBuild(document3D, data, currentKey, true, 1.5);

                if (currentKey == KeyNote.C)
                {
                    currentKey = KeyNote.Db;
                }
                else
                {
                    if (currentKey == KeyNote.A)
                    {
                        currentKey = KeyNote.Bb;
                    }
                }

                KeyPartBuild(document3D, data, currentKey, false,
                             _keyboardHeight);
                break;
            }
            }
        }
Example #4
0
        /// <summary>
        /// Метод, рисующий эскиз клавиш.
        /// </summary>
        /// <param name="document3D">Указатель на активный документ КОМПАС-3D.</param>
        /// <param name="data">Указатель на данные.</param>
        /// <param name="currentKey">Текущая клавиша.</param>
        /// <param name="isWhiteKey">Принадлежность к белым клавишам.</param>
        /// <param name="keyboardHeight">Высота клавиатурной секции.</param>
        /// <param name="keyLevel">Уровень клавиши.</param>
        private void KeyPartBuild(ksDocument3D document3D,
                                  KeyboardParametersStorage data, KeyNote currentKey,
                                  bool isWhiteKey, double keyboardHeight,
                                  KeyLevel keyLevel = KeyLevel.Top)
        {
            // Установка фронтального отступа в зависимости от выбранного
            // уровня клавиш.
            //
            double marginTop;

            var keyMarginTopDictionary = new Dictionary <KeyLevel, double>()
            {
                { KeyLevel.Bottom, 3.6 },
                { KeyLevel.Middle, 0.6 },
                { KeyLevel.Top, 0.5 }
            };

            marginTop = keyMarginTopDictionary[keyLevel];

            // Сброс отступа.
            _marginLeft = -(data.BodyLength / 2) + (data.BoardLength / 2)
                          - _space;

            part = (ksPart)document3D.GetPart((short)Part_Type.pTop_Part);
            var entityOffsetPlane = (ksEntity)part.NewEntity((short)Obj3dType.o3d_planeOffset);
            var entitySketch      = (ksEntity)part.NewEntity((short)Obj3dType.o3d_sketch);

            if (entityOffsetPlane != null)
            {
                var offsetDef = (ksPlaneOffsetDefinition)entityOffsetPlane.GetDefinition();
                if (offsetDef != null)
                {
                    offsetDef.direction = true;
                    offsetDef.offset    = data.BodyHeight - keyboardHeight;

                    var basePlane = (ksEntity)part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                    basePlane.name = "Начальная плоскость";
                    offsetDef.SetPlane(basePlane);

                    entityOffsetPlane.name   = "Смещенная плоскость";
                    entityOffsetPlane.hidden = true;
                    entityOffsetPlane.Create();
                    var sketchDef = (ksSketchDefinition)entitySketch.GetDefinition();
                    if (sketchDef != null)
                    {
                        sketchDef.SetPlane(entityOffsetPlane);
                        entitySketch.Create();
                        var sketchEdit = (ksDocument2D)sketchDef.BeginEdit();

                        if (isWhiteKey)
                        {
                            entitySketch.name = "Белые клавиши";
                            for (int count = 0; count < data.WhiteKeyAmount;
                                 count++)
                            {
                                KeyLineDraw(sketchEdit, data, currentKey,
                                            count, marginTop).Build();
                                _marginLeft = _marginLeft - 2.2 - _space;

                                // Сброс последовательности клавиш.
                                //
                                if (currentKey == KeyNote.B)
                                {
                                    currentKey = KeyNote.C;
                                }
                                else
                                {
                                    currentKey++;
                                }
                            }
                        }
                        else
                        {
                            entitySketch.name = "Черные клавиши";
                            for (int count = 0; count < data.BlackKeyAmount;
                                 count++)
                            {
                                // Для ровного отображения черных клавиш
                                // относительно белых, необходимо задать
                                // отступ после каждой клавиши.
                                //
                                if (count == 0 && currentKey == KeyNote.Db)
                                {
                                    _marginLeft = _marginLeft - 2.2 - _space;
                                }
                                else if (currentKey == KeyNote.Db ||
                                         currentKey == KeyNote.Gb)
                                {
                                    _marginLeft = _marginLeft - (2.2
                                                                 + _space) * 2;
                                }
                                else
                                {
                                    _marginLeft = _marginLeft - 2.2
                                                  - _space;
                                }
                                KeyLineDraw(sketchEdit, currentKey).Build();

                                // Следующей после СИ-БЕМОЛЬ черной клавишей
                                // является РЕ-БЕМОЛЬ.
                                //
                                if (currentKey == KeyNote.Bb)
                                {
                                    currentKey = KeyNote.Db;
                                }
                                else
                                {
                                    currentKey++;
                                }
                            }
                        }
                        sketchDef.EndEdit();
                        if (isWhiteKey)
                        {
                            KeyExtruse(part, entitySketch, data,
                                       isWhiteKey, keyLevel);
                        }
                        else
                        {
                            KeyExtruse(part, entitySketch, data,
                                       isWhiteKey);
                            BlackKeyCutSketch(document3D, data);
                        }
                    }
                }
            }
        }
Example #5
0
        /// <summary>
        /// Метод, рисующий линии белой клавиши для эскиза.
        /// </summary>
        /// <param name="sketch">Указатель на эскиз.</param>
        /// <param name="data">Указатель на данные.</param>
        /// <param name="currentKey">Текущая клавиша.</param>
        /// <param name="count">Номер текущей клавиши.</param>
        /// <param name="marginFront">Фронтальный отступ.</param>
        private KeyCreatorBase KeyLineDraw(ksDocument2D sketch,
                                           KeyboardParametersStorage data, KeyNote currentKey, int count,
                                           double marginFront)
        {
            switch (currentKey)
            {
            case KeyNote.C:
            {
                if (count + 1 == data.WhiteKeyAmount)
                {
                    return(new KeyCreatorCAdditional(sketch,
                                                     _marginLeft, marginFront));
                }
                return(new KeyCreatorC(sketch, _marginLeft,
                                       marginFront));
            }

            case KeyNote.D:
            {
                return(new KeyCreatorD(sketch, _marginLeft,
                                       marginFront));
            }

            case KeyNote.E:
            {
                return(new KeyCreatorE(sketch, _marginLeft,
                                       marginFront));
            }

            case KeyNote.F:
            {
                return(new KeyCreatorF(sketch, _marginLeft,
                                       marginFront));
            }

            case KeyNote.G:
            {
                return(new KeyCreatorG(sketch, _marginLeft,
                                       marginFront));
            }

            case KeyNote.A:
            {
                if (count == 0)
                {
                    return(new KeyCreatorAAdditional(sketch,
                                                     _marginLeft, marginFront));
                }
                return(new KeyCreatorA(sketch, _marginLeft,
                                       marginFront));
            }

            case KeyNote.B:
            {
                return(new KeyCreatorB(sketch, _marginLeft,
                                       marginFront));
            }

            default:
            {
                throw new Exception("TODO");
            }
            }
        }