コード例 #1
0
 /// <summary>
 /// The background worker run worker completed.
 /// </summary>
 /// <param name="sender">
 /// The sender.
 /// </param>
 /// <param name="e">
 /// The e.
 /// </param>
 private void BackgroundWorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
 {
     ButtonProgressAssist.SetIsIndeterminate(this.ButtonRefresh, false);
     this.TextBlockWait.Visibility = Visibility.Collapsed;
     this.ButtonRefresh.IsEnabled  = true;
     MessageBox.Show("Data Updated Successfully!");
 }
コード例 #2
0
        private void buttonOnClick(object sender, EventArgs e)
        {
            Button button = sender as Button;

            ButtonProgressAssist.SetIsIndicatorVisible(button, true);
            ButtonProgressAssist.SetIsIndeterminate(button, true);
            int i = (int)button.Tag;

            Debug.WriteLine(i + "-" + links[i]);
            downloadAndOpen(links[i], button);
        }
コード例 #3
0
        /// <summary>
        /// The tile refresh on click.
        /// </summary>
        /// <param name="sender">
        /// The sender.
        /// </param>
        /// <param name="e">
        /// The e.
        /// </param>
        private void ButtonRefreshOnClick(object sender, RoutedEventArgs e)
        {
            ButtonProgressAssist.SetIsIndeterminate(this.ButtonRefresh, true);
            this.TextBlockWait.Visibility = Visibility.Visible;
            this.ButtonRefresh.IsEnabled  = false;

            this.backgroundWorker                     = new BackgroundWorker();
            this.backgroundWorker.DoWork             += this.BackgroundWorkerDoWork;
            this.backgroundWorker.RunWorkerCompleted += this.BackgroundWorkerRunWorkerCompleted;

            try
            {
                this.backgroundWorker.RunWorkerAsync();
            }
            catch (Exception exception)
            {
                MessageBox.Show(exception.Message);
            }
        }
コード例 #4
0
        private async void  downloadAndOpen(string v, Button button)
        {
            var path = await v.DownloadFileAsync(AppDomain.CurrentDomain.BaseDirectory, "filed.torrent");

            ButtonProgressAssist.SetIsIndicatorVisible(button, false);
            ButtonProgressAssist.SetIsIndeterminate(button, false);
            Debug.WriteLine("Path : " + path);
            try
            {
                Process.Start(new ProcessStartInfo(path)
                {
                    UseShellExecute = true
                });
            }
            catch
            {
                Debug.WriteLine("Error");
                MessageBox.Show("Make sure any Torrent client is installed");
            }
        }
コード例 #5
0
        /// <summary>
        /// The background worker do work.
        /// </summary>
        /// <param name="sender">
        /// The sender.
        /// </param>
        /// <param name="e">
        /// The e.
        /// </param>
        private async void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
        {
            this.Dispatcher.Invoke(() => ButtonProgressAssist.SetIsIndeterminate(this.ButtonRefresh, true));

            #region Zone And Division

            var zoneAndDivisionModel =
                StaticDbContext.ConnectFireStore.GetCollectionFields <ZoneAndDivision>("Root", "Employee");

            DataHelper.ZoneAndDivisionModel = zoneAndDivisionModel;

            var jsonResult = JsonConvert.SerializeObject(zoneAndDivisionModel, Formatting.Indented);

            var zoneAndDivisionFile = Path.Combine(DataHelper.JsonFolderPath, Properties.Resources.ZoneAndDivisionJson);

            if (File.Exists(zoneAndDivisionFile))
            {
                File.Delete(zoneAndDivisionFile);
            }

            using (var streamWriter = new StreamWriter(zoneAndDivisionFile, true))
            {
                await streamWriter.WriteLineAsync(jsonResult).ConfigureAwait(false);

                streamWriter.Close();
            }

            #endregion

            #region Stations

            if (DataHelper.ZoneAndDivisionModel != null)
            {
                var stationsList = new StationsList {
                    Stations = new Dictionary <string, Station>()
                };

                foreach (var zone in DataHelper.ZoneAndDivisionModel.ZoneList)
                {
                    var collectionList = StaticDbContext.ConnectFireStore.GetCollections(
                        "Root",
                        "Stations",
                        "StationDetails",
                        zone);

                    foreach (var collectionReference in collectionList)
                    {
                        var stations = StaticDbContext.ConnectFireStore.GetAllDocumentData <Station>(
                            "Root",
                            "Stations",
                            "StationDetails",
                            zone,
                            collectionReference.Id);

                        foreach (var station in stations)
                        {
                            stationsList.Stations.Add(new KeyValuePair <string, Station>(station.StationCode, station));
                        }
                    }
                }

                DataHelper.StationsList = stationsList;

                var jsonResult2 = JsonConvert.SerializeObject(stationsList, Formatting.Indented);

                var stationsJson = Path.Combine(DataHelper.JsonFolderPath, Properties.Resources.StationsListJson);

                if (File.Exists(stationsJson))
                {
                    File.Delete(stationsJson);
                }

                using (var streamWriter = new StreamWriter(stationsJson, true))
                {
                    await streamWriter.WriteLineAsync(jsonResult2).ConfigureAwait(false);

                    streamWriter.Close();
                }
            }

            #endregion
        }
