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 :D. 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ò
:D

[mjordan]

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



Secondo me le GTK come interfaccia sono un abominio :D. 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ò
:D

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...