public async Task SwitchToDesktopAsync()
        {
            IUserMessage response;
            EmbedBuilder initialBuilder;


            initialBuilder = EmbedHelper.GetDefaultEmbed(Context);
            initialBuilder.AddField(":desktop: Switching to desktop", "Please wait...");

            response = await ReplyAsync("", embed : initialBuilder.Build());

            try {
                ScreenCaptureProvider provider;
                IntPtr       windowHandle;
                EmbedBuilder embed;
                const int    WM_COMMAND = 0x111;
                const int    MIN_ALL    = 419;


                embed        = EmbedHelper.GetDefaultEmbed(Context);
                provider     = new ScreenCaptureProvider(_config);
                windowHandle = User32.GetDesktopWindow();

                IntPtr lHwnd = User32.FindWindow("Shell_TrayWnd", null);
                User32.SendMessage(lHwnd, WM_COMMAND, (IntPtr)MIN_ALL, IntPtr.Zero);

                User32.SetForegroundWindow(windowHandle);

                embed.AddField(":white_check_mark: Success", "The desktop should now be in focus.");

                await response.ModifyAsync(msg => { msg.Embed = embed.Build(); msg.Content = ""; });
            } catch (Exception e) {
                await response.ModifyAsync(msg => msg = ErrorHandler.GetDefaultErrorMessageEmbed(e, msg, Context.Message));
            }
        }
        public async Task GetScreenStatusAsync()
        {
            IUserMessage response;
            EmbedBuilder initialBuilder;


            initialBuilder = EmbedHelper.GetDefaultEmbed(Context);
            initialBuilder.AddField(":camera_with_flash: Uploading screenshot", "Please wait...");

            response = await ReplyAsync("", embed : initialBuilder.Build());

            try {
                ScreenCaptureProvider provider;
                IntPtr                windowHandle;
                EmbedBuilder          embed;
                Stopwatch             watch;
                Stopwatch             uploadWatch;
                ISupportedImageFormat format;
                TextLayer             watermark;
                Byte[]                imageBytes;


                watch       = new Stopwatch();
                uploadWatch = new Stopwatch();

                watch.Start();

                embed    = EmbedHelper.GetDefaultEmbed(Context);
                provider = new ScreenCaptureProvider(_config);

                // Get the desktop window rather than the GTA window, if there is an application
                // blocking the GTA window then taking a screenshot of the GTA window won't really
                // show any problems. Getting the desktop window will grab the currently active desktop.
                windowHandle = User32.GetDesktopWindow();

                format = new JpegFormat {
                    Quality = 50
                };
                imageBytes = provider.CaptureWindow(windowHandle);

                watermark = BuildWatermark(windowHandle);

                using (var stream = new MemoryStream(imageBytes)) {
                    using (MemoryStream outStream = new MemoryStream()) {
                        // Initialize the ImageFactory using the overload to preserve EXIF metadata.
                        using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true)) {
                            imageFactory.Load(stream)
                            .Format(format)
                            .Watermark(watermark)
                            .Save(outStream);
                        }

                        watch.Stop();

                        embed.AddField(":camera_with_flash: Success", "Current status of the host machine is shown below.");
                        embed.AddField(":alarm_clock: Action time", watch.Elapsed.ToShortForm(), inline: true);

                        uploadWatch.Start();

                        await Context.Channel.SendFileAsync(outStream, "window.jpg");
                    }
                }

                uploadWatch.Stop();
                embed.AddField(":alarm_clock: Upload time", uploadWatch.Elapsed.ToShortForm(), inline: true);

                await response.ModifyAsync(msg => { msg.Embed = embed.Build(); msg.Content = ""; });
            } catch (Exception e) {
                await response.ModifyAsync(msg => msg = ErrorHandler.GetDefaultErrorMessageEmbed(e, msg, Context.Message));
            }
        }
Beispiel #3
0
        public async Task GrabPlayerList()
        {
            IUserMessage response;
            EmbedBuilder initialBuilder;


            initialBuilder = EmbedHelper.GetDefaultEmbed(Context);
            initialBuilder.AddField(":camera_with_flash: Capturing Player List", "Please wait...");

            response = await ReplyAsync("", embed : initialBuilder.Build());

            try {
                Byte[] imageBytes;
                ScreenCaptureProvider provider;
                EmbedBuilder          embed;
                ISupportedImageFormat format;


                embed    = EmbedHelper.GetDefaultEmbed(Context);
                provider = new ScreenCaptureProvider(_config);

                format = new JpegFormat {
                    Quality = 50
                };
                imageBytes = provider.MergePlayerList();

                using (var stream = new MemoryStream(imageBytes)) {
                    using (MemoryStream outStream = new MemoryStream()) {
                        // Initialize the ImageFactory using the overload to preserve EXIF metadata.
                        using (ImageFactory imageFactory = new ImageFactory(preserveExifData: true)) {
                            imageFactory.Load(stream)
                            .Format(format)
                            .Save(outStream);
                        }
                        TimeSpan span;
                        string   dateString;


                        span       = (DateTime.Now - File.GetLastWriteTimeUtc(Common.PlayerListFirstScreenshotPath));
                        dateString = "";

                        if (span.Days > 0)
                        {
                            dateString += $"{span.Days} days, ";
                        }

                        if (span.Hours > 0)
                        {
                            dateString += $"{span.Hours} hours, ";
                        }

                        if (span.Minutes > 0)
                        {
                            dateString += $"{span.Minutes} minutes, ";
                        }

                        dateString += $"{span.Seconds} seconds";
                        embed.AddField(":pencil: Current Player List", $"List age: {dateString} old");

                        await Context.Channel.SendFileAsync(outStream, "players.jpg");
                    }
                }

                await response.ModifyAsync(msg => { msg.Embed = embed.Build(); msg.Content = ""; });
            } catch (Exception e) {
                await response.ModifyAsync(msg => msg = ErrorHandler.GetDefaultErrorMessageEmbed(e, msg, Context.Message));
            }
        }