Example #1
0
        /// <summary>
        ///     This will be called when the menu item in the Editor is clicked
        /// </summary>
        private async Task <string> UploadAsync(ICaptureDetails captureDetails, ISurface surfaceToUpload)
        {
            try
            {
                string url;
                using (var pleaseWaitForm = new PleaseWaitForm("Box", _boxLanguage.CommunicationWait))
                {
                    pleaseWaitForm.Show();
                    try
                    {
                        url = await UploadToBoxAsync(captureDetails, surfaceToUpload).ConfigureAwait(true);
                    }
                    finally
                    {
                        pleaseWaitForm.Close();
                    }
                }

                if (url != null && _boxConfiguration.AfterUploadLinkToClipBoard)
                {
                    ClipboardHelper.SetClipboardData(url);
                }

                return(url);
            }
            catch (Exception ex)
            {
                Log.Error().WriteLine(ex, "Error uploading.");
                MessageBox.Show(_boxLanguage.UploadFailure + " " + ex.Message);
                return(null);
            }
        }
Example #2
0
        public async Task <string> Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload)
        {
            try
            {
                string url;
                using (var pleaseWaitForm = new PleaseWaitForm("GooglePhotos", _googlePhotosLanguage.CommunicationWait))
                {
                    pleaseWaitForm.Show();
                    try
                    {
                        url = await UploadToPicasa(surfaceToUpload);
                    }
                    finally
                    {
                        pleaseWaitForm.Close();
                    }
                }

                if (url != null && _googlePhotosConfiguration.AfterUploadLinkToClipBoard)
                {
                    ClipboardHelper.SetClipboardData(url);
                }
                return(url);
            }
            catch (Exception e)
            {
                Log.Error().WriteLine(e, "Error uploading.");
                MessageBox.Show(_googlePhotosLanguage.UploadFailure + " " + e.Message);
            }
            return(null);
        }
Example #3
0
        // SP - Please Wait Form will start in upper-right quadrant of screen
        // Constructor with no params will start form wherever Windows starts it

        public void StartForm()
        {
            Thread plsWaitThread = new Thread((ThreadStart)(() => Application.Run((Form)PleaseWaitForm)));

            plsWaitThread.SetApartmentState(ApartmentState.STA);
            plsWaitThread.Start();
            PleaseWaitForm.Focus();
        }
Example #4
0
        public PleaseWaitDialog()
        {
            var pleaseWaitForm = new PleaseWaitForm();
            var progress       = new Progress <string>(s => pleaseWaitForm.StatusLabel.Text = s);

            PleaseWaitForm = pleaseWaitForm;
            Progress       = progress;

            StartForm();
        }
        /// <summary>
        /// Upload the capture to OneDrive
        /// </summary>
        /// <param name="captureDetails">ICaptureDetails</param>
        /// <param name="surfaceToUpload">ISurface</param>
        /// <returns>Uri</returns>
        private async Task <Uri> Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload)
        {
            var outputSettings = new SurfaceOutputSettings(_config.UploadFormat, _config.UploadJpegQuality,
                                                           _config.UploadReduceColors);

            try
            {
                string filename = Path.GetFileName(FilenameHelper.GetFilenameFromPattern(_config.FilenamePattern,
                                                                                         _config.UploadFormat, captureDetails));
                Uri response = null;

                var cancellationTokenSource = new CancellationTokenSource();
                using (var pleaseWaitForm = new PleaseWaitForm("OneDrive plug-in", _oneDriveLanguage.CommunicationWait,
                                                               cancellationTokenSource))
                {
                    pleaseWaitForm.Show();
                    try
                    {
                        var oneDriveResponse = await OneDriveUtils.UploadToOneDriveAsync(_oauth2Settings, surfaceToUpload,
                                                                                         outputSettings, captureDetails.Title, filename, null, cancellationTokenSource.Token);

                        response = new Uri(oneDriveResponse.WebUrl);
                    }
                    finally
                    {
                        pleaseWaitForm.Close();
                    }
                }

                if (response != null)
                {
                    if (_config.AfterUploadLinkToClipBoard)
                    {
                        ClipboardHelper.SetClipboardData(response.ToString());
                    }

                    return(response);
                }
            }
            catch (Exception e)
            {
                Log.Error().WriteLine(e, "Error uploading.");
                MessageBox.Show(_oneDriveLanguage.UploadFailure + " " + e.Message);
            }

            return(null);
        }
        private SPList TryGetSPList()
        {
            if (StringUtil.IsNullOrWhitespace(TxtSPListUrl.Text))
            {
                return(null);
            }
            PleaseWaitForm pleaseWait = new PleaseWaitForm();

            try
            {
#if (!DEBUG)
                pleaseWait.Show(this.Parent);
                Application.DoEvents();
#endif
                using (SPSite site = new SPSite(TxtSPListUrl.Text))
                {
                    using (SPWeb web = site.OpenWeb())
                    {
                        Uri curUri = new Uri(TxtSPListUrl.Text);
                        return(SPListHelper.TryGetListByRelativeUrl(web, curUri.PathAndQuery));
                    }
                }
            }
            catch (SPException spex)
            {
                MessageBox.Show(spex.Message);
                Log.Error(spex);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                Log.Error(ex);
            }
            finally
            {
#if (!DEBUG)
                pleaseWait.Close();
#endif
            }
            return(null);
        }
Example #7
0
        // SP - Please Wait Form will start in upper-right quadrant of screen
        // Constructor with no params will start form wherever Windows starts it
        public PleaseWaitDialog(Form currentForm)
        {
            var pleaseWaitForm = new PleaseWaitForm();
            int currentX       = currentForm.Location.X;
            var currentY       = currentForm.Location.Y;
            var currentWidth   = currentForm.Width;
            var currentHeight  = currentForm.Height;

            var startX = (currentWidth / 2) + currentX - (pleaseWaitForm.Width / 2);
            var startY = (currentHeight / 2) + currentY - (pleaseWaitForm.Height / 2);

            pleaseWaitForm.StartPosition = FormStartPosition.Manual;
            pleaseWaitForm.Location      = new Point(startX, startY);

            var progress = new Progress <string>(s => pleaseWaitForm.StatusLabel.Text = s);

            PleaseWaitForm = pleaseWaitForm;
            Progress       = progress;

            StartForm();
        }
Example #8
0
        public async Task <string> Upload(ICaptureDetails captureDetails, ISurface surface)
        {
            string uploadUrl = null;

            var outputSettings = new SurfaceOutputSettings(_flickrConfiguration.UploadFormat, _flickrConfiguration.UploadJpegQuality, false);

            try
            {
                var cancellationTokenSource = new CancellationTokenSource();
                using (var pleaseWaitForm = new PleaseWaitForm("Flickr", _flickrLanguage.CommunicationWait, cancellationTokenSource))
                {
                    pleaseWaitForm.Show();
                    try
                    {
                        var filename = Path.GetFileName(FilenameHelper.GetFilename(_flickrConfiguration.UploadFormat, captureDetails));
                        uploadUrl = await FlickrUtils.UploadToFlickrAsync(surface, outputSettings, captureDetails.Title, filename);
                    }
                    finally
                    {
                        pleaseWaitForm.Close();
                    }
                }


                if (uploadUrl == null)
                {
                    return(null);
                }
                if (_flickrConfiguration.AfterUploadLinkToClipBoard)
                {
                    ClipboardHelper.SetClipboardData(uploadUrl);
                }
            }
            catch (Exception e)
            {
                Log.Error().WriteLine(e, "Error uploading.");
                MessageBox.Show(_flickrLanguage.UploadFailure + " " + e.Message);
            }
            return(uploadUrl);
        }
        /// <summary>
        ///     This will be called when the menu item in the Editor is clicked
        /// </summary>
        private async Task <string> UploadAsync(ICaptureDetails captureDetails, ISurface surfaceToUpload, CancellationToken cancellationToken = default)
        {
            string dropboxUrl     = null;
            var    outputSettings = new SurfaceOutputSettings(_dropboxPluginConfiguration.UploadFormat, _dropboxPluginConfiguration.UploadJpegQuality, false);

            try
            {
                var cancellationTokenSource = new CancellationTokenSource();
                using (var pleaseWaitForm = new PleaseWaitForm("Dropbox", _dropboxLanguage.CommunicationWait, cancellationTokenSource))
                {
                    pleaseWaitForm.Show();
                    try
                    {
                        var filename = Path.GetFileName(FilenameHelper.GetFilename(_dropboxPluginConfiguration.UploadFormat, captureDetails));
                        using (var imageStream = new MemoryStream())
                        {
                            ImageOutput.SaveToStream(surfaceToUpload, imageStream, outputSettings);
                            imageStream.Position = 0;
                            using (var streamContent = new StreamContent(imageStream))
                            {
                                streamContent.Headers.ContentType = new MediaTypeHeaderValue("image/" + outputSettings.Format);
                                dropboxUrl = await UploadAsync(filename, streamContent, null, cancellationToken);
                            }
                        }
                    }
                    finally
                    {
                        pleaseWaitForm.Close();
                    }
                }
            }
            catch (Exception e)
            {
                Log.Error().WriteLine(e);
                MessageBox.Show(_dropboxLanguage.UploadFailure + " " + e.Message);
            }
            return(dropboxUrl);
        }
        private void QueryList()
        {
            PleaseWaitForm pleaseWait = new PleaseWaitForm();

            try
            {
#if (!DEBUG)
                pleaseWait.Show(this.Parent);
                Application.DoEvents();
#endif
                if (StringUtil.IsNullOrWhitespace(TxtSPListUrl.Text))
                {
                    return;
                }
                curList = TryGetSPList();
                if (curList == null)
                {
                    return;
                }
                PopulateSchema(curList.SchemaXml);
                PopulateListData(curList, curList.Items.GetDataTable());
                PopulatePropertiesDropDown(curList);
                ListTabs.SelectedTab = TabData;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                Log.Error(ex);
            }
            finally
            {
#if (!DEBUG)
                pleaseWait.Close();
#endif
            }
        }
Example #11
0
        /// <summary>
        /// Upload the capture to imgur
        /// </summary>
        /// <param name="captureDetails">ICaptureDetails</param>
        /// <param name="surfaceToUpload">ISurface</param>
        /// <returns>Uri</returns>
        private async Task <Uri> Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload)
        {
            var outputSettings = new SurfaceOutputSettings(_imgurConfiguration.UploadFormat, _imgurConfiguration.UploadJpegQuality, _imgurConfiguration.UploadReduceColors);

            try
            {
                string     filename = Path.GetFileName(FilenameHelper.GetFilenameFromPattern(_imgurConfiguration.FilenamePattern, _imgurConfiguration.UploadFormat, captureDetails));
                ImgurImage imgurImage;

                var cancellationTokenSource = new CancellationTokenSource();
                using (var pleaseWaitForm = new PleaseWaitForm("Imgur plug-in", _imgurLanguage.CommunicationWait, cancellationTokenSource))
                {
                    pleaseWaitForm.Show();
                    try
                    {
                        imgurImage = await ImgurUtils.UploadToImgurAsync(_oauth2Settings, surfaceToUpload, outputSettings, captureDetails.Title, filename, null, cancellationTokenSource.Token);

                        if (imgurImage != null)
                        {
                            // Create thumbnail
                            using (var tmpImage = surfaceToUpload.GetBitmapForExport())
                                using (var thumbnail = tmpImage.CreateThumbnail(90, 90))
                                {
                                    imgurImage.Image = thumbnail.ToBitmapSource();
                                }
                            if (_imgurConfiguration.AnonymousAccess && _imgurConfiguration.TrackHistory)
                            {
                                Log.Info().WriteLine("Storing imgur upload for hash {0} and delete hash {1}", imgurImage.Data.Id, imgurImage.Data.Deletehash);
                                _imgurConfiguration.ImgurUploadHistory.Add(imgurImage.Data.Id, imgurImage.Data.Deletehash);
                                _imgurConfiguration.RuntimeImgurHistory.Add(imgurImage.Data.Id, imgurImage);

                                // TODO: Update History - ViewModel!!!
                                // UpdateHistoryMenuItem();
                            }
                        }
                    }
                    finally
                    {
                        pleaseWaitForm.Close();
                    }
                }

                if (imgurImage != null)
                {
                    var uploadUrl = _imgurConfiguration.UsePageLink ? imgurImage.Data.LinkPage: imgurImage.Data.Link;
                    if (uploadUrl == null || !_imgurConfiguration.CopyLinkToClipboard)
                    {
                        return(uploadUrl);
                    }

                    try
                    {
                        ClipboardHelper.SetClipboardData(uploadUrl.AbsoluteUri);
                    }
                    catch (Exception ex)
                    {
                        Log.Error().WriteLine(ex, "Can't write to clipboard: ");
                        uploadUrl = null;
                    }
                    return(uploadUrl);
                }
            }
            catch (Exception e)
            {
                Log.Error().WriteLine(e, "Error uploading.");
                MessageBox.Show(_imgurLanguage.UploadFailure + " " + e.Message);
            }
            return(null);
        }
Example #12
0
        /// <summary>
        /// Upload the capture to lutim
        /// </summary>
        /// <param name="captureDetails">ICaptureDetails</param>
        /// <param name="surfaceToUpload">ISurface</param>
        /// <param name="uploadUrl">out string for the url</param>
        /// <returns>true if the upload succeeded</returns>
        private async Task <string> Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload)
        {
            string uploadUrl;
            SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(_lutimConfiguration.UploadFormat, _lutimConfiguration.UploadJpegQuality, _lutimConfiguration.UploadReduceColors);

            try
            {
                string    filename = Path.GetFileName(FilenameHelper.GetFilenameFromPattern(_lutimConfiguration.FilenamePattern, _lutimConfiguration.UploadFormat, captureDetails));
                LutimInfo lutimInfo;

                var cancellationTokenSource = new CancellationTokenSource();
                using (var pleaseWaitForm = new PleaseWaitForm("Lutim", _lutimLanguage.CommunicationWait, cancellationTokenSource))
                {
                    pleaseWaitForm.Show();
                    try
                    {
                        lutimInfo = await LutimUtils.UploadToLutim(surfaceToUpload, outputSettings, filename);

                        if (lutimInfo != null)
                        {
                            Log.Info().WriteLine("Storing lutim upload for hash {0} and delete hash {1}",
                                                 lutimInfo.Short, lutimInfo.Token);
                            // TODO: Write somewhere
                            // _lutimConfiguration.LutimUploadHistory.Add(lutimInfo.Short, lutimInfo.ToIniString());
                            _lutimConfiguration.RuntimeLutimHistory.Add(lutimInfo.Short, lutimInfo);
                            // TODO: Update
                            // UpdateHistoryMenuItem();
                        }
                    }
                    finally
                    {
                        pleaseWaitForm.Close();
                    }
                }


                if (lutimInfo != null)
                {
                    uploadUrl = lutimInfo.Short;
                    if (string.IsNullOrEmpty(uploadUrl) || !_lutimConfiguration.CopyLinkToClipboard)
                    {
                        return(uploadUrl);
                    }
                    try
                    {
                        ClipboardHelper.SetClipboardData(uploadUrl);
                    }
                    catch (Exception ex)
                    {
                        Log.Error().WriteLine(ex, "Can't write to clipboard: ");
                        return(null);
                    }
                    return(uploadUrl);
                }
            }
            catch (Exception e)
            {
                Log.Error().WriteLine(e, "Error uploading.");
                MessageBox.Show(_lutimLanguage.UploadFailure + " " + e.Message);
            }
            return(null);
        }
Example #13
0
        private void btnStop_Click(object sender, EventArgs e)
        {
            PleaseWaitWorker pleaseWaitWorker = new PleaseWaitWorker();
            PleaseWaitForm pleaseWaitForm = new PleaseWaitForm();
            pleaseWaitWorker.pleaseWaitForm.ShowInTaskbar = false;
            pleaseWaitWorker.pleaseWaitForm.StartPosition = FormStartPosition.Manual; //manual artinya diatur oleh Location
            int XPoint = this.Location.X + this.Width / 2 - pleaseWaitWorker.pleaseWaitForm.Width / 2;
            int YPoint = this.Location.Y + this.Height / 2 - pleaseWaitWorker.pleaseWaitForm.Height / 2;
            pleaseWaitWorker.pleaseWaitForm.Location = new Point(XPoint, YPoint);

            Thread pleaseWaitThread = new Thread(pleaseWaitWorker.Show);
            pleaseWaitThread.Start();

            Console.WriteLine("Stop recording");
            WaitAllThreadStop();
            Console.WriteLine("Closing connection");
            db.CloseConnection();

            pleaseWaitForm.Dispose();
            pleaseWaitThread.Abort();

            //TODO : Clear all queue in RabbitMQ

            this.btnStart.Enabled = true;
            this.ckLisBxSensor.Enabled = true;
            this.btnStart.FlatStyle = FlatStyle.Standard;
            this.btnStart.BackColor = SystemColors.ButtonFace;
            this.btnStop.Enabled = false;
        }