/* Datei hello.cc
   Ein "Hello World"-Programm für Gtk--.

   Dieses Programm definiert zunächst eine von Gtk::Window abgelei-
   tete Klasse HelloWindow, die zwei Buttons und ein Label in der
   folgenden Weise in einem Fenster anordnet:
   +--------+-------+
   | Button | Label |
   +--------+-------+   (Zur Festlegung der Anordnung werden
   |     Button     |    eine HBox und eine VBox verwendet)
   +----------------+

   In main() wird eine Instanz dieser Klasse erzeugt und benutzt.
*/
#include <iostream>

// Headerfile für Gtk::Window, ein Hauptfenster für X11-Anwendungen:
#include <gtk--/window.h>

// Headerfile für Gtk::HBox, Gtk::VBox, zwei Container, die
// beliebige Widgets neben- bzw. übereinander anordnen:
#include <gtk--/box.h>

#include <gtk--/label.h>  // Gtk::Label
#include <gtk--/button.h> // Gtk::Button

// Headerfile für Gtk::Main. Jede Gtk-- Anwendung muss genau ein
// Objekt dieses Typs instanzieren.
#include <gtk--/main.h>

// Anstelle der einzelnen Headerfiles hätten wir auch nur 
// #include <gtk--.h> schreiben können. Damit werden sämtliche
// Headerfiles eingelesen. Bei größeren Projekten verbietet sich das
// jedoch wegen der längeren Übersetzungsdauer.


// Die neue Klasse, die von einem leeren Anwendungsfenster erbt:
class HelloWindow : public Gtk::Window {
  Gtk::VBox   vbox;
  Gtk::HBox   hbox;
  Gtk::Button hello_button; // der Button oben links
  Gtk::Label  world_label;  // das Label oben rechts
  Gtk::Button bye_button;   // der untere Button

protected:
  // Wir überschreiben eine virtuelle Funktion, die automatisch
  // aufgerufen wird, wenn das Anwendungsfenster durch den Window-
  // manager geschlossen werden soll:
  virtual gint
  delete_event_impl(GdkEventAny*);

public:
  // Der Konstruktor erhält drei Strings als Argumente, die von
  // den Buttons (1. und 3. String) bzw. dem Label angezeigt werden.
  HelloWindow(const string & hello_string,
              const string & world_string,
              const string & bye_string);

  
  // Callback-Methode, die aufgerufen werden soll, wenn auf den
  // oberen linken Button geklickt wird.
  void
  say_hello(void); // Gibt "Hello!" auf dem Terminal aus.

  
  // Callback-Methode, die aufgerufen werden soll, wenn auf den
  // unteren Button geklickt wird.
  void
  say_goodbye(void); // Gibt "Good Bye" aus und beendet das Programm.
};


HelloWindow::HelloWindow(const string & hello_string,
                         const string & world_string,
                         const string & bye_string)
  // Die HBox und die VBox werden vom Default-Konstruktor initia-
  // lisiert. Die Buttons und das Label werden mit den übergebenen
  // Strings initialisiert. (Button hat einen Komfort-Konstruktor,
  // der ein Label erzeugt und es in den Button einfügt.)
  : hello_button(hello_string),
    world_label (world_string),
    bye_button  (bye_string)
{
  // Den oberen linken Button in die HBox einfügen:
  hbox.add(hello_button);
  // Alle Widget müssen mit show() sichtbar gemacht werden:
  hello_button.show();

  // Das obere rechte Label in die HBox neben den Button einfügen:
  hbox.add(world_label);
  world_label.show();

  // Die HBox in die VBox einfügen:
  vbox.add(hbox);
  hbox.show();

  // Den unteren Button unter die HBox einfügen, die den anderen
  // Button und das Label enthält:
  vbox.add(bye_button);
  bye_button.show();

  // Die VBox in das Anwendungsfenster (*this) einfügen:
  add(vbox);
  vbox.show();

  // Buttons mit den Callbacks verbinden (s. Kasten über libsigc++):
  hello_button.clicked.connect(SigC::slot(this,
                                          &HelloWindow::say_hello));
  bye_button.clicked.connect(SigC::slot(this,
                                        &HelloWindow::say_goodbye));
}

void
HelloWindow::say_hello(void)
{
  cout << "Hello!" << endl;
}

void
HelloWindow::say_goodbye(void)
{
  cout << "Good bye!" << endl;
  Gtk::Main::quit(); // Exit event loop
}

// Das Fenster soll vom Windowmanager geschlossen werden:
gint
HelloWindow::delete_event_impl(GdkEventAny*)
{
  Gtk::Main::quit(); // Exit event loop

  // Rückgabewert true verhindert, dass das Fenster sofort nach
  // der Rückkehr zerstört wird.
  // (In diesem Fall wäre das eigentlich egal, weil
  //  das Programm sowieso anschließend beendet wird.)
  return true;
}

int
main(int argc, char ** argv)
{
  // Eine Instanz von Main wird erzeugt. Sie durchsucht die
  // Kommandozeilenelemente und entfernt diejenigen, die vom
  // Toolkit bearbeitet werden.
  Gtk::Main   kit(argc, argv);

  // Eine Instanz des Anwendungsfensters erzeugen und anzeigen.
  HelloWindow hello("Hello,", "World!",
                    "Good" "\n" "bye!");
  hello.show();

  // Eventschleife. Aus dieser Funktion heraus werden die Callbacks
  // aufgerufen.
  kit.run();

  return 0;
}