Come testare se la finestra di dialogo GTK + è stata creata?

Question

Ho usato Wnck per verificare se una finestra si è creato in questo modo:

screen = Wnck.Screen.get_default() 
    screen.force_update() # recommended per Wnck documentation 
    window_list = screen.get_windows() 

    for window in window_list: 
     print(window.get_name()) 
     if window.has_name(): 
      if window.get_name() == self.xld_main_window.get_title(): 
       window_found = True 
       break 
    assert window_found, 'The Gtk.Window named {window_name} has not been found.'\ 
     .format(window_name=self.xld_main_window.get_title()) 

    # clean up Wnck (saves resources, check documentation) 
    window = None 
    screen = None 

Tuttavia, dato che le finestre di dialogo non si presentano nella lista di compiti, non riesco a trovare in quel modo. Qual è un modo appropriato per verificare se sono visualizzati (e modali/non modali)?

Answer 1

Il metodo Wnck.Screen.get_windows restituisce tutte le finestre comprese le finestre di dialogo. Non c'è alcuna distinzione poiché la funzione restituisce qualsiasi Wnck.Window attualmente mappato. La fonte è questa:

* The #WnckScreen represents a physical screen. A screen may consist of 
* multiple monitors which are merged to form a large screen area. The 
* #WnckScreen is at the bottom of the libwnck stack of objects: #WnckWorkspace 
* objects exist a #WnckScreen and #WnckWindow objects are displayed on a 
* #WnckWorkspace. 
* 
* The #WnckScreen corresponds to the notion of 
* <classname>GdkScreen</classname> in GDK. 

GList* 
wnck_screen_get_windows (WnckScreen *screen) 
{ 
    g_return_val_if_fail (WNCK_IS_SCREEN (screen), NULL); 

    return screen->priv->mapped_windows; 
} 

dove screen->priv punti ad un struct contenente alcune liste delle finestre (mappati, impilati), un puntatore alla finestra attiva, ecc Alcuni WnckWindow possono avere WNCK_WINDOW_DIALOG insieme ed essere una finestra .

La classe WnckWindow fornisce anche una funzione transient_is_most_recently_activated() di sapere se l'attenzione dovrebbe andare a una finestra figlio transiente quando selezionato in un WnckTaskList o per ridurre la finestra transitorio con il suo genitore. Ad esempio, per conoscere wether My Application finestra ha un transitorio attivato più di recente:

screen = Wnck.Screen.get_default() 
screen.force_update() # recommended per Wnck documentation 
window_list = screen.get_windows() 

for window in window_list: 
    if window.get_name() == 'My Application': 
     print(window.transient_is_most_recently_activated()) 

Lo script di seguito cattura le finestre di dialogo come altre finestre mappati (non importa se sono modali/non-modale o l'applicazione sono da) .

import gi 
gi.require_version('Gtk', '3.0') 
gi.require_version('Wnck', '3.0') 
from gi.repository import Gtk, Wnck 

class DialogExample(Gtk.Dialog): 

    def __init__(self, parent): 
     Gtk.Dialog.__init__(self, "My Dialog", parent, 0, #or Gtk.DialogFlags.MODAL 
      (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, 
      Gtk.STOCK_OK, Gtk.ResponseType.OK)) 

     self.set_default_size(100, 100) 

     label = Gtk.Label("This is a dialog to display additional information") 

     box = self.get_content_area() 
     box.add(label) 
     self.show_all() 

class DialogWindow(Gtk.Window): 

    def __init__(self): 
     Gtk.Window.__init__(self, title="Dialog Example") 
     self.set_border_width(6) 
     button = Gtk.Button("Open dialog") 
     button.connect("clicked", self.on_button_clicked) 
     self.add(button) 

    def on_button_clicked(self, widget): 
     dialog = DialogExample(self) 
     response = dialog.run() 

     if response == Gtk.ResponseType.OK: 
      print("The OK button was clicked") 
     elif response == Gtk.ResponseType.CANCEL: 
      print("The Cancel button was clicked") 

     screen = Wnck.Screen.get_default() 
     screen.force_update() # recommended per Wnck documentation 
     window_list = screen.get_windows() 

     for window in window_list: 
      print(window.get_name()) 

     window, window_list = (None,)*2 
     screen = None 

     dialog.destroy() 

win = DialogWindow() 
win.connect("delete-event", Gtk.main_quit) 
win.show_all() 

window = None 
screen = None 
Gtk.main() 

Utilizzando Gdk anziché Wnck, si sta facendo la stessa cosa a un livello leggermente inferiore.

Answer 2

Prendendo parte da this answer da Eye of Hell che dice come ottenere le finestre aperte, si può fare questo:

from gtk import gdk 

name = "MyDialog" 

root = gdk.get_default_root_window() 
matches = [] 
for id in root.property_get("_NET_CLIENT_LIST"): 
    window = gdk.window_foreign_new(id) 
    if window and window.property_get("WM_NAME")[2] == name: 
     matches.append(window) 

for match in matches: 
    print(match, match.get_modal_hint())