コード例 #6
0
 /// <summary>
 /// The background worker run worker completed.
 /// </summary>
 /// <param name="sender">
 /// The sender.
 /// </param>
 /// <param name="e">
 /// The e.
 /// </param>
 private void BackgroundWorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
 {
     ButtonProgressAssist.SetIsIndeterminate(this.ButtonRefresh, false);
 }
コード例 #7
0
        public HomeView()
        {
            InitializeComponent();

            this.WhenActivated(disposables =>
            {
                // Link and Start
                this.Bind(ViewModel,
                          viewModel => viewModel.Link,
                          view => view.linkTextBox.Text)
                .DisposeWith(disposables);

                linkTextBox.Events().KeyDown
                .Where(x => x.Key == Key.Enter)
                .Select(x => Unit.Default)
                .InvokeCommand(ViewModel !.StartDownloadCommand)           // Null forgiving reason: upstream limitation.
                .DisposeWith(disposables);

                this.OneWayBind(ViewModel,
                                viewModel => viewModel.BackendService.GlobalDownloadProgressPercentage,
                                view => view.downloadButton.Content,
                                percentage => percentage > 0.0 ? percentage.ToString("P1") : "_Download")
                .DisposeWith(disposables);

                // ButtonProgressAssist bindings
                ViewModel.WhenAnyValue(x => x.BackendInstance.IsRunning)
                .ObserveOn(RxApp.MainThreadScheduler)
                .Subscribe(x =>
                {
                    ButtonProgressAssist.SetIsIndicatorVisible(downloadButton, x);
                    ButtonProgressAssist.SetIsIndicatorVisible(listFormatsButton, x);
                })
                .DisposeWith(disposables);

                ViewModel.WhenAnyValue(x => x.BackendService.ProgressState)
                .Select(x => x == TaskbarItemProgressState.Indeterminate)
                .ObserveOn(RxApp.MainThreadScheduler)
                .Subscribe(x => ButtonProgressAssist.SetIsIndeterminate(downloadButton, x))
                .DisposeWith(disposables);

                ViewModel.WhenAnyValue(x => x.BackendService.GlobalDownloadProgressPercentage)
                .ObserveOn(RxApp.MainThreadScheduler)
                .Subscribe(x => ButtonProgressAssist.SetValue(downloadButton, x * 100))
                .DisposeWith(disposables);

                ViewModel.WhenAnyValue(x => x.BackendService.ProgressState)
                .Select(x => x == TaskbarItemProgressState.Indeterminate)
                .ObserveOn(RxApp.MainThreadScheduler)
                .Subscribe(x => ButtonProgressAssist.SetIsIndeterminate(listFormatsButton, x))
                .DisposeWith(disposables);

                // presetComboBox
                this.OneWayBind(ViewModel,
                                viewModel => viewModel.Presets,
                                view => view.presetComboBox.ItemsSource)
                .DisposeWith(disposables);

                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.SelectedPreset,
                          view => view.presetComboBox.SelectedItem)
                .DisposeWith(disposables);

                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.SelectedPresetText,
                          view => view.presetComboBox.Text)
                .DisposeWith(disposables);

                // Subtitles
                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.DownloadSubtitles,
                          view => view.subtitlesDefaultCheckBox.IsChecked)
                .DisposeWith(disposables);

                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.DownloadSubtitlesAllLanguages,
                          view => view.subtitlesAllLanguagesCheckBox.IsChecked)
                .DisposeWith(disposables);

                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.DownloadAutoGeneratedSubtitles,
                          view => view.subtitlesAutoGeneratedCheckBox.IsChecked)
                .DisposeWith(disposables);

                // Options row 1
                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.AddMetadata,
                          view => view.metadataToggle.IsChecked)
                .DisposeWith(disposables);

                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.DownloadThumbnail,
                          view => view.thumbnailToggle.IsChecked)
                .DisposeWith(disposables);

                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.DownloadPlaylist,
                          view => view.playlistToggle.IsChecked)
                .DisposeWith(disposables);

                // Options row 2
                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.UseCustomOutputTemplate,
                          view => view.filenameTemplateToggle.IsChecked)
                .DisposeWith(disposables);

                this.OneWayBind(ViewModel,
                                viewModel => viewModel.SharedSettings.UseCustomOutputTemplate,
                                view => view.filenameTemplateTextBox.IsEnabled)
                .DisposeWith(disposables);

                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.CustomOutputTemplate,
                          view => view.filenameTemplateTextBox.Text)
                .DisposeWith(disposables);

                // Options row 3
                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.UseCustomPath,
                          view => view.pathToggle.IsChecked)
                .DisposeWith(disposables);

                this.OneWayBind(ViewModel,
                                viewModel => viewModel.SharedSettings.UseCustomPath,
                                view => view.pathComboBox.IsEnabled)
                .DisposeWith(disposables);

                this.OneWayBind(ViewModel,
                                viewModel => viewModel.DownloadPathHistory,
                                view => view.pathComboBox.ItemsSource)
                .DisposeWith(disposables);

                this.Bind(ViewModel,
                          viewModel => viewModel.SharedSettings.DownloadPath,
                          view => view.pathComboBox.Text)
                .DisposeWith(disposables);

                // Arguments
                this.OneWayBind(ViewModel,
                                viewModel => viewModel.DownloadArguments,
                                view => view.argumentsItemsControl.ItemsSource)
                .DisposeWith(disposables);

                // Output
                this.Bind(ViewModel,
                          viewModel => viewModel.QueuedTextBoxSink.Content,
                          view => view.resultTextBox.Text)
                .DisposeWith(disposables);

                resultTextBox.Events().TextChanged
                .Where(_ => WpfHelper.IsScrolledToEnd(resultTextBox))
                .Subscribe(_ => resultTextBox.ScrollToEnd())
                .DisposeWith(disposables);

                // Download, list, abort button
                this.BindCommand(ViewModel,
                                 viewModel => viewModel.StartDownloadCommand,
                                 view => view.downloadButton)
                .DisposeWith(disposables);

                this.BindCommand(ViewModel,
                                 viewModel => viewModel.ListFormatsCommand,
                                 view => view.listFormatsButton)
                .DisposeWith(disposables);

                this.BindCommand(ViewModel,
                                 viewModel => viewModel.AbortDlCommand,
                                 view => view.abortButton)
                .DisposeWith(disposables);

                // Browse and open folder button
                this.BindCommand(ViewModel,
                                 viewModel => viewModel.BrowseDownloadFolderCommand,
                                 view => view.browseButton)
                .DisposeWith(disposables);

                this.BindCommand(ViewModel,
                                 viewModel => viewModel.OpenDownloadFolderCommand,
                                 view => view.openFolderButton)
                .DisposeWith(disposables);

                // Reset custom filename template button
                this.BindCommand(ViewModel,
                                 viewModel => viewModel.ResetCustomFilenameTemplateCommand,
                                 view => view.resetFilenameTemplateButton)
                .DisposeWith(disposables);

                // Custom preset buttons
                this.BindCommand(ViewModel,
                                 viewModel => viewModel.OpenAddCustomPresetDialogCommand,
                                 view => view.addPresetButton)
                .DisposeWith(disposables);

                this.BindCommand(ViewModel,
                                 viewModel => viewModel.OpenEditCustomPresetDialogCommand,
                                 view => view.editPresetButton)
                .DisposeWith(disposables);

                this.BindCommand(ViewModel,
                                 viewModel => viewModel.DuplicatePresetCommand,
                                 view => view.duplicatePresetButton)
                .DisposeWith(disposables);

                this.BindCommand(ViewModel,
                                 viewModel => viewModel.DeleteCustomPresetCommand,
                                 view => view.deletePresetButton)
                .DisposeWith(disposables);
            });
        }
コード例 #8
0
        private void LoginBTN_Clicked(object sender, RoutedEventArgs e)
        {
            Button btn = sender as Button;

            MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndeterminate(btn, true);
            MaterialDesignThemes.Wpf.ButtonProgressAssist.SetValue(btn, -1);
            MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndicatorVisible(btn, true);
            btn.IsEnabled       = false;
            SignupBTN.IsEnabled = false;
            bool EverythingFine = true;

            if (String.IsNullOrEmpty(UsernameBox.Text))
            {
                UsernameBox.GetBindingExpression(TextBox.TextProperty);
                ValidationError validationError = new ValidationError(new NotEmptyValidationRule(), UsernameBox.GetBindingExpression(TextBox.TextProperty));
                validationError.ErrorContent = "Field is required.";

                Validation.MarkInvalid(
                    UsernameBox.GetBindingExpression(TextBox.TextProperty),
                    validationError);
                EverythingFine = false;
            }
            else
            {
                Validation.ClearInvalid(UsernameBox.GetBindingExpression(TextBox.TextProperty));
            }
            if (String.IsNullOrEmpty(PasswordBox.Password))
            {
                PasswordBox.GetBindingExpression(TextBox.TextProperty);
                ValidationError validationError = new ValidationError(new NotEmptyValidationRule(), PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty));
                validationError.ErrorContent = "Field is required.";

                Validation.MarkInvalid(
                    PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty),
                    validationError);
                EverythingFine = false;
            }
            else if (PasswordBox.Password.Length < 1)
            {
                PasswordBox.GetBindingExpression(TextBox.TextProperty);
                ValidationError validationError = new ValidationError(new NotEmptyValidationRule(), PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty));
                validationError.ErrorContent = "At least 8 characters.";

                Validation.MarkInvalid(
                    PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty),
                    validationError);
                EverythingFine = false;
            }
            else
            {
                Validation.ClearInvalid(PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty));
            }
            if (EverythingFine)
            {
                LoginRequest loginRequest = new LoginRequest();
                loginRequest.username = UsernameBox.Text;
                loginRequest.password = PasswordBox.Password;

                app.communicator.SocketSendReceive(JsonSerializer.serializeRequest(loginRequest, Constants.LOGIN_REQUEST_CODE)).ContinueWith(task =>
                {
                    ResponseInfo response       = task.Result;
                    LoginResponse loginResponse = JsonDeserializer.deserializeResponse <LoginResponse>(response.buffer);
                    switch (loginResponse.status)
                    {
                    case Constants.LOGIN_SUCCESS:
                        MyMessageQueue.Enqueue("Sign in Successfully!");
                        this.Dispatcher.Invoke(() =>
                        {
                            app.username         = UsernameBox.Text;
                            NavigationService ns = NavigationService.GetNavigationService(this);
                            ns.Navigate(new Uri("Menu.xaml", UriKind.Relative));
                        });
                        break;

                    case Constants.LOGIN_INCORRECT_PASSWORD:
                        MyMessageQueue.Enqueue("Incorrect password.");
                        break;

                    case Constants.LOGIN_USERNAME_NOT_EXIST:
                        MyMessageQueue.Enqueue("Username not exist.");
                        break;

                    case Constants.LOGIN_UNEXPECTED_ERR:
                        MyMessageQueue.Enqueue("There was an unexpected error.");
                        break;

                    case Constants.LOGIN_ALREADY_ONLINE:
                        MyMessageQueue.Enqueue("This Username is already online.");
                        break;
                    }
                    this.Dispatcher.Invoke(() =>
                    {
                        ButtonProgressAssist.SetIsIndeterminate(btn, false);
                        ButtonProgressAssist.SetIsIndicatorVisible(btn, false);
                        btn.IsEnabled       = true;
                        SignupBTN.IsEnabled = true;
                    });
                });
            }
            else
            {
                MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndeterminate(btn, false);
                MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndicatorVisible(btn, false);
                btn.IsEnabled       = true;
                SignupBTN.IsEnabled = true;
            }
        }
コード例 #9
0
ファイル: MainWindow.xaml.cs プロジェクト: Ayalos/Importador
        private void btnImport_Click_1(object sender, RoutedEventArgs e)
        {
            ButtonProgressAssist.SetIsIndeterminate(btnImport, true);

            BancoInfo info = new BancoInfo();

            info.Instancia1    = lblInstancia.Text;
            info.NomeServidor1 = lblNomeServe.Text;

            Conexao conec = new Conexao(info);

            ImportacaoEnti   inserirEnti = new ImportacaoEnti(conec);
            ImportacaoProd   inserirProd = new ImportacaoProd(conec);
            ImportacaoDoc    inserirDoc  = new ImportacaoDoc(conec);
            ImportacaoFilial inserirFil  = new ImportacaoFilial(conec);
            ImportacaoEmp    inserirEmp  = new ImportacaoEmp(conec);
            ImportConsignado inserirCon  = new ImportConsignado(conec);

            checkEntidade.IsChecked = inserirEnti.ChecarEntidade();
            if (checkHiper.IsChecked == true)
            {
                try
                {
                    inserirEmp.InsertCME();
                    MessageBox.Show("Empresa Cadastrada");
                } catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
                if (checkFilial.IsChecked == true)
                {
                    try
                    {
                        inserirFil.InserFilial();
                    } catch (Exception ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }
                }
                if (checkEntidade.IsChecked == true)
                {
                    try
                    {
                        inserirEnti.ImportPerf();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }
                }
                if (checkProd.IsChecked == true)
                {
                    try
                    {
                        inserirProd.InserEnderec();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }
                }

                if (checkDoc.IsChecked == true)
                {
                    try
                    {
                        inserirDoc.DocumentoDuplicado();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }
                }

                if (checkCon.IsChecked == true)
                {
                    try
                    {
                        inserirCon.ImportarConsignado();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }
                }
                if (checkCfop.IsChecked == true)
                {
                    inserirProd.UpdateCFOP();
                    try
                    {
                        inserirProd.InserCFOP();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }
                }

                MessageBox.Show("Importação do Hiper Legado concluída");
            }
            ImportMiniEnti InserMiniEnti = new ImportMiniEnti(conec);
            ImportMiniProd InserMiniProd = new ImportMiniProd(conec);

            if (checkHiperMini.IsChecked == true)
            {
                if (checkMiniEnt.IsChecked == true)
                {
                    try
                    {
                        InserMiniEnti.InsertEnti();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }
                }
                if (checkMiniProd.IsChecked == true)
                {
                    try
                    {
                        InserMiniProd.InsertMarca();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.ToString());
                    }
                }
                if (checkMiniCFOP.IsChecked == true)
                {
                    InserMiniProd.UpdateMiniCFOP();
                    InserMiniProd.InserMiniCFOP();
                }

                MessageBox.Show("Importação do Hiper Mini Concluída");
            }
            ButtonProgressAssist.SetIsIndeterminate(btnImport, false);
        }
コード例 #10
0
        private void CreateBTN_Click(object sender, RoutedEventArgs e)
        {
            Button btn = sender as Button;

            MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndeterminate(btn, true);
            MaterialDesignThemes.Wpf.ButtonProgressAssist.SetValue(btn, -1);
            MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndicatorVisible(btn, true);
            btn.IsEnabled = false;
            bool allFine = true;

            MaxPlayersBox.Text = new String(MaxPlayersBox.Text.Where(Char.IsDigit).ToArray());
            if (MaxPlayersBox.Text.Length > 3)
            {
                MaxPlayersBox.Text = MaxPlayersBox.Text.Substring(0, 3);
            }
            if (String.IsNullOrEmpty(MaxPlayersBox.Text))
            {
                setError(MaxPlayersBox, "Field is required.");
                allFine = false;
            }
            else
            {
                int count = int.Parse(MaxPlayersBox.Text);
                if (count > 15)
                {
                    setError(MaxPlayersBox, "Can't be more than 15 players.");
                    allFine = false;
                }
                else if (count < 2)
                {
                    setError(MaxPlayersBox, "Can't be less than 2 players.");
                    allFine = false;
                }
                else
                {
                    Validation.ClearInvalid(MaxPlayersBox.GetBindingExpression(TextBox.TextProperty));
                }
            }
            QuestionsBox.Text = new String(QuestionsBox.Text.Where(Char.IsDigit).ToArray());
            if (QuestionsBox.Text.Length > 3)
            {
                QuestionsBox.Text = QuestionsBox.Text.Substring(0, 3);
            }
            if (String.IsNullOrEmpty(QuestionsBox.Text))
            {
                setError(QuestionsBox, "Field is required.");
                allFine = false;
            }
            else
            {
                int count = int.Parse(QuestionsBox.Text);
                if (count > 20)
                {
                    setError(QuestionsBox, "Can't be more than 20 questions.");
                    allFine = false;
                }
                else if (count < 2)
                {
                    setError(QuestionsBox, "Can't be less than 2 questions.");
                    allFine = false;
                }
                else
                {
                    Validation.ClearInvalid(QuestionsBox.GetBindingExpression(TextBox.TextProperty));
                }
            }
            SecondsBox.Text = new String(SecondsBox.Text.Where(Char.IsDigit).ToArray());
            if (SecondsBox.Text.Length > 3)
            {
                SecondsBox.Text = SecondsBox.Text.Substring(0, 3);
            }
            if (String.IsNullOrEmpty(SecondsBox.Text))
            {
                setError(SecondsBox, "Field is required.");
                allFine = false;
            }
            else
            {
                int count = int.Parse(SecondsBox.Text);
                if (count > 100)
                {
                    setError(SecondsBox, "Can't be more than 100 seconds.");
                    allFine = false;
                }
                else if (count < 10)
                {
                    setError(SecondsBox, "Can't be less than 10 seconds.");
                    allFine = false;
                }
                else
                {
                    Validation.ClearInvalid(SecondsBox.GetBindingExpression(TextBox.TextProperty));
                }
            }
            if (String.IsNullOrEmpty(RoomNameBox.Text))
            {
                setError(RoomNameBox, "Field is required.");
                allFine = false;
            }
            else
            {
                Validation.ClearInvalid(RoomNameBox.GetBindingExpression(TextBox.TextProperty));
            }
            if (allFine)
            {
                CreateRoomRequest createRoomRequest = new CreateRoomRequest();
                createRoomRequest.answerTimeout = int.Parse(SecondsBox.Text);
                createRoomRequest.maxUsers      = int.Parse(MaxPlayersBox.Text);
                createRoomRequest.questionCount = int.Parse(QuestionsBox.Text);
                createRoomRequest.roomName      = RoomNameBox.Text;
                app.communicator.SocketSendReceive(JsonSerializer.serializeRequest(createRoomRequest, Constants.CREATE_ROOM_REQUEST_CODE)).ContinueWith(task =>
                {
                    ResponseInfo response = task.Result;
                    CreateRoomResponse createRoomResponse = JsonDeserializer.deserializeResponse <CreateRoomResponse>(response.buffer);
                    switch (createRoomResponse.status)
                    {
                    case Constants.CREATE_ROOM_SUCCESS:
                        MyMessageQueue.Enqueue("Room Created Successfully!");
                        this.Dispatcher.Invoke(() =>
                        {
                            app.admin            = true;
                            NavigationService ns = NavigationService.GetNavigationService(this);
                            ns.Navigate(new Uri("RoomLobby.xaml", UriKind.Relative));
                        });
                        break;

                    case Constants.CREATE_ROOM_MAXIMUM_ROOMS_IN_SERVER:
                        MyMessageQueue.Enqueue("Max rooms reached.\nTry again later.");
                        break;
                    }
                    this.Dispatcher.Invoke(() =>
                    {
                        ButtonProgressAssist.SetIsIndeterminate(btn, false);
                        ButtonProgressAssist.SetIsIndicatorVisible(btn, false);
                        btn.IsEnabled = true;
                    });
                });
            }
            else
            {
                ButtonProgressAssist.SetIsIndeterminate(btn, false);
                ButtonProgressAssist.SetIsIndicatorVisible(btn, false);
                btn.IsEnabled = true;
            }
        }
コード例 #11
0
ファイル: Requests.xaml.cs プロジェクト: marktabz/EncodeMe
        private async void Button_OnClick(object sender, RoutedEventArgs e)
        {
            if (CurrentWork?.Result == ResultCodes.Success)
            {
                MainTransitioner.SelectedIndex = 3;
                Content.SelectedIndex          = 2;
                return;
            }

            var NextButton = (Button)sender;

            if (MainViewModel.Instance.Encoder == null)
            {
                MainTransitioner.SelectedIndex = 1;
                PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast);
                return;
            }

            if (workFetched)
            {
                return;
            }
            workFetched = true;
            ButtonProgressAssist.SetIsIndicatorVisible(NextButton, true);
            ButtonProgressAssist.SetIsIndeterminate(NextButton, true);
            var work = await Client.GetNextWork();

            CurrentWork         = work;
            Student.DataContext = work.Student;
            ButtonProgressAssist.SetIsIndicatorVisible(NextButton, false);
            ButtonProgressAssist.SetIsIndeterminate(NextButton, false);
            //_encoderMagic.IsGenieOut = false;
            var errorMessage = "";

            switch (work.Result)
            {
            case ResultCodes.Success:
                WorkDataGrid.ItemsSource = work.ClassSchedules;
                //_workMagic.IsGenieOut = true;
                MainTransitioner.SelectedIndex = 3;
                Content.SelectedIndex          = 2;
                LoginLamp.Visibility           = Visibility.Collapsed;
                StudentId.Text   = work.StudentId;
                StudentName.Text = work.StudentName;
                break;

            case ResultCodes.NotFound:
                //MessageBox.Show("No more pending items.");
                errorMessage = "No more requests";
                break;

            case ResultCodes.Offline:
                errorMessage = "Can not find server";
                break;

            case ResultCodes.Timeout:
                errorMessage = "Request timeout";
                break;

            case ResultCodes.Error:
                errorMessage = "Request timeout";
                break;
            }


            await ShowMessage(errorMessage);


            workFetched = false;
        }