GTK ventana de detección de cambiar el tamaño del usuario

Question

En GTK (o pygtk o gtkmm ...)

¿Cómo se puede detectar lo que una ventana de aplicación ha sido manualmente redimensionarse por el usuario, como se hace típicamente arrastrando el el borde de la ventana?

Necesito encontrar una forma de diferenciar los cambios de tamaño manuales de los tamaños que se originan en gtk, como los cambios en el contenido de la ventana.

Answer 1

¿Ha intentado conectarse al evento GDK_CONFIGURE?

Consulte this example en la sección "Ventana móvil". El ejemplo muestra una devolución de llamada que hace algo cuando se mueve la ventana, pero el evento de configuración es un comodín para los eventos de movimiento, cambio de tamaño y orden de la pila.

Answer 2

En PyGTK, siempre he buscado el expose_event para un tamaño de ventana, luego uso el método get_allocation para obtener el nuevo tamaño.

Answer 3

Puede juntar algo utilizando gdk_window_get_root_origin para obtener la esquina superior izquierda de la ventana y gdk_window_get_geometry para obtener el ancho y la altura. Luego, puede conectar una devolución de llamada al GDK_BUTTON_PRESS_MASK y verificar si la pulsación del botón se produce cerca/en uno de los bordes de la ventana.

Por supuesto, esto parece bastante hackish y realmente me molesta que no pude encontrar una manera simple en la documentación para que GdkWindow hiciera esto. Hay una función gdk_window_begin_resize_drag que realmente me hace pensar que hay una manera más clara de hacerlo, pero no vi nada más obvio que mi respuesta.

Answer 4

Me las arreglé para lograr esto al observar las señales size_allocate y size_request en el GtkWindow. Si size_request alguna vez se hizo más pequeño, llamé al resize(1,1). Si el size_allocate fue más grande de lo esperado, apagué el sistema.

Una cosa que me aseguré de manejar fue size_request volviendo grande, luego pequeña, y teniendo size_allocate ser grande y luego pequeña. No sé si esto es posible, pero lo arreglé asegurándome de disminuir solo los valores esperados para size_allocate cuando obtuve un size_allocate más pequeño, no cuando obtuve un size_request más pequeño.

Asegúrese de que su controlador size_request viene después del controlador de la clase base para que pueda obtener los valores correctos. Lo hice anulando el método y luego llamando primero al método de la clase base.

He intentado esto en las dimensiones 1 y 2 y parece funcionar de cualquier manera.

Answer 5

En mi caso, estaba tratando de distinguir entre un usuario cambiar el tamaño de un Gtk.Paned del usuario cambiar el tamaño de toda la ventana. Ambos emitieron la señal notify::position.

Mi solución fue, ya que no puedo saber si el usuario está cambiando el tamaño de la ventana del widget, revertir lo que quería saber. Registre si el usuario ha reubicado el widget e ignore las actualizaciones si el usuario no las inició en mi widget.

Es decir, en lugar de las pruebas "si se cambia el tamaño de la ventana" Grabé las button-press-event y button-release-event 's a nivel local para que pudiera vez probar 'si widget de ser re-posiciona'

from gi.repository import Gtk 

class MyPaned(Gtk.Paned): 
    _user_activated = False 

    def on_position(self, _, gparamspec): 
     if self._user_activated: 
      # widget touched 

     else: 
      # window resized (probably) 

    def on_button_press(self, *_): 
     self._user_activated = True 

    def on_button_release(self, *_): 
     self._user_activated = False 


    dev __init__(self, *args): 
     super(MyPaned, self).__init__(*args) 
     self.connect('notify::position', self.on_position) 
     self.connect('button-press-event', self.on_button_press) 
     self.connect('button-release-event', self.on_button_release) 

efectivamente por grabados cuando el usuario comenzó y terminó interactuando directamente con mi widget, pude suponer que el resto del tiempo se debió a que se redimensionó la ventana. (Hasta que encuentre más casos)