Inheritance: System.ComponentModel.BackgroundWorker
        internal PublishStatusControl(HighlightObject highlightObject, PublishWorker.PublishWorkerTypes publishWorkerType)
            : this(highlightObject)
        {
            this.publishWorkerType = publishWorkerType;

            ConnectEvents();
        }
        private void highlightObject_FacebookShareWorkerUpdated(object sender, EventArgs e)
        {
            _publishWorker = _highlightObject.FacebookShareWorker;
            switch (_publishWorker.PublishWorkerResult)
            {
                case PublishWorker.PublishWorkerResults.Cancelled:
                    ShowCancelled("Cancelled sharing to facebook");
                    break;

                case PublishWorker.PublishWorkerResults.NotFinished:
                    ShowWorking("Sharing to facebook (" + _publishWorker.Progress + "%)");
                    break;

                case PublishWorker.PublishWorkerResults.Success:
                    ShowCompleted("Shared to facebook", new LinkArea(10, 8));
                    break;

                case PublishWorker.PublishWorkerResults.UnableToSplice:
                case PublishWorker.PublishWorkerResults.UnableToShare:
                    ShowError("Error saving to facebook");
                    break;

                default:
                    throw new NotImplementedException();
            }
        }
        private void Publish()
        {
            string backgroundWorkerArgument = "";

            if (PublishWorkerType == PublishWorker.PublishWorkerTypes.Facebook)
            {
                var progress = TutorialHelper.GetTutorialProgress();
                if (progress == TutorialProgress.TutorialShareButton)
                { // don't actually share
                    Logger.Info("Simulating facebook sharing due to tutorial");
                    OnAdvanceTutorial();
                    return;
                }

                // make sure we have access token
                if (Properties.Settings.Default.FacebookAccessToken.Length == 0 ||
                    Properties.Settings.Default.FacebookAccessTokenExpiration < DateTime.Now)
                {
                    if (FacebookHelper.LoginToFacebook() == false)
                    {
                        return;
                    }
                }

                if (CurrentHighlight.FacebookShareWorker != null)
                {
                    CurrentHighlight.FacebookShareWorker.Dispose();
                    CurrentHighlight.FacebookShareWorker = null;
                }

                CurrentHighlight.FacebookShareWorker = new FacebookShareWorker(CurrentHighlight);
                publishWorker = CurrentHighlight.FacebookShareWorker;
            }
            else if (PublishWorkerType == OdessaGUIProject.Workers.PublishWorker.PublishWorkerTypes.Save)
            {
                using (var saveFileDialog = new SaveFileDialog())
                {
                    saveFileDialog.Title = "Where should we save your highlight?";

                    if (Properties.Settings.Default.LastSavedDirectory.Length == 0)
                        saveFileDialog.InitialDirectory = MainModel.GetMyVideosDirectory();
                    else
                        saveFileDialog.InitialDirectory = Properties.Settings.Default.LastSavedDirectory;

                    string originalExtension = CurrentHighlight.InputFileObject.SourceFileInfo.Extension; // includes dot
                    saveFileDialog.FileName = CurrentHighlight.Title + originalExtension;

                    SaveWorker.OutputFormats outputFormat = (SaveWorker.OutputFormats)Enum.Parse(typeof(SaveWorker.OutputFormats), Properties.Settings.Default.SaveOutputFormat);
                    if (outputFormat == SaveWorker.OutputFormats.Original)
                        saveFileDialog.Filter = "Videos (*" + originalExtension + ")|*" + originalExtension + "|All files (*.*)|*.*";
                    else if (outputFormat == SaveWorker.OutputFormats.ProRes)
                        saveFileDialog.Filter = "ProRes Videos (*.mov)|*.mov|All files (*.*)|*.*";

                    if (saveFileDialog.ShowDialog() != DialogResult.OK)
                    {
                        return;
                    }

                    Properties.Settings.Default.LastSavedDirectory = Path.GetDirectoryName(saveFileDialog.FileName);
                    Properties.Settings.Default.Save();

                    currentHighlight.Title = Path.GetFileNameWithoutExtension(saveFileDialog.FileName);

                    backgroundWorkerArgument = saveFileDialog.FileName;

                    if (CurrentHighlight.SaveWorker != null)
                    {
                        CurrentHighlight.SaveWorker.Dispose();
                        CurrentHighlight.SaveWorker = null;
                    }

                    CurrentHighlight.SaveWorker = new SaveWorker(CurrentHighlight);
                    CurrentHighlight.SaveWorker.OutputFormat = outputFormat;
                    publishWorker = CurrentHighlight.SaveWorker;
                }
            }

            publishWorker.ProgressChanged += publishWorker_ProgressChanged;
            publishWorker.RunWorkerCompleted += publishWorker_RunWorkerCompleted;
            publishWorker.RunWorkerAsync(backgroundWorkerArgument);

            UpdateUI();
        }
        private void highlightObject_SaveWorkerUpdated(object sender, EventArgs e)
        {
            _publishWorker = _highlightObject.SaveWorker;
            switch (_publishWorker.PublishWorkerResult)
            {
                case PublishWorker.PublishWorkerResults.Cancelled:
                    ShowCancelled("Cancelled saving as video file");
                    break;

                case PublishWorker.PublishWorkerResults.NotFinished:
                    ShowWorking("Saving as video file (" + _publishWorker.Progress + "%)...");
                    break;

                case PublishWorker.PublishWorkerResults.Success:
                    ShowCompleted("Saved as video file", new LinkArea(9, 10));
                    break;

                case PublishWorker.PublishWorkerResults.UnableToSplice:
                    ShowError("Error saving as video file");
                    break;
                default:
                    throw new NotImplementedException();
            }
        }
Ejemplo n.º 5
0
        private void RunWorker(PublishWorker publishWorker)
        {
            ActivePublishWorkers.Add(publishWorker);

            try
            {
                publishWorker.RunWorkerAsync(outputDirectoryPath);
                while (publishWorker.IsBusy)
                { // wait for the scanworker to finish
                    if (CancellationPending)
                        publishWorker.CancelAsync();

                    System.Threading.Thread.Sleep(500);

                }
            }
            catch (Exception ex)
            {
                Logger.Error("Error starting PublishWorker! {0}", ex.ToString());
            }

            Logger.Info("PublishWorker[" + publishWorker.Id + "] ended with result " + publishWorker.PublishWorkerResult.ToString());
            ActivePublishWorkers.RemoveAt(0);
            CompletedPublishWorkers.Add(publishWorker);
            bankedProgressUnits += publishWorker.TotalProgressUnits;
        }