Ejemplo n.º 1
0
 public void RemoveSound(SBEngine.Sound sound) => RemoveSound(sound.ID);
Ejemplo n.º 2
0
        //
        // constructor
        //
        public SoundElement(SBEngine.Sound sound) : base()
        {
            //
            // set sound variable
            //
            if (!sound.IsSound())
            {
                SBEngine.ThrowError($"Error to create SoundElement {sound} (this is not sound)");
            }

            g.engine.soundElements.Add(this);

            baseSound = sound;

            // paint bg
            BackColor = Color.Transparent;

            Text      = $"{(g.vars.hotkeySound != KeyDict.Disable ? $"[{baseSound.ID}] " : "")}{baseSound.name()}";
            Font      = paintFont;
            AutoSize  = false;
            ForeColor = Color.White;
            TextAlign = ContentAlignment.MiddleCenter;

            //
            // setup elements
            //
            // resize button
            var ResizeButton = new DrawElement(Size.Width - ResizeSize, Size.Height - ResizeSize, ResizeSize, ResizeSize, this, Brushes.LightBlue);

            ResizeButton.onResize = (DrawElement obj, int x, int y, int w, int h) =>
            {
                if (IsEditing)
                {
                    obj.x = w - ResizeSize;
                    obj.y = h - ResizeSize;
                }
            };
            ResizeButton.OnClickEvent = (DrawElement obj, MouseEventArgs args) => IsResizing = IsEditing;

            // close button
            var CloseButton = new DrawElement(0, 0, ResizeSize, ResizeSize, this, Brushes.Red);

            CloseButton.OnClickEvent = (DrawElement obj, MouseEventArgs args) =>
            {
                if (IsEditing)
                {
                    Remove();
                }
            };

            //
            // on click
            //
            MouseDown += (object obj, MouseEventArgs args) =>
            {
                //
                // editing mode
                //
                if (IsEditing)
                {
                    var self = (SoundElement)obj;

                    offset.X = args.X;
                    offset.Y = args.Y;
                }
                // default mode
                //
                // play sounds etc...
                else if (!IsEditing && args.Button == MouseButtons.Left)
                {
                    g.engine.PlaySound(baseSound);
                }
            };

            MouseUp += (object obj, MouseEventArgs args) =>
            {
                if (args.Button == MouseButtons.Left)
                {
                    IsResizing = false;
                }
            };

            //
            // mouse scroll
            //
            MouseWheel += (object obj, MouseEventArgs args) =>
            {
                // play sound
                if (args.Delta != 0)
                {
                    g.engine.PlaySound(baseSound);
                }
            };

            //
            // move element
            //
            MouseMove += (object obj, MouseEventArgs args) =>
            {
                if (IsEditing && args.Button == MouseButtons.Left)
                {
                    var   self  = (SoundElement)obj;
                    Frame frame = (Frame)((Panel)self.Parent).Parent;

                    if (IsResizing)
                    {
                        var newSize = self.Size;

                        newSize.Width  = Math.Max(args.X + 5, MinSize.Width);
                        newSize.Height = Math.Max(args.Y + 5, MinSize.Height);

                        // snap
                        if (frame.GridEnable)
                        {
                            newSize.Width  = (int)(Math.Round(newSize.Width / (double)g.vars.GridSize) * g.vars.GridSize);
                            newSize.Height = (int)(Math.Round(newSize.Height / (double)g.vars.GridSize) * g.vars.GridSize);
                        }

                        SetSize(newSize.Width, newSize.Height);

                        self.Invalidate();
                    }
                    else
                    {
                        var newLoc = self.Location;

                        newLoc.X += args.X - offset.X;
                        newLoc.Y += args.Y - offset.Y;

                        // snap
                        if (frame.GridEnable)
                        {
                            newLoc.X = (int)(Math.Round(newLoc.X / (double)g.vars.GridSize) * g.vars.GridSize);                             // 4 - snap size
                            newLoc.Y = (int)(Math.Round(newLoc.Y / (double)g.vars.GridSize) * g.vars.GridSize);
                        }

                        SetPos(Math.Max(newLoc.X, 0), Math.Max(newLoc.Y, 0));
                    }
                }
            };

            Resize += (object obj, EventArgs args) =>
            {
                if (((Frame)((Panel)((SoundElement)obj).Parent).Parent).GridEnable)
                {
                    g.MainFrame.RepaintGlobal();
                }
            };

            //
            // paint
            //
            Paint += (object obj, PaintEventArgs args) =>
            {
                var graphic = args.Graphics;
                var self    = (SoundElement)obj;

                // draw border
                if (IsEditing)
                {
                    graphic.DrawRectangle(new Pen(Color.Gray, BorderSize), new Rectangle(1, 1, self.Size.Width - 2, self.Size.Height - 2));
                }
                else
                {
                    Pen pen = Pens.Cyan;

                    if (g.engine.currentSound == baseSound && !g.engine.isOnDelay)
                    {
                        pen = Pens.Blue;
                    }
                    else if (g.engine.currentSound == baseSound && g.engine.isOnDelay)
                    {
                        pen = Pens.DarkGreen;
                    }

                    graphic.DrawRectangle(pen, new Rectangle(0, 0, self.Size.Width - 1, self.Size.Height - 1));
                }
            };

            g.engine.OnTrackStart  += (SBEngine.Sound soundStarted, bool isDelay) => RepaintAllElements();
            g.engine.OnTrackFinish += (SBEngine.Sound soundFinished) => RepaintAllElements();
        }