Exemplo n.º 1
0
		private void leftplayervolume_ValueChanged(object sender, System.EventArgs e)
		{
            if(BlockLeft == false)
			    player.SetPlayerVolume(100 - ((VScrollBar)sender).Value, 100 - rightplayervolume.Value);

            BlockLeft = false;
		}
Exemplo n.º 2
0
        public SoundPlayer(CASCFile file)
        {
            InitializeComponent();

            this.file = file;
            localPath = Path.Combine(Constants.TEMP_DIRECTORY, file.FullName);

            player = new ZPlay();
            if (!File.Exists(localPath))
            {
                EventManager.FileExtractComplete += OnFileExtractComplete;

                RunnerExtractItem extract = new RunnerExtractItem(file);
                runnerID = extract.runnerID;
                extract.Begin();

                SetState("Extracting file...");
            }
            else
            {
                ready = true;
                Play();
            }

            UI_TrackTitle.Text = file.Name;
            Text = file.Name + " - W3DT";

            UI_VolumeBar.Value = Program.Settings.SoundPlayerVolume;
            player.SetPlayerVolume(UI_VolumeBar.Value, UI_VolumeBar.Value);
        }
Exemplo n.º 3
0
        public void AdjustPlayerParams(ref ZPlay player)
        {
            player.SetPlayerVolume(50, 50);
            player.SetMasterVolume(100, 100);

            playerVolumeTrackBarEx.Value = 50;
            masterVolumeTrackBarEx.Value = 100;
            pitchTrackBarEx.Value        = 100;
            rateTrackBarEx.Value         = 100;
        }
Exemplo n.º 4
0
        private void CheckMailbox(object sender, EventArgs args)
        {
            string incomingMessagesTranslationMode = incomingLangComboBox.Text;

            try
            {
                var result = _flowClientWorker.GetMessage(incomingMessagesTranslationMode);

                if (result.Success)
                {
                    if (incomingMessagesRichTextBox.InvokeRequired)
                    {
                        incomingMessagesRichTextBox.Invoke((MethodInvoker)(() =>
                        {
                            incomingMessagesRichTextBox.AppendText(
                                Environment.NewLine + new string('-', 168) +
                                Environment.NewLine +
                                $"From {result.SenderName} [{result.SenderId}] : {result.MessageBody}");
                        }));
                    }
                    else
                    {
                        incomingMessagesRichTextBox.AppendText(
                            Environment.NewLine + new string('-', 168) +
                            Environment.NewLine +
                            $"From {result.SenderName} [{result.SenderId}] : {result.MessageBody}");
                    }

                    try
                    {
                        ZPlay player = new ZPlay();

                        if (player.OpenFile(@"Resources/OwOw.mp3", TStreamFormat.sfAutodetect))
                        {
                            player.SetMasterVolume(100, 100);
                            player.SetPlayerVolume(100, 100);

                            player.StartPlayback();
                        }
                    }
                    catch (Exception)
                    {
                        // I don't care if soundplayer is going crazy
                    }
                }
            }
            catch (Exception exception)
            {
                Debug.WriteLine(exception);
                MessageBox.Show(string.IsNullOrWhiteSpace(exception.Message)
                    ? "Something is wrong: check your server connection"
                    : exception.Message);
            }
        }
Exemplo n.º 5
0
 private void UI_VolumeBar_Scroll(object sender, EventArgs e)
 {
     player.SetPlayerVolume(UI_VolumeBar.Value, UI_VolumeBar.Value);
     Program.Settings.SoundPlayerVolume = UI_VolumeBar.Value;
     Program.Settings.Persist();
 }
Exemplo n.º 6
0
        private void RegisterControlsEvents()
        {
            #region Menu Buttons

            loadAudioFileButtonAdv.Click += (sender, args) => OpenAudioFile(ref Player);

            //secondLoadAudioFileButtonAdv.Click +=
            //    (sender, args) =>
            //    {
            //        OpenAudioFile(secondAxWindowsMediaPlayer, ref _secondAudioFilePath);
            //        this.Height = 600;
            //        secondAxWindowsMediaPlayer.Location = new Point(
            //            firstAxWindowsMediaPlayer.Left,
            //            secondAxWindowsMediaPlayer.Top
            //        );
            //    };

            #endregion

            pitchTrackBarEx.MouseUp += (sender, args) =>
            {
                int pitchValue = ((TrackBarEx)sender).Value;
                pitchNumericUpDown.Value = pitchValue >= 10 ? pitchValue : 10;
            };

            pitchNumericUpDown.ValueChanged += (sender, args) =>
            {
                int pitchValue = (int)((NumericUpDown)sender).Value;
                pitchTrackBarEx.Value = pitchValue;

                Player?.SetPitch(pitchValue);
            };


            // freeeeeeeeeeeee

            frequencyTrackBarEx.MouseUp += (sender, args) =>
            {
                int pitchValue = ((TrackBarEx)sender).Value;
                frequencyNumericUpDown.Value = pitchValue >= 20 ? pitchValue : 20;
            };

            frequencyNumericUpDown.ValueChanged += (sender, args) =>
            {
                int pitchValue = (int)((NumericUpDown)sender).Value;
                frequencyTrackBarEx.Value = pitchValue;

                _metronomePlayer?.SetPitch(pitchValue);
            };

            // periooooooooooooooo

            periodicityTrackBarEx.MouseUp += (sender, args) =>
            {
                int tempoValue = ((TrackBarEx)sender).Value;
                //periodicityTextBox.Text = $@"{BpmToPeriodicity(tempoValue >= 20 ? tempoValue : 20)}";
                periodicityTextBox.Text =
                    $@"{BpmToPeriodicity(periodicityTrackBarEx.Maximum - tempoValue + periodicityTrackBarEx.Minimum)}";
            };

            periodicityTextBox.TextChanged += (sender, args) =>
            {
                decimal periodicityValue = decimal.Parse(periodicityTextBox.Text);
                periodicityTrackBarEx.Value = periodicityTrackBarEx.Maximum - PeriodicityToBPM(periodicityValue) +
                                              periodicityTrackBarEx.Minimum;

                _metronomePlayer?.SetTempo(periodicityTrackBarEx.Maximum - periodicityTrackBarEx.Value +
                                           periodicityTrackBarEx.Minimum);
            };


            //rateTrackBarEx.Click += (sender, args) =>
            //{
            //    int rateValue = ((TrackBarEx)sender).Value;
            //    Player?.SetTempo(rateValue);
            //};

            tempoTrackBarEx.MouseUp += (sender, args) =>
            {
                int tempoValue = ((TrackBarEx)sender).Value;
                tempoNumericUpDown.Value = tempoValue >= 10 ? tempoValue : 10;
            };

            tempoNumericUpDown.ValueChanged += (sender, args) =>
            {
                int tempoValue = (int)((NumericUpDown)sender).Value;
                tempoTrackBarEx.Value = tempoValue;

                Player?.SetTempo(tempoValue);
            };

            reversePlaybackToggleButton.ToggleStateChanged += (sender, args) =>
            {
                if (Player == null)
                {
                    return;
                }

                ToggleButton self = (ToggleButton)sender;

                if (self.ToggleState == ToggleButtonState.Active)
                {
                    Player?.ReverseMode(true);
                }
                else
                {
                    // ToggleButtonState.Inactive
                    Player?.ReverseMode(false);
                }
            };

            playbackProgressBarAdv.MouseDown += (sender, args) =>
            {
                //if (args.Button != MouseButtons.Left)
                //    return;

                TStreamTime newPosition = new TStreamTime();
                TStreamInfo info        = GetStreamInfo(ref Player);

                newPosition.ms = Convert.ToUInt32(
                    args.X * info.Length.ms / Convert.ToDouble(((ProgressBarAdv)sender).Size.Width));


                Player?.Seek(TTimeFormat.tfMillisecond, ref newPosition, TSeekMethod.smFromBeginning);
            };

            _volumeRadialMenuSlider.SliderValueChanged += (sender, args) =>
            {
                int volumeLevel = (int)((RadialMenuSlider)sender).SliderValue;

                if (FFTPictureBox.InvokeRequired)
                {
                    FFTPictureBox.Invoke((MethodInvoker)(() => { Player?.SetPlayerVolume(volumeLevel, volumeLevel); }));
                }
                else
                {
                    Player?.SetPlayerVolume(volumeLevel, volumeLevel);
                }
            };

            volumePictureBox.Click += (sender, args) =>
            {
                _radialMenu = new RadialMenu();

                #region Volume Radial Menu Slider

                _volumeRadialMenuSlider.MinimumValue = 0;
                _volumeRadialMenuSlider.MaximumValue = 100;
                _volumeRadialMenuSlider.SliderValue  = 50;
                _volumeRadialMenuSlider.Text         = "VOLUME";

                #endregion

                #region Radial Menu Properties Settings

                _radialMenu.WedgeCount = 1;

                _radialMenu.MenuIcon =
                    Image.FromFile($@"{Path.GetDirectoryName(Application.ExecutablePath)}\Icons\Volume-high-icon.png");

                _radialMenu.MenuVisibility       = true;
                _radialMenu.PersistPreviousState = true;
                _radialMenu.UseIndexBasedOrder   = true;

                _radialMenu.RadialMenuSliderDrillDown(_volumeRadialMenuSlider);

                #region TRASH

                //_radialMenu.Items.Add(_volumeRadialMenuSlider);
                //_radialMenu.Icon = Image
                //    .FromFile($@"{Path.GetDirectoryName(Application.ExecutablePath)}\Icons\arrow-back-icon.png");


                //ImageCollection ic = new ImageCollection();
                //ic.Add(Image.FromFile($@"{Path.GetDirectoryName(Application.ExecutablePath)}\Icons\arrow-back-icon.png"));

                //_radialMenu.ImageCollection = ic;

                //_radialMenu.DisplayStyle = DisplayStyle.TextAboveImage;
                //ImageList imageList = new ImageList();
                //string[] files = Directory.GetFiles($@"{Path.GetDirectoryName(Application.ExecutablePath)}\Icons");

                //foreach (string file in files)
                //{
                //    imageList.Images.Add("volume", Image.FromFile(file));
                //}

                //_radialMenu.ImageList = ImageListAdv.FromImageList(imageList);

                #endregion

                #endregion

                #region Show Radial Menu

                this.Controls.Add(_radialMenu);
                _radialMenu.ShowRadialMenu();
                //_radialMenu.HidePopup();
                //_radialMenu.ShowPopup(new Point());

                #endregion

                _radialMenu.PreviousLevelOpened += (radialMenuSender, opening) => _radialMenu.Dispose();

                // Emulate mouse click on 50% Volume on _volumeRadialMenuSlider
                // because there's a library bug that cannot update value
                // by .SliderValue property as it's meant to be updated.
                Point location = MousePosition;
                LeftMouseClick(location.X - 40, location.Y + 15);
            };


            FFTPictureBox.Paint += (sender, args) =>
            {
                IntPtr MyDeviceContext = default(IntPtr);
                MyDeviceContext = args.Graphics.GetHdc();
                Player?.DrawFFTGraphOnHDC(MyDeviceContext, 0, 0, FFTPictureBox.Width, FFTPictureBox.Height);
                args.Graphics.ReleaseHdc(MyDeviceContext);
            };

            playToggleButton.ToggleStateChanged += (sender, args) =>
            {
                if (Player == null)
                {
                    return;
                }

                if (playToggleButton.ToggleState == ToggleButtonState.Active)
                {
                    Player.StartPlayback();
                    //_timer.Start();
                    return;
                }
                else
                {
                    Player.StopPlayback(); // ToggleButtonState.Inactive
                    //_timer.Stop();
                }
            };

            metronomeToggleButton.ToggleStateChanged += (sender, args) =>
            {
                if (metronomeToggleButton.ToggleState == ToggleButtonState.Active)
                {
                    if (_metronomePlayer == null)
                    {
                        _metronomePlayer = new ZPlay();
                    }

                    if (_metronomePlayer.OpenFile(@"Resources\metronom.mp3", TStreamFormat.sfAutodetect) == false)
                    {
                        MessageBox.Show($@"ERROR {_metronomePlayer.GetError()}");
                        return;
                    }

                    _metronomePlayer.StartPlayback();

                    _metronomePlayer.SetMasterVolume(100, 100);
                    _metronomePlayer.SetPlayerVolume(100, 100);

                    _isMetronomeSwitch = true;
                }
                else
                {
                    _metronomePlayer.StopPlayback(); // ToggleButtonState.Inactive
                    _isMetronomeSwitch = false;
                }
            };

            playerVolumeTrackBarEx.Scroll += (sender, args) =>
            {
                int volumeLevel = ((TrackBarEx)sender).Value;
                Player?.SetPlayerVolume(volumeLevel, volumeLevel);
            };

            masterVolumeTrackBarEx.Scroll += (sender, args) =>
            {
                int volumeLevel = ((TrackBarEx)sender).Value;
                Player?.SetMasterVolume(volumeLevel, volumeLevel);
            };

            this.MouseDown += (sender, mouseEventArgs) =>
            {
                if (mouseEventArgs.Button == MouseButtons.Left)
                {
                    ReleaseCapture();
                    SendMessage(Handle, WM_NCLBUTTONDOWN, HT_CAPTION, 0);
                }
            };

            closePictureBox.Click += (sender, args) => this.Close();

            #region _secondForm Control Buttons

            ReplayPictureBox.Click      += OnReplayPictureBoxOnClick;
            PlayResumePictureBox.Click  += OnPlayResumePictureBoxOnClick;
            PausePictureBox.Click       += OnPausePictureBoxOnClick;
            StopPictureBox.Click        += OnStopPictureBoxOnClick;
            RewindPictureBox.Click      += OnRewindPictureBoxOnClick;
            FastForwardPictureBox.Click += OnFastForwardPictureBoxOnClick;

            #endregion
        }
Exemplo n.º 7
0
        private void RegisterEventHandlers()
        {
            authButton.Click += (sender, args) =>
            {
                Task.Run(() =>
                {
                    try
                    {
                        bool authenticated = _flowClientWorker.Authenticate(
                            login: authLoginTextBox.Text,
                            password: authPassTextBox.Text);

                        MessageBox.Show($@"Authenticated: {authenticated}");
                    }
                    catch (Exception exception)
                    {
                        Debug.WriteLine(exception);
                        MessageBox.Show(string.IsNullOrWhiteSpace(exception.Message)
                            ? "Something is wrong: check your server connection"
                            : exception.Message);
                    }
                });
            };

            connectToServerButton.Click += (sender, args) =>
            {
                Task.Run(() =>
                {
                    try
                    {
                        bool connected = _flowClientWorker.Connect(
                            ipAddress: IPAddress.Parse(serverIpAddressTextBox.Text.Trim()),
                            port: int.Parse(serverPortTextBox.Text.Trim()));

                        MessageBox.Show($@"Connected: {connected}");
                    }
                    catch (Exception exception)
                    {
                        Debug.WriteLine(exception);
                        MessageBox.Show(string.IsNullOrWhiteSpace(exception.Message)
                            ? "Something is wrong: check your server connection"
                            : exception.Message);
                    }
                });
            };

            registerButton.Click += (sender, args) =>
            {
                Task.Run(() =>
                {
                    try
                    {
                        bool registered = _flowClientWorker.Register(
                            login: registerLoginTextBox.Text,
                            password: registerPassTextBox.Text,
                            name: registerNameTextBox.Text);

                        MessageBox.Show(registered
                            ? @"Registered successfully"
                            : @"Registration failed");
                    }
                    catch (Exception exception)
                    {
                        Debug.WriteLine(exception);
                        MessageBox.Show(string.IsNullOrWhiteSpace(exception.Message)
                            ? "Something is wrong: check your server connection"
                            : exception.Message);
                    }
                });
            };

            translateButton.Click += (sender, args) =>
            {
                Task.Run(() =>
                {
                    if (string.IsNullOrWhiteSpace(translateInputRichTextBox.Text))
                    {
                        return;
                    }
                    try
                    {
                        string inputTextLang  = fromLangComboBox.Text;
                        string outputTextLang = toLangComboBox.Text;

                        string translatedText = _flowClientWorker.Translate(
                            sourceText: translateInputRichTextBox.Text,
                            sourceTextLang: inputTextLang,
                            targetTextLanguage: outputTextLang);

                        if (translateOutputRichTextBox.InvokeRequired)
                        {
                            translateOutputRichTextBox.Invoke((MethodInvoker)(() =>
                            {
                                translateOutputRichTextBox.Text = translatedText;
                            }));
                        }
                        else
                        {
                            translateOutputRichTextBox.Text = translatedText;
                        }
                    }
                    catch (Exception exception)
                    {
                        Debug.WriteLine(exception);
                        MessageBox.Show(string.IsNullOrWhiteSpace(exception.Message)
                            ? "Something is wrong: check your server connection"
                            : exception.Message);
                    }
                });
            };

            sendMessageButton.Click += (sender, args) =>
            {
                Task.Run(() =>
                {
                    if (string.IsNullOrWhiteSpace(outgoingMessagesRichTextBox.Text))
                    {
                        return;
                    }

                    string recipient          = recipientTextBox.Text.Trim();
                    string messageBody        = outgoingMessagesRichTextBox.Text;
                    string sourceTextLanguage = outgoingLangComboBox.Text;

                    try
                    {
                        var result = _flowClientWorker.SendMessage(
                            recipient: recipient,
                            messageText: messageBody,
                            messageTextLang: sourceTextLanguage);

                        if (result.Success)
                        {
                            try
                            {
                                ZPlay player = new ZPlay();

                                if (player.OpenFile(@"Resources/Sent2.mp3", TStreamFormat.sfAutodetect))
                                {
                                    player.SetMasterVolume(100, 100);
                                    player.SetPlayerVolume(100, 100);

                                    player.StartPlayback();
                                }
                            }
                            catch (Exception)
                            {
                                // I don't care if soundplayer is dgoing crazy
                            }
                            //MessageBox.Show($@"{result.ResponseMessage}");
                            outgoingMessagesRichTextBox.Clear();
                        }
                        else
                        {
                            MessageBox.Show(string.IsNullOrWhiteSpace(result.ResponseMessage)
                                ? "Recipient not found"
                                : result.ResponseMessage);
                        }
                    }
                    catch (Exception exception)
                    {
                        Debug.WriteLine(exception);
                        MessageBox.Show(string.IsNullOrWhiteSpace(exception.Message)
                            ? "Something is wrong: check your server connection"
                            : exception.Message);
                    }
                });
            };

            activateOnlineModeButton.Click += (sender, args) =>
            {
                Task.Run(() =>
                {
                    if (_timer != null)
                    {
                        return;
                    }

                    _timer = new Timer
                    {
                        AutoReset = true,
                        Interval  = 3000
                    };

                    _timer.Elapsed += CheckMailbox;
                    _timer.Start();

                    ((Button)sender).FlatAppearance.BorderColor          = Color.DeepSkyBlue;
                    activateOfflineModeButton.FlatAppearance.BorderColor = Color.Gray;
                });
            };

            activateOfflineModeButton.Click += (sender, args) =>
            {
                Task.Run(() =>
                {
                    if (_timer != null)
                    {
                        _timer.Stop();
                        _timer = null;
                    }

                    ((Button)sender).FlatAppearance.BorderColor         = Color.DeepSkyBlue;
                    activateOnlineModeButton.FlatAppearance.BorderColor = Color.Gray;
                });
            };
        }