GTK e C++

[Kleidemos]

Dove trovo una guida che mi insegni ad usare le GTK(BENE!) con il C++ per creare GUI??

[mjordan]

Originally posted by "Kleidemos"

Dove trovo una guida che mi insegni ad usare le GTK(BENE!) con il C++ per creare GUI??

Imparati prima ad usare il toolkit nativo con il C, vedrai che poi usarle sotto C++ è solo una questione di leggere qualche esempio.

[maxithron]

prova un pò qui:

http://utenti.lycos.it/ldm/art/iart7.htm

[/\/\@®¢Ø]

Originally posted by "mjordan"



Imparati prima ad usare il toolkit nativo con il C, vedrai che poi usarle sotto C++ è solo una questione di leggere qualche esempio.

Secondo me le GTK come interfaccia sono un abominio . Piu' semplice partire da un binding per il C++, che e' decisamente piu' intuitivo anche se c'e' meno documentazione (ad esempio con le GTK--, http://www.gtkmm.org)

[gokan]

Originally posted by "Kleidemos"

Dove trovo una guida che mi insegni ad usare le GTK(BENE!) con il C++ per creare GUI??

Su una rivista di Linux ho letto che consigliavano questo libro:
http://www.apogeonline.com/libri/00615/scheda

Il mio è solo un link.Di più nin sò

[mjordan]

Originally posted by "/\/\@®¢Ø"



Secondo me le GTK come interfaccia sono un abominio . Piu' semplice partire da un binding per il C++, che e' decisamente piu' intuitivo anche se c'e' meno documentazione (ad esempio con le GTK--, http://www.gtkmm.org)

Non capisco come fai a dire che un binding per un toolkit nativo di un altro linguaggio sia + intuitivo...

[mjordan]

Originally posted by "gokan"


Su una rivista di Linux ho letto che consigliavano questo libro:
http://www.apogeonline.com/libri/00615/scheda

Il mio è solo un link.Di più nin sò

Non è un libro che può essere letto da una persona che le GTK+ non le conosce.

[AnonimoVeneziano]

Purtroppo è il problema delle QT

Si inventassero qualcosa tipo il QT Designer della TrollTech

Ciao

[/\/\@®¢Ø]

Originally posted by "mjordan"



Non capisco come fai a dire che un binding per un toolkit nativo di un altro linguaggio sia + intuitivo...

Nel caso in questione si tratta di un toolkit dalla struttura object-oriented implementato in un linguaggio procedurale.
Un qualsiasi binding per un linguaggio OO riesce a togliere di mezzo i trucchi arcani a cui sono ricorsi gli implementatori delle GTK+ per fare cio'.

Ad esempio ecco il codice per fare un semplice "Hello World" con le GTK+ e due binding differenti ( uno C++ e l'altryo Python )

GTK+:

#include <gtk/gtk.h>
static void hello( GtkWidget *widget,
                   gpointer   data )
{
    g_print ("Hello World\n");
}

static gboolean delete_event( GtkWidget *widget,
                              GdkEvent  *event,
                              gpointer   data )
{
    g_print ("delete event occurred\n");
    return TRUE;
}

static void destroy( GtkWidget *widget,
                     gpointer   data )
{
    gtk_main_quit ();
}

int main( int   argc,
          char *argv[] )
{
    GtkWidget *window;
    GtkWidget *button;
    gtk_init (&argc, &argv);
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    
    g_signal_connect (G_OBJECT (window), "delete_event",
		      G_CALLBACK (delete_event), NULL);
    
    g_signal_connect (G_OBJECT (window), "destroy",
		      G_CALLBACK (destroy), NULL);
    
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
    button = gtk_button_new_with_label ("Hello World");
    
    g_signal_connect (G_OBJECT (button), "clicked",
		      G_CALLBACK (hello), NULL);
    
    g_signal_connect_swapped (G_OBJECT (button), "clicked",
			      G_CALLBACK (gtk_widget_destroy),
                              G_OBJECT (window));
    
    gtk_container_add (GTK_CONTAINER (window), button);
    
    gtk_widget_show (button);
    
    gtk_widget_show (window);
    
    gtk_main ();
    
    return 0;
}

gtkmm:

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

class HelloWorld : public Gtk::Window
{

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

protected:
  virtual void on_button_clicked();

  Gtk::Button m_button;
};

HelloWorld::HelloWorld()
: m_button("Hello World")   // creates a new button with the label "Hello World".
{
  set_border_width(10);

  m_button.signal_clicked().connect(SigC::slot(*this, &HelloWorld::on_button_clicked));

  add(m_button);

  m_button.show();
}

HelloWorld::~HelloWorld()
{
}

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

File: main.cc

#include <gtkmm/main.h>
#include "helloworld.h"

int main (int argc, char *argv[])
{
  Gtk::Main kit(argc, argv);

  HelloWorld helloworld;
  Gtk::Main::run(helloworld); //Shows the window and returns when it is closed.

  return 0;
}

e py-gtk:

#!/usr/bin/env python

# translation of the simple.c test in the gtk+ distribution, using the
# new() function from gobject (this is an example of creating objects
# with the properties interface).

import gobject, gtk

def hello(*args):
	print "Hello World"
	window.destroy()

def destroy(*args):
	window.hide()
	gtk.main_quit()

window = gobject.new(gtk.Window,
		     type=gtk.WINDOW_TOPLEVEL,
		     title='Hello World',
		     allow_grow=gtk.FALSE,
		     allow_shrink=gtk.FALSE,
		     border_width=10)
window.connect("destroy", destroy)

button = gobject.new(gtk.Button, label="Hello World", parent=window)
button.connect("clicked", hello)

window.show_all()
gtk.main()

Al di la' del codice in se' (che non e' perfettamente identico), quello che e' piu' evidente e' che mentre col C devi fare contorsionismi con le dita sulla tastiera, con gli altri due linguaggi risulta tutto piu' naturale, visto che non devi scrivere a ripetizione macro e cast uno sull'altro, e in piu' il compilatore puo' scovare molti piu' errori.

[mjordan]

Originally posted by "/\/\@®¢Ø"


Nel caso in questione si tratta di un toolkit dalla struttura object-oriented implementato in un linguaggio procedurale.
Un qualsiasi binding per un linguaggio OO riesce a togliere di mezzo i trucchi arcani a cui sono ricorsi gli implementatori delle GTK+ per fare cio'.

Ad esempio ecco il codice per fare un semplice "Hello World" con le GTK+ e due binding differenti ( uno C++ e l'altryo Python )

GTK+:

#include <gtk/gtk.h>
static void hello( GtkWidget *widget,
                   gpointer   data )
{
    g_print ("Hello World\n");
}

static gboolean delete_event( GtkWidget *widget,
                              GdkEvent  *event,
                              gpointer   data )
{
    g_print ("delete event occurred\n");
    return TRUE;
}

static void destroy( GtkWidget *widget,
                     gpointer   data )
{
    gtk_main_quit ();
}

int main( int   argc,
          char *argv[] )
{
    GtkWidget *window;
    GtkWidget *button;
    gtk_init (&argc, &argv);
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    
    g_signal_connect (G_OBJECT (window), "delete_event",
		      G_CALLBACK (delete_event), NULL);
    
    g_signal_connect (G_OBJECT (window), "destroy",
		      G_CALLBACK (destroy), NULL);
    
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
    button = gtk_button_new_with_label ("Hello World");
    
    g_signal_connect (G_OBJECT (button), "clicked",
		      G_CALLBACK (hello), NULL);
    
    g_signal_connect_swapped (G_OBJECT (button), "clicked",
			      G_CALLBACK (gtk_widget_destroy),
                              G_OBJECT (window));
    
    gtk_container_add (GTK_CONTAINER (window), button);
    
    gtk_widget_show (button);
    
    gtk_widget_show (window);
    
    gtk_main ();
    
    return 0;
}

gtkmm:

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

class HelloWorld : public Gtk::Window
{

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

protected:
  virtual void on_button_clicked();

  Gtk::Button m_button;
};

HelloWorld::HelloWorld()
: m_button("Hello World")   // creates a new button with the label "Hello World".
{
  set_border_width(10);

  m_button.signal_clicked().connect(SigC::slot(*this, &HelloWorld::on_button_clicked));

  add(m_button);

  m_button.show();
}

HelloWorld::~HelloWorld()
{
}

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

File: main.cc

#include <gtkmm/main.h>
#include "helloworld.h"

int main (int argc, char *argv[])
{
  Gtk::Main kit(argc, argv);

  HelloWorld helloworld;
  Gtk::Main::run(helloworld); //Shows the window and returns when it is closed.

  return 0;
}

e py-gtk:

#!/usr/bin/env python

# translation of the simple.c test in the gtk+ distribution, using the
# new() function from gobject (this is an example of creating objects
# with the properties interface).

import gobject, gtk

def hello(*args):
	print "Hello World"
	window.destroy()

def destroy(*args):
	window.hide()
	gtk.main_quit()

window = gobject.new(gtk.Window,
		     type=gtk.WINDOW_TOPLEVEL,
		     title='Hello World',
		     allow_grow=gtk.FALSE,
		     allow_shrink=gtk.FALSE,
		     border_width=10)
window.connect("destroy", destroy)

button = gobject.new(gtk.Button, label="Hello World", parent=window)
button.connect("clicked", hello)

window.show_all()
gtk.main()

Al di la' del codice in se' (che non e' perfettamente identico), quello che e' piu' evidente e' che mentre col C devi fare contorsionismi con le dita sulla tastiera, con gli altri due linguaggi risulta tutto piu' naturale, visto che non devi scrivere a ripetizione macro e cast uno sull'altro, e in piu' il compilatore puo' scovare molti piu' errori.

Sara' comunque e' questione di gusti...