Resolution, Position und Frequenz aus Fenster und Vollbild Modus aus Prozesse lesen.

  • VB.NET

Es gibt 66 Antworten in diesem Thema. Der letzte Beitrag () ist von Xiantrius.

    Resolution, Position und Frequenz aus Fenster und Vollbild Modus aus Prozesse lesen.

    hi Leute,
    Habe ein anderes experiment versucht, doch leider ist es wie erwartet gescheitert.
    Habe versucht statt direkt ein Monitor ein Prozessfenster anzusprechen. Hat auch von Code her funktioniert.
    Aber der Ausführung wird nicht angenommen.

    Wie die ChangeResolution aufgerufen werden kann findet ihr unter diesen Thread.
    Eigener Code Bildschirmauflösung ändern & externe Prozess HWND kleines problem


    funktioniert nicht, oder doch? vielleicht wenn es für Prozess HWND's über diese API was gibt.

    VB.NET-Quellcode

    1. For Each Prozess In Process.GetProcessesByName("notepad")
    2. ChangeResolution(CUInt(Prozess.MainWindowHandle), 640, 480)
    3. Next


    Natürlich gibt es ja noch eine andere API wo man das steuern kann das ist mir klar. Allerdings funktioniert das nur bei Anwendungen die in Fenstermodus laufen, wenn ich mich nicht irre. Jedenfalls reagiert meine Vollbildanwendung überhaupt nicht drauf, weil er die Werte in den Modus nicht findet.
    Hab da kleines Beispiel der Sub TestResHWND greift auf den WindowHandle zu und die API kann Position und die Auflösung des Fensters ändern.
    Wie geht das bei Vollbild Anwendungen?
    Die API kennt ihr bestimmt.

    VB.NET-Quellcode

    1. <Runtime.InteropServices.DllImport("user32.dll")>
    2. Private Shared Function SetWindowPos(ByVal hWnd As IntPtr, ByVal hWndInsertAfter As IntPtr, ByVal X As Integer, ByVal Y As Integer, ByVal cx As Integer, ByVal cy As Integer, ByVal uFlags As Integer) As Boolean
    3. End Function
    4. Public Enum SetWindowPosFlags As UInteger
    5. ''' <summary>If the calling thread and the thread that owns the window are attached to different input queues,
    6. ''' the system posts the request to the thread that owns the window. This prevents the calling thread from
    7. ''' blocking its execution while other threads process the request.</summary>
    8. ''' <remarks>SWP_ASYNCWINDOWPOS</remarks>
    9. SynchronousWindowPosition = &H4000
    10. ''' <summary>Prevents generation of the WM_SYNCPAINT message.</summary>
    11. ''' <remarks>SWP_DEFERERASE</remarks>
    12. DeferErase = &H2000
    13. ''' <summary>Draws a frame (defined in the window's class description) around the window.</summary>
    14. ''' <remarks>SWP_DRAWFRAME</remarks>
    15. DrawFrame = &H20
    16. ''' <summary>Applies new frame styles set using the SetWindowLong function. Sends a WM_NCCALCSIZE message to
    17. ''' the window, even if the window's size is not being changed. If this flag is not specified, WM_NCCALCSIZE
    18. ''' is sent only when the window's size is being changed.</summary>
    19. ''' <remarks>SWP_FRAMECHANGED</remarks>
    20. FrameChanged = &H20
    21. ''' <summary>Hides the window.</summary>
    22. ''' <remarks>SWP_HIDEWINDOW</remarks>
    23. HideWindow = &H80
    24. ''' <summary>Does not activate the window. If this flag is not set, the window is activated and moved to the
    25. ''' top of either the topmost or non-topmost group (depending on the setting of the hWndInsertAfter
    26. ''' parameter).</summary>
    27. ''' <remarks>SWP_NOACTIVATE</remarks>
    28. DoNotActivate = &H10
    29. ''' <summary>Discards the entire contents of the client area. If this flag is not specified, the valid
    30. ''' contents of the client area are saved and copied back into the client area after the window is sized or
    31. ''' repositioned.</summary>
    32. ''' <remarks>SWP_NOCOPYBITS</remarks>
    33. DoNotCopyBits = &H100
    34. ''' <summary>Retains the current position (ignores X and Y parameters).</summary>
    35. ''' <remarks>SWP_NOMOVE</remarks>
    36. IgnoreMove = &H2
    37. ''' <summary>Does not change the owner window's position in the Z order.</summary>
    38. ''' <remarks>SWP_NOOWNERZORDER</remarks>
    39. DoNotChangeOwnerZOrder = &H200
    40. ''' <summary>Does not redraw changes. If this flag is set, no repainting of any kind occurs. This applies to
    41. ''' the client area, the nonclient area (including the title bar and scroll bars), and any part of the parent
    42. ''' window uncovered as a result of the window being moved. When this flag is set, the application must
    43. ''' explicitly invalidate or redraw any parts of the window and parent window that need redrawing.</summary>
    44. ''' <remarks>SWP_NOREDRAW</remarks>
    45. DoNotRedraw = &H8
    46. ''' <summary>Same as the SWP_NOOWNERZORDER flag.</summary>
    47. ''' <remarks>SWP_NOREPOSITION</remarks>
    48. DoNotReposition = &H200
    49. ''' <summary>Prevents the window from receiving the WM_WINDOWPOSCHANGING message.</summary>
    50. ''' <remarks>SWP_NOSENDCHANGING</remarks>
    51. DoNotSendChangingEvent = &H400
    52. ''' <summary>Retains the current size (ignores the cx and cy parameters).</summary>
    53. ''' <remarks>SWP_NOSIZE</remarks>
    54. IgnoreResize = &H1
    55. ''' <summary>Retains the current Z order (ignores the hWndInsertAfter parameter).</summary>
    56. ''' <remarks>SWP_NOZORDER</remarks>
    57. IgnoreZOrder = &H4
    58. ''' <summary>Displays the window.</summary>
    59. ''' <remarks>SWP_SHOWWINDOW</remarks>
    60. ShowWindow = &H40
    61. End Enum
    62. 'Beispiel Ausführung
    63. Private Sub TestResHWND
    64. For Each Prozess In Process.GetProcessesByName("notepad")
    65. '1 = HWND , 2 = X Position, 3 = Y Position, 4 = Bildschirmbreite, 5 = Bildschirmlänge, 6 = K.A was da hin soll
    66. SetWindowPos(Prozess.MainWindowHandle, Nothing, 0, 0, 640, 480, 0)
    67. Next
    68. End Sub

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Xiantrius“ ()

    tl;dr
    Spekulatius: Solange eine App im Vollbild ist, ergibt es keinen Sinn, die Größe/Position zu ändern, denn sie sind durch den Vollbildmodus festgelegt. Dementsprechend muss die App erstmal aus dem Vollbildmodus "befreit werden", bevor da Änderungen möglich sind.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.
    Vollzitat des direkten Vorposts an dieser Stelle entfernt ~VaporiZed

    Das mit der Position ändern wäre tatsächlich bei Vollbild sinnlos. Aber wie stehts mit der Auflösung ändern?
    Die Auflösung kann ich ja bereits bei eine Fenstermodus Anwendung ändern wie der Prozess notepad.exe.
    Also die frage ist:
    Ich habe eine Anwendung egal welche, die aber nicht aus mein Projekt ist sondern externe Anwendung auf mein Rechner im Vollbild laufen.
    Wie bekomme ich sie in Fenstermodus, und dannach wieder in Vollbildmodus?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    Xiantrius schrieb:

    wie stehts mit der Auflösung ändern?
    Vielleicht denken wir in ne andere Richtung, aber die Auflösung ist doch durch Windows (falls zutreffend) vorgegeben. Die "Auflösung" einer Fensterapp zu ändern bedeutet doch in Wirklichkeit nur, die Fenstergröße zu ändern. Aber bei einer Vollbildapp ist die Größe fix, nämlich die Größe = Bildschirmauflösung. Wenn Du ne Vollbildapp in der Auflösung ändern willst, müsstest Du die Windows-Anzeige-Einstellung ändern (s. Anhang). Sowas wollte ich mal für einen meiner User auf Knopfdruck machen (Grund: Kombination aus Kurzsichtigkeit und Unwillen, eine Brille zu tragen), aber hab es bis heute nicht geschafft (zuwenig Recherche).
    Ich weiß daher auch nicht, was Du damit bezwecken willst, eine (Fremd)App in den Fenster- und danach wieder in den Vollbildmodus bringen zu wollen. Die Auflösung ändert sich dadurch ja nicht.
    Bilder
    • Resolution.png

      5,58 kB, 374×303, 17 mal angesehen
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.
    Hi

    Es gibt APIs mit denen Du erst einmal das MainWindow fragen kannst, im welchem WindowsState (Maximized, Minimized, Normal) es sich befindet. Entsprechend sendet man dann eine Message in welchem WindowsState sich das MainWindow dann schalten soll.
    Mfg -Franky-
    Aber das bringt ja nix, weil die Auflösung für ne Vollbild-App m.E. nur über die OS-Einstellung geändert werden kann. Aber würde mich nicht wundern, wenn Du dafür auch ne API-Lösung kennst.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.
    Vollzitat eines Vorposts an dieser Stelle entfernt ~VaporiZed

    Man kann aber die MainWindowHandle direkt von Prozess abfragen. Das kriege ich auch ohne API hin geht ja nur um die MainWindow Form. Nur mit welcher API kann ich abfragen ob es in Vollbildmodus ist, welche kann ich mit Parameter sagen die Form soll aus den Vollbildmous irgendwie die Auflösung für den Vollbildmodus ändern? Wenn man ja bei spielen in config dateien, oder direkt über Optionen ist kann man das dort auch ändern bei manchen unerstützt das auch Fenstermodus und Vollbildmodus einstellungen häufig bei neueren Spielen möglich.
    Es gibt auch alte Spiele die keine Option im Spiel haben aber eine Config Datei um das eventuel dann zu tun.
    Kann man das über VB.NET über eine bestimmte API auf exterenen Prozess irgendwie steuern, wenn es in Vollbild ist zb. Auflösung während den Vollbildmodus ändern?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    DU kannst den "WindowState" so abfragen:

    1. GetWindowPlacement
    docs.microsoft.com/en-us/windo…inuser-getwindowplacement
    2. Die Struktur WINDOWPLACEMENT
    docs.microsoft.com/en-us/windo…s-winuser-windowplacement

    Die WINDOWPLACEMENT Struktur hat ein Feld mit dem Namen cmdShow
    das kannste dann auswerten, hier mehr Daten(Die SW_.... Konstanten)
    docs.microsoft.com/en-us/windo…ser/nf-winuser-showwindow

    Schau mal wegen der funktion bei pinvoke.net vorbei.
    Also hab das auf eine Vollbild Anwendung getestet
    Wenn die Anwendung gerade in Vollbild ist dann ist der Wert = 1 Normal und nicht Maximiert weis aber nicht ob das normal ist.
    Wenn minimiert ist der Wert auf 2 das passt soweit.
    Ist es in Fenstermodus ist es als Normal Wert 1.

    Der wahre Vollbildmodus ka wie der geht.

    VB.NET-Quellcode

    1. <Runtime.InteropServices.DllImport("user32.dll")>
    2. Private Shared Function GetWindowPlacement(ByVal hWnd As IntPtr, ByRef lpwndpl As WINDOWPLACEMENT) As Boolean
    3. End Function
    4. <Runtime.InteropServices.DllImport("user32.dll")>
    5. Private Shared Function GetWindowRect(ByVal hWnd As Runtime.InteropServices.HandleRef, ByRef lpRect As RECT) As Boolean
    6. End Function
    7. Public Structure POINTAPI
    8. Public X As Int32
    9. Public Y As Int32
    10. End Structure
    11. <Runtime.InteropServices.StructLayout(Runtime.InteropServices.LayoutKind.Sequential)> Public Structure RECT
    12. Public Left As Integer
    13. Public Top As Integer
    14. Public Right As Integer
    15. Public Bottom As Integer
    16. End Structure
    17. Public Structure WINDOWPLACEMENT
    18. Public Length As Int32
    19. Public flags As Int32
    20. Public showCmd As Int32
    21. Public ptMinPosition As POINTAPI
    22. Public ptMaxPosition As POINTAPI
    23. Public rcNormalPosition As RECT
    24. End Structure
    25. Dim intRet As Integer
    26. Dim wpTemp As WINDOWPLACEMENT
    27. Private Sub PrüfeWindowedModus()
    28. Dim intRet As Integer
    29. Dim wpTemp As WINDOWPLACEMENT
    30. For Each Prozess As Process In Process.GetProcessesByName(TextBox1.Text)
    31. wpTemp.Length = System.Runtime.InteropServices.Marshal.SizeOf(wpTemp)
    32. intRet = CInt(GetWindowPlacement(Prozess.MainWindowHandle, wpTemp))
    33. Next
    34. If wpTemp.showCmd = 1 Then
    35. 'normal
    36. ElseIf wpTemp.showCmd = 2 Then
    37. 'minimized
    38. ElseIf wpTemp.showCmd = 3 Then
    39. 'maximized
    40. End If
    41. TextBox2.Text = intRet & " # " & wpTemp.showCmd.ToString
    42. End Sub
    43. Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
    44. PrüfeWindowedModus()
    45. End Sub

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Xiantrius“ ()

    @Xiantrius Check nochmal die APIs bezüglich der Parameter. Ich hoffe die kopierst nicht einfach so irgendwoher ohne zu prüfen ob diese stimmen. Pinvoke.net -> Schüttel und Grusel. Struct RECT kannst auch durch .Net Rectangle ersetzen. POINTAPI durch .Net Point. Warum CInt(GetWindowPlacement und wozu soll das sein wenn du die Rückgabe der API sowieso nicht auswertest ob diese Erfolgreich war oder nicht? Gibt Prozess.MainWindowHandle immer ein Handle zurück? Und nochwas, wo genau prüfst du den WindowsState? Außerhalb der Schleife?

    Ansonsten : Ich kann auch ein Fenster mit/ohne Border usw in den gleichen Dimensionen des Monitores anzeigen. Das Fenster hat aber nicht den State Maximized.
    Mfg -Franky-

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „-Franky-“ ()

    Die Rückgabe war erfolgreich, sonst würde er nicht auf minimiert den Wert 2 nehmen und in Vollbild 1 nehmen.
    Ich habe Option Strict On darum CInt(GetWindowPlacement.
    Trotzdem er hat den Handle gefunden.
    TextBox2.Text = intRet & " # " & wpTemp.showCmd.ToString damit habe ich es ausgegeben.

    Nach meiner Erfahrung wenn es nicht ein muss ist sollte man immer hinter der schleife das Ergebnis anzeigen lassen.
    Nur wenn er jetzt durch sucht und es auflisten müsste dann in die schleife.
    Wenn ich den TextBox3.Text = Prozess.MainWindowhandle.tostring ausgebe wird der Wert in meinen fall 265832 angezeigt.
    Also hab es nochmal geprüft alles ok.

    -1 # 1 # MinimalPosition X: -32000 # MinimalPosition Y: -32000 # MaximalPosition X: -1 # MaximalPosition Y: -1
    -32000 bedeutet das es in Vollbild ist.
    Warum maximalPosition bei X und Y -1 ist weis ich allerdings nicht.

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Xiantrius“ ()

    Hi

    Ok, dann eine andere Frage. Was schätzt Du wieviel Prozesse da in der For/Each Schleife durchlaufen werden und woher weißt Du, daß das was Du nach der Schleife ausgibst, das gesuchte Fenster ist? Weil Du Dich ja fragst, warum da State Normal steht und nicht Maximized.



    Hi

    Ah, ich seh schon, Du suchst ja den Prozess. Hab nix gesagt. :)

    Beiträge zusammengefügt. ~Thunderbolt
    Mfg -Franky-

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Thunderbolt“ ()

    weil ich das mit Spy++ vergliechen habe. Die Handle Werte sind extact identisch und die For Schleife sucht nur nach den Prozessname den ich eingebe in der TextBox. Wenn er keinen findet kommt kein zufriedenstellendes Ergebnis und es crasht nicht.

    Ich habe noch eine ergänzung und so mit die Auflösung im Bild.
    -1 # 1 # MinimalPosition X: -32000 # MinimalPosition Y: -32000 # MaximalPosition X: -1 # MaximalPosition Y: -1 # Links: 0 # Oben: 0 # Rechts: 1280 # Unten: 1024

    Naja zumindest hab ich die Auflösung des Vollbildmodus so mit gefunden. Sie ist wirklich 1280x1024.



    Allerdings habe ich unterschiedliche Prozesse durch geschaut, so richtig kann man das nicht unterscheiden ob es Fullscreen ist.
    Allerdings kann die funktion Auflösung in Fenster und Vollbildmodus auslesen, was schon mal recht gut ist.
    Mir fehlt nur noch die möglichkeit die wahre Vollbild Auflösung auszulesen.

    Maximierte Auflösung ist keine Vollbildauflösung wie ich es in Spielen zb. kenne.

    Das ist für mich die richtige Vollbild Auflösung:
    Vollbild heist doch das der Prozess mit den Windowed meist ohne Fensterrahmen immer an der Front ist und gleichgültig welche Auflösung der Desktop hat, könnte diese gleich oder anders sein je nach Konfiguration und ausserdem wird das immer den ganzen Bildschirm beanspruchen, solange es nicht minimiert, in Fenstermodus gewandelt, oder geschlossen wurde.
    Seid ihr sicher das die API GetWindowPlacement mit der Structure WINDOWPLACEMENT den wahren Vollbildmodus auslesen kann?
    Habe damit 2 Prozesse ausgelesen die in Vollbild waren immer nur spuckt er den Wert 1 raus.
    Wert 1 = Normale Auflösung wird selbst bei Vollbild so angezeigt.
    Wert 2 = Minimiert
    Wert 3 = Maximiert nur wenn Prozess maximiert wurde nicht in Vollbild

    Fazit:
    Ich kann mit mein bisherigen Code zwar Auflösung egal ob Fenstermodus, oder Vollbildmodus auslesen.
    Kann aber wenn alles angezeigt wird nicht wirklich auslesen ob der Bildschirm des ausgewählten Fensters in Vollbild ist, oder nicht.
    Das ist mein bisheriger Code:
    Vielleicht ist auch was an der API was falsch, oder es fehlen noch Parameter die ich nicht kenne...

    VB.NET-Quellcode

    1. Private Sub AutoSizeListViewColumns(oListView As ListView)
    2. 'Dim nColumns As Integer = 0
    3. SuspendLayout()
    4. For nCol = 0 To oListView.Columns.Count - 1
    5. oListView.Columns(nCol).Width = -1 'forces autosizing on column
    6. If oListView.Columns(nCol).Width < 100 Then
    7. oListView.Columns(nCol).Width = 100
    8. End If
    9. Next
    10. oListView.Refresh()
    11. ResumeLayout()
    12. End Sub
    13. Dim CheckList As Boolean
    14. Dim CheckColumn As Boolean
    15. Dim Alle_Prozesse As Process
    16. Private Sub Prozessliste()
    17. If CheckColumn = False Then
    18. CheckColumn = True
    19. ListView1.FullRowSelect = True
    20. ListView1.Columns.Add("FensterHandle")
    21. ListView1.Columns.Add("Fensternamen")
    22. ListView1.Columns.Add("Prozesse")
    23. ListView1.Columns.Add("Prozess-ID")
    24. ListView1.Columns.Add("RAM")
    25. ElseIf CheckColumn = True Then
    26. Exit Sub
    27. End If
    28. If CheckList = False Then
    29. 'CheckList = True
    30. ListView1.Items.Clear()
    31. For Each Alle_Prozesse In Process.GetProcesses()
    32. If Alle_Prozesse.MainWindowHandle.ToInt32 > 0 Then
    33. With ListView1.Items.Add(Hex(Alle_Prozesse.MainWindowHandle.ToString))
    34. .SubItems.Add(Alle_Prozesse.MainWindowTitle)
    35. .SubItems.Add(Alle_Prozesse.ProcessName)
    36. .SubItems.Add(Hex(Alle_Prozesse.Id.ToString))
    37. End With
    38. End If
    39. Next
    40. If ListView1.Items.Count > 0 Then
    41. AutoSizeListViewColumns(ListView1)
    42. End If
    43. End If
    44. End Sub
    45. Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    46. Prozessliste()
    47. End Sub
    48. <Runtime.InteropServices.DllImport("user32.dll")>
    49. Private Shared Function GetWindowPlacement(ByVal hWnd As IntPtr, ByRef lpwndpl As WINDOWPLACEMENT) As Int32
    50. End Function
    51. 'Die API kam bisher noch nicht im Einsatz...
    52. <Runtime.InteropServices.DllImport("user32.dll")>
    53. Private Shared Function GetWindowRect(ByVal hwnd As IntPtr, ByRef lpRect As RECT) As Int32 ' oder Boolean
    54. End Function
    55. <Runtime.InteropServices.StructLayout(Runtime.InteropServices.LayoutKind.Sequential)>
    56. Public Structure RECT
    57. Public Left As Int32
    58. Public Top As Int32
    59. Public Right As Int32
    60. Public Bottom As Int32
    61. End Structure
    62. 'Mir wurde Rectangle empfohlen, aber die Ergebnisse sind leider die gleichen.
    63. Public Structure Rectangle
    64. Public Left As Int32
    65. Public Top As Int32
    66. Public Right As Int32
    67. Public Bottom As Int32
    68. End Structure
    69. Public Structure POINTAPI
    70. Public X As Int32
    71. Public Y As Int32
    72. End Structure
    73. Public Structure WINDOWPLACEMENT
    74. Public Length As Int32
    75. Public flags As Int32
    76. Public showCmd As Int32
    77. Public ptMinPosition As POINTAPI
    78. Public ptMaxPosition As POINTAPI
    79. Public rcNormalPosition As RECT
    80. Public rcDevice As RECT
    81. End Structure
    82. Dim XYRect As RECT
    83. Dim intRet As Integer
    84. Dim wpTemp As WINDOWPLACEMENT
    85. Private Sub PrüfeWindowedModus()
    86. For Each Prozess As Process In Process.GetProcessesByName(ListView1.SelectedItems.Item(0).SubItems(2).Text)
    87. TextBox1.Text = Prozess.ProcessName
    88. wpTemp.Length = System.Runtime.InteropServices.Marshal.SizeOf(wpTemp)
    89. intRet = GetWindowPlacement(Prozess.MainWindowHandle, wpTemp)
    90. TextBox2.Text = Prozess.MainWindowHandle.ToString
    91. Next
    92. TextBox3.Text = intRet & " # ShowWindowMode: " & wpTemp.showCmd & " # Länge: " & wpTemp.Length & vbNewLine &
    93. "MinimalPosition X: " & wpTemp.ptMinPosition.X & " # MinimalPosition Y: " & wpTemp.ptMinPosition.Y & vbNewLine &
    94. "MaximalPosition X: " & wpTemp.ptMaxPosition.X & " # MaximalPosition Y: " & wpTemp.ptMaxPosition.Y & vbNewLine &
    95. "Links: " & wpTemp.rcNormalPosition.Left & " # Oben: " & wpTemp.rcNormalPosition.Top & vbNewLine &
    96. "Rechts: " & wpTemp.rcNormalPosition.Right & " # Unten: " & wpTemp.rcNormalPosition.Bottom & vbNewLine &
    97. "rcDevice Links: " & wpTemp.rcDevice.Left & vbNewLine &
    98. "rcDevice Rechts: " & wpTemp.rcDevice.Right & vbNewLine &
    99. "rcDevice Oben: " & wpTemp.rcDevice.Top & vbNewLine &
    100. "rcDevice Unten: " & wpTemp.rcDevice.Bottom & vbNewLine &
    101. "Flags: " & wpTemp.flags
    102. If wpTemp.showCmd = 1 Then
    103. 'normal
    104. ElseIf wpTemp.showCmd = 2 Then
    105. 'minimized
    106. ElseIf wpTemp.showCmd = 3 Then
    107. 'maximized
    108. ElseIf wpTemp.showCmd = 4 Then '4 oder anderer Wert für Vollbild??? bisher gescheitert trotz richtige Auflösung
    109. 'fullscreen???
    110. End If
    111. End Sub
    112. Private Sub ListView1_Click(sender As Object, e As EventArgs) Handles ListView1.Click
    113. If ListView1.Items.Count > 0 Then
    114. PrüfeWindowedModus()
    115. End If
    116. End Sub
    117. Private Sub ListView1_KeyUp(sender As Object, e As KeyEventArgs) Handles ListView1.KeyUp
    118. If e.KeyCode = Keys.Down Or e.KeyCode = Keys.Up Then
    119. If ListView1.Items.Count > 0 Then
    120. If ListView1.SelectedIndices.Count > 0 Then
    121. PrüfeWindowedModus()
    122. End If
    123. End If
    124. End If
    125. End Sub


    Beiträge zusammengefügt. ~Thunderbolt

    Dieser Beitrag wurde bereits 6 mal editiert, zuletzt von „Xiantrius“ ()

    Hi

    Vllt muss man hier zwischen Anwendungen unterscheiden die ausschließlich GDI (normale Windows Apps) und zusätzlich DirectX, OpenGL usw. (Spiele) verwenden. DirectX erzeugt, wenn ich mich recht erinnere, ein Overlay auf einem Fenster. Könnte mir vorstellen das das Spiel selbst im WindowsState Normal verbleibt und halt nur ein Overlay auf dem Desktop für Vollbild erzeugt. Wie man da rankommt, keine Ahnung weil noch nie damit beschäftigt.
    Mfg -Franky-

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „-Franky-“ ()

    Damit willst du andeuten es gibt keine API die das auslesen kann ob es sich um eine tatsächliche Vollbildauflösung handelt, oder nicht?
    Es sei dem man setzt sich mit GDI und/oder Directx Programmierung ausseinander?
    Um mehr geht es ja nicht ausser die WindowsForms abzufragen wegen den Modus.
    Hi

    Wie angedeutet, erzeugen meiner Meinung und letztem Wissensstand nach, Spiele die mit DirectX ihre Szene im Vollbild und Windowed? rendern, ein Overlay das glaub nicht per API GetWindowPlacement erfasst werden kann. Kann mich aber auch irren und ist eher was für DirectX-Spezies. Bei normalen Windowsanwendungen wie Notepad usw., sollte die API schon den WindowsState korrekt zurück liefern.
    Mfg -Franky-
    Es gäbe eventuel noch einen Weg, aber der ist sehr umständlich.
    Zwar die Adresse des jeweiligen Prozesses suchen und pointern meist klappt das weil das nichts mit den Spielinhalt zu tun hat, sondern mehr der WindowsForms Anwendung des Prozesses.
    Würde aber dann mehr mit Memory Hack zu tun haben, aber ich mache sowas ungern.
    Es gibt 3 möglichkeiten.

    1. Directx, GDI variante.
    2. Über die umständlichere Veriante was ich aber nicht gerne mache.
    3. Oder aufgeben was die aller letzte Option wäre.

    Amsonsten sehe ich wie du keine anderen möglichkeiten.

    -Franky- schrieb:

    Wie angedeutet, erzeugen meiner Meinung und letztem Wissensstand nach, Spiele die mit DirectX ihre Szene im Vollbild und Windowed?


    Also man hat ein gewöhliches Fenster, jedes "WindowState" möglich.
    Wir haben aber auch eine Swapchain, welcher wir sagen können, windowed oder nicht. Setzt man die Auflösung auf FHD und nicht windowed und der Monitor läuft in 4K, wird die Monitorauflösung umgeschaltet auf FHD. Was dann für Ergebnisse kommen, muss mal ausgewertet werden, könnte sein, das es da Probleme gibt. Evtl. muss oder kann man dann was mit DXGI machen, müsste man aber erstmal feststellen, ob überhaupt DirectX vom Prozess verwndet wird.
    Hi

    Gerade noch mal was nachgelesen. Es gibt wohl 3 Modi für DirectX Games. Windowed, Borderless Windowed und FullScreen Exclusive. Bei ersterem den WindowsState ermitteln, sollte kein Problem sein. Bei dem zweiten kann das Fenster FullScreen sein, hat aber nicht zwangsweise den WindowsState Maximized. Bei letzterem kommt man wahrscheinlich nicht so ohne weiteres ran.
    Mfg -Franky-