Gtkmm: Entry, Label, segnali, ustring

ho creato una semplice GUI con Glade.
ho creato due signal handler per i bottoni: uno esegue l’ inversione della ustring, l’ altro cancella i campi.

  • i parametri passati con il binding sono i puntatori ai widget.
    Notare anche l’ uso di ptr_fun per indicare il puntatore ad una funzione, a differenza di mem_fun che serve con i puntatori a metodi.
  • notare come viene invertita la ustring: non ho trovato di meglio che usare il metodo assign che supporta gli iteratori. Usando i reverse iterators si ottiene la stringa invertita.
  • il testo di una label di imposta/modifica con set_text e get_text.
  • per una entry il testo si trova in un buffer a cui si accede con get_buffer, i cui metodi get_text() e delete_text() consentono la manipolazione.

ecco il listato:

#include <gtkmm/application.h>
#include <gtkmm/window.h>
#include <gtkmm/button.h>
#include <gtkmm/entry.h>
#include <gtkmm/label.h>
#include <gtkmm/builder.h>
#include <iostream>


void onOK_clicked(Gtk::Entry *pE, Gtk::Label *pL)
{
	Glib::ustring rev = pE->get_buffer()->get_text();
	rev.assign(rev.rbegin(), rev.rend());
	pL->set_text(rev);
	std::cout << "OK !" << std::endl;
}

void onCancel_clicked(Gtk::Entry *pE, Gtk::Label *pL)
{
	pE->get_buffer()->delete_text(0, -1);
	pL->set_text("inserisci nuovo testo.");
	std::cout << "Cancel :-(" << std::endl;
}

int main(int argc, char** argv)
{
	Glib::RefPtr<Gtk::Application> app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

	Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create_from_file("src/GUI.glade");

	Gtk::Button *pOk_button, *pCancel_button;
	builder->get_widget("button_OK",pOk_button);
	builder->get_widget("button_CANCEL", pCancel_button);

	Gtk::Entry *pEntry;
	Gtk::Label *pLabel;
	builder->get_widget("entry", pEntry);
	builder->get_widget("label", pLabel);

	pOk_button->signal_clicked().connect(sigc::bind<Gtk::Entry*, Gtk::Label*>( sigc::ptr_fun(&onOK_clicked), pEntry, pLabel) );
	pCancel_button->signal_clicked().connect(sigc::bind<Gtk::Entry*, Gtk::Label*>( sigc::ptr_fun(&onCancel_clicked), pEntry, pLabel) );

	Gtk::Window *window;
	builder->get_widget("window", window);
	return app->run(*window);
}

Signal handler con gtkmm

Dopo aver dichiarato un widget e una funzione void in una classe Gtk::Window

#include <gtkmm/button.h>
#include <gtkmm/window.h>

class HelloWorld : public Gtk::Window
{

public:
  HelloWorld();
  virtual ~HelloWorld();

protected:
  //Signal handlers:
  void on_button_clicked();

  //Member widgets:
  Gtk::Button m_button;
};

bisogna “collegare” la funzione al widget in modo che venga chiamata ogni volta che un segnale viene lanciato:

#include "helloworld.h"
#include <iostream>

HelloWorld::HelloWorld()
: m_button("Hello World")   // creates a new button with label "Hello World".
{
  ...
  m_button.signal_clicked().connect(sigc::mem_fun(*this,
              &HelloWorld::on_button_clicked));
  ...
}

void HelloWorld::on_button_clicked()
{
  std::cout << "Hello World" << std::endl;
}

Notare che l’ handler non ha parametri.

A volte si può usare uno stesso handler per più widget simili.
Allora si rende necessario il passaggio di parametri o argomenti.
Per passare argomenti, bisogna fare il binding:

...
void on_button_clicked(Glib::ustring, int val);
...
// sigc::bind<Tipo1, Tipo2, ...>(HANDLER, param1, param2, ...);
m_button1.signal_clicked().connect( sigc::bind<Glib::ustring, int>( sigc::mem_fun(*this, &HelloWorld::on_button_clicked), "xyz", 3) );