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

    Ok mir war zunext nicht klar wenn man sie in Fenstermodus umwandelt die Auflösung ändert und sie wieder in Vollbild ändert das dies nicht funktioniert.... na gut wie geht es dann anders?

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

Facebook
Telefonspende