C# Screenshot nur wenn ein bestimmter Prozess vorhanden ist?

[PeterParty]

Hi @ All

Ich Schreibe grade ein Programm was jede 10 Sekunden ein Screenshot macht und es auf eine Website hochlädt....

Ich möchte das er nur Screenshots von einem bestimmten Programm macht dem MS Flugsimulator 2004 oder MS Flugsimulator X (egal ob FS minimiert oder ausgewählt wurde)

Wie ich überprüfen kann ob der Prozess vorhanden ist, ist ja kein Problem nur wie kann ich einen Screenshot nur von dem Prozess machen?

Ich bekomme es nur hin einen Screenshot vom Aktivien Windows Fenster zu machen!?

Code zum erstellen des Screenshot`s

        private void screenshot()
        {
            string screenshot = callsign + ".jpg";
            string screenshot1 = callsign + "Thumb.jpg";
            Image.GetThumbnailImageAbort myCallback = new Image.GetThumbnailImageAbort(ThumbnailCallback);
            Bitmap bmp = new Bitmap(this.Width, this.Height);
            Screenshot screen = new Screenshot();
            bmp = screen.ActiveWindow();
            Image myThumbnail = bmp.GetThumbnailImage(1280, 800, myCallback, IntPtr.Zero);
            Image myThumbnail1 = bmp.GetThumbnailImage(100, 79, myCallback, IntPtr.Zero);
            myThumbnail.Save(screenshot, ImageFormat.Jpeg);
            myThumbnail1.Save(screenshot1, ImageFormat.Jpeg);

        }

evtl. kann mir ja jemand helfen


MfG
Peter

 

[Simpson474]

Ich denke nicht, dass es dafür eine Windows-Funktion gibt. Einzige Möglichkeit wäre, wenn der Flight-Simulator selbst eine Screenshot-Funktion hat - in diesem Fall könntest du möglicherweise entsprechende Events/Tastencodes an den Flight-Simulator senden.

 

[Krik]

Äh, wäre es nicht besser und leichter, einfach die laufenden Prozesse auszulesen und dann dort die Eigenschaften von Prozess xy auszulesen? Das sind dieselben Eigenschaften, die der Taskmanager auch anzeigt.

Bsp:

Process thisProc = Process.GetCurrentProcess();

while (true)
{
    Console.WriteLine("\n\nProcessName:" + thisProc.ProcessName);
    Console.WriteLine("Process: {0}, ID: {1}", thisProc.StartTime, thisProc.Id);
    Console.WriteLine("    CPU time: {0}", thisProc.TotalProcessorTime);
    Console.WriteLine("    priority class: {0}  priority: {1}", thisProc.PriorityClass, thisProc.BasePriority);
    Console.WriteLine("    virtual memory: {0}", thisProc.VirtualMemorySize);
    Console.WriteLine("    private memory: {0}", thisProc.PrivateMemorySize);
    Console.WriteLine("    physical memory: {0}", thisProc.WorkingSet);

    System.Threading.Thread.Sleep(1000);
}

Wenn man das hat, ist es ein leichtes zB eine HTML-Seite oder ein Bild zu machen, das diese Informationen beinhaltet.

 

[lynxx]

using System;
using System.Diagnostics;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;

/// <summary>
/// Klasse zum erzeugen beliebiger Screenshots
/// </summary>
public class Screenshot {
  private struct RECT {
    public int Left;
    public int Top;
    public int Right;
    public int Bottom;
  }

  [DllImport("user32.dll", SetLastError = true)]
  public static extern bool BringWindowToTop(IntPtr hWnd);
  
  [DllImport("user32.dll")]
  public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);

  [DllImport("user32.dll")]
  public static extern int GetForegroundWindow();

  /// <summary>
  /// Erzeugt ein Screenshot vom gesamten Desktop.
  /// </summary>
  /// <returns>Bitmap</returns>
  public static Bitmap WholeDesktop() {
    return CreateScreenshot(0, 0, Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height);
  }

  /// <summary>
  /// Erzeugt ein Screenshot vom aktiven Fenster.
  /// </summary>
  /// <returns>Bitmap</returns>
  public static Bitmap ActiveWindow() {
    return CreateScreenshot((System.IntPtr)GetForegroundWindow());
  }


  /// <summary>
  /// Erzeugt ein Screenshot vom MainWindowHandle des Übergebenen Prozessnamen oder NULL (Prozess nicht gefunden)
  /// </summary>
  /// <param name="topleft">Punkt des Bereich oben - links</param>
  /// <param name="bottomRight">Punkt des Bereich unten - rechts</param>
  /// <returns>Bitmap</returns>
  public static Bitmap MakeProcessScreenShot(String procName) {
    Bitmap bmp = null;
    Process[] thisProc = Process.GetProcessesByName(procName);
    if (thisProc.Length != 0) {
      IntPtr windowhandle = thisProc[0].MainWindowHandle;
      BringWindowToTop(windowhandle);
      bmp = UserDefinedWindowHandle(windowhandle);
    }
    return bmp;
  }

  
  /// <summary>
  /// Erzeugt ein Screenshot vom übergebenen Bereich.
  /// </summary>
  /// <param name="topleft">Punkt des Bereich oben - links</param>
  /// <param name="bottomRight">Punkt des Bereich unten - rechts</param>
  /// <returns>Bitmap</returns>
  public static Bitmap UserDefined(Point topleft, Point bottomRight) {
    return CreateScreenshot(topleft.X, topleft.Y, bottomRight.X, bottomRight.Y);
  }

  /// <summary>
  /// Erzeugt ein Screenshot vom definierten Bereich
  /// </summary>
  /// <param name="left">Punkt des Bereichs links</param>
  /// <param name="top">Punkt des Bereichs oben</param>
  /// <param name="width">Breite</param>
  /// <param name="height">Höhe</param>
  /// <returns>Bitmap</returns>
  public static Bitmap CreateScreenshot(int left, int top, int width, int height) {
    Bitmap bmp = new Bitmap(width, height);
    Graphics g = Graphics.FromImage(bmp);
    g.CopyFromScreen(left, top, 0, 0, new Size(width, height));
    g.Dispose();
    return bmp;
  }

  /// <summary>
  /// Erzeugt ein Screenshot vom Fenster des übergebenen Handels
  /// </summary>
  /// <param name="windowhandle"></param>
  /// <returns>Bitmap</returns>
  public static Bitmap UserDefinedWindowHandle(IntPtr windowhandle) {
    return CreateScreenshot(windowhandle);
  }

  /// <summary>
  /// Erzeugt ein Screenshot vom definierten windowhandle
  /// </summary>
  /// <returns>Bitmap</returns>
  public static Bitmap CreateScreenshot(IntPtr windowhandle) {
    RECT windowRectangle;
    GetWindowRect(windowhandle, out windowRectangle);
    return CreateScreenshot(windowRectangle.Left, windowRectangle.Top, windowRectangle.Right - windowRectangle.Left, windowRectangle.Bottom - windowRectangle.Top);
  }
}

Und dann per:

Bitmap bmp = Screenshot.MakeProcessScreenShot("MS Flugsimulator X");
bmp.Save(fileName);

speichern.

Alle aktuellen Prozessnamen ausgeben:

Process[] thisProc = Process.GetProcesses();
for (int i = 0; i < thisProc.Length; i++) {
  Console.WriteLine(thisProc[i].ProcessName);
}

 

[Tailtinn]

Alternativ kann man auch die PrintWindow Methode verwenden. Dann muss das Fenster nicht im Vordergrund sein:

[DllImport("user32.dll")]
private static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);

[DllImport("user32.dll")]
public static extern bool PrintWindow(IntPtr hWnd, IntPtr hdcBlt, int nFlags);

private struct RECT
{
    public int Left;
    public int Top;
    public int Right;
    public int Bottom;
}

public static Bitmap CaptureWindow(IntPtr windowhandle, PixelFormat pixelFormat = PixelFormat.Format32bppArgb)
{
    RECT windowRectangle;
    Bitmap bitmap = null;
    Graphics graphics = null;
    IntPtr hdcBitmap = IntPtr.Zero;

    GetWindowRect(windowhandle, out windowRectangle);

    bitmap = new Bitmap(windowRectangle.Right - windowRectangle.Left, windowRectangle.Bottom - windowRectangle.Top, pixelFormat);
    graphics = Graphics.FromImage(bitmap);
    hdcBitmap = graphics.GetHdc();

    PrintWindow(windowhandle, hdcBitmap, 0);

    graphics.ReleaseHdc(hdcBitmap);
    graphics.Dispose();

    return bitmap;
}

 

[PeterParty]

Danke für eure Hilfe, ich werde es heute am späteren Abend ausprobieren!
Ich werde mich melde ob es funktioniert hat

MfG
Peter

Ergänzung (6. Januar 2012)

Ich bekomme beim DLL Import einen Fehler

    [DllImport("user32.dll")]
    public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);

Inkonsistenter Zugriff: Parametertyp "out Screenshot.RECT" ist weniger zugreifbar als Methode "Screenshot.GetWindowRect(System.IntPtr, out Screenshot.RECT)"

Woran kann das liegen?

MfG
Peter

 

[Grantig]

Na die Fehlermeldung ist doch wirklich selbsterklärend.

Du deklarierst die GetWindowRect Methode public, aber die RECT Structure ist nur private.
Also deklarier am besten GetWindowRect private. (oder eben RECT public)

 

[PeterParty]

@Tailtinn

Danke es funktioniert nun alles, das einzige problem was ich noch hab ist, das wenn ich auf minimieren gehe das er danach nur Screenshots von der oberen leiste macht und nicht vom haptfenster!?

Kann man das noch hinbekommen das er nur ein screenshot von Hauptfenster macht?

MfG
Peter