#PB_Event_SizeWindow

[stevie1401]

Mit folgendem Code kann ich herausfinden, ob jemand die Grösse eines Fensters verändert:

Code: Alles auswählen

  If event= #PB_Event_SizeWindow   

  endif

Nun möchte ich herausfinden, wann der Benutzer das Resizen beendet, weil ich erst nach dem BENDEN das Fenster neu zeichnen möchte.
Wie kann ich das denn herausfinden?

[RSBasic]

Tut mir leid, dir mitteilen zu müssen, aber es geht wieder nur mit API.
Windows mit #WM_EXITSIZEMOVE:

Code: Alles auswählen

EnableExplicit

Procedure WinCallback(hWnd, uMsg, wParam, lParam) 
  Select uMsg
    Case #WM_SIZING
      Debug "Fenstergröße wird gerade geändert..."
    Case #WM_EXITSIZEMOVE 
      Debug "Fenstergrößenänderung fertig"
  EndSelect 
  
  ProcedureReturn #PB_ProcessPureBasicEvents 
EndProcedure 


If OpenWindow(0, 0, 0, 500, 400, "Window", #PB_Window_SystemMenu | #PB_Window_ScreenCentered | #PB_Window_SizeGadget)
  SetWindowCallback(@WinCallback())
  
  Repeat
    Select WaitWindowEvent()
      Case #PB_Event_CloseWindow
        End
    EndSelect
  ForEver
EndIf

Lösungen für Linux und MacOS musst du auf andere warten.

Es gäbe zwar noch eine andere Möglichkeit und zwar mit Hilfe eines Timers und einer Variable. Du ermittelst während des Events "#PB_Event_CloseWindow" die aktuelle Größe und Zeit und wenn das Fenster sich seit x Sekunden nicht mehr vergrößert/verkleinert wurde, dann kannst du sicherstellen, dass der Benutzer damit fertig ist, aber dann hast du auf jeden Fall eine Verzögerung. Deshalb würde ich lieber die von mir oben geschriebene Lösung bevorzugen. Wer weiß, vielleicht gibt es unter Linux und MacOS auch so ein Finish-Event.

[Shardik]

Hier ist eine plattform-übergreifende Lösung für MacOS X (getestet auf MacOS X 10.9.5 Mavericks mit PB 5.31 x86 und x64 im ASCII- und Unicode-Modus), Linux (getestet mit PB 5.31 auf andLinux/Kubuntu 9.04 x86 mit KDE, Lubuntu 14.04 x86 mit LXDE und Ubuntu 14.04 x86 mit Unity) und Windows (getestet mit PB 5.31 auf Windows XP SP3 und Windows 7 SP1 x86).

Die MacOS-Lösung ist ähnlich wie in Windows (in MacOS löst die Notification NSWindowDidEndLiveResizeNotification den Aufruf des Callbacks aus, wenn die Fenstergrößenänderung beendet ist).

In Linux ist die Lösung weniger elegant, da in GTK2 und GDK2 kein spezielles Event bei Beendigung einer Fenstergrößenänderung vorhanden ist (weil das zugrunde liegende XWindow dies anscheinend nicht unterstützt, vielleicht ändert sich dies ja zukünftig mit dem neuen Wayland...). Daher wird ein Timer genutzt, der nach Ablauf von 200 Millisekunden ohne Fenstergrößenänderung die entsprechende Meldung ausgibt, indem das neu definierte Event #PB_Event_WindowResized mit PostEvent() in die WindowEvent-Schleife eingespeist wird.

Code: Alles auswählen

EnableExplicit

#PB_Event_WindowResized = #PB_Event_FirstCustomValue

CompilerSelect #PB_Compiler_OS
  CompilerCase #PB_OS_Linux ; -------------------------------------------------
    #Timeout = 200

    Define TimerID.I

    ProcedureC ResizingFinished(*UserData)
      Shared TimerID.I

      TimerID = 0
      PostEvent(#PB_Event_WindowResized, 0, 0)

      ProcedureReturn #False
    EndProcedure

    ProcedureC WindowCallback(*Window.GtkWindow, *Event.GdkEventConfigure,
      *UserData)
      Shared TimerID.I

      If TimerID
        g_source_remove_(TimerID)
      EndIf

      TimerID = g_timeout_add_(#Timeout, @ResizingFinished(), 0)

      ProcedureReturn #False
    EndProcedure
  CompilerCase #PB_OS_MacOS ; -------------------------------------------------
    ImportC ""
      sel_registerName(MethodName.P-ASCII)
      class_addMethod(Class.I, Selector.I, Implementation.I, Types.P-ASCII)
    EndImport

    ProcedureC WindowCallback(Object.I, Selector.I, Notification.I)
      PostEvent(#PB_Event_WindowResized, 0, 0)
    EndProcedure
  CompilerCase #PB_OS_Windows ; -----------------------------------------------
    Procedure WindowCallback(WindowHandle.I, Msg.I, WParam.I, LParam.I)
      If Msg = #WM_EXITSIZEMOVE
        PostEvent(#PB_Event_WindowResized, 0, 0)
      EndIf
 
      ProcedureReturn #PB_ProcessPureBasicEvents
    EndProcedure
CompilerEndSelect ; -----------------------------------------------------------


If OpenWindow(0, 0, 0, 500, 400,
  "Erkennung der Beendigung einer Fenstergrößenänderung",
  #PB_Window_SystemMenu | #PB_Window_ScreenCentered | #PB_Window_SizeGadget)
  CompilerSelect #PB_Compiler_OS
    CompilerCase #PB_OS_Linux ; -----------------------------------------------
      gtk_widget_add_events_(WindowID(0), #GDK_CONFIGURE)
      g_signal_connect_(WindowID(0), "configure-event", @WindowCallback(), 0)
    CompilerCase #PB_OS_MacOS ; -----------------------------------------------
      Define AppDelegate.I = CocoaMessage(0, CocoaMessage(0, 0,
        "NSApplication sharedApplication"), "delegate")
      Define DelegateClass.I = CocoaMessage(0, AppDelegate, "class")
      Define NotificationCenter.I = CocoaMessage(0, 0,
       "NSNotificationCenter defaultCenter")
      Define Selector.I = sel_registerName("WindowResizeDidEnd:")

      class_addMethod(DelegateClass, Selector, @WindowCallback(), "v@:@")
      CocoaMessage(0, NotificationCenter,
        "addObserver:", AppDelegate,
        "selector:", Selector,
        "name:$", @"NSWindowDidEndLiveResizeNotification",
        "object:", WindowID(0))
    CompilerCase #PB_OS_Windows ; ---------------------------------------------
      SetWindowCallback(@WindowCallback())
  CompilerEndSelect ; ---------------------------------------------------------
 
  Repeat
    Select WaitWindowEvent()
      Case #PB_Event_CloseWindow
        Break
      Case #PB_Event_SizeWindow
        Debug "Fenstergröße wird gerade geändert..."
      Case #PB_Event_WindowResized
        Debug "Fenstergrößenänderung abgeschlossen!"
    EndSelect
  ForEver
EndIf

CompilerIf #PB_Compiler_OS = #PB_OS_MacOS
  CocoaMessage(0, NotificationCenter, "removeObserver:", AppDelegate,
    "name:$", @"NSWindowDidEndLiveResizeNotification", "object:", 0)
CompilerEndIf