Propagación de eventos
Propagación de eventos significa que, cuando se emite un evento en un widget particular, puede pasarse a su widget padre (y ese widget puede pasárselo a su padre, y así sucesivamente) y, si el padre tiene un manejador de eventos, se llamará.
Al contrario que otros eventos, los eventos del teclado primero se envían a la ventana de nivel superior (Gtk::Window), donde se verifican los atajos del teclado establecidos (teclas aceleradoras y combinaciones, utilizadas para seleccionar elementos del menú desde el teclado). Después de esto (y asumuiendo que no se manejó el evento), se envía al widget que tiene el foco, y la propagación comienza desde allí.
El evento se propagará hasta que alcance el widget de mayor nivel, o hasta que detenga la propagación devolviendo true desde un manejador de eventos.
Tenga en cuenta que, después de haber cancelado un evento, no se llamará a ninguna otra función (incluso si es del mismo widget).
- 23.2.1. Ejemplo
23.2.1. Ejemplo
En este ejemplo hay tres manejadores de eventos que se llaman después del manejador de eventos predeterminado de Gtk::Window, uno en la Gtk::Entry, uno en el Gtk::Grid y uno en la Gtk::Window.
En la Gtk::Window, también está la sobrecarga del manejador predeterminado (on_key_release_event()), y otro manejador que se llama antes del predeterminado (windowKeyReleaseBefore()).
El propósito de este ejemplo es mostrar los pasos que el evento sigue cuando se emite.
Cuando escriba en el «entry», se emitirá un evento de liberación de tecla, que primero irá a la ventana superior (Gtk::Window), dado que hay un manejador de eventos establecido para que se llame antes, y ese es el que se llama primero (windowKeyReleaseBefore()). Después se llama al manejador de eventos predeterminado (al que se ha sobrecargado), y luego se envía el evento al widget que tiene el foco, el Entry en el ejemplo y, dependiendo de si lo dejamos propagar o no, puede alcanzar los manejadores de eventos del Grid y la Window. Si se propaga, el texto que esté escribiendo aparecerá en el Label arriba del Entry.
File: examplewindow.h (For use with gtkmm 3, not gtkmm 2)
#ifndef GTKMM_EVENT_PROPAGATION_H
#define GTKMM_EVENT_PROPAGATION_H
#include <gtkmm.h>
class ExampleWindow : public Gtk::Window
{
public:
ExampleWindow();
virtual ~ExampleWindow();
private:
//Override default signal handler:
virtual bool on_key_release_event(GdkEventKey* event);
bool entryKeyRelease(GdkEventKey* event);
bool gridKeyRelease(GdkEventKey* event);
bool windowKeyReleaseBefore(GdkEventKey* event);
bool windowKeyRelease(GdkEventKey* event);
Gtk::Grid m_container;
Gtk::Label m_label;
Gtk::Entry m_entry;
Gtk::CheckButton m_checkbutton_can_propagate;
};
#endif //GTKMM_EVENT_PROPAGATION_H
File: examplewindow.cc (For use with gtkmm 3, not gtkmm 2)
#include "examplewindow.h"
#include <iostream>
ExampleWindow::ExampleWindow()
{
add(m_container);
set_title("Event Propagation");
set_border_width(10);
m_label.set_label("A label");
m_checkbutton_can_propagate.set_label("Can Propagate");
m_checkbutton_can_propagate.set_active();
// Main Container
m_container.set_orientation(Gtk::ORIENTATION_VERTICAL);
m_container.add(m_label);
m_container.add(m_entry);
m_container.add(m_checkbutton_can_propagate);
// Events
add_events(Gdk::KEY_RELEASE_MASK);
m_entry.signal_key_release_event().connect(
sigc::mem_fun(*this, &ExampleWindow::entryKeyRelease));
m_container.signal_key_release_event().connect(
sigc::mem_fun(*this, &ExampleWindow::gridKeyRelease));
// Called before the default event signal handler.
signal_key_release_event().connect(
sigc::mem_fun(*this, &ExampleWindow::windowKeyReleaseBefore), false);
// Called after the default event signal handler.
signal_key_release_event().connect(
sigc::mem_fun(*this, &ExampleWindow::windowKeyRelease));
show_all_children();
}
//By changing the return value we allow, or don't allow, the event to propagate to other elements.
bool ExampleWindow::entryKeyRelease(GdkEventKey* /* event */ )
{
std::cout << "Entry" << std::endl;
if(m_checkbutton_can_propagate.get_active())
{
return false;
}
return true;
}
bool ExampleWindow::gridKeyRelease(GdkEventKey* /* event */ )
{
std::cout << "Grid" << std::endl;
//Let it propagate:
return false;
}
bool ExampleWindow::windowKeyReleaseBefore(GdkEventKey* /* event */ )
{
std::cout << "Window before" << std::endl;
return false;
}
bool ExampleWindow::on_key_release_event(GdkEventKey* event)
{
std::cout << "Window overridden" << std::endl;
// call base class function (to get the normal behaviour)
return Gtk::Window::on_key_release_event(event);
}
// This will set the entry's text in the label, every time a key is pressed.
bool ExampleWindow::windowKeyRelease(GdkEventKey* /* event */ )
{
std::cout << "Window after";
//checking if the entry is on focus, otherwise the label would get changed by pressing keys
//on the window (when the entry is not on focus), even if m_checkbutton_can_propagate wasn't active
if(m_entry.has_focus())
{
m_label.set_text(m_entry.get_text());
std::cout << ", " << m_entry.get_text();
}
std::cout << std::endl;
return true;
}
ExampleWindow::~ExampleWindow()
{
}
File: main.cc (For use with gtkmm 3, not gtkmm 2)
#include "examplewindow.h"
#include <gtkmm/application.h>
int main(int argc, char *argv[])
{
Glib::RefPtr<Gtk::Application> app = Gtk::Application::create(argc, argv, "org.gtkmm.example");
ExampleWindow window;
//Shows the window and returns when it is closed.
return app->run(window);
}