# Προγραμματισμός με gtkmm 3

Murray Cumming
Bernhard Rieder Chapter on "Timeouts".
Jonathon Jongsma Chapter on "Drawing with Cairo". Chapter on "Working with gtkmm's Source Code". Chapter on "Recent Files".
Ole Laursen Parts of chapter on "Internationalization".
Marko Anastasov Chapter on "Printing". Parts of chapter on "Internationalization".
Daniel Elstner Section "Build Structure" of chapter on "Wrapping C Libraries with gmmproc".
Chris Vine Chapter on "Multi-threaded programs".
David King Section on Gtk::Grid.
Pedro Ferreira Chapter on Keyboard Events.
Kjell Ahlstedt Parts of the update from gtkmm 2 to gtkmm 3.

Αυτό το βιβλίο εξηγεί βασικές έννοιες του gtkmm C++ API για δημιουργία διεπαφών χρήστη. Εισάγει επίσης τα κύρια στοιχεία διεπαφής χρήστη ("γραφικά συστατικά").

2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Murray Cumming

Επιτρέπεται η αντιγραφή, η διανομή και/ή τροποποίηση αυτού του εγγράφου υπό τους όρους της Ελεύθερης άδειας τεκμηρίωσης GNU, έκδοσης 1.2 ή σε οποιαδήποτε μεταγενέστερη, όπως αυτή δημοσιεύεται από το Ίδρυμα ελεύθερου λογισμικού· χωρίς αμετάβλητα τμήματα, χωρίς κείμενα εξωφύλλου ή οπισθόφυλλου. Μπορείτε να λάβετε ένα αντίγραφο της Ελεύθερης άδειας τεκμηρίωσης GNU από το Ίδρυμα ελεύθερου λογισμικού επισκεπτόμενοι τον ιστότοπό τους ή γράφοντας στο: Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

## Εισαγωγή

### Αυτό το βιβλίο

Αυτό το βιβλίο εξηγεί βασικές έννοιες του gtkmm C++ API για δημιουργία διεπαφών χρήστη. Εισάγει επίσης τα κύρια στοιχεία διεπαφής χρήστη ("γραφικά συστατικά"). Αν και αναφέρει κλάσεις, κατασκευαστές και μεθόδους, δεν υπεισέρχεται σε πολύ λεπτομερώς. Συνεπώς, για πλήρεις πληροφορίες API, θα πρέπει να ακολουθήσετε τους συνδέσμους στην τεκμηρίωση αναφοράς.

Αυτό το βιβλίο υποθέτει καλή κατανόηση της C++ και πώς να δημιουργείτε προγράμματα C++.

Θα θέλαμε πάρα πολύ να ακούσουμε οποιαδήποτε προβλήματα έχετε μαθαίνοντας το gtkmm με αυτό το έγγραφο και θα εκτιμούσαμε εισαγωγή σχετικά με βελτιώσεις. Παρακαλούμε, δείτε την ενότητα Συνεισφορά για παραπέρα πληροφορίες.

### gtkmm

Η gtkmm είναι ένας συσκευαστής C++ για το GTK+, μια βιβλιοθήκη που χρησιμοποιείται για τη δημιουργία γραφικών διεπαφών χρήστη. Αδειοδοτείται χρησιμοποιώντας την άδεια LGPL, έτσι μπορείτε να αναπτύξετε ανοικτό λογισμικό, ελεύθερο λογισμικό, ή ακόμα εμπορικό μη ελεύθερο λογισμικό χρησιμοποιώντας τη gtkmm χωρίς την αγορά αδειών.

Η gtkmm ονομάστηκε αρχικά gtk--, επειδή το GTK+ είχε ήδη ένα + στο όνομά του. Όμως, επειδή το -- δεν ευρετηριοποιείται εύκολα από τις μηχανές αναζήτησης, το πακέτο γενικά έγινε gtkmm και εκεί κολλήσαμε.

#### Γιατί χρησιμοποιούμε τη gtkmm αντί για το GTK+;

Η gtkmm επιτρέπει τη συγγραφή κώδικα χρησιμοποιώντας κανονικές τεχνικές C++ όπως ενθυλάκωση, παραγωγή και πολυμορφισμό. Ως προγραμματιστής C++ θα καταλάβατε ήδη ότι αυτό οδηγεί σε σαφέστερο και καλύτερα οργανωμένο κώδικα.

Η gtkmm είναι περισσότερο ασφαλές στους τύπους, έτσι ο μεταγλωττιστής μπορεί να αναγνωρίσει σφάλματα που θα μπορούσαν να ανιχνευτούν μόνο κατά τον χρόνο εκτέλεσης, κατά τη χρήση της C. Αυτή η χρήση ειδικών τύπων κάνει επίσης το API σαφέστερο, επειδή μπορείτε να δείτε τι τύποι πρέπει να χρησιμοποιηθούν κοιτώντας απλά σε μια δήλωση μεθόδου.

Η κληρονομικότητα μπορεί να χρησιμοποιηθεί για παραγωγή νέων γραφικών συστατικών. Η παραγωγή νέων γραφικών συστατικών σε κώδικα GTK+ C είναι τόσο περίπλοκη και επιρρεπής σε σφάλματα που σχεδόν κανένας κωδικοποιητής C δεν το κάνει. Ως προγραμματιστής C++, ξέρετε ότι η παραγωγή είναι μια βασική αντικειμενοστραφής τεχνική.

Μπορούν να χρησιμοποιηθούν στιγμιότυπα μελών, απλοποιώντας τη διαχείριση μνήμης. Όλα τα γραφικά συστατικά GTK+ C αντιμετωπίζονται με τη χρήση δεικτών.Ως κωδικοποιητής C++, ξέρετε ότι οι δείκτες πρέπει να αποφεύγονται, όπου είναι δυνατό.

Η gtkmm εμπεριέχει λιγότερο κώδικα συγκρινόμενη με τη GTK+, που χρησιμοποιεί ονόματα συναρτήσεων με πρόθεμα και πολλές αποχρώσεις μακροεντολών.

#### Η gtkmm συγκρινόμενη με τη Qt

Η Qt του Trolltech είναι ο πλησιέστερος ανταγωνιστής με τη gtkmm, έτσι αξίζει συζήτηση.

Οι προγραμματιστές της gtkmm τείνουν να προτιμούν τη gtkmm από τη Qt επειδή η gtkmm κάνει πράγματα με έναν πιο C++ τρόπο. Η Qt προέρχεται από μια εποχή όταν η C++ και η τυπική βιβλιοθήκη δεν είχαν προτυποποιηθεί ή δεν υποστηριζόντουσαν καλά από μεταγλωττιστές. Συνεπώς, διπλοεγγράφει πολύ υλικό που είναι τώρα στην τυπική βιβλιοθήκη, όπως περιέκτες και πληροφορίες τύπων. Πιο σημαντικό, η Trolltech τροποποίησε τη γλώσσα C++ για να δώσει σήματα, έτσι ώστε οι κλάσεις Qt δεν μπορούν να χρησιμοποιηθούν εύκολα με μη Qt κλάσεις. Η gtkmm μπορούσε να χρησιμοποιήσει την τυπική C++ για να παράσχει σήματα χωρίς αλλαγή της γλώσσας C++. Δείτε τις συχνές ερωτήσεις για περισσότερο λεπτομερείς διαφορές.

#### Η gtkmm είναι ένας συσκευαστής

Η gtkmm δεν είναι ένα εγγενές πακέτο εργαλείων C++, αλλά ένας συσκευαστής ενός πακέτου εργαλείων C. Αυτή ο χωρισμός της διεπαφής και της υλοποίησης έχει πλεονεκτήματα. Οι προγραμματιστές της gtkmm διαθέτουν τον περισσότερο χρόνο τους συζητώντας πώς η gtkmm μπορεί να παρουσιάσει τη πιο σαφή API, χωρίς περίεργους συμβιβασμούς λόγω των ασαφών τεχνικών λεπτομερειών. Συνεισφέρουμε λίγο στον υποκείμενο κώδικα βάσης GTK+, αλλά το ίδιο κάνουν και οι κωδικογράφοι της C και της Perl και του Python, κλπ. Συνεπώς η GTK+ επωφελείται από μια πλατύτερη βάση χρήστη από τα ειδικά πακέτα εργαλείων γλώσσας - υπάρχουν περισσότερα άτομα για υλοποίηση, ανάπτυξη, έλεγχο και χρήση.

## Εγκατάσταση

### Εξαρτήσεις

Πριν την προσπάθεια εγκατάστασης του gtkmm 3.0, ίσως χρειαστείτε πρώτα να εγκαταστήσετε αυτά τα άλλα πακέτα.

- libsigc++ 2.0

- GTK+ 3.0

- glibmm

- cairomm

- pangomm

- atkmm

Αυτές οι εξαρτήσεις έχουν τις δικές τους εξαρτήσεις, συμπεριλαμβανόμενων των ακόλουθων εφαρμογών και βιβλιοθηκών:

- pkg-config

- glib

- ATK

- Pango

- cairo

- gdk-pixbuf

### Unix και Linux

#### Προκατασκευασμένα πακέτα

Οι πρόσφατες εκδόσεις της gtkmm είναι πακεταρισμένες από σχεδόν κάθε μεγάλη διανομή Linux αυτές τις ημέρες. Έτσι, αν χρησιμοποιείτε Linux, μπορείτε προφανώς να ξεκινήσετε με τη gtkmm εγκαθιστώντας το πακέτο από το επίσημο αποθετήριο για τη διανομή σας. Οι διανομές που περιλαμβάνουν τη gtkmm στα αποθετήριά τους περιλαμβάνουν Ντέμπιαν, Ουμπούντου, Ρέντ Χατ, Φεντόρα, Μαντρίβα, Σούσε και πολλές άλλες.

Τα ονόματα των πακέτων της gtkmm ποικίλουν από διανομή σε διανομή (π.χ. libgtkmm3.0-dev στο Ντέμπιαν και Ουμπούντου ή gtkmm30-devel στο Ρέντ χατ φεντόρα), γιαυτό ελέγξτε το πρόγραμμα διαχείρισης πακέτου της διανομής σας για το σωστό όνομα πακέτου και εγκαταστήστε το όπως θα κάνατε με οποιοδήποτε άλλο πακέτο.

Τα ονόματα του πακέτου δεν θα αλλάζουν όταν νέες συμβατές εκδόσεις API/ABI της gtkmm κυκλοφορούν. Αλλιώς, μπορεί να μην είναι συμβατά με API/ABI. Έτσι μην εκπλαγείτε, για παράδειγμα, αν βρείτε τη gtkmm 3.8 που παρέχεται από το πακέτο libgtkmm3.0-dev του Ντέμπιαν.

#### Εγκατάσταση από την πηγή

Αν η διανομή σας δεν παρέχει ένα προκατασκευασμένο πακέτο της gtkmm, ή αν θέλετε να εγκαταστήσετε μια διαφορετική έκδοση από την παρεχόμενη από τη διανομή σας, μπορείτε επίσης να εγκαταστήσετε τη gtkmm από την πηγή. Ο πηγαίος κώδικας για τη gtkmm μπορεί να μεταφορτωθεί από το .

Αφού έχετε εγκαταστήσει όλες τις εξαρτήσεις, μεταφορτώστε τον πηγαίο κώδικα της gtkmm, αποσυμπιέστε τον και αλλάξτε στον νεοδημιουργούμενο κατάλογο. Η gtkmm μπορεί να δομηθεί και να εγκατασταθεί με την ακόλουθη σειρά εντολών:

    # ./configure
    # make
    # make install

Να θυμάστε ότι σε ένα λειτουργικό σύστημα Unix ή Linux θα χρειαστείτε προφανώς να είσαστε `root` (υπερχρήστης) για την εγκατάσταση λογισμικού. Η εντολή `su` ή `sudo` θα επιτρέψει να εισάγετε τον κωδικό πρόσβασης του `root` και να έχετε προσωρινά την κατάσταση `root`.

Το σενάριο `configure` (διαμόρφωση) θα ελέγξει για να διασφαλίσει ότι όλες οι απαιτούμενες εξαρτήσεις έχουν ήδη εγκατασταθεί. Αν σας λείπει κάποια εξάρτηση, θα εξέλθει και θα εμφανίσει ένα σφάλμα.

By default, gtkmm will be installed under the `/usr/local` directory. On some systems you may need to install to a different location. For instance, on Red Hat Linux systems you might use the `--prefix` option with configure, like so:

    # ./configure --prefix=/usr

Θα πρέπει να είστε πολύ προσεκτικοί κατά την εγκατάσταση σε τυπικά προθέματα συστήματος όπως `/usr`. Οι διανομές Linux εγκαθιστούν πακέτα λογισμικού στο `/usr`, έτσι η εγκατάσταση ενός πηγαίου πακέτου σε αυτό το πρόθεμα μπορεί να αλλοιώσει ή να συγκρουστεί με το εγκατεστημένο λογισμικό χρησιμοποιώντας το σύστημα διαχείρισης πακέτου της διανομής σας. Ιδανικά, θα πρέπει να χρησιμοποιήσετε ένα ξεχωριστό πρόθεμα για όλο το λογισμικό που εγκαθιστάτε από την πηγή.

Αν θέλετε να βοηθήσετε στην ανάπτυξη της gtkmm ή να πειραματιστείτε με νέα χαρακτηριστικά, μπορείτε επίσης να εγκαταστήσετε τη gtkmm από το git. Οι περισσότεροι χρήστες δεν θα χρειαστεί ποτέ να το κάνουν αυτό, αλλά αν ενδιαφέρεστε να βοηθήσετε στην ανάπτυξη της gtkmm, δείτε το παράρτημα Εργασία με τον πηγαίο κώδικα της gtkmm.

### Microsoft Windows

Οι GTK+ και gtkmm σχεδιάστηκαν να δουλεύουν καλά με τα Microsoft Windows και οι προγραμματιστές ενθαρρύνουν τη χρήση τους σε λειτουργικό win32. Όμως, τα Windows δεν έχουν τυπικό σύστημα εγκατάστασης για ανάπτυξη βιβλιοθηκών. Παρακαλούμε, δείτε τη σελίδα Εγκατάσταση Windows για οδηγίες και σημειώσεις εγκατάστασης ειδικής για Windows.

## Τα βασικά

Αυτό το κεφάλαιο θα εισάγει μερικές από τις πιο σημαντικές πτυχές της κωδικοποίησης της gtkmm. Αυτές θα παρουσιαστούν με απλό παράδειγμα εργασίας κώδικα. Όμως, αυτό είναι απλά μια δοκιμή, έτσι χρειάζεται να κοιτάξετε τα άλλα κεφάλαια για περισσότερο ουσιαστικές πληροφορίες.

Η υπάρχουσα γνώση της C++ θα σας βοηθήσει με τη gtkmm, όπως θα έκανε με οποιαδήποτε βιβλιοθήκη. Εκτός και δηλωθεί αλλιώς, μπορείτε να περιμένετε οι κλάσεις της gtkmm να συμπεριφέρονται όπως οποιαδήποτε άλλη κλάση C++ και μπορείτε να περιμένετε να χρησιμοποιήσετε τις υπάρχουσες τεχνικές C++ με τις κλάσεις της gtkmm.

### Απλό παράδειγμα

Για να ξεκινήσουμε την εισαγωγή μας στη gtkmm, θα αρχίσουμε με το πιο απλό δυνατό πρόγραμμα. Αυτό το πρόγραμμα θα δημιουργήσει ένα κενό παράθυρο 200 x 200 εικονοστοιχεία.

Source Code

File: `base.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <gtkmm.h>

    int main(int argc, char *argv[])
    {
      auto app =
        Gtk::Application::create(argc, argv,
          "org.gtkmm.examples.base");

      Gtk::Window window;
      window.set_default_size(200, 200);

      return app->run(window);
    }

Θα εξηγήσουμε τώρα κάθε γραμμή του παραδείγματος

    #include <gtkmm.h>

Όλα τα προγράμματα της gtkmm πρέπει να περιλαμβάνουν συγκεκριμένες κεφαλίδες της gtkmm· η `gtkmm.h` περιλαμβάνει το πλήρες πακέτο της gtkmm. Αυτό συνήθως δεν είναι καλή ιδέα, επειδή περιλαμβάνει ένα Mb περίπου κεφαλίδες, αλλά για απλά προγράμματα, επαρκεί.

The next statement:

    Glib::RefPtr<Gtk::Application> app = Gtk::Application::create(argc, argv, "org.gtkmm.examples.base");

creates a Gtk::Application object, stored in a RefPtr smartpointer. This is needed in all gtkmm applications. The create() method for this object initializes gtkmm, and checks the arguments passed to your application on the command line, looking for standard options such as `--display`. It takes these from the argument list, leaving anything it does not recognize for your application to parse or ignore. This ensures that all gtkmm applications accept the same set of standard arguments.

Οι επόμενες δύο γραμμές κώδικα δημιουργούν ένα παράθυρο και ορίζουν το προεπιλεγμένο (αρχικό) μέγεθος τους:

    Gtk::Window window;
    window.set_default_size(200, 200);

Η τελευταία γραμμή εμφανίζει το παράθυρο και εισάγει τον κύριο βρόχο επεξεργασίας της gtkmm, που θα τελειώσει, όταν κλείσει το παράθυρο. Η συνάρτηση `main()`, θα επιστρέψει τότε με τον κατάλληλο κώδικα επιτυχίας ή σφάλματος.

    return app->run(window);

After putting the source code in `simple.cc` you can compile the above program with gcc using:

    g++ simple.cc -o simple `pkg-config gtkmm-3.0 --cflags --libs`

Note that you must surround the `pkg-config` invocation with backquotes. Backquotes cause the shell to execute the command inside them, and to use the command's output as part of the command line. Note also that `simple.cc` must come before the `pkg-config` invocation on the command line.

### Κεφαλίδες και σύνδεση

Αν και έχουμε εμφανίσει την εντολή μεταγλώττισης για το απλό παράδειγμα, θα πρέπει πραγματικά να χρησιμοποιήσετε τα εργαλεία automake και autoconf, όπως περιγράφονται στο "Autoconf, Automake, Libtool", από τον G. V. Vaughan κ.α. Τα χρησιμοποιούμενα παραδείγματα σε αυτό το βιβλίο περιλαμβάνονται στο πακέτο gtkmm-τεκμηρίωση, με κατάλληλα αρχεία δόμησης, έτσι δεν θα εμφανίσουμε τις εντολές δόμησης στο μέλλον. Θα χρειαστείτε απλά να βρείτε τον κατάλληλο κατάλογο και να πληκτρολογήσετε `make`.

Για απλοποίηση της μεταγλώττισης, χρησιμοποιούμε `pkg-config`, που είναι παρόν σε όλες τις (σωστά εγκατεστημένες εγκαταστάσεις) της gtkmm. Αυτό το πρόγραμμα 'ξέρει' τι διακόπτες μεταγλωττιστή απαιτούνται για μεταγλώττιση προγραμμάτων που χρησιμοποιούν τη gtkmm. Η επιλογή `--cflags` προκαλεί τη `pkg-config` να δώσει μια λίστα των περιλαμβανόμενων καταλόγων για να ψάξει ο μεταγλωττιστής· η επιλογή `--libs` ζητά τη λίστα των βιβλιοθηκών ώστε ο μεταγλωττιστής να συνδεθεί και οι κατάλογοι να τους βρουν. Δοκιμάστε να το εκτελέσετε από την προτροπή φλοιού για να δείτε τα αποτελέσματα στο σύστημά σας.

However, this is even simpler when using the `PKG_CHECK_MODULES()` macro in a standard configure.ac file with autoconf and automake. For instance:

    PKG_CHECK_MODULES([MYAPP], [gtkmm-3.0 >= 3.8.0])

This checks for the presence of gtkmm and defines MYAPP_LIBS and MYAPP_CFLAGS for use in your Makefile.am files.

gtkmm-3.0 είναι το όνομα της τρέχουσας σταθερής API. Υπήρξε μια παλιότερη API που λεγότανε gtkmm-2-4 που εγκαθίσταται παράλληλα όταν είναι διαθέσιμη. Υπήρξαν πολλές εκδόσεις του gtkmm-2.4, όπως gtkmm 2.10 και θα υπάρξουν αρκετές εκδόσεις του gtkmm-3.0 API. Σημειώστε ότι το όνομα API δεν αλλάζει για κάθε έκδοση, επειδή αυτό θα ήταν μια ασύμβατη διακοπή API και ABI. Θεωρητικά, μπορεί να υπάρξει μια μελλοντική API gtkmm-4.0 που θα εγκαθίσταται παράλληλα με το gtkmm-3.0 χωρίς να επηρεάζει τις υπάρχουσες εφαρμογές.

Σημειώστε ότι αν αναφέρετε πρόσθετα αρθρώματα πέρα από το gtkmm-3.0, θα πρέπει να χωρίζονται από διαστήματα, όχι κόμματα.

Openismus έχει περισσότερη βασική βοήθεια με automake και autoconf.

### Γραφικά συστατικά

Οι εφαρμογές της gtkmm αποτελούνται από παράθυρα που περιέχουν γραφικά συστατικά, όπως κουμπιά και πλαίσια κειμένου. Σε μερικά άλλα συστήματα, τα γραφικά συστατικά λέγονται "στοιχεία ελέγχου". Για κάθε γραφικό συστατικό στα παράθυρα της εφαρμογής σας, υπάρχει ένα αντικείμενο C++ στον κώδικα της εφαρμογής σας. Έτσι χρειάζεστε απλά να καλέσετε μια μέθοδο της κλάσης του γραφικού συστατικού για να επηρεάσετε το ορατό γραφικό συστατικό.

Widgets are arranged inside container widgets such as frames and notebooks, in a hierarchy of widgets within widgets. Some of these container widgets, such as Gtk::Grid, are not visible - they exist only to arrange other widgets. Here is some example code that adds 2 Gtk::Button widgets to a Gtk::Box container widget:

    m_box.pack_start(m_Button1);
    m_box.pack_start(m_Button2);

and here is how to add the Gtk::Box, containing those buttons, to a Gtk::Frame, which has a visible frame and title:

    m_frame.add(m_box);

Τα περισσότερα από τα κεφάλαια σε αυτό το βιβλίο πραγματεύονται ειδικά γραφικά συστατικά. Δείτε την ενότητα Γραφικά συστατικά περιέκτη για περισσότερες λεπτομέρειες για την προσθήκη γραφικών συστατικών σε γραφικά συστατικά περιέκτη.

Αν και μπορείτε να ορίσετε τη διάταξη και την εμφάνιση των παραθύρων και των γραφικών συστατικών με τον κώδικα C++, θα βρείτε πιο βολικό να σχεδιάσετε τις διεπαφές χρήστη σας με το `Glade` και να τις φορτώσετε στον χρόνο εκτέλεσης με `Gtk::Builder`. Δείτε το κεφάλαιο Glade and Gtk::Builder.

Αν και τα στιγμιότυπα γραφικών συστατικών του gtkmm έχουν χρόνους ζωής και εμβέλειες ακριβώς όπως αυτά των άλλων κλάσεων της C++, η gtkmm έχει ένα προαιρετικό χαρακτηριστικό αποθήκευσης χρόνου που θα δείτε σε μερικά παραδείγματα. Η `Gtk::manage()` επιτρέπει να πείτε ότι ένα θυγατρικό γραφικό συστατικό κατέχεται από τον περιέκτη στον οποίο το τοποθετείτε. Αυτό σας επιτρέπει `new` γραφικό συστατικό, προσθήκη του στον περιέκτη και παράλειψη της διαγραφής του. Μπορείτε να μάθετε περισσότερα για τις τεχνικές διαχείρισης μνήμης της gtkmm στο κεφάλαιο διαχείρισης μνήμης.

### Σήματα

Η gtkmm, όπως τα περισσότερα πακέτα εργαλείων γραφικής διεπαφής, οδηγείται από τα συμβάντα. Όταν συμβαίνει ένα γεγονός, όπως το πάτημα ενός πλήκτρου του ποντικιού, το κατάλληλο σήμα θα εκπεμφθεί από το γραφικό συστατικό που πατήθηκε. Κάθε γραφικό συστατικό έχει ένα διαφορετικό σύνολο σημάτων που μπορεί να εκπέμψει. Για να κάνετε ένα πάτημα κουμπιού αποτέλεσμα σε μια ενέργεια, ορίζουμε έναν χειριστή σήματος για τη σύλληψη του σήματος "πατημένο" του κουμπιού.

gtkmm uses the libsigc++ library to implement signals. Here is an example line of code that connects a Gtk::Button's "clicked" signal with a signal handler called "on_button_clicked":

    m_button1.signal_clicked().connect( sigc::mem_fun(*this,
      &HelloWorld::on_button_clicked) );

Για περισσότερο λεπτομερείς πληροφορίες για τα σήματα, δείτε το παράρτημα.

Για πληροφορίες υλοποίησης των δικών σας σημάτων αντί για απλή σύνδεση σε υπάρχοντα σήματα της gtkmm, δείτε το παράρτημα.

### Glib::ustring

Μπορεί να εκπλαγείτε μαθαίνοντας ότι η gtkmm δεν χρησιμοποιεί τη std::string στις διεπαφές της. Αντίθετα χρησιμοποιεί τη Glib::ustring, που είναι τόσο παρόμοια και διακριτική που θα μπορούσατε στην πραγματικότητα να προσποιηθείτε ότι κάθε Glib::ustring είναι μία std::string και να αγνοήστε το υπόλοιπο αυτής της ενότητας. Αλλά διαβάστε, αν θέλετε να χρησιμοποιήσετε διαφορετικές γλώσσες από τα αγγλικά στην εφαρμογή σας.

Το std::string χρησιμοποιεί 8 δυαδικά ψηφία ανά χαρακτήρα, αλλά 8 δυαδικά δεν είναι αρκετά για κωδικοποίηση γλωσσών όπως αραβικά, κινέζικα και ιαπωνικά. Αν και οι κωδικοποιήσεις για αυτές τις γλώσσες έχουν τώρα καθοριστεί από την κοινοπραξία Unicode, οι γλώσσες C και C++ δεν παρέχουν ακόμα καμιά προτυποποιημένη υποστήριξη Unicode. GTK+ και GNOME επιλέγουν την υλοποίηση του Unicode χρησιμοποιώντας UTF-8 και αυτό συσκευάζεται από το Glib::ustring. Παρέχει σχεδόν ακριβώς την ίδια διεπαφή ως std::string, μαζί με αυτόματες μετατροπές προς και από std::string.

Ένα από τα πλεονεκτήματα του UTF-8 είναι ότι δεν χρειάζεστε να το χρησιμοποιήσετε εκτός και το θέλετε, έτσι δεν χρειάζεστε να τροποποιήσετε όλο τον κώδικά σας μονομιάς. Η std::string θα δουλέψει ακόμα για συμβολοσειρές ASCII 7 δυαδικών ψηφίων. Αλλά, όταν δοκιμάσετε να τοπικοποιήσετε την εφαρμογή σας για γλώσσες όπως κινέζικα, για παράδειγμα, θα αρχίσετε να βλέπετε περίεργα σφάλματα και πιθανές καταρρεύσεις. Τότε, αυτό που χρειάζεται να κάνετε είναι να αρχίσετε να χρησιμοποιείτε τη Glib::ustring στη θέση του.

Σημειώστε ότι το UTF-8 δεν είναι συμβατό με κωδικοποιήσεις 8 δυαδικών όπως το ISO-8859-1. Για παράδειγμα, τα γερμανικά umlauts δεν είναι στην περιοχή ASCII και χρειάζεται περισσότερο από 1 ψηφιολέξη στην κωδικοποίηση UTF-8. Αν ο κώδικας σας περιέχει κυριολεκτικές συμβολοσειρές 8 δυαδικών, πρέπει να τις μετατρέψετε σε UTF-8 (π.χ. ο βαυαρικός χαιρετισμός "Grüß Gott" πρέπει να είναι "Gr\xC3\xBC\xC3\x9F Gott").

Θα πρέπει να αποφύγετε τον αριθμητικό δείκτη τεχνοτροπίας C και συναρτήσεις όπως strlen(). Σε UTF-8, κάθε χαρακτήρας μπορεί να χρειαστεί οπουδήποτε από 1 έως 6 ψηφιολέξεις, έτσι δεν είναι δυνατό να θεωρήσετε ότι η επόμενη ψηφιολέξη είναι ένας άλλος χαρακτήρας. Η Glib::ustring ασχολείται με τις λεπτομέρειες αυτού για σας, έτσι μπορείτε να χρησιμοποιήσετε μεθόδους όπως Glib::ustring::substr(), ενώ σκεφτόσαστε ακόμα χαρακτήρες αντί για ψηφιολέξεις.

Αντίθετα με τη λύση Unicode UCS-2 των Windows, αυτό δεν απαιτεί καμιά ειδική επιλογή μεταγλωττιστή για επεξεργασία κυριολεκτικών συμβολοσειρών και δεν καταλήγει σε εκτελέσιμα Unicode και βιβλιοθήκες που είναι ασύμβατες με τις αντίστοιχες ASCII.

Reference

Δείτε την ενότητα διεθνοποίηση για πληροφορίες σχετικές με την παροχή κυριολεκτικών συμβολοσειρών UTF-8.

### Ενδιάμεσοι τύποι

Μερικές API που σχετίζονται με τη gtkmm χρησιμοποιούν ενδιάμεσους περιέκτες δεδομένων, όπως Glib::StringArrayHandle, αντί για ειδικό τυπικό περιέκτη C++ όπως std::vector ή std::list, αν και το ίδιο το gtkmm τώρα χρησιμοποιεί απλά std::vector από το gtkmm 3.0.

You should not declare these types yourself. You should instead use whatever Standard C++ container you prefer. glibmm will do the conversion for you. Here are some of these intermediate types:

- Glib::StringArrayHandle or Glib::ArrayHandle<Glib::ustring>: Use std::vector<Glib::ustring>, std::list<Glib::ustring>, const char*[], etc.

- Glib::ListHandle<Gtk::Widget*>: Use std::vector<Gtk::Widget*>, std::list<Gtk::Widget*>, etc.

- Glib::SListHandle<Gtk::Widget*>: Use std::vector<Gtk::Widget*>, std::list<Gtk::Widget*>, etc.

### Ανάμειξη APIs C και C++

Μπορείτε να χρησιμοποιήσετε APIs C που δεν έχουν ακόμα βολικές διεπαφές C++. Δεν είναι γενικά πρόβλημα να χρησιμοποιήσετε APIs C από C++ και τη gtkmm βοηθά δίνοντας πρόσβαση στο υποκείμενο αντικείμενο C και παρέχοντας έναν εύκολο τρόπο δημιουργίας αντικειμένου συσκευαστή C++ από ένα αντικείμενο C, με την προϋπόθεση ότι η API C βασίζεται επίσης στο σύστημα GObject.

Για να χρησιμοποιήσετε ένα στιγμιότυπο της gtkmm με μια συνάρτηση C που απαιτεί ένα στιγμιότυπο GObject της C, χρησιμοποιήστε τη συνάρτηση `gobj()` για να πάρετε έναν δείκτη στο υποκείμενο στιγμιότυπο GObject. Για παράδειγμα

    Gtk::Button* button = new Gtk::Button("example");
    gtk_button_do_something_new(button->gobj());

Για να πάρετε ένα στιγμιότυπο της gtkmm από ένα στιγμιότυπο GObject της C, χρησιμοποιήστε τη συνάρτηση Glib::wrap(). Για παράδειγμα

    GtkButton* cbutton = get_a_button();
    Gtk::Button* button = Glib::wrap(cbutton);

### Hello World στη gtkmm

Έχουμε τώρα μάθει αρκετά για να κοιτάξουμε ένα πραγματικό παράδειγμα. Σύμφωνα με μια παλιά παράδοση της επιστήμης των υπολογιστών, θα εισάγουμε τώρα Hello World, στη gtkmm:

Source Code

File: `helloworld.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_HELLOWORLD_H
    #define GTKMM_EXAMPLE_HELLOWORLD_H

    #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;
    };

    #endif // GTKMM_EXAMPLE_HELLOWORLD_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

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

    int main (int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      HelloWorld helloworld;

      //Shows the window and returns when it is closed.
      return app->run(helloworld);
    }

File: `helloworld.cc` (For use with gtkmm 3, not gtkmm 2)

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

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

      // When the button receives the "clicked" signal, it will call the
      // on_button_clicked() method defined below.
      m_button.signal_clicked().connect(sigc::mem_fun(*this,
                  &HelloWorld::on_button_clicked));

      // This packs the button into the Window (a container).
      add(m_button);

      // The final step is to display this newly created widget...
      m_button.show();
    }

    HelloWorld::~HelloWorld()
    {
    }

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

Δοκιμάστε να μεταγλωττίσετε και να το εκτελέσετε πριν να συνεχίσουμε. Θα πρέπει να δείτε κάτι σαν αυτό:

Hello World

Αρκετά συναρπαστικό; Ας εξετάσουμε τον κώδικα. Πρώτα, την κλάση HelloWorld:

    class HelloWorld : public Gtk::Window
    {

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

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

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

Αυτή η κλάση υλοποιεί το παράθυρο "Hello World". Παράγεται από τη Gtk::Window και έχει ένα μοναδικό Gtk::Button ως μέλος. Έχουμε επιλέξει να χρησιμοποιήσουμε τον κατασκευαστή για να κάνει όλη την εργασία αρχικοποίησης για το παράθυρο, συμπεριλαμβανόμενης της ρύθμισης των σημάτων. Να το, με παράλειψη των σχολίων:

    HelloWorld::HelloWorld()
    :
      m_button ("Hello World")
    {
      set_border_width(10)·
      m_button.signal_clicked().connect(sigc::mem_fun(*this,
        &HelloWorld::on_button_clicked));
      add(m_button);.
      m_button.show();
    }

Σημειώστε ότι έχουμε χρησιμοποιήσει μια πρόταση αρχικοποίησης για να δώσουμε στο αντικείμενο `m_button` την ετικέτα "Hello World".

Έπειτα, καλούμε τη μέθοδο set_border_width() του παραθύρου. Αυτό ρυθμίζει τον χώρο μεταξύ των πλευρών του παραθύρου και του γραφικού συστατικού που περιέχει.

Έπειτα συνδέουμε έναν χειριστή σήματος στο `m_button` το σήμα του `clicked` (πατημένο). Αυτό εκτυπώνει τον φιλικό μας χαιρετισμό στην `stdout` (τυπική έξοδος).

Κατόπιν, χρησιμοποιούμε τη μέθοδο add() του παραθύρου για να βάλουμε στο παράθυρο `m_button`. (η add() έρχεται από το Gtk::Container, που περιγράφεται στο κεφάλαιο των γραφικών συστατικών περιέκτη.) Η μέθοδος add() βάζει το γραφικό συστατικό στο παράθυρο, αλλά δεν εμφανίζει το γραφικό συστατικό. Τα γραφικά συστατικά της gtkmm είναι πάντα αόρατα, όταν τα δημιουργείτε - για την εμφάνισή τους, πρέπει να καλέσετε τη μέθοδό τους show(), που είναι αυτό που κάνουμε στην επόμενη γραμμή.

Τώρα ας κοιτάξουμε στη συνάρτηση `main()` του προγράμματός μας. Να τη, χωρίς σχόλια:

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

      HelloWorld helloworld;
      return app->run(helloworld);
    }

Πρώτα, δημιουργούμε ένα αποθηκευμένο αντικείμενο στον έξυπνο δείκτη RefPtr που λέγεται `app`. Αυτό είναι του τύπου Gtk::Application. Κάθε πρόγραμμα της gtkmm πρέπει να έχει ένα από αυτά. Περνάμε τα ορίσματα της γραμμής εντολών μας στη μέθοδο της create(). Παίρνει τα ορίσματα που θέλει και σας αφήνει τα υπόλοιπα, όπως περιγράψαμε νωρίτερα.

Next we make an object of our HelloWorld class, whose constructor takes no arguments, but it isn't visible yet. When we call Gtk::Application::run(), giving it the helloworld Window, it shows the Window and starts the gtkmm event loop. During the event loop gtkmm idles, waiting for actions from the user, and responding appropriately. When the user closes the Window, run() will return, causing the final line of our main() function be to executed. The application will then finish.

## Αλλαγές στη gtkmm 3

Η gtkmm-3.0 είναι μια νέα έκδοση της API της gtkmm που εγκαθίσταται παράλληλα με την παλιότερη API της gtkmm-2.4. Η τελευταία έκδοση της API της gtkmm-2.4 ήταν η gtkmm 2.24. Η gtkmm 3 δεν έχει κύριες θεμελιακές διαφορές με την gtkmm 2, αλλά κάνει πολλές μικρές αλλαγές που δεν ήταν δυνατές κατά τη διατήρηση δυαδικής συμβατότητας. Αν δεν έχετε ποτέ χρησιμοποιήσει την API της gtkmm-2.4, τότε μπορείτε να αγνοήσετε με ασφάλεια αυτό το κεφάλαιο.

Η βιβλιοθήκη της gtkmm 3 λέγεται `libgtkmm-3.0` αντί για `libgtkmm-2.4` και εγκαθιστά τις κεφαλίδες της σε έναν κατάλογο παρόμοιας έκδοσης, έτσι ο έλεγχος σας pkg-config πρέπει να ζητήσει για `gtkmm-3.0` αντί για `gtkmm-2.4`.

Η gtkmm 3 πρόσθεσε μερικές νέες κλάσεις:

1. Οι Gtk::AppChooser, Gtk::AppChooserButton, Gtk::AppChooserDialog επιτρέπουν την επιλογή μιας εγκατεστημένης εφαρμογής που θα ανοίξει έναν συγκεκριμένο τύπο περιεχομένου.

2. Η Gtk::Grid είναι ένα νέο γραφικό συστατικό περιέκτη που θα αντικαταστήσει τελικά την Gtk::Box και την Gtk::Table. Ταξινομεί τα θυγατρικά της σύμφωνα με τις ιδιότητες αυτών των θυγατρικών αντί για τις δικές της λεπτομέρειες διάταξης.

3. Η Gtk::Switch εμφανίζει καταστάσεις ναι/όχι πιο σαφώς από την Gtk::CheckBox. Μπορεί να είναι χρήσιμη, για παράδειγμα, όταν επιτρέπει στους χρήστες να ενεργοποιούν υλικό.

Η gtkmm 3 επίσης έκανε πολλές μικρές αλλαγές στην API, τις οποίες προφανώς θα αντιμετωπίσετε κατά τη μεταφορά κώδικα που χρησιμοποιήθηκε στο gtkmm-2.4. Να μια σύντομη λίστα:

1. Gtk::CellLayout, χρησιμοποιήθηκε από Gtk::IconView, Gtk::TreeView::Column και Gtk::ComboBox, τώρα έχει μια Gtk::CellArea που μπορεί να χρησιμοποιηθεί για να ορίσει περισσότερες λεπτομέρειες τακτοποίησης και στοίχισης των CellRenderer.

2. Το Gtk::ComboBox τώρα παράγεται από CellLayout, επιτρέποντας ευκολότερη διάταξη και στοίχιση των Gtk::CellRenderer του.

3. Οι Gtk::Adjustment, IconSet και Gdk::Cursor χρησιμοποιούνται τώρα μέσα από Glib::RefPtr.

4. Οι Gtk::Box, Gtk::ButtonBox, Gtk::IconView, Gtk::Paned, Gtk::ProgressBar, Gtk::ScaleButton, Gtk::Scrollbar και Gtk::Separator παράγονται τώρα από Gtk::Orientable, επιτρέποντας τον προσανατολισμό τους (κάθετο ή οριζόντιο) να οριστεί χωρίς αίτηση χρήσης παράγωγης κλάσης όπως Gtk::HBox.

5. Gtk::IconView, Gtk::TextView, Gtk::TreeView και άλλα γραφικά συστατικά παράγονται από κυλιόμενα αντί να έχουν τις δικές τους μεθόδους όπως get_vadjustment() και αντί να έχουν το δικό τους σήμα set_scroll_adjustments.

6. Οι Gtk::Style and Gtk::Rc αφαιρέθηκαν και αντικαταστάθηκαν με Gtk::StyleContext και Gtk::StyleProviders, όπως Gtk::CssProvider.

7. Η Widget::on_expose_event() αντικαταστάθηκε από Widget::on_draw(), που υποθέτει ότι το cairomm χρησιμοποιείται για σχεδίαση, μέσα από την παρεχόμενη Cairo::Context και δεν σας ζητά να καλέσετε την Cairo::Context::clip().

8. Η Gdk::RGBA αντικαθιστά την Color, προσθέτοντας ένα άλφα συστατικό για αδιαφάνεια. Η Colormap αφαιρέθηκε, μαζί με τη περίεργη χρήση της για κατανομή χρωμάτων.

9. Οι Gdk::Pixmap και αφαιρέθηκαν Gdk::Bitmap υπέρ της Gdk::Pixbuf.

10. Η Gdk::Drawable αφαιρέθηκε, με τις μεθόδους της να μετακινούνται στο Gdk::Window.

11. Τώρα χρησιμοποιούμε std::vector σε αρκετές μεθόδους αντί για τους ενδιάμεσους τύπους *Handle για να κάνουμε την API πιο σαφή.

Όλες οι παρωχημένες API αφαιρέθηκαν στην gtkmm 3.0, αν και θα υπάρχουν νέα παρωχημένα στις μελλοντικές εκδόσεις.

Ως πρώτο βήμα για μεταφορά του πηγαίου κώδικά σας στο gtkmm-3.0, θα πρέπει προφανώς να εξασφαλίσετε, ότι η εφαρμογή σας δομεί με την παρωχημένη gtkmm-2.4 με ανενεργή API, ορίζοντας μακροεντολή όπως GTK_DISABLE_DEPRECATED. Υπάρχουν μερικά αυτόματα εργαλεία μακροεντολών που μπορούν να βοηθήσουν με αυτό ορίζοντας τα προαιρετικά την ώρα δόμησης. Δείτε τη σελίδα wiki μεταφοράς gtkmm 3 για περισσότερες λεπτομέρειες.

## Κουμπιά

Η gtkmm παρέχει τέσσερις βασικούς τύπους κουμπιών:

Κουμπιά πίεσης

  Gtk::Button. Τυπικά κουμπιά, συνήθως σημειωμένα με μια ετικέτα ή εικόνα. Πιέζοντας ένα προκαλεί μια ενέργεια. Δείτε την ενότητα Κουμπί.

Κουμπιά εναλλαγής

  Gtk::ToggleButton. Αντίθετα με ένα κανονικό κουμπί, που αναπηδά πίσω, ένα ToggleButton παραμένει κάτω μέχρι να το ξαναπήσετε. Μπορεί να είναι χρήσιμο ως ένας διακόπτης ναι/όχι. Δείτε την ενότητα ToggleButton.

Πλαίσια ελέγχου

  Gtk::CheckButton. Αυτά δρουν ως ToggleButtons, αλλά εμφανίζουν την κατάστασή τους σε μικρά τετράγωνα, με την ετικέτα τους στο πλάι. Πρέπει να χρησιμοποιούνται στις περισσότερες περιπτώσεις που απαιτούν μια ρύθμιση ναι/όχι. Δείτε την ενότητα CheckBox.

Ραδιοπλήκτρα

  Gtk::RadioButton. Ονομάστηκαν σύμφωνα με τους επιλογείς σταθμών σε παλιά ραδιόφωνα αυτοκινήτων, αυτά τα κουμπιά χρησιμοποιούνται σε ομάδες για επιλογές που αποκλείονται αμοιβαία. Πατώντας ένα προκαλεί όλα τα άλλα σε αυτήν την ομάδα να απενεργοποιηθούν. Είναι παρόμοια με τα CheckBoxes (ένα μικρό γραφικό συστατικό με μια ετικέτα στο πλάι), αλλά συνήθως μοιάζουν διαφορετικά. Δείτε την ενότητα RadioButton.

Σημειώστε ότι, λόγω του συστήματος θεμάτων του GTK+, η εμφάνιση αυτών των γραφικών συστατικών θα ποικίλει. Στην περίπτωση των πλαισίων ελέγχου και ραδιοπλήκτρων, μπορεί να ποικίλουν σημαντικά.

### Κουμπί

#### Κατασκευαστές

Υπάρχουν δύο τρόποι δημιουργίας ενός κουμπιού. Μπορείτε να ορίσετε μια συμβολοσειρά ετικέτας στον κατασκευαστή Gtk::Button, ή να το ορίσετε αργότερα με set_label().

Για τον ορισμό ενός πλήκτρου επιταχυντή για περιήγηση πληκτρολογίου, τοποθετήστε μια υπογράμμιση πριν από έναν από τους χαρακτήρες της ετικέτας και ορίστε `true` (αληθές) για την προαιρετική παράμετρο `mnemonic` (μνημονική). Για παράδειγμα:

    Gtk::Button* pButton = new Gtk::Button("_Something", true);

Έτοιμα στοιχεία συνιστώνται για χρήση στα κουμπιά. Από την gtkmm-3.10 είναι ξεπερασμένα. Δεν πρέπει να χρησιμοποιηθούν σε νεογραμμένο κώδικα. Όμως, η τεκμηρίωση του namespace Gtk::Stock εμφανίζει συνιστώμενες ετικέτες και επώνυμα εικονίδια να εμφανίζονται στα κουμπιά.

Η Gtk::Button είναι επίσης ένας περιέκτης, έτσι μπορείτε να βάλετε οποιοδήποτε άλλο γραφικό συστατικό, όπως μια Gtk::Image μέσα του.

Reference

#### Παράδειγμα

Αυτό το παράδειγμα δημιουργεί ένα κουμπί με μια εικόνα και μια ετικέτα.

παράδειγμα κουμπιών

Source Code

File: `buttons.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_BUTTONS_H
    #define GTKMM_EXAMPLE_BUTTONS_H

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

    class Buttons : public Gtk::Window
    {
    public:
      Buttons();
      virtual ~Buttons();

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

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

    #endif //GTKMM_EXAMPLE_BUTTONS_H

File: `buttons.cc` (For use with gtkmm 3, not gtkmm 2)

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

    Buttons::Buttons()
    {
      m_button.add_pixlabel("info.xpm", "cool button");

      set_title("Pixmap'd buttons!");
      set_border_width(10);

      m_button.signal_clicked().connect( sigc::mem_fun(*this,
                  &Buttons::on_button_clicked) );

      add(m_button);

      show_all_children();
    }

    Buttons::~Buttons()
    {
    }

    void Buttons::on_button_clicked()
    {
      std::cout << "The Button was clicked." << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "buttons.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      Buttons buttons;

      //Shows the window and returns when it is closed.
      return app->run(buttons);
    }

#### Σήματα

The Gtk::Button widget has the following signals, but all except the `clicked` signal are deprecated and should not be used in newly-written code:

`pressed`

  Emitted when the button is pressed. Use Gtk::Widget::signal_button_press_event() instead.

`released`

  Emitted when the button is released. Use Gtk::Widget::signal_button_release_event() instead.

`clicked`

  Εκπέμπεται όταν πατιέται το κουμπί και ελευθερώνεται.

`enter`

  Emitted when the mouse pointer enters the button's window. Use Gtk::Widget::signal_enter_notify_event() instead.

`leave`

  Emitted when the mouse pointer leaves the button's window. Use Gtk::Widget::signal_leave_notify_event() instead.

### Κουμπί εναλλαγής

Οι ToggleButton είναι όπως τα κανονικά Button, αλλά όταν πατιούνται παραμένουν ενεργοποιημένα, ή πατημένα, μέχρι να ξαναπατηθούν.

Για ανάκτηση της κατάστασης της ToggleButton, μπορείτε να χρησιμοποιήσετε τη μέθοδο get_active(). Αυτή επιστρέφει `true` (αληθές), αν το κουπί είναι "κάτω". Μπορείτε επίσης να ορίσετε την κατάσταση του κουμπιού εναλλαγής, με set_active(). Σημειώστε ότι, αν το κάνετε αυτό και η κατάσταση στην πραγματικότητα αλλάξει, προκαλεί την εκπομπή του σήματος "πατημένο". Αυτό είναι συνήθως αυτό που θέλετε.

Μπορείτε να χρησιμοποιήσετε τη μέθοδο toggled() για εναλλαγή του κουμπιού, αντί να το εξαναγκάσετε να είναι πάνω ή κάτω: Αυτό εναλλάσσει την κατάσταση του κουμπιού και προκαλεί την εκπομπή του σήματος `toggled`.

Η Gtk::ToggleButton είναι η πιο χρήσιμη ως βασική κλάση για τις κλάσεις Gtk::CheckButton και Gtk::RadioButton.

Reference

### Κουμπί ελέγχου

Η Gtk::CheckButton κληρονομεί από την Gtk::ToggleButton. Η μόνη πραγματική διαφορά μεταξύ των δύο είναι η εμφάνιση της Gtk::CheckButton. Μπορείτε να ελέγξετε, να ορίσετε και να εναλλάξετε ένα πλαίσιο ελέγχου χρησιμοποιώντας τις ίδιες μεθόδους μέλους όπως για την Gtk::ToggleButton.

Reference

#### Παράδειγμα

Κουμπί ελέγχου

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_BUTTONS_H
    #define GTKMM_EXAMPLE_BUTTONS_H

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

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      //Child widgets:
      Gtk::CheckButton m_button;
    };

    #endif //GTKMM_EXAMPLE_BUTTONS_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_button("something")
    {
      set_title("checkbutton example");
      set_border_width(10);

      m_button.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_clicked) );

      add(m_button);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_clicked()
    {
      std::cout << "The Button was clicked: state="
          << (m_button.get_active() ? "true" : "false")
          << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Ραδιοπλήκτρο

Όπως τα πλαίσια ελέγχου, τα ραδιοπλήκτρα κληρονομούν επίσης από την Gtk::ToggleButton, αλλά αυτά δουλεύουν σε ομάδες και μόνο ένα RadioButton σε μια ομάδα μπορεί να επιλεγεί οποτεδήποτε.

#### Ομάδες

Υπάρχουν δύο τρόποι να ρυθμίσετε μια ομάδα ραδιοπλήκτρων. Ο πρώτος τρόπος είναι η δημιουργία κουμπιών και η ρύθμιση των ομάδων τους κατόπιν. Μόνο οι πρώτοι δύο κατασκευαστές χρησιμοποιούνται. Στο παρακάτω παράδειγμα, κάνουμε μια νέα κλάση παραθύρων που λέγεται RadioButtons και έπειτα βάζουμε τρία ραδιοπλήκτρα μέσα της:

    class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();

    protected:
        Gtk::RadioButton m_rb1, m_rb2, m_rb3;
    };

    RadioButtons::RadioButtons()
      : m_rb1("button1"),
        m_rb2("button2"),
        m_rb3("button3")
    {
        Gtk::RadioButton::Group group = m_rb1.get_group();
        m_rb2.set_group(group);
        m_rb3.set_group(group);
    }

Είπαμε στη gtkmm να βάλει και τα τρία RadioButton στην ίδια ομάδα παίρνοντας την ομάδα με get_group() και χρησιμοποιώντας set_group() για να πούμε στις άλλες RadioButton να μοιραστούν αυτήν την ομάδα.

Note that you can't just do

    m_rb2.set_group(m_rb1.get_group()); //doesn't work

because the group is modified by set_group() and therefore non-const.

Ο δεύτερος τρόπος να ρυθμίσετε τα ραδιοπλήκτρα είναι να κάνετε πρώτα μια ομάδα και έπειτα να προσθέσετε ραδιοπλήκτρα σε αυτή. Ιδού ένα παράδειγμα:

    class RadioButtons : public Gtk::Window
    {
    public:
        RadioButtons();
    };

    RadioButtons::RadioButtons()
    {
        Gtk::RadioButton::Group group;
        Gtk::RadioButton *m_rb1 = Gtk::manage(
          new Gtk::RadioButton(group,"button1"));
        Gtk::RadioButton *m_rb2 = manage(
          new Gtk::RadioButton(group,"button2"));
          Gtk::RadioButton *m_rb3 = manage(
            new Gtk::RadioButton(group,"button3"));
    }

Κάναμε μια νέα ομάδα δηλώνοντας απλά μια μεταβλητή, `group`, του τύπου Gtk::RadioButton::Group. Έπειτα κάναμε τρία ραδιοπλήκτρα, χρησιμοποιώντας έναν κατασκευαστή για να κάνουμε καθένα τους μέρος της `group`.

#### Μέθοδοι

Τα RadioButtons είναι "ανενεργά" όταν δημιουργούνται· αυτό σημαίνει ότι όταν κάνετε πρώτα μια ομάδα τους, θα είναι όλα ανενεργά. Μην παραλείψετε να ενεργοποιήσετε ένα τους χρησιμοποιώντας set_active():

Reference

#### Παράδειγμα

Το παρακάτω παράδειγμα δείχνει τη χρήση των RadioButton:

Ραδιοπλήκτρο

Source Code

File: `radiobuttons.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_RADIOBUTTONS_H
    #define GTKMM_EXAMPLE_RADIOBUTTONS_H

    #include <gtkmm/box.h>
    #include <gtkmm/window.h>
    #include <gtkmm/radiobutton.h>
    #include <gtkmm/separator.h>

    class RadioButtons : public Gtk::Window
    {
    public:
      RadioButtons();
      virtual ~RadioButtons();

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

      //Child widgets:
      Gtk::Box m_Box_Top, m_Box1, m_Box2;
      Gtk::RadioButton m_RadioButton1, m_RadioButton2, m_RadioButton3;
      Gtk::Separator m_Separator;
      Gtk::Button m_Button_Close;
    };

    #endif //GTKMM_EXAMPLE_RADIOBUTTONS_H

File: `radiobuttons.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "radiobuttons.h"

    RadioButtons::RadioButtons() :
      m_Box_Top(Gtk::ORIENTATION_VERTICAL),
      m_Box1(Gtk::ORIENTATION_VERTICAL, 10),
      m_Box2(Gtk::ORIENTATION_VERTICAL, 10),
      m_RadioButton1("button1"),
      m_RadioButton2("button2"),
      m_RadioButton3("button3"),
      m_Button_Close("close")
    {
      // Set title and border of the window
      set_title("radio buttons");
      set_border_width(0);

      // Put radio buttons 2 and 3 in the same group as 1:
      Gtk::RadioButton::Group group = m_RadioButton1.get_group();
      m_RadioButton2.set_group(group);
      m_RadioButton3.set_group(group);

      // Add outer box to the window (because the window
      // can only contain a single widget)
      add(m_Box_Top);

      //Put the inner boxes and the separator in the outer box:
      m_Box_Top.pack_start(m_Box1);
      m_Box_Top.pack_start(m_Separator);
      m_Box_Top.pack_start(m_Box2);

      // Set the inner boxes' borders
      m_Box2.set_border_width(10);
      m_Box1.set_border_width(10);

      // Put the radio buttons in Box1:
      m_Box1.pack_start(m_RadioButton1);
      m_Box1.pack_start(m_RadioButton2);
      m_Box1.pack_start(m_RadioButton3);

      // Set the second button active
      m_RadioButton2.set_active();

      // Put Close button in Box2:
      m_Box2.pack_start(m_Button_Close);

      // Make the button the default widget
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      // Connect the clicked signal of the button to
      // RadioButtons::on_button_clicked()
      m_Button_Close.signal_clicked().connect(sigc::mem_fun(*this,
                  &RadioButtons::on_button_clicked) );

      // Show all children of the window
      show_all_children();
    }

    RadioButtons::~RadioButtons()
    {
    }

    void RadioButtons::on_button_clicked()
    {
      hide(); //to close the application.
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "radiobuttons.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      RadioButtons buttons;

      //Shows the window and returns when it is closed.
      return app->run(buttons);
    }

## Γραφικά συστατικά περιοχής

Οι Gtk::Scale και Gtk::Scrollbar κληρονομούν από Gtk::Range και μοιράζονται πολλή λειτουργικότητα. Περιέχουν έναν "περιέκτη" και έναν "ολισθητή" (μερικές φορές λέγεται "ιχνοσφαίρα" σε άλλα περιβάλλοντα γραφικής διεπαφής. Σύροντας τον ολισθητή με τον δείκτη τον μετακινεί μέσα στον περιέκτη, ενώ πατώντας στον περιέκτη προωθεί τον ολισθητή προς τη θέση του πατήματος, είτε πλήρως, ή με υποδεικνυόμενη ποσότητα, ανάλογα με το ποιο πλήκτρο του ποντικιού χρησιμοποιείται. Αυτό πρέπει να εξοικειωθεί με τη συμπεριφορά της γραμμής κύλισης.

Όπως θα εξηγηθεί στην ενότητα ρύθμιση, όλα τα γραφικά συστατικά της περιοχής συσχετίζονται με ένα αντικείμενο Adjustment. Για να αλλάξετε την χαμηλότερη, ανώτερη και τρέχουσα τιμή που χρησιμοποιείται από το γραφικό συστατικό χρειάζεστε να χρησιμοποιήσετε τις μεθόδους της Adjustment, που μπορείτε να πάρετε με τη μέθοδο get_adjustment(). Οι προεπιλεγμένοι κατασκευαστές των γραφικών συστατικών Range δημιουργούν μια Adjustment αυτόματα, ή μπορείτε να ορίσετε μια υπάρχουσα Adjustment, μπορί να την μοιραστεί με ένα άλλο γραφικό συστατικό. Δείτε την ενότητα Ρυθμίσεις για παραπέρα λεπτομέρειες.

Reference

### Γραφικά συστατικά γραμμής κύλισης

Αυτές είναι τυπικές γραμμές κύλισης. Πρέπει να χρησιμοποιηθούν μόνο για κύλιση ενός άλλου γραφικού συστατικού, όπως, Gtk::Entry, ή Gtk::Viewport, αν και είναι συνήθως ευκολότερη η χρήση του γραφικού συστατικού Gtk::ScrolledWindow στις περισσότερες περιπτώσεις.

Ο προσανατολισμός μιας Gtk::Scrollbar μπορεί να είναι ή οριζόντιος ή κάθετος.

Reference

### Κλιμάκωση γραφικών συστατικών

Τα γραφικά συστατικά (ή "ολισθητές") Gtk::Scale επιτρέπουν στον χρήστη την οπτική επιλογή και χειρισμό μιας τιμής μέσα σε μια συγκεκριμένη περιοχή. Μπορεί να χρησιμοποιήσετε, για παράδειγμα, για να προσαρμόσετε το επίπεδο μεγέθυνσης σε μια εστιασμένη προεπισκόπηση μιας εικόνας, ή να ελέγξετε τη φωτεινότητα ενός χρώματος, ή να ορίσετε τον αριθμό των λεπτών αδράνειας πριν μια προφύλαξη οθόνης αναλάβει την οθόνη.

Όσον αφορά Scrollbars, ο προσανατολισμός μπορεί να είναι ή οριζόντιος ή κάθετος. Ο προεπιλεγμένος κατασκευαστής δημιουργεί μια Adjustment με όλες τις τιμές του που ορίστηκαν στο `0.0`. Αυτό δεν είναι χρήσιμο, έτσι θα χρειαστείτε να ορίσετε μερικές λεπτομέρειες της Adjustment για να πάρετε συμπεριφορά με νόημα.

#### Χρήσιμες μέθοδοι

Τα γραφικά συστατικά Scale μπορούν να εμφανίσουν την τρέχουσα τιμή τους ως έναν αριθμό δίπλα στον περιέκτη. Από προεπιλογή, εμφανίζουν την τιμή, αλλά μπορείτε να το αλλάξετε με τη μέθοδο set_draw_value().

Η εμφανιζόμενη τιμή από ένα γραφικό συστατικό κλίμακας στρογγυλοποιείται σε μια δεκαδική θέση από προεπιλογή, όπως είναι το πεδίο `value` στο Gtk::Adjustment. Μπορείτε να το αλλάξετε με τη μέθοδο set_digits().

Επίσης, η τιμή μπορεί να σχεδιαστεί σε διαφορετικές θέσεις σχετικά με τον περιέκτη, που ορίζεται από τη μέθοδο set_value_pos().

Reference

### Παράδειγμα

Αυτό το παράδειγμα εμφανίζει ένα παράθυρο με τρία γραφικά συστατικά περιοχής που όλα είναι συνδεμένα με την ίδια ρύθμιση, μαζί με λίγα στοιχεία ελέγχου για ρύθμιση κάποιων παραμέτρων που αναφέρθηκαν παραπάνω και στην ενότητα των ρυθμίσεων, έτσι μπορείτε να δείτε πώς επηρεάζουν τον τρόπο εργασίας αυτά τα γραφικά συστατικά για τον χρήστη.

Γραφικά συστατικά περιοχής

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_RANGEWIDGETS_H
    #define GTKMM_EXAMPLE_RANGEWIDGETS_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_checkbutton_toggled();
      void on_combo_position();
      void on_adjustment1_value_changed();
      void on_adjustment2_value_changed();
      void on_button_quit();

      //Child widgets:
      Gtk::Box m_VBox_Top, m_VBox2, m_VBox_HScale;
      Gtk::Box m_HBox_Scales, m_HBox_Combo, m_HBox_Digits, m_HBox_PageSize;

      Glib::RefPtr<Gtk::Adjustment> m_adjustment, m_adjustment_digits, m_adjustment_pagesize;

      Gtk::Scale m_VScale;
      Gtk::Scale m_HScale, m_Scale_Digits, m_Scale_PageSize;

      Gtk::Separator m_Separator;

      Gtk::CheckButton m_CheckButton;

      Gtk::Scrollbar m_Scrollbar;

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_position_type); add(m_col_title); }

        Gtk::TreeModelColumn<Gtk::PositionType> m_col_position_type;
        Gtk::TreeModelColumn<Glib::ustring> m_col_title;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::ComboBox m_ComboBox_Position;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;

      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLE_RANGEWIDGETS_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    :
      m_VBox_Top(Gtk::ORIENTATION_VERTICAL, 0),
      m_VBox2(Gtk::ORIENTATION_VERTICAL, 20),
      m_VBox_HScale(Gtk::ORIENTATION_VERTICAL, 10),
      m_HBox_Scales(Gtk::ORIENTATION_HORIZONTAL, 10),
      m_HBox_Combo(Gtk::ORIENTATION_HORIZONTAL, 10),
      m_HBox_Digits(Gtk::ORIENTATION_HORIZONTAL, 10),
      m_HBox_PageSize(Gtk::ORIENTATION_HORIZONTAL, 10),

      // Value, lower, upper, step_increment, page_increment, page_size:
      // Note that the page_size value only makes a difference for
      // scrollbar widgets, and the highest value you'll get is actually
      // (upper - page_size).
      m_adjustment( Gtk::Adjustment::create(0.0, 0.0, 101.0, 0.1, 1.0, 1.0) ),
      m_adjustment_digits( Gtk::Adjustment::create(1.0, 0.0, 5.0, 1.0, 2.0) ),
      m_adjustment_pagesize( Gtk::Adjustment::create(1.0, 1.0, 101.0) ),

      m_VScale(m_adjustment, Gtk::ORIENTATION_VERTICAL),
      m_HScale(m_adjustment, Gtk::ORIENTATION_HORIZONTAL),
      m_Scale_Digits(m_adjustment_digits),
      m_Scale_PageSize(m_adjustment_pagesize),

      // A checkbutton to control whether the value is displayed or not:
      m_CheckButton("Display value on scale widgets", 0),

      // Reuse the same adjustment again.
      // Notice how this causes the scales to always be updated
      // continuously when the scrollbar is moved.
      m_Scrollbar(m_adjustment),

      m_Button_Quit("Quit")
    {
      set_title("range controls");
      set_default_size(300, 350);

      //VScale:
      m_VScale.set_digits(1);
      m_VScale.set_value_pos(Gtk::POS_TOP);
      m_VScale.set_draw_value();
      m_VScale.set_inverted(); // highest value at top

      //HScale:
      m_HScale.set_digits(1);
      m_HScale.set_value_pos(Gtk::POS_TOP);
      m_HScale.set_draw_value();

      add(m_VBox_Top);
      m_VBox_Top.pack_start(m_VBox2);
      m_VBox2.set_border_width(10);
      m_VBox2.pack_start(m_HBox_Scales);

      //Put VScale and HScale (above scrollbar) side-by-side.
      m_HBox_Scales.pack_start(m_VScale);
      m_HBox_Scales.pack_start(m_VBox_HScale);

      m_VBox_HScale.pack_start(m_HScale);

      //Scrollbar:
      m_VBox_HScale.pack_start(m_Scrollbar);

      //CheckButton:
      m_CheckButton.set_active();
      m_CheckButton.signal_toggled().connect( sigc::mem_fun(*this,
        &ExampleWindow::on_checkbutton_toggled) );
      m_VBox2.pack_start(m_CheckButton, Gtk::PACK_SHRINK);

      //Position ComboBox:
      //Create the Tree model:
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_ComboBox_Position.set_model(m_refTreeModel);
      m_ComboBox_Position.pack_start(m_Columns.m_col_title);

      //Fill the ComboBox's Tree Model:
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_position_type] = Gtk::POS_TOP;
      row[m_Columns.m_col_title] = "Top";
      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_position_type] = Gtk::POS_BOTTOM;
      row[m_Columns.m_col_title] = "Bottom";
      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_position_type] = Gtk::POS_LEFT;
      row[m_Columns.m_col_title] = "Left";
      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_position_type] = Gtk::POS_RIGHT;
      row[m_Columns.m_col_title] = "Right";

      m_VBox2.pack_start(m_HBox_Combo, Gtk::PACK_SHRINK);
      m_HBox_Combo.pack_start(
        *Gtk::manage(new Gtk::Label("Scale Value Position:", 0)), Gtk::PACK_SHRINK);
      m_HBox_Combo.pack_start(m_ComboBox_Position);
      m_ComboBox_Position.signal_changed().connect( sigc::mem_fun(*this, &ExampleWindow::on_combo_position) );
      m_ComboBox_Position.set_active(0); // Top

      //Digits:
      m_HBox_Digits.pack_start(
        *Gtk::manage(new Gtk::Label("Scale Digits:", 0)), Gtk::PACK_SHRINK);
      m_Scale_Digits.set_digits(0);
      m_adjustment_digits->signal_value_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_adjustment1_value_changed));
      m_HBox_Digits.pack_start(m_Scale_Digits);

      //Page Size:
      m_HBox_PageSize.pack_start(
        *Gtk::manage(new Gtk::Label("Scrollbar Page Size:", 0)),
        Gtk::PACK_SHRINK);
      m_Scale_PageSize.set_digits(0);
      m_adjustment_pagesize->signal_value_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_adjustment2_value_changed));
      m_HBox_PageSize.pack_start(m_Scale_PageSize);

      m_VBox2.pack_start(m_HBox_Digits, Gtk::PACK_SHRINK);
      m_VBox2.pack_start(m_HBox_PageSize, Gtk::PACK_SHRINK);
      m_VBox_Top.pack_start(m_Separator, Gtk::PACK_SHRINK);
      m_VBox_Top.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);

      m_Button_Quit.set_can_default();
      m_Button_Quit.grab_default();
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_quit));
      m_Button_Quit.set_border_width(10);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_checkbutton_toggled()
    {
      m_VScale.set_draw_value(m_CheckButton.get_active());
      m_HScale.set_draw_value(m_CheckButton.get_active());
    }

    void ExampleWindow::on_combo_position()
    {
      Gtk::TreeModel::iterator iter = m_ComboBox_Position.get_active();
      if(!iter)
        return;

      Gtk::TreeModel::Row row = *iter;
      if(!row)
        return;

      const Gtk::PositionType postype = row[m_Columns.m_col_position_type];

      m_VScale.set_value_pos(postype);
      m_HScale.set_value_pos(postype);
    }

    void ExampleWindow::on_adjustment1_value_changed()
    {
      const double val = m_adjustment_digits->get_value();
      m_VScale.set_digits((int)val);
      m_HScale.set_digits((int)val);
    }

    void ExampleWindow::on_adjustment2_value_changed()
    {
      const double val = m_adjustment_pagesize->get_value();
      m_adjustment->set_page_size(val);
      m_adjustment->set_page_increment(val);

      // Note that we don't have to emit the "changed" signal
      // because gtkmm does this for us.
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## Ποικίλα γραφικά συστατικά

### Ετικέτα

Οι ετικέτες είναι η κύρια μέθοδος τοποθέτησης μη επεξεργάσιμου κειμένου στα παράθυρα, για παράδειγμα η τοποθέτηση ενός τίτλου δίπλα σε ένα γραφικό συστατικό Entry. Μπορείτε να ορίσετε το κείμενο στον κατασκευαστή, ή αργότερα με τις μεθόδους set_text() ή set_markup().

Το πλάτος της ετικέτας θα προσαρμοστεί αυτόματα. Μπορείτε να παράξετε ετικέτες πολλαπλών γραμμών βάζοντας αλλαγές γραμμών ("\n") στη συμβολοσειρά της ετικέτας.

Το κείμενο της ετικέτας μπορεί να στοιχιστεί χρησιμοποιώντας τη μέθοδο set_justify(). Το γραφικό συστατικό μπορεί επίσης να αναδιπλώσει λέξεις, που μπορεί να ενεργοποιηθεί με τη set_line_wrap().

Το Gtk::Label υποστηρίζει κάποια απλή μορφοποίηση, για παράδειγμα επιτρέπει τη δημιουργία κάποιου έντονου, χρωματιστού ή μεγαλύτερου κειμένου. Μπορείτε να το κάνετε δίνοντας μια συμβολοσειρά στο set_markup(), χρησιμοποιώντας τη σύνταξη σήμανσης Pango. Για παράδειγμα, `<b>bold text</b> και <s>strikethrough text</s>` .

Reference

#### Παράδειγμα

Παρακάτω είναι ένα σύντομο παράδειγμα που επεξηγεί αυτές τις λειτουργίες. Αυτό το παράδειγμα χρησιμοποιεί το γραφικό συστατικό πλαίσιο για καλύτερη εμφάνιση των τεχνοτροπιών ετικέτας. (Το γραφικό συστατικό πλαισίου εξηγείται στην ενότητα Πλαίσιο.) Είναι δυνατό ότι ο πρώτος χαρακτήρας στο `m_Label_Normal` εμφανίζεται υπογραμμισμένος μόνο όταν πατάτε το πλήκτρο Alt.

Ετικέτα

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Child widgets:
      Gtk::Box m_HBox;
      Gtk::Box m_VBox, m_VBox2;
      Gtk::Frame m_Frame_Normal, m_Frame_Multi, m_Frame_Left, m_Frame_Right,
        m_Frame_LineWrapped, m_Frame_FilledWrapped, m_Frame_Underlined;
      Gtk::Label m_Label_Normal, m_Label_Multi, m_Label_Left, m_Label_Right,
        m_Label_LineWrapped, m_Label_FilledWrapped, m_Label_Underlined;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    :
      m_HBox(Gtk::ORIENTATION_HORIZONTAL, 5),
      m_VBox(Gtk::ORIENTATION_VERTICAL, 5),
      m_VBox2(Gtk::ORIENTATION_VERTICAL, 5),
      m_Frame_Normal("Normal Label"),
      m_Frame_Multi("Multi-line Label"),
      m_Frame_Left("Left Justified Label"),
      m_Frame_Right("Right Justified Label"),
      m_Frame_LineWrapped("Line wrapped label"),
      m_Frame_FilledWrapped("Filled, wrapped label"),
      m_Frame_Underlined("Underlined label"),
      m_Label_Normal("_This is a Normal label", true),
      m_Label_Multi("This is a Multi-line label.\nSecond line\nThird line"),
      m_Label_Left("This is a Left-Justified\nMulti-line label.\nThird line"),
      m_Label_Right("This is a Right-Justified\nMulti-line label.\nThird line"),
      m_Label_Underlined("This label is underlined!\n"
              "This one is underlined in quite a funky fashion")
    {
      set_title("Label");
      set_border_width(5);

      add(m_HBox);

      m_HBox.pack_start(m_VBox, Gtk::PACK_SHRINK);

      m_Frame_Normal.add(m_Label_Normal);
      m_VBox.pack_start(m_Frame_Normal, Gtk::PACK_SHRINK);

      m_Frame_Multi.add(m_Label_Multi);
      m_VBox.pack_start(m_Frame_Multi, Gtk::PACK_SHRINK);

      m_Label_Left.set_justify(Gtk::JUSTIFY_LEFT);
      m_Frame_Left.add(m_Label_Left);
      m_VBox.pack_start(m_Frame_Left, Gtk::PACK_SHRINK);

      m_Label_Right.set_justify(Gtk::JUSTIFY_RIGHT);
      m_Frame_Right.add(m_Label_Right);
      m_VBox.pack_start(m_Frame_Right, Gtk::PACK_SHRINK);

      m_HBox.pack_start(m_VBox2, Gtk::PACK_SHRINK);

      m_Label_LineWrapped.set_text(
              "This is an example of a line-wrapped label.  It "
              /* add a big space to the next line to test spacing */
              "should not be taking up the entire             "
              "width allocated to it, but automatically "
              "wraps the words to fit.  "
              "The time has come, for all good men, to come to "
              "the aid of their party.  "
              "The sixth sheik's six sheep's sick.\n"
              "     It supports multiple paragraphs correctly, "
              "and  correctly   adds "
              "many          extra  spaces. ");
      m_Label_LineWrapped.set_line_wrap();
      m_Frame_LineWrapped.add(m_Label_LineWrapped);
      m_VBox2.pack_start(m_Frame_LineWrapped, Gtk::PACK_SHRINK);

      m_Label_FilledWrapped.set_text(
              "This is an example of a line-wrapped, filled label.  "
              "It should be taking "
              "up the entire              width allocated to it.  "
              "Here is a sentence to prove "
              "my point.  Here is another sentence. "
              "Here comes the sun, do de do de do.\n"
              "    This is a new paragraph.\n"
              "    This is another newer, longer, better "
              "paragraph.  It is coming to an end, "
              "unfortunately.");
      m_Label_FilledWrapped.set_justify(Gtk::JUSTIFY_FILL);
      m_Label_FilledWrapped.set_line_wrap();
      m_Frame_FilledWrapped.add(m_Label_FilledWrapped);
      m_VBox2.pack_start(m_Frame_FilledWrapped, Gtk::PACK_SHRINK);

      m_Label_Underlined.set_justify(Gtk::JUSTIFY_LEFT);
      m_Label_Underlined.set_pattern (
              "_________________________ _ _________ _ ______"
              "     __ _______ ___");
      m_Frame_Underlined.add(m_Label_Underlined);
      m_VBox2.pack_start(m_Frame_Underlined, Gtk::PACK_SHRINK);

      show_all_children();
    }

    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[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Καταχώριση

#### Απλή χρήση

Τα γραφικά συστατικά καταχώρισης επιτρέπουν στον χρήστη να εισάγει κείμενο. Μπορείτε να αλλάξετε τα περιεχόμενα με τη μέθοδο set_text() και να διαβάσετε τα τρέχοντα περιεχόμενα με τη μέθοδο get_text().

Ενίοτε μπορεί να θέλετε να κάνετε ένα γραφικό συστατικό Entry μόνο για ανάγνωση. Αυτό μπορεί να γίνει περνώντας το `false` στη μέθοδο set_editable().

Για την είσοδο των κωδικών πρόσβασης, συνθηματικών και άλλων πληροφοριών που δεν θέλετε να εμφανίζονται στην οθόνη, η κλήση της set_visibility() με `false` θα προκαλέσει την απόκρυψη του κειμένου.

Μπορεί να θέλετε να ειδοποιηθεί όποτε ο χρήστης πληκτρολογεί σε ένα γραφικό συστατικό καταχώρισης κειμένου. Η Gtk::Entry παρέχει δύο σήματα, `activate` και `changed`, για αυτόν τον σκοπό. Το `activate` εκπέμπεται όταν ο χρήστης πατά το πλήκτρο εισαγωγής στο γραφικό συστατικό καταχώρισης κειμένου· το `changed` εκπέμπεται, όταν το κείμενο στο γραφικό συστατικό αλλάζει. Μπορείτε να χρησιμοποιήσετε αυτά, για παράδειγμα, για να επικυρώσετε ή να φιλτράρετε το κείμενο που πληκτρολογεί ο χρήστης. Η μετακίνηση της εστίασης του πληκτρολογίου σε ένα άλλο γραφικό συστατικό μπορεί επίσης να δώσει σήμα ότι ο χρήστης έχει τελειώσει την εισαγωγή κειμένου. Το σήμα `focus_out_event` που η Gtk::Entry κληρονομεί από την Gtk::Widget μπορεί να σας ειδοποιήσει όταν αυτό συμβαίνει. Η ενότητα Σύνθετο πλαίσιο με μια καταχώριση περιέχει παράδειγμα προγραμμάτων που χρησιμοποιούν αυτά τα σήματα.

Αν περάσετε `true` στη μέθοδο set_activates_default(), πατώντας εισαγωγή στη Gtk::Entry θα ενεργοποιήσει το προεπιλεγμένο γραφικό συστατικό για το παράθυρο που περιέχει την Gtk::Entry. Αυτό είναι ιδιαίτερα χρήσιμο σε πλαίσια διαλόγων. Το προεπιλεγμένο γραφικό συστατικό είναι συνήθως ένα από τα κουμπιά διαλόγου, που π.χ. θα κλείσει το πλαίσιο διαλόγου. Για τον ορισμό ενός γραφικού συστατικού ως το προεπιλεγμένο γραφικό συστατικό, χρησιμοποιήστε τις Gtk::Widget::set_can_default() και Gtk::Widget::grab_default().

Reference

##### Απλό παράδειγμα καταχώρισης

Αυτό το παράδειγμα χρησιμοποιεί την Gtk::Entry. Έχει επίσης δύο CheckButtons, με τα οποία μπορείτε να εναλλάξετε την επεξεργάσιμη και την ορατή σημαία.

Καταχώριση

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_checkbox_editable_toggled();
      void on_checkbox_visibility_toggled();
      void on_button_close();

      //Child widgets:
      Gtk::Box m_HBox;
      Gtk::Box m_VBox;
      Gtk::Entry m_Entry;
      Gtk::Button m_Button_Close;
      Gtk::CheckButton m_CheckButton_Editable, m_CheckButton_Visible;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Close("Close"),
      m_CheckButton_Editable("Editable"),
      m_CheckButton_Visible("Visible")
    {
      set_size_request(200, 100);
      set_title("Gtk::Entry");

      add(m_VBox);

      m_Entry.set_max_length(50);
      m_Entry.set_text("hello");
      m_Entry.set_text(m_Entry.get_text() + " world");
      m_Entry.select_region(0, m_Entry.get_text_length());
      m_VBox.pack_start(m_Entry);

      // Note that add() can also be used instead of pack_xxx()
      m_VBox.add(m_HBox);

      m_HBox.pack_start(m_CheckButton_Editable);
      m_CheckButton_Editable.signal_toggled().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbox_editable_toggled) );
      m_CheckButton_Editable.set_active(true);

      m_HBox.pack_start(m_CheckButton_Visible);
      m_CheckButton_Visible.signal_toggled().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbox_visibility_toggled) );
      m_CheckButton_Visible.set_active(true);

      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox.pack_start(m_Button_Close);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_checkbox_editable_toggled()
    {
      m_Entry.set_editable(m_CheckButton_Editable.get_active());
    }

    void ExampleWindow::on_checkbox_visibility_toggled()
    {
      m_Entry.set_visibility(m_CheckButton_Visible.get_active());
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Συμπλήρωση καταχώρισης

Ένα γραφικό συστατικό Entry μπορεί να προσφέρει μια πτυσσόμενη λίστα προϋπαρχουσών επιλογών με βάση τους πρώτους λίγους χαρακτήρες που πληκτρολογήθηκαν από τον χρήστη. Για παράδειγμα, ένας διάλογος αναζήτησης μπορεί να προτείνει κείμενο από προηγούμενες αναζητήσεις.

Για την ενεργοποίηση αυτής της λειτουργίας, πρέπει να δημιουργήσετε ένα αντικείμενο EntryCompletion και να το δώσετε στο γραφικό συστατικό Entry μέσα από τη μέθοδο set_completion().

Η EntryCompletion μπορεί να χρησιμοποιήσει ένα TreeModel που περιέχει πιθανές καταχωρίσεις, που ορίστηκαν με set_model(). Τότε θα πρέπει να καλέσετε την set_text_column() για να ορίσετε ποιες στήλες του προτύπου σας πρέπει να χρησιμοποιηθούν για να ταιριάζουν με πιθανές καταχωρίσεις κειμένου.

Εναλλακτικά, αν μια πλήρης λίστα των πιθανών καταχωρίσεων μπορεί να είναι υπερβολικά μεγάλη ή υπερβολικά άβολη για να δημιουργηθεί, μια σχισμή επανάκλησης μπορεί να οριστεί με set_match_func(). Αυτό είναι επίσης χρήσιμο, αν θέλετε να ταιριάξετε ένα μέρος της συμβολοσειράς διαφορετικό από την αρχή.

Reference

##### Παράδειγμα συμπλήρωσης καταχώρισης

Αυτό το παράδειγμα δημιουργεί μια Gtk::EntryCompletion και την συσχετίζει με ένα γραφικό συστατικό Gtk::Entry. Η συμπλήρωση χρησιμοποιεί μια Gtk::TreeModel των πιθανών καταχωρίσεων και κάποιες πρόσθετες ενέργειες.

Συμπλήρωση καταχώρισης

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      void on_completion_action_activated(int index);

      //See the comment in the implementation:
      //bool on_completion_match(const Glib::ustring& key, const Gtk::TreeModel::const_iterator& iter);

      //Tree model columns, for the EntryCompletion's filter model:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); }

        Gtk::TreeModelColumn<unsigned int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumns m_Columns;

      typedef std::map<int, Glib::ustring> type_actions_map;
      type_actions_map m_CompletionActions;

      //Child widgets:
      Gtk::Box m_HBox;
      Gtk::Box m_VBox;
      Gtk::Entry m_Entry;
      Gtk::Label m_Label;
      Gtk::Button m_Button_Close;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Label("Press a or b to see a list of possible completions and actions."),
      m_Button_Close("Close")
    {
      //set_size_request(200, 100);
      set_title("Gtk::EntryCompletion");

      add(m_VBox);
      m_VBox.pack_start(m_Entry, Gtk::PACK_SHRINK);

      m_VBox.pack_start(m_Label, Gtk::PACK_EXPAND_WIDGET);

      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox.pack_start(m_Button_Close, Gtk::PACK_SHRINK);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      //Add an EntryCompletion:
      auto completion =
          Gtk::EntryCompletion::create();
      m_Entry.set_completion(completion);

      //Create and fill the completion's filter model
      auto refCompletionModel =
          Gtk::ListStore::create(m_Columns);
      completion->set_model(refCompletionModel);

      // For more complex comparisons, use a filter match callback, like this.
      // See the comment below for more details:
      //completion->set_match_func( sigc::mem_fun(*this,
                  //&ExampleWindow::on_completion_match) );

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(refCompletionModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Alan Zebedee";

      row = *(refCompletionModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Adrian Boo";

      row = *(refCompletionModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Bob McRoberts";

      row = *(refCompletionModel->append());
      row[m_Columns.m_col_id] = 4;
      row[m_Columns.m_col_name] = "Bob McBob";

      //Tell the completion what model column to use to
      //- look for a match (when we use the default matching, instead of
      //  set_match_func().
      //- display text in the entry when a match is found.
      completion->set_text_column(m_Columns.m_col_name);

      //Add actions to the completion:
      //These are just extra items shown at the bottom of the list of possible
      //completions.

      //Remember them for later.
      m_CompletionActions[0] = "Use Wizard";
      m_CompletionActions[1] = "Browse for Filename";

      for(const auto& the_pair : m_CompletionActions)
      {
        auto position = the_pair.first;
        auto title = the_pair.second;
        completion->insert_action_text(title, position);
      }

      completion->signal_action_activated().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_completion_action_activated) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

    /* You can do more complex matching with a handler like this.
     * For instance, you could check for substrings inside the string instead of the start,
     * or you could look for the key in extra model columns as well as the model column that will be displayed.
     * The code here is not actually more complex - it's a reimplementation of the default behaviour.
     *
    bool ExampleWindow::on_completion_match(const Glib::ustring& key, const
            Gtk::TreeModel::const_iterator& iter)
    {
      if(iter)
      {
        Gtk::TreeModel::Row row = *iter;

        Glib::ustring::size_type key_length = key.size();
        Glib::ustring filter_string = row[m_Columns.m_col_name];

        Glib::ustring filter_string_start = filter_string.substr(0, key_length);
        //The key is lower-case, even if the user input is not.
        filter_string_start = filter_string_start.lowercase();

        if(key == filter_string_start)
          return true; //A match was found.
      }

      return false; //No match.
    }
    */

    void ExampleWindow::on_completion_action_activated(int index)
    {
      type_actions_map::iterator iter = m_CompletionActions.find(index);
      if(iter != m_CompletionActions.end()) //If it's in the map
      {
        Glib::ustring title = iter->second;
        std::cout << "Action selected: " << title << std::endl;
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Εικονίδια καταχώρισης

Ένα γραφικό συστατικό Entry μπορεί να εμφανίσει ένα εικονίδιο στην αρχή ή το τέλος της περιοχής κειμένου. Το εικονίδιο μπορεί να οριστεί με μεθόδους όπως set_icon_from_pixbuf() ή set_icon_from_icon_name(). Μια εφαρμογή μπορεί να απαντά στο πάτημα του εικονιδίου από τον χρήστη με επεξεργασία του σήματος signal_icon_press.

##### Παράδειγμα εικονιδίου καταχώρισης

Αυτό το παράδειγμα δείχνει ένα γραφικό συστατικό Gtk::Entry με ένα επώνυμο εικονίδιο αναζήτησης και εκτυπώνει το κείμενο στο τερματικό, όταν το εικονίδιο πατιέται.

Καταχώριση με εικονίδιο

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_icon_pressed(Gtk::EntryIconPosition icon_pos, const GdkEventButton* event);
      void on_button_close();

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Entry m_Entry;
      Gtk::Button m_Button_Close;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Close("Close")
    {
      set_title("Gtk::Entry");

      add(m_VBox);

      m_Entry.set_max_length(50);
      m_Entry.set_text("Hello world");
      m_VBox.pack_start(m_Entry, Gtk::PACK_SHRINK);

      m_Entry.set_icon_from_icon_name("edit-find");
      m_Entry.signal_icon_press().connect( sigc::mem_fun(*this, &ExampleWindow::on_icon_pressed) );

      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox.pack_start(m_Button_Close, Gtk::PACK_SHRINK);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_icon_pressed(Gtk::EntryIconPosition /* icon_pos */, const GdkEventButton* /* event */)
    {
      std::cout << "Icon pressed." << std::endl;
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Πρόοδος καταχώρισης

Ένα γραφικό συστατικό Entry μπορεί να προβάλει μια γραμμή προόδου μέσα στην περιοχή κειμένου, κάτω από το εισαγόμενο κείμενο. Η γραμμή προόδου θα εμφανιστεί αν οι μέθοδοι set_progress_fraction() ή set_progress_pulse_step() κληθούν.

##### Παράδειγμα προόδου καταχώρισης

Αυτό το παράδειγμα δείχνει ένα γραφικό συστατικό Gtk::Entry με μια γραμμή προόδου.

Καταχώριση με γραμμή προόδου

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      bool on_timeout();
      void on_button_close();

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Entry m_Entry;
      Gtk::Button m_Button_Close;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Close("Close")
    {
      set_title("Gtk::Entry");

      add(m_VBox);

      m_Entry.set_max_length(50);
      m_Entry.set_text("Hello world");
      m_VBox.pack_start(m_Entry, Gtk::PACK_SHRINK);

      //Change the progress fraction every 0.1 second:
      Glib::signal_timeout().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_timeout),
        100
      );

      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox.pack_start(m_Button_Close, Gtk::PACK_SHRINK);
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    bool ExampleWindow::on_timeout()
    {
      static double fraction = 0;
      m_Entry.set_progress_fraction(fraction);

      fraction += 0.01;
      if(fraction > 1)
        fraction = 0;

      return true;
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Κουμπί αυξομείωσης

Μια SpinButton επιτρέπει την επιλογή μιας τιμής από μια περιοχή αριθμητικών τιμών. Έχει ένα γραφικό συστατικό Entry με κουμπιά αύξησης και μείωσης στο πλάι. Πατώντας τα κουμπιά προκαλεί στην τιμή να 'αυξομειωθεί' μες την περιοχή των δυνατών τιμών. Το γραφικό συστατικό Entry μπορεί επίσης να χρησιμοποιηθεί για εισαγωγή μιας τιμής άμεσα.

Η τιμή μπορεί να έχει έναν ρυθμίσιμο αριθμό δεκαδικών θέσεων και το βήμα του μεγέθους είναι διαμορφώσιμο. Οι SpinButtons έχουν ένα γνώρισμα 'αυτόματης επανάληψης' επίσης: κρατώντας πατημένο το κουμπί αύξησης ή μείωσης μπορεί προαιρετικά να προκαλέσει μια πιο γρήγορη αλλαγή της τιμής όσο το κουμπί κρατιέται πατημένο.

SpinButtons use an Adjustment object to hold information about the range of values. These Adjustment attributes are used by the Spin Button like so:

- `value`: value for the Spin Button

- `lower`: lower range value

- `upper`: upper range value

- `step_increment`: value to increment/decrement when pressing mouse button 1 on a button

- `page_increment`: value to increment/decrement when pressing mouse button 2 on a button

- `page_size`: unused

Επιπρόσθετα, το πλήκτρο του ποντικιού 3 μπορεί να χρησιμοποιηθεί για άμεση μετάβαση στις τιμές `ανώτερη` ή `κατώτερη`.

Η SpinButton μπορεί να δημιουργήσει μια προεπιλεγμένη Adjustment, που μπορείτε να προσπελάσετε μέσα από τη μέθοδο get_adjustment(), ή μπορείτε να ορίσετε μια υπάρχουσα Adjustment στον κατασκευαστή.

#### Μέθοδοι

Ο αριθμός των δεκαδικών θέσεων μπορεί να αλλαχτεί χρησιμοποιώντας τη μέθοδο set_digits().

Μπορείτε να ορίσετε τιμή κουμπιού αυξομείωσης χρησιμοποιώντας τη μέθοδο set_value() και να την ανακτήσετε με get_value().

Η μέθοδος spin() 'αυξομειώνει' την SpinButton, ως εάν τα κουμπιά της αύξησης ή μείωσης να είχαν πατηθεί. Χρειάζεται να ορίσετε μια Gtk::SpinType για να ορίσετε την κατεύθυνση ή τη νέα θέση.

Για να αποτραπεί η πληκτρολόγηση από τον χρήστη μη αριθμητικών χαρακτήρων στο πλαίσιο καταχώρισης, περάστε `αληθές` στη μέθοδο set_numeric().

Για να κάνετε την SpinButton να 'αναδιπλωθεί' μεταξύ του ανώτερου και κατώτερου ορίου, χρησιμοποιήστε τη μέθοδο set_wrap().

Για να την εξαναγκάσετε να προσκολληθεί στο πλησιέστερο `step_increment`, χρησιμοποιήστε set_snap_to_ticks().

Reference

#### Παράδειγμα

Να ένα παράδειγμα μιας SpinButton σε ενέργεια:

Κουμπί αυξομείωσης

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_checkbutton_snap();
      void on_checkbutton_numeric();
      void on_spinbutton_digits_changed();
      void on_button_close();

      enum enumValueFormats
      {
        VALUE_FORMAT_INT,
        VALUE_FORMAT_FLOAT
      };
      void on_button_getvalue(enumValueFormats display);

      //Child widgets:
      Gtk::Frame m_Frame_NotAccelerated, m_Frame_Accelerated;
      Gtk::Box m_HBox_NotAccelerated, m_HBox_Accelerated,
        m_HBox_Buttons;
      Gtk::Box m_VBox_Main, m_VBox, m_VBox_Day, m_VBox_Month, m_VBox_Year,
        m_VBox_Accelerated, m_VBox_Value, m_VBox_Digits;
      Gtk::Label m_Label_Day, m_Label_Month, m_Label_Year,
        m_Label_Value, m_Label_Digits,
        m_Label_ShowValue;
      Glib::RefPtr<Gtk::Adjustment> m_adjustment_day, m_adjustment_month, m_adjustment_year,
        m_adjustment_value, m_adjustment_digits;
      Gtk::SpinButton m_SpinButton_Day, m_SpinButton_Month, m_SpinButton_Year,
        m_SpinButton_Value, m_SpinButton_Digits;
      Gtk::CheckButton m_CheckButton_Snap, m_CheckButton_Numeric;
      Gtk::Button m_Button_Int, m_Button_Float, m_Button_Close;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <iostream>
    #include <cstdio>

    ExampleWindow::ExampleWindow()
    :
      m_Frame_NotAccelerated("Not accelerated"),
      m_Frame_Accelerated("Accelerated"),
      m_VBox_Main(Gtk::ORIENTATION_VERTICAL, 5),
      m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_VBox_Day(Gtk::ORIENTATION_VERTICAL),
      m_VBox_Month(Gtk::ORIENTATION_VERTICAL),
      m_VBox_Year(Gtk::ORIENTATION_VERTICAL),
      m_VBox_Accelerated(Gtk::ORIENTATION_VERTICAL),
      m_VBox_Value(Gtk::ORIENTATION_VERTICAL),
      m_VBox_Digits(Gtk::ORIENTATION_VERTICAL),
      m_Label_Day("Day: ", Gtk::ALIGN_START),
      m_Label_Month("Month: ", Gtk::ALIGN_START),
      m_Label_Year("Year: ", Gtk::ALIGN_START),
      m_Label_Value("Value: ", Gtk::ALIGN_START),
      m_Label_Digits("Digits: ", Gtk::ALIGN_START),
      m_adjustment_day( Gtk::Adjustment::create(1.0, 1.0, 31.0, 1.0, 5.0, 0.0) ),
      m_adjustment_month( Gtk::Adjustment::create(1.0, 1.0, 12.0, 1.0, 5.0, 0.0) ),
      m_adjustment_year( Gtk::Adjustment::create(2012.0, 1.0, 2200.0, 1.0, 100.0, 0.0) ),
      m_adjustment_value( Gtk::Adjustment::create(0.0, -10000.0, 10000.0, 0.5, 100.0, 0.0) ),
      m_adjustment_digits( Gtk::Adjustment::create(2.0, 1.0, 5.0, 1.0, 1.0, 0.0) ),
      m_SpinButton_Day(m_adjustment_day),
      m_SpinButton_Month(m_adjustment_month),
      m_SpinButton_Year(m_adjustment_year),
      m_SpinButton_Value(m_adjustment_value, 1.0, 2),
      m_SpinButton_Digits(m_adjustment_digits),
      m_CheckButton_Snap("Snap to 0.5-ticks"),
      m_CheckButton_Numeric("Numeric only input mode"),
      m_Button_Int("Value as Int"),
      m_Button_Float("Value as Float"),
      m_Button_Close("Close")
    {
      set_title("SpinButton");

      m_VBox_Main.set_border_width(10);
      add(m_VBox_Main);

      m_VBox_Main.pack_start(m_Frame_NotAccelerated);

      m_VBox.set_border_width(5);
      m_Frame_NotAccelerated.add(m_VBox);

      /* Day, month, year spinners */

      m_VBox.pack_start(m_HBox_NotAccelerated, Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox_Day.pack_start(m_Label_Day);

      m_SpinButton_Day.set_wrap();

      m_VBox_Day.pack_start(m_SpinButton_Day);

      m_HBox_NotAccelerated.pack_start(m_VBox_Day, Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox_Month.pack_start(m_Label_Month);

      m_SpinButton_Month.set_wrap();
      m_VBox_Month.pack_start(m_SpinButton_Month);

      m_HBox_NotAccelerated.pack_start(m_VBox_Month, Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox_Year.pack_start(m_Label_Year);

      m_SpinButton_Year.set_wrap();
      m_SpinButton_Year.set_size_request(55, -1);
      m_VBox_Year.pack_start(m_SpinButton_Year);

      m_HBox_NotAccelerated.pack_start(m_VBox_Year, Gtk::PACK_EXPAND_WIDGET, 5);

      //Accelerated:
      m_VBox_Main.pack_start(m_Frame_Accelerated);

      m_VBox_Accelerated.set_border_width(5);
      m_Frame_Accelerated.add(m_VBox_Accelerated);

      m_VBox_Accelerated.pack_start(m_HBox_Accelerated, Gtk::PACK_EXPAND_WIDGET, 5);

      m_HBox_Accelerated.pack_start(m_VBox_Value, Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox_Value.pack_start(m_Label_Value);

      m_SpinButton_Value.set_wrap();
      m_SpinButton_Value.set_size_request(100, -1);
      m_VBox_Value.pack_start(m_SpinButton_Value);

      m_HBox_Accelerated.pack_start(m_VBox_Digits, Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox_Digits.pack_start(m_Label_Digits);

      m_SpinButton_Digits.set_wrap();
      m_adjustment_digits->signal_value_changed().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_spinbutton_digits_changed) );

      m_VBox_Digits.pack_start(m_SpinButton_Digits);

      //CheckButtons:
      m_VBox_Accelerated.pack_start(m_CheckButton_Snap);
      m_CheckButton_Snap.set_active();
      m_CheckButton_Snap.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_snap) );

      m_VBox_Accelerated.pack_start(m_CheckButton_Numeric);
      m_CheckButton_Numeric.set_active();
      m_CheckButton_Numeric.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_numeric) );

      //Buttons:
      m_VBox_Accelerated.pack_start (m_HBox_Buttons, Gtk::PACK_SHRINK, 5);

      m_Button_Int.signal_clicked().connect( sigc::bind( sigc::mem_fun(*this,
                      &ExampleWindow::on_button_getvalue), VALUE_FORMAT_INT) );
      m_HBox_Buttons.pack_start(m_Button_Int, Gtk::PACK_EXPAND_WIDGET, 5);

      m_Button_Float.signal_clicked().connect( sigc::bind( sigc::mem_fun(*this,
                      &ExampleWindow::on_button_getvalue), VALUE_FORMAT_FLOAT) );
      m_HBox_Buttons.pack_start(m_Button_Float, Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox_Accelerated.pack_start(m_Label_ShowValue);
      m_Label_ShowValue.set_text("0");

      //Close button:
      m_Button_Close.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_VBox_Main.pack_start(m_Button_Close, Gtk::PACK_SHRINK);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

    void ExampleWindow::on_checkbutton_snap()
    {
      m_SpinButton_Value.set_snap_to_ticks( m_CheckButton_Snap.get_active() );
    }

    void ExampleWindow::on_checkbutton_numeric()
    {
      m_SpinButton_Value.set_numeric( m_CheckButton_Numeric.get_active() );
    }

    void ExampleWindow::on_spinbutton_digits_changed()
    {
      m_SpinButton_Value.set_digits( m_SpinButton_Digits.get_value_as_int() );
    }

    void ExampleWindow::on_button_getvalue(enumValueFormats display)
    {
      gchar buf[32];

      if (display == VALUE_FORMAT_INT)
        sprintf (buf, "%d", m_SpinButton_Value.get_value_as_int());
      else
        sprintf (buf, "%0.*f", m_SpinButton_Value.get_digits(),
                m_SpinButton_Value.get_value());

      m_Label_ShowValue.set_text(buf);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Γραμμή προόδου

Οι γραμμές προόδου χρησιμοποιούνται για την εμφάνιση της κατάστασης της συνεχιζόμενης λειτουργίας. Για παράδειγμα, μια ProgressBar μπορεί να εμφανίσει πόση εργασία έχει ολοκληρωθεί.

Για την αλλαγή της εμφανιζόμενης τιμής, χρησιμοποιήστε τη μέθοδο set_fraction(), περνώντας έναν αριθμό διπλής ακρίβειας μεταξύ 0.0 και 1.0 για να δώσετε το νέο ποσοστό.

Μια ProgressBar είναι οριζόντια και από αριστερά προς τα δεξιά από προεπιλογή, αλλά μπορείτε να την αλλάξετε σε μια κάθετη γραμμή προόδου χρησιμοποιώντας τη μέθοδο set_orientation() method.

Reference

#### Κατάσταση δραστηριότητας

Εκτός από την υπόδειξη του ποσού της προόδου που έχει συμβεί, η γραμμή προόδου μπορεί επίσης να χρησιμοποιηθεί για να δείξει ότι υπάρχει κάποια δραστηριότητα· αυτό γίνεται τοποθετώντας τη γραμμή προόδου στην κατάσταση δραστηριότητας. Σε αυτήν την κατάσταση, η γραμμή προόδου εμφανίζει ένα μικρό ορθογώνιο που μετακινείται πίσω και μπρος. Η κατάσταση δραστηριότητας είναι χρήσιμη σε περιπτώσεις, όπου η πρόοδος μιας λειτουργίας δεν μπορεί να υπολογιστεί ως μια περιοχή τιμών (π.χ., λήψη αρχείου άγνωστου μήκους).

Για να το κάνετε αυτό, χρειάζεται να καλέσετε τη μέθοδο pulse() σε κανονικά διαστήματα. Μπορείτε επίσης να επιλέξετε το μέγεθος βήματος, με τη μέθοδο set_pulse_step().

Η γραμμή προόδου μπορεί επίσης να εμφανίσει μια ρυθμίσιμη συμβολοσειρά κειμένου μέσα στην υποδοχή, χρησιμοποιώντας τη μέθοδο set_text().

#### Παράδειγμα

Γραμμή προόδου

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_checkbutton_text();
      void on_checkbutton_activity();
      void on_checkbutton_inverted();

      bool on_timeout();
      void on_button_close();

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Grid m_Grid;
      Gtk::ProgressBar m_ProgressBar;
      Gtk::Separator m_Separator;
      Gtk::CheckButton m_CheckButton_Text, m_CheckButton_Activity, m_CheckButton_Inverted;
      Gtk::Button m_Button_Close;

      sigc::connection m_connection_timeout;
      bool m_bActivityMode;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL, 5),
      m_CheckButton_Text("Show text"),
      m_CheckButton_Activity("Activity mode"),
      m_CheckButton_Inverted("Right to Left"),
      m_Button_Close("Close"),
      m_bActivityMode(false)
    {
      set_resizable();
      set_title("Gtk::ProgressBar");

      m_VBox.set_border_width(10);
      add(m_VBox);

      m_VBox.pack_start(m_ProgressBar, Gtk::PACK_SHRINK, 5);
      m_ProgressBar.set_halign(Gtk::ALIGN_CENTER);
      m_ProgressBar.set_valign(Gtk::ALIGN_CENTER);
      m_ProgressBar.set_text("some text");
      m_ProgressBar.set_show_text(false);

      //Add a timer callback to update the value of the progress bar:
      m_connection_timeout = Glib::signal_timeout().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_timeout), 50 );

      m_VBox.pack_start(m_Separator, Gtk::PACK_SHRINK);
      m_VBox.pack_start(m_Grid);
      m_Grid.set_row_homogeneous(true);

      //Add a check button to select displaying of the trough text:
      m_Grid.attach(m_CheckButton_Text, 0, 0, 1, 1);
      m_CheckButton_Text.property_margin() = 5;
      m_CheckButton_Text.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_text) );

      //Add a check button to toggle activity mode:
      m_Grid.attach(m_CheckButton_Activity, 0, 1, 1, 1);
      m_CheckButton_Activity.property_margin() = 5;
      m_CheckButton_Activity.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_activity) );

      //Add a check button to select growth from left to right or from right to left:
      m_Grid.attach(m_CheckButton_Inverted, 0, 2, 1, 1);
      m_CheckButton_Inverted.property_margin() = 5;
      m_CheckButton_Inverted.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_checkbutton_inverted) );

      //Add a button to exit the program.
      m_VBox.pack_start(m_Button_Close, Gtk::PACK_SHRINK);
      m_Button_Close.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_close) );
      m_Button_Close.set_can_default();
      m_Button_Close.grab_default();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_checkbutton_text()
    {
      const bool show_text = m_CheckButton_Text.get_active();
      m_ProgressBar.set_show_text(show_text);
    }

    void ExampleWindow::on_checkbutton_activity()
    {
      m_bActivityMode = m_CheckButton_Activity.get_active();

      if(m_bActivityMode)
        m_ProgressBar.pulse();
      else
        m_ProgressBar.set_fraction(0.0);
    }

    void ExampleWindow::on_checkbutton_inverted()
    {
      const bool inverted = m_CheckButton_Inverted.get_active();
      m_ProgressBar.set_inverted(inverted);
    }

    void ExampleWindow::on_button_close()
    {
      hide();
    }

    /* Update the value of the progress bar so that we get
     * some movement */
    bool ExampleWindow::on_timeout()
    {
      if(m_bActivityMode)
        m_ProgressBar.pulse();
      else
      {
        double new_val = m_ProgressBar.get_fraction() + 0.01;

        if(new_val > 1.0)
          new_val = 0.0;

        //Set the new value:
        m_ProgressBar.set_fraction(new_val);
      }

      //As this is a timeout function, return true so that it
      //continues to get called
      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Γραμμή πληροφοριών (InfoBar)

Μια InfoBar μπορεί να εμφανίσει μικρά στοιχεία πληροφοριών ή να ζητήσει σύντομες ερωτήσεις. Αντίθετα με έναν Dialog, εμφανίζεται στην κορυφή του τρέχοντος παραθύρου αντί για άνοιγμα ενός νέου παραθύρου. Η API της είναι πολύ παρόμοια με την API Gtk::Dialog.

Reference

#### Παράδειγμα

Γραμμή πληροφοριών (InfoBar)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_infobar_response(int response);
      void on_button_quit();
      void on_button_clear();
      void on_textbuffer_changed();

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TextView m_TextView;

      Glib::RefPtr<Gtk::TextBuffer> m_refTextBuffer;

      Gtk::InfoBar m_InfoBar;
      Gtk::Label m_Message_Label;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit, m_Button_Clear;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL, 6),
      m_Button_Quit("_Quit", true),
      m_Button_Clear("_Clear", true)
    {
      set_title("Gtk::InfoBar example");
      set_border_width(6);
      set_default_size(400, 200);

      add(m_VBox);

      // Add the message label to the InfoBar:
      auto infoBarContainer =
        dynamic_cast<Gtk::Container*>(m_InfoBar.get_content_area());
      if (infoBarContainer)
        infoBarContainer->add(m_Message_Label);

      // Add an ok button to the InfoBar:
      m_InfoBar.add_button("_OK", 0);

      // Add the InfoBar to the vbox:
      m_VBox.pack_start(m_InfoBar, Gtk::PACK_SHRINK);

      // Create the buffer and set it for the TextView:
      m_refTextBuffer = Gtk::TextBuffer::create();
      m_TextView.set_buffer(m_refTextBuffer);

      // Add the TreeView, inside a ScrolledWindow:
      m_ScrolledWindow.add(m_TextView);

      // Show the scrollbars only when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);

      // Add button box:
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Clear, Gtk::PACK_SHRINK);
      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_spacing(6);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);

      // Connect signals:
      m_InfoBar.signal_response().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_infobar_response) );
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );
      m_Button_Clear.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_clear) );
      m_refTextBuffer->signal_changed().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_textbuffer_changed) );

      show_all();

      // Keep the InfoBar hidden until a message needs to be shown:
      m_InfoBar.hide();

      // Make the clear button insensitive until text is typed in the buffer.  When
      // the button is sensitive and it is pressed, the InfoBar is displayed with a
      // message.
      m_Button_Clear.set_sensitive(false);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_infobar_response(int)
    {
      // Clear the message and hide the info bar:
      m_Message_Label.set_text("");
      m_InfoBar.hide();
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::on_button_clear()
    {
      m_refTextBuffer->set_text("");
      m_Message_Label.set_text("Cleared the text.");
      m_InfoBar.set_message_type(Gtk::MESSAGE_INFO);
      m_InfoBar.show();
    }

    void ExampleWindow::on_textbuffer_changed()
    {
      m_Button_Clear.set_sensitive(m_refTextBuffer->size() > 0);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;
      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Συμβουλές οθόνης

Οι συμβουλές οθόνης είναι τα μικρά παράθυρα πληροφοριών που αναδύονται όταν αφήνετε τον δείκτη σας πάνω από ένα γραφικό συστατικό για λίγα δευτερόλεπτα. Χρησιμοποιήστε την set_tooltip_text() για να ορίσετε μια συμβολοσειρά κειμένου ως συμβουλή οθόνης σε οποιοδήποτε Widget. Οι Gtk::ToolItems δεν είναι Widgets, αλλά έχουν την ίδια μέθοδο για διευκόλυνση. Η Gtk::Tooltip χρησιμοποιείται για πιο προχωρημένη χρήση συμβουλών οθόνης, όπως εμφάνιση μιας εικόνας καθώς και κειμένου.

Widget Reference

Tooltip Reference

#### Παράδειγμα

Συμβουλή οθόνης

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:

      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Methods:
      void prepare_textview();
      void connect_signals();

      //Signal handlers:
      void on_markup_checkbutton_click();
      bool on_textview_query_tooltip(int x, int y, bool keyboard_tooltip, const Glib::RefPtr<Gtk::Tooltip>& tooltip);
      bool on_button_query_tooltip(int x, int y, bool keyboard_tooltip, const Glib::RefPtr<Gtk::Tooltip>& tooltip);

      //Child widgets:
      Gtk::Box m_vbox;

      Gtk::CheckButton m_checkbutton;
      Gtk::Label m_label;

      Gtk::ScrolledWindow m_scrolled_window;
      Gtk::TextView m_text_view;
      Glib::RefPtr<Gtk::TextBuffer> m_ref_text_buffer;
      Glib::RefPtr<Gtk::TextTag> m_ref_bold_tag;

      Gtk::Button m_button;
      Gtk::Window m_button_tooltip_window;

    };

    #endif // GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    #include <vector>

    const Glib::ustring app_title = "gtkmm tooltips example";
    const Glib::ustring non_markedup_tip = "A tooltip without markup.";
    const Glib::ustring markedup_tip = "<i>Markup</i> in a tooltip.";

    ExampleWindow::ExampleWindow()
      :
      m_vbox(Gtk::ORIENTATION_VERTICAL, 3),
      m_checkbutton("Click to alternate markup in tooltip"),
      m_label("A label"),
      m_button("Custom widget in tooltip window"),
      m_button_tooltip_window(Gtk::WINDOW_POPUP)
    {
      //Set up window and the top-level container:
      set_title(app_title);
      set_border_width(10);

      add(m_vbox);

      //Check button with markup in tooltip:
      m_checkbutton.set_tooltip_text(non_markedup_tip);
      m_vbox.pack_start(m_checkbutton, Gtk::PACK_SHRINK);

      //Label:
      m_label.set_tooltip_text("Another tooltip");
      m_vbox.pack_start(m_label, Gtk::PACK_SHRINK);

      //Textview:
      prepare_textview();

      //Button:
      // set_tooltip_window(), like set_tooltip_text(),
      // will call set_has_tooltip() for us.
      m_button.set_tooltip_window(m_button_tooltip_window);
      m_vbox.pack_start(m_button, Gtk::PACK_SHRINK);

      //Button's custom tooltip window:
      m_button_tooltip_window.set_default_size(250, 30);
      Gtk::Label* label =
        Gtk::manage(new Gtk::Label("A label in a custom tooltip window"));
      label->show();
      m_button_tooltip_window.add(*label);

      connect_signals();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::prepare_textview()
    {
      Gtk::TextIter iter;
      std::vector< Glib::RefPtr<Gtk::TextTag> > tags;

      //Set up a scrolled window:
      m_scrolled_window.add(m_text_view);
      m_scrolled_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
      m_vbox.pack_start(m_scrolled_window);

      //Create a text buffer with some text:
      m_ref_text_buffer = Gtk::TextBuffer::create();

      iter = m_ref_text_buffer->end();
      m_ref_text_buffer->insert(iter, "Hover over the text ");

      //Insert some text with a tag.
      //In the tooltip signal handler below, we will show a tooltip
      //when mouse pointer is above this tagged text.
      m_ref_bold_tag = m_ref_text_buffer->create_tag("bold");
      m_ref_bold_tag->set_property("weight", Pango::WEIGHT_BOLD);

      tags.push_back(m_ref_bold_tag);

      iter = m_ref_text_buffer->end();
      m_ref_text_buffer->insert_with_tags(iter, "in bold", tags);

      iter = m_ref_text_buffer->end();
      m_ref_text_buffer->insert(iter, " to see its tooltip");

      m_text_view.set_buffer(m_ref_text_buffer);

      m_text_view.set_size_request(320, 50);

      //When only connecting to the query-tooltip signal, and not using any
      //of set_tooltip_text(), set_tooltip_markup() or set_tooltip_window(),
      //we need to explicitly tell GTK+ that the widget has a tooltip which
      //we'll show.
      m_text_view.set_has_tooltip();
    }

    void ExampleWindow::connect_signals()
    {
      m_checkbutton.signal_clicked().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_markup_checkbutton_click));

      m_text_view.signal_query_tooltip().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_textview_query_tooltip));

      m_button.signal_query_tooltip().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_button_query_tooltip));
    }

    void ExampleWindow::on_markup_checkbutton_click()
    {
      if (m_checkbutton.get_active() == true)
      {
        m_checkbutton.set_tooltip_markup(markedup_tip);
      }
      else
      {
        m_checkbutton.set_tooltip_markup(non_markedup_tip);
      }
    }

    bool ExampleWindow::on_textview_query_tooltip(int x, int y, bool keyboard_tooltip, const Glib::RefPtr<Gtk::Tooltip>& tooltip)
    {
      Gtk::TextIter iter;

      if (keyboard_tooltip)
      {
        int offset = m_ref_text_buffer->property_cursor_position().get_value();
        iter = m_ref_text_buffer->get_iter_at_offset(offset);
      }
      else
      {
        int mouse_x, mouse_y, trailing;
        m_text_view.window_to_buffer_coords(Gtk::TEXT_WINDOW_TEXT,
                                            x, y, mouse_x, mouse_y);
        m_text_view.get_iter_at_position(iter, trailing, mouse_x, mouse_y);
      }

      //Show a tooltip if the cursor or mouse pointer is over the text
      //with the specific tag:
      if (iter.has_tag(m_ref_bold_tag))
      {
        tooltip->set_markup("<b>Information</b> attached to a text tag");
        tooltip->set_icon_from_icon_name("dialog-information", Gtk::ICON_SIZE_MENU);
      }
      else
      {
        return false;
      }

      return true;
    }

    bool ExampleWindow::on_button_query_tooltip(int, int, bool, const Glib::RefPtr<Gtk::Tooltip>&)
    {
      //We already have a custom window ready, just return true to show it:
      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## Γραφικά συστατικά περιέκτη

Όλα τα γραφικά συστατικά περιέκτη παράγονται από την Gtk::Container, όχι πάντα άμεσα. Μερικά γραφικά συστατικά περιέκτη, όπως Gtk::Grid μπορούν να κρατήσουν πολλά θυγατρικά γραφικά συστατικά, έτσι αυτά τυπικά έχουν περισσότερο σύνθετες διεπαφές. Άλλα, όπως Gtk::Frame περιέχουν μόνο ένα θυγατρικό γραφικό συστατικό.

### Περιέκτες μοναδικού στοιχείου

Τα γραφικά συστατικά περιέκτη μοναδικού στοιχείου παράγονται από Gtk::Bin, που παρέχει τις μεθόδους add() και remove() για το θυγατρικό γραφικό συστατικό. Σημειώστε ότι, οι Gtk::Button και Gtk::Window είναι τεχνικά περιέκτες μοναδικού στοιχείου, αλλά το έχουμε ήδη συζητήσει αλλού.

Θα συζητήσουμε επίσης το γραφικό συστατικό Gtk::Paned, που επιτρέπει τη διαίρεση ενός παραθύρου σε δύο ξεχωριστά "φατνώματα". Αυτό το γραφικό συστατικό στην πραγματικότητα περιέχει δύο θυγατρικά γραφικά συστατικά, αλλά ο αριθμός ορίστηκε έτσι ώστε να φαίνεται κατάλληλος.

#### Σκελετός (frame)

Οι σκελετοί (Frames) μπορούν να περικλείουν ένα ή μια ομάδα γραφικών συστατικών μέσα σε ένα πλαίσιο, προαιρετικά με τίτλο. Για παράδειγμα, μπορείτε να βάλετε μια ομάδα RadioButtons ή CheckButtons σε μια Frame.

Reference

##### Παράδειγμα

Σκελετός (frame)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Child widgets:
      Gtk::Frame m_Frame;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    {
     /* Set some window properties */
      set_title("Frame Example");
      set_size_request(300, 300);

      /* Sets the border width of the window. */
      set_border_width(10);

      add(m_Frame);

      /* Set the frames label */
      m_Frame.set_label("Gtk::Frame Widget");

      /* Align the label at the right of the frame */
      //m_Frame.set_label_align(Gtk::ALIGN_END, Gtk::ALIGN_START);

      /* Set the style of the frame */
      m_Frame.set_shadow_type(Gtk::SHADOW_ETCHED_OUT);

      show_all_children();
    }

    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[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Με φατνώματα (Paned)

Τα φατνώματα (Panes) διαιρούν ένα γραφικό συστατικό σε δύο μισά, που χωρίζονται από ένα μετακινήσιμο χώρισμα. Τα δύο μισά (φατνώματα) μπορούν να προσανατολιστούν ή οριζόντια (πλάι-πλάι) ή κάθετα (το ένα πάνω από το άλλο).

Αντίθετα με τα άλλα γραφικά συστατικά σε αυτήν την ενότητα, τα γραφικά συστατικά φατνωμάτων (pane) δεν περιέχουν ένα αλλά δύο θυγατρικά γραφικά συστατικά, ένα σε κάθε φάτνωμα. Συνεπώς, θα πρέπει να χρησιμοποιήσετε add1() και add2() αντί για τη μέθοδο add().

Μπορείτε να ρυθμίσετε τη θέση του χωρίσματος χρησιμοποιώντας τη μέθοδο set_position() και θα χρειαστείτε προφανώς να το κάνετε.

Reference

##### Παράδειγμα

Με φατνώματα (Paned)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include "messageslist.h"
    #include "messagetext.h"
    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Child widgets:
      Gtk::Paned m_VPaned;
      MessagesList m_MessagesList;
      MessageText m_MessageText;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `messagetext.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MESSAGETEXT_H
    #define GTKMM_EXAMPLE_MESSAGETEXT_H

    #include <gtkmm.h>

    class MessageText : public Gtk::ScrolledWindow
    {
    public:
      MessageText();
      virtual ~MessageText();

      void insert_text();

    protected:
      Gtk::TextView m_TextView;
    };

    #endif //GTKMM_EXAMPLE_MESSAGETEXT_H

File: `messageslist.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MESSAGESLIST_H
    #define GTKMM_EXAMPLE_MESSAGESLIST_H

    #include <gtkmm.h>

    class MessagesList: public Gtk::ScrolledWindow
    {
    public:
      MessagesList();
      virtual ~MessagesList();

      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_text); }

        Gtk::TreeModelColumn<Glib::ustring> m_col_text;
      };

      ModelColumns m_Columns;

    protected:
      Glib::RefPtr<Gtk::ListStore> m_refListStore; //The Tree Model.
      Gtk::TreeView m_TreeView; //The Tree View.
    };
    #endif //GTKMM_EXAMPLE_MESSAGESLIST_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VPaned(Gtk::ORIENTATION_VERTICAL)
    {
      set_title ("Paned Windows");
      set_border_width(10);
      set_default_size(450, 400);

      /* Add a vpaned widget to our toplevel window */
      add(m_VPaned);

      /* Now add the contents of the two halves of the window */
      m_VPaned.add1(m_MessagesList);
      m_VPaned.add2(m_MessageText);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

File: `messageslist.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "messageslist.h"
    #include <sstream>

    MessagesList::MessagesList()
    {
      /* Create a new scrolled window, with scrollbars only if needed */
      set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      add(m_TreeView);

      /* create list store */
      m_refListStore = Gtk::ListStore::create(m_Columns);

      m_TreeView.set_model(m_refListStore);

      /* Add some messages to the window */
      for(int i = 0; i < 10; ++i)
      {
        std::ostringstream text;
        text << "message #" << i;

        Gtk::TreeModel::Row row = *(m_refListStore->append());
        row[m_Columns.m_col_text] = text.str();
      }

      //Add the Model's column to the View's columns:
      m_TreeView.append_column("Messages", m_Columns.m_col_text);

      show_all_children();
    }

    MessagesList::~MessagesList()
    {
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

File: `messagetext.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "messagetext.h"

    MessageText::MessageText()
    {
      set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      add(m_TextView);
      insert_text();

      show_all_children();
    }

    MessageText::~MessageText()
    {
    }

    void MessageText::insert_text()
    {
      auto refTextBuffer = m_TextView.get_buffer();

      Gtk::TextBuffer::iterator iter = refTextBuffer->get_iter_at_offset(0);
      refTextBuffer->insert(iter,
        "From: pathfinder@nasa.gov\n"
        "To: mom@nasa.gov\n"
        "Subject: Made it!\n"
        "\n"
        "We just got in this morning. The weather has been\n"
        "great - clear but cold, and there are lots of fun sights.\n"
        "Sojourner says hi. See you soon.\n"
        " -Path\n");
    }

#### Κυλιόμενο παράθυρο

Τα γραφικά συστατικά ScrolledWindow δημιουργούν μια κυλιόμενη περιοχή. Μπορείτε να εισάγετε οποιοδήποτε τύπο γραφικού συστατικού στο παράθυρο ScrolledWindow και θα είναι προσβάσιμο ανεξάρτητα από το μέγεθος του χρησιμοποιώντας τις γραμμές κύλισης. Σημειώστε ότι το ScrolledWindow δεν είναι μια Gtk::Window παρά το ελαφρώς παραπλανητικό όνομα.

Τα κυλιόμενα παράθυρα έχουν πολιτικές γραμμής κύλισης που προσδιορίζουν αν οι Scrollbars θα εμφανίζονται. Οι πολιτικές μπορούν να οριστούν με τη μέθοδο set_policy(). Η πολιτική μπορεί να είναι από τις `Gtk::POLICY_AUTOMATIC` ή `Gtk::POLICY_ALWAYS`. Το `Gtk::POLICY_AUTOMATIC` θα προκαλέσει στο κυλιόμενο παράθυρο να εμφανίζει τη γραμμή κύλισης μόνο αν το περιεχόμενο γραφικό συστατικό είναι μεγαλύτερο από την ορατή περιοχή. Το `Gtk::POLICY_ALWAYS` θα προκαλέσει στη γραμμή κύλισης να εμφανίζεται πάντα.

Reference

##### Παράδειγμα

Να ένα απλό παράδειγμα που πακετάρει 100 κουμπιά εναλλαγής σε ένα κυλιόμενο παράθυρο. Δοκιμάστε αυξομείωση του παραθύρου για να δείτε την αντίδραση των γραμμών κύλισης.

Κυλιόμενο παράθυρο

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Dialog
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_dialog_response(int response_id);

      //Child widgets:
      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::Grid m_Grid;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    {
      set_title("Gtk::ScrolledWindow example");
      set_border_width(0);
      set_size_request(300, 300);

      m_ScrolledWindow.set_border_width(10);

      /* the policy is one of Gtk::POLICY AUTOMATIC, or Gtk::POLICY_ALWAYS.
       * Gtk::POLICY_AUTOMATIC will automatically decide whether you need
       * scrollbars, whereas Gtk::POLICY_ALWAYS will always leave the scrollbars
       * there.  The first one is the horizontal scrollbar, the second,
       * the vertical. */
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);

      get_content_area()->pack_start(m_ScrolledWindow);

      /* set the spacing to 10 on x and 10 on y */
      m_Grid.set_row_spacing(10);
      m_Grid.set_column_spacing(10);

      /* pack the grid into the scrolled window */
      m_ScrolledWindow.add(m_Grid);

      /* this simply creates a grid of toggle buttons
       * to demonstrate the scrolled window. */
      for(int i = 0; i < 10; i++)
      {
         for(int j = 0; j < 10; j++)
         {
            char buffer[32];
            sprintf(buffer, "button (%d,%d)\n", i, j);
            auto pButton = Gtk::manage(new Gtk::ToggleButton(buffer));
            m_Grid.attach(*pButton, i, j, 1, 1);
         }
      }

      /* Add a "close" button to the bottom of the dialog */
      add_button("_Close", Gtk::RESPONSE_CLOSE);
      signal_response().connect(sigc::mem_fun(*this, &ExampleWindow::on_dialog_response));

      /* This makes it so the button is the default.
       * Simply hitting the "Enter" key will cause this button to activate. */
      set_default_response(Gtk::RESPONSE_CLOSE);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_dialog_response(int response_id)
    {
      switch (response_id)
      {
      case Gtk::RESPONSE_CLOSE:
      case Gtk::RESPONSE_DELETE_EVENT:
        hide();
        break;
      default:
        std::cout << "Unexpected response_id=" << response_id << std::endl;
        break;
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Σκελετός όψης (AspectFrame)

Το γραφικό συστατικό AspectFrame φαίνεται σαν ένα γραφικό συστατικό Frame, αλλά εξαναγκάζει επίσης την αναλογία διαστάσεων (ο λόγος του πλάτους προς το ύψος) του θυγατρικού γραφικού συστατικού, προσθέτοντας πρόσθετο χώρο, αν είναι απαραίτητο. Για παράδειγμα, αυτό μπορεί να επιτρέψει την εμφάνιση μιας φωτογραφίας χωρίς να επιτρέπει στον χρήστη να την παραμόρφωση οριζόντια ή κάθετα κατά την αυξομείωση.

Reference

##### Παράδειγμα

Το παρακάτω πρόγραμμα χρησιμοποιεί μία Gtk::AspectFrame για να παρουσιάσει μια περιοχή σχεδίασης της οποίας η αναλογία διαστάσεων θα είναι πάντα 2:1, ανεξάρτητα πώς ο χρήστης αυξομειώνει το παράθυρο κορυφαίου επιπέδου.

Σκελετός όψης (AspectFrame)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      //Child widgets:
      Gtk::AspectFrame m_AspectFrame;
      Gtk::DrawingArea m_DrawingArea;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_AspectFrame("2x1", /* label */
        Gtk::ALIGN_CENTER, /* center x */
        Gtk::ALIGN_CENTER, /* center y */
        2.0, /* xsize/ysize = 2 */
        false /* ignore child's aspect */)
    {
      set_title("Aspect Frame");
      set_border_width(10);

      // Add a child widget to the aspect frame */
      // Ask for a 200x200 window, but the AspectFrame will give us a 200x100
      // window since we are forcing a 2x1 aspect ratio */
      m_DrawingArea.set_size_request(200, 200);
      m_AspectFrame.add(m_DrawingArea);

      // Add the aspect frame to our toplevel window:
      add(m_AspectFrame);

      show_all_children();
    }

    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[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Στοίχιση

Το γραφικό συστατικό Alignment επιτρέπει την τοποθέτηση ενός γραφικού συστατικού σε μια θέση και μέγεθος σχετικά με το μέγεθος του ίδιου του γραφικού συστατικού Alignment. Για παράδειγμα, μπορεί να χρησιμοποιηθεί για κεντράρισμα ενός γραφικού συστατικού.

The Alignment widget is deprecated from gtkmm version 3.14 and should not be used in newly-written code. Use Gtk::Widget's alignment and margin methods instead.

##### Παράδειγμα

This example right-aligns a button in a window by using Gtk::Widget::set_halign().

Στοίχιση

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      //Child widgets:
      Gtk::Button m_Button;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_Button("_Close", /* mnemonic= */ true)
    {
      set_title("Alignment");
      set_border_width(10);
      set_default_size(200, 50);

      m_Button.set_halign(Gtk::ALIGN_END);
      m_Button.set_valign(Gtk::ALIGN_CENTER);
      add(m_Button);

      m_Button.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_clicked) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_clicked()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

See the ProgressBar section for another example that uses set_halign().

### Γραφικά συστατικά πολλαπλών στοιχείων

Τα γραφικά συστατικά πολλαπλών στοιχείων κληρονομούν από την Gtk::Container; ακριβώς όπως με την Gtk::Bin, χρησιμοποιείτε τις μεθόδους add() και remove() για την πρόσθεση και αφαίρεση περιεχόμενων γραφικών συστατικών. Αντίθετα με την Gtk::Bin::remove(), όμως, η μέθοδος remove() για την Gtk::Container παίρνει ένα όρισμα, ορίζοντας ποιο γραφικό συστατικό θα αφαιρεθεί.

#### Πακετάρισμα

Έχετε προφανώς σημειώσει ότι τα παράθυρα gtkmm φαίνονται "ελαστικά" - μπορούν συνήθως να τεντωθούν με πολλούς διαφορετικούς τρόπους. Αυτό οφείλεται στο σύστημα συσκευασίας γραφικού συστατικού.

Πολλά πακέτα εργαλείων GUI απαιτούν την ακριβή τοποθέτηση γραφικών συστατικών σε ένα παράθυρο, χρησιμοποιώντας απόλυτη τοποθέτηση, χρησιμοποιώντας συχνά έναν οπτικό επεξεργαστή. Αυτό οδηγεί σε πολλά προβλήματα:

- Τα γραφικά συστατικά δεν αναδιατάσσουν τους εαυτούς τους όταν το παράθυρο αυξομειώνεται. Κάποια γραφικά συστατικά κρύβονται όταν το παράθυρο γίνεται μικρότερο και πολύς άχρηστος χώρος εμφανίζεται όταν το παράθυρο γίνεται μεγαλύτερο.

- Είναι αδύνατο να προβλέψετε τον απαραίτητο χώρο για κείμενο αφού έχει μεταφραστεί σε άλλες γλώσσες ή όταν εμφανίζεται με μια διαφορετική γραμματοσειρά. Στο Unix είναι επίσης αδύνατο να προβλέψτε τις επιδράσεις κάθε θέματος και διαχειριστή παραθύρου.

- Η αλλαγή της διάταξης ενός παραθύρου "άμεσα", για να εμφανιστούν κάποια πρόσθετα γραφικά συστατικά, για παράδειγμα, είναι σύνθετη. Απαιτεί κουραστικούς επανυπολογισμούς κάθε θέσης του γραφικού συστατικού.

Το gtkmm χρησιμοποιεί το σύστημα συσκευασίας για την επίλυση αυτών των προβλημάτων. Αντί να ορίζει τη θέση και το μέγεθος κάθε γραφικού συστατικού στο παράθυρο, μπορείτε να τακτοποιήσετε τα γραφικά συστατικά σας σε γραμμές, στήλες και/ή πλέγματα. Το gtkmm μπορεί να προσαρμόσει το παράθυρό σας αυτόματα, με βάση τα μεγέθη των γραφικών συστατικών που περιέχει. Και τα μεγέθη των γραφικών συστατικών καθορίζονται, με τη σειρά τους, από το πόσο κείμενο περιέχουν, ή το ελάχιστο και μέγιστο μέγεθος που ορίζετε, και/ή πώς έχετε ζητήσει να μοιράζεται ο διαθέσιμος χώρος μεταξύ ομάδων γραφικών συστατικών. Μπορείτε να τελειοποιήσετε τη διάταξή σας ορίζοντας απόσταση συμπλήρωσης και κεντράρισμα τιμών για κάθε γραφικό συστατικό σας. Τότε το gtkmm χρησιμοποιεί όλες αυτές τις πληροφορίες για αυξομείωση και ανατοποθέτηση καθενός λογικά και ομαλά, όταν ο χρήστης χειρίζεται το παράθυρο.

Το gtkmm τακτοποιεί τα γραφικά συστατικά ιεραρχικά, χρησιμοποιώντας περιέκτες. Ένα γραφικό συστατικό περιέκτη περιέχει άλλα γραφικά συστατικά. Τα περισσότερα γραφικά συστατικά του gtkmm είναι περιέκτες. Παράθυρα, καρτέλες σημειωματάριου και κουμπιά είναι όλα γραφικά συστατικά περιεκτών. Υπάρχουν δύο γεύσεις περιεκτών: περιέκτες μοναδικού θυγατρικού, που είναι όλοι απόγονοι της Gtk::Bin, και περιέκτες πολλαπλών θυγατρικών, που είναι απόγονοι της Gtk::Container. Τα περισσότερα γραφικά συστατικά στο gtkmm είναι απόγονοι της Gtk::Bin, συμπεριλαμβανόμενης της Gtk::Window.

Ναι, αυτό είναι σωστό: ένα παράθυρο μπορεί να περιέχει το πολύ ένα γραφικό συστατικό. Πώς, τότε, μπορούμε να χρησιμοποιούμε ένα παράθυρο για ο,τιδήποτε χρήσιμο; Τοποθετώντας έναν περιέκτη πολλαπλού θυγατρικού στο παράθυρο. Τα πιο χρήσιμα γραφικά συστατικά περιεκτών είναι οι Gtk::Grid και Gtk::Box.

- Η Gtk::Grid τακτοποιεί τα θυγατρικά της γραφικά συστατικά σε γραμμές και στήλες. Χρησιμοποιήστε attach(), attach_next_to() και add() για την εισαγωγή θυγατρικών γραφικών συστατικών.

- Η Gtk::Box τακτοποιεί τα θυγατρικά της γραφικά συστατικά κάθετα ή οριζόντια. Χρησιμοποιήστε pack_start() και pack_end() για εισαγωγή θυγατρικών γραφικών συστατικών.

Υπάρχουν αρκετοί άλλοι περιέκτες, που θα συζητήσουμε επίσης.

Αν δεν έχετε χρησιμοποιήσει ποτέ πριν ένα πακέτο εργαλείων συσκευασίας, μπορεί να πάρει κάμποσο για να το χρησιμοποιήσετε. Θα βρείτε προφανώς, όμως, ότι δεν χρειάζεστε να βασίζεστε σε οπτικές μορφές επεξεργαστών τόσο πολύ όσο θα πρέπει με άλλα πακέτα εργαλείων.

#### Ένα βελτιωμένο Hello World

Ας ρίξουμε μια ματιά σε ένα ελαφρά βελτιωμένο `helloworld`, που δείχνει τι έχουμε μάθει.

Hello World 2

Source Code

File: `helloworld.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_HELLOWORLD_H
    #define GTKMM_EXAMPLE_HELLOWORLD_H

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

    class HelloWorld : public Gtk::Window
    {
    public:
      HelloWorld();
      virtual ~HelloWorld();

    protected:

      // Signal handlers:
      // Our new improved on_button_clicked(). (see below)
      void on_button_clicked(Glib::ustring data);

      // Child widgets:
      Gtk::Box m_box1;
      Gtk::Button m_button1, m_button2;
    };

    #endif // GTKMM_EXAMPLE_HELLOWORLD_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

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

    int main (int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      HelloWorld helloworld;

      //Shows the window and returns when it is closed.
      return app->run(helloworld);
    }

File: `helloworld.cc` (For use with gtkmm 3, not gtkmm 2)

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

    HelloWorld::HelloWorld()
    : m_button1("Button 1"),
      m_button2("Button 2")
    {
      // This just sets the title of our new window.
      set_title("Hello Buttons!");

      // sets the border width of the window.
      set_border_width(10);

      // put the box into the main window.
      add(m_box1);

      // Now when the button is clicked, we call the "on_button_clicked" function
      // with a pointer to "button 1" as it's argument
      m_button1.signal_clicked().connect(sigc::bind<Glib::ustring>(
                  sigc::mem_fun(*this, &HelloWorld::on_button_clicked), "button 1"));

      // instead of gtk_container_add, we pack this button into the invisible
      // box, which has been packed into the window.
      // note that the pack_start default arguments are Gtk::EXPAND | Gtk::FILL, 0
      m_box1.pack_start(m_button1);

      // always remember this step, this tells GTK that our preparation
      // for this button is complete, and it can be displayed now.
      m_button1.show();

      // call the same signal handler with a different argument,
      // passing a pointer to "button 2" instead.
      m_button2.signal_clicked().connect(sigc::bind<-1, Glib::ustring>(
                  sigc::mem_fun(*this, &HelloWorld::on_button_clicked), "button 2"));

      m_box1.pack_start(m_button2);

      // Show the widgets.
      // They will not really be shown until this Window is shown.
      m_button2.show();
      m_box1.show();
    }

    HelloWorld::~HelloWorld()
    {
    }

    // Our new improved signal handler.  The data passed to this method is
    // printed to stdout.
    void HelloWorld::on_button_clicked(Glib::ustring data)
    {
      std::cout << "Hello World - " << data << " was pressed" << std::endl;
    }

Μετά τη δόμηση και εκτέλεση αυτού του προγράμματος, προσπαθήστε να αυξομειώσετε το παράθυρο για να δείτε τη συμπεριφορά. Επίσης, δοκιμάστε να παίξετε με τις επιλογές στη pack_start(), ενώ διαβάζετε την ενότητα Πλαίσια (Boxes).

#### Πλαίσια (Boxes)

Οι περισσότερες συσκευασίες χρησιμοποιούν πλαίσια (boxes) όπως στο παραπάνω παράδειγμα. Αυτά είναι αόρατοι περιέκτες στους οποίους μπορούμε να συσκευάσουμε τα γραφικά συστατικά μας. Όταν συσκευάζονται γραφικά συστατικά σε ένα οριζόντιο πλαίσιο, τα αντικείμενα εισάγονται οριζόντια από αριστερά προς τα δεξιά ή δεξιά προς τα αριστερά ανάλογα με το αν χρησιμοποιείται pack_start() ή pack_end(). Σε ένα κάθετο πλαίσιο, τα γραφικά συστατικά συσκευάζονται από πάνω προς τα κάτω ή αντίστροφα. Μπορεί να χρησιμοποιήσετε οποιοδήποτε συνδυασμό πλαισίων μέσα ή δίπλα σε άλλα πλαίσια για τη δημιουργία της επιθυμητής επίδρασης.

##### Προσθήκη γραφικών συστατικών

###### Επιλογές συσκευασίας ανά θυγατρικό

Οι μέθοδοι pack_start() και pack_end() τοποθέτησης γραφικών συστατικών μέσα σε αυτούς τους περιέκτες. Η μέθοδος pack_start() θα ξεκινήσει στην κορυφή και θα δουλέψει τον τρόπο της κάτω σε ένα Box με κάθετο προσανατολισμό, ή θα συσκευάσει από αριστερά προς τα δεξιά σε ένα Box με οριζόντιο προσανατολισμό. Η pack_end() θα κάνει το αντίθετο, συσκευάζοντας από κάτω προς τα πάνω ή από δεξιά προς τα αριστερά. Η χρήση αυτών των μεθόδων επιτρέπει τη δεξιά ή αριστερή στοίχιση των γραφικών συστατικών μας. Θα χρησιμοποιήσουμε τη pack_start() στα περισσότερα παραδείγματά μας.

Υπάρχουν αρκετές επιλογές που διέπουν τον τρόπο συσκευασίας των γραφικών συστατικών και αυτό μπορεί να μπερδεύει στην αρχή. Αν δυσκολεύεστε, τότε είναι μερικές φορές καλή ιδέα να παίξετε με τον σχεδιαστή γραφικής διεπαφής glade για να δείτε τι είναι δυνατό. Μπορείτε ακόμα να αποφασίσετε τη χρήση της API Gtk::Builder για τη φόρτωση της γραφικής διεπαφής κατά τον χρόνο εκτέλεσης.

Υπάρχουν βασικά πέντε διαφορετικές τεχνοτροπίες, όπως φαίνεται σε αυτήν την εικόνα:

Συσκευασία πλαισίου (Box) 1

Κάθε γραμμή περιέχει ένα οριζόντιο Box με αρκετά κουμπιά. Κάθε κουμπί σε μια γραμμή συσκευάζεται σε ένα Box με τα ίδια ορίσματα στη μέθοδο pack_start().

Αυτή είναι η δήλωση της μεθόδου pack_start():

    void pack_start(Gtk::Widget& child,
                    Gtk::PackOptions options = Gtk::PACK_EXPAND_WIDGET,
                    guint padding = 0);

Το πρώτο όρισμα είναι το γραφικό συστατικό που συσκευάζετε. Στο παράδειγμά μας όλα αυτά είναι Buttons.

The options argument can take one of these three options:

- `Gtk::PACK_SHRINK`: Space is contracted to the child widget size. The widget will take up just-enough space and never expand.

- `Gtk::PACK_EXPAND_PADDING`: Extra space is filled with padding. The widgets will be spaced out evenly, but their sizes won't change - there will be empty space between the widgets instead.

- `Gtk::PACK_EXPAND_WIDGET`: Extra space is taken up by increasing the child widget size, without changing the amount of space between widgets.

Το όρισμα padding καθορίζει το πλάτος μιας πρόσθετης περιοχής περιγράμματος για να αφήσει ολόγυρα το συσκευασμένο γραφικό συστατικό.

Reference

###### Επιλογές συσκευασίας ανά περιέκτη

Here's the constructor for the Box widget, and methods that set per-container packing options:

    Gtk::Box(Gtk::Orientation orientation = Gtk::ORIENTATION_HORIZONTAL, int spacing = 0);
    void set_spacing(int spacing);
    void set_homogeneous(bool homogeneous = true);

Passing `true` to set_homogeneous() will cause all of the contained widgets to be the same size. spacing is a (minimum) number of pixels to leave between each widget.

Ποια είναι η διαφορά μεταξύ διακένου (που ορίστηκε όταν δημιουργείται το πλαίσιο (box)) και συμπλήρωσης (που ορίζεται όταν συσκευάζονται στοιχεία); Το διάκενο προστίθεται μεταξύ αντικειμένων και η συμπλήρωση προστίθεται σε όποια πλευρά του γραφικού συστατικού. Η παρακάτω εικόνα πρέπει να το ξεκαθαρίζει:

Συσκευασία πλαισίου (Box) 2

##### Gtk::επιλογές εφαρμογής και γραμμής εντολών

Το παρακάτω παράδειγμα προγράμματος απαιτεί μια επιλογή γραμμής εντολών. Ο πηγαίος κώδικας εμφανίζει δύο τρόπους χειρισμού των επιλογών της γραμμής εντολών σε συνδυασμό με την Gtk::Application.

- Χειριστείτε τις επιλογές στη `main()` και κρύψτε τες από την Gtk::Application ορίζοντας `argc = 1` στην κλήση στην Gtk::Application::create().

- Δώστε όλες τις επιλογές της γραμμής εντολών στη Gtk::Application::create() και προσθέστε τη σημαία `Gio::APPLICATION_HANDLES_COMMAND_LINE`. Συνδέστε έναν χειριστή σήματος στο σήμα `command_line` και χειριστείτε τις επιλογές της γραμμής εντολών στον χειριστή σήματος.

  Πρέπει να ορίσετε μια προαιρετική παράμετρο `after = false` στην κλήση στο `signal_command_line().connect()`, επειδή ο χειριστής σήματός σας πρέπει να κληθεί πριν τον προεπιλεγμένο χειριστή σήματος. Πρέπει επίσης να καλέσετε την Gio::Application::activate() στον χειριστή σήματος, εκτός και θέλετε η εφαρμογή σας να εξέλθει χωρίς την εμφάνιση του κυρίως παραθύρου. (η Gio::Application είναι μια βασική κλάση της Gtk::Application.)

##### Παράδειγμα

Να ο πηγαίος κώδικας για το παράδειγμα που παρήγαγε τα παραπάνω στιγμιότυπα. Όταν εκτελείτε αυτό το παράδειγμα, δώστε έναν αριθμό μεταξύ 1 και 3 ως επιλογή της γραμμής εντολών, για να δείτε σε χρήση τις διαφορετικές επιλογές συσκευασίας.

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow(int which);
      virtual ~ExampleWindow();

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

      //Child widgets:
      Gtk::Button m_button;
      Gtk::Box m_box1;
      Gtk::Box m_boxQuit;
      Gtk::Button m_buttonQuit;

      Gtk::Label m_Label1, m_Label2;

      Gtk::Separator m_separator1, m_separator2;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `packbox.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_PACKBOX_H
    #define GTKMM_EXAMPLE_PACKBOX_H

    #include <gtkmm.h>

    class PackBox : public Gtk::Box
    {
    public:
      PackBox(bool homogeneous, int spacing, Gtk::PackOptions options, int padding = 0);
      virtual ~PackBox();

    protected:
      Gtk::Button m_button1, m_button2, m_button3;
      Gtk::Button* m_pbutton4;
    };

    #endif //GTKMM_EXAMPLE_PACKBOX_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include "examplewindow.h"
    #include "packbox.h"

    ExampleWindow::ExampleWindow(int which)
    : m_box1(Gtk::ORIENTATION_VERTICAL),
      m_buttonQuit("Quit")
    {
      set_title("Gtk::Box example");

      PackBox *pPackBox1, *pPackBox2, *pPackBox3, *pPackBox4, *pPackBox5;

      switch(which)
      {
        case 1:
        {
          m_Label1.set_text("Gtk::Box(Gtk::ORIENTATION_HORIZONTAL); set_homogeneous(false);");

          // Align the label to the left side.
          m_Label1.set_halign(Gtk::ALIGN_START);
          m_Label1.set_valign(Gtk::ALIGN_START);

          // Pack the label into the vertical box (vbox box1).  Remember that
          // widgets added to a vbox will be packed one on top of the other in
          // order.
          m_box1.pack_start(m_Label1, Gtk::PACK_SHRINK);

          // Create a PackBox - homogeneous = false, spacing = 0,
          // options = Gtk::PACK_SHRINK, padding = 0
          pPackBox1 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_SHRINK));
          m_box1.pack_start(*pPackBox1, Gtk::PACK_SHRINK);

          // Create a PackBox - homogeneous = false, spacing = 0,
          // options = Gtk::PACK_EXPAND_PADDING, padding = 0
          pPackBox2 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_EXPAND_PADDING));
          m_box1.pack_start(*pPackBox2, Gtk::PACK_SHRINK);

          // Create a PackBox - homogeneous = false, spacing = 0,
          // options = Gtk::PACK_EXPAND_WIDGET, padding = 0
          pPackBox3 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_EXPAND_WIDGET));
          m_box1.pack_start(*pPackBox3, Gtk::PACK_SHRINK);

          // pack the separator into the vbox.  Remember each of these
          // widgets are being packed into a vbox, so they'll be stacked
          // vertically.
          m_box1.pack_start(m_separator1, Gtk::PACK_SHRINK, 5);

          // create another new label, and show it.
          m_Label2.set_text("Gtk::Box(Gtk::ORIENTATION_HORIZONTAL); set_homogeneous(true);");
          m_Label2.set_halign(Gtk::ALIGN_START);
          m_Label2.set_valign(Gtk::ALIGN_START);
          m_box1.pack_start(m_Label2, Gtk::PACK_SHRINK);

          // Args are: homogeneous, spacing, options, padding
          pPackBox4 = Gtk::manage(new PackBox(true, 0, Gtk::PACK_EXPAND_PADDING));
          m_box1.pack_start(*pPackBox4, Gtk::PACK_SHRINK);

          // Args are: homogeneous, spacing, options, padding
          pPackBox5 = Gtk::manage(new PackBox(true, 0, Gtk::PACK_EXPAND_WIDGET));
          m_box1.pack_start(*pPackBox5, Gtk::PACK_SHRINK);

          m_box1.pack_start(m_separator2, Gtk::PACK_SHRINK, 5);

          break;
        }

        case 2:
        {

          m_Label1.set_text("Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 10); set_homogeneous(false);");
          m_Label1.set_halign(Gtk::ALIGN_START);
          m_Label1.set_valign(Gtk::ALIGN_START);
          m_box1.pack_start(m_Label1, Gtk::PACK_SHRINK);

          pPackBox1 = Gtk::manage(new PackBox(false, 10, Gtk::PACK_EXPAND_PADDING));
          m_box1.pack_start(*pPackBox1, Gtk::PACK_SHRINK);

          pPackBox2 = Gtk::manage(new PackBox(false, 10, Gtk::PACK_EXPAND_WIDGET));
          m_box1.pack_start(*pPackBox2, Gtk::PACK_SHRINK);

          m_box1.pack_start(m_separator1, Gtk::PACK_SHRINK, 5);

          m_Label2.set_text("Gtk::Box(Gtk::ORIENTATION_HORIZONTAL); set_homogeneous(false);");
          m_Label2.set_halign(Gtk::ALIGN_START);
          m_Label2.set_valign(Gtk::ALIGN_START);
          m_box1.pack_start(m_Label2, Gtk::PACK_SHRINK);

          pPackBox3 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_SHRINK, 10));
          m_box1.pack_start(*pPackBox3, Gtk::PACK_SHRINK);

          pPackBox4 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_EXPAND_WIDGET, 10));
          m_box1.pack_start(*pPackBox4, Gtk::PACK_SHRINK);

          m_box1.pack_start(m_separator2, Gtk::PACK_SHRINK, 5);

          break;
        }

        case 3:
        {
          // This demonstrates the ability to use Gtk::Box::pack_end() to
          // right justify widgets.  First, we create a new box as before.
          pPackBox1 = Gtk::manage(new PackBox(false, 0, Gtk::PACK_SHRINK));

          // create the label that will be put at the end.
          m_Label1.set_text("end");

          // pack it using pack_end(), so it is put on the right side
          // of the PackBox.
          pPackBox1->pack_end(m_Label1, Gtk::PACK_SHRINK);

          m_box1.pack_start(*pPackBox1, Gtk::PACK_SHRINK);

          // this explicitly sets the separator to 500 pixels wide by 5 pixels
          // high.  This is so the hbox we created will also be 500 pixels wide,
          // and the "end" label will be separated from the other labels in the
          // hbox.  Otherwise, all the widgets in the hbox would be packed as
          // close together as possible.
          m_separator1.set_size_request(500, 5);

          // pack the separator into the vbox.
          m_box1.pack_start(m_separator1, Gtk::PACK_SHRINK, 5);

          break;
        }

        default:
        {
          std::cerr << "Unexpected command-line option." << std::endl;
          break;
        }
      }

      // Connect the signal to hide the window:
      m_buttonQuit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit_clicked) );

      // pack the button into the quitbox.
      // The last 2 arguments to Box::pack_start are: options, padding.
      m_boxQuit.pack_start(m_buttonQuit, Gtk::PACK_EXPAND_PADDING);
      m_box1.pack_start(m_boxQuit, Gtk::PACK_SHRINK);

      // pack the vbox (box1) which now contains all our widgets, into the
      // main window.
      add(m_box1);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit_clicked()
    {
      hide();
    }

File: `packbox.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "packbox.h"

    PackBox::PackBox(bool homogeneous, int spacing, Gtk::PackOptions options,
            int padding)
    : Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, spacing),
      m_button1("box.pack_start("),
      m_button2("button,"),
      m_button3((options == Gtk::PACK_SHRINK) ? "Gtk::PACK_SHRINK" :
                ((options == Gtk::PACK_EXPAND_PADDING) ?
                 "Gtk::PACK_EXPAND_PADDING" : "Gtk::PACK_EXPAND_WIDGET"))
    {
      set_homogeneous(homogeneous);

      pack_start(m_button1, options, padding);
      pack_start(m_button2, options, padding);
      pack_start(m_button3, options, padding);

      m_pbutton4 = new Gtk::Button(Glib::ustring::format(padding) + ");");
      pack_start(*m_pbutton4, options, padding);
    }

    PackBox::~PackBox()
    {
      delete m_pbutton4;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>
    #include <iostream>
    #include <cstdlib>

    #define GTK_APPLICATION_RECEIVES_COMMAND_LINE_ARGUMENTS 0

    #if GTK_APPLICATION_RECEIVES_COMMAND_LINE_ARGUMENTS
    namespace
    {
    int on_command_line(const Glib::RefPtr<Gio::ApplicationCommandLine>& command_line,
                        Glib::RefPtr<Gtk::Application>& app)
    {
      int argc = 0;
      char** argv = command_line->get_arguments(argc);

      for (int i = 0; i < argc; ++i)
        std::cout << "argv[" << i << "] = " << argv[i] << std::endl;

      app->activate(); // Without activate() the window won't be shown.
      return EXIT_SUCCESS;
    }
    } // anonymous namespace
    #endif

    int main(int argc, char *argv[])
    {
      if (argc != 2)
      {
        std::cerr << "Usage: example <num>, where <num> is 1, 2, or 3." << std::endl;
        return EXIT_FAILURE;
      }

    #if GTK_APPLICATION_RECEIVES_COMMAND_LINE_ARGUMENTS
      // The command line arguments must be checked before Gtk::Application::run()
      // is called. The Gio::APPLICATION_HANDLES_COMMAND_LINE flag and the
      // on_command_line() signal handler are not necessary. This program is simpler
      // without them, and with argc = 1 in the call to Gtk::Application::create().
      // They are included to show a program with Gio::APPLICATION_HANDLES_COMMAND_LINE.
      // Gio::APPLICATION_NON_UNIQUE makes it possible to run several instances of
      // this application simultaneously.
      auto app = Gtk::Application::create(argc, argv,
        "org.gtkmm.example", Gio::APPLICATION_HANDLES_COMMAND_LINE | Gio::APPLICATION_NON_UNIQUE);

      // Note after = false.
      // Only one signal handler is invoked. This signal handler must run before
      // the default signal handler, or else it won't run at all.
      app->signal_command_line().connect(sigc::bind(sigc::ptr_fun(&on_command_line), app), false);
    #else
      // Gio::APPLICATION_NON_UNIQUE makes it possible to run several instances of
      // this application simultaneously.
      int argc1 = 1; // Don't give the command line arguments to Gtk::Application.
      auto app = Gtk::Application::create(argc1, argv,
        "org.gtkmm.example", Gio::APPLICATION_NON_UNIQUE);
    #endif

      ExampleWindow window(std::atoi(argv[1]));
      return app->run(window); //Shows the window and returns when it is closed.
    }

#### Πλαίσια με κουμπιά (ButtonBoxes)

Τα πλαίσια με κουμπιά (Button boxes) είναι ένας βολικός τρόπος γρήγορης τακτοποίησης μιας ομάδας κουμπιών. Ο προσανατολισμός τους μπορεί να είναι ή οριζόντιος ή κάθετος.

ButtonBoxes βοηθούν να κάνουν τις εφαρμογές σας να εμφανίζονται συνεπείς, επειδή χρησιμοποιούν τυπικές ρυθμίσεις, όπως διάκενο και συσκευασία μεταξύ κουμπιών.

Τα κουμπιά προστίθενται σε μία ButtonBox με τη μέθοδο add().

Τα πλαίσια με κουμπιά (Button boxes) υποστηρίζουν πολλές τεχνοτροπίες διάταξης. Η τεχνοτροπία μπορεί να ανακτηθεί και να αλλαχθεί χρησιμοποιώντας get_layout() και set_layout().

Reference

##### Παράδειγμα

Πλαίσιο με κουμπιά (Button Box)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      //Child widgets:
      Gtk::Box m_VBox_Main, m_VBox;
      Gtk::Box m_HBox;
      Gtk::Frame m_Frame_Horizontal, m_Frame_Vertical;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplebuttonbox.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_BUTTONBOX_H
    #define GTKMM_EXAMPLE_BUTTONBOX_H

    #include <gtkmm.h>

    class ExampleButtonBox : public Gtk::Frame
    {
    public:
      ExampleButtonBox(bool horizontal,
           const Glib::ustring& title,
           gint spacing,
           Gtk::ButtonBoxStyle layout);

    protected:
      Gtk::Button m_Button_OK, m_Button_Cancel, m_Button_Help;
    };

    #endif //GTKMM_EXAMPLE_BUTTONBOX_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include "examplebuttonbox.h"

    ExampleWindow::ExampleWindow()
    : m_VBox_Main(Gtk::ORIENTATION_VERTICAL),
      m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Frame_Horizontal("Horizontal Button Boxes"),
      m_Frame_Vertical("Vertical Button Boxes")
    {
      set_title("Gtk::ButtonBox");
      add(m_VBox_Main);

      m_VBox_Main.pack_start(m_Frame_Horizontal, Gtk::PACK_EXPAND_WIDGET, 10);

      //The horizontal ButtonBoxes:
      m_VBox.set_border_width(10);
      m_Frame_Horizontal.add(m_VBox);

      m_VBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(true, "Spread (spacing 40)", 40,
                      Gtk::BUTTONBOX_SPREAD)),
              Gtk::PACK_EXPAND_WIDGET);

      m_VBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(true, "Edge (spacing 30)", 30,
                      Gtk::BUTTONBOX_EDGE)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(true, "Start (spacing 20)", 20,
                      Gtk::BUTTONBOX_START)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      m_VBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(true, "end (spacing 10)", 10,
                      Gtk::BUTTONBOX_END)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      //The vertical ButtonBoxes:
      m_VBox_Main.pack_start(m_Frame_Vertical, Gtk::PACK_EXPAND_WIDGET, 10);

      m_HBox.set_border_width(10);
      m_Frame_Vertical.add(m_HBox);

      m_HBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(false, "Spread (spacing 5)", 5,
                      Gtk::BUTTONBOX_SPREAD)),
              Gtk::PACK_EXPAND_WIDGET);

      m_HBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(false, "Edge (spacing 30)", 30,
                      Gtk::BUTTONBOX_EDGE)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      m_HBox.pack_start(*Gtk::manage(
                  new ExampleButtonBox(false, "Start (spacing 20)", 20,
                      Gtk::BUTTONBOX_START)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      m_HBox.pack_start(*Gtk::manage(new ExampleButtonBox(false, "End (spacing 10)",
                      10, Gtk::BUTTONBOX_END)),
              Gtk::PACK_EXPAND_WIDGET, 5);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_clicked()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

File: `examplebuttonbox.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplebuttonbox.h"

    ExampleButtonBox::ExampleButtonBox(bool horizontal,
           const Glib::ustring& title,
           gint spacing,
           Gtk::ButtonBoxStyle layout)
    : Gtk::Frame(title),
      m_Button_OK("OK"),
      m_Button_Cancel("Cancel"),
      m_Button_Help("Help")
    {
      Gtk::ButtonBox* bbox = nullptr;

      if(horizontal)
        bbox = Gtk::manage( new Gtk::ButtonBox(Gtk::ORIENTATION_HORIZONTAL) );
      else
        bbox = Gtk::manage( new Gtk::ButtonBox(Gtk::ORIENTATION_VERTICAL) );

      bbox->set_border_width(5);

      add(*bbox);

      /* Set the appearance of the Button Box */
      bbox->set_layout(layout);
      bbox->set_spacing(spacing);

      bbox->add(m_Button_OK);
      bbox->add(m_Button_Cancel);
      bbox->add(m_Button_Help);
    }

#### Πλέγμα

Μια Grid διευθετεί δυναμικά τα θυγατρικά γραφικά συστατικά σε γραμμές και στήλες. Οι διαστάσεις του πλέγματος δεν χρειάζονται να οριστούν στον κατασκευαστή.

Τα θυγατρικά γραφικά συστατικά μπορούν να καλύψουν πολλαπλές γραμμές ή στήλες, χρησιμοποιώντας την attach(), ή να προστεθούν δίπλα σε ένα υπάρχον γραφικό συστατικό μέσα στο πλέγμα με την attach_next_to(). Μεμονωμένες γραμμές και στήλες του πλέγματος μπορούν να οριστούν ώστε να έχουν ομοιόμορφο ύψος ή πλάτος με τις set_row_homogeneous() και set_column_homogeneous().

Μπορείτε να ορίσετε τις ιδιότητες περιθωρίου και επέκτασης των θυγατρικών Widgets ώστε να ελέγχουν το διάκενό τους και τη συμπεριφορά τους, όταν το πλέγμα αυξομειώνεται.

Reference

##### Παράδειγμα

Αυτό το παράδειγμα δημιουργεί ένα παράθυρο με τρία κουμπιά σε ένα πλέγμα. Τα πρώτα δύο κουμπιά είναι στην ανώτερη γραμμή, από αριστερά προς τα δεξιά. Ένα τρίτο κουμπί προσαρτάται κάτω από το πρώτο κουμπί, σε μια χαμηλότερη γραμμή, καλύπτοντας δύο στήλες.

Πλέγμα

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    private:
      // Signal handlers:
      void on_button_quit();
      void on_button_numbered(const Glib::ustring& data);

      // Child widgets:
      Gtk::Grid m_grid;
      Gtk::Button m_button_1, m_button_2, m_button_quit;
    };

    #endif /* GTKMM_EXAMPLEWINDOW_H */

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_button_1("button 1"),
      m_button_2("button 2"),
      m_button_quit("Quit")
    {
      set_title("Gtk::Grid");
      set_border_width(12);

      add(m_grid);

      m_grid.add(m_button_1);
      m_grid.add(m_button_2);
      m_grid.attach_next_to(m_button_quit, m_button_1, Gtk::POS_BOTTOM, 2, 1);

      m_button_1.signal_clicked().connect(
        sigc::bind<Glib::ustring>( sigc::mem_fun(*this,
          &ExampleWindow::on_button_numbered), "button 1") );
      m_button_2.signal_clicked().connect(
        sigc::bind<Glib::ustring>( sigc::mem_fun(*this,
          &ExampleWindow::on_button_numbered), "button 2") );

      m_button_quit.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_quit) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void
    ExampleWindow::on_button_numbered(const Glib::ustring& data)
    {
      std::cout << data << " was pressed" << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      // Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Πίνακας

Η Gtk::Table επιτρέπει την τοποθέτηση γραφικών συστατικών σε ένα πλέγμα, παρόμοιο με Gtk::Grid.

Η Gtk::Table είναι παρωχημένη από την έκδοση 3.4 της gtkmm και δεν πρέπει να χρησιμοποιηθεί σε νέο κώδικα. Χρησιμοποιήστε Gtk::Grid στη θέση του.

#### Σημειωματάριο

Μια A Notebook έχει ένα σύνολο στοιβαγμένων `pages` (σελίδων), που καθεμιά τους περιέχει γραφικά συστατικά. Με ετικέτα `tabs` (καρτέλες) επιτρέπει στον χρήστη να επιλέξει τις σελίδες. Οι Notebooks επιτρέπουν αρκετά σύνολα γραφικών συστατικών να τοποθετηθούν σε μικρό χώρο, εμφανίζοντας μόνο μια σελίδα τη φορά. Για παράδειγμα, χρησιμοποιούνται συχνά σε διαλόγους προτιμήσεων.

Χρησιμοποιήστε τις μεθόδους append_page(), prepend_page() και insert_page() για την προσθήκη σελίδων με καρτέλες στο `Notebook` (σημειωματάριο), παρέχοντας στο θυγατρικό γραφικό συστατικό και το όνομα για την καρτέλα.

Για να βρείτε την τρέχουσα ορατή σελίδα, χρησιμοποιήστε τη μέθοδο get_current_page(). Αυτή επιστρέφει τον αριθμό της σελίδας και έπειτα καλώντας την get_nth_page() με αυτόν τον αριθμό θα σας δώσει έναν δείκτη στο ενεργό θυγατρικό γραφικό συστατικό.

Για προγραμματιστική αλλαγή της επιλεγμένης σελίδας, χρησιμοποιήστε τη μέθοδο set_current_page().

Reference

##### Παράδειγμα

Σημειωματάριο

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();
      void on_notebook_switch_page(Gtk::Widget* page, guint page_num);

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Notebook m_Notebook;
      Gtk::Label m_Label1, m_Label2;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Label1("Contents of tab 1"),
      m_Label2("Contents of tab 2"),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::Notebook example");
      set_border_width(10);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the Notebook, with the button underneath:
      m_Notebook.set_border_width(10);
      m_VBox.pack_start(m_Notebook);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Add the Notebook pages:
      m_Notebook.append_page(m_Label1, "First");
      m_Notebook.append_page(m_Label2, "Second");

      m_Notebook.signal_switch_page().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_notebook_switch_page) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::on_notebook_switch_page(Gtk::Widget* /* page */, guint page_num)
    {
      std::cout << "Switched to tab with index " << page_num << std::endl;

      //You can also use m_Notebook.get_current_page() to get this index.
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Βοηθός

Μια Assistant χωρίζει μια σύνθετη λειτουργία σε βήματα. Κάθε βήμα είναι μια σελίδα, που περιέχει μια κεφαλίδα, ένα θυγατρικό γραφικό συστατικό και μια περιοχή ενέργειας. Η ενέργεια του βοηθού έχει πλήκτρα περιήγησης που ενημερώνουν αυτόματα ανάλογα με τον τύπο της σελίδας, που ορίστηκε με set_page_type().

Χρησιμοποιήστε τις μεθόδους append_page(), prepend_page και insert_page() για την προσθήκη σελίδων στη Assistant, παρέχοντας το θυγατρικό γραφικό συστατικό για κάθε σελίδα.

Για τον προσδιορισμό της τρέχουσας ορατής σελίδας, χρησιμοποιήστε τη μέθοδο get_current_page() και περάστε το αποτέλεσμα στη get_nth_page(), που επιστρέφει έναν δείκτη στο ενεργό γραφικό συστατικό. Για προγραμματιστική αλλαγή της τρέχουσας σελίδας, χρησιμοποιήστε τη μέθοδο set_current_page().

Για τον ορισμό του τίτλου μιας σελίδας, χρησιμοποιήστε τη μέθοδο set_page_title(). Η κεφαλίδα και οι πλευρικές εικόνες μιας σελίδας μπορούν να οριστούν με τις μεθόδους set_page_header_image() και set_page_side_image().

Για την προσθήκη γραφικών συστατικών σε μια περιοχή ενέργειας, χρησιμοποιήστε τη μέθοδο add_action_widget(). Θα συσκευαστούν δίπλα στα προεπιλεγμένα κουμπιά. Χρησιμοποιήστε τη μέθοδο remove_action_widget() για αφαίρεση των γραφικών συστατικών.

Reference

##### Παράδειγμα

Βοηθός

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include "exampleassistant.h"
    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    private:
      // Signal handlers:
      void on_button_clicked();
      void on_assistant_apply();

      // Child widgets:
      Gtk::Grid m_grid;
      Gtk::Button m_button;
      Gtk::Label m_label1, m_label2;
      Gtk::CheckButton m_check;
      Gtk::Entry m_entry;
      ExampleAssistant m_assistant;
    };

    #endif /* GTKMM_EXAMPLEWINDOW_H */

File: `exampleassistant.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEASSISTANT_H
    #define GTKMM_EXAMPLEASSISTANT_H

    #include <gtkmm.h>

    class ExampleAssistant : public Gtk::Assistant
    {
    public:
      ExampleAssistant();
      virtual ~ExampleAssistant();

      void get_result(bool& check_state, Glib::ustring& entry_text);

    private:
      // Signal handlers:
      void on_assistant_apply();
      void on_assistant_cancel();
      void on_assistant_close();
      void on_assistant_prepare(Gtk::Widget* widget);
      void on_entry_changed();

      // Member functions:
      void print_status();

      // Child widgets:
      Gtk::Box m_box;
      Gtk::Label m_label1, m_label2;
      Gtk::CheckButton m_check;
      Gtk::Entry m_entry;
    };

    #endif /* GTKMM_EXAMPLEASSISTANT_H */

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include "exampleassistant.h"

    ExampleWindow::ExampleWindow()
    : m_button("Show the assistant"),
      m_label1("State of assistant checkbutton:", Gtk::ALIGN_START, Gtk::ALIGN_CENTER),
      m_label2("Contents of assistant entry:", Gtk::ALIGN_START, Gtk::ALIGN_CENTER)
    {
      set_title("Gtk::Assistant example");
      set_border_width(12);

      m_grid.set_row_homogeneous(true);

      m_grid.attach(m_button, 0, 0, 2, 1);
      m_button.set_hexpand(true);
      m_button.set_valign(Gtk::ALIGN_CENTER);

      m_grid.attach(m_label1, 0, 1, 1, 1);

      m_grid.attach(m_label2, 0, 2, 1, 1);

      m_grid.attach(m_check, 1, 1, 1, 1);
      m_check.set_halign(Gtk::ALIGN_START);

      m_grid.attach(m_entry, 1, 2, 1, 1);
      m_entry.set_hexpand(true);

      add(m_grid);

      m_button.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_clicked));
      m_assistant.signal_apply().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_assistant_apply));

      m_check.set_sensitive(false);
      m_entry.set_sensitive(false);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_assistant_apply()
    {
      bool check_state;
      Glib::ustring entry_text;

      m_assistant.get_result(check_state, entry_text);
      m_check.set_active(check_state);
      m_entry.set_text(entry_text);
    }

    void ExampleWindow::on_button_clicked()
    {
      m_assistant.show();
    }

File: `exampleassistant.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleAssistant::ExampleAssistant()
    : m_box(Gtk::ORIENTATION_HORIZONTAL, 12),
      m_label1("Type text to allow the assistant to continue:"),
      m_label2("Confirmation page"),
      m_check("Optional extra information")
    {
      set_title("Gtk::Assistant example");
      set_border_width(12);
      set_default_size(400, 300);

      m_box.pack_start(m_label1);
      m_box.pack_start(m_entry);

      append_page(m_box);
      append_page(m_check);
      append_page(m_label2);

      set_page_title(*get_nth_page(0), "Page 1");
      set_page_title(*get_nth_page(1), "Page 2");
      set_page_title(*get_nth_page(2), "Confirmation");

      set_page_complete(m_check, true);
      set_page_complete(m_label2, true);

      set_page_type(m_box, Gtk::ASSISTANT_PAGE_INTRO);
      set_page_type(m_label2, Gtk::ASSISTANT_PAGE_CONFIRM);

      signal_apply().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_assistant_apply));
      signal_cancel().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_assistant_cancel));
      signal_close().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_assistant_close));
      signal_prepare().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_assistant_prepare));

      m_entry.signal_changed().connect(sigc::mem_fun(*this,
        &ExampleAssistant::on_entry_changed));

      show_all_children();
    }

    ExampleAssistant::~ExampleAssistant()
    {
    }

    void ExampleAssistant::get_result(bool& check_state, Glib::ustring& entry_text)
    {
      check_state = m_check.get_active();
      entry_text = m_entry.get_text();
    }

    void ExampleAssistant::on_assistant_apply()
    {
      std::cout << "Apply was clicked";
      print_status();
    }

    void ExampleAssistant::on_assistant_cancel()
    {
      std::cout << "Cancel was clicked";
      print_status();
      hide();
    }

    void ExampleAssistant::on_assistant_close()
    {
      std::cout << "Assistant was closed";
      print_status();
      hide();
    }

    void ExampleAssistant::on_assistant_prepare(Gtk::Widget* /* widget */)
    {
      set_title(Glib::ustring::compose("Gtk::Assistant example (Page %1 of %2)",
        get_current_page() + 1, get_n_pages()));
    }

    void ExampleAssistant::on_entry_changed()
    {
      // The page is only complete if the entry contains text.
      if(m_entry.get_text_length())
        set_page_complete(m_box, true);
      else
        set_page_complete(m_box, false);
    }

    void ExampleAssistant::print_status()
    {
      std::cout << ", entry contents: \"" << m_entry.get_text()
        << "\", checkbutton status: " << m_check.get_active() << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      // Shows the window and returns when it is closed.
      return app->run(window);
    }

## Το γραφικό συστατικό προβολή δένδρου (TreeView)

Το γραφικό συστατικό Gtk::TreeView μπορεί να περιέχει λίστες ή δένδρα δεδομένων, σε στήλες.

### Το πρότυπο

Κάθε Gtk::TreeView έχει μια συνδεμένη Gtk::TreeModel, που περιέχει τα εμφανιζόμενα δεδομένα από την TreeView. Κάθε Gtk::TreeModel μπορεί να χρησιμοποιηθεί από περισσότερες από μία Gtk::TreeView. Για παράδειγμα, αυτό επιτρέπει τα ίδια υποκείμενα δεδομένα να εμφανίζονται και να επεξεργάζονται με 2 διαφορετικούς τρόπους ταυτόχρονα. Ή οι 2 προβολές μπορεί να εμφανίζουν διαφορετικές στήλες από τα ίδια δεδομένα του προτύπου, κατά τον ίδιο τρόπο που 2 ερωτήματα SQL (ή "προβολές") μπορείνα εμφανίζουν διαφορετικά πεδία από τον ίδιο πίνακα βάσης δεδομένων.

Αν και μπορείτε θεωρητικά να υλοποιήσετε το δικό σας πρότυπο, θα χρησιμοποιείτε κανονικά τις κλάσεις προτύπου ή την ListStore ή την TreeStore.

Reference

#### Αποθήκευση λίστας (ListStore), για γραμμές

Η ListStore περιέχει απλές γραμμές δεδομένων και κάθε γραμμή δεν έχει θυγατρικά.

Προβολή δένδρου - Αποθήκευση λίστας (TreeView - ListStore)

Reference

#### Αποθήκευση δένδρου, για μια ιεραρχία

Η TreeStore περιέχει γραμμές δεδομένων και κάθε γραμμή μπορεί να έχει θυγατρικές γραμμές.

Προβολή δένδρου - Αποθήκευση λίστας (TreeView - ListStore)

Reference

#### Στήλες προτύπου

Η κλάση TreeModelColumnRecord χρησιμοποιείται για διατήρηση ανίχνευσης των στηλών και των τύπων δεδομένων τους. Προσθέτετε στιγμιότυπα TreeModelColumn στη ColumnRecord και έπειτα τα χρησιμοποιείτε στη TreeModelColumns, όταν παίρνετε και ορίζετε τα δεδομένα στις γραμμές του προτύπου. Θα το βρείτε προφανώς βολικό να παράξετε μια νέα TreeModelColumnRecord που έχει τα στιγμιότυπά σας στη TreeModelColumn ως δεδομένα μέλους.

    class ModelColumns : public Gtk::TreeModelColumnRecord
    {
    public:

      ModelColumns()
        { add(m_col_text); add(m_col_number); }

      Gtk::TreeModelColumn<Glib::ustring> m_col_text;
      Gtk::TreeModelColumn<int> m_col_number;
    };

    ModelColumns m_Columns;

Ορίζετε την ColumnRecord όταν δημιουργείτε το πρότυπο, ως εξής:

    Glib::RefPtr<Gtk::ListStore> refListStore =
        Gtk::ListStore::create(m_Columns);

Σημειώστε ότι το στιγμιότυπο (όπως m_Columns εδώ) πρέπει συνήθως να μην είναι στατικό, επειδή χρειάζεται συχνά να δημιουργηθεί αφού η glibmm έχει δημιουργηθεί.

#### Προσθήκη γραμμών

Προσθέστε γραμμές στο πρότυπο με τις μεθόδους append(), prepend(), ή insert().

    Gtk::TreeModel::iterator iter = m_refListStore->append();

Μπορείτε να αφαιρέσετε την αναφορά από τον επαναλήπτη για να πάρετε τη γραμμή:

    Gtk::TreeModel::Row row = *iter;

##### Προσθήκη θυγατρικών γραμμών

Τα πρότυπα Gtk::TreeStore μπορούν να έχουν θυγατρικά στοιχεία. Προσθέστε τα με τις μεθόδους append(), prepend(), ή insert() ως εξής:

    Gtk::TreeModel::iterator iter_child =
        m_refTreeStore->append(row.children());

#### Ορισμός τιμών

Μπορείτε να χρησιμοποιήσετε τη operator[] για να αντικαταστήσει τον ορισμό των δεδομένων για μια συγκεκριμένη στήλη στη γραμμή, ορίζοντας την TreeModelColumn που χρησιμοποιήθηκε στη δημιουργία του προτύπου.

    row[m_Columns.m_col_text] = "sometext";

#### Λήψη τιμών

Μπορείτε να χρησιμοποιήσετε τη operator[] για να αντικαταστήσει τη λήψη των δεδομένων για μια συγκεκριμένη στήλη σε μια γραμμή, ορίζοντας την TreeModelColumn που χρησιμοποιήθηκε στη δημιουργία του προτύπου.

    Glib::ustring strText = row[m_Columns.m_col_text];
    int number = row[m_Columns.m_col_number];

Ο μεταγλωττιστής θα παραπονεθεί αν χρησιμοποιήσετε έναν ακατάλληλο τύπο. Για παράδειγμα, αυτό θα μπορούσε να δημιουργήσει ένα σφάλμα μεταγλωττιστή:

    //compiler error - no conversion from ustring to int.
    int number = row[m_Columns.m_col_text];

#### "Κρυφές" στήλες

Μπορεί να θέλετε να συνδέσετε πρόσθετα δεδομένα με κάθε γραμμή. Αν συμβαίνει αυτό, απλά προσθέστε το ως μια στήλη προτύπου, αλλά μην το προσθέσετε στην προβολή.

### Η προβολή

Η προβολή είναι το ενεργό γραφικό συστατικό (Gtk::TreeView) που εμφανίζει τα δεδομένα του προτύπου (Gtk::TreeModel) και επιτρέπει στον χρήστη να αλληλεπιδράσει με αυτά. Η προβολή μπορεί να εμφανίσει όλες τις στήλες του προτύπου, ή απλά μερικές και μπορεί να τις εμφανίσει με ποικίλους τρόπους.

Reference

#### Χρήση ενός προτύπου

Μπορείτε να ορίσετε μία Gtk::TreeModel, όταν κατασκευάζετε την Gtk::TreeView, ή μπορείτε να χρησιμοποιήσετε τη μέθοδο set_model(), ως εξής:

    m_TreeView.set_model(m_refListStore);

#### Προσθήκη στηλών προβολής

Μπορείτε να χρησιμοποιήσετε τη μέθοδο append_column() για να πείτε στην προβολή ότι θα πρέπει να εμφανίσει συγκεκριμένες στήλες του προτύπου, σε μια συγκεκριμένη σειρά, με έναν συγκεκριμένο τίτλο στήλης.

    m_TreeView.append_column("Messages", m_Columns.m_col_text);

Όταν χρησιμοποιείτε αυτήν απλή αντικατάσταση append_column(), η TreeView θα εμφανίσει τα δεδομένα του προτύπου με μια κατάλληλη CellRenderer. Για παράδειγμα, οι συμβολοσειρές και οι αριθμοί εμφανίζονται σε ένα απλό γραφικό συστατικό Gtk::Entry και οι τιμές Μπουλ εμφανίζονται σε μια Gtk::CheckButton. Αυτό είναι συνήθως αυτό που χρειάζεστε. Για άλλους τύπους στηλών, πρέπει ή να συνδεθείτε με μια επανάκληση που μετατρέπει τον τύπο σας σε μια συμβολοσειρά παρουσίασης, με TreeViewColumn::set_cell_data_func(), ή να παράξει μια προσαρμοσμένη CellRenderer. Σημειώστε ότι (χωρίς πρόσημο) μικρός αριθμός δεν υποστηρίζεται από προεπιλογή - Μπορείτε να χρησιμοποιήσετε (χωρίς πρόσημο) ακέραιο ή (χωρίς πρόσημο) μεγάλο αριθμό ως τύπο στήλης στη θέση του.

#### Περισσότερες από μια στήλη προτύπου ανά στήλη προβολής

Για την απόδοση περισσότερων από μια στήλης προτύπου σε μια στήλη προβολής, χρειάζεται να δημιουργήσετε το γραφικό συστατικό TreeView::Column χειροκίνητα και να χρησιμοποιήσετε την pack_start() για να προσθέσετε τις στήλες του προτύπου σε αυτή.

Έπειτα χρησιμοποιήστε την append_column() για να προσθέσετε τη στήλη προβολής στην προβολή. Σημειώστε ότι η Gtk::TreeView::append_column() επικαλύπτεται για να δεχτεί είτε ένα προκατασκευασμένο γραφικό συστατικό Gtk::TreeView::Column, ή απλά την TreeModelColumn από την οποία παράγει ένα κατάλληλο γραφικό συστατικό Gtk::TreeView::Column.

Να κάποιο παράδειγμα κώδικα από το `gtkmm/demos/gtk-demo/example_icontheme.cc`, που έχει ένα εικονίδιο pixbuf και ένα όνομα κειμένου στην ίδια στήλη:

    Gtk::TreeView::Column* pColumn =
      Gtk::manage(new Gtk::TreeView::Column("Icon Name"));

    // m_columns.icon and m_columns.iconname είναι στήλες στο μοντέλο.
    // pColumn είναι η στήλη στην προβολή δένδρου:
    pColumn->pack_start(m_columns.icon, /* expand= */ false);
    pColumn->pack_start(m_columns.iconname);

    m_TreeView.append_column(*pColumn);

#### Ορίζοντας τις λεπτομέρειες CellRenderer

Η προεπιλεγμένη CellRenderers και η προεπιλεγμένη τους συμπεριφορά κανονικά αρκούν, αλλά μπορεί ενίοτε να χρειαστείτε πιο λεπτό έλεγχο. Για παράδειγμα, αυτός ο κώδικας παραδείγματος από το `gtkmm/demos/gtk-demo/example_treeview_treestore.cc`, προσαρτά ένα γραφικό συστατικό Gtk::CellRenderer και το πληροφορεί για να αποδώσει τα δεδομένα από ποικίλες στήλες προτύπου μέσα από ποικίλες πτυχές της εμφάνισης του.

    int cols_count = m_TreeView.append_column_editable("Alex", m_columns.alex);
    Gtk::TreeViewColumn* pColumn = m_TreeView.get_column(cols_count-1);
    if(pColumn)
    {
      Gtk::CellRendererToggle* pRenderer =
        static_cast<Gtk::CellRendererToggle*>(pColumn->get_first_cell());
      pColumn->add_attribute(pRenderer->property_visible(), m_columns.visible);
      pColumn->add_attribute(pRenderer->property_activatable(), m_columns.world);

Μπορείτε επίσης να συνδέσετε τα σήματα CellRenderer στην αναγνώριση ενεργειών χρήστη. Για παράδειγμα:

    Gtk::CellRendererToggle* pRenderer =
        Gtk::manage( new Gtk::CellRendererToggle() );
    pRenderer->signal_toggled().connect(
        sigc::bind( sigc::mem_fun(*this,
            &Example_TreeView_TreeStore::on_cell_toggled), m_columns.dave)
    );

#### Επεξεργάσιμα κελιά

##### Αυτόματα αποθηκευμένα επεξεργάσιμα κελιά.

Cells in a TreeView can be edited in-place by the user. To allow this, use the Gtk::TreeView insert_column_editable() and append_column_editable() methods instead of insert_column() and append_column(). When these cells are edited the new values will be stored immediately in the Model. Note that these methods are templates which can only be instantiated for simple column types such as Glib::ustring, int, and long.

##### Υλοποίηση προσαρμοσμένης λογικής για επεξεργάσιμα κελιά.

Όμως, μπορεί να μην θέλετε οι νέες τιμές να αποθηκευτούν αμέσως. Για παράδειγμα, μπορεί να θέλετε να περιορίσετε την είσοδο σε συγκεκριμένους χαρακτήρες ή περιοχές τιμών.

To achieve this, you should use the normal Gtk::TreeView insert_column() and append_column() methods, then use get_column_cell_renderer() to get the Gtk::CellRenderer used by that column.

Θα πρέπει έπειτα να αλλάξετε τύπο σε Gtk::CellRenderer* στο συγκεκριμένο CellRenderer που περιμένετε, έτσι μπορείτε να χρησιμοποιήσετε ειδικές API.

Για παράδειγμα, για CellRendererText, μπορείτε να ορίσετε την ιδιότητα επεξεργάσιμο του κελιού σε αληθές, ως εξής:

    cell.property_editable() = true;

Για ένα CellRendererToggle, μπορείτε να ορίσετε την ενεργοποιήσιμη ιδιότητα στη θέση του.

Μπορείτε έπειτα να συνδεθείτε με το κατάλληλο "επεξεργασμένο" σήμα. Για παράδειγμα, συνδεθείτε στις Gtk::CellRendererText::signal_edited(), ή Gtk::CellRendererToggle::signal_toggled(). Αν η στήλη περιέχει περισσότερες από μία CellRenderer, τότε θα απαιτηθεί η χρήση της Gtk::TreeView::get_column() και μετά η κλήση της get_cell_renderers() σε αυτήν την στήλη προβολής.

Στον χειριστή σήματός σας, θα πρέπει να εξετάσετε τη νέα τιμή και έπειτα να την αποθηκεύσει στο πρότυπο, αν αυτό είναι κατάλληλο για την εφαρμογή σας.

### Επανάληψη στις γραμμές προτύπου

Η Gtk::TreeModel παρέχει έναν τυπικό περιέκτη τεχνοτροπίας βιβλιοθήκης του θυγατρικού του, μέσα από τη μέθοδο children(). Μπορείτε να χρησιμοποιήσετε τις οικείες μεθόδους begin() and end() επαναλήπτη αύξησης, ως εξής:

    typedef Gtk::TreeModel::Children type_children; //minimise code length.
    type_children children = refModel->children();
    for(type_children::iterator iter = children.begin();
        iter != children.end(); ++iter)
    {
      Gtk::TreeModel::Row row = *iter;
      //Do something with the row - see above for set/get.
    }

#### Θυγατρικά γραμμή

When using a Gtk::TreeStore, the rows can have child rows, which can have their own children in turn. Use Gtk::TreeModel::Row::children() to get the container of child Rows:

    Gtk::TreeModel::Children children = row.children();

### Η επιλογή

Για να βρείτε ποιες γραμμές έχει επιλέξει ο χρήστης, πάρτε το αντικείμενο Gtk::TreeView::Selection από την TreeView, ως εξής:

    Glib::RefPtr<Gtk::TreeSelection> refTreeSelection =
        m_TreeView.get_selection();

#### Μεμονωμένη ή πολλαπλή επιλογή

By default, only single rows can be selected, but you can allow multiple selection by setting the mode, like so:

    refTreeSelection->set_mode(Gtk::SELECTION_MULTIPLE);

#### Οι επιλεγμένες γραμμές

Για μεμονωμένη επιλογή, μπορείτε να καλέσετε απλά την get_selected(), ως εξής:

    TreeModel::iterator iter = refTreeSelection->get_selected();
    if(iter) //Αν κάτι έχει επιλεγεί
    {
      TreeModel::Row row = *iter;
      //Do something with the row.
    }

Για πολλαπλή επιλογή, χρειάζεται να ορίσετε μια επανάκληση και να της δώσετε selected_foreach(), selected_foreach_path(), ή selected_foreach_iter(), ως εξής:

    refTreeSelection->selected_foreach_iter(
        sigc::mem_fun(*this, &TheClass::selected_row_callback) );

    void TheClass::selected_row_callback(
        const Gtk::TreeModel::iterator& iter)
    {
      TreeModel::Row row = *iter;
      //Do something with the row.
    }

#### Το "αλλαγμένο" σήμα

Για απάντηση στο πάτημα του χρήστη σε μια γραμμή ή περιοχή γραμμών, συνδεθείτε με το σήμα ως εξής:

    refTreeSelection->signal_changed().connect(
        sigc::mem_fun(*this, &Example_IconTheme::on_selection_changed)
    );

#### Αποτρέποντας την επιλογή γραμμής

Μπορεί ο χρήστης να μην πρέπει να μπορεί να επιλέξει κάθε στοιχείο στη λίστα ή δένδρο σας. Για παράδειγμα, στο gtk-demo, μπορείτε να επιλέξετε μια παρουσίαση για να δείτε τον πηγαίο κώδικα, αλλά δεν έχει νόημα να επιλέξετε μια κατηγορία παρουσίασης.

Για τον έλεγχο των γραμμών που μπορούν να επιλεγούν, χρησιμοποιήστε τη μέθοδο set_select_function(), δίνοντας μια επανάκληση sigc::slot. Για παράδειγμα:

    m_refTreeSelection->set_select_function( sigc::mem_fun(*this,
        &DemoWindow::select_function) );

και έπειτα

    bool DemoWindow::select_function(
        const Glib::RefPtr<Gtk::TreeModel>& model,
        const Gtk::TreeModel::Path& path, bool)
    {
      const Gtk::TreeModel::iterator iter = model->get_iter(path);
      return iter->children().empty(); // only allow leaf nodes to be selected
    }

#### Αλλαγή της επιλογής

Για να αλλάξετε την επιλογή, ορίστε έναν Gtk::TreeModel::iterator ή Gtk::TreeModel::Row, ως εξής:

    Gtk::TreeModel::Row row = m_refModel->children()[5]; //The fifth row.
    if(row)
      refTreeSelection->select(row);

ή

    Gtk::TreeModel::iterator iter = m_refModel->children().begin()
    if(iter)
      refTreeSelection->select(iter);

### Ταξινόμηση

Τα τυπικά πρότυπα δένδρου (TreeStore και ListStore) παράγονται από TreeSortable, έτσι προσφέρουν ταξινόμηση λειτουργικότητας. Για παράδειγμα, καλέστε set_sort_column(), για ταξινόμηση του προτύπου από τη συγκεκριμένη στήλη. Ή δώστε μια συνάρτηση επανάκλησης set_sort_func() για να υλοποιηθεί ένας πιο περίπλοκος αλγόριθμος ταξινόμησης.

TreeSortable Reference

#### Ταξινόμηση πατώντας στις στήλες

Για να μπορεί ένας χρήστης να πατά σε μία κεφαλίδα στήλης TreeView για να ταξινομήσει τα περιεχόμενα της TreeView, καλέστε Gtk::TreeView::Column::set_sort_column(), παρέχοντας τη στήλη προτύπου στην οποία το πρότυπο πρέπει να ταξινομηθεί, όταν πατηθεί η κεφαλίδα. Για παράδειγμα:

    Gtk::TreeView::Column* pColumn = treeview.get_column(0);
    if(pColumn)
      pColumn->set_sort_column(m_columns.m_col_id);

#### Ανεξάρτητα ταξινομημένες προβολές του ίδιου προτύπου

Η TreeView επιτρέπει ήδη να εμφανίσετε την ίδια TreeModel σε δύο γραφικά συστατικά TreeView. Αν χρειάζεστε μια από αυτές τις TreeViews για να ταξινομήσετε το πρότυπο διαφορετικά από την άλλη, τότε θα πρέπει να χρησιμοποιήσετε μια TreeModelSort αντί για απλώς, για παράδειγμα, Gtk::TreeViewModel::set_sort_column(). Η TreeModelSort είναι ένα πρότυπο που περιέχει ένα άλλο πρότυπο, που παρουσιάζει μια ταξινομημένη έκδοση αυτού του προτύπου. Για παράδειγμα, μπορεί να προσθέσετε μια ταξινομημένη έκδοση ενός προτύπου σε μια TreeView ως εξής:

    Glib::RefPtr<Gtk::TreeModelSort> sorted_model =
        Gtk::TreeModelSort::create(model);
    sorted_model->set_sort_column(columns.m_col_name, Gtk::SORT_ASCENDING);
    treeview.set_model(sorted_model);

Σημειώστε, όμως, ότι η TreeView θα δώσει επαναλήπτες στο ταξινομημένο πρότυπο. Πρέπει να τους μετατρέψετε σε επαναλήπτες στο υποκείμενο θυγατρικό πρότυπο για να εκτελέσετε ενέργειες σε αυτό το πρότυπο. Για παράδειγμα:

    void ExampleWindow::on_button_delete()
    {
      Glib::RefPtr<Gtk::TreeSelection> refTreeSelection =
          m_treeview.get_selection();
      if(refTreeSelection)
      {
        Gtk::TreeModel::iterator sorted_iter =
            m_refTreeSelection->get_selected();
        if(sorted_iter)
        {
          Gtk::TreeModel::iterator iter =
              m_refModelSort->convert_iter_to_child_iter(sorted_iter);
          m_refModel->erase(iter);
        }
      }
    }

TreeModelSort Reference

### Μεταφορά κι απόθεση

Η Gtk::TreeView υλοποιεί ήδη απλή μεταφορά και απόθεση όταν χρησιμοποιείται με τα μοντέλα Gtk::ListStore ή Gtk::TreeStore. Αν είναι απαραίτητο, επιτρέπει επίσης την υλοποίηση πιο σύνθετης συμπεριφοράς όταν μεταφέρονται και αποτίθενται στοιχεία, χρησιμοποιώντας την κανονική API Μεταφορά και απόθεση.

#### Αναδιατάξιμες γραμμές

Αν καλέσετε τη Gtk::TreeView::set_reorderable(), τότε τα στοιχεία της προβολής δένδρου μπορούν να μετακινηθούν μέσα στην ίδια προβολή δένδρου. Αυτό δείχνεται στο παράδειγμα TreeStore.

Όμως, αυτό δεν επιτρέπει κανένα στοιχείο ελέγχου του οποίου τα στοιχεία μπορούν να μετακινηθούν και όπου μπορούν να αποτεθούν. Αν χρειάζεστε αυτόν τον πρόσθετο έλεγχο, τότε μπορείτε να δημιουργήσετε ένα παράγωγο `Gtk::TreeModel` από τα `Gtk::TreeStore` ή `Gtk::ListStore` και να αντικαταστήσετε τις εικονικές μεθόδους `Gtk::TreeDragSource::row_draggable()` και `Gdk::TreeDragDest::row_drop_possible()`. Μπορείτε να εξετάσετε τα παρεχόμενα `Gtk::TreeModel::Path`s και να επιτρέψετε ή να απορρίψετε τη μεταφορά ή απόθεση επιστρέφοντας `true` ή `false`.

Αυτό παρουσιάζεται στο παράδειγμα drag_and_drop.

### Αναδυόμενο μενού περιεχομένων

Πολλά άτομα χρειάζονται να υλοποιήσουν δεξιό πάτημα σε μενού περιεχομένων για την TreeView, έτσι θα εξηγήσουμε πώς να το κάνετε αυτό εδώ για να σας εξοικονομήσουμε κάποιο χρόνο. Πέρα από ένα ή δύο σημεία, είναι παρεμφερές με το κανονικό μενού περιεχομένων, όπως περιγράφηκε στο κεφάλαιο μενού.

#### Χειρισμός `button_press_event`

Για την αναγνώριση ενός πατήματος του δεξιού πλήκτρου του ποντικιού, χρειάζεστε να χειριστείτε το σήμα `button_press_event` και να ελέγξετε ακριβώς ποιο κουμπί πατήθηκε. Επειδή η TreeView χειρίζεται κανονικά αυτό το σήμα πλήρως, χρειάζεστε ή να αντικαταστήσετε τον προεπιλεγμένο χειριστή σήματος σε μια παράγωγη κλάση TreeView, ή να χρησιμοποιήσετε την connect_notify() αντί για την connect(). Θα θέλετε προφανώς επίσης να καλέσετε τον προεπιλεγμένο χειριστή πριν να κάνετε οτιδήποτε άλλο, έτσι ώστε το δεξιό πάτημα να προκαλέσει να επιλεγεί πρώτα τη γραμμή.

Αυτό παρουσιάζεται στο παράδειγμα αναδυόμενου προσαρμοσμένου μενού.

### Παραδείγματα

#### Αποθήκευση λιστών

Αυτό το παράδειγμα έχει ένα γραφικό συστατικό Gtk::TreeView, με ένα μοντέλο Gtk::ListStore.

Προβολή δένδρου - Αποθήκευση λίστας (TreeView - ListStore)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); add(m_col_number); add(m_col_percentage);}

        Gtk::TreeModelColumn<unsigned int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
        Gtk::TreeModelColumn<short> m_col_number;
        Gtk::TreeModelColumn<int> m_col_percentage;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TreeView m_TreeView;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::TreeView (ListStore) example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Create the Tree model:
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_TreeView.set_model(m_refTreeModel);

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";
      row[m_Columns.m_col_number] = 10;
      row[m_Columns.m_col_percentage] = 15;

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Joey Jojo";
      row[m_Columns.m_col_number] = 20;
      row[m_Columns.m_col_percentage] = 40;

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Rob McRoberts";
      row[m_Columns.m_col_number] = 30;
      row[m_Columns.m_col_percentage] = 70;

      //Add the TreeView's view columns:
      //This number will be shown with the default numeric formatting.
      m_TreeView.append_column("ID", m_Columns.m_col_id);
      m_TreeView.append_column("Name", m_Columns.m_col_name);

      m_TreeView.append_column_numeric("Formatted number", m_Columns.m_col_number,
              "%010d" /* 10 digits, using leading zeroes. */);

      //Display a progress bar instead of a decimal number:
      auto cell = Gtk::manage(new Gtk::CellRendererProgress);
      int cols_count = m_TreeView.append_column("Some percentage", *cell);
      auto pColumn = m_TreeView.get_column(cols_count - 1);
      if(pColumn)
      {
        pColumn->add_attribute(cell->property_value(), m_Columns.m_col_percentage);
      }

      //Make all the columns reorderable:
      //This is not necessary, but it's nice to show the feature.
      //You can use TreeView::set_column_drag_function() to more
      //finely control column drag and drop.
      for(guint i = 0; i < 2; i++)
      {
        auto column = m_TreeView.get_column(i);
        column->set_reorderable();
      }

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Αποθήκευση δένδρου

Αυτό το παράδειγμα είναι πολύ παρόμοιο με το παράδειγμα ListStore, αλλά χρησιμοποιεί ένα μοντέλο Gtk::TreeStore και προσθέτει θυγατρικά στις γραμμές.

Προβολή δένδρου - Αποθήκευση λίστας (TreeView - ListStore)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_quit();
      void on_treeview_row_activated(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column);

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); }

        Gtk::TreeModelColumn<int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TreeView m_TreeView;
      Glib::RefPtr<Gtk::TreeStore> m_refTreeModel;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::TreeView (TreeStore) example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Create the Tree model:
      m_refTreeModel = Gtk::TreeStore::create(m_Columns);
      m_TreeView.set_model(m_refTreeModel);

      //All the items to be reordered with drag-and-drop:
      m_TreeView.set_reorderable();

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";

      Gtk::TreeModel::Row childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 11;
      childrow[m_Columns.m_col_name] = "Billy Bob Junior";

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 12;
      childrow[m_Columns.m_col_name] = "Sue Bob";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Joey Jojo";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Rob McRoberts";

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 31;
      childrow[m_Columns.m_col_name] = "Xavier McRoberts";

      //Add the TreeView's view columns:
      m_TreeView.append_column("ID", m_Columns.m_col_id);
      m_TreeView.append_column("Name", m_Columns.m_col_name);

      //Connect signal:
      m_TreeView.signal_row_activated().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_treeview_row_activated) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::on_treeview_row_activated(const Gtk::TreeModel::Path& path,
            Gtk::TreeViewColumn* /* column */)
    {
      Gtk::TreeModel::iterator iter = m_refTreeModel->get_iter(path);
      if(iter)
      {
        Gtk::TreeModel::Row row = *iter;
        std::cout << "Row activated: ID=" << row[m_Columns.m_col_id] << ", Name="
            << row[m_Columns.m_col_name] << std::endl;
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Επεξεργάσιμα κελιά

Αυτό το παράδειγμα είναι ταυτόσημο με το παράδειγμα ListStore, αλλά χρησιμοποιεί την TreeView::append_column_editable() αντί για TreeView::append_column().

Προβολή δένδρου (TreeView) - Επεξεργάσιμα κελιά

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      void treeviewcolumn_validated_on_cell_data(Gtk::CellRenderer* renderer, const Gtk::TreeModel::iterator& iter);
      void cellrenderer_validated_on_editing_started(Gtk::CellEditable* cell_editable, const Glib::ustring& path);
      void cellrenderer_validated_on_edited(const Glib::ustring& path_string, const Glib::ustring& new_text);

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); add(m_col_foo); add(m_col_number); add(m_col_number_validated); }

        Gtk::TreeModelColumn<unsigned int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
        Gtk::TreeModelColumn<bool> m_col_foo;
        Gtk::TreeModelColumn<int> m_col_number;
        Gtk::TreeModelColumn<int> m_col_number_validated;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TreeView m_TreeView;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;

      //For the validated column:
      //You could also use a CellRendererSpin or a CellRendererProgress:
      Gtk::CellRendererText m_cellrenderer_validated;
      Gtk::TreeView::Column m_treeviewcolumn_validated;
      bool m_validate_retry;
      Glib::ustring m_invalid_text_for_retry;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    #include "examplewindow.h"

    using std::sprintf;
    using std::strtol;

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit"),
      m_validate_retry(false)
    {
      set_title("Gtk::TreeView Editable Cells example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Create the Tree model:
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_TreeView.set_model(m_refTreeModel);

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";
      row[m_Columns.m_col_foo] = true;
      row[m_Columns.m_col_number] = 10;

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Joey Jojo";
      row[m_Columns.m_col_foo] = true;
      row[m_Columns.m_col_number] = 20;

      row = *(m_refTreeModel->append());

      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Rob McRoberts";
      row[m_Columns.m_col_foo] = false;
      row[m_Columns.m_col_number] = 30;

      //Add the TreeView's view columns:
      //We use the *_editable convenience methods for most of these,
      //because the default functionality is enough:
      m_TreeView.append_column_editable("ID", m_Columns.m_col_id);
      m_TreeView.append_column_editable("Name", m_Columns.m_col_name);
      m_TreeView.append_column_editable("foo", m_Columns.m_col_foo);
      m_TreeView.append_column_numeric_editable("foo", m_Columns.m_col_number,
              "%010d");

      //For this column, we create the CellRenderer ourselves, and connect our own
      //signal handlers, so that we can validate the data that the user enters, and
      //control how it is displayed.
      m_treeviewcolumn_validated.set_title("validated (<10)");
      m_treeviewcolumn_validated.pack_start(m_cellrenderer_validated);
      m_TreeView.append_column(m_treeviewcolumn_validated);

      //Tell the view column how to render the model values:
      m_treeviewcolumn_validated.set_cell_data_func(m_cellrenderer_validated,
              sigc::mem_fun(*this,
                  &ExampleWindow::treeviewcolumn_validated_on_cell_data) );

      //Make the CellRenderer editable, and handle its editing signals:
      m_cellrenderer_validated.property_editable() = true;

      m_cellrenderer_validated.signal_editing_started().connect(
              sigc::mem_fun(*this,
            &ExampleWindow::cellrenderer_validated_on_editing_started) );

      m_cellrenderer_validated.signal_edited().connect( sigc::mem_fun(*this,
                  &ExampleWindow::cellrenderer_validated_on_edited) );

      //If this was a CellRendererSpin then you would have to set the adjustment:
      //m_cellrenderer_validated.property_adjustment() = m_spin_adjustment;

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::treeviewcolumn_validated_on_cell_data(
            Gtk::CellRenderer* /* renderer */,
            const Gtk::TreeModel::iterator& iter)
    {
      //Get the value from the model and show it appropriately in the view:
      if(iter)
      {
        Gtk::TreeModel::Row row = *iter;
        int model_value = row[m_Columns.m_col_number_validated];

        //This is just an example.
        //In this case, it would be easier to use append_column_editable() or
        //append_column_numeric_editable()
        char buffer[32];
        sprintf(buffer, "%d", model_value);

        Glib::ustring view_text = buffer;
        m_cellrenderer_validated.property_text() = view_text;
      }
    }

    void ExampleWindow::cellrenderer_validated_on_editing_started(
            Gtk::CellEditable* cell_editable, const Glib::ustring& /* path */)
    {
      //Start editing with previously-entered (but invalid) text,
      //if we are allowing the user to correct some invalid data.
      if(m_validate_retry)
      {
        //This is the CellEditable inside the CellRenderer.
        auto celleditable_validated = cell_editable;

        //It's usually an Entry, at least for a CellRendererText:
        auto pEntry = dynamic_cast<Gtk::Entry*>(celleditable_validated);
        if(pEntry)
        {
          pEntry->set_text(m_invalid_text_for_retry);
          m_validate_retry = false;
          m_invalid_text_for_retry.clear();
        }
      }

    }

    void ExampleWindow::cellrenderer_validated_on_edited(
            const Glib::ustring& path_string,
            const Glib::ustring& new_text)
    {
      Gtk::TreePath path(path_string);

      //Convert the inputed text to an integer, as needed by our model column:
      char* pchEnd = nullptr;
      int new_value = strtol(new_text.c_str(), &pchEnd, 10);

      if(new_value > 10)
      {
        //Prevent entry of numbers higher than 10.

        //Tell the user:
        Gtk::MessageDialog dialog(*this,
                "The number must be less than 10. Please try again.",
                false, Gtk::MESSAGE_ERROR);
        dialog.run();

        //Start editing again, with the bad text, so that the user can correct it.
        //A real application should probably allow the user to revert to the
        //previous text.

        //Set the text to be used in the start_editing signal handler:
        m_invalid_text_for_retry = new_text;
        m_validate_retry = true;

        //Start editing again:
        m_TreeView.set_cursor(path, m_treeviewcolumn_validated,
                m_cellrenderer_validated, true /* start_editing */);
      }
      else
      {
        //Get the row from the path:
        Gtk::TreeModel::iterator iter = m_refTreeModel->get_iter(path);
        if(iter)
        {
          Gtk::TreeModel::Row row = *iter;

          //Put the new value in the model:
          row[m_Columns.m_col_number_validated] = new_value;
        }
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Μεταφορά κι απόθεση

Αυτό το παράδειγμα μοιάζει πολύ με το παράδειγμα TreeStore, αλλά έχει 2 πρόσθετες στήλες για να δείξει αν η γραμμή μπορεί να μετακινηθεί και αν μπορεί να δεχτεί γραμμές με μεταφορά και απόθεση. Χρησιμοποιεί μια παραγόμενη Gtk::TreeStore που υπερισχύει των εικονικών συναρτήσεων όπως περιγράφτηκαν στην ενότητα Μεταφορά και απόθεση προβολής δένδρου.

Προβολή δένδρου - Μεταφορά και απόθεση

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "treemodel_dnd.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TreeView m_TreeView;
      Glib::RefPtr<TreeModel_Dnd> m_refTreeModel;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `treemodel_dnd.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_TREEMODEL_DND_H
    #define GTKMM_EXAMPLE_TREEMODEL_DND_H

    #include <gtkmm.h>

    class TreeModel_Dnd : public Gtk::TreeStore
    {
    protected:
      TreeModel_Dnd();

    public:

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); add(m_col_draggable); add(m_col_receivesdrags); }

        Gtk::TreeModelColumn<int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
        Gtk::TreeModelColumn<bool> m_col_draggable;
        Gtk::TreeModelColumn<bool> m_col_receivesdrags;
      };

      ModelColumns m_Columns;

      static Glib::RefPtr<TreeModel_Dnd> create();

    protected:
      //Overridden virtual functions:
      bool row_draggable_vfunc(const Gtk::TreeModel::Path& path) const override;
      bool row_drop_possible_vfunc(const Gtk::TreeModel::Path& dest, const Gtk::SelectionData& selection_data) const override;

    };

    #endif //GTKMM_EXAMPLE_TREEMODEL_DND_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("_Quit", true)
    {
      set_title("Gtk::TreeView (Drag and Drop) example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      //Create the Tree model:
      //Use our derived model, which overrides some Gtk::TreeDragDest and
      //Gtk::TreeDragSource virtual functions:
      //The columns are declared in the overridden TreeModel.
      m_refTreeModel = TreeModel_Dnd::create();
      m_TreeView.set_model(m_refTreeModel);

      //Enable Drag-and-Drop of TreeView rows:
      //See also the derived TreeModel's *_vfunc overrides.
      m_TreeView.enable_model_drag_source();
      m_TreeView.enable_model_drag_dest();

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_refTreeModel->m_Columns.m_col_id] = 1;
      row[m_refTreeModel->m_Columns.m_col_name] = "Billy Bob";
      row[m_refTreeModel->m_Columns.m_col_draggable] = true;
      row[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      Gtk::TreeModel::Row childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_refTreeModel->m_Columns.m_col_id] = 11;
      childrow[m_refTreeModel->m_Columns.m_col_name] = "Billy Bob Junior";
      childrow[m_refTreeModel->m_Columns.m_col_draggable] = true;
      childrow[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_refTreeModel->m_Columns.m_col_id] = 12;
      childrow[m_refTreeModel->m_Columns.m_col_name] = "Sue Bob";
      childrow[m_refTreeModel->m_Columns.m_col_draggable] = true;
      childrow[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      row = *(m_refTreeModel->append());
      row[m_refTreeModel->m_Columns.m_col_id] = 2;
      row[m_refTreeModel->m_Columns.m_col_name] = "Joey Jojo";
      row[m_refTreeModel->m_Columns.m_col_draggable] = true;
      row[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      row = *(m_refTreeModel->append());
      row[m_refTreeModel->m_Columns.m_col_id] = 3;
      row[m_refTreeModel->m_Columns.m_col_name] = "Rob McRoberts";
      row[m_refTreeModel->m_Columns.m_col_draggable] = true;
      row[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_refTreeModel->m_Columns.m_col_id] = 31;
      childrow[m_refTreeModel->m_Columns.m_col_name] = "Xavier McRoberts";
      childrow[m_refTreeModel->m_Columns.m_col_draggable] = true;
      childrow[m_refTreeModel->m_Columns.m_col_receivesdrags] = true;

      //Add the TreeView's view columns:
      m_TreeView.append_column("ID", m_refTreeModel->m_Columns.m_col_id);
      m_TreeView.append_column("Name", m_refTreeModel->m_Columns.m_col_name);
      m_TreeView.append_column_editable("Draggable",
              m_refTreeModel->m_Columns.m_col_draggable);
      m_TreeView.append_column_editable("Receives Drags",
              m_refTreeModel->m_Columns.m_col_receivesdrags);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `treemodel_dnd.cc` (For use with gtkmm 3, not gtkmm 2)

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

    TreeModel_Dnd::TreeModel_Dnd()
    {
      //We can't just call Gtk::TreeModel(m_Columns) in the initializer list
      //because m_Columns does not exist when the base class constructor runs.
      //And we can't have a static m_Columns instance, because that would be
      //instantiated before the gtkmm type system.
      //So, we use this method, which should only be used just after creation:
      set_column_types(m_Columns);
    }

    Glib::RefPtr<TreeModel_Dnd> TreeModel_Dnd::create()
    {
      return Glib::RefPtr<TreeModel_Dnd>( new TreeModel_Dnd() );
    }

    bool
    TreeModel_Dnd::row_draggable_vfunc(const Gtk::TreeModel::Path& path) const
    {
      // Make the value of the "draggable" column determine whether this row can
      // be dragged:

      //TODO: Add a const version of get_iter to TreeModel:
      auto unconstThis = const_cast<TreeModel_Dnd*>(this);
      const_iterator iter = unconstThis->get_iter(path);
      //const_iterator iter = get_iter(path);
      if(iter)
      {
        Row row = *iter;
        bool is_draggable = row[m_Columns.m_col_draggable];
        return is_draggable;
      }

      return Gtk::TreeStore::row_draggable_vfunc(path);
    }

    bool
    TreeModel_Dnd::row_drop_possible_vfunc(const Gtk::TreeModel::Path& dest,
            const Gtk::SelectionData& selection_data) const
    {
      //Make the value of the "receives drags" column determine whether a row can be
      //dragged into it:

      //dest is the path that the row would have after it has been dropped:
      //But in this case we are more interested in the parent row:
      Gtk::TreeModel::Path dest_parent = dest;
      bool dest_is_not_top_level = dest_parent.up();
      if(!dest_is_not_top_level || dest_parent.empty())
      {
        //The user wants to move something to the top-level.
        //Let's always allow that.
      }
      else
      {
        //Get an iterator for the row at this path:
        //We must unconst this. This should not be necessary with a future version
        //of gtkmm.
        //TODO: Add a const version of get_iter to TreeModel:
        auto unconstThis = const_cast<TreeModel_Dnd*>(this);
        const_iterator iter_dest_parent = unconstThis->get_iter(dest_parent);
        //const_iterator iter_dest_parent = get_iter(dest);
        if(iter_dest_parent)
        {
          Row row = *iter_dest_parent;
          bool receives_drags = row[m_Columns.m_col_receivesdrags];
          return receives_drags;
        }
      }

      //You could also examine the row being dragged (via selection_data)
      //if you must look at both rows to see whether a drop should be allowed.
      //You could use
      //TODO: Add const version of get_from_selection_data(): Glib::RefPtr<const
      //Gtk::TreeModel> refThis = Glib::RefPtr<const Gtk::TreeModel>(this);
      //
      //auto refThis =
      //Glib::RefPtr<Gtk::TreeModel>(const_cast<TreeModel_Dnd*>(this));
      //refThis->reference(); //, true /* take_copy */)
      //Gtk::TreeModel::Path path_dragged_row;
      //Gtk::TreeModel::Path::get_from_selection_data(selection_data, refThis,
      //path_dragged_row);

      return Gtk::TreeStore::row_drop_possible_vfunc(dest, selection_data);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Αναδυόμενο μενού περιεχομένων

Αυτό το παράδειγμα μοιάζει πολύ με το παράδειγμα ListStore, αλλά παράγει μια προσαρμοσμένη TreeView για να επικαλύψει το `button_press_event` και επίσης να ενθυλακώσει τον κώδικα προτύπου δένδρου στην παραγόμενη κλάση μας. Δείτε την ενότητα Αναδυόμενο μενού περιεχομένων προβολής δένδρου.

Προβολή δένδρου - Αναδυόμενο μενού περιεχομένων

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "treeview_withpopup.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      TreeView_WithPopup m_TreeView;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `treeview_withpopup.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_TREEVIEW_WITHPOPUP_H
    #define GTKMM_EXAMPLE_TREEVIEW_WITHPOPUP_H

    #include <gtkmm.h>

    class TreeView_WithPopup : public Gtk::TreeView
    {
    public:
      TreeView_WithPopup();
      virtual ~TreeView_WithPopup();

    protected:
      // Override Signal handler:
      // Alternatively, use signal_button_press_event().connect_notify()
      bool on_button_press_event(GdkEventButton* button_event) override;

      //Signal handler for popup menu items:
      void on_menu_file_popup_generic();

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); }

        Gtk::TreeModelColumn<unsigned int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumns m_Columns;

      //The Tree model:
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;

      Gtk::Menu m_Menu_Popup;
    };

    #endif //GTKMM_EXAMPLE_TREEVIEW_WITHPOPUP_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Gtk::TreeView (ListStore) example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TreeView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

File: `treeview_withpopup.cc` (For use with gtkmm 3, not gtkmm 2)

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

    TreeView_WithPopup::TreeView_WithPopup()
    {
      //Create the Tree model:
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      set_model(m_refTreeModel);

      //Fill the TreeView's model
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "right-click on this";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "or this";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "or this, for a popup context menu";

      //Add the TreeView's view columns:
      append_column("ID", m_Columns.m_col_id);
      append_column("Name", m_Columns.m_col_name);

      //Fill popup menu:
      auto item = Gtk::manage(new Gtk::MenuItem("_Edit", true));
      item->signal_activate().connect(
        sigc::mem_fun(*this, &TreeView_WithPopup::on_menu_file_popup_generic) );
      m_Menu_Popup.append(*item);

      item = Gtk::manage(new Gtk::MenuItem("_Process", true));
      item->signal_activate().connect(
        sigc::mem_fun(*this, &TreeView_WithPopup::on_menu_file_popup_generic) );
      m_Menu_Popup.append(*item);

      item = Gtk::manage(new Gtk::MenuItem("_Remove", true));
      item->signal_activate().connect(
        sigc::mem_fun(*this, &TreeView_WithPopup::on_menu_file_popup_generic) );
      m_Menu_Popup.append(*item);

      m_Menu_Popup.accelerate(*this);
      m_Menu_Popup.show_all(); //Show all menu items when the menu pops up
    }

    TreeView_WithPopup::~TreeView_WithPopup()
    {
    }

    bool TreeView_WithPopup::on_button_press_event(GdkEventButton* button_event)
    {
      bool return_value = false;

      //Call base class, to allow normal handling,
      //such as allowing the row to be selected by the right-click:
      return_value = TreeView::on_button_press_event(button_event);

      //Then do our custom stuff:
      if( (button_event->type == GDK_BUTTON_PRESS) && (button_event->button == 3) )
      {
        m_Menu_Popup.popup(button_event->button, button_event->time);
      }

      return return_value;
    }

    void TreeView_WithPopup::on_menu_file_popup_generic()
    {
      std::cout << "A popup menu item was selected." << std::endl;

      auto refSelection = get_selection();
      if(refSelection)
      {
        Gtk::TreeModel::iterator iter = refSelection->get_selected();
        if(iter)
        {
          int id = (*iter)[m_Columns.m_col_id];
          std::cout << "  Selected ID=" << id << std::endl;
        }
      }
    }

## Σύνθετα πλαίσια

Το γραφικό συστατικό ComboBox προσφέρει μια λίστα (ή δένδρο) των επιλογών σε ένα πτυσσόμενο μενού. Αν είναι κατάλληλο, μπορεί να εμφανίσει πρόσθετες πληροφορίες για κάθε στοιχείο, όπως κείμενο, εικόνα, πλαίσιο ελέγχου, ή μια γραμμή προόδου. Το γραφικό συστατικό ComboBox συνήθως περιορίζει τον χρήστη στις διαθέσιμες επιλογές, αλλά μπορεί προαιρετικά να έχει μια Entry, που επιτρέπει στον χρήστη να εισάγει ελεύθερο κείμενο αν καμιά από τις διαθέσιμες επιλογές δεν είναι κατάλληλη.

Η λίστα παρέχεται μέσα από TreeModel και οι στήλες από αυτό το πρότυπο προστίθενται στην προβολή του ComboBox με τη μέθοδο ComboBox::pack_start(). Αυτό παρέχει ευελιξία και ασφάλεια τύπου χρόνου μεταγλώττισης, αλλά η κλάση ComboBoxText παρέχει μια πιο απλή εξειδίκευση με βάση το κείμενο σε περίπτωση που η ευελιξία δεν απαιτείται.

Reference

### Το πρότυπο

Το πρότυπο για ένα ComboBox μπορεί να οριστεί και να συμπληρωθεί ακριβώς όπως μια TreeView. Για παράδειγμα, μπορείτε να παράξετε μια κλάση σύνθετου πλαισίου με έναν ακέραιο και μια στήλη κειμένου, ως εξής:

    ModelColumns()
    { add(m_col_id); add(m_col_name); }

      Gtk::TreeModelColumn<int> m_col_id;
      Gtk::TreeModelColumn<Glib::ustring> m_col_name;
    };

    ModelColumns m_columns;

Μετά την προσάρτηση των γραμμών σε αυτό το πρότυπο, θα πρέπει να δώσετε το πρότυπο στην ComboBox με τη μέθοδο set_model(). Έπειτα χρησιμοποιήστε τις μεθόδους pack_start() ή pack_end() για να ορίσετε ποιες στήλες θα εμφανίζονται στο ComboBox. Όπως στην περίπτωση της TreeView μπορείτε είτε να χρησιμοποιήσετε την προεπιλεγμένη απόδοση κελιού περνώντας την TreeModelColumn στις μεθόδους συσκευασίας, ή μπορείτε να δημιουργήσετε μια συγκεκριμένη CellRenderer και να ορίσετε μια ειδική απεικόνιση με είτε add_attribute() ή set_cell_data_func(). Σημειώστε ότι, αυτές οι μέθοδοι είναι στη βασική κλάση CellLayout.

### Το επιλεγμένο στοιχείο

Για να βρείτε ποιο στοιχείο, αν υπάρχει, έχει επιλέξει ο χρήστης από το ComboBox, καλέστε ComboBox::get_active(). Αυτό επιστρέφει μια TreeModel::iterator, που μπορείτε να απομακρύνετε την αναφορά σε μια Row για να διαβάσετε τις τιμές στις στήλες σας. Για παράδειγμα, μπορείτε να διαβάσετε μια ακέραιη τιμή αναγνωριστικού από το πρότυπο, αν και έχετε επιλέξει να εμφανίζεται μόνο σε ανθρωπίνως αναγνώσιμη περιγραφή στο σύνθετο πλαίσιο. Για παράδειγμα:

    Gtk::TreeModel::iterator iter = m_Combo.get_active();
    if(iter)
    {
      Gtk::TreeModel::Row row = *iter;

      //Λήψη των δεδομένων για την επιλεγμένη γραμμή, χρησιμοποιώντας τη
      //γνώση μας του προτύπου δένδρου:
      int id = row[m_Columns.m_col_id];
      set_something_id_chosen(id); //Η δικιά σας συνάρτηση.
    }
    else
      set_nothing_chosen(); //Η δικιά σας συνάρτηση.

### Απάντηση σε αλλαγές

Μπορεί να χρειαστείτε να αντιδράσετε σε κάθε αλλαγή της επιλογής στο ComboBox, για παράδειγμα να ενημερώσετε άλλα γραφικά συστατικά. Για να γίνει αυτό, θα πρέπει να χειριστείτε το σήμα `changed`. Για παράδειγμα:

    m_combo.signal_changed().connect( sigc::mem_fun(*this,
          &ExampleWindow::on_combo_changed) );

### Πλήρες παράδειγμα

ComboBox

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm/window.h>
    #include <gtkmm/comboboxtext.h>
    #include <gtkmm/liststore.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      void on_cell_data_extra(const Gtk::TreeModel::const_iterator& iter);

      //Signal handlers:
      void on_combo_changed();

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); add(m_col_extra);}

        Gtk::TreeModelColumn<int> m_col_id;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
        Gtk::TreeModelColumn<Glib::ustring> m_col_extra;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::ComboBox m_Combo;
      Gtk::CellRendererText m_cell;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    {
      set_title("ComboBox example");

      //Create the Tree model:
      //m_refTreeModel = Gtk::TreeStore::create(m_Columns);
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_Combo.set_model(m_refTreeModel);

      //Fill the ComboBox's Tree Model:
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 1;
      row[m_Columns.m_col_name] = "Billy Bob";
      row[m_Columns.m_col_extra] = "something";
      m_Combo.set_active(row);
      /*
      Gtk::TreeModel::Row childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 11;
      childrow[m_Columns.m_col_name] = "Billy Bob Junior";

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 12;
      childrow[m_Columns.m_col_name] = "Sue Bob";
      */

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 2;
      row[m_Columns.m_col_name] = "Joey Jojo";
      row[m_Columns.m_col_extra] = "yadda";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = 3;
      row[m_Columns.m_col_name] = "Rob McRoberts";
      row[m_Columns.m_col_extra] = "";

      /*
      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 31;
      childrow[m_Columns.m_col_name] = "Xavier McRoberts";
      */

      //Add the model columns to the Combo (which is a kind of view),
      //rendering them in the default way:
      m_Combo.pack_start(m_Columns.m_col_id);
      m_Combo.pack_start(m_Columns.m_col_name);

      //An example of adding a cell renderer manually,
      //instead of using pack_start(model_column)
      //so we have more control:
      m_Combo.set_cell_data_func(m_cell,
        sigc::mem_fun(*this, &ExampleWindow::on_cell_data_extra));
      m_Combo.pack_start(m_cell);

      //Add the ComboBox to the window.
      add(m_Combo);

      //Connect signal handler:
      m_Combo.signal_changed().connect( sigc::mem_fun(*this, &ExampleWindow::on_combo_changed) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_cell_data_extra(const Gtk::TreeModel::const_iterator& iter)
    {
      auto row = *iter;
      const Glib::ustring extra = row[m_Columns.m_col_extra];

      //Some arbitrary logic just to show that this is where you can do such things:

      //Transform the value, deciding how to represent it as text:
      if(extra.empty())
        m_cell.property_text() = "(none)";
      else
        m_cell.property_text() = "-" + extra + "-";

      //Change other cell renderer properties too:
      m_cell.property_foreground() = (extra == "yadda" ? "red" : "green");
    }

    void ExampleWindow::on_combo_changed()
    {
      Gtk::TreeModel::iterator iter = m_Combo.get_active();
      if(iter)
      {
        Gtk::TreeModel::Row row = *iter;
        if(row)
        {
          //Get the data for the selected row, using our knowledge of the tree
          //model:
          int id = row[m_Columns.m_col_id];
          Glib::ustring name = row[m_Columns.m_col_name];

          std::cout << " ID=" << id << ", name=" << name << std::endl;
        }
      }
      else
        std::cout << "invalid iter" << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Απλό παράδειγμα κειμένου

ComboBoxText

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

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

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      //Child widgets:
      Gtk::ComboBoxText m_Combo;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    {
      set_title("ComboBoxText example");

      //Fill the combo:
      m_Combo.append("something");
      m_Combo.append("something else");
      m_Combo.append("something or other");
      m_Combo.set_active(1);

      add(m_Combo);

      //Connect signal handler:
      m_Combo.signal_changed().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_combo_changed) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_combo_changed()
    {
      Glib::ustring text = m_Combo.get_active_text();
      if(!(text.empty()))
        std::cout << "Combo changed: " << text << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### ComboBox με μια καταχώριση

Μια ComboBox μπορεί να περιέχει ένα γραφικό συστατικό Entry για εισαγωγή ελεύθερου κειμένου, ορίζοντας `true` για την παράμετρο του κατασκευαστή `has_entry`.

#### Η στήλη κειμένου

So that the Entry can interact with the drop-down list of choices, you must specify which of your model columns is the text column, with set_entry_text_column(). For instance:

    m_combo.set_entry_text_column(m_columns.m_col_name);

Όταν διαλέγετε μια επιλογή από το πτυσσόμενο μενού, η τιμή από αυτήν τη στήλη θα τοποθετηθεί στην Entry.

#### Η καταχώριση

Επειδή ο χρήστης μπορεί να εισάγει ένα ελεύθερο κείμενο, μια ενεργή γραμμή προτύπου δεν είναι αρκετή για να πει ποιο κείμενο έχει εισάγει ο χρήστης. Συνεπώς, θα πρέπει να ανακτήσετε το γραφικό συστατικό Entry με τη μέθοδο ComboBox::get_entry() και να καλέσετε get_text() σε αυτό.

#### Απάντηση σε αλλαγές

When the user enters arbitrary text, it may not be enough to connect to the `changed` signal, which is emitted for every typed character. It is not emitted when the user presses the Enter key. Pressing the Enter key or moving the keyboard focus to another widget may signal that the user has finished entering text. To be notified of these events, connect to the Entry's `activate` and `focus_out_event` signals, like so

    Gtk::Entry* entry = m_Combo.get_entry();
    if (entry)
    {
      // The Entry shall receive focus-out events.
      entry->add_events(Gdk::FOCUS_CHANGE_MASK);

      // Alternatively you can connect to m_Combo.signal_changed().
      entry->signal_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_entry_changed) );

      entry->signal_activate().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_entry_activate) );

      entry->signal_focus_out_event().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_entry_focus_out_event) );
    }

The `changed` signals of ComboBox and Entry are both emitted for every change. It doesn't matter which one you connect to. But only Entry's `focus_out_event` signal is useful here.

Τα συμβάντα Χ περιγράφονται πιο λεπτομερώς στην ενότητα Σήματα συμβάντων Χ στο παράρτημα.

#### Πλήρες παράδειγμα

ComboBox με καταχώριση

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm/window.h>
    #include <gtkmm/combobox.h>
    #include <gtkmm/liststore.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_entry_changed();
      void on_entry_activate();
      bool on_entry_focus_out_event(GdkEventFocus* event);

      //Signal connection:
      sigc::connection m_ConnectionFocusOut;

      //Tree model columns:
      class ModelColumns : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumns()
        { add(m_col_id); add(m_col_name); }

        Gtk::TreeModelColumn<Glib::ustring> m_col_id; //The data to choose - this must be text.
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumns m_Columns;

      //Child widgets:
      Gtk::ComboBox m_Combo;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_Combo(true /* has_entry */)
    {
      set_title("ComboBox example");

      //Create the Tree model:
      //m_refTreeModel = Gtk::TreeStore::create(m_Columns);
      m_refTreeModel = Gtk::ListStore::create(m_Columns);
      m_Combo.set_model(m_refTreeModel);

      //Fill the ComboBox's Tree Model:
      Gtk::TreeModel::Row row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = "1";
      row[m_Columns.m_col_name] = "Billy Bob";
      /*
      Gtk::TreeModel::Row childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 11;
      childrow[m_Columns.m_col_name] = "Billy Bob Junior";

      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 12;
      childrow[m_Columns.m_col_name] = "Sue Bob";
      */

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = "2";
      row[m_Columns.m_col_name] = "Joey Jojo";

      row = *(m_refTreeModel->append());
      row[m_Columns.m_col_id] = "3";
      row[m_Columns.m_col_name] = "Rob McRoberts";

      /*
      childrow = *(m_refTreeModel->append(row.children()));
      childrow[m_Columns.m_col_id] = 31;
      childrow[m_Columns.m_col_name] = "Xavier McRoberts";
      */

      //Add the model columns to the Combo (which is a kind of view),
      //rendering them in the default way:
      //This is automatically rendered when we use set_entry_text_column().
      //m_Combo.pack_start(m_Columns.m_col_id);
      m_Combo.pack_start(m_Columns.m_col_name);

      m_Combo.set_entry_text_column(m_Columns.m_col_id);
      m_Combo.set_active(1);

      //Add the ComboBox to the window.
      add(m_Combo);

      //Connect signal handlers:
      auto entry = m_Combo.get_entry();
      if (entry)
      {
        // The Entry shall receive focus-out events.
        entry->add_events(Gdk::FOCUS_CHANGE_MASK);
        // Alternatively you can connect to m_Combo.signal_changed().
        entry->signal_changed().connect(sigc::mem_fun(*this,
          &ExampleWindow::on_entry_changed) );
        entry->signal_activate().connect(sigc::mem_fun(*this,
          &ExampleWindow::on_entry_activate) );
        m_ConnectionFocusOut = entry->signal_focus_out_event().
          connect(sigc::mem_fun(*this, &ExampleWindow::on_entry_focus_out_event) );
      }
      else
        std::cout << "No Entry ???" << std::endl;

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
      // The focus_out signal may be emitted while m_Combo is being destructed.
      // The signal handler can generate critical messages, if it's called when
      // m_Combo has been partly destructed.
      m_ConnectionFocusOut.disconnect();
    }

    void ExampleWindow::on_entry_changed()
    {
      auto entry = m_Combo.get_entry();
      if (entry)
      {
        std::cout << "on_entry_changed(): Row=" << m_Combo.get_active_row_number()
          << ", ID=" << entry->get_text() << std::endl;
      }
    }

    void ExampleWindow::on_entry_activate()
    {
      auto entry = m_Combo.get_entry();
      if (entry)
      {
        std::cout << "on_entry_activate(): Row=" << m_Combo.get_active_row_number()
          << ", ID=" << entry->get_text() << std::endl;
      }
    }

    bool ExampleWindow::on_entry_focus_out_event(GdkEventFocus* /* event */)
    {
      auto entry = m_Combo.get_entry();
      if (entry)
      {
        std::cout << "on_entry_focus_out_event(): Row=" << m_Combo.get_active_row_number()
          << ", ID=" << entry->get_text() << std::endl;
        return true;
      }
      return false;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Απλό παράδειγμα κειμένου

ComboBoxText με καταχώριση

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

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

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_combo_changed();
      void on_entry_activate();
      bool on_entry_focus_out_event(GdkEventFocus* event);

      //Signal connection:
      sigc::connection m_ConnectionFocusOut;

      //Child widgets:
      Gtk::ComboBoxText m_Combo;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_Combo(true /* has_entry */)
    {
      set_title("ComboBoxText example");

      //Fill the combo:
      m_Combo.append("something");
      m_Combo.append("something else");
      m_Combo.append("something or other");
      m_Combo.set_active(0);

      add(m_Combo);

      //Connect signal handlers:
      auto entry = m_Combo.get_entry();
      // Alternatively you can connect to entry->signal_changed().
      m_Combo.signal_changed().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_combo_changed) );
      if (entry)
      {
        // The Entry shall receive focus-out events.
        entry->add_events(Gdk::FOCUS_CHANGE_MASK);
        entry->signal_activate().connect(sigc::mem_fun(*this,
          &ExampleWindow::on_entry_activate) );
        m_ConnectionFocusOut = entry->signal_focus_out_event().
          connect(sigc::mem_fun(*this, &ExampleWindow::on_entry_focus_out_event) );
      }
      else
        std::cout << "No Entry ???" << std::endl;

      m_Combo.property_has_frame() = false;
      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
      // The focus_out signal may be emitted while m_Combo is being destructed.
      // The signal handler can generate critical messages, if it's called when
      // m_Combo has been partly destructed.
      m_ConnectionFocusOut.disconnect();
    }

    void ExampleWindow::on_combo_changed()
    {
      std::cout << "on_combo_changed(): Row=" << m_Combo.get_active_row_number()
        << ", Text=" << m_Combo.get_active_text() << std::endl;
    }

    void ExampleWindow::on_entry_activate()
    {
      std::cout << "on_entry_activate(): Row=" << m_Combo.get_active_row_number()
        << ", Text=" << m_Combo.get_active_text() << std::endl;
    }

    bool ExampleWindow::on_entry_focus_out_event(GdkEventFocus* /* event */)
    {
      std::cout << "on_entry_focus_out_event(): Row=" << m_Combo.get_active_row_number()
        << ", Text=" << m_Combo.get_active_text() << std::endl;
      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## TextView

Το γραφικό συστατικό TextView μπορεί να χρησιμοποιηθεί για την εμφάνιση και επεξεργασία μεγάλων ποσοτήτων μορφοποιημένου κειμένου. Όπως η TreeView, έχει μια σχεδίαση προτύπου/προβολής. Σε αυτήν την περίπτωση η TextBuffer είναι το πρότυπο.

### Η ενδιάμεση μνήμη

Gtk::TextBuffer είναι ένα πρότυπο που περιέχει τα δεδομένα για την Gtk::TextView, όπως η Gtk::TreeModel χρησιμοποιείται από Gtk::TreeView. Αυτό επιτρέπει δύο ή περισσότερες Gtk::TextViews να μοιραστούν την ίδια TextBuffer και επιτρέπει αυτά τα TextBuffers να εμφανίζονται ελαφρά διαφορετικά. Ή μπορείτε να διατηρήσετε αρκετές Gtk::TextBuffers και να επιλέξετε να εμφανίσετε κάθε μια σε διαφορετικούς χρόνους στο ίδιο γραφικό συστατικό Gtk::TextView.

Η TextView δημιουργεί τη δική της προεπιλογή TextBuffer, που μπορείτε να προσπελάσετε μέσα από τη μέθοδο get_buffer().

Reference

#### Επαναλήπτες

#### Ετικέτες και μορφοποίηση

##### Ετικέτες

Για να ορίσετε ότι κάποιο κείμενο στην ενδιάμεση μνήμη πρέπει να έχει ειδική μορφοποίηση, πρέπει να ορίσετε μια ετικέτα που θα κρατήσει αυτήν την πληροφορία μορφοποίησης και έπειτα θα εφαρμόσει αυτήν την ετικέτα στην περιοχή του κειμένου. Για παράδειγμα, για τον ορισμό της ετικέτας και των ιδιοτήτων της:

    Glib::RefPtr<Gtk::TextBuffer::Tag> refTagMatch =
        Gtk::TextBuffer::Tag::create();
    refTagMatch->property_background() = "orange";

Μπορείτε να ορίσετε ένα όνομα για την Tag, όταν χρησιμοποιείτε τη μέθοδο create(), αλλά δεν είναι απαραίτητο.

Η κλάση Tag έχει πολλές άλλες ιδιότητες.

Reference

##### TagTable

Κάθε Gtk::TextBuffer χρησιμοποιεί μια Gtk::TextBuffer::TagTable, που περιέχει τις Tags για αυτή την ενδιάμεση μνήμη. 2 ή περισσότερες TextBuffers μοιράζονται την ίδια TagTable. Όταν δημιουργείτε Tags θα πρέπει να τις προσθέσετε στη TagTable. Για παράδειγμα:

    Glib::RefPtr<Gtk::TextBuffer::TagTable> refTagTable =
        Gtk::TextBuffer::TagTable::create();
    refTagTable->add(refTagMatch);
    //Ας ελπίσουμε ότι μια μελλοντική έκδοση του gtkmm θα έχει μια μέθοδο set_tag_table(),
    //για χρήση μετά τη δημιουργία της ενδιάμεσης μνήμης.
    Glib::RefPtr<Gtk::TextBuffer> refBuffer =
        Gtk::TextBuffer::create(refTagTable);

Μπορείτε επίσης να χρησιμοποιήσετε την get_tag_table() για να πάρετε και ίσως να τροποποιήσετε στη TextBuffer, την προεπιλεγμένη TagTable αντί για δημιουργία μιας σαφώς.

Reference

##### Εφαρμογή ετικετών

Αν έχετε δημιουργήσει μια Tag και την προσθέσατε στην TagTable, μπορεί να εφαρμόσετε αυτήν την ετικέτα σε μέρος της TextBuffer έτσι ώστε κάποιο κείμενο να εμφανίζεται με αυτήν τη μορφοποίηση. Ορίζετε την αρχή και το τέλος της περιοχής του κειμένου ορίζοντας Gtk::TextBuffer::iterators. Για παράδειγμα:

    refBuffer->apply_tag(refTagMatch, iterRangeStart, iterRangeStop);

Or you could specify the tag when first inserting the text:

    refBuffer->insert_with_tag(iter, "Some text", refTagMatch);

Μπορείτε να εφαρμόσετε περισσότερες από μία Tag στο ίδιο κείμενο, χρησιμοποιώντας την apply_tag() περισσότερο από μια φορά, ή χρησιμοποιώντας την insert_with_tags(). Οι Tags μπορεί να ορίζουν διαφορετικές τιμές για τις ίδιες ιδιότητες, αλλά μπορείτε να επιλύσετε αυτές τις συγκρούσεις χρησιμοποιώντας Tag::set_priority().

#### Σημάδια

Οι επαναλήπτες TextBuffer είναι γενικά άκυροι όταν το κείμενο αλλάζει, αλλά μπορείτε να χρησιμοποιήσετε μια Gtk::TextBuffer::Mark για να θυμάται μια θέση σε αυτές τις καταστάσεις. Για παράδειγμα,

    Glib::RefPtr<Gtk::TextBuffer::Mark> refMark =
        refBuffer->create_mark(iter);

Μπορείτε έπειτα να χρησιμοποιήσετε τη μέθοδο get_iter() αργότερα για να δημιουργήσετε έναν επαναλήπτη για τη νέα θέση της Mark.

Υπάρχουν δύο ενσωματωμένες Marks - `insert` και `select_bound`, που μπορείτε να προσπελάσετε στην TextBuffer με τις μεθόδους get_insert() και get_selection_bound().

Reference

#### Η προβολή

Όπως αναφέρθηκε παραπάνω, κάθε TextView έχει μια TextBuffer και μία ή περισσότερες TextView μπορούν να μοιραστούν την ίδια TextBuffer.

Όπως η TreeView, θα πρέπει προφανώς να βάλετε την TextView σας μέσα σε μια ScrolledWindow για να επιτρέψετε στον χρήστη να δει και να μετακινήσει ολόγυρα όλη την περιοχή κειμένου με γραμμές κύλισης.

Reference

##### Προεπιλεγμένη μορφοποίηση

Η TextView έχει ποικίλες μεθόδους που επιτρέπουν την αλλαγή της παρουσίασης της ενδιάμεσης μνήμης για αυτήν τη συγκεκριμένη προβολή. Μερικές από αυτές μπορεί να αντικατασταθούν από τις Gtk::TextTags στην ενδιάμεση μνήμη, αν ορίζουν τα ίδια πράγματα. Για παράδειγμα, set_left_margin(), set_right_margin(), set_indent(), κλπ.

##### Κύλιση

Η Gtk::TextView έχει ποικίλες μεθόδους scroll_to_*(). Αυτές επιτρέπουν να εξασφαλίσετε ότι το συγκεκριμένο μέρος της ενδιάμεσης μνήμης του κειμένου είναι ορατό. Για παράδειγμα, το γνώρισμα εύρεσης της εφαρμογή σας μπορεί να χρησιμοποιήσει την Gtk::TextView::scroll_to_iter() για να εμφανίσει το ευρεθέν κείμενο.

### Γραφικά συστατικά και ChildAnchors

Μπορείτε να ενσωματώσετε γραφικά συστατικά, όπως Gtk::Buttons, στο κείμενο. Κάθε τέτοιο θυγατρικό γραφικό συστατικό χρειάζεται μια ChildAnchor. Οι ChildAnchors συσχετίζονται με την iterators. Για παράδειγμα, για να δημιουργήσετε μια θυγατρική αγκύρωση σε μια ειδική θέση, χρησιμοποιήστε Gtk::TextBuffer::create_child_anchor():

    Glib::RefPtr<Gtk::TextChildAnchor> refAnchor =
        refBuffer->create_child_anchor(iter);

Έπειτα, για να προσθέσετε ένα γραφικό συστατικό σε αυτή τη θέση, χρησιμοποιήστε Gtk::TextView::add_child_at_anchor():

    m_TextView.add_child_at_anchor(m_Button, refAnchor);

Reference

### Παραδείγματα

#### Απλό παράδειγμα

TextView

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      void fill_buffers();

      //Signal handlers:
      void on_button_quit();
      void on_button_buffer1();
      void on_button_buffer2();

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TextView m_TextView;

      Glib::RefPtr<Gtk::TextBuffer> m_refTextBuffer1, m_refTextBuffer2;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit, m_Button_Buffer1, m_Button_Buffer2;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("_Quit", true),
      m_Button_Buffer1("Use buffer 1"),
      m_Button_Buffer2("Use buffer 2")
    {
      set_title("Gtk::TextView example");
      set_border_width(5);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the TreeView, inside a ScrolledWindow, with the button underneath:
      m_ScrolledWindow.add(m_TextView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);

      //Add buttons:
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Buffer1, Gtk::PACK_SHRINK);
      m_ButtonBox.pack_start(m_Button_Buffer2, Gtk::PACK_SHRINK);
      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_spacing(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);

      //Connect signals:
      m_Button_Quit.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );
      m_Button_Buffer1.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_buffer1) );
      m_Button_Buffer2.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_buffer2) );

      fill_buffers();
      on_button_buffer1();

      show_all_children();
    }

    void ExampleWindow::fill_buffers()
    {
      m_refTextBuffer1 = Gtk::TextBuffer::create();
      m_refTextBuffer1->set_text("This is the text from TextBuffer #1.");

      m_refTextBuffer2 = Gtk::TextBuffer::create();
      m_refTextBuffer2->set_text(
              "This is some alternative text, from TextBuffer #2.");

    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

    void ExampleWindow::on_button_buffer1()
    {
      m_TextView.set_buffer(m_refTextBuffer1);
    }

    void ExampleWindow::on_button_buffer2()
    {
      m_TextView.set_buffer(m_refTextBuffer2);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## Μενού και Εργαλειοθήκες

There are specific APIs for menus and toolbars, but you should usually deal with them together, creating Gio::SimpleActions that you can refer to in both menus and toolbars. In this way you can handle activation of the action instead of responding to the menu and toolbar items separately. And you can enable or disable both the menu and toolbar item via the action. Gtk::Builder can create menus and toolbars.

This involves the use of the Gio::SimpleActionGroup, Gio::SimpleAction and Gtk::Builder classes, all of which should be instantiated via their create() methods, which return RefPtrs.

Alternatively, Gtk::ActionGroup, Gtk::Action and Gtk::UIManager can be used, but this is not recommended in new code. GtkAction, GtkActionGroup and GtkUIManager are deprecated in GTK+ from version 3.10. The corresponding classes in gtkmm will be deprecated in the future.

### Ενέργειες

First create the Gio::SimpleActions and add them to a Gio::SimpleActionGroup, with Gio::ActionMap::add_action(). (Gio::ActionMap is a base class of Gio::SimpleActionGroup.) Then add the action group to your window with Gtk::Widget::insert_action_group().

The arguments to add_action() specify the action's name, which is used in the menu items and toolbar buttons. You can also specify a signal handler when calling add_action(). This signal handler will be called when the action is activated via either a menu item or a toolbar button.

Για παράδειγμα:

    m_refActionGroup = Gio::SimpleActionGroup::create();

    m_refActionGroup->add_action("new", sigc::mem_fun(*this, &ExampleWindow::on_action_file_new));
    m_refActionGroup->add_action("open", sigc::mem_fun(*this, &ExampleWindow::on_action_file_open));
    m_refActionGroup->add_action("quit", sigc::mem_fun(*this, &ExampleWindow::on_action_file_quit));

    insert_action_group("example", m_refActionGroup);

If you use an Gtk::ApplicationWindow, you don't have to create your own action group. Gio::ActionGroup and Gio::ActionMap are base classes of Gtk::ApplicationWindow.

### Menubar and Toolbar

Next you should create a Gtk::Builder. At this point is also a good idea to tell the application to respond to keyboard shortcuts, by using Gtk::Application::set_accel_for_action().

Για παράδειγμα,

    Glib::RefPtr<Gtk::Builder> m_refBuilder = Gtk::Builder::create();

    app->set_accel_for_action("example.new", "<Primary>n");
    app->set_accel_for_action("example.quit", "<Primary>q");
    app->set_accel_for_action("example.copy", "<Primary>c");
    app->set_accel_for_action("example.paste", "<Primary>v");

If your main window is derived from ApplicationWindow and you instantiate your menubar with Gtk::Application::set_menubar(), then you don't have to call set_accel_for_action(). See Application Menu and Main Menu example for an example.

Then, you can define the actual visible layout of the menus and toolbars, and add the UI layout to the Builder. This "ui string" uses an XML format, in which you should mention the names of the actions that you have already created. For instance:

    const char* ui_info =
      "<interface>"
      "  <menu id='menubar'>"
      "    <submenu>"
      "      <attribute name='label' translatable='yes'>_File</attribute>"
      "      <section>"
      "        <item>"
      "          <attribute name='label' translatable='yes'>_New</attribute>"
      "          <attribute name='action'>example.new</attribute>"
      "          <attribute name='accel'>&lt;Primary&gt;n</attribute>"
      "        </item>"
      "      </section>"
      "      <section>"
      "        <item>"
      "          <attribute name='label' translatable='yes'>_Quit</attribute>"
      "          <attribute name='action'>example.quit</attribute>"
      "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
      "        </item>"
      "      </section>"
      "    </submenu>"
      "    <submenu>"
      "      <attribute name='label' translatable='yes'>_Edit</attribute>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>_Copy</attribute>"
      "        <attribute name='action'>example.copy</attribute>"
      "        <attribute name='accel'>&lt;Primary&gt;c</attribute>"
      "      </item>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>_Paste</attribute>"
      "        <attribute name='action'>example.paste</attribute>"
      "        <attribute name='accel'>&lt;Primary&gt;v</attribute>"
      "      </item>"
      "    </submenu>"
      "  </menu>"
      "</interface>";

    m_refBuilder->add_from_string(ui_info);
    m_refBuilder->add_from_resource("/toolbar/toolbar.glade");

This is where we specify the names of the menu items as they will be seen by users in the menu. Therefore, this is where you should make strings translatable, by adding `translatable='yes'`.

To instantiate a Gtk::MenuBar and Gtk::Toolbar which you can actually show, you should use the Builder::get_object() and Builder::get_widget() methods, and then add the widgets to a container. For instance:

    Glib::RefPtr<Glib::Object> object = m_refBuilder->get_object("menubar");
    Glib::RefPtr<Gio::Menu> gmenu = Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
    Gtk::MenuBar* pMenuBar = Gtk::manage(new Gtk::MenuBar(gmenu));
    m_Box.pack_start(*pMenuBar, Gtk::PACK_SHRINK);

    Gtk::Toolbar* toolbar = nullptr;
    m_refBuilder->get_widget("toolbar", toolbar);
    m_Box.pack_start(*toolbar, Gtk::PACK_SHRINK);

### Αναδυόμενα μενού

Η Menus προστέθηκε κανονικά μόλις σε ένα παράθυρο, αλλά μπορεί επίσης να εμφανιστεί προσωρινά ως το αποτέλεσμα ενός πατήματος πλήκτρου του ποντικιού. Για παράδειγμα, ένα μενού περιεχομένων μπορεί να εμφανιστεί όταν ο χρήστης πατά το δεξιό πλήκτρο ποντικιού.

Για παράδειγμα:

    Glib::ustring ui_info =
      "<interface>"
      "  <menu id='menu-examplepopup'>"
      "    <section>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>Edit</attribute>"
      "        <attribute name='action'>examplepopup.edit</attribute>"
      "      </item>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>Process</attribute>"
      "        <attribute name='action'>examplepopup.process</attribute>"
      "      </item>"
      "      <item>"
      "        <attribute name='label' translatable='yes'>Remove</attribute>"
      "        <attribute name='action'>examplepopup.remove</attribute>"
      "      </item>"
      "    </section>"
      "  </menu>"
      "</interface>";

    m_refBuilder->add_from_string(ui_info);

    Glib::RefPtr<Glib::Object> object = m_refBuilder->get_object("menu-examplepopup");
    Glib::RefPtr<Gio::Menu> gmenu = Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
    m_pMenuPopup = new Gtk::Menu(gmenu);

Για εμφάνιση του αναδυόμενου μενού, χρησιμοποιήστε τη μέθοδο Gtk::Menu's popup(), που παρέχει το αναγνωριστικό κουμπιού και τον χρόνο ενεργοποίησης, όπως παρέχεται από το σήμα `button_press_event`, που θα χρειαστείτε να χειριστείτε οπωσδήποτε. Για παράδειγμα:

    bool ExampleWindow::on_button_press_event(GdkEventButton* event)
    {
      if( (event->type == GDK_BUTTON_PRESS) && (event->button == 3) )
      {
        if(!m_pMenuPopup->get_attach_widget())
          m_pMenuPopup->attach_to_widget(*this);

        m_pMenuPopup->popup(event->button, event->time);
        return true; //It has been handled.
      }
      else
        return false;
    }

### Gio::Resource and glib-compile-resources

Applications and libraries often contain binary or textual data that is really part of the application, rather than user data. For instance Gtk::Builder `.glade` files, splashscreen images, Gio::Menu markup xml, CSS files, icons, etc. These are often shipped as files in `$datadir/appname`, or manually included as literal strings in the code.

The Gio::Resource API and the glib-compile-resources program provide a convenient and efficient alternative to this, which has some nice properties. You maintain the files as normal files, so it's easy to edit them, but during the build the files are combined into a binary bundle that is linked into the executable. This means that loading the resource files is efficient (as they are already in memory, shared with other instances) and simple (no need to check for things like I/O errors or locate the files in the filesystem). It also makes it easier to create relocatable applications.

Resource bundles are created by the glib-compile-resources program which takes an xml file that describes the bundle, and a set of files that the xml references. These are combined into a binary resource bundle.

Gio::Resource Reference

An example:

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/toolbar">
        <file preprocess="xml-stripblanks">toolbar.glade</file>
        <file>rain.png</file>
      </gresource>
    </gresources>

This will create a resource bundle with the files

- `/toolbar/toolbar.glade`

- `/toolbar/rain.png`

You can then use glib-compile-resources to compile the xml to a binary bundle that you can load with Gio::Resource::create_from_file(). However, it's more common to use the --generate-source argument to create a C source file to link directly into your application. E.g.

    $ glib-compile-resources --target=resources.c --generate-source toolbar.gresource.xml

Once a Gio::Resource has been created and registered all the data in it can be accessed globally in the process by using API calls like Gio::Resource::open_stream_from_global_resources() to stream the data or Gio::Resource::lookup_data_in_global_resources() to get a direct pointer to the data. You can also use URIs like resource:///toolbar/rain.png with Gio::File to access the resource data.

Often you don't need a Gio::Resource instance, because resource data can be loaded with methods such as Gdk::Pixbuf::create_from_resource(), Gtk::Builder::add_from_resource() and Gtk::Image::set_from_resource().

### Παραδείγματα

#### Application Menu and Main Menu example

This program contains an application menu, a menubar and a toolbar. Classes are derived from Gtk::Application and Gtk::ApplicationWindow.

App and Main Menu

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::ApplicationWindow
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      void on_menu_choices(const Glib::ustring& parameter);
      void on_menu_choices_other(int parameter);
      void on_menu_toggle();

      //Child widgets:
      Gtk::Box m_Box;

      Glib::RefPtr<Gtk::Builder> m_refBuilder;

      //Two sets of choices:
      Glib::RefPtr<Gio::SimpleAction> m_refChoice;
      Glib::RefPtr<Gio::SimpleAction> m_refChoiceOther;

      Glib::RefPtr<Gio::SimpleAction> m_refToggle;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `exampleapplication.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEAPPLICATION_H
    #define GTKMM_EXAMPLEAPPLICATION_H

    #include <gtkmm.h>

    class ExampleApplication : public Gtk::Application
    {
    protected:
      ExampleApplication();

    public:
      static Glib::RefPtr<ExampleApplication> create();

    protected:
      //Overrides of default signal handlers:
      void on_startup() override;
      void on_activate() override;

    private:
      void create_window();

      void on_window_hide(Gtk::Window* window);
      void on_menu_file_new_generic();
      void on_menu_file_quit();
      void on_menu_help_about();

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
    };

    #endif /* GTKMM_EXAMPLEAPPLICATION_H */

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : Gtk::ApplicationWindow(),
      m_Box(Gtk::ORIENTATION_VERTICAL)
    {
      set_title("Main menu example");
      set_default_size(300, 100);

      // ExampleApplication displays the menubar. Other stuff, such as a toolbar,
      // is put into the box.
      add(m_Box);

      // Create actions for menus and toolbars.
      // We can use add_action() because Gtk::ApplicationWindow derives from Gio::ActionMap.
      // This Action Map uses a "win." prefix for the actions.
      // Therefore, for instance, "win.copy", is used in ExampleApplication::on_startup()
      // to layout the menu.

      //Edit menu:
      add_action("copy", sigc::mem_fun(*this, &ExampleWindow::on_menu_others));
      add_action("paste", sigc::mem_fun(*this, &ExampleWindow::on_menu_others));
      add_action("something", sigc::mem_fun(*this, &ExampleWindow::on_menu_others));

      //Choices menus, to demonstrate Radio items,
      //using our convenience methods for string and int radio values:
      m_refChoice = add_action_radio_string("choice",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_choices), "a");

      m_refChoiceOther = add_action_radio_integer("choiceother",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_choices_other), 1);

      m_refToggle = add_action_bool("sometoggle",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_toggle), false);

      //Help menu:
      add_action("about", sigc::mem_fun(*this, &ExampleWindow::on_menu_others));

      //Create the toolbar and add it to a container widget:

      m_refBuilder = Gtk::Builder::create();

      Glib::ustring ui_info =
        "<!-- Generated with glade 3.18.3 -->"
        "<interface>"
        "  <requires lib='gtk+' version='3.4'/>"
        "  <object class='GtkToolbar' id='toolbar'>"
        "    <property name='visible'>True</property>"
        "    <property name='can_focus'>False</property>"
        "    <child>"
        "      <object class='GtkToolButton' id='toolbutton_new'>"
        "        <property name='visible'>True</property>"
        "        <property name='can_focus'>False</property>"
        "        <property name='tooltip_text' translatable='yes'>New Standard</property>"
        "        <property name='action_name'>app.newstandard</property>"
        "        <property name='icon_name'>document-new</property>"
        "      </object>"
        "      <packing>"
        "        <property name='expand'>False</property>"
        "        <property name='homogeneous'>True</property>"
        "      </packing>"
        "    </child>"
        "    <child>"
        "      <object class='GtkToolButton' id='toolbutton_quit'>"
        "        <property name='visible'>True</property>"
        "        <property name='can_focus'>False</property>"
        "        <property name='tooltip_text' translatable='yes'>Quit</property>"
        "        <property name='action_name'>app.quit</property>"
        "        <property name='icon_name'>application-exit</property>"
        "      </object>"
        "      <packing>"
        "        <property name='expand'>False</property>"
        "        <property name='homogeneous'>True</property>"
        "      </packing>"
        "    </child>"
        "  </object>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_info);
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "Building toolbar failed: " <<  ex.what();
      }

      Gtk::Toolbar* toolbar = nullptr;
      m_refBuilder->get_widget("toolbar", toolbar);
      if (!toolbar)
        g_warning("GtkToolbar not found");
      else
        m_Box.pack_start(*toolbar, Gtk::PACK_SHRINK);
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_menu_others()
    {
      std::cout << "A menu item was selected." << std::endl;
    }

    void ExampleWindow::on_menu_choices(const Glib::ustring& parameter)
    {
      //The radio action's state does not change automatically:
      m_refChoice->change_state(parameter);

      Glib::ustring message;
      if (parameter == "a")
        message = "Choice a was selected.";
      else
        message = "Choice b was selected.";

      std::cout << message << std::endl;
    }

    void ExampleWindow::on_menu_choices_other(int parameter)
    {
      //The radio action's state does not change automatically:
      m_refChoiceOther->change_state(parameter);

      Glib::ustring message;
      if (parameter == 1)
        message = "Choice 1 was selected.";
      else
        message = "Choice 2 was selected.";

      std::cout << message << std::endl;
    }

    void ExampleWindow::on_menu_toggle()
    {
      bool active = false;
      m_refToggle->get_state(active);

      //The toggle action's state does not change automatically:
      active = !active;
      m_refToggle->change_state(active);

      Glib::ustring message;
      if (active)
        message = "Toggle is active.";
      else
        message = "Toggle is not active.";

      std::cout << message << std::endl;
    }

File: `exampleapplication.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "exampleapplication.h"
    #include "examplewindow.h"
    #include <iostream>

    ExampleApplication::ExampleApplication()
    : Gtk::Application("org.gtkmm.example.main_menu")
    {
      Glib::set_application_name("Main Menu Example");
    }

    Glib::RefPtr<ExampleApplication> ExampleApplication::create()
    {
      return Glib::RefPtr<ExampleApplication>(new ExampleApplication());
    }

    void ExampleApplication::on_startup()
    {
      //Call the base class's implementation:
      Gtk::Application::on_startup();

      //Create actions for menus and toolbars.
      //We can use add_action() because Gtk::Application derives from Gio::ActionMap.

      //File|New sub menu:
      add_action("newstandard",
        sigc::mem_fun(*this, &ExampleApplication::on_menu_file_new_generic));

      add_action("newfoo",
        sigc::mem_fun(*this, &ExampleApplication::on_menu_file_new_generic));

      add_action("newgoo",
        sigc::mem_fun(*this, &ExampleApplication::on_menu_file_new_generic));

      //File menu:
      add_action("quit", sigc::mem_fun(*this, &ExampleApplication::on_menu_file_quit));

      //Help menu:
      add_action("about", sigc::mem_fun(*this, &ExampleApplication::on_menu_help_about));

      m_refBuilder = Gtk::Builder::create();

      //Layout the actions in a menubar and an application menu:
      Glib::ustring ui_info =
        "<interface>"
        "  <!-- menubar -->"
        "  <menu id='menu-example'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Standard</attribute>"
        "          <attribute name='action'>app.newstandard</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;n</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Foo</attribute>"
        "          <attribute name='action'>app.newfoo</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Goo</attribute>"
        "          <attribute name='action'>app.newgoo</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Quit</attribute>"
        "          <attribute name='action'>app.quit</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Edit</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Copy</attribute>"
        "          <attribute name='action'>win.copy</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;c</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Paste</attribute>"
        "          <attribute name='action'>win.paste</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;v</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Something</attribute>"
        "          <attribute name='action'>win.something</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Choices</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Choice _A</attribute>"
        "          <attribute name='action'>win.choice</attribute>"
        "          <attribute name='target'>a</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Choice _B</attribute>"
        "          <attribute name='action'>win.choice</attribute>"
        "          <attribute name='target'>b</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Other Choices</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Choice 1</attribute>"
        "          <attribute name='action'>win.choiceother</attribute>"
        "          <attribute name='target' type='i'>1</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Choice 2</attribute>"
        "          <attribute name='action'>win.choiceother</attribute>"
        "          <attribute name='target' type='i'>2</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Some Toggle</attribute>"
        "          <attribute name='action'>win.sometoggle</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Help</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_About</attribute>"
        "          <attribute name='action'>win.about</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "  </menu>"
        ""
        "  <!-- application menu -->"
        "  <menu id='appmenu'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Standard</attribute>"
        "          <attribute name='action'>app.newstandard</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;n</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Foo</attribute>"
        "          <attribute name='action'>app.newfoo</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>New _Goo</attribute>"
        "          <attribute name='action'>app.newgoo</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Quit</attribute>"
        "          <attribute name='action'>app.quit</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Help</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_About</attribute>"
        "          <attribute name='action'>app.about</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "  </menu>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_info);
      }
      catch (const Glib::Error& ex)
      {
        std::cerr << "Building menus failed: " << ex.what();
      }

      //Get the menubar and the app menu, and add them to the application:
      auto object = m_refBuilder->get_object("menu-example");
      auto gmenu = Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
      object = m_refBuilder->get_object("appmenu");
      auto appMenu = Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
      if (!(gmenu && appMenu)) {
        g_warning("GMenu or AppMenu not found");
      }
      else
      {
        set_app_menu(appMenu);
        set_menubar(gmenu);
      }
    }

    void ExampleApplication::on_activate()
    {
      //std::cout << "debug1: " << G_STRFUNC << std::endl;
      // The application has been started, so let's show a window.
      // A real application might want to reuse this window in on_open(),
      // when asked to open a file, if no changes have been made yet.
      create_window();
    }

    void ExampleApplication::create_window()
    {
      auto win = new ExampleWindow();

      //Make sure that the application runs for as long this window is still open:
      add_window(*win);

      //Delete the window when it is hidden.
      //That's enough for this simple example.
      win->signal_hide().connect(sigc::bind<Gtk::Window*>(
        sigc::mem_fun(*this, &ExampleApplication::on_window_hide), win));

      win->show_all();
    }

    void ExampleApplication::on_window_hide(Gtk::Window* window)
    {
      delete window;
    }

    void ExampleApplication::on_menu_file_new_generic()
    {
      std::cout << "A File|New menu item was selected." << std::endl;
    }

    void ExampleApplication::on_menu_file_quit()
    {
      std::cout << G_STRFUNC << std::endl;
      quit(); // Not really necessary, when Gtk::Widget::hide() is called.

      // Gio::Application::quit() will make Gio::Application::run() return,
      // but it's a crude way of ending the program. The window is not removed
      // from the application. Neither the window's nor the application's
      // destructors will be called, because there will be remaining reference
      // counts in both of them. If we want the destructors to be called, we
      // must remove the window from the application. One way of doing this
      // is to hide the window.
      std::vector<Gtk::Window*> windows = get_windows();
      if (windows.size() > 0)
        windows[0]->hide(); // In this simple case, we know there is only one window.
    }

    void ExampleApplication::on_menu_help_about()
    {
      std::cout << "App|Help|About was selected." << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "exampleapplication.h"

    int main(int argc, char* argv[])
    {
      auto application = ExampleApplication::create();

      // Start the application, showing the initial window,
      // and opening extra windows for any files that it is asked to open,
      // for instance as a command-line parameter.
      // run() will return when the last window has been closed by the user.
      const int status = application->run(argc, argv);
      return status;
    }

#### Κύριο παράδειγμα μενού

This program contains a menubar and a toolbar. A class is derived from Gtk::Window.

Κύριο μενού

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow(const Glib::RefPtr<Gtk::Application>& app);
      virtual ~ExampleWindow();

    private:
      //Signal handlers:
      void on_action_file_new();
      void on_action_file_quit();
      void on_action_others();
      void on_action_toggle();

      //Child widgets:
      Gtk::Box m_Box;

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gio::SimpleActionGroup> m_refActionGroup;
      Glib::RefPtr<Gio::SimpleAction> m_refActionRain;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm.h>
    #include <iostream>

    ExampleWindow::ExampleWindow(const Glib::RefPtr<Gtk::Application>& app)
    : m_Box(Gtk::ORIENTATION_VERTICAL)
    {
      set_title("main_menu example");
      set_default_size(200, 200);

      add(m_Box); //We can put a MenuBar at the top of the box and other stuff below it.

      //Define the actions:
      m_refActionGroup = Gio::SimpleActionGroup::create();

      m_refActionGroup->add_action("new",
        sigc::mem_fun(*this, &ExampleWindow::on_action_file_new) );
      m_refActionGroup->add_action("open",
        sigc::mem_fun(*this, &ExampleWindow::on_action_others) );

      m_refActionRain = m_refActionGroup->add_action_bool("rain",
        sigc::mem_fun(*this, &ExampleWindow::on_action_toggle),
        false);

      m_refActionGroup->add_action("quit",
        sigc::mem_fun(*this, &ExampleWindow::on_action_file_quit) );

      m_refActionGroup->add_action("cut",
        sigc::mem_fun(*this, &ExampleWindow::on_action_others) );
      m_refActionGroup->add_action("copy",
        sigc::mem_fun(*this, &ExampleWindow::on_action_others) );
      m_refActionGroup->add_action("paste",
        sigc::mem_fun(*this, &ExampleWindow::on_action_others) );

      insert_action_group("example", m_refActionGroup);

      //Define how the actions are presented in the menus and toolbars:
      m_refBuilder = Gtk::Builder::create();

      //Layout the actions in a menubar and toolbar:
      const char* ui_info =
        "<interface>"
        "  <menu id='menubar'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_New</attribute>"
        "          <attribute name='action'>example.new</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;n</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Open</attribute>"
        "          <attribute name='action'>example.open</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;o</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Rain</attribute>"
        "          <attribute name='action'>example.rain</attribute>"
        "        </item>"
        "      </section>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Quit</attribute>"
        "          <attribute name='action'>example.quit</attribute>"
        "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_Edit</attribute>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_Cut</attribute>"
        "        <attribute name='action'>example.cut</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;x</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_Copy</attribute>"
        "        <attribute name='action'>example.copy</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;c</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_Paste</attribute>"
        "        <attribute name='action'>example.paste</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;v</attribute>"
        "      </item>"
        "    </submenu>"
        "  </menu>"
        "</interface>";

      // When the menubar is a child of a Gtk::Window, keyboard accelerators are not
      // automatically fetched from the Gio::Menu.
      // See the examples/book/menus/main_menu example for an alternative way of
      // adding the menubar when using Gtk::ApplicationWindow.
      // Gtk::Application::set_accel_for_action() is new in gtkmm 3.11.9.
      app->set_accel_for_action("example.new", "<Primary>n");
      app->set_accel_for_action("example.open", "<Primary>o");
      app->set_accel_for_action("example.quit", "<Primary>q");
      app->set_accel_for_action("example.cut", "<Primary>x");
      app->set_accel_for_action("example.copy", "<Primary>c");
      app->set_accel_for_action("example.paste", "<Primary>v");

      try
      {
        m_refBuilder->add_from_string(ui_info);
        m_refBuilder->add_from_resource("/toolbar/toolbar.glade");
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "Building menus and toolbar failed: " <<  ex.what();
      }

      //Get the menubar:
      auto object = m_refBuilder->get_object("menubar");
      auto gmenu = Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
      if (!gmenu)
        g_warning("GMenu not found");
      else
      {
        auto pMenuBar = Gtk::manage(new Gtk::MenuBar(gmenu));

        //Add the MenuBar to the window:
        m_Box.pack_start(*pMenuBar, Gtk::PACK_SHRINK);
      }

      //Get the toolbar and add it to a container widget:
      Gtk::Toolbar* toolbar = nullptr;
      m_refBuilder->get_widget("toolbar", toolbar);
      if (!toolbar)
        g_warning("GtkToolbar not found");
      else
        m_Box.pack_start(*toolbar, Gtk::PACK_SHRINK);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_action_file_quit()
    {
      hide(); //Closes the main window to stop the app->run().
    }

    void ExampleWindow::on_action_file_new()
    {
       std::cout << "A File|New menu item was selected." << std::endl;
    }

    void ExampleWindow::on_action_others()
    {
      std::cout << "A menu item was selected." << std::endl;
    }

    void ExampleWindow::on_action_toggle()
    {
      std::cout << "The toggle menu item was selected." << std::endl;

      bool active = false;
      m_refActionRain->get_state(active);

      //The toggle action's state does not change automatically:
      active = !active;
      m_refActionRain->change_state(active);

      Glib::ustring message;
      if(active)
        message = "Toggle is active.";
      else
        message = "Toggle is not active";

      std::cout << message << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <gtkmm.h>
    #include "examplewindow.h"

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window(app);

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

File: `toolbar.gresource.xml` (For use with gtkmm 3, not gtkmm 2)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/toolbar">
        <file preprocess="xml-stripblanks">toolbar.glade</file>
        <file>rain.png</file>
      </gresource>
    </gresources>

#### Αναδυόμενο παράδειγμα μενού

Αναδυόμενο μενού

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      bool on_button_press_event(GdkEventButton* button_event) override;

      void on_menu_file_popup_generic();

      //Child widgets:
      Gtk::Box m_Box;
      Gtk::EventBox m_EventBox;
      Gtk::Label m_Label;

      Glib::RefPtr<Gtk::Builder> m_refBuilder;

      Gtk::Menu* m_pMenuPopup;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_Box(Gtk::ORIENTATION_VERTICAL),
      m_Label("Right-click to see the popup menu."),
      m_pMenuPopup(nullptr)
    {
      set_title("popup example");
      set_default_size(200, 200);

      add(m_Box);

      //Add an event box that can catch button_press events:
      m_Box.pack_start(m_EventBox);
      m_EventBox.signal_button_press_event().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_press_event) );

      m_EventBox.add(m_Label);

      //Create actions:

      //Fill menu:

      auto refActionGroup =
        Gio::SimpleActionGroup::create();

      //File|New sub menu:
      //These menu actions would normally already exist for a main menu, because a
      //context menu should not normally contain menu items that are only available
      //via a context menu.

      refActionGroup->add_action("edit",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic));

      refActionGroup->add_action("process", //TODO: How to specify "<control>P" as an accelerator.
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic));

      refActionGroup->add_action("remove",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_popup_generic));

      insert_action_group("examplepopup", refActionGroup);

      m_refBuilder = Gtk::Builder::create();

      //Layout the actions in a menubar and toolbar:
      Glib::ustring ui_info =
        "<interface>"
        "  <menu id='menu-examplepopup'>"
        "    <section>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>Edit</attribute>"
        "        <attribute name='action'>examplepopup.edit</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>Process</attribute>"
        "        <attribute name='action'>examplepopup.process</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>Remove</attribute>"
        "        <attribute name='action'>examplepopup.remove</attribute>"
        "      </item>"
        "    </section>"
        "  </menu>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menus failed: " <<  ex.what();
      }

      //Get the menu:
      auto object =
        m_refBuilder->get_object("menu-examplepopup");
      auto gmenu =
        Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
      if(!gmenu)
        g_warning("GMenu not found");

      m_pMenuPopup = new Gtk::Menu(gmenu);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_menu_file_popup_generic()
    {
       std::cout << "A popup menu item was selected." << std::endl;
    }

    bool ExampleWindow::on_button_press_event(GdkEventButton* button_event)
    {
      if( (button_event->type == GDK_BUTTON_PRESS) && (button_event->button == 3) )
      {
        if(!m_pMenuPopup->get_attach_widget())
        {
          m_pMenuPopup->attach_to_widget(*this);
        }

        if(m_pMenuPopup)
          m_pMenuPopup->popup(button_event->button, button_event->time);

        return true; //It has been handled.
      }
      else
        return false;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## Παλέτα εργαλείου

Μια ToolPalette είναι παρόμοια με μια Toolbar, αλλά μπορεί να περιέχει ένα πλέγμα στοιχείων, κατηγοριοποιημένο σε ομάδες. Ο χρήστης μπορεί να κρύψει ή να επεκτείνει κάθε ομάδα. Όπως στην εργαλειοθήκη, τα στοιχεία μπορεί να εμφανιστούν ως μόνο εικονίδια, ως μόνο κείμενο, ή ως εικονίδια με κείμενο.

Τα στοιχεία της ToolPalette μπορεί να μετακινηθούν ή απλά να ενεργοποιηθούν. Για παράδειγμα, ο χρήστης μπορεί να μετακινήσει αντικείμενα σε ένα καμβά για να δημιουργήσει νέα στοιχεία εκεί. Ή ο χρήστης μπορεί να πατήσει ένα στοιχείο για να ενεργοποιήσει ένα συγκεκριμένο μέγεθος πινέλου σε μια εφαρμογή σχεδίασης.

Οι ToolItemGroups πρέπει να προστεθούν στη παλέτα του εργαλείου μέσα από τη μέθοδο `Gtk::Container::add()` της βασικής κλάσης, για παράδειγμα ως εξής:

    Gtk::ToolItemGroup* group_brushes =
      Gtk::manage(new Gtk::ToolItemGroup("Brushes"));
    m_ToolPalette.add(*group_brushes);

Οι Gtk::ToolItems μπορούν έπειτα να προστεθούν στην ομάδα. Για παράδειγμα, ως εξής:

    Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(icon, "Big"));
    button->set_tooltip_text("Big Brush);
    group_brushes->insert(*button);

Μπορείτε έπειτα να χειριστείτε στην ToolButton το σήμα `clicked`. Εναλλακτικά, θα μπορείτε να επιτρέψετε στο στοιχείο να μετακινηθεί σε ένα άλλο γραφικό συστατικό, καλώντας Gtk::ToolPalette::add_drag_dest() και έπειτα χρησιμοποιώντας την Gtk::ToolPalette::get_drag_item() στον χειριστή σήματος `drag_data_received` του άλλου γραφικού συστατικού.

ToolPalette Reference

ToolItemGroup Reference

ToolItem Reference

### Μεταφορά κι απόθεση

Καλέστε τη add_drag_dest() για να επιτρέψετε σε στοιχεία ή ομάδες να μετακινηθούν από την παλέτα εργαλείων σε έναν συγκεκριμένο γραφικό συστατικό προορισμού. Μπορείτε έπειτα να χρησιμοποιήσετε την get_drag_item() για να βρείτε ποιο ToolItem ή ToolItemGroup μεταφέρθηκε. Μπορείτε να χρησιμοποιήσετε την `dynamic_cast` για να βρείτε αν είναι ένα στοιχείο ή μια ομάδα. Για παράδειγμα, μπορεί να χρησιμοποιήσετε αυτό στον χειριστή σήματός σας `drag_data_received`, για να προσθέσετε ένα αποτιθέμενο στοιχείο, ή να εμφανίσετε ένα κατάλληλο εικονίδιο κατά τη μεταφορά.

Δείτε το κεφάλαιο Μεταφορά και απόθεση για γενικές συμβουλές σχετικά με τη μεταφορά και απόθεση με gtkmm.

### Παράδειγμα παλέτας εργαλείου

Αυτό το παράδειγμα προσθέτει μια ToolPalette και μια DrawingArea σε ένα παράθυρο και επιτρέπει στον χρήστη να μεταφέρει εικονίδια από την παλέτα εργαλείων στην περιοχή σχεδίασης. Η παλέτα εργαλείων περιέχει αρκετές ομάδες στοιχείων. Τα σύνθετα πλαίσια επιτρέπουν στον χρήστη να αλλάξει την τεχνοτροπία και τον προσανατολισμό της παλέτας εργαλείων.

Παλέτα εργαλείου

Source Code

File: `canvas.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_CANVAS_H
    #define GTKMM_EXAMPLE_CANVAS_H

    #include <gtkmm.h>

    // This little canvas class is only here
    // because gtkmm does not have a canvas class yet.
    // Applications should probably use GooCanvas::Canvas (goocanvasmm) instead.
    class Canvas : public Gtk::DrawingArea
    {
    public:
      Canvas();
      virtual ~Canvas();

    private:

      class CanvasItem
      {
      public:
        CanvasItem(Gtk::Widget* canvas, Gtk::ToolButton* button, double x, double y)
        {
          Glib::ustring icon_name(button->get_icon_name());
          if (icon_name.empty())
            icon_name = button->get_label();

          auto icon_theme = Gtk::IconTheme::get_for_screen(canvas->get_screen());
          int width = 0;
          int height = 0; //ignored
          Gtk::IconSize::lookup(Gtk::ICON_SIZE_DIALOG, width, height);
          this->m_pixbuf = icon_theme->load_icon(icon_name, width, Gtk::ICON_LOOKUP_GENERIC_FALLBACK);
          this->m_x = x;
          this->m_y = y;
        }

        Glib::RefPtr<Gdk::Pixbuf> m_pixbuf;
        double m_x, m_y;
      };

      void item_draw(const CanvasItem *item,
        const Cairo::RefPtr<Cairo::Context>& cr,
        bool preview);

      bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;
      void on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context,
        int x, int y, const Gtk::SelectionData& selection_data, guint info, guint time) override;
      bool on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time) override;
      bool on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time) override;
      void on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time) override;

      bool m_drag_data_requested_for_drop; //So we know what to do in on_drag_data_received().
      CanvasItem* m_drop_item;

      typedef std::vector<CanvasItem*> type_vec_items;
      type_vec_items m_canvas_items;
    };

    #endif //GTKMM_EXAMPLE_CANVAS_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "canvas.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    private:

      void load_icon_items();
      void load_toggle_items();
      void load_special_items();

      //Signal handlers:
      void on_combo_orientation_changed();
      void on_combo_style_changed();

      //Tree model columns:
      class ModelColumnsOrientation : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumnsOrientation()
        { add(m_col_value); add(m_col_name); }

        Gtk::TreeModelColumn<Gtk::Orientation> m_col_value;
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumnsOrientation m_ColumnsOrientation;

      //Tree model columns:
      class ModelColumnsStyle : public Gtk::TreeModel::ColumnRecord
      {
      public:

        ModelColumnsStyle()
        { add(m_col_value); add(m_col_name); }

        Gtk::TreeModelColumn<int> m_col_value; //We use int to also allow -1
        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
      };

      ModelColumnsStyle m_ColumnsStyle;

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Box m_HBox;
      Gtk::ComboBox m_ComboOrientation;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModelOrientation;
      Gtk::ComboBox m_ComboStyle;
      Glib::RefPtr<Gtk::ListStore> m_refTreeModelStyle;
      Gtk::ToolPalette m_ToolPalette;
      Gtk::ScrolledWindow m_ScrolledWindowPalette;
      Gtk::ScrolledWindow m_ScrolledWindowCanvas;
      Canvas m_Canvas;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    void ExampleWindow::load_icon_items()
    {
      auto icon_theme = Gtk::IconTheme::get_for_screen(get_screen());

      typedef std::vector<Glib::ustring> type_stringvec;
      type_stringvec icon_names = icon_theme->list_icons();

      // Obtain the names of all contexts, and the icon names per context.
      type_stringvec contexts = icon_theme->list_contexts();
      std::sort(contexts.begin(), contexts.end());

      int requested_icon_size = 0;
      int requested_icon_height = 0; //ignored
      Gtk::IconSize::lookup(Gtk::ICON_SIZE_BUTTON, requested_icon_size, requested_icon_height);
      const guint max_icons_per_group = 10;

      for (type_stringvec::const_iterator iter = contexts.begin(); iter != contexts.end(); ++iter)
      {
        const Glib::ustring context_name = *iter;
        Gtk::ToolItemGroup* group =
          Gtk::manage(new Gtk::ToolItemGroup(context_name));
        m_ToolPalette.add(*group);

        // Iterate through the icon names, populating the ToolItemGroup as appropriate.
        type_stringvec icon_names_for_context = icon_theme->list_icons(context_name);
        std::sort(icon_names_for_context.begin(), icon_names_for_context.end());
        guint icons_count = 0;
        for (type_stringvec::const_iterator iconiter = icon_names_for_context.begin(); iconiter != icon_names_for_context.end(); ++iconiter)
        {
          const Glib::ustring icon_name = *iconiter;
          Glib::RefPtr<Gdk::Pixbuf> pixbuf;
          try
          {
            pixbuf = icon_theme->load_icon(icon_name, requested_icon_size, Gtk::ICON_LOOKUP_GENERIC_FALLBACK);
          }
          catch (const Gtk::IconThemeError& /* ex */)
          {
            // Gtk::IconTheme::list_icons() may return some names of icons
            // that can't be loaded.
            continue;
          }

          // Skip large icons, just to make the ToolPalette look better.
          if (pixbuf->get_width() > 2*requested_icon_size ||
              pixbuf->get_height() > 2*requested_icon_size)
            continue;

          auto image = Gtk::manage(new Gtk::Image(pixbuf));
          auto button = Gtk::manage(new Gtk::ToolButton(*image, icon_name));
          button->set_tooltip_text(icon_name);
          button->set_is_important();
          group->insert(*button);

          // Prevent us having an insane number of icons:
          ++icons_count;
          if(icons_count >= max_icons_per_group)
            break;
        }
      }
    }

    void ExampleWindow::load_toggle_items()
    {
      auto group =
        Gtk::manage(new Gtk::ToolItemGroup("Radio Item"));
      m_ToolPalette.add(*group);

      Gtk::RadioToolButton::Group radio_group;

      for(int i = 1; i <= 10; ++i)
      {
        const Glib::ustring label = Glib::ustring::compose("#%1", i);
        auto button = Gtk::manage(new Gtk::RadioToolButton());
        button->set_group(radio_group);
        button->set_label(label);

        group->insert(*button);
      }
    }

    static Gtk::ToolItem* create_entry_item(const Glib::ustring& text)
    {
      auto entry = Gtk::manage(new Gtk::Entry());
      entry->set_text(text);
      entry->set_width_chars(5);

      auto item = Gtk::manage(new Gtk::ToolItem());
      item->add(*entry);

      return item;
    }

    void ExampleWindow::load_special_items()
    {
      auto group = Gtk::manage(new Gtk::ToolItemGroup());

      Gtk::Button *label_button = Gtk::manage(new Gtk::Button("Advanced Features"));
      label_button->show();
      group->set_label_widget(*label_button);
      m_ToolPalette.add(*group);

      auto item = create_entry_item ("homogeneous=false");
      group->insert(*item);
      //TODO: Add Gtk::Container::set_child_property().
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                               "homogeneous", FALSE, NULL);

      item = create_entry_item ("homogeneous=FALSE, expand=TRUE");
      group->insert(*item);
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                               "homogeneous", FALSE, "expand", TRUE,
                               NULL);

      item = create_entry_item ("homogeneous=FALSE, expand=TRUE, fill=FALSE");
      group->insert(*item);
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                               "homogeneous", FALSE, "expand", TRUE,
                               "fill", FALSE, NULL);

      item = create_entry_item ("homogeneous=FALSE, expand=TRUE, new-row=TRUE");
      group->insert(*item);
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                               "homogeneous", FALSE, "expand", TRUE,
                               "new-row", TRUE, NULL);

      Gtk::ToolButton *button = Gtk::manage(new Gtk::ToolButton());
      button->set_icon_name("go-up");
      button->set_tooltip_text("Show on vertical palettes only");
      group->insert(*button);
      button->set_visible_horizontal(false);

      button = Gtk::manage(new Gtk::ToolButton());
      button->set_icon_name("go-next");
      button->set_tooltip_text("Show on horizontal palettes only");
      group->insert(*button);
      button->set_visible_vertical(false);

      button = Gtk::manage(new Gtk::ToolButton());
      button->set_icon_name("edit-delete");
      button->set_tooltip_text("Do not show at all");
      button->set_no_show_all();
      group->insert(*button);
      button->set_visible_vertical(false);

      button = Gtk::manage(new Gtk::ToolButton());
      button->set_icon_name("view-fullscreen");
      button->set_tooltip_text("Expanded this item");
      group->insert(*button);
      gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (button->gobj()),
                               "homogeneous", FALSE,
                               "expand", TRUE,
                               NULL);

      button = Gtk::manage(new Gtk::ToolButton());
      button->set_icon_name("help-contents");
      button->set_tooltip_text("A regular item");
      group->insert(*button);
    }

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL, 6),
      m_HBox(Gtk::ORIENTATION_HORIZONTAL, 6)
    {
      set_title("Gtk::ToolPalette example");
      set_size_request(600, 600);
      set_border_width(6);

      add(m_VBox);

      //The Orientation ComboBox:
      m_refTreeModelOrientation = Gtk::ListStore::create(m_ColumnsOrientation);
      Gtk::TreeModel::Row row = *(m_refTreeModelOrientation->append());
      row[m_ColumnsOrientation.m_col_value] = Gtk::ORIENTATION_HORIZONTAL;
      row[m_ColumnsOrientation.m_col_name] = "Horizontal";\
      row = *(m_refTreeModelOrientation->append());
      row[m_ColumnsOrientation.m_col_value] = Gtk::ORIENTATION_VERTICAL;
      row[m_ColumnsOrientation.m_col_name] = "Vertical";
      m_ComboOrientation.set_model(m_refTreeModelOrientation);
      m_VBox.pack_start(m_ComboOrientation, Gtk::PACK_SHRINK);
      m_ComboOrientation.pack_start(m_ColumnsOrientation.m_col_name);
      m_ComboOrientation.signal_changed().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_combo_orientation_changed) );
      m_ComboOrientation.set_active(row);

      //The Style ComboBox:
      m_refTreeModelStyle = Gtk::ListStore::create(m_ColumnsStyle);
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_TEXT;
      row[m_ColumnsStyle.m_col_name] = "Text";\
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_BOTH;
      row[m_ColumnsStyle.m_col_name] = "Both";
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_BOTH_HORIZ;
      row[m_ColumnsStyle.m_col_name] = "Both: Horizontal";
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_ICONS;
      row[m_ColumnsStyle.m_col_name] = "Icons";
      row = *(m_refTreeModelStyle->append());
      row[m_ColumnsStyle.m_col_value] = -1; // A custom meaning for this demo.
      row[m_ColumnsStyle.m_col_name] = "Default";
      m_ComboStyle.set_model(m_refTreeModelStyle);
      m_VBox.pack_start(m_ComboStyle, Gtk::PACK_SHRINK);
      m_ComboStyle.pack_start(m_ColumnsStyle.m_col_name);
      m_ComboStyle.signal_changed().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_combo_style_changed) );
      m_ComboStyle.set_active(row);

      //Add and fill the ToolPalette:
      load_icon_items();
      load_toggle_items();
      load_special_items();

      m_VBox.pack_start(m_HBox, Gtk::PACK_EXPAND_WIDGET);

      m_ScrolledWindowPalette.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
      m_ScrolledWindowPalette.set_border_width(6);
      m_ScrolledWindowPalette.add(m_ToolPalette);
      m_HBox.pack_start(m_ScrolledWindowPalette);

      on_combo_orientation_changed();

      m_ScrolledWindowCanvas.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);
      m_ScrolledWindowCanvas.set_border_width(6);
      m_ScrolledWindowCanvas.add(m_Canvas);
      m_ScrolledWindowCanvas.set_size_request(200, -1);
      m_HBox.pack_start(m_ScrolledWindowCanvas);

      m_ToolPalette.add_drag_dest(m_Canvas,
        Gtk::DEST_DEFAULT_HIGHLIGHT, Gtk::TOOL_PALETTE_DRAG_ITEMS, Gdk::ACTION_COPY);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_combo_orientation_changed()
    {
      Gtk::TreeModel::iterator iter = m_ComboOrientation.get_active();
      if(!iter)
        return;

      Gtk::TreeModel::Row row = *iter;
      const Gtk::Orientation value = row[m_ColumnsOrientation.m_col_value];

      m_ToolPalette.set_orientation(value);

      if(value == Gtk::ORIENTATION_HORIZONTAL)
        m_ScrolledWindowPalette.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_NEVER);
      else
        m_ScrolledWindowPalette.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
    }

    void ExampleWindow::on_combo_style_changed()
    {
      Gtk::TreeModel::iterator iter = m_ComboStyle.get_active();
      if(!iter)
        return;

      Gtk::TreeModel::Row row = *iter;
      const int value = row[m_ColumnsStyle.m_col_value];

      if(value == -1)
        m_ToolPalette.unset_style();
      else
        m_ToolPalette.set_style((Gtk::ToolbarStyle)value);
    }

File: `canvas.cc` (For use with gtkmm 3, not gtkmm 2)

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

    Canvas::Canvas()
    : m_drag_data_requested_for_drop(false),
      m_drop_item(nullptr)
    {
      set_app_paintable();
    }

    Canvas::~Canvas()
    {
      while(!m_canvas_items.empty())
      {
        auto iter = m_canvas_items.begin();
        auto item = *iter;
        delete item;
        m_canvas_items.erase(iter);
      }

      delete m_drop_item;
    }

    void Canvas::item_draw(const CanvasItem *item,
      const Cairo::RefPtr<Cairo::Context>& cr,
      bool preview)
    {
      if(!item || !item->m_pixbuf)
        return;

      const double cx = item->m_pixbuf->get_width();
      const double cy = item->m_pixbuf->get_height();

      Gdk::Cairo::set_source_pixbuf(cr,
        item->m_pixbuf,
        item->m_x - cx * 0.5, item->m_y - cy * 0.5);

      if(preview)
        cr->paint_with_alpha(0.6);
      else
        cr->paint();
    }

    bool Canvas::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      cr->set_source_rgb(1.0, 1.0, 1.0);
      const Gtk::Allocation allocation = get_allocation();
      cr->rectangle(0, 0, allocation.get_width(), allocation.get_height());
      cr->fill();

      for(type_vec_items::iterator iter = m_canvas_items.begin();
        iter != m_canvas_items.end(); ++iter )
      {
        item_draw(*iter, cr, false);
      }

      if(m_drop_item)
        item_draw (m_drop_item, cr, true);

      return true;
    }

    bool Canvas::on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context,
      int x, int y, guint time)
    {
      m_drag_data_requested_for_drop = false; //It's for drag-motion instead.

      if(m_drop_item)
      {
        // We already have a drop indicator so just update its position.

        m_drop_item->m_x = x;
        m_drop_item->m_y = y;

        queue_draw();
        context->drag_status(Gdk::ACTION_COPY, time);
      }
      else
      {
        // Request DnD data for creating a drop indicator.
        // This will cause on_drag_data_received() to be called.
        const Glib::ustring target = drag_dest_find_target(context);

        if (target.empty())
          return false;

        drag_get_data(context, target, time);
      }

      Gtk::DrawingArea::on_drag_motion(context, x, y, time);
      return true;
    }

    void Canvas::on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context,
      int x, int y, const Gtk::SelectionData& selection_data, guint info, guint time)
    {
      // Find the tool button which is the source of this DnD operation.
      auto widget = drag_get_source_widget(context);

      auto drag_palette = dynamic_cast<Gtk::ToolPalette*>(widget);
      while(widget && !drag_palette)
      {
        widget = widget->get_parent();
        drag_palette = dynamic_cast<Gtk::ToolPalette*>(widget);
      }

      Gtk::ToolItem* drag_item = nullptr;
      if(drag_palette)
        drag_item = drag_palette->get_drag_item(selection_data);

      // Create a drop indicator when a tool button was found:
      auto button = dynamic_cast<Gtk::ToolButton*>(drag_item);
      if(!button)
        return;

      delete m_drop_item;
      m_drop_item = nullptr;

      try
      {
        auto item = new CanvasItem(this, button, x, y);

        if(m_drag_data_requested_for_drop)
        {
          m_canvas_items.push_back(item);

          // Signal that the item was accepted and then redraw.
          context->drag_finish(true /* success */, false /* del */, time);
        }
        else
        {
          m_drop_item = item;

          // We are getting this data due to a request in drag_motion,
          // rather than due to a request in drag_drop, so we are just
          // supposed to call gdk_drag_status (), not actually paste in
          // the data.
          context->drag_status(Gdk::ACTION_COPY, time);
        }

        queue_draw();
      }
      catch (const Gtk::IconThemeError& ex)
      {
        std::cerr << "IconThemeError: " << ex.what() << std::endl;
      }

      Gtk::DrawingArea::on_drag_data_received(context, x, y, selection_data, info, time);
    }

    bool Canvas::on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int /* x */, int /* y */, guint time)
    {
      // Request DnD data for creating a dopped item.
      // This will cause on_drag_data_received() to be called.
      const Glib::ustring target = drag_dest_find_target(context);

      if (target.empty())
        return false;

      m_drag_data_requested_for_drop = true;
      drag_get_data(context, target, time);

      return true;
    }

    void Canvas::on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time)
    {
      //This signal is emitted to clean up the item used for drag-motion,
      //either when the cursor moves out of the widget or when we drop.

      if(!m_drop_item)
        return;

      delete m_drop_item;
      m_drop_item = nullptr;

      queue_draw();

      Gtk::DrawingArea::on_drag_leave(context, time);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## Προσαρμογές

Η gtkmm έχει ποικίλα γραφικά συστατικά που μπορούν να προσαρμοστούν οπτικά χρησιμοποιώντας το ποντίκι ή το πληκτρολόγιο, όπως τα γραφικά συστατικά Range (που περιγράφηκαν στην ενότητα Γραφικά συστατικά περιοχής). Υπάρχουν επίσης λίγα γραφικά συστατικά που εμφανίζουν κάποιο ρυθμίσιμο μέρος μιας μεγαλύτερης περιοχής, όπως το γραφικό συστατικό Viewport. Αυτά τα γραφικά συστατικά έχουν αντικείμενα Gtk::Adjustment που εκφράζουν αυτό το κοινό τμήμα της API τους.

Για να μπορούν αυτές οι εφαρμογές να αντιδρούν στις αλλαγές, για παράδειγμα όταν ένας χρήστης μετακινεί μια γραμμή κύλισης, η Gtk::Adjustment έχει ένα σήμα `value_changed`. Μπορείτε έπειτα να χρησιμοποιήσετε τη μέθοδο get_value() για να βρείτε τη νέα τιμή.

### Δημιουργία μιας προσαρμογής

Το Gtk::Adjustment δημιουργείται από την μέθοδο του create() που έχει ως εξής:

    Glib::RefPtr<Gtk::Adjustment> Gtk::Adjustment::create(
      double value,
      double lower,
      double upper,
      double step_increment = 1,
      double page_increment = 10,
      double page_size = 0);

Το όρισμα value είναι η αρχική τιμή της προσαρμογής, που αντιστοιχεί συνήθως στην ανώτατη ή αριστερότερη θέση ενός προσαρμόσιμου γραφικού συστατικού. Τα ορίσματα lower και upper καθορίζουν τη δυνατή περιοχή τιμών που η προσαρμογή μπορεί να κρατήσει. Το όρισμα step_increment καθορίζει την μικρότερη από τις δύο αυξήσεις με τις οποίες ο χρήστης μπορεί να αλλάξει την τιμή, ενώ η page_increment είναι η μεγαλύτερη. Το όρισμα page_size συνήθως αντιστοιχεί κάπως στην ορατή περιοχή ενός μετακινούμενου γραφικού συστατικού. Το όρισμα upper χρησιμοποιείται για την αναπαράσταση της πιο μικρής ή πιο δεξιάς συντεταγμένης σε ένα θυγατρικό μετακινούμενο γραφικό συστατικό.

### Χρήση προσαρμογών με τον εύκολο τρόπο

Τα προσαρμόσιμα γραφικά συστατικά μπορούν να διαιρεθούν χοντρικά σε αυτά τα οποία χρησιμοποιούν και απαιτούν ειδικές μονάδες για αυτές τις τιμές και σε αυτά που τα θεωρούν ως ελεύθερους αριθμούς.

Η ομάδα που θεωρεί τις τιμές ως τυχαίους αριθμούς περιλαμβάνει τα γραφικά συστατικά Range (Scrollbar και Scale), το γραφικό συστατικό ScaleButton και το γραφικό συστατικό SpinButton. Αυτά τα γραφικά συστατικά είναι τυπικά "προσαρμοσμένα" άμεσα από τον χρήστη με το ποντίκι ή το πληκτρολόγιο. Θα θεωρήσουν τις τιμές lower και upper μιας προσαρμογής ως μια περιοχή μέσα στην οποία ο χρήστης μπορεί να χειριστεί την value της προσαρμογής. Από προεπιλογή, θα τροποποιήσουν μόνο την value μιας προσαρμογής.

Η άλλη ομάδα περιλαμβάνει τα γραφικά συστατικά Viewport widget και ScrolledWindow. Όλα αυτά τα γραφικά συστατικά χρησιμοποιούν τιμές εικονοστοιχείου για τις προσαρμογές τους. Αυτά προσαρμόζονται επίσης τυπικά εμμέσως χρησιμοποιώντας γραμμές κύλισης. Ενώ όλα τα γραφικά συστατικά που χρησιμοποιούν προσαρμογές μπορούν ή να δημιουργήσουν τις δικές τους προσαρμογές ή να χρησιμοποιήσουν αυτές που δίνετε, θα θέλετε γενικά να επιτρέψετε σε αυτήν τη συγκεκριμένη κατηγορία γραφικών συστατικών να δημιουργήσει τις δικές της προσαρμογές.

Αν μοιράζεστε ένα αντικείμενο προσαρμογής μεταξύ ενός γραφικού συστατικού γραμμής κύλισης και ενός προβολής κειμένου (TextView), ο χειρισμός της γραμμής κύλισης θα προσαρμόσει αυτόματα το γραφικό συστατικό προβολής κειμένου. Μπορείτε να το ρυθμίσετε όπως αυτό:

    // δημιουργεί τις δικές του προσαρμογές
    Gtk::TextView textview·
    // χρησιμοποιεί την νεοδημιουργούμενη προσαρμογή για τη γραμμή κύλισης επίσης
    Gtk::Scrollbar vscrollbar (textview.get_vadjustment(), Gtk::ORIENTATION_VERTICAL)·

### Προσαρμογή εσωτερικών

Εντάξει, αυτό είναι ωραίο, αλλά τι θα συμβεί αν θελήσετε να δημιουργήσετε τους δικούς σας χειριστές για να απαντούν όταν ο χρήστης ρυθμίζει ένα γραφικό συστατικό Range ή μια SpinButton. Για να προσπελάσετε την τιμή μιας Gtk::Adjustment, μπορείτε να χρησιμοποιήσετε τις μεθόδους get_value() και set_value():

Όπως αναφέρθηκε νωρίτερα, η Gtk::Adjustment μπορεί να εκπέμπει σήματα. Έτσι, φυσικά, οι ενημερώσεις γίνονται αυτόματα όταν μοιράζεστε ένα αντικείμενο Adjustment μεταξύ μιας Scrollbar και ενός άλλου προσαρμόσιμου γραφικού συστατικού· όλα τα προσαρμόσιμα γραφικά συστατικά συνδέουν χειριστές σήματος με το σήμα `value_changed` της προσαρμογής τους, όπως μπορεί το πρόγραμμά σας.

Έτσι, για παράδειγμα, αν έχετε ένα γραφικό συστατικό Scale και θέλετε να αλλάξετε την περιστροφή μιας εικόνας όποτε η τιμή του αλλάζει, θα πρέπει να δημιουργήσετε έναν χειριστή σήματος, όπως αυτόν:

    void cb_rotate_picture (MyPicture* picture)
    {
      picture->set_rotation(adj->get_value());
    ...

και να το συνδέσετε στην προσαρμογή του γραφικού συστατικού κλίμακας όπως αυτό:

    adj->signal_value_changed().connect(sigc::bind<MyPicture*>(sigc::mem_fun(*this,
        &cb_rotate_picture), picture));

Τι συμβαίνει αν ένα γραφικό συστατικό αναδιαμορφώνει τα πεδία upper ή lower της Adjustment του, όπως όταν ένας χρήστης προσθέτει περισσότερο κείμενο στο γραφικό συστατικό κειμένου; Σε αυτήν την περίπτωση εκπέμπει το σήμα `changed`.

Τα γραφικά συστατικά Range συνδέουν τυπικά έναν χειριστή με αυτό το σήμα, που αλλάζει την εμφάνισή τους για να απεικονίζει την αλλαγή - για παράδειγμα, το μέγεθος του ολισθητή σε μια γραμμή κύλισης θα αυξήσει ή θα συρρικνώσει αντιστρόφως ανάλογα με τη διαφορά μεταξύ των τιμών lower και upper της Adjustment του.

Δεν θα χρειαστείτε ποτέ να προσαρτήσετε έναν χειριστή σε αυτό το σήμα, εκτός και γράφετε έναν νέο τύπο γραφικού συστατικού περιοχής.

    adjustment->signal_changed();

## Γραφικά συστατικά χωρίς X-Windows

Μερικά γραφικά συστατικά δεν έχουν συνδεμένο ένα X-Window, έτσι δεν δέχονται συνεπώς συμβάντα Χ. Αυτό σημαίνει ότι τα σήματα που περιγράφηκαν στην ενότητα σήματα συμβάντων Χ δεν θα εκπεμφθούν. Αν θέλετε να συλλάβετε συμβάντα για αυτά τα γραφικά συστατικά, μπορείτε να χρησιμοποιήσετε έναν ειδικό περιέκτη που λέγεται Gtk::EventBox και περιγράφεται στην ενότητα Πλαίσια συμβάντων.

Ιδού μια λίστα μερικών από αυτά τα γραφικά συστατικά:

    Gtk::Alignment (deprecated from gtkmm version 3.14)
    Gtk::Arrow (deprecated from gtkmm version 3.14)
    Gtk::AspectFrame
    Gtk::Bin
    Gtk::Box
    Gtk::Button
    Gtk::CheckButton
    Gtk::Fixed
    Gtk::Frame
    Gtk::Grid
    Gtk::Image
    Gtk::Label
    Gtk::MenuItem
    Gtk::Notebook
    Gtk::Paned
    Gtk::RadioButton
    Gtk::Range
    Gtk::ScrolledWindow
    Gtk::Separator
    Gtk::Table (deprecated from gtkmm version 3.4)
    Gtk::Toolbar

Αυτά τα γραφικά συστατικά χρησιμοποιούνται κυρίως για διάκοσμο ή διάταξη, έτσι δεν θα χρειάζεστε συχνά τη σύλληψη συμβάντων σε αυτά. Προορίζονται να μην έχουν X-Window για να βελτιώσουν την απόδοση.

### Πλαίσιο συμβάντων (Event Box)

Μερικά γραφικά συστατικά της gtkmm δεν έχουν συσχετισμένα παράθυρα Χ· σχεδιάζονται στα γονικά τους παράθυρα. Λόγω αυτού, δεν μπορούν να δεχτούν συμβάντα. Επίσης, αν είναι λαθεμένα σε μέγεθος, δεν περικόπτονται, έτσι μπορείτε να δεχτείτε μπερδεμένη αντικατάσταση κλπ. Για την λήψη συμβάντων σε ένα από αυτά τα γραφικά συστατικά, μπορείτε να το τοποθετήσετε μέσα σε ένα γραφικό συστατικό EventBox και έπειτα να καλέσετε Gtk::Widget::set_events() στο EventBox πριν το εμφανίσετε.

Αν και το όνομα EventBox δίνει έμφαση στη μέθοδο χειρισμού συμβάντων, το γραφικό συστατικό μπορεί επίσης να χρησιμοποιηθεί για απόκομμα (και περισσότερα· δείτε το παρακάτω παράδειγμα).

Ο κατασκευαστής για Gtk::EventBox είναι:

    Gtk::EventBox()·

Ένα θυγατρικό γραφικό συστατικό μπορεί να προστεθεί στο EventBox χρησιμοποιώντας:

    event_box.add(child_widget);

Reference

#### Παράδειγμα

Το παρακάτω παράδειγμα δείχνει και τις δύο χρήσεις ενός EventBox - μια ετικέτα δημιουργείται που περικόπτεται σε ένα μικρό πλαίσιο και ρυθμίζεται έτσι ώστε με πάτημα του ποντικιού στην ετικέτα να προκαλεί έξοδο από το πρόγραμμα. Αυξομείωση του παραθύρου αποκαλύπτει ποικίλα ποσά της ετικέτας.

Πλαίσιο συμβάντων (Event Box)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      bool on_eventbox_button_press(GdkEventButton* button_event);

      //Child widgets:
      Gtk::EventBox m_EventBox;
      Gtk::Label m_Label;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_Label("Click here to quit, quit, quit, quit, quit")
    {
      set_title ("EventBox");
      set_border_width(10);

      add(m_EventBox);

      m_EventBox.add(m_Label);

      //Clip the label short:
      set_default_size(110, 20);
      m_Label.set_size_request(110, 20);
      m_Label.set_ellipsize(Pango::ELLIPSIZE_END);

      //And bind an action to it:
      m_EventBox.set_events(Gdk::BUTTON_PRESS_MASK);
      m_EventBox.signal_button_press_event().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_eventbox_button_press) );

      m_EventBox.set_tooltip_text("Click me!");

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    bool ExampleWindow::on_eventbox_button_press(GdkEventButton*)
    {
      hide();
      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## Διάλογοι

Οι διάλογοι χρησιμοποιούνται ως δευτερεύοντα παράθυρα, για να δώσουν ειδικές πληροφορίες ή να ρωτήσουν. Τα παράθυρα Gtk::Dialog περιέχουν λίγα προσυσκευασμένα γραφικά συστατικά για να εξασφαλίσουν σταθερότητα και μια μέθοδο run() που φράσσει μέχρι ο χρήστης να διώξει τον διάλογο.

Υπάρχουν αρκετές παραγόμενες κλάσεις Dialog που μπορεί να βρείτε χρήσιμες. Η Gtk::MessageDialog χρησιμοποιείται για τις πιο απλές ειδοποιήσεις. Αλλά άλλες φορές μπορεί να χρειαστείτε να παράξετε τη δική σας κλάση διαλόγου για να δώσετε περισσότερο σύνθετη λειτουργικότητα.

Για να συσκευάσετε γραφικά συστατικά σε έναν προσαρμοσμένο διάλογο, θα πρέπει να τις συσκευάσετε στην Gtk::Box, διαθέσιμη μέσα από get_content_area(). Για να προσθέσετε απλά μια Button στο τέλος του Dialog, μπορείτε να χρησιμοποιήσετε τη μέθοδο add_button().

Η μέθοδος run() επιστρέφει έναν `int`. Αυτός μπορεί να είναι μια τιμή από την `Gtk::ResponseType` αν ο χρήστης έκλεισε τον διάλογο πατώντας ένα τυπικό κουμπί, ή μπορεί να είναι η προσαρμοσμένη τιμή απάντησης που ορίσατε, όταν χρησιμοποιήσατε add_button().

Reference

### Διάλογος μηνύματος (MessageDialog)

Η MessageDialog είναι μια κλάση διευκόλυνσης, που χρησιμοποιείται για τη δημιουργία απλών, τυπικών διαλόγων μηνύματος, με ένα μήνυμα, ένα εικονίδιο και κουμπιά για απάντηση του χρήστη. Μπορείτε να ορίσετε τον τύπο του μηνύματος και το κείμενο στον κατασκευαστή, καθώς και να ορίσετε τυπικά κουμπιά μέσα από την αρίθμηση `Gtk::ButtonsType`.

Reference

#### Παράδειγμα

Διάλογος μηνύματος (MessageDialog)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_info_clicked();
      void on_button_question_clicked();

      //Child widgets:
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Info, m_Button_Question;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/messagedialog.h>
    #include <iostream>

    ExampleWindow::ExampleWindow()
    : m_ButtonBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Info("Show Info MessageDialog"),
      m_Button_Question("Show Question MessageDialog")
    {
      set_title("Gtk::MessageDialog example");

      add(m_ButtonBox);

      m_ButtonBox.pack_start(m_Button_Info);
      m_Button_Info.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_info_clicked) );

      m_ButtonBox.pack_start(m_Button_Question);
      m_Button_Question.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_question_clicked) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_info_clicked()
    {
      Gtk::MessageDialog dialog(*this, "This is an INFO MessageDialog");
      dialog.set_secondary_text(
              "And this is the secondary text that explains things.");

      dialog.run();
    }

    void ExampleWindow::on_button_question_clicked()
    {
      Gtk::MessageDialog dialog(*this, "This is a QUESTION MessageDialog",
              false /* use_markup */, Gtk::MESSAGE_QUESTION,
              Gtk::BUTTONS_OK_CANCEL);
      dialog.set_secondary_text(
              "And this is the secondary text that explains things.");

      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case(Gtk::RESPONSE_OK):
        {
          std::cout << "OK clicked." << std::endl;
          break;
        }
        case(Gtk::RESPONSE_CANCEL):
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked." << std::endl;
          break;
        }
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Διάλογος επιλογής αρχείου (FileChooserDialog)

Η FileChooserDialog είναι κατάλληλη για χρήση με στοιχεία μενού "Άνοιγμα" ή "Αποθήκευση".

Οι περισσότερες από τις χρήσιμες μεθόδους μέλους για αυτήν την κλάση είναι στην πραγματικότητα στη βασική κλάση Gtk::FileChooser.

Reference

#### Παράδειγμα

Επιλογέας αρχείου (FileChooser)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_file_clicked();
      void on_button_folder_clicked();

      //Child widgets:
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_File, m_Button_Folder;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_ButtonBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_File("Choose File"),
      m_Button_Folder("Choose Folder")
    {
      set_title("Gtk::FileSelection example");

      add(m_ButtonBox);

      m_ButtonBox.pack_start(m_Button_File);
      m_Button_File.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_file_clicked) );

      m_ButtonBox.pack_start(m_Button_Folder);
      m_Button_Folder.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_folder_clicked) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_folder_clicked()
    {
      Gtk::FileChooserDialog dialog("Please choose a folder",
              Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
      dialog.set_transient_for(*this);

      //Add response buttons the the dialog:
      dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
      dialog.add_button("Select", Gtk::RESPONSE_OK);

      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case(Gtk::RESPONSE_OK):
        {
          std::cout << "Select clicked." << std::endl;
          std::cout << "Folder selected: " << dialog.get_filename()
              << std::endl;
          break;
        }
        case(Gtk::RESPONSE_CANCEL):
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked." << std::endl;
          break;
        }
      }
    }

    void ExampleWindow::on_button_file_clicked()
    {
      Gtk::FileChooserDialog dialog("Please choose a file",
              Gtk::FILE_CHOOSER_ACTION_OPEN);
      dialog.set_transient_for(*this);

      //Add response buttons the the dialog:
      dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
      dialog.add_button("_Open", Gtk::RESPONSE_OK);

      //Add filters, so that only certain file types can be selected:

      auto filter_text = Gtk::FileFilter::create();
      filter_text->set_name("Text files");
      filter_text->add_mime_type("text/plain");
      dialog.add_filter(filter_text);

      auto filter_cpp = Gtk::FileFilter::create();
      filter_cpp->set_name("C/C++ files");
      filter_cpp->add_mime_type("text/x-c");
      filter_cpp->add_mime_type("text/x-c++");
      filter_cpp->add_mime_type("text/x-c-header");
      dialog.add_filter(filter_cpp);

      auto filter_any = Gtk::FileFilter::create();
      filter_any->set_name("Any files");
      filter_any->add_pattern("*");
      dialog.add_filter(filter_any);

      //Show the dialog and wait for a user response:
      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case(Gtk::RESPONSE_OK):
        {
          std::cout << "Open clicked." << std::endl;

          //Notice that this is a std::string, not a Glib::ustring.
          std::string filename = dialog.get_filename();
          std::cout << "File selected: " <<  filename << std::endl;
          break;
        }
        case(Gtk::RESPONSE_CANCEL):
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked." << std::endl;
          break;
        }
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Διάλογος επιλογής χρώματος (ColorChooserDialog)

Η ColorChooserDialog επιτρέπει στον χρήστη να διαλέξει ένα χρώμα. Η ColorButton ανοίγει έναν διάλογο επιλογής χρώματος όταν πατιέται.

Reference

#### Παράδειγμα

Διάλογος επιλογής χρώματος (ColorChooserDialog)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_color_button_color_set();
      void on_button_dialog_clicked();
      bool on_drawing_area_draw(const Cairo::RefPtr<Cairo::Context>& cr);

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::ColorButton m_ColorButton;
      Gtk::Button m_Button_Dialog;
      Gtk::DrawingArea m_DrawingArea; //To show the color.

      Gdk::RGBA m_Color;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL, 5),
      m_Button_Dialog("Choose Color")
    {
      set_title("Gtk::ColorChooserDialog example");
      set_default_size(200, 200);

      add(m_VBox);

      m_VBox.pack_start(m_ColorButton, Gtk::PACK_SHRINK);
      m_ColorButton.signal_color_set().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_color_button_color_set) );

      m_VBox.pack_start(m_Button_Dialog, Gtk::PACK_SHRINK);
      m_Button_Dialog.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_dialog_clicked) );

      //Set start color:
      m_Color.set_red(0.0);
      m_Color.set_green(0.0);
      m_Color.set_blue(1.0);
      m_Color.set_alpha(1.0); //opaque
      m_ColorButton.set_rgba(m_Color);

      m_VBox.pack_start(m_DrawingArea);
      m_DrawingArea.signal_draw().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_drawing_area_draw));

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_color_button_color_set()
    {
      //Store the chosen color:
      m_Color = m_ColorButton.get_rgba();
    }

    void ExampleWindow::on_button_dialog_clicked()
    {
      Gtk::ColorChooserDialog dialog("Please choose a color");
      dialog.set_transient_for(*this);

      //Get the previously selected color:
      dialog.set_rgba(m_Color);

      const int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case Gtk::RESPONSE_OK:
        {
          //Store the chosen color:
          m_Color = dialog.get_rgba();
          m_ColorButton.set_rgba(m_Color);
          break;
        }
        case Gtk::RESPONSE_CANCEL:
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked: " << result << std::endl;
          break;
        }
      }
    }

    bool ExampleWindow::on_drawing_area_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Gdk::Cairo::set_source_rgba(cr, m_Color);
      cr->paint();

      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Διάλογος επιλογής γραμματοσειράς (FontChooserDialog)

Η FontChooserDialog επιτρέπει στον χρήστη να διαλέξει μία γραμματοσειρά. Η FontButton ανοίγει έναν διάλογο επιλογής γραμματοσειράς όταν πατιέται.

Reference

#### Παράδειγμα

Διάλογος επιλογής γραμματοσειράς (FontChooserDialog)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_font_button_font_set();
      void on_button_dialog_clicked();

      //Child widgets:
      Gtk::ButtonBox m_ButtonBox;
      Gtk::FontButton m_FontButton;
      Gtk::Button m_Button_Dialog;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_ButtonBox(Gtk::ORIENTATION_VERTICAL),
      m_FontButton("Sans 10"),
      m_Button_Dialog("Choose Font")
    {
      set_title("Gtk::FontChooserDialog example");

      add(m_ButtonBox);

      m_ButtonBox.pack_start(m_FontButton);
      m_FontButton.set_use_font(true);
      m_FontButton.set_use_size(true);
      m_FontButton.signal_font_set().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_font_button_font_set) );

      m_ButtonBox.pack_start(m_Button_Dialog);
      m_Button_Dialog.signal_clicked().connect(sigc::mem_fun(*this,
        &ExampleWindow::on_button_dialog_clicked) );
      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_font_button_font_set()
    {
      Glib::ustring font_name = m_FontButton.get_font_name();
      std::cout << "Font chosen: " << font_name << std::endl;
    }

    void ExampleWindow::on_button_dialog_clicked()
    {
      Gtk::FontChooserDialog dialog("Please choose a font", *this);

      //Get the previously selected font name from the FontButton:
      dialog.set_font(m_FontButton.get_font_name());

      int result = dialog.run();

      //Handle the response:
      switch(result)
      {
        case Gtk::RESPONSE_OK:
        {
          Glib::ustring font_name = dialog.get_font();
          std::cout << "Font chosen: " << font_name << std::endl;
          m_FontButton.set_font_name(font_name);
          break;
        }
        case Gtk::RESPONSE_CANCEL:
        {
          std::cout << "Cancel clicked." << std::endl;
          break;
        }
        default:
        {
          std::cout << "Unexpected button clicked: " << result << std::endl;
          break;
        }
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Μη αναγκαστικό περί του διαλόγου (AboutDialog)

Η AboutDialog προσφέρει έναν απλό τρόπο εμφάνισης πληροφοριών για ένα πρόγραμμα, όπως τον λογότυπο του,όνομα, πνευματικά δικαιώματα, ιστότοπο και άδεια.

Οι περισσότεροι διάλογοι σε αυτό το κεφάλαιο είναι αναγκαστικοί, παγώνουν την υπόλοιπη εφαρμογή ενώ εμφανίζονται. Είναι επίσης δυνατή η δημιουργία μη αναγκαστικού διαλόγου, που δεν παγώνει άλλα παράθυρα στην εφαρμογή. Το παρακάτω παράδειγμα εμφανίζει μία μη αναγκαστική AboutDialog. Αυτός δεν είναι ίσως το είδος του διαλόγου που θα κάνατε κανονικά μη αναγκαστικό, αλλά οι μη αναγκαστικοί διάλογοι μπορεί να είναι χρήσιμοι σε άλλες περιπτώσεις. Π.χ. ο διάλογος αναζήτησης και αντικατάστασης της gedit είναι μη αναγκαστικός.

Reference

#### Παράδειγμα

Περί διαλόγου (AboutDialog)

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_clicked();
      void on_about_dialog_response(int response_id);

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Label m_Label;
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button;
      Gtk::AboutDialog m_Dialog;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Label("The AboutDialog is non-modal. "
        "You can select parts of this text while the AboutDialog is shown."),
      m_ButtonBox(Gtk::ORIENTATION_VERTICAL),
      m_Button("Show AboutDialog")
    {
      set_title("Gtk::AboutDialog example");

      add(m_VBox);

      m_VBox.pack_start(m_Label);
      m_Label.set_line_wrap(true);
      m_Label.set_selectable(true);

      m_VBox.pack_start(m_ButtonBox);
      m_ButtonBox.pack_start(m_Button);
      m_Button.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_clicked) );

      m_Dialog.set_transient_for(*this);

      m_Dialog.set_program_name("Example application");
      m_Dialog.set_version("1.0.0");
      m_Dialog.set_copyright("Murray Cumming");
      m_Dialog.set_comments("This is just an example application.");
      m_Dialog.set_license("LGPL");

      m_Dialog.set_website("http://www.gtkmm.org");
      m_Dialog.set_website_label("gtkmm website");

      std::vector<Glib::ustring> list_authors;
      list_authors.push_back("Murray Cumming");
      list_authors.push_back("Somebody Else");
      list_authors.push_back("AN Other");
      m_Dialog.set_authors(list_authors);

      m_Dialog.signal_response().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_about_dialog_response) );

      show_all_children();

      // The widget must be realized and mapped before grab_focus() is called.
      // That's why it's called after show_all_children().
      m_Button.grab_focus();
    }

    ExampleWindow::~ExampleWindow()
    {

    }

    void ExampleWindow::on_about_dialog_response(int response_id)
    {
      std::cout << response_id
        << ", close=" << Gtk::RESPONSE_CLOSE
        << ", cancel=" << Gtk::RESPONSE_CANCEL
        << ", delete_event=" << Gtk::RESPONSE_DELETE_EVENT
        << std::endl;

      if((response_id == Gtk::RESPONSE_CLOSE) ||
         (response_id == Gtk::RESPONSE_CANCEL) )
      {
        m_Dialog.hide();
      }
    }

    void ExampleWindow::on_button_clicked()
    {
      m_Dialog.show();

      //Bring it to the front, in case it was already shown:
      m_Dialog.present();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## Το γραφικό συστατικό περιοχής σχεδίασης

Το γραφικό συστατικό DrawingArea είναι ένα κενό παράθυρο που σας δίνει την ελευθερία της δημιουργίας οποιουδήποτε γραφικού επιθυμείτε. Μαζί με την ελευθερία έρχεται η ευθύνη χειρισμού σημάτων σχεδίασης στο γραφικό συστατικό. Όταν ένα γραφικό συστατικό πρωτοεμφανίζεται, ή όταν καλύπτεται και έπειτα αποκαλύπτεται ξανά, χρειάζεται να ανασχεδιαστεί. Τα περισσότερα γραφικά συστατικά έχουν κώδικα για να το κάνουν αυτό, αλλά το DrawingArea δεν έχει, επιτρέποντας σας να γράψετε τον δικό σας χειριστή σήματος για να προσδιορίσετε πώς τα περιεχόμενα του γραφικού συστατικού θα σχεδιαστούν. Αυτό γίνεται συχνά με αντικατάσταση της εικονικής συνάρτησης μέλους on_draw().

Η GTK+ χρησιμοποιεί την API σχεδίασης Cairo. Με την gtkmm, μπορείτε να χρησιμοποιήσετε την API της C++ για cairo cairomm.

Μπορείτε να σχεδιάσετε πολύ προχωρημένα σχήματα χρησιμοποιώντας το Cairo, αλλά οι μέθοδοι για να γίνει αυτό είναι αρκετά βασικές. Το Cairo παρέχει μεθόδους για σχεδίαση ευθειών γραμμών, καμπύλων γραμμών και τόξων (συμπεριλαμβανομένων κύκλων). Αυτά τα βασικά σχήματα μπορούν να συνδυαστούν για να δημιουργήσουν πιο σύνθετα σχήματα και μονοπάτια που μπορούν να γεμίσουν με συμπαγή χρώματα, διαβαθμίσεις, μοτίβα και άλλα. Επιπλέον, το Cairo μπορεί να εκτελέσει σύνθετους μετασχηματισμούς, να συνθέσει εικόνες και να αποδώσει εξομαλυμένο κείμενο.

Cairo και Pango

Αν και το Cairo μπορεί να αποδώσει κείμενο, δεν σημαίνει ότι είναι αντικατάσταση του Pango. Το Pango είναι μια καλύτερη επιλογή αν χρειάζεται να εκτελέσετε πιο προχωρημένη απόδοση κειμένου όπως αναδίπλωση ή ελλειπτικό κείμενο. Η σχεδίαση κειμένου με το Cairo πρέπει να γίνεται μόνο αν το κείμενο είναι μέρος ενός γραφικού.

Σε αυτήν την ενότητα του μαθήματος, θα καλύψουμε το βασικό πρότυπο σχεδίασης του Cairo, θα περιγράψουμε κάθε βασικό στοιχείο σχεδίασης με κάποιες λεπτομέρειες (με παραδείγματα) και έπειτα θα παρουσιάσουμε μια απλή εφαρμογή που χρησιμοποιεί Cairo για τη σχεδίαση ενός προσαρμοσμένου γραφικού συστατικού ρολογιού.

### Το πρότυπο σχεδίασης Cairo

Η βασική ιδέα σχεδίασης στο Cairo εμπεριέχει τον ορισμό 'αόρατων' μονοπατιών και έπειτα βάψιμο ή γέμισμά τους για να γίνουν ορατά.

Για να κάνετε οποιαδήποτε σχεδίαση στο gtkmm με το Cairo, πρέπει πρώτα να δημιουργήσετε ένα αντικείμενο Cairo::Context. Αυτή η κλάση κρατά όλες τις παραμέτρους κατάστασης των γραφικών που περιγράφουν πώς πρόκειται να γίνει η σχεδίαση. Αυτό περιλαμβάνει πληροφορίες όπως πλάτος γραμμής, χρώμα, την επιφάνεια για σχεδίαση και πολλά άλλα. Αυτό επιτρέπει στις ενεργές λειτουργίες σχεδίασης να πάρουν λιγότερα ορίσματα για να απλοποιήσουν τη διεπαφή. Στην gtkmm, μια Cairo::Context δημιουργείται καλώντας τη συνάρτηση Gdk::Window::create_cairo_context(). Αφού τα περιεχόμενα Cairo είναι αντικείμενα με μετρημένες αναφορές, αυτή η συνάρτηση επιστρέφει ένα αντικείμενο Cairo::RefPtr<Cairo::Context>.

Το παρακάτω παράδειγμα εμφανίζει πώς να ρυθμιστεί ένα περιεχόμενο Cairo με ένα χρώμα προσκηνίου κόκκινου και ένα πλάτος 2. Οποιεσδήποτε λειτουργίες σχεδίασης που χρησιμοποιούν αυτό το περιεχόμενο θα χρησιμοποιήσουν αυτές τις ρυθμίσεις.

    Gtk::DrawingArea myArea;
    Cairo::RefPtr<Cairo::Context> myContext = myArea.get_window()->create_cairo_context();
    myContext->set_source_rgb(1.0, 0.0, 0.0);
    myContext->set_line_width(2.0);

Κάθε Cairo::Context συσχετίζεται με μια ειδική Gdk::Window, έτσι ώστε η πρώτη γραμμή του παραπάνω παραδείγματος να δημιουργεί ένα γραφικό συστατικό Gtk::DrawingArea και η δεύτερη γραμμή να χρησιμοποιεί την συνδεμένη Gdk::Window για να δημιουργήσει ένα αντικείμενο Cairo::Context. Οι τελικές δύο γραμμές αλλάζουν την κατάσταση γραφικών του περιεχομένου.

Υπάρχει ένας αριθμός από μεταβλητές κατάστασης γραφικών που μπορεί να οριστεί για περιεχόμενο Cairo. Τα πιο κοινά γνωρίσματα περιεχομένου είναι χρώμα (χρησιμοποιώντας set_source_rgb() ή set_source_rgba() για ημιδιαφανή χρώματα), πλάτος γραμμής (χρησιμοποιώντας set_line_width()), μοτίβο παύλας γραμμής (χρησιμοποιώντας set_dash()), τεχνοτροπία άκρου γραμμής (χρησιμοποιώντας set_line_cap()), και τεχνοτροπία ένωσης γραμμών (χρησιμοποιώντας set_line_join()), και τεχνοτροπίες γραμματοσειρών (χρησιμοποιώντας set_font_size(), set_font_face() και άλλες). Υπάρχουν επίσης πολλές άλλες ρυθμίσεις, όπως πίνακες μετασχηματισμών, γέμισμα κανόνων, αν θα εκτελεστεί εξομάλυνση κι άλλες. Για περισσότερες πληροφορίες, δείτε την τεκμηρίωση API cairomm.

The current state of a Cairo::Context can be saved to an internal stack of saved states and later be restored to the state it was in when you saved it. To do this, use the save() method and the restore() method. This can be useful if you need to temporarily change the line width and color (or any other graphics setting) in order to draw something and then return to the previous settings. In this situation, you could call Cairo::Context::save(), change the graphics settings, draw the lines, and then call Cairo::Context::restore() to restore the original graphics state. Multiple calls to save() and restore() can be nested; each call to restore() restores the state from the matching paired save().

It is good practice to put all modifications to the graphics state between save()/restore() function calls. For example, if you have a function that takes a Cairo::Context reference as an argument, you might implement it as follows:

    void doSomething(const Cairo::RefPtr<Cairo::Context>& context, int x)
    {
        context->save();
        // change graphics state
        // perform drawing operations
        context->restore();
    }

Η εικονική μέθοδος on_draw() παρέχει ένα περιεχόμενο Cairo που θα χρησιμοποιήσετε για σχεδίαση στο γραφικό συστατικό Gtk::DrawingArea. Δεν είναι απαραίτητο να αποθηκεύσετε και να επαναφέρετε αυτό το περιεχόμενο Cairo στην on_draw().

### Σχεδίαση ευθειών γραμμών

Now that we understand the basics of the Cairo graphics library, we're almost ready to start drawing. We'll start with the simplest of drawing elements: the straight line. But first you need to know a little bit about Cairo's coordinate system. The origin of the Cairo coordinate system is located in the upper-left corner of the window with positive x values to the right and positive y values going down.

Since the Cairo graphics library was written with support for multiple output targets (the X window system, PNG images, OpenGL, etc), there is a distinction between user-space and device-space coordinates. The mapping between these two coordinate systems defaults to one-to-one so that integer values map roughly to pixels on the screen, but this setting can be adjusted if desired. Sometimes it may be useful to scale the coordinates so that the full width and height of a window both range from 0 to 1 (the 'unit square') or some other mapping that works for your application. This can be done with the Cairo::Context::scale() function.

#### Παράδειγμα

Σε αυτό το παράδειγμα, θα κατασκευάσουμε ένα μικρό, αλλά πλήρως λειτουργικό πρόγραμμα της gtkmm και θα σχεδιάσουμε μερικές γραμμές στο παράθυρο. Οι γραμμές σχεδιάζονται δημιουργώντας ένα μονοπάτι και έπειτα βάφοντας το. Το μονοπάτι δημιουργείται χρησιμοποιώντας τις συναρτήσεις Cairo::Context::move_to() και Cairo::Context::line_to(). Η συνάρτηση move_to() είναι παρόμοια με την πράξη της ανύψωσης του στυλού σας από το χαρτί και της τοποθέτησης του κάπου αλλού -- καμιά γραμμή δεν σχεδιάζεται μεταξύ του σημείου που ήσασταν και του σημείου που πήγατε. Για τη σχεδίαση μιας γραμμής μεταξύ δύο σημείων, χρησιμοποιήστε τη συνάρτηση line_to().

Αφού έχετε τελειώσει τη δημιουργία του μονοπατιού σας, δεν έχετε σχεδιάσει ακόμα τίποτα ορατό ακόμα. Για να κάνετε ορατό το μονοπάτι, πρέπει να χρησιμοποιήσετε τη συνάρτηση stroke() που θα βάψει το τρέχον μονοπάτι με το πλάτος της γραμμής και την τεχνοτροπία που ορίζεται στο αντικείμενό σας Cairo::Context. Μετά την πινελιά, το τρέχον μονοπάτι θα καθαριστεί έτσι ώστε να μπορείτε να ξεκινήσετε με το επόμενο μονοπάτι σας.

Πολλές συναρτήσεις σχεδίασης Cairo έχουν μια παραλλαγή _preserve(). Κανονικά οι συναρτήσεις σχεδίασης όπως clip(), fill(), ή stroke() θα καθαρίσουν την τρέχουσα διαδρομή. Αν χρησιμοποιήσετε την παραλλαγή _preserve(), η τρέχουσα διαδρομή θα διατηρηθεί, έτσι ώστε να μπορείτε να χρησιμοποιήσετε την ίδια διαδρομή με την επόμενη συνάρτηση σχεδίασης.

Περιοχή σχεδίασης - Γραμμές

Source Code

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      //Override default signal handler:
      bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <cairomm/context.h>

    MyArea::MyArea()
    {
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      // coordinates for the center of the window
      int xc, yc;
      xc = width / 2;
      yc = height / 2;

      cr->set_line_width(10.0);

      // draw red lines out from the center of the window
      cr->set_source_rgb(0.8, 0.0, 0.0);
      cr->move_to(0, 0);
      cr->line_to(xc, yc);
      cr->line_to(0, height);
      cr->move_to(xc, yc);
      cr->line_to(width, yc);
      cr->stroke();

      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

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

       Gtk::Window win;
       win.set_title("DrawingArea");

       MyArea area;
       win.add(area);
       area.show();

       return app->run(win);
    }

Αυτό το πρόγραμμα περιέχει μια μοναδική κλάση, MyArea, που είναι υποκλάση της Gtk::DrawingArea και περιέχει μια συνάρτηση μέλους on_draw(). Αυτή η συνάρτηση καλείται όποτε η εικόνα στην περιοχή σχεδίασης χρειάζεται ανασχεδιασμό. Περνιέται ένας δείκτης Cairo::RefPtr στην Cairo::Context που χρησιμοποιούμε για τη σχεδίαση. Ο ενεργός κώδικας σχεδίασης ορίζει το χρώμα που θέλουμε να χρησιμοποιήσουμε για σχεδίαση χρησιμοποιώντας την set_source_rgb() που παίρνει ορίσματα ορίζοντας τα συστατικά κόκκινο, πράσινο και γαλάζιο του επιθυμητού χρώματος (έγκυρες τιμές είναι μεταξύ 0 και 1). Μετά τον ορισμό του χρώματος, δημιουργούμε μια νέα διαδρομή χρησιμοποιώντας τις συναρτήσεις move_to() και line_to() και έπειτα βάφουμε αυτήν τη διαδρομή με stroke().

Σχεδίαση με σχετικές συντεταγμένες

Στο παραπάνω παράδειγμα σχεδιάσαμε καθετί χρησιμοποιώντας απόλυτες συντεταγμένες. Μπορείτε επίσης να σχεδιάσετε χρησιμοποιώντας σχετικές συντεταγμένες. Για μια ευθεία γραμμή, αυτό γίνεται με τη συνάρτηση Cairo::Context::rel_line_to().

#### Τεχνοτροπίες γραμμής

Πέρα από τη σχεδίαση βασικών ευθειών γραμμών, υπάρχει ένας αριθμός από πράγματα που μπορείτε να προσαρμόσετε σε μια γραμμή. Έχετε ήδη δει παραδείγματα ρύθμισης χρώματος και πλάτους γραμμής, αλλά υπάρχουν κι άλλα.

Αν έχετε σχεδιάσει μια σειρά γραμμών που σχηματίζουν μια διαδρομή, μπορεί να θελήσετε να τις ενώσετε μαζί με έναν συγκεκριμένο τρόπο. Το Cairo προσφέρει τρεις διαφορετικούς τρόπους για ένωση γραμμών μεταξύ τους: μύτη, λοξότμηση και στρογγυλό. Αυτά εμφανίζονται παρακάτω:

Διαφορετικοί τύποι ένωσης στο Cairo

Η τεχνοτροπία ένωσης γραμμής ορίζεται χρησιμοποιώντας τη συνάρτηση Cairo::Context::set_line_join().

Τα άκρα της γραμμής μπορούν να έχουν διαφορετικές τεχνοτροπίες επίσης. Η προεπιλεγμένη τεχνοτροπία είναι να αρχίζει και να σταματά η γραμμή ακριβώς στα σημεία προορισμού της γραμμής. Αυτό λέγεται ένα κουτσουρεμένο άκρο. Οι άλλες επιλογές είναι στρογγυλή (χρησιμοποιεί ένα στρογγυλό τέλος, με το κέντρο του κύκλου στο τελικό σημείο) ή τετράγωνη (χρησιμοποιεί ένα τετραγωνισμένο τέλος, με το κέντρο του τετραγώνου στο τελικό σημείο). Αυτή η ρύθμιση ορίζεται χρησιμοποιώντας τη συνάρτηση Cairo::Context::set_line_cap().

Υπάρχουν άλλα πράγματα που μπορείτε να προσαρμόσετε επίσης, συμπεριλαμβανομένων της δημιουργίας γραμμών με παύλες και άλλα. Για περισσότερες πληροφορίες, δείτε την τεκμηρίωση API Cairo.

#### Σχεδίαση λεπτών γραμμών

Αν δοκιμάσετε να σχεδιάσετε γραμμές πλάτους ενός εικονοστοιχείου, μπορεί να σημειώσετε ότι η γραμμή μερικές φορές παρουσιάζεται θολωμένη και πλατύτερη από όσο θα έπρεπε να είναι. Αυτό συμβαίνει επειδή το Cairo θα προσπαθήσει να σχεδιάσει από την επιλεγμένη θέση και στις δυο πλευρές (μισή σε καθεμιά), έτσι αν είσαστε τοποθετημένοι ακριβώς στην τομή των εικονοστοιχείων και θέλετε μια γραμμή με πλάτος ένα εικονοστοιχείο, το Cairo θα προσπαθήσει να χρησιμοποιήσει το μισό κάθε γειτονικού εικονοστοιχείου, που δεν είναι δυνατό (ένα εικονοστοιχείο είναι η μικρότερη δυνατή μονάδα). Αυτό συμβαίνει όταν το πλάτος της γραμμής είναι ένας περιττός αριθμός εικονοστοιχείων (όχι μόνο ένα εικονοστοιχείο).

Το τέχνασμα είναι η τοποθέτηση στη μέση του εικονοστοιχείου όπου θέλετε η γραμμή να σχεδιαστεί και έτσι εγγυάται ότι παίρνετε τα επιθυμητά αποτελέσματα. Δείτε Συχνές ερωτήσεις Cairo.

Περιοχή σχεδίασης - Λεπτές γραμμές

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm/window.h>
    #include <gtkmm/grid.h>
    #include <gtkmm/checkbutton.h>
    #include "myarea.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

    private:
      Gtk::Grid m_Container;
      MyArea m_Area_Lines;
      Gtk::CheckButton m_Button_FixLines;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

      void fix_lines(bool fix = true);
      void force_redraw();

    protected:
      //Override default signal handler:
      bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;

    private:
      double m_fix;
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_Button_FixLines("Fix lines")
    {
      set_title("Thin lines example");

      m_Container.set_orientation(Gtk::ORIENTATION_HORIZONTAL);

      m_Container.add(m_Area_Lines);
      m_Container.add(m_Button_FixLines);

      add(m_Container);

      m_Button_FixLines.signal_toggled().connect(
        sigc::mem_fun(*this, &ExampleWindow::on_button_toggled));

      // Synchonize the drawing in m_Area_Lines with the state of the toggle button.
      on_button_toggled();

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_toggled()
    {
      m_Area_Lines.fix_lines(m_Button_FixLines.get_active());
    }

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"

    MyArea::MyArea()
    : m_fix (0)
    {
      set_size_request (200, 100);
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      cr->set_line_width(1.0);

      // draw one line, every two pixels
      // without the 'fix', you won't notice any space between the lines,
      // since each one will occupy two pixels (width)
      for (int i = 0; i < width; i += 2)
      {
        cr->move_to(i + m_fix, 0);
        cr->line_to(i + m_fix, height);
      }

      cr->stroke();

      return true;
    }

    // Toogle between both values (0 or 0.5)
    void MyArea::fix_lines(bool fix)
    {
      // to get the width right, we have to draw in the middle of the pixel
      m_fix = fix ? 0.5 : 0.0;

      force_redraw();
    }

    // force the redraw of the image
    void MyArea::force_redraw()
    {
      auto win = get_window();
      if (win)
      {
        Gdk::Rectangle r(0, 0, get_allocation().get_width(), get_allocation().get_height());
        win->invalidate_rect(r, false);
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char* argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Σχεδίαση καμπύλων γραμμών

Πέρα από τη σχεδίαση ευθειών γραμμών το Cairo επιτρέπει την εύκολη σχεδίαση καμπύλων γραμμών (τεχνικά μια κυβική εύκαμπτη καμπύλη Bézier) χρησιμοποιώντας τις συναρτήσεις Cairo::Context::curve_to() και Cairo::Context::rel_curve_to(). Αυτές οι συναρτήσεις παίρνουν συντεταγμένες για ένα σημείο προορισμού καθώς και συντεταγμένες για δύο σημεία 'ελέγχου'. Αυτό εξηγείται καλύτερα χρησιμοποιώντας ένα παράδειγμα, έτσι ας μπούμε μέσα.

#### Παράδειγμα

Αυτή η απλή εφαρμογή σχεδιάζει μια καμπύλη με Cairo και εμφανίζει τα σημεία ελέγχου για κάθε άκρο της καμπύλης.

Περιοχή σχεδίασης - Γραμμές

Source Code

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      //Override default signal handler:
      bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <cairomm/context.h>

    MyArea::MyArea()
    {
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      double x0=0.1, y0=0.5, // start point
             x1=0.4, y1=0.9,  // control point #1
             x2=0.6, y2=0.1,  // control point #2
             x3=0.9, y3=0.5;  // end point

      // scale to unit square (0 to 1 width and height)
      cr->scale(width, height);

      cr->set_line_width(0.05);
      // draw curve
      cr->move_to(x0, y0);
      cr->curve_to(x1, y1, x2, y2, x3, y3);
      cr->stroke();
      // show control points
      cr->set_source_rgba(1, 0.2, 0.2, 0.6);
      cr->move_to(x0, y0);
      cr->line_to (x1, y1);
      cr->move_to(x2, y2);
      cr->line_to (x3, y3);
      cr->stroke();

      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

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

       Gtk::Window win;
       win.set_title("DrawingArea");

       MyArea area;
       win.add(area);
       area.show();

       return app->run(win);
    }

Η μόνη διαφορά μεταξύ αυτού του παραδείγματος και του παραδείγματος της ευθείας γραμμής είναι στη συνάρτηση on_draw(), αλλά υπάρχουν λίγες νέες έννοιες και συναρτήσεις που εισήχθησαν εδώ, έτσι ας τις εξετάσουμε συνοπτικά.

Κάνουμε μια κλήση στη Cairo::Context::scale(), περνώντας το πλάτος και το ύψος της περιοχής σχεδίασης. Αυτό κλιμακώνει το σύστημα συντεταγμένων χώρου χρήστη, έτσι ώστε το πλάτος και το ύψος του γραφικού συστατικού να είναι ίσα με 1.0 'μονάδες'. Δεν υπάρχει ειδικός λόγος να κλιμακώσουμε το σύστημα συντεταγμένων σε αυτήν την περίπτωση, αλλά μερικές φορές μπορεί να κάνουμε τη σχεδίαση λειτουργιών ευκολότερα.

Η κλήση στη Cairo::Context::curve_to() πρέπει να είναι επαρκώς αυτονόητη. Το πρώτο ζεύγος συντεταγμένων ορίζει το σημείο ελέγχου για την αρχή της καμπύλης. Το δεύτερο σύνολο των συντεταγμένων ορίζει το σημείο ελέγχου για το τέλος της καμπύλης και το τελευταίο σύνολο συντεταγμένων ορίζει το σημείο προορισμού. Για τη διευκόλυνση της έννοιας των σημείων ελέγχου στην οπτικοποίηση, μια γραμμή έχει σχεδιαστεί από κάθε σημείο ελέγχου στο τελικό σημείο της καμπύλης με το οποίο σχετίζεται. Σημειώστε ότι αυτές οι γραμμές σημείων ελέγχου είναι και οι δυο ημιδιαφανείς. Αυτό πετυχαίνεται με μια παραλλαγή της set_source_rgb() που λέγεται set_source_rgba(). Αυτή η συνάρτηση παίρνει ένα τέταρτο όρισμα που ορίζει την τιμή άλφα του χρώματος (έγκυρες τιμές είναι μεταξύ 0 και 1).

### Σχεδίαση τόξων και κύκλων

Με το Cairo, η ίδια συνάρτηση χρησιμοποιείται για σχεδίαση τόξων, κύκλων ή ελλείψεων: Cairo::Context::arc(). Αυτή συνάρτηση παίρνει πέντε ορίσματα. Τα πρώτα δύο είναι οι συντεταγμένες του κεντρικού σημείου του τόξου, το τρίτο όρισμα είναι η ακτίνα του τόξου και τα τελευταία δυο ορίσματα ορίζουν την αρχή και τη γωνία τέλους του τόξου. Όλες οι γωνίες ορίζονται σε ακτίνια, έτσι η σχεδίαση ενός κύκλου είναι η ίδια με τη σχεδίαση ενός τόξου από 0 έως 2 * M_PI ακτίνια. Μια γωνία 0 είναι η κατεύθυνση του θετικού άξονα Χ (στον χώρο του χρήστη). Μια γωνία M_PI/2 ακτίνια (90 μοίρες) είναι στην κατεύθυνση του θετικού άξονα Υ (στον χώρο του χρήστη). Οι γωνίες αυξάνουν στην κατεύθυνση από τον θετικό άξονα Χ προς τον θετικό άξονα Υ. Έτσι, με τον προεπιλεγμένο πίνακα μετασχηματισμού, οι γωνίες αυξάνουν με δεξιόστροφη κατεύθυνση. (Να θυμάστε ότι θετικός άξονας Υ δείχνει προς τα κάτω.)

To draw an ellipse, you can scale the current transformation matrix by different amounts in the X and Y directions. For example, to draw an ellipse with center at `x`, `y` and size `width`, `height`:

    context->save();
    context->translate(x, y);
    context->scale(width / 2.0, height / 2.0);
    context->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);
    context->restore();

#### Παράδειγμα

Ιδού ένα παράδειγμα απλού προγράμματος που σχεδιάζει ένα τόξο, έναν κύκλο και μια έλλειψη σε μια περιοχή σχεδίασης.

Περιοχή σχεδίασης - Τόξα

Source Code

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      //Override default signal handler:
      bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <cairomm/context.h>
    #include <cmath>

    MyArea::MyArea()
    {
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      // This is where we draw on the window
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();
      const int lesser = MIN(width, height);

      // coordinates for the center of the window
      int xc, yc;
      xc = width / 2;
      yc = height / 2;

      cr->set_line_width(lesser * 0.02);  // outline thickness changes
                                          // with window size

      // first draw a simple unclosed arc
      cr->save();
      cr->arc(width / 3.0, height / 4.0, lesser / 4.0, -(M_PI / 5.0), M_PI);
      cr->close_path();   // line back to start point
      cr->set_source_rgb(0.0, 0.8, 0.0);
      cr->fill_preserve();
      cr->restore();  // back to opaque black
      cr->stroke();   // outline it

      // now draw a circle
      cr->save();
      cr->arc(xc, yc, lesser / 4.0, 0.0, 2.0 * M_PI); // full circle
      cr->set_source_rgba(0.0, 0.0, 0.8, 0.6);    // partially translucent
      cr->fill_preserve();
      cr->restore();  // back to opaque black
      cr->stroke();

      // and finally an ellipse
      double ex, ey, ew, eh;
      // center of ellipse
      ex = xc;
      ey = 3.0 * height / 4.0;
      // ellipse dimensions
      ew = 3.0 * width / 4.0;
      eh = height / 3.0;

      cr->save();

      cr->translate(ex, ey);  // make (ex, ey) == (0, 0)
      cr->scale(ew / 2.0, eh / 2.0);  // for width: ew / 2.0 == 1.0
                                      // for height: eh / 2.0 == 1.0

      cr->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);  // 'circle' centered at (0, 0)
                                              // with 'radius' of 1.0

      cr->set_source_rgba(0.8, 0.0, 0.0, 0.7);
      cr->fill_preserve();
      cr->restore();  // back to opaque black
      cr->stroke();

      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

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

       Gtk::Window win;
       win.set_title("DrawingArea");

       MyArea area;
       win.add(area);
       area.show();

       return app->run(win);
    }

Υπάρχουν κάποια πράγματα να σημειώσετε για αυτόν τον κώδικα του παραδείγματος. Πάλι, η μόνη πραγματική διαφορά μεταξύ αυτού του παραδείγματος και των προηγούμενων είναι η συνάρτηση on_draw(), έτσι θα περιορίσουμε την εστίασή μας σε αυτήν τη συνάρτηση. Επιπλέον, το πρώτο μέρος της συνάρτησης είναι σχεδόν ταυτόσημο με τα προηγούμενα παραδείγματα, έτσι θα παραλείψουμε αυτό το τμήμα.

Σημειώστε ότι σε αυτήν την περίπτωση, έχουμε εκφράσει σχεδόν καθετί ως προς το ύψος και το πλάτος του παραθύρου, συμπεριλαμβάνοντας το πλάτος των γραμμών. Λόγω αυτού, όταν αυξομειώνετε το παράθυρο, καθετί κλιμακώνεται με το παράθυρο. Επίσης, σημειώστε ότι υπάρχουν τρεις ενότητες σχεδίασης στη συνάρτηση και καθεμιά συσκευάζεται με ένα ζεύγος save()/restore(), έτσι ώστε να είμαστε πίσω σε μια γνωστή κατάσταση μετά από κάθε σχεδίαση.

Η ενότητα για σχεδίαση ενός τόξου εισάγει μια νέα συνάρτηση, close_path(). Αυτή η συνάρτηση θα σχεδιάσει στην πραγματικότητα μια ευθεία γραμμή από το τρέχον σημείο πίσω προς το πρώτο σημείο στη διαδρομή. Υπάρχει μια σημαντική διαφορά μεταξύ κλήσης της close_path() και χειροκίνητης σχεδίασης μιας γραμμής πίσω προς το αρχικό σημείο, όμως. Αν χρησιμοποιήσετε την close_path(), οι γραμμές θα ενωθούν ωραία μαζί. Αν χρησιμοποιήσετε την line_to(), οι γραμμές θα τερματίσουν στο ίδιο σημείο, αλλά το Cairo δεν θα κάνει καμιά ειδική ένωση.

Σχεδίαση αριστερόστροφα

Η συνάρτηση Cairo::Context::arc_negative() είναι ακριβώς η ίδια με την Cairo::Context::arc(), αλλά οι γωνίες πηγαίνουν προς την αντίθετη κατεύθυνση.

### Σχεδίαση κειμένου

#### Σχεδίαση κειμένου με Pango

Το κείμενο σχεδιάζεται μέσα από διατάξεις Pango. Ο πιο εύκολος τρόπος για δημιουργία μιας Pango::Layout είναι η χρήση μιας Gtk::Widget::create_pango_layout(). Μόλις δημιουργηθεί, η διάταξη μπορεί να επεξεργαστεί με ποικίλους τρόπους, συμπεριλαμβάνοντας αλλαγή κειμένου, γραμματοσειράς, κλπ. Τελικά, η διάταξη μπορεί να απεικονιστεί χρησιμοποιώντας τη μέθοδο Pango::Layout::show_in_cairo_context().

#### Παράδειγμα

Ιδού ένα παράδειγμα προγράμματος που σχεδιάζει κάποιο κείμενο, κάποιο από αυτό ανάποδα. Το κεφάλαιο εκτύπωσης περιέχει ένα άλλο παράδειγμα σχεδίασης κειμένου.

Περιοχή σχεδίασης - Κείμενο

Source Code

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      //Override default signal handler:
      bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;

    private:
      void draw_rectangle(const Cairo::RefPtr<Cairo::Context>& cr, int width, int height);
      void draw_text(const Cairo::RefPtr<Cairo::Context>& cr, int rectangle_width, int rectangle_height);

    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"

    MyArea::MyArea()
    {
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      const int rectangle_width = width;
      const int rectangle_height = height / 2;

      // Draw a black rectangle
      cr->set_source_rgb(0.0, 0.0, 0.0);
      draw_rectangle(cr, rectangle_width, rectangle_height);

      // and some white text
      cr->set_source_rgb(1.0, 1.0, 1.0);
      draw_text(cr, rectangle_width, rectangle_height);

      // flip the image vertically
      // see http://www.cairographics.org/documentation/cairomm/reference/classCairo_1_1Matrix.html
      // the -1 corresponds to the yy part (the flipping part)
      // the height part is a translation (we could have just called cr->translate(0, height) instead)
      // it's height and not height / 2, since we want this to be on the second part of our drawing
      // (otherwise, it would draw over the previous part)
      Cairo::Matrix matrix(1.0, 0.0, 0.0, -1.0, 0.0, height);

      // apply the matrix
      cr->transform(matrix);

      // white rectangle
      cr->set_source_rgb(1.0, 1.0, 1.0);
      draw_rectangle(cr, rectangle_width, rectangle_height);

      // black text
      cr->set_source_rgb(0.0, 0.0, 0.0);
      draw_text(cr, rectangle_width, rectangle_height);

      return true;
    }

    void MyArea::draw_rectangle(const Cairo::RefPtr<Cairo::Context>& cr,
                                int width, int height)
    {
      cr->rectangle(0, 0, width, height);
      cr->fill();
    }

    void MyArea::draw_text(const Cairo::RefPtr<Cairo::Context>& cr,
                           int rectangle_width, int rectangle_height)
    {
      // http://developer.gnome.org/pangomm/unstable/classPango_1_1FontDescription.html
      Pango::FontDescription font;

      font.set_family("Monospace");
      font.set_weight(Pango::WEIGHT_BOLD);

      // http://developer.gnome.org/pangomm/unstable/classPango_1_1Layout.html
      auto layout = create_pango_layout("Hi there!");

      layout->set_font_description(font);

      int text_width;
      int text_height;

      //get the text dimensions (it updates the variables -- by reference)
      layout->get_pixel_size(text_width, text_height);

      // Position the text in the middle
      cr->move_to((rectangle_width-text_width)/2, (rectangle_height-text_height)/2);

      layout->show_in_cairo_context(cr);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

    int main(int argc, char* argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      Gtk::Window window;
      window.set_title("Drawing text example");

      MyArea area;
      window.add(area);
      area.show();

      return app->run(window);
    }

### Σχεδίαση εικόνων

Υπάρχει μια μέθοδος για σχεδίαση από μια Gdk::Pixbuf σε μια Cairo::Context. Μια ενδιάμεση μνήμη Gdk::Pixbuf είναι ένας χρήσιμος συσκευαστής γύρω από μια συλλογή εικονοστοιχείων, που μπορεί να διαβαστεί από αρχεία και χειρίζεται με ποικίλους τρόπους.

Probably the most common way of creating Gdk::Pixbufs is to use Gdk::Pixbuf::create_from_file() or Gdk::Pixbuf::create_from_resource(), which can read an image file, such as a png file into a pixbuf ready for rendering.

Η Gdk::Pixbuf μπορεί να απεικονιστεί ορίζοντας την ως το πηγαίο υπόδειγμα του περιεχομένου Cairo με την Gdk::Cairo::set_source_pixbuf(). Έπειτα, σχεδιάστε την εικόνα με είτε Cairo::Context::paint() (για σχεδίαση ολόκληρης της εικόνας), ή Cairo::Context::rectangle() και Cairo::Context::fill() (για γέμισμα του συγκεκριμένου ορθογωνίου). Η set_source_pixbuf() δεν είναι μέλος της Cairo::Context. Παίρνει μια Cairo::Context ως την πρώτη της παράμετρο.

Ιδού ένα μικρό τμήμα κώδικα για σύζευξη τους όλων μαζί: (Σημειώστε ότι συνήθως δεν θα πρέπει να φορτώνετε την εικόνα κάθε φορά στον χειριστή σήματος σχεδίασης! Εμφανίζεται απλά εδώ για να τα διατηρήσει όλα μαζί.)

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Glib::RefPtr<Gdk::Pixbuf> image = Gdk::Pixbuf::create_from_file("myimage.png");
      // Draw the image at 110, 90, εκτός από το πιο εξωτερικό 10 pixels.
      Gdk::Cairo::set_source_pixbuf(cr, image, 100, 80);
      cr->rectangle(110, 90, image->get_width()-20, image->get_height()-20);
      cr->fill();
      return true;
    }

#### Παράδειγμα

Here is an example of a simple program that draws an image. The program loads the image from a resource file. See the Gio::Resource and glib-compile-resources section. Use glib-compile-resources to compile the resources into a C source file that can be compiled and linked with the C++ code. E.g.

    $ glib-compile-resources --target=resources.c --generate-source image.gresource.xml

Περιοχή σχεδίασης - Εικόνα

Source Code

File: `myarea.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_MYAREA_H
    #define GTKMM_EXAMPLE_MYAREA_H

    #include <gtkmm/drawingarea.h>
    #include <gdkmm/pixbuf.h>

    class MyArea : public Gtk::DrawingArea
    {
    public:
      MyArea();
      virtual ~MyArea();

    protected:
      //Override default signal handler:
      bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;

      Glib::RefPtr<Gdk::Pixbuf> m_image;
    };

    #endif // GTKMM_EXAMPLE_MYAREA_H

File: `myarea.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <cairomm/context.h>
    #include <giomm/resource.h>
    #include <gdkmm/general.h> // set_source_pixbuf()
    #include <glibmm/fileutils.h>
    #include <iostream>

    MyArea::MyArea()
    {
      try
      {
        // The fractal image has been created by the XaoS program.
        // http://xaos.sourceforge.net
        m_image = Gdk::Pixbuf::create_from_resource("/image/fractal_image.png");
      }
      catch(const Gio::ResourceError& ex)
      {
        std::cerr << "ResourceError: " << ex.what() << std::endl;
      }
      catch(const Gdk::PixbufError& ex)
      {
        std::cerr << "PixbufError: " << ex.what() << std::endl;
      }

      // Show at least a quarter of the image.
      if (m_image)
        set_size_request(m_image->get_width()/2, m_image->get_height()/2);
    }

    MyArea::~MyArea()
    {
    }

    bool MyArea::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      if (!m_image)
        return false;

      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      // Draw the image in the middle of the drawing area, or (if the image is
      // larger than the drawing area) draw the middle part of the image.
      Gdk::Cairo::set_source_pixbuf(cr, m_image,
        (width - m_image->get_width())/2, (height - m_image->get_height())/2);
      cr->paint();

      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "myarea.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

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

      Gtk::Window win;
      win.set_title("DrawingArea");
      win.set_default_size(300, 200);

      MyArea area;
      win.add(area);
      area.show();

      return app->run(win);
    }

File: `image.gresource.xml` (For use with gtkmm 3, not gtkmm 2)

    <?xml version="1.0" encoding="UTF-8"?>
    <gresources>
      <gresource prefix="/image">
        <file>fractal_image.png</file>
      </gresource>
    </gresources>

### Εφαρμογή παραδείγματος: Δημιουργία ενός ρολογιού με Cairo

Τώρα, που έχουμε καλύψει τα βασικά της σχεδίασης με Cairo, ας δοκιμάσουμε να τα βάλουμε όλα μαζί και να δημιουργήσουμε μια απλή εφαρμογή που πράγματι κάνει κάτι. Το παρακάτω παράδειγμα χρησιμοποιεί Cairo για τη δημιουργία ενός προσαρμοσμένου γραφικού συστατικού Clock. Το ρολόι έχει ένα δευτερολεπτοδείκτη, έναν λεπτοδείκτη και έναν ωροδείκτη και ενημερώνει τον εαυτόν του κάθε δευτερόλεπτο.

Source Code

File: `clock.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_CLOCK_H
    #define GTKMM_EXAMPLE_CLOCK_H

    #include <gtkmm/drawingarea.h>

    class Clock : public Gtk::DrawingArea
    {
    public:
      Clock();
      virtual ~Clock();

    protected:
      //Override default signal handler:
      bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;

      bool on_timeout();

      double m_radius;
      double m_line_width;

    };

    #endif // GTKMM_EXAMPLE_CLOCK_H

File: `clock.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <ctime>
    #include <cmath>
    #include <cairomm/context.h>
    #include <glibmm/main.h>
    #include "clock.h"

    Clock::Clock()
    : m_radius(0.42), m_line_width(0.05)
    {
      Glib::signal_timeout().connect( sigc::mem_fun(*this, &Clock::on_timeout), 1000 );
    }

    Clock::~Clock()
    {
    }

    bool Clock::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      Gtk::Allocation allocation = get_allocation();
      const int width = allocation.get_width();
      const int height = allocation.get_height();

      // scale to unit square and translate (0, 0) to be (0.5, 0.5), i.e.
      // the center of the window
      cr->scale(width, height);
      cr->translate(0.5, 0.5);
      cr->set_line_width(m_line_width);

      cr->save();
      cr->set_source_rgba(0.337, 0.612, 0.117, 0.9);   // green
      cr->paint();
      cr->restore();
      cr->arc(0, 0, m_radius, 0, 2 * M_PI);
      cr->save();
      cr->set_source_rgba(1.0, 1.0, 1.0, 0.8);
      cr->fill_preserve();
      cr->restore();
      cr->stroke_preserve();
      cr->clip();

      //clock ticks
      for (int i = 0; i < 12; i++)
      {
        double inset = 0.05;

        cr->save();
        cr->set_line_cap(Cairo::LINE_CAP_ROUND);

        if(i % 3 != 0)
        {
          inset *= 0.8;
          cr->set_line_width(0.03);
        }

        cr->move_to(
          (m_radius - inset) * cos (i * M_PI / 6),
          (m_radius - inset) * sin (i * M_PI / 6));
        cr->line_to (
          m_radius * cos (i * M_PI / 6),
          m_radius * sin (i * M_PI / 6));
        cr->stroke();
        cr->restore(); /* stack-pen-size */
      }

      // store the current time
      time_t rawtime;
      time(&rawtime);
      struct tm * timeinfo = localtime (&rawtime);

      // compute the angles of the indicators of our clock
      double minutes = timeinfo->tm_min * M_PI / 30;
      double hours = timeinfo->tm_hour * M_PI / 6;
      double seconds= timeinfo->tm_sec * M_PI / 30;

      cr->save();
      cr->set_line_cap(Cairo::LINE_CAP_ROUND);

      // draw the seconds hand
      cr->save();
      cr->set_line_width(m_line_width / 3);
      cr->set_source_rgba(0.7, 0.7, 0.7, 0.8); // gray
      cr->move_to(0, 0);
      cr->line_to(sin(seconds) * (m_radius * 0.9),
        -cos(seconds) * (m_radius * 0.9));
      cr->stroke();
      cr->restore();

      // draw the minutes hand
      cr->set_source_rgba(0.117, 0.337, 0.612, 0.9);   // blue
      cr->move_to(0, 0);
      cr->line_to(sin(minutes + seconds / 60) * (m_radius * 0.8),
        -cos(minutes + seconds / 60) * (m_radius * 0.8));
      cr->stroke();

      // draw the hours hand
      cr->set_source_rgba(0.337, 0.612, 0.117, 0.9);   // green
      cr->move_to(0, 0);
      cr->line_to(sin(hours + minutes / 12.0) * (m_radius * 0.5),
        -cos(hours + minutes / 12.0) * (m_radius * 0.5));
      cr->stroke();
      cr->restore();

      // draw a little dot in the middle
      cr->arc(0, 0, m_line_width / 3.0, 0, 2 * M_PI);
      cr->fill();

      return true;
    }

    bool Clock::on_timeout()
    {
        // force our program to redraw the entire clock.
        auto win = get_window();
        if (win)
        {
            Gdk::Rectangle r(0, 0, get_allocation().get_width(),
                    get_allocation().get_height());
            win->invalidate_rect(r, false);
        }
        return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "clock.h"
    #include <gtkmm/application.h>
    #include <gtkmm/window.h>

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

       Gtk::Window win;
       win.set_title("Cairomm Clock");

       Clock c;
       win.add(c);
       c.show();

       return app->run(win);
    }

Όπως πριν, όλο σχεδόν το ενδιαφέρον υλικό γίνεται στον χειριστή σήματος σχεδίασης on_draw(). Πριν εμβαθύνουμε στον χειριστή σήματος σχεδίασης, σημειώστε ότι ο κατασκευαστής για το γραφικό συστατικό Clock συνδέει μια συνάρτηση χειριστή on_timeout() με ένα χρονόμετρο με μια περίοδο λήξης χρόνου των 1000 χιλιοστοδευτερολέπτων (1 δευτερολέπτου). Αυτό σημαίνει ότι η on_timeout() θα καλείται μια φορά ανά δευτερόλεπτο. Η μόνη ευθύνη αυτής της συνάρτησης είναι η ακύρωση του παραθύρου έτσι ώστε η gtkmm να εξαναγκαστεί να το ανασχεδιάσει.

Τώρα, ας ρίξουμε μια ματιά στον κώδικα που εκτελεί την ενεργή σχεδίαση. Η πρώτη ενότητα της on_draw() πρέπει να είναι αρκετά οικεία μέχρι τώρα. Αυτό το παράδειγμα κλιμακώνει πάλι το σύστημα συντεταγμένων για να είναι μια τετράγωνη μονάδα, έτσι ώστε να είναι ευκολότερη η σχεδίαση του ρολογιού ως ποσοστού του μεγέθους του παραθύρου, έτσι ώστε να κλιμακώσει αυτόματα όταν το μέγεθος του παραθύρου προσαρμόζεται. Επιπλέον, το σύστημα συντεταγμένων κλιμακώνεται πάνω και κάτω έτσι ώστε η συντεταγμένη (0, 0) να είναι ακριβώς στο κέντρο του παραθύρου.

Η συνάρτηση Cairo::Context::paint() χρησιμοποιείται εδώ για να ορίσει το χρώμα παρασκηνίου του παραθύρου. Αυτή η συνάρτηση δεν παίρνει ορίσματα και γεμίζει την τρέχουσα επιφάνεια (ή το αποκομμένο τμήμα της επιφάνειας) με το τρέχον ενεργό πηγαίο χρώμα. Μετά τον ορισμό του χρώματος παρασκηνίου του παραθύρου, σχεδιάζουμε έναν κύκλο για το περίγραμμα του ρολογιού, το γεμίζουμε με λευκό και έπειτα βάφουμε το περίγραμμα με μαύρο. Σημειώστε ότι και οι δυο αυτές ενέργειες χρησιμοποιούν την παραλλαγή _preserve για να διατηρήσουν το τρέχον μονοπάτι και έπειτα αυτό το ίδιο το μονοπάτι περικόπτεται για να διασφαλίσει ότι οι επόμενες γραμμές μας δεν θα πάνε έξω από το περίγραμμα του ρολογιού.

Μετά τη σχεδίαση του περιγράμματος, πηγαίνουμε γύρω από το ρολόι και σχεδιάζουμε υποδιαιρέσεις για κάθε ώρα, με μια μεγαλύτερη υποδιαίρεση στα 12, 3, 6 και 9. Τώρα, τελικά είμαστε έτοιμοι να υλοποιήσουμε την λειτουργία διατήρησης του χρόνου του ρολογιού, που εμπεριέχει απλά τη λήψη των τρεχουσών τιμών για ώρες, λεπτά και δευτερόλεπτα και σχεδίαση των δεικτών στις σωστές γωνίες.

## Μεταφορά κι απόθεση

Η Gtk::Widget έχει αρκετές μεθόδους και σήματα με πρόθεμα "drag_". Αυτά χρησιμοποιούνται για μεταφορά και απόθεση.

### Πηγές και προορισμοί

Τα πράγματα μεταφέρονται από `πηγές` για να αποτεθούν σε `προορισμούς`. Κάθε πηγή και προορισμός έχει πληροφορίες για τις μορφές δεδομένων που μπορεί να στείλει ή να δεχτεί, που παρέχονται από τα στοιχεία Gtk::TargetEntry. Ένας προορισμός απόθεσης θα δεχτεί μόνο ένα μεταφερόμενο στοιχείο αν και οι δυο μοιράζονται ένα συμβατό στοιχείο Gtk::TargetEntry. Κατάλληλα σήματα θα εκπεμφθούν τότε, λέγοντας στους χειριστές σήματος ποια Gtk::TargetEntry.

Gtk::TargetEntry objects contain this information:

- target: A name, such as "STRING"

- info: An identifier which will be sent to your signals to tell you which TargetEntry was used.

- flags: Used only for drag and drop, this specifies whether the data may be dragged to other widgets and applications, or only to the same ones.

### Μέθοδοι

Η Widgets μπορεί να ταυτοποιηθεί ως πηγές ή προορισμοί χρησιμοποιώντας αυτές τις μεθόδους Gtk::Widget:

    void drag_source_set(const std::vector<Gtk::TargetEntry>& targets,
          Gdk::ModifierType start_button_mask, Gdk::DragAction actions);

- Το `targets` είναι ένα διάνυσμα των στοιχείων Gtk::TargetEntry.

- `start_button_mask` είναι ένας συνδυασμός τιμών ORed, που ορίζει ποιο πλήκτρο τροποποίησης ή πλήκτρο του ποντικιού πρέπει να πατηθεί για να ξεκινήσει η μεταφορά.

- `actions` είναι ένας συνδυασμός τιμών ORed, που ορίζει ποιες λειτουργίες μεταφοράς και απόθεσης θα είναι δυνατές από αυτήν την πηγή - για παράδειγμα, αντιγραφή, μετακίνηση, ή σύνδεση. Ο χρήστης μπορεί να επιλέξει μεταξύ των ενεργειών χρησιμοποιώντας πλήκτρα τροποποίησης, όπως Shift για αλλαγή από `copy` σε `move` και αυτό θα εμφανιστεί από έναν διαφορετικό δρομέα.

    void drag_dest_set(const std::vector<Gtk::TargetEntry>& targets,
        Gtk::DestDefaults flags, Gdk::DragAction actions);

- Οι `flags` είναι ένας συνδυασμός τιμών ORed που δείχνει πώς θα απαντήσει οπτικά το γραφικό συστατικό σε στοιχεία μεταφοράς και απόθεσης.

- Οι `actions` δείχνουν τις ενέργειες μεταφοράς και απόθεσης που αυτός ο προορισμός μπορεί να δεχτεί - δείτε την παραπάνω περιγραφή.

### Σήματα

Όταν ένας προορισμός απόθεσης έχει αποδεχτεί ένα μεταφερόμενο στοιχείο, συγκεκριμένα σήματα θα εκπεμφθούν, ανάλογα με το ποια ενέργεια έχει επιλεγεί. Για παράδειγμα, ο χρήστης μπορεί να έχει πατημένο το πλήκτρο Shift για να ορίσει μια `move` αντί για μια `copy`. Να θυμάστε ότι ο χρήστης μπορεί να επιλέξει μόνο τις ενέργειες που έχετε ορίσει στις κλήσεις σας στις drag_dest_set() και drag_source_set().

#### Αντιγραφή

The source widget will emit these signals, in this order:

- `drag_begin`: Provides DragContext.

- `drag_data_get`: Provides `info` about the dragged data format, and a `Gtk::SelectionData` structure, in which you should put the requested data.

- `drag_end`: Provides DragContext.

The destination widget will emit these signals, in this order:

- `drag_motion`: Provides DragContext and coordinates. You can call the drag_status() method of the DragContext to indicate which action will be accepted.

- `drag_drop`: Provides DragContext and coordinates. You can call drag_get_data(), which triggers the `drag_data_get` signal in the source widget, and then the `drag_data_received` signal in the destination widget.

- `drag_data_received`: Provides `info` about the dragged data format, and a `Gtk::SelectionData` structure which contains the dropped data. You should call the drag_finish() method of the `DragContext` to indicate whether the operation was successful.

#### Μετακίνηση

During a `move`, the source widget will also emit this signal:

- `drag_data_delete`: Gives the source the opportunity to delete the original data if that's appropriate.

### Περιεχόμενο μεταφοράς (DragContext)

Τα σήματα μεταφοράς και απόθεσης παρέχουν ένα DragContext, που περιέχει κάποια πληροφορία για τη λειτουργία μεταφοράς και απόθεσης και μπορεί να χρησιμοποιηθεί για να επηρεάσει τη διεργασία. Για παράδειγμα, μπορείτε να ανακαλύψετε το πηγαίο γραφικό συστατικό, ή να αλλάξετε το εικονίδιο της μεταφοράς και απόθεσης, χρησιμοποιώντας τις μεθόδους set_icon(). Πιο σημαντικό, θα πρέπει να καλέσετε τη μέθοδο drag_finish() από τον χειριστή σήματός σας `drag_data_received` για να δείξετε αν η απόθεση ήταν πετυχημένη.

### Παράδειγμα

Να ένα πολύ απλό παράδειγμα, που δείχνει μια λειτουργία μεταφοράς και απόθεσης `Copy`:

Μεταφορά κι απόθεση

Source Code

File: `dndwindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_DNDWINDOW_H
    #define GTKMM_EXAMPLE_DNDWINDOW_H

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

    class DnDWindow : public Gtk::Window
    {

    public:
      DnDWindow();
      virtual ~DnDWindow();

    protected:
      //Signal handlers:
      void on_button_drag_data_get(
              const Glib::RefPtr<Gdk::DragContext>& context,
              Gtk::SelectionData& selection_data, guint info, guint time);
      void on_label_drop_drag_data_received(
              const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
              const Gtk::SelectionData& selection_data, guint info, guint time);

      //Member widgets:
      Gtk::Box m_HBox;
      Gtk::Button m_Button_Drag;
      Gtk::Label m_Label_Drop;
    };

    #endif // GTKMM_EXAMPLE_DNDWINDOW_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "dndwindow.h"
    #include <gtkmm/application.h>

    int main (int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      DnDWindow dndWindow;

      //Shows the window and returns when it is closed.
      return app->run(dndWindow);
    }

File: `dndwindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    DnDWindow::DnDWindow()
    : m_Button_Drag("Drag Here\n"),
      m_Label_Drop("Drop here\n")
    {
      set_title("DnD example");

      add(m_HBox);

      //Targets:
      std::vector<Gtk::TargetEntry> listTargets;
      listTargets.push_back( Gtk::TargetEntry("STRING") );
      listTargets.push_back( Gtk::TargetEntry("text/plain") );

      //Drag site:

      //Make m_Button_Drag a DnD drag source:
      m_Button_Drag.drag_source_set(listTargets);

      //Connect signals:
      m_Button_Drag.signal_drag_data_get().connect(sigc::mem_fun(*this,
                  &DnDWindow::on_button_drag_data_get));

      m_HBox.pack_start(m_Button_Drag);

      //Drop site:

      //Make m_Label_Drop a DnD drop destination:
      m_Label_Drop.drag_dest_set(listTargets);

      //Connect signals:
      m_Label_Drop.signal_drag_data_received().connect(sigc::mem_fun(*this,
                  &DnDWindow::on_label_drop_drag_data_received) );

      m_HBox.pack_start(m_Label_Drop);

      show_all();
    }

    DnDWindow::~DnDWindow()
    {
    }

    void DnDWindow::on_button_drag_data_get(
            const Glib::RefPtr<Gdk::DragContext>&,
            Gtk::SelectionData& selection_data, guint, guint)
    {
      selection_data.set(selection_data.get_target(), 8 /* 8 bits format */,
              (const guchar*)"I'm Data!",
              9 /* the length of I'm Data! in bytes */);
    }

    void DnDWindow::on_label_drop_drag_data_received(
            const Glib::RefPtr<Gdk::DragContext>& context, int, int,
            const Gtk::SelectionData& selection_data, guint, guint time)
    {
      const int length = selection_data.get_length();
      if((length >= 0) && (selection_data.get_format() == 8))
      {
        std::cout << "Received \"" << selection_data.get_data_as_string()
            << "\" in label " << std::endl;
      }

      context->drag_finish(false, false, time);
    }

Υπάρχει ένα πιο σύνθετο παράδειγμα στο examples/others/dnd.

## Το πρόχειρο

Η λειτουργία αντιγραφής-επικόλλησης απλού κειμένου παρέχεται ελεύθερα από γραφικά συστατικά όπως Gtk::Entry και Gtk::TextView, αλλά μπορεί να χρειαστείτε ειδικό κώδικα για να αντιμετωπίσετε τις δικές σας μορφές δεδομένων. Για παράδειγμα, ένα πρόγραμμα σχεδίασης μπορεί να χρειαστεί ειδικό κώδικα για να επιτρέψει την αντιγραφή και επικόλληση μέσα σε μια προβολή, ή μεταξύ εγγράφων.

Μπορείτε συνήθως να προσποιηθείτε ότι η Gtk::Clipboard είμαι μια singleton. Μπορείτε να πάρετε ένα προεπιλεγμένο στιγμιότυπο προχείρου με Gtk::Clipboard::get(). Αυτό είναι προφανώς το μόνο πρόχειρο που θα χρειαστείτε ποτέ.

Η εφαρμογή σας δεν χρειάζεται να περιμένει για τις λειτουργίες του προχείρου, ιδιαίτερα μεταξύ του χρόνου όταν ο χρήστης επιλέγει αντιγραφή και έπειτα αργότερα επιλέγει επικόλληση. Οι περισσότερες μέθοδοι Gtk::Clipboard παίρνουν sigc::slots που ορίζουν μεθόδους επανάκλησης. Όταν η Gtk::Clipboard είναι έτοιμη, θα καλέσει αυτές τις μεθόδους, είτε παρέχοντας τα ζητούμενα δεδομένα, είτε ζητώντας τα δεδομένα.

Reference

### Προορισμοί

Διαφορετικές εφαρμογές περιέχουν διαφορετικούς τύπους δεδομένων και μπορεί να κάνουν τα δεδομένα διαθέσιμα σε μια ποικιλία μορφών. Η gtkmm καλεί αυτούς τους τύπους δεδομένων `target`s.

Για παράδειγμα, η gedit μπορεί να παρέχει και να δέχεται τον προορισμό `"UTF8_STRING"`, έτσι μπορείτε να επικολλήσετε δεδομένα στην gedit από οποιαδήποτε εφαρμογή που δίνει αυτόν τον προορισμό. Ή δύο διαφορετικές εφαρμογές επεξεργασίας εικόνας μπορεί να παρέχουν και να δέχονται μια ποικιλία μορφών εικόνας ως προορισμούς. Όσο μια εφαρμογή μπορεί να δεχτεί έναν από τους προορισμούς που η άλλη παρέχει, τόσο θα μπορείτε να αντιγράψετε δεδομένα από την μία στην άλλη.

Ένας προορισμός μπορεί να είναι σε μια ποικιλία δυαδικών μορφών. Αυτό το κεφάλαιο και τα παραδείγματα θεωρούν ότι τα δεδομένα είναι κείμενο 8 δυαδικών. Αυτό μπορεί να επιτρέψει τη χρήση μιας μορφής XML για τα δεδομένα του προχείρου. Όμως, αυτό μπορεί προφανώς να μην είναι κατάλληλο για δυαδικά δεδομένα όπως εικόνες. Η Gtk::Clipboard δίνει υπερφορτώσεις που επιτρέπουν τον ορισμό μορφής με περισσότερη λεπτομέρεια αν είναι απαραίτητο.

Η API της Μεταφοράς και απόθεσης χρησιμοποιεί τον ίδιο μηχανισμό. Θα πρέπει προφανώς να χρησιμοποιήσετε τα ίδια δεδομένα προορισμών και μορφών και για το πρόχειρο και για τη μεταφορά και απόθεση.

### Αντιγραφή

Όταν ο χρήστης ζητά να αντιγράψει κάποια δεδομένα, θα πρέπει να πείτε στο Clipboard ποιοι προορισμοί είναι διαθέσιμοι και να δώσετε τις μεθόδους επανάκλησης που μπορεί να χρησιμοποιηθούν για τη λήψη δεδομένων. Σε αυτό το σημείο θα πρέπει να αποθηκεύσετε ένα αντίγραφο των δεδομένων, για να δοθεί όταν το πρόχειρο καλέσει τη μέθοδο επανάκλησης σε απάντηση για μια επικόλληση.

Για παράδειγμα,

    Glib::RefPtr<Gtk::Clipboard> refClipboard = Gtk::Clipboard::get();

    //Προορισμοί:
    std::vector<Gtk::TargetEntry> targets;
    targets.push_back( Gtk::TargetEntry("example_custom_target") );
    targets.push_back( Gtk::TargetEntry("UTF8_STRING") );

    refClipboard->set( targets,
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_get),
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_clear) );

Η επανάκληση θα δώσει τότε τα αποθηκευμένα δεδομένα, όταν ο χρήστης επιλέγει την επικόλληση δεδομένων. Για παράδειγμα:

    void ExampleWindow::on_clipboard_get(
        Gtk::SelectionData& selection_data, guint /* info */)
    {
      const std::string target = selection_data.get_target();

      if(target == "example_custom_target")
        selection_data.set("example_custom_target", m_ClipboardStore);
    }

Το `ideal` παράδειγμα παρακάτω μπορεί να δώσει περισσότερους από έναν προορισμούς προχείρου.

Η επανάκληση καθαρισμού επιτρέπει την απελευθέρωση χρησιμοποιούμενης μνήμης από τα αποθηκευμένα δεδομένα όταν το πρόχειρο αντικαθιστά τα δεδομένα του με κάτι άλλο.

### Επικόλληση

Όταν ο χρήστης ζητά την επικόλληση δεδομένων από την Clipboard, θα πρέπει να ζητήσετε μια ειδική μορφή και να δώσετε μια μέθοδο επανάκλησης που θα κληθεί με τα ενεργά δεδομένα. Για παράδειγμα:

    refClipboard->request_contents("example_custom_target",
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_received) );

Ιδού ένα παράδειγμα μεθόδου επανάκλησης:

    void ExampleWindow::on_clipboard_received(
        const Gtk::SelectionData& selection_data)
    {
      Glib::ustring clipboard_data = selection_data.get_data_as_string();
      //Do something with the pasted data.
    }

#### Εύρεση των διαθέσιμων προορισμών

Για την εύρεση των προορισμών που είναι προς το παρόν διαθέσιμοι στην Clipboard για επικόλληση, καλέστε τη μέθοδο request_targets(), ορίζοντας μια μέθοδο για κλήση με την πληροφορία. Για παράδειγμα:

    refClipboard->request_targets( sigc::mem_fun(*this,
        &ExampleWindow::on_clipboard_received_targets) )·

Αν η επανάκλησή σας, συγκρίνεται το διάνυσμα των διαθέσιμων προορισμών με αυτά που υποστηρίζει η εφαρμογή σας για επικόλληση. Μπορείτε να ενεργοποιήσετε ή να απενεργοποιήσετε το στοιχείο μενού επικόλλησης, ανάλογα με το αν η επικόλληση είναι προς το παρόν δυνατή. Για παράδειγμα:

    void ExampleWindow::on_clipboard_received_targets(
      const std::vector<Glib::ustring>& targets)
    {
      const bool bPasteIsPossible =
        std::find(targets.begin(), targets.end(),
          example_target_custom) != targets.end();

      // Ενεργοποίηση/απενεργοποίηση του κατάλληλου κουμπιού επικόλλησης:
      m_Button_Paste.set_sensitive(bPasteIsPossible);
    }

### Παραδείγματα

#### Απλό

Αυτό το παράδειγμα επιτρέπει αντιγραφή και επικόλληση των ειδικών δεδομένων εφαρμογής, χρησιμοποιώντας τον τυπικό προορισμό κειμένου. Αν και είναι απλό, δεν είναι ιδανικό επειδή δεν αναγνωρίζει ότι τα δεδομένα Clipboard δεν είναι ειδικού τύπου.

Πρόχειρο - Απλό

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_copy();
      void on_button_paste();
      void on_clipboard_text_received(const Glib::ustring& text);

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::Label m_Label;

      Gtk::Grid m_Grid;
      Gtk::ToggleButton m_ButtonA1, m_ButtonA2, m_ButtonB1, m_ButtonB2;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Copy, m_Button_Paste;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Label("Select cells in the grid, click Copy, then open a second "
            "instance of this example to try pasting the copied data."),
      m_ButtonA1("A1"), m_ButtonA2("A2"), m_ButtonB1("B1"), m_ButtonB2("B2"),
      m_Button_Copy("_Copy", /* mnemonic= */ true), m_Button_Paste("_Paste", true)
    {
      set_title("Gtk::Clipboard example");
      set_border_width(12);

      add(m_VBox);

      m_VBox.pack_start(m_Label, Gtk::PACK_SHRINK);

      //Fill Grid:
      m_VBox.pack_start(m_Grid);
      m_Grid.set_row_homogeneous(true);
      m_Grid.set_column_homogeneous(true);
      m_Grid.attach(m_ButtonA1, 0, 0, 1, 1);
      m_Grid.attach(m_ButtonA2, 1, 0, 1, 1);
      m_Grid.attach(m_ButtonB1, 0, 1, 1, 1);
      m_Grid.attach(m_ButtonB2, 1, 1, 1, 1);

      //Add ButtonBox to bottom:
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);
      m_VBox.set_spacing(6);

      //Fill ButtonBox:
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_ButtonBox.pack_start(m_Button_Copy, Gtk::PACK_SHRINK);
      m_Button_Copy.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_copy) );
      m_ButtonBox.pack_start(m_Button_Paste, Gtk::PACK_SHRINK);
      m_Button_Paste.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_paste) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_copy()
    {
      //Build a string representation of the stuff to be copied:
      //Ideally you would use XML, with an XML parser here:
      Glib::ustring strData;
      strData += m_ButtonA1.get_active() ? "1" : "0";
      strData += m_ButtonA2.get_active() ? "1" : "0";
      strData += m_ButtonB1.get_active() ? "1" : "0";
      strData += m_ButtonB2.get_active() ? "1" : "0";

      auto refClipboard = Gtk::Clipboard::get();
      refClipboard->set_text(strData);
    }

    void ExampleWindow::on_button_paste()
    {
      //Tell the clipboard to call our method when it is ready:
      auto refClipboard = Gtk::Clipboard::get();
      refClipboard->request_text(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_text_received) );
    }

    void ExampleWindow::on_clipboard_text_received(const Glib::ustring& text)
    {
      //See comment in on_button_copy() about this silly clipboard format.
      if(text.size() >= 4)
      {
        m_ButtonA1.set_active( text[0] == '1' );
        m_ButtonA2.set_active( text[1] == '1' );
        m_ButtonB1.set_active( text[2] == '1' );
        m_ButtonB2.set_active( text[3] == '1' );
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      //APPLICATION_NON_UNIQUE because it shall be possible to run several
      //instances of this application simultaneously.
      auto app = Gtk::Application::create(
        argc, argv, "org.gtkmm.example", Gio::APPLICATION_NON_UNIQUE);

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

#### Ιδανικό

This is like the simple example, but it

1. Defines a custom clipboard target, though the format of that target is still text.

2. It supports pasting of 2 targets - both the custom one and a text one that creates an arbitrary text representation of the custom data.

3. It uses request_targets() and the `owner_change` signal and disables the Paste button if it can't use anything on the clipboard.

Πρόχειρο - Ιδανικό

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_button_copy();
      void on_button_paste();

      void on_clipboard_owner_change(GdkEventOwnerChange* event);
      void on_clipboard_get(Gtk::SelectionData& selection_data, guint info);
      void on_clipboard_clear();

      void on_clipboard_received(const Gtk::SelectionData& selection_data);
      void on_clipboard_received_targets(const std::vector<Glib::ustring>& targets);

      void update_paste_status(); //Disable the paste button if there is nothing to paste.

      //Child widgets:
      Gtk::Box m_VBox;

      Gtk::Label m_Label;

      Gtk::Grid m_Grid;
      Gtk::ToggleButton m_ButtonA1, m_ButtonA2, m_ButtonB1, m_ButtonB2;

      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Copy, m_Button_Paste;

      Glib::ustring m_ClipboardStore; //Keep copied stuff here, until it is pasted. This could be a big complex data structure.
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <algorithm>

    namespace
    {

    //These should usually be MIME types.
    const char example_target_custom[] = "gtkmmclipboardexample";
    const char example_target_text[]   = "UTF8_STRING";

    } // anonymous namespace

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Label("Select cells in the grid, click Copy, then open a second instance "
              "of this example to try pasting the copied data.\nOr try pasting the "
              "text representation into gedit."),
      m_ButtonA1("A1"), m_ButtonA2("A2"), m_ButtonB1("B1"), m_ButtonB2("B2"),
      m_Button_Copy("_Copy", /* mnemonic= */ true), m_Button_Paste("_Paste", true)
    {
      set_title("Gtk::Clipboard example");
      set_border_width(12);

      add(m_VBox);

      m_VBox.pack_start(m_Label, Gtk::PACK_SHRINK);

      //Fill Grid:
      m_VBox.pack_start(m_Grid);
      m_Grid.set_row_homogeneous(true);
      m_Grid.set_column_homogeneous(true);
      m_Grid.attach(m_ButtonA1, 0, 0, 1, 1);
      m_Grid.attach(m_ButtonA2, 1, 0, 1, 1);
      m_Grid.attach(m_ButtonB1, 0, 1, 1, 1);
      m_Grid.attach(m_ButtonB2, 1, 1, 1, 1);

      //Add ButtonBox to bottom:
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);
      m_VBox.set_spacing(6);

      //Fill ButtonBox:
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_ButtonBox.pack_start(m_Button_Copy, Gtk::PACK_SHRINK);
      m_Button_Copy.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_copy) );
      m_ButtonBox.pack_start(m_Button_Paste, Gtk::PACK_SHRINK);
      m_Button_Paste.signal_clicked().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_button_paste) );

      //Connect a signal handler that will be called when the contents of
      //the clipboard change.
      Gtk::Clipboard::get()->signal_owner_change().connect(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_owner_change) );

      show_all_children();

      update_paste_status();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_copy()
    {
      //Build a string representation of the stuff to be copied:
      //Ideally you would use XML, with an XML parser here:
      Glib::ustring strData;
      strData += m_ButtonA1.get_active() ? "1" : "0";
      strData += m_ButtonA2.get_active() ? "1" : "0";
      strData += m_ButtonB1.get_active() ? "1" : "0";
      strData += m_ButtonB2.get_active() ? "1" : "0";

      auto refClipboard = Gtk::Clipboard::get();

      //Targets:
      std::vector<Gtk::TargetEntry> targets;

      targets.push_back( Gtk::TargetEntry(example_target_custom) );
      targets.push_back( Gtk::TargetEntry(example_target_text) );

      refClipboard->set(targets,
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_get),
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_clear) );

      //Store the copied data until it is pasted:
      //(Must be done after the call to refClipboard->set(), because that call
      //may trigger a call to on_clipboard_clear.)
      m_ClipboardStore = strData;

      update_paste_status();
    }

    void ExampleWindow::on_button_paste()
    {
      //Tell the clipboard to call our method when it is ready:
      auto refClipboard = Gtk::Clipboard::get();

      refClipboard->request_contents(example_target_custom,
        sigc::mem_fun(*this, &ExampleWindow::on_clipboard_received) );

      update_paste_status();
    }

    void ExampleWindow::on_clipboard_owner_change(GdkEventOwnerChange*)
    {
      update_paste_status();
    }

    void ExampleWindow::on_clipboard_get(Gtk::SelectionData& selection_data,
      guint /* info */)
    {
      // info corresponds to the optional info parameter in Gtk::TargetEntry's
      // constructor. We don't use that, so we use selection_data's target instead.

      const std::string target = selection_data.get_target();

      if(target == example_target_custom)
      {
        // This set() override uses an 8-bit text format for the data.
        selection_data.set(example_target_custom, m_ClipboardStore);
      }
      else if(target == example_target_text)
      {
        //Build some arbitrary text representation of the data,
        //so that people see something when they paste into a text editor:
        Glib::ustring text_representation;

        text_representation += m_ButtonA1.get_active() ? "A1, " : "";
        text_representation += m_ButtonA2.get_active() ? "A2, " : "";
        text_representation += m_ButtonB1.get_active() ? "B1, " : "";
        text_representation += m_ButtonB2.get_active() ? "B2, " : "";

        selection_data.set_text(text_representation);
      }
      else
      {
        g_warning("ExampleWindow::on_clipboard_get(): "
                "Unexpected clipboard target format.");
      }
    }

    void ExampleWindow::on_clipboard_clear()
    {
      //This isn't really necessary. I guess it might save memory.
      m_ClipboardStore.clear();
    }

    void ExampleWindow::on_clipboard_received(
            const Gtk::SelectionData& selection_data)
    {
      const std::string target = selection_data.get_target();

      //It should always be this, because that's what we asked for when calling
      //request_contents().
      if(target == example_target_custom)
      {
        Glib::ustring clipboard_data = selection_data.get_data_as_string();

        //See comment in on_button_copy() about this silly clipboard format.
        if(clipboard_data.size() >= 4)
        {
          m_ButtonA1.set_active( clipboard_data[0] == '1' );
          m_ButtonA2.set_active( clipboard_data[1] == '1' );
          m_ButtonB1.set_active( clipboard_data[2] == '1' );
          m_ButtonB2.set_active( clipboard_data[3] == '1' );
        }
      }
    }

    void ExampleWindow::update_paste_status()
    {
      //Disable the paste button if there is nothing to paste.

      auto refClipboard = Gtk::Clipboard::get();

      //Discover what targets are available:
      refClipboard->request_targets(sigc::mem_fun(*this,
                  &ExampleWindow::on_clipboard_received_targets) );
    }

    void ExampleWindow::on_clipboard_received_targets(
      const std::vector<Glib::ustring>& targets)
    {
      const bool bPasteIsPossible =
        std::find(targets.begin(), targets.end(),
          example_target_custom) != targets.end();

      // Enable/Disable the Paste button appropriately:
      m_Button_Paste.set_sensitive(bPasteIsPossible);
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      //APPLICATION_NON_UNIQUE because it shall be possible to run several
      //instances of this application simultaneously.
      auto app = Gtk::Application::create(
        argc, argv, "org.gtkmm.example", Gio::APPLICATION_NON_UNIQUE);

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## Εκτύπωση

Στο επίπεδο ανάπτυξης της εφαρμογής, η API εκτύπωσης της gtkmm παρέχει διαλόγους που είναι ομοιόμορφοι στις εφαρμογές και επιτρέπει την χρήση κοινής API σχεδίασης του Cairo, με απεικόνιση κειμένου που καθοδηγείται από το Pango. Στην υλοποίηση αυτής της κοινής API, χρησιμοποιούνται ειδικά παρασκήνια πλατφόρμας και ειδικοί οδηγοί εκτυπωτή.

### Λειτουργία εκτύπωσης (PrintOperation)

Το κύριο αντικείμενο είναι Gtk::PrintOperation, κατανεμημένο για κάθε λειτουργία εκτύπωσης. Για χειρισμό της σχεδίασης σελίδας συνδεθείτε με τα σήματά του, ή κληρονομείστε από αυτό και αντικαταστήστε τους προεπιλεγμένους εικονικούς χειριστές σήματος. Η PrintOperation χειρίζεται αυτόματα όλες τις ρυθμίσεις που επηρεάζουν τον βρόχο εκτύπωσης.

#### Σήματα

The PrintOperation::run() method starts the print loop, during which various signals are emitted:

- `begin_print`: You must handle this signal, because this is where you create and set up a Pango::Layout using the provided Gtk::PrintContext, and break up your printing output into pages.

- `paginate`: Pagination is potentially slow so if you need to monitor it you can call the PrintOperation::set_show_progress() method and handle this signal.

- For each page that needs to be rendered, the following signals are emitted:

  - `request_page_setup`: Provides a PrintContext, page number and Gtk::PageSetup. Handle this signal if you need to modify page setup on a per-page basis.

  - `draw_page`: You must handle this signal, which provides a PrintContext and a page number. The PrintContext should be used to create a Cairo::Context into which the provided page should be drawn. To render text, iterate over the Pango::Layout you created in the `begin_print` handler.

- `end_print`: A handler for it is a safe place to free any resources related to a PrintOperation. If you have your custom class that inherits from PrintOperation, it is naturally simpler to do it in the destructor.

- `done`: This signal is emitted when printing is finished, meaning when the print data is spooled. Note that the provided `Gtk::PrintOperationResult` may indicate that an error occurred. In any case you probably want to notify the user about the final status.

- `status_changed`: Emitted whenever a print job's status changes, until it is finished. Call the PrintOperation::set_track_print_status() method to monitor the job status after spooling. To see the status, use get_status() or get_status_string().

Reference

### Διαμόρφωση σελίδας

Η κλάση PrintOperation έχει μια μέθοδο που λέγεται set_default_page_setup() που επιλέγει το προεπιλεγμένο μέγεθος χαρτιού, προσανατολισμό και περιθώρια. Για την εμφάνιση διαλόγου ρύθμισης της σελίδας από την εφαρμογή σας, χρησιμοποιήστε τη μέθοδο Gtk::run_page_setup_dialog(), που επιστρέφει ένα αντικείμενο Gtk::PageSetup με τις επιλεγμένες ρυθμίσεις. Χρησιμοποιήστε αυτό το αντικείμενο για ενημέρωση μιας PrintOperation και πρόσβαση των επιλεγμένων Gtk::PaperSize, `Gtk::PageOrientation` και των ειδικών περιθωρίων του εκτυπωτή.

Θα πρέπει να αποθηκεύσετε την επιλεγμένη Gtk::PageSetup έτσι ώστε να μπορείτε να την χρησιμοποιήσετε πάλι, αν ο διάλογος διαμόρφωσης σελίδας εμφανιστεί πάλι.

For instance,

    //Within a class that inherits from Gtk::Window and keeps m_refPageSetup and m_refSettings as members...
    Glib::RefPtr<Gtk::PageSetup> new_page_setup = Gtk::run_page_setup_dialog(*this, m_refPageSetup, m_refSettings);
    m_refPageSetup = new_page_setup;

Reference

Το σύστημα συντεταγμένων Cairo, στον χειριστή `draw_page`, περιστρέφεται αυτόματα στον τρέχοντα προσανατολισμό της σελίδας. Είναι κανονικά μέσα στα περιθώρια του εκτυπωτή, αλλά μπορείτε να το αλλάξετε μέσα από τη μέθοδο PrintOperation::set_use_full_page(). Η προεπιλεγμένη μονάδα μέτρησης είναι εικονοστοιχεία συσκευής. Για επιλογή άλλων μονάδων, χρησιμοποιήστε τη μέθοδο PrintOperation::set_unit().

### Απεικόνιση κειμένου

Η απόδοση κειμένου γίνεται χρησιμοποιώντας Pango. Το αντικείμενο Pango::Layout για την εκτύπωση πρέπει να δημιουργηθεί καλώντας τη μέθοδο PrintContext::create_pango_layout(). Το αντικείμενο PrintContext παρέχει επίσης τα μετρικά της σελίδας, μέσα από την get_width() και get_height(). Ο αριθμός των σελίδων μπορεί να οριστεί με την PrintOperation::set_n_pages(). Για ενεργή απόδοση του κειμένου Pango στην `on_draw_page`, πάρτε μια Cairo::Context με PrintContext::get_cairo_context() και εμφανίστε τις Pango::LayoutLines που εμφανίζονται μέσα στον ζητούμενο αριθμό σελίδας.

Δείτε ένα παράδειγμα πώς ακριβώς μπορεί να γίνει αυτό.

### Ασύγχρονες λειτουργίες

Από προεπιλογή, η PrintOperation::run() επιστρέφεται όταν η λειτουργία εκτύπωσης ολοκληρωθεί. Αν χρειάζεστε να εκτελέσετε μια μη ομαδική λειτουργία εκτύπωσης, καλέστε την PrintOperation::set_allow_async(). Σημειώστε ότι η set_allow_async() δεν υποστηρίζεται σε όλα τα λειτουργικά συστήματα, όμως το σήμα `done` θα εκπεμφθεί.

Η run() μπορεί να επιστρέψει την `PRINT_OPERATION_RESULT_IN_PROGRESS`. Για ανίχνευση της κατάστασης και χειρισμό του αποτελέσματος ή σφάλματος χρειάζεται να υλοποιηθούν οι χειριστές σήματος για τα σήματα `done` και `status_changed`:

For instance,

    // in class ExampleWindow's method...
    Glib::RefPtr<PrintOperation> op = PrintOperation::create();
    // ...set up op...
    op->signal_done().connect(sigc::bind(sigc::mem_fun(*this, &ExampleWindow::on_printoperation_done), op));
    // run the op

Second, check for an error and connect to the `status_changed` signal. For instance:

    void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result, const Glib::RefPtr<PrintOperation>& op)
    {
      if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
        //notify user
      else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
        //Update PrintSettings with the ones used in this PrintOperation

      if (! op->is_finished())
        op->signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this, &ExampleWindow::on_printoperation_status_changed), op));
    }

Finally, check the status. For instance,

    void ExampleWindow::on_printoperation_status_changed(const Glib::RefPtr<PrintFormOperation>& op)
    {
      if (op->is_finished())
        //the print job is finished
      else
        //get the status with get_status() or get_status_string()

      //update UI
    }

### Εξαγωγή σε PDF

The 'Print to file' option is available in the print dialog, without the need for extra implementation. However, it is sometimes useful to generate a pdf file directly from code. For instance,

    Glib::RefPtr<Gtk::PrintOperation> op = Gtk::PrintOperation::create();
    // ...set up op...
    op->set_export_filename("test.pdf");
    Gtk::PrintOperationResult res = op->run(Gtk::PRINT_OPERATION_ACTION_EXPORT);

### Επέκταση του διαλόγου εκτύπωσης

You may add a custom tab to the print dialog:

- Set the title of the tab via PrintOperation::set_custom_tab_label(), create a new widget and return it from the `create_custom_widget` signal handler. You'll probably want this to be a container widget, packed with some others.

- Get the data from the widgets in the `custom_widget_apply` signal handler.

Although the `custom_widget_apply` signal provides the widget you previously created, to simplify things you can keep the widgets you expect to contain some user input as class members. For example, let's say you have a Gtk::Entry called `m_Entry` as a member of your CustomPrintOperation class:

    Gtk::Widget* CustomPrintOperation::on_create_custom_widget()
    {
      set_custom_tab_label("My custom tab");

      Gtk::Box* hbox = new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 8);
      hbox->set_border_width(6);

      Gtk::Label* label = Gtk::manage(new Gtk::Label("Enter some text: "));
      hbox->pack_start(*label, false, false);
      label->show();

      hbox->pack_start(m_Entry, false, false);
      m_Entry.show();

      return hbox;
    }

    void CustomPrintOperation::on_custom_widget_apply(Gtk::Widget* /* widget */)
    {
      Glib::ustring user_input = m_Entry.get_text();
      //...
    }

Το παράδειγμα στο examples/book/printing/advanced δείχνει αυτό.

### Προεπισκόπηση

The native GTK+ print dialog has a preview button, but you may also start a preview directly from an application:

    // in a class that inherits from Gtk::Window...
    Glib::RefPtr<PrintOperation> op = PrintOperation::create();
    // ...set up op...
    op->run(Gtk::PRINT_OPERATION_ACTION_PREVIEW, *this);

Στο Unix, ο προεπιλεγμένος χειριστής προεπισκόπησης χρησιμοποιεί ένα εξωτερικό πρόγραμμα προβολής. Στα Windows, ο εγγενής διάλογος προεπισκόπησης θα εμφανιστεί. Αν είναι απαραίτητο, μπορείτε να αντικαταστήσετε αυτήν τη συμπεριφορά και να δώσετε έναν προσαρμοσμένο διάλογο προεπισκόπησης. Δείτε το παράδειγμα που βρίσκεται στο /examples/book/printing/advanced.

### Παράδειγμα

#### Απλό

Το παρακάτω παράδειγμα δείχνει πώς να εκτυπώσετε κάποια είσοδο από μια διεπαφή χρήστη. Εμφανίζει πώς να υλοποιήσετε τις `on_begin_print` και `on_draw_page`, καθώς και πώς να αναγνωρίστε την κατάσταση εκτύπωσης και πώς να ενημερώσετε τις ρυθμίσεις εκτύπωσης.

Εκτύπωση - Απλή

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class PrintFormOperation;

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

    protected:

      void build_main_menu();

      void print_or_preview(Gtk::PrintOperationAction print_action);

      //PrintOperation signal handlers.
      //We handle these so can get necessary information to update the UI or print settings.
      //Our derived PrintOperation class also overrides some default signal handlers.
      void on_printoperation_status_changed(const Glib::RefPtr<PrintFormOperation>& operation);

      void on_printoperation_done(Gtk::PrintOperationResult result, const Glib::RefPtr<PrintFormOperation>& operation);

      //Action signal handlers:
      void on_menu_file_new();
      void on_menu_file_page_setup();
      void on_menu_file_print_preview();
      void on_menu_file_print();
      void on_menu_file_quit();

      //Printing-related objects:
      Glib::RefPtr<Gtk::PageSetup> m_refPageSetup;
      Glib::RefPtr<Gtk::PrintSettings> m_refSettings;

      //Child widgets:
      Gtk::Box m_VBox;
      Gtk::Grid m_Grid;

      Gtk::Label m_NameLabel;
      Gtk::Entry m_NameEntry;

      Gtk::Label m_SurnameLabel;
      Gtk::Entry m_SurnameEntry;

      Gtk::Label m_CommentsLabel;
      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TextView m_TextView;

      Glib::RefPtr<Gtk::TextBuffer> m_refTextBuffer;

      unsigned m_ContextId;
      Gtk::Statusbar m_Statusbar;

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `printformoperation.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_PRINT_FORM_OPERATION_H
    #define GTKMM_PRINT_FORM_OPERATION_H

    #include <gtkmm.h>
    #include <pangomm.h>
    #include <vector>

    //We derive our own class from PrintOperation,
    //so we can put the actual print implementation here.
    class PrintFormOperation : public Gtk::PrintOperation
    {
     public:
      static Glib::RefPtr<PrintFormOperation> create();
      virtual ~PrintFormOperation();

      void set_name(const Glib::ustring& name) { m_Name = name; }
      void set_comments(const Glib::ustring& comments) { m_Comments = comments; }

     protected:
      PrintFormOperation();

      //PrintOperation default signal handler overrides:
      void on_begin_print(const Glib::RefPtr<Gtk::PrintContext>& context) override;
      void on_draw_page(const Glib::RefPtr<Gtk::PrintContext>& context, int page_nr) override;

      Glib::ustring m_Name;
      Glib::ustring m_Comments;
      Glib::RefPtr<Pango::Layout> m_refLayout;
      std::vector<int> m_PageBreaks; // line numbers where a page break occurs
    };

    #endif // GTKMM_PRINT_FORM_OPERATION_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include "printformoperation.h"

    #include <iostream>

    #include <pangomm.h>

    const Glib::ustring app_title = "gtkmm Printing Example";

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_NameLabel("Name"),
      m_SurnameLabel("Surname"),
      m_CommentsLabel("Comments")
    {
      m_refPageSetup = Gtk::PageSetup::create();
      m_refSettings = Gtk::PrintSettings::create();

      m_ContextId = m_Statusbar.get_context_id(app_title);

      set_title(app_title);
      set_default_size(400, 300);

      add(m_VBox);

      build_main_menu();

      m_VBox.pack_start(m_Grid);

      //Arrange the widgets inside the grid:
      m_Grid.set_row_spacing(5);
      m_Grid.set_column_spacing(5);
      m_Grid.attach(m_NameLabel, 0, 0, 1, 1);
      m_Grid.attach(m_NameEntry, 1, 0, 1, 1);

      m_Grid.attach(m_SurnameLabel, 0, 1, 1, 1);
      m_Grid.attach(m_SurnameEntry, 1, 1, 1, 1);

      //Add the TextView, inside a ScrolledWindow:
      m_ScrolledWindow.add(m_TextView);

      //Only show the scrollbars when they are necessary:
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_Grid.attach(m_CommentsLabel, 0, 2, 1, 1);
      m_Grid.attach(m_ScrolledWindow, 1, 2, 1, 1);
      m_ScrolledWindow.set_hexpand(true);
      m_ScrolledWindow.set_vexpand(true);

      m_refTextBuffer = Gtk::TextBuffer::create();
      m_TextView.set_buffer(m_refTextBuffer);

      m_VBox.pack_start(m_Statusbar);

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::build_main_menu()
    {
      //Create actions for menus and toolbars:
      auto refActionGroup =
       Gio::SimpleActionGroup::create();

      //File menu:
      refActionGroup->add_action("new",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new));

      refActionGroup->add_action("pagesetup",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_page_setup));

      refActionGroup->add_action("printpreview",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_print_preview));

      refActionGroup->add_action("print",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_print));

      refActionGroup->add_action("quit",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_quit));

      insert_action_group("example", refActionGroup);

      m_refBuilder = Gtk::Builder::create();

      //TODO: add_accel_group(m_refBuilder->get_accel_group());

      //Layout the actions in a menubar and toolbar:

      Glib::ustring ui_info =
       "<interface>"
        "  <menu id='menu-example'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <section>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Page _Setup</attribute>"
        "          <attribute name='action'>example.pagesetup</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>Print Preview</attribute>"
        "          <attribute name='action'>example.printpreview</attribute>"
        "        </item>"
        "        <item>"
        "          <attribute name='label' translatable='yes'>_Print</attribute>"
        "          <attribute name='action'>example.print</attribute>"
        "        </item>"
        "      </section>"
        "    </submenu>"
        "  </menu>"
    /* TODO:
          "  <toolbar  name='ToolBar'>"
            "    <toolitem action='New'/>"
            "    <toolitem action='Print'/>"
            "      <separator/>"
            "    <toolitem action='Quit'/>"
            "  </toolbar>"
    */
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menus failed: " << ex.what();
      }

      //Get the menubar and toolbar widgets, and add them to a container widget:
      auto object =
        m_refBuilder->get_object("menu-example");
      auto gmenu =
        Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
      if(!gmenu)
        g_warning("GMenu not found");

      auto pMenubar = new Gtk::MenuBar(gmenu);
      m_VBox.pack_start(*pMenubar, Gtk::PACK_SHRINK);

    /* TODO:
      auto pToolbar = m_refBuilder->get_widget("/ToolBar") ;
      if(pToolbar)
        m_VBox.pack_start(*pToolbar, Gtk::PACK_SHRINK);
    */
    }

    void ExampleWindow::on_printoperation_status_changed(
            const Glib::RefPtr<PrintFormOperation>& operation)
    {
      Glib::ustring status_msg;

      if (operation->is_finished())
      {
        status_msg = "Print job completed.";
      }
      else
      {
        //You could also use get_status().
        status_msg = operation->get_status_string();
      }

      m_Statusbar.push(status_msg, m_ContextId);
    }

    void ExampleWindow::on_printoperation_done(Gtk::PrintOperationResult result,
            const Glib::RefPtr<PrintFormOperation>& operation)
    {
      //Printing is "done" when the print data is spooled.

      if (result == Gtk::PRINT_OPERATION_RESULT_ERROR)
      {
        Gtk::MessageDialog err_dialog(*this, "Error printing form", false,
                Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
        err_dialog.run();
      }
      else if (result == Gtk::PRINT_OPERATION_RESULT_APPLY)
      {
        //Update PrintSettings with the ones used in this PrintOperation:
        m_refSettings = operation->get_print_settings();
      }

      if (! operation->is_finished())
      {
        //We will connect to the status-changed signal to track status
        //and update a status bar. In addition, you can, for example,
        //keep a list of active print operations, or provide a progress dialog.
        operation->signal_status_changed().connect(sigc::bind(sigc::mem_fun(*this,
                        &ExampleWindow::on_printoperation_status_changed),
                    operation));
      }
    }

    void ExampleWindow::print_or_preview(Gtk::PrintOperationAction print_action)
    {
      //Create a new PrintOperation with our PageSetup and PrintSettings:
      //(We use our derived PrintOperation class)
      auto print = PrintFormOperation::create();

      print->set_name(m_NameEntry.get_text() + " " + m_SurnameEntry.get_text());
      print->set_comments(m_refTextBuffer->get_text(false /*Don't include hidden*/));

      print->set_track_print_status();
      print->set_default_page_setup(m_refPageSetup);
      print->set_print_settings(m_refSettings);

      print->signal_done().connect(sigc::bind(sigc::mem_fun(*this,
                      &ExampleWindow::on_printoperation_done), print));
      try
      {
        print->run(print_action /* print or preview */, *this);
      }
      catch (const Gtk::PrintError& ex)
      {
        //See documentation for exact Gtk::PrintError error codes.
        std::cerr << "An error occurred while trying to run a print operation:"
            << ex.what() << std::endl;
      }
    }

    void ExampleWindow::on_menu_file_new()
    {
      //Clear entries and textview:
      m_NameEntry.set_text("");
      m_SurnameEntry.set_text("");
      m_refTextBuffer->set_text("");
      m_TextView.set_buffer(m_refTextBuffer);
    }

    void ExampleWindow::on_menu_file_page_setup()
    {
      //Show the page setup dialog, asking it to start with the existing settings:
      auto new_page_setup =
          Gtk::run_page_setup_dialog(*this, m_refPageSetup, m_refSettings);

      //Save the chosen page setup dialog for use when printing, previewing, or
      //showing the page setup dialog again:
      m_refPageSetup = new_page_setup;
    }

    void ExampleWindow::on_menu_file_print_preview()
    {
      print_or_preview(Gtk::PRINT_OPERATION_ACTION_PREVIEW);
    }

    void ExampleWindow::on_menu_file_print()
    {
      print_or_preview(Gtk::PRINT_OPERATION_ACTION_PRINT_DIALOG);
    }

    void ExampleWindow::on_menu_file_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

File: `printformoperation.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "printformoperation.h"

    PrintFormOperation::PrintFormOperation()
    {
    }

    PrintFormOperation::~PrintFormOperation()
    {
    }

    Glib::RefPtr<PrintFormOperation> PrintFormOperation::create()
    {
      return Glib::RefPtr<PrintFormOperation>(new PrintFormOperation());
    }

    void PrintFormOperation::on_begin_print(
            const Glib::RefPtr<Gtk::PrintContext>& print_context)
    {
      //Create and set up a Pango layout for PrintData based on the passed
      //PrintContext: We then use this to calculate the number of pages needed, and
      //the lines that are on each page.
      m_refLayout = print_context->create_pango_layout();

      Pango::FontDescription font_desc("sans 12");
      m_refLayout->set_font_description(font_desc);

      const double width = print_context->get_width();
      const double height = print_context->get_height();

      m_refLayout->set_width(static_cast<int>(width * Pango::SCALE));

      //Set and mark up the text to print:
      Glib::ustring marked_up_form_text;
      marked_up_form_text += "<b>Name</b>: " + m_Name + "\n\n";
      marked_up_form_text += "<b>Comments</b>: " + m_Comments;

      m_refLayout->set_markup(marked_up_form_text);

      //Set the number of pages to print by determining the line numbers
      //where page breaks occur:
      const int line_count = m_refLayout->get_line_count();

      Glib::RefPtr<Pango::LayoutLine> layout_line;
      double page_height = 0;

      for (int line = 0; line < line_count; ++line)
      {
        Pango::Rectangle ink_rect, logical_rect;

        layout_line = m_refLayout->get_line(line);
        layout_line->get_extents(ink_rect, logical_rect);

        const double line_height = logical_rect.get_height() / 1024.0;

        if (page_height + line_height > height)
        {
          m_PageBreaks.push_back(line);
          page_height = 0;
        }

        page_height += line_height;
      }

      set_n_pages(m_PageBreaks.size() + 1);
    }

    void PrintFormOperation::on_draw_page(
            const Glib::RefPtr<Gtk::PrintContext>& print_context, int page_nr)
    {
      //Decide which lines we need to print in order to print the specified page:
      int start_page_line = 0;
      int end_page_line = 0;

      if(page_nr == 0)
      {
        start_page_line = 0;
      }
      else
      {
        start_page_line = m_PageBreaks[page_nr - 1];
      }

      if(page_nr < static_cast<int>(m_PageBreaks.size()))
      {
        end_page_line = m_PageBreaks[page_nr];
      }
      else
      {
        end_page_line = m_refLayout->get_line_count();
      }

      //Get a Cairo Context, which is used as a drawing board:
      Cairo::RefPtr<Cairo::Context> cairo_ctx = print_context->get_cairo_context();

      //We'll use black letters:
      cairo_ctx->set_source_rgb(0, 0, 0);

      //Render Pango LayoutLines over the Cairo context:
      Pango::LayoutIter iter = m_refLayout->get_iter();

      double start_pos = 0;
      int line_index = 0;

      do
      {
        if(line_index >= start_page_line)
        {
          auto layout_line = iter.get_line();
          Pango::Rectangle logical_rect = iter.get_line_logical_extents();
          int baseline = iter.get_baseline();

          if (line_index == start_page_line)
          {
            start_pos = logical_rect.get_y() / 1024.0;
          }

          cairo_ctx->move_to(logical_rect.get_x() / 1024.0,
            baseline / 1024.0 - start_pos);

          layout_line->show_in_cairo_context(cairo_ctx);
        }

        line_index++;
      }
      while(line_index < end_page_line && iter.next_line());
    }

## Πρόσφατα χρησιμοποιημένα έγγραφα

Η gtkmm δίνει έναν εύκολο τρόπο διαχείρισης πρόσφατα χρησιμοποιημένων εγγράφων. Οι εμπλεκόμενες κλάσεις στην υλοποίηση αυτής της λειτουργίας είναι RecentManager, RecentChooserDialog, RecentChooserMenu, RecentChooserWidget, RecentAction και RecentFilter.

Κάθε στοιχείο στον κατάλογο των πρόσφατα χρησιμοποιημένων αρχείων ταυτοποιείται από το URI του και μπορεί να συσχετιστεί με μεταδεδομένα. Τα μεταδεδομένα μπορούν να χρησιμοποιηθούν για τον ορισμό του τρόπου εμφάνισης του αρχείου, μια περιγραφή του αρχείου, τον τύπο του mime, ποια εφαρμογή το καταχωρίζει, αν είναι ιδιωτικό στην εφαρμογή καταχώρισης και πολλά άλλα πράγματα.

### Πρόσφατος διαχειριστής (RecentManager)

Η RecentManager δρα ως μια βάση δεδομένων των πρόσφατα χρησιμοποιημένων αρχείων. Χρησιμοποιείτε αυτήν την κλάση για να καταχωρίσετε νέα αρχεία, να αφαιρέσετε αρχεία από τον κατάλογο, ή να αναζητήσετε πρόσφατα χρησιμοποιημένα αρχεία. Υπάρχει ένας κατάλογος των πρόσφατα χρησιμοποιημένων αρχείων ανά χρήστη.

Μπορείτε να δημιουργήσετε μια νέα RecentManager, αλλά μάλλον θα θέλετε να χρησιμοποιήσετε απλά την προεπιλεγμένη. Μπορείτε να κάνετε μια αναφορά στην προεπιλεγμένη RecentManager με την get_default().

Η RecentManager είναι το πρότυπο ενός υποδείγματος προβολής προτύπου, όπου η προβολή είναι μια κλάση που υλοποιεί τη διεπαφή RecentChooser.

#### Προσθήκη στοιχείων στον κατάλογο των πρόσφατων αρχείων

Για να προσθέσετε ένα νέο αρχείο στον κατάλογο των πρόσφατων εγγράφων, στην πιο απλή περίπτωση, χρειάζεστε μόνο να δώσετε το URI. Για παράδειγμα:

    Glib::RefPtr<Gtk::RecentManager> recent_manager = Gtk::RecentManager::get_default();
    recent_manager->add_item(uri);

Αν θέλετε να καταχωρίσετε ένα αρχείο με μεταδεδομένα, μπορείτε να περάσετε μια παράμετρο RecentManager::Data στην add_item(). Τα μεταδεδομένα που μπορούν να οριστούν στο συγκεκριμένο στοιχείο του αρχείου είναι ως εξής:

- `app_exec`: Η γραμμή εντολών που θα χρησιμοποιηθεί για εκκίνηση αυτού του πόρου. Αυτή η συμβολοσειρά μπορεί να περιέχει τους χαρακτήρες διαφυγής "f" και "u" που θα επεκταθούν στη διαδρομή αρχείου του πόρου και στο URI αντίστοιχα

- `app_name`: Το όνομα της εφαρμογής που καταχωρίστηκε στον πόρο

- `description`: Μια σύντομη περιγραφή του πόρου ως μια κωδικοποιημένη συμβολοσειρά UTF-8

- `display_name`: Το όνομα του πόρου που θα χρησιμοποιηθεί για εμφάνιση ως μιας κωδικοποιημένης συμβολοσειράς UTF-8

- `groups`: Ένας κατάλογος ομάδων που σχετίζεται με αυτό το στοιχείο. Οι ομάδες είναι βασικά ελεύθερες συμβολοσειρές που σχετίζονται με έναν συγκεκριμένο πόρο. Μπορούν να θεωρηθούν ως 'κατηγορίες' (όπως "αλληλογραφία", "γραφικά", κλπ) ή ετικέτες για τον πόρο.

- `is_private`: Αν αυτός ο πόρος πρέπει να είναι ορατός μόνο στις εφαρμογές που το έχουν καταχωρίσει ή όχι

- `mime_type`: Ο τύπος MIME του πόρου

Πέρα από την προσθήκη στοιχείων στον κατάλογο, μπορείτε επίσης να αναζητήσετε στοιχεία από τον κατάλογο και να τροποποιήσετε ή να αφαιρέσετε στοιχεία.

#### Αναζήτηση στοιχείων στον κατάλογο των πρόσφατων αρχείων

Για την αναζήτηση πρόσφατα χρησιμοποιημένων αρχείων, η RecentManager δίνει αρκετές συναρτήσεις. Για αναζήτηση ενός συγκεκριμένου στοιχείου με το URI του, μπορείτε να χρησιμοποιήσετε τη συνάρτηση lookup_item(), που θα επιστρέψει μια κλάση RecentInfo. Αν το συγκεκριμένο URI δεν υπήρχε στον κατάλογο των πρόσφατων αρχείων, η lookup_item() εκπέμπει μια εξαίρεση της RecentManagerError. Για παράδειγμα:

    Glib::RefPtr<Gtk::RecentInfo> info;
    try
    {
      info = recent_manager->lookup_item(uri);
    }
    catch(const Gtk::RecentManagerError& ex)
    {
      std::cerr << "RecentManagerError: " << ex.what() << std::endl;
    }
    if (info)
    {
      // το στοιχείο βρέθηκε
    }

Ένα αντικείμενο RecentInfo είναι βασικά ένα αντικείμενο που περιέχει όλα τα μεταδεδομένα για ένα μονό πρόσφατα χρησιμοποιούμενο αρχείο. Μπορείτε να χρησιμοποιήσετε αυτό το αντικείμενο για αναζήτηση οποιασδήποτε ιδιότητας είναι καταχωρισμένη παραπάνω.

Αν δεν θέλετε να ψάξετε για ένα συγκεκριμένο URI, αλλά αντίθετα θέλετε να πάρετε έναν κατάλογο όλων των πρόσφατα χρησιμοποιημένων στοιχείων, η RecentManager παρέχει τη συνάρτηση get_items(). Η τιμή επιστροφής αυτής της συνάρτησης είναι μια std::vector όλων των πρόσφατα χρησιμοποιημένων αρχείων. Ο παρακάτω κώδικας δείχνει πώς μπορείτε να πάρετε έναν κατάλογο των πρόσφατα χρησιμοποιημένων αρχείων:

    std::vector< Glib::RefPtr<Gtk::RecentInfo> > info_list = recent_manager->get_items();

Η μέγιστη ηλικία των στοιχείων στον κατάλογο των πρόσφατα χρησιμοποιημένων αρχείων μπορεί να οριστεί με την Gtk::Settings::property_gtk_recent_files_max_age(). Προεπιλεγμένη τιμή: 30 ημέρες.

#### Τροποποίηση του καταλόγου των πρόσφατων αρχείων

Εκεί μπορεί να υπάρχουν φορές που χρειάζεστε να τροποποιήσετε τον κατάλογο των πρόσφατων αρχείων. Για παράδειγμα, αν ένα αρχείο μετακινήθηκε ή μετονομάστηκε, μπορεί να χρειαστεί να ενημερώσετε τη θέση του αρχείου στον κατάλογο πρόσφατων αρχείων, έτσι ώστε να μην δείχνει μια εσφαλμένη θέση. Μπορείτε να ενημερώσετε τη θέση ενός στοιχείου χρησιμοποιώντας την move_item().

Πέρα από την αλλαγή του URI ενός αρχείου, μπορείτε επίσης να αφαιρέσετε στοιχεία από τον κατάλογο, είτε ένα τη φορά είτε καθαρίζοντας τα όλα μονομιάς. Το πρώτο πραγματοποιείται με την remove_item(), το δεύτερο με την purge_items().

Οι συναρτήσεις move_item(), remove_item() και purge_items() δεν επιδρούν στα ενεργά αρχεία που αναφέρονται από τα URIs, τροποποιούν μόνο τον κατάλογο των πρόσφατων αρχείων.

### Επιλογή προσφάτων (RecentChooser)

Η RecentChooser είναι μια διεπαφή που μπορεί να υλοποιηθεί από γραφικά συστατικά που εμφανίζουν τον κατάλογο των πρόσφατα χρησιμοποιημένων αρχείων. Η gtkmm δίνει τέσσερις ενσωματωμένες υλοποιήσεις για επιλογή πρόσφατων αρχείων: RecentChooserWidget, RecentChooserDialog, RecentChooserMenu και RecentAction.

Η RecentChooserWidget είναι ένα απλό γραφικό συστατικό για εμφάνιση ενός καταλόγου των πρόσφατα χρησιμοποιημένων αρχείων. Η RecentChooserWidget είναι η βασική ομάδα δόμησης για την RecentChooserDialog, αλλά μπορείτε να την ενσωματώσετε στη διεπαφή χρήστη αν θέλετε.

Οι RecentChooserMenu και RecentAction επιτρέπουν την καταγραφή πρόσφατα χρησιμοποιημένων αρχείων ως μενού.

#### Απλό παράδειγμα διαλόγου επιλογής προσφάτων (RecentChooserDialog)

Παρακάτω εμφανίζεται ένα απλό παράδειγμα χρήσης των κλάσεων RecentChooserDialog και RecentAction σε ένα πρόγραμμα. Αυτό το απλό πρόγραμμα έχει μια γραμμή μενού με ένα στοιχείο μενού Διάλογος πρόσφατων αρχείων. Όταν επιλέγετε αυτό το στοιχείο μενού, ένας διάλογος αναδύεται εμφανίζοντας τον κατάλογο των πρόσφατα χρησιμοποιημένων αρχείων.

Αν αυτή είναι η πρώτη φορά που χρησιμοποιείτε ένα πρόγραμμα που χρησιμοποιεί τον σκελετό πρόσφατων αρχείων, ο διάλογος μπορεί να είναι κενός στην αρχή. Αλλιώς πρέπει να εμφανίσει έναν κατάλογο των πρόσφατα χρησιμοποιημένων καταχωρισμένων εγγράφων από άλλες εφαρμογές.

Μετά την επιλογή του στοιχείου μενού Διάλογος πρόσφατων αρχείων, θα πρέπει να δείτε κάτι παρόμοιο με το παρακάτω παράθυρο.

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow(const Glib::RefPtr<Gtk::Application>& app);
      virtual ~ExampleWindow();

    protected:
      //Signal handlers:
      void on_menu_file_recent_files_item();
      void on_menu_file_recent_files_dialog();
      void on_menu_file_quit();
      void on_menu_file_new();

      //Child widgets:
      Gtk::Box m_Box;

      Glib::RefPtr<Gtk::Builder> m_refBuilder;
      Glib::RefPtr<Gio::SimpleActionGroup> m_refActionGroup;

      Glib::RefPtr<Gtk::RecentManager> m_refRecentManager;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow(const Glib::RefPtr<Gtk::Application>& app)
    : m_Box(Gtk::ORIENTATION_VERTICAL),
      m_refRecentManager(Gtk::RecentManager::get_default())
    {
      set_title("recent files example");
      set_default_size(200, 200);

      //We can put a MenuBar at the top of the box and other stuff below it.
      add(m_Box);

      //Create actions for menus and toolbars:
      m_refActionGroup = Gio::SimpleActionGroup::create();

      //File menu:
      m_refActionGroup->add_action("new",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_new));

      //A menu item to open the recent-files dialog:
      m_refActionGroup->add_action("recent-files-dialog",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_recent_files_dialog) );

      m_refActionGroup->add_action("quit",
        sigc::mem_fun(*this, &ExampleWindow::on_menu_file_quit) );

      insert_action_group("example", m_refActionGroup);

      m_refBuilder = Gtk::Builder::create();

      // When the menubar is a child of a Gtk::Window, keyboard accelerators are not
      // automatically fetched from the Gio::Menu.
      // See the examples/book/menus/main_menu example for an alternative way of
      // adding the menubar when using Gtk::ApplicationWindow.
      app->set_accel_for_action("example.new", "<Primary>n");
      app->set_accel_for_action("example.recent-files-dialog", "<Primary>o");
      app->set_accel_for_action("example.quit", "<Primary>q");

      //Layout the actions in a menubar and a toolbar:
      const char* ui_info =
        "<interface>"
        "  <menu id='menubar'>"
        "    <submenu>"
        "      <attribute name='label' translatable='yes'>_File</attribute>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_New</attribute>"
        "        <attribute name='action'>example.new</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;n</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>Recent Files _Dialog</attribute>"
        "        <attribute name='action'>example.recent-files-dialog</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;o</attribute>"
        "      </item>"
        "      <item>"
        "        <attribute name='label' translatable='yes'>_Quit</attribute>"
        "        <attribute name='action'>example.quit</attribute>"
        "        <attribute name='accel'>&lt;Primary&gt;q</attribute>"
        "      </item>"
        "    </submenu>"
        "  </menu>"
        "  <object class='GtkToolbar' id='toolbar'>"
        "    <property name='visible'>True</property>"
        "    <property name='can_focus'>False</property>"
        "    <child>"
        "      <object class='GtkToolButton' id='toolbutton_new'>"
        "        <property name='visible'>True</property>"
        "        <property name='can_focus'>False</property>"
        "        <property name='tooltip_text' translatable='yes'>New</property>"
        "        <property name='action_name'>example.new</property>"
        "        <property name='icon_name'>document-new</property>"
        "      </object>"
        "      <packing>"
        "        <property name='expand'>False</property>"
        "        <property name='homogeneous'>True</property>"
        "      </packing>"
        "    </child>"
        "    <child>"
        "      <object class='GtkToolButton' id='toolbutton_quit'>"
        "        <property name='visible'>True</property>"
        "        <property name='can_focus'>False</property>"
        "        <property name='tooltip_text' translatable='yes'>Quit</property>"
        "        <property name='action_name'>example.quit</property>"
        "        <property name='icon_name'>application-exit</property>"
        "      </object>"
        "      <packing>"
        "        <property name='expand'>False</property>"
        "        <property name='homogeneous'>True</property>"
        "      </packing>"
        "    </child>"
        "  </object>"
        "</interface>";

      try
      {
        m_refBuilder->add_from_string(ui_info);
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "building menubar and toolbar failed: " <<  ex.what();
      }

      //Get the menubar and toolbar widgets, and add them to a container widget:
      auto object = m_refBuilder->get_object("menubar");
      auto gmenu = Glib::RefPtr<Gio::Menu>::cast_dynamic(object);
      if (gmenu)
      {
        //Menubar:
        auto pMenubar = Gtk::manage(new Gtk::MenuBar(gmenu));
        m_Box.pack_start(*pMenubar, Gtk::PACK_SHRINK);
      }
      else
        g_warning("GMenu not found");

      Gtk::Toolbar* pToolbar = nullptr;
      m_refBuilder->get_widget("toolbar", pToolbar);
      if (pToolbar)
        //Toolbar:
        m_Box.pack_start(*pToolbar, Gtk::PACK_SHRINK);
      else
        g_warning("GtkToolbar not found");

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_menu_file_new()
    {
      std::cout << " New File" << std::endl;
    }

    void ExampleWindow::on_menu_file_quit()
    {
      hide(); //Closes the main window to stop the app->run().
    }

    void ExampleWindow::on_menu_file_recent_files_dialog()
    {
      Gtk::RecentChooserDialog dialog(*this, "Recent Files", m_refRecentManager);
      dialog.add_button("Select File", Gtk::RESPONSE_OK);
      dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);

      const int response = dialog.run();
      dialog.hide();
      if(response == Gtk::RESPONSE_OK)
      {
        std::cout << "URI selected = " << dialog.get_current_uri() << std::endl;
      }
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window(app);

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

The constructor for ExampleWindow creates the menu and the toolbar using Builder (see for more information). It then adds the menu and the toolbar to the window.

#### Φιλτράρισμα πρόσφατων αρχείων

Για οποιαδήποτε κλάση RecentChooser, αν δεν θέλετε να εμφανίσετε όλα τα στοιχεία στον κατάλογο των πρόσφατων αρχείων, μπορείτε να φιλτράρετε τον κατάλογο για να εμφανίσετε μόνο αυτά που θέλετε. Μπορείτε να φιλτράρετε τον κατάλογο με τη βοήθεια της κλάσης RecentFilter. Αυτή η κλάση επιτρέπει το φιλτράρισμα πρόσφατων αρχείων με το όνομά τους (add_pattern()), τον mime τύπο τους, (add_mime_type()), την εφαρμογή που τις καταχωρίζει (add_application()), ή με μια συνάρτηση προσαρμοσμένου φίλτρου (add_custom()). Παρέχει επίσης τη δυνατότητα φιλτραρίσματος με βάση τον χρόνο τροποποίησης και τις ομάδες που ανήκει.

Αφού έχετε δημιουργήσει και ρυθμίσει το φίλτρο να ταιριάζει μόνο τα στοιχεία που θέλετε, μπορείτε να εφαρμόσετε ένα φίλτρο σε ένα γραφικό συστατικό επιλογής με τη συνάρτηση RecentChooser::add_filter().

## Δέκτες και δότες (Plugs and Sockets)

### Επισκόπηση

Κάπου-κάπου, μπορεί να είναι χρήσιμο να μπορείτε να ενσωματώσετε ένα γραφικό συστατικό από μια άλλη εφαρμογή στην εφαρμογή σας. Η gtkmm επιτρέπει να το κάνετε αυτό με τις κλάσεις Gtk::Socket και Gtk::Plug. Δεν είναι αναμενόμενο ότι πάρα πολλές εφαρμογές θα χρειαστούν αυτήν τη λειτουργία, αλλά στην σπάνια περίπτωση που χρειαστείτε να εμφανίσετε ένα γραφικό συστατικό που εκτελείται σε μια ολότελα διαφορετική επεξεργασία, αυτές οι κλάσεις μπορεί να είναι πολύ χρήσιμες.

Η επικοινωνία μεταξύ μιας Socket και μιας Plug ακολουθεί το πρωτόκολλο XEmbed. Αυτό το πρωτόκολλο έχει επίσης υλοποιηθεί σε άλλα πακέτα εργαλείων (π.χ. Qt), που επιτρέπουν το ίδιο επίπεδο ενσωμάτωσης όταν ενσωματώνεται ένα γραφικό συστατικό Qt σε GTK+ ή αντίστροφα.

Ο τρόπος που οι Sockets και Plugs δουλεύουν μαζί είναι μέσα από τα αναγνωριστικά του παραθύρου τους. Και οι δυο Socket και Plug έχουν αναγνωριστικά που μπορούν να ανακτηθούν με τις συναρτήσεις μέλους τους get_id(). Η χρήση αυτών των αναγνωριστικών θα εξηγηθεί παρακάτω στο .

#### Δότες (Sockets)

Μια Socket είναι ένα ειδικό είδος γραφικού συστατικού περιέκτη που παρέχει την ικανότητα ενσωμάτωσης γραφικών συστατικών από μια διεργασία σε μια άλλη διεργασία με έναν τρόπο που είναι διαφανής στον χρήστη.

#### Δέκτες (Plugs)

Μια Plug είναι ένα ειδικό είδος παραθύρου που μπορεί να συνδεθεί με μια Socket. Εκτός από τις κανονικές ιδιότητες και μεθόδους της Gtk::Window, μια Plug παρέχει έναν κατασκευαστή που παίρνει το αναγνωριστικό μιας Socket, που θα ενσωματώσει αυτόματα την Plug στην Socket που ταιριάζει αυτό το αναγνωριστικό.

Αφού μια Plug είναι απλά ένας ειδικός τύπος μιας κλάσης Gtk::Window, μπορείτε να προσθέσετε περιέκτες ή γραφικά συστατικά σε αυτή όπως μπορείτε να κάνετε με οποιοδήποτε άλλο παράθυρο.

#### Σύνδεση δοτών και δεκτών

Αφού ένα αντικείμενο Socket ή μια Plug πραγματοποιηθεί, μπορείτε να πάρετε το αναγνωριστικό του με τη συνάρτησή του get_id(). Αυτό το αναγνωριστικό μπορεί έπειτα μοιράζεται με άλλες διεργασίες έτσι ώστε οι άλλες διεργασίες να ξέρουν πώς να συνδεθούν μεταξύ τους.

There are two basic strategies that can be used:

- Create a Socket object in one process and pass the ID of that Socket to another process so that it can create a Plug object by specifying the given Socket ID in its constructor. There is no way to assign a Plug to a particular Socket after creation, so you must pass the Socket ID to the Plug's constructor.

- Create a Plug independantly from any particular Socket and pass the ID of the Plug to other processes that need to use it. The ID of the Plug can be associated with a particular Socket object using the Socket::add_id() function. This is the approach used in the example below.

### Παράδειγμα δεκτών και δοτών (Plugs and Sockets)

Το παρακάτω είναι ένα απλό παράδειγμα χρήσης δεκτών και δοτών. Η μέθοδος επικοινωνίας μεταξύ διεργασιών διατηρείται σκόπιμα πολύ απλή: Η Plug γράφει το αναγνωριστικό της σε ένα αρχείο κειμένου με όνομα `plug.id` και η επεξεργασία με τον δέκτη διαβάζει το αναγνωριστικό από αυτό το αρχείο. Σε ένα πραγματικό πρόγραμμα, μπορεί να θέλετε να χρησιμοποιήσετε μια περισσότερο προηγμένη μέθοδο επικοινωνίας μεταξύ των διεργασιών.

Source Code

File: `plug.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include <fstream>
    #include <gtkmm.h>
    #include <gtkmm/plug.h>
    #include <glib/gstdio.h>

    using namespace std;

    const char* id_filename = "plug.id";

    void on_embed()
    {
      cout << "I've been embedded." << endl;
    }

    class MyPlug : public Gtk::Plug
    {
      public:
        MyPlug() :
          m_label("I am the plug")
      {
        set_size_request(150, 100);
        add(m_label);
        signal_embedded().connect(sigc::ptr_fun(on_embed));
        show_all_children();
      }

      private:
        Gtk::Label m_label;
    };

    int main(int argc, char** argv)
    {
      // The plug and the socket have different application ids, so they can run
      // simultaneously.
      auto app =
        Gtk::Application::create(argc, argv, "org.gtkmm.example.plug");
      MyPlug plug;
      plug.show();

      ofstream out(id_filename);
      out << plug.get_id();
      out.close();
      cout << "The window ID is: " << plug.get_id() << endl;

      app->run(plug);

      // remove the ID file when the program exits
      g_remove(id_filename);
      return 0;
    }

File: `socket.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include <fstream>
    #include <gtkmm.h>
    #include <gtkmm/socket.h>

    using namespace std;

    const char* id_filename = "plug.id";

    void plug_added()
    {
      cout << "A plug was added" << endl;
    }

    bool plug_removed()
    {
      cout << "A Plug was removed" << endl;
      return true;
    }

    class MySocketWindow : public Gtk::Window
    {
      public:
        MySocketWindow()
        {
          ifstream infile(id_filename);
          if (infile)
          {
            auto socket = Gtk::manage(new Gtk::Socket());
            add(*socket);
            socket->signal_plug_added().connect(sigc::ptr_fun(plug_added));
            socket->signal_plug_removed().connect(sigc::ptr_fun(plug_removed));
            ::Window plug_id = 0;
            infile >> plug_id;
            infile.close();
            socket->add_id(plug_id);
          }
          else
          {
            auto label = Gtk::manage(
                new Gtk::Label(
                  "Plug id file not found.\n Make sure plug is running."));
            add(*label);
            set_size_request(150, 50);
          }
          show_all();
        }
    };

    int main(int argc, char** argv)
    {
      // The plug and the socket have different application ids, so they can run
      // simultaneously.
      auto app =
        Gtk::Application::create(argc, argv, "org.gtkmm.example.socket");
      MySocketWindow win;
      app->run(win);
      return 0;
    }

Αυτό το παράδειγμα δημιουργεί δύο εκτελέσιμα προγράμματα: `socket` και `plug`. Η ιδέα είναι ότι η `socket` έχει ένα παράθυρο εφαρμογής που θα ενσωματώσει ένα γραφικό συστατικό από το πρόγραμμα `plug`. Ο τρόπος αυτού του παραδείγματος σχεδιάστηκε έτσι ώστε το `plug` να πρέπει να εκτελεστεί πρώτα πριν ξεκινήσει το `socket`. Για να δείτε το παράδειγμα σε δράση, εκτελέστε τις παρακάτω εντολές με τη σειρά μέσα στον κατάλογο του παραδείγματος:

Ξεκινήστε το πρόγραμμα `plug` και στείλτε το στο παρασκήνιο (ή απλά χρησιμοποιήστε ένα διαφορετικό τερματικό).

    $ ./plug &

Μετά από το οποίο θα πρέπει να δείτε κάτι όπως το παρακάτω:

    Το αναγνωριστικό του παραθύρου είναι: 69206019

Έπειτα αρχίστε το πρόγραμμα `socket`:

    $ ./socket

Μετά την έναρξη του `socket`, θα πρέπει να δείτε την παρακάτω έξοδο στο τερματικό:

    I've been embedded.
    A plug was added

Η πρώτη γραμμή της εξόδου είναι από το `plug`, αφού έχει ειδοποιηθεί ότι έχει ενσωματωθεί μέσα σε μια Socket. Η δεύτερη γραμμή εκπέμφθηκε από το `socket` σε απάντηση του σήματός του plug_added. Αν όλα έγιναν όπως περιγράφτηκε παραπάνω, το παράθυρο `socket` πρέπει να φαίνεται χοντρικά όπως το παρακάτω:

If for some reason the Socket couldn't attach the Plug, the window would look something like this:

## Συμβάντα πληκτρολογίου

Τα συμβάντα Χ διαφέρουν με κάποιους τρόπους από άλλα σήματα. Αυτές οι διαφορές περιγράφονται στην ενότητα Σήματα συμβάντων Χ στο παράρτημα. Εδώ, θα χρησιμοποιήσουμε συμβάντα πληκτρολογίου για την εμφάνιση του τρόπου χρήσης των συμβάντων Χ σε ένα πρόγραμμα.

### Επισκόπηση

Όποτε πατάτε ή απελευθερώνετε ένα πλήκτρο, εκπέμπεται ένα συμβάν. Μπορείτε να συνδέσετε έναν χειριστή σήματος για να επεξεργαστεί τέτοια συμβάντα.

Για να δεχτείτε τα συμβάντα του πληκτρολογίου, πρέπει πρώτα να; καλέσετε τη συνάρτηση Gtk::Widget::add_events() με λίγη μάσκα των συμβάντων που ενδιαφέρεστε. Το συμβάν χειριστή σήματος θα δεχτεί ένα όρισμα που εξαρτάται από τον τύπο του συμβάντος. Για συμβάντα πληκτρολογίου είναι ένας GdkEventKey*. Όπως περιγράφτηκε στο παράρτημα, ο χειριστής σήματος συμβάντος επιστρέφει μια τιμή Μπουλ, για να δείξει ότι το σήμα επεξεργάστηκε πλήρως (`true`) ή να επιτρέψει τη διάδοση του συμβάντος (`false`).

Για να προσδιορίσετε ποιο πλήκτρο πατήθηκε ή απελευθερώθηκε διαβάζετε την τιμή της `GdkEventKey::keyval` και την συγκρίνετε με μια σταθερά στο αρχείο κεφαλίδας `<gdk/gdkkeysyms.h>`. Οι καταστάσεις των πλήκτρων τροποποίησης (Shift, Ctrl, κλπ.) είναι διαθέσιμες ως σημαίες δυαδικών ψηφίων στη `GdkEventKey::state`.

Here's a simple example:

    bool on_key_press_or_release_event(GdkEventKey* event)
    {
      if (event->type == GDK_KEY_PRESS &&
        event->keyval == GDK_KEY_1 &&
        (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == GDK_MOD1_MASK)
      {
        handle_alt_1_press(); // GDK_MOD1_MASK is normally the Alt key
        return true;
      }
      return false;
    }

    Gtk::Entry m_entry; // in a class definition

    // in the class constructor
    m_entry.signal_key_press_event().connect( sigc::ptr_fun(&on_key_press_or_release_event) );
    m_entry.signal_key_release_event().connect( sigc::ptr_fun(&on_key_press_or_release_event) );
    m_entry.add_events(Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK);

#### Παράδειγμα

Σε αυτό το παράδειγμα υπάρχουν τρεις συντομεύσεις πληκτρολογίου: η Alt+1 επιλέγει το πρώτο ραδιοπλήκτρο, η Alt+2 επιλέγει το δεύτερο και το πλήκτρο Esc κρύβει (κλείνει) το παράθυρο. Ο προεπιλεγμένος χειριστής σήματος αντικαθίσταται, όπως περιγράφεται στην ενότητα Αντικατάσταση προεπιλεγμένων χειριστών σημάτων στο παράρτημα.

Συμβάντα πληκτρολογίου - απλό

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>

    class ExampleWindow : public Gtk::Window
    {
    public:

      ExampleWindow();
      virtual ~ExampleWindow();

    private:
      //Override default signal handler:
      bool on_key_press_event(GdkEventKey* event) override;

      Gtk::Grid m_container;
      Gtk::RadioButton m_first;
      Gtk::RadioButton m_second;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    {
      set_title("Keyboard Events");
      set_border_width(10);
      add(m_container);

      // Radio buttons:
      m_first.set_label("First");
      m_second.set_label("Second");

      Gtk::RadioButton::Group group = m_first.get_group();
      m_second.set_group(group);
      m_first.set_active();

      // Main Container:
      m_container.add(m_first);
      m_container.add(m_second);

      // Events.
      // We override the default event signal handler.
      add_events(Gdk::KEY_PRESS_MASK);

      show_all_children();
    }

    bool ExampleWindow::on_key_press_event(GdkEventKey* key_event)
    {
      //GDK_MOD1_MASK -> the 'alt' key(mask)
      //GDK_KEY_1 -> the '1' key
      //GDK_KEY_2 -> the '2' key

      //select the first radio button, when we press alt + 1
      if((key_event->keyval == GDK_KEY_1) &&
        (key_event->state &(GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == GDK_MOD1_MASK)
      {
        m_first.set_active();
        //returning true, cancels the propagation of the event
        return true;
      }
      else if((key_event->keyval == GDK_KEY_2) &&
        (key_event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == GDK_MOD1_MASK)
      {
        //and the second radio button, when we press alt + 2
        m_second.set_active();
        return true;
      }
      else if(key_event->keyval == GDK_KEY_Escape)
      {
        //close the window, when the 'esc' key is pressed
        hide();
        return true;
      }

      //if the event has not been handled, call the base class
      return Gtk::Window::on_key_press_event(key_event);
    }

    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[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

### Διάδοση συμβάντος

Διάδοση συμβάντος σημαίνει ότι, όταν ένα συμβάν εκπέμπεται σε ένα συγκεκριμένο γραφικό συστατικό, μπορεί να περαστεί στο γονικό τους γραφικό συστατικό (και αυτό το γραφικό συστατικό μπορεί να το περάσει στο γονικό του, και ούτω καθεξής) και, αν το γονικό έχει έναν χειριστή συμβάντος, αυτός ο χειριστής θα κληθεί.

Αντίθετα με άλλα συμβάντα, τα συμβάντα πληκτρολογίου στέλνονται πρώτα στο παράθυρο ανωτάτου επιπέδου (Gtk::Window), όπου θα ελεγχθεί για οποιεσδήποτε συντομεύσεις πληκτρολογίου που μπορούν να οριστούν (πλήκτρα επιταχυντή και μνημονικά, που χρησιμοποιούνται για επιλογή στοιχείων μενού από το πληκτρολόγιο). Μετά από αυτό (και θεωρώντας ότι το συμβάν δεν επεξεργάστηκε), στέλνεται στο γραφικό συστατικό που έχει την εστίαση και η διάδοση ξεκινά από εκεί.

Το συμβάν θα διαδοθεί μέχρι να φτάσει στο γραφικό συστατικό ανωτάτου επιπέδου, ή μέχρι να σταματήστε τη διάδοση επιστρέφοντας `true` από έναν χειριστή συμβάντος.

Σημειώστε, ότι μετά την ακύρωση ενός συμβάντος, καμιά άλλη συνάρτηση δεν θα κληθεί (ακόμα κι αν είναι από το ίδιο γραφικό συστατικό).

#### Παράδειγμα

Σε αυτό το παράδειγμα υπάρχουν τρεις χειριστές συμβάντων που καλούνται μετά τον προεπιλεγμένο χειριστή συμβάντος της Gtk::Window, ένας στην Gtk::Entry, ένας στην Gtk::Grid και ένας στην Gtk::Window.

Στην Gtk::Window, έχουμε επίσης αντικαταστήσει τον προεπιλεγμένο χειριστή (on_key_release_event()), και ένας άλλος χειριστής καλείται πριν τον προεπιλεγμένο χειριστή (windowKeyReleaseBefore()).

Ο σκοπός αυτού του παραδείγματος είναι να εμφανίσει τα βήματα που παίρνει το συμβάν όταν εκπέμπεται.

Όταν γράφετε στην καταχώριση, ένα συμβάν απελευθέρωσης πλήκτρου θα εκπεμφθεί, που θα πάει πρώτα στο παράθυρο ανωτάτου επιπέδου (Gtk::Window), αφού έχουμε έναν ορισμένο χειριστή συμβάντος να κληθεί πριν, αυτό λέγεται πρώτο (windowKeyReleaseBefore()). Έπειτα ο προεπιλεγμένος χειριστής καλείται (τον οποίο έχουμε αντικαταστήσει) και μετά από αυτό το συμβάν στέλνεται στο γραφικό συστατικό που έχει την εστίαση, η Entry στο παράδειγμά μας και ανάλογα με το αν το επιτρέψουμε, μπορεί να φτάσει στους χειριστές συμβάντων των Grid και Window. Αν διαδοθεί, το κείμενο που γράφετε θα εμφανιστεί στην Label πάνω από την Entry.

Συμβάντα πληκτρολογίου - Διάδοση συμβάντος

Source Code

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:
      bool on_key_release_event(GdkEventKey* event) override;

      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* key_event)
    {
      std::cout << "Window overridden" << std::endl;

      // call base class function (to get the normal behaviour)
      return Gtk::Window::on_key_release_event(key_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[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

## Λήξεις χρόνου, είσοδος/έξοδος και αδρανείς συναρτήσεις

### Λήξεις χρόνου

Μπορεί να αναρωτιέστε πώς γίνεται η gtkmm να κάνει χρήσιμη εργασία, ενώ είναι αδρανής. Ευτυχώς, έχετε πολλές επιλογές. Χρησιμοποιώντας τις ακόλουθες μεθόδους μπορείτε να δημιουργήσετε μια μέθοδο ορίου χρόνου που θα καλείται κάθε λίγα χιλιοστά του δευτερολέπτου.

    sigc::connection Glib::SignalTimeout::connect(const sigc::slot<bool>& slot,
                                          unsigned int interval, int priority = Glib::PRIORITY_DEFAULT);

Το πρώτο όρισμα είναι μια slot που θέλετε να κληθεί όταν συμβαίνει λήξη χρόνου. Το δεύτερο όρισμα είναι ένας αριθμός χιλιοστών του δευτερολέπτου μεταξύ κλήσεων σε αυτήν τη μέθοδο. Δέχεστε ένα αντικείμενο sigc::connection που μπορεί να χρησιμοποιηθεί για απενεργοποίηση της σύνδεσης χρησιμοποιώντας τη μέθοδό του disconnect():

    my_connection.disconnect();

Another way of destroying the connection is your signal handler. It has to be of the type sigc::slot<bool>. As you see from the definition your signal handler has to return a value of the type `bool`. A definition of a sample method might look like this:

    bool MyCallback() { std::cout << "Hello World!\n" << std::endl; return true; }

Μπορείτε να σταματήσετε τη μέθοδο λήξης χρόνου επιστρέφοντας `false` από τον χειριστή σήματός σας. Συνεπώς, αν θέλετε η μέθοδός σας να καλείται επανειλημμένα, θα πρέπει να επιστρέψετε `true`.

Ιδού ένα παράδειγμα αυτής της τεχνικής:

Source Code

File: `timerexample.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_TIMEREXAMPLE_H
    #define GTKMM_EXAMPLE_TIMEREXAMPLE_H

    #include <gtkmm.h>
    #include <iostream>
    #include <map>

    class TimerExample : public Gtk::Window
    {
    public:
      TimerExample();

    protected:
      // signal handlers
      void on_button_add_timer();
      void on_button_delete_timer();
      void on_button_quit();

      // This is the callback function the timeout will call
      bool on_timeout(int timer_number);

      // Member data:

      Gtk::Box m_Box;
      Gtk::Button m_ButtonAddTimer, m_ButtonDeleteTimer, m_ButtonQuit;

      // Keep track of the timers being added:
      int m_timer_number;

      // These two constants are initialized in the constructor's member initializer:
      const int count_value;
      const int timeout_value;

      // STL map for storing our connections
      std::map<int, sigc::connection> m_timers;

      // STL map for storing our timer values.
      // Each timer counts back from COUNT_VALUE to 0 and is removed when it reaches 0
      std::map<int, int> m_counters;
    };

    #endif // GTKMM_EXAMPLE_TIMEREXAMPLE_H

File: `timerexample.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "timerexample.h"

    TimerExample::TimerExample() :
      m_Box(Gtk::ORIENTATION_HORIZONTAL, 10),
      m_ButtonAddTimer("_Add", true),
      m_ButtonDeleteTimer("_Remove", true),
      m_ButtonQuit("_Quit", true),
      m_timer_number(0), // start numbering the timers at 0
      count_value(5), // each timer will count down 5 times before disconnecting
      timeout_value(1500) // 1500 ms = 1.5 seconds
    {
      set_border_width(10);

      add(m_Box);
      m_Box.pack_start(m_ButtonAddTimer);
      m_Box.pack_start(m_ButtonDeleteTimer);
      m_Box.pack_start(m_ButtonQuit);

      // Connect the three buttons:
      m_ButtonQuit.signal_clicked().connect(sigc::mem_fun(*this,
                  &TimerExample::on_button_quit));
      m_ButtonAddTimer.signal_clicked().connect(sigc::mem_fun(*this,
                  &TimerExample::on_button_add_timer));
      m_ButtonDeleteTimer.signal_clicked().connect(sigc::mem_fun(*this,
                  &TimerExample::on_button_delete_timer));

      show_all_children();
    }

    void TimerExample::on_button_quit()
    {
      hide();
    }

    void TimerExample::on_button_add_timer()
    {
      // Creation of a new object prevents long lines and shows us a little
      // how slots work.  We have 0 parameters and bool as a return value
      // after calling sigc::bind.
      sigc::slot<bool> my_slot = sigc::bind(sigc::mem_fun(*this,
                  &TimerExample::on_timeout), m_timer_number);

      // This is where we connect the slot to the Glib::signal_timeout()
      sigc::connection conn = Glib::signal_timeout().connect(my_slot,
              timeout_value);

      // Remember the connection:
      m_timers[m_timer_number] = conn;

      // Initialize timer count:
      m_counters[m_timer_number] = count_value + 1;

      // Print some info to the console for the user:
      std::cout << "added timeout " << m_timer_number++ << std::endl;
    }

    void TimerExample::on_button_delete_timer()
    {
      // any timers?
      if(m_timers.empty())
      {
        // no timers left
        std::cout << "Sorry, there are no timers left." << std::endl;
      }
      else
      {
        // get the number of the first timer
        int timer_number = m_timers.begin()->first;

        // Give some info to the user:
        std::cout << "manually disconnecting timer " << timer_number
            << std::endl;

        // Remove the entry in the counter values
        m_counters.erase(timer_number);

        // Diconnect the signal handler:
        m_timers[timer_number].disconnect();

        // Forget the connection:
        m_timers.erase(timer_number);
      }
    }

    bool TimerExample::on_timeout(int timer_number)
    {
      // Print the timer:
      std::cout << "This is timer " << timer_number;

      // decrement and check counter value
      if (--m_counters[timer_number] == 0)
      {
        std::cout << " being disconnected" <<  std::endl;

        // delete the counter entry in the STL MAP
        m_counters.erase(timer_number);

        // delete the connection entry in the STL MAP
        m_timers.erase(timer_number);

        // Note that we do not have to explicitly call disconnect() on the
        // connection since Gtk::Main does this for us when we return false.
        return false;
      }

      // Print the timer value
      std::cout << " - " << m_counters[timer_number] << "/"
          << count_value << std::endl;

     // Keep going (do not disconnect yet):
      return true;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "timerexample.h"
    #include <gtkmm/application.h>

    int main (int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      TimerExample example;
      return app->run(example);
    }

### Εποπτεία εισόδου/εξόδου

Ένα αποτελεσματικό γνώρισμα του Glib (μια από τις βιβλιοθήκες που υπόκεινται στην gtkmm) είναι η ικανότητα να ελέγχουν για δεδομένα σε έναν περιγραφέα αρχείου για σας. Αυτό είναι ιδιαίτερα χρήσιμο για εφαρμογές δικτύωσης. Η παρακάτω μέθοδος χρησιμοποιείται για να κάνετε αυτό:

    sigc::connection Glib::SignalIO::connect(const sigc::slot<bool,Glib::IOCondition>& slot,
                                     int fd, Glib::IOCondition condition,
                                     int priority = Glib::PRIORITY_DEFAULT);

Το πρώτο όρισμα είναι μια σχισμή που θέλετε να κληθεί όταν το συγκεκριμένο συμβάν (δείτε όρισμα 3) συμβαίνει στον περιγραφέα του αρχείου που ορίσατε χρησιμοποιώντας το όρισμα δύο. Το όρισμα τρία μπορεί να είναι ένα ή περισσότερα (χρησιμοποιώντας `|`) των:

- Glib::IO_IN - Κλήση της μεθόδου σας όταν υπάρχουν δεδομένα έτοιμα για ανάγνωση στον περιγραφέα αρχείου σας.

- Glib::IO_OUT - Κλήση της μεθόδου σας όταν ο περιγραφέας αρχείου είναι έτοιμος για εγγραφή.

- Glib::IO_PRI - Κλήση της μεθόδου σας όταν ο περιγραφέας αρχείου έχει επείγοντα δεδομένα για ανάγνωση.

- Glib::IO_ERR - Κλήση της μεθόδου σας όταν ένα σφάλμα προκύψει στον περιγραφέα αρχείου.

- Glib::IO_HUP - Κλήση της μεθόδου σας όταν διακόψει (η σύνδεση έχει διακοπεί συνήθως για διοχετεύσεις και υποδοχές).

Η τιμή επιστροφής είναι μια sigc::connection που μπορεί να χρησιμοποιηθεί για να σταματήσει την παρακολούθηση αυτού του περιγραφέα αρχείου χρησιμοποιώντας τη μέθοδό του disconnect(). Ο χειριστής σήματος slot πρέπει να δηλωθεί ως εξής:

    bool input_callback(Glib::IOCondition condition);

όπου η condition ορίζεται όπως παραπάνω. Ως συνήθως, η υποδοχή δημιουργείται με την `sigc::mem_fun()` (για μια μέθοδο μέλους ενός αντικειμένου.), ή `sigc::ptr_fun()` (για μια συνάρτηση).

Ένα μικρό παράδειγμα ακολουθεί. Για τη χρήση του παραδείγματος εκτελέστε το απλά από ένα τερματικό· δεν δημιουργεί παράθυρο. Θα δημιουργήσει μια διοχέτευση με όνομα `testfifo` στον τρέχοντα κατάλογο. Έπειτα ξεκινήστε ένα άλλο κέλυφος και εκτελέστε την `echo "Hello" > testfifo`. Το παράδειγμα θα εκτυπώσει κάθε γραμμή που εισάγετε μέχρι την εκτέλεση της `echo "Q" > testfifo`.

Source Code

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <build/config.h>
    #include <gtkmm/application.h>
    #include <glibmm/main.h>
    #include <glibmm/iochannel.h>
    #include <fcntl.h>
    #include <iostream>

    #include <unistd.h> //The SUN Forte compiler puts F_OK here.

    //The SUN Forte compiler needs these for mkfifo:
    #include <sys/types.h>
    #include <sys/stat.h>

    Glib::RefPtr<Gtk::Application> app;

    int read_fd;
    Glib::RefPtr<Glib::IOChannel> iochannel;

    /*
      send to the fifo with:
      echo "Hello" > testfifo

      quit the program with:
      echo "Q" > testfifo
    */

    // this will be our signal handler for read operations
    // it will print out the message sent to the fifo
    // and quit the program if the message was 'Q'.
    bool MyCallback(Glib::IOCondition io_condition)
    {
      if ((io_condition & Glib::IO_IN) == 0) {
        std::cerr << "Invalid fifo response" << std::endl;
      }
      else {
       Glib::ustring buf;

       iochannel->read_line(buf);
       std::cout << buf;
       if (buf == "Q\n")
         app->quit();

      }
      return true;
    }

    int main(int argc, char *argv[])
    {
      app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      if (access("testfifo", F_OK) == -1) {
        // fifo doesn't exist - create it
        #ifdef HAVE_MKFIFO
        if (mkfifo("testfifo", 0666) != 0) {
          std::cerr << "error creating fifo" << std::endl;
          return -1;
        }
        #else
          std::cerr << "error creating fifo: This platform does not have mkfifo()"
              << std::endl;
        #endif //HAVE_MKFIFO
      }

      // Although we will only read from the fifo, we open it in read/write mode.
      // Due to a peculiarity with the poll() system call, used deep down in glib,
      // this small program will use all available CPU time, if the fifo is opened
      // as O_RDONLY. See a discussion on the gtkmm-list, e.g.
      // https://mail.gnome.org/archives/gtkmm-list/2015-September/msg00034.html
      // and the link from there to stackoverflow.
      read_fd = open("testfifo", O_RDWR);
      if (read_fd == -1)
      {
        std::cerr << "error opening fifo" << std::endl;
        return -1;
      }

      // connect the signal handler
      Glib::signal_io().connect(sigc::ptr_fun(MyCallback), read_fd, Glib::IO_IN);

      // Creates a iochannel from the file descriptor
      iochannel = Glib::IOChannel::create_from_fd(read_fd);

      // and last but not least - run the application main loop
      app->hold(); // keep the application running without a window
      app->run();

      // now remove the temporary fifo
      if(unlink("testfifo"))
        std::cerr << "error removing fifo" << std::endl;

      return 0;
    }

### Αδρανείς συναρτήσεις

Αν θέλετε να ορίσετε μια μέθοδο που καλείται όταν τίποτα άλλο δεν συμβαίνει, χρησιμοποιήστε την ακόλουθη:

    sigc::connection  Glib::SignalIdle::connect(const sigc::slot<bool>& slot,
                                        int priority = Glib::PRIORITY_DEFAULT_IDLE);

Αυτό προκαλεί την gtkmm να καλέσει τη συγκεκριμένη μέθοδο όποτε τίποτα άλλο δεν συμβαίνει. Μπορείτε να προσθέσετε μια προτεραιότητα (μικρότεροι αριθμοί έχουν μεγαλύτερη προτεραιότητα). Υπάρχουν δύο τρόποι για να αφαιρέσετε τον χειριστή σήματος: κλήση της disconnect() στο αντικείμενο sigc::connection, ή επιστροφή της `false` στον χειριστή σήματος, που πρέπει να δηλωθεί ως εξής:

    bool idleFunc();

Αφού αυτό είναι πολύ παρόμοιο με τις παραπάνω μεθόδους αυτή η εξήγηση πρέπει να είναι αρκετή για την κατανόηση του τι συμβαίνει. Όμως, να ένα μικρό παράδειγμα:

Source Code

File: `idleexample.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_IDLEEXAMPLE_H
    #define GTKMM_EXAMPLE_IDLEEXAMPLE_H

    #include <gtkmm.h>
    #include <iostream>

    class IdleExample : public Gtk::Window
    {
    public:
      IdleExample();

    protected:
      // Signal Handlers:
      bool on_timer();
      bool on_idle();
      void on_button_clicked();

      // Member data:
      Gtk::Box m_Box;
      Gtk::Button m_ButtonQuit;
      Gtk::ProgressBar m_ProgressBar_c;
      Gtk::ProgressBar m_ProgressBar_d;
    };

    #endif // GTKMM_EXAMPLE_IDLEEXAMPLE_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "idleexample.h"
    #include <gtkmm/application.h>

    int main (int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      IdleExample example;
      return app->run(example);
    }

File: `idleexample.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "idleexample.h"

    IdleExample::IdleExample() :
      m_Box(Gtk::ORIENTATION_VERTICAL, 5),
      m_ButtonQuit("_Quit", true)
    {
      set_border_width(5);

      // Put buttons into container

      // Adding a few widgets:
      add(m_Box);
      m_Box.pack_start( *Gtk::manage(new Gtk::Label("Formatting Windows drive C:")));
      m_Box.pack_start( *Gtk::manage(new Gtk::Label("100 MB")) );
      m_Box.pack_start(m_ProgressBar_c);

      m_Box.pack_start( *Gtk::manage(new Gtk::Label("")) );

      m_Box.pack_start( *Gtk::manage(new Gtk::Label("Formatting Windows drive D:")));
      m_Box.pack_start( *Gtk::manage(new Gtk::Label("5000 MB")) );
      m_Box.pack_start(m_ProgressBar_d);

      auto hbox = Gtk::manage( new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL,10));
      m_Box.pack_start(*hbox);
      hbox->pack_start(m_ButtonQuit, Gtk::PACK_EXPAND_PADDING);

      // Connect the signal handlers:
      m_ButtonQuit.signal_clicked().connect( sigc::mem_fun(*this,
                  &IdleExample::on_button_clicked) );

      // formatting drive c in timeout signal handler - called once every 50ms
      Glib::signal_timeout().connect( sigc::mem_fun(*this, &IdleExample::on_timer),
              50 );

      // formatting drive d in idle signal handler - called as quickly as possible
      Glib::signal_idle().connect( sigc::mem_fun(*this, &IdleExample::on_idle) );

      show_all_children();
    }

    void IdleExample::on_button_clicked()
    {
      hide();
    }

    // this timer callback function is executed once every 50ms (set in connection
    // above).  Use timeouts when speed is not critical. (ie periodically updating
    // something).
    bool IdleExample::on_timer()
    {
      double value = m_ProgressBar_c.get_fraction();

      // Update progressbar 1/500th each time:
      m_ProgressBar_c.set_fraction(value + 0.002);

      return value < 0.99;  // return false when done
    }

    // This idle callback function is executed as often as possible, hence it is
    // ideal for processing intensive tasks.
    bool IdleExample::on_idle()
    {
      double value = m_ProgressBar_d.get_fraction();

      // Update progressbar 1/5000th each time:
      m_ProgressBar_d.set_fraction(value + 0.0002);

      return value < 0.99;  // return false when done
    }

Αυτό το παράδειγμα δείχνει λίγο τη διαφορά των μεθόδων αδράνειας και λήξης χρόνου. Αν χρειάζεστε μεθόδους που καλούνται περιοδικά και η ταχύτητα δεν είναι πολύ σημαντική, τότε θέλετε μεθόδους χρόνου λήξης. Αν θέλετε μεθόδους που καλούνται όσον το δυνατό πιο συχνά (όπως υπολογισμός κλαστικού στο παρασκήνιο), τότε χρησιμοποιήστε τις αδρανείς μεθόδους.

Δοκιμάστε την εκτέλεση του παραδείγματος και αυξήστε το φορτίο του συστήματος. Η ανώτερη γραμμή προόδου θα αυξάνεται σταθερά· η κατώτερη γραμμή θα επιβραδύνεται.

## Διαχείριση μνήμης

### Γραφικά συστατικά

#### Κανονική διαχείριση μνήμης C++

Η gtkmm επιτρέπει στον προγραμματιστή να ελέγξει τον χρόνο ζωής (δηλαδή, την κατασκευή και καταστροφή) οποιουδήποτε γραφικού συστατικού με τον ίδιο τρόπο όπως οποιοδήποτε άλλο αντικείμενο C++. Αυτή η ευελιξία επιτρέπει τη χρήση των `new` και `delete` για τη δημιουργία και καταστροφή αντικειμένων δυναμικά ή τη χρήση κανονικών μελών κλάσης (που καταστρέφονται αυτόματα όταν καταστρέφεται η κλάση) ή τη χρήση τοπικών στιγμιοτύπων (που καταστρέφονται όταν το στιγμιότυπο βγαίνει εκτός εμβέλειας). Αυτή η ευελιξία δεν παρουσιάζεται σε μερικά πακέτα εργαλείων GUI της C++, που περιορίζει τον προγραμματιστή σε ένα υποσύνολο μόνο των γνωρισμάτων διαχείρισης μνήμης της C++.

Ιδού μερικά παραδείγματα κανονικής διαχείρισης μνήμης C++:

##### Τα γραφικά συστατικά εμβέλειας κλάσης

Αν ένας προγραμματιστής δεν χρειάζεται δυναμική κατανομή μνήμης, μπορούν να χρησιμοποιηθούν αυτόματα γραφικά συστατικά στην εμβέλεια της κλάσης. Ένα πλεονέκτημα των αυτόματων γραφικών συστατικών σε εμβέλεια κλάσης είναι ότι η διαχείριση μνήμης ομαδοποιείται σε μια θέση. Ο προγραμματιστής δεν διακινδυνεύει διαρροές μνήμης από αποτυχία `delete` ενός γραφικού συστατικού.

Το κύριο μειονέκτημα χρήσης γραφικών συστατικών εμβέλειας κλάσης είναι η εμφάνιση της υλοποίησης κλάσης αντί για την διεπαφή κλάσης στην κεφαλίδα κλάσης.

    #include <gtkmm/button.h>
    #include <gtkmm/window.h>
    class Foo : public Gtk::Window
    {
    private:
      Gtk::Button theButton;
      // θα καταστραφεί όταν το αντικείμενο Foo καταστραφεί
    };

##### Γραφικά συστατικά εμβέλειας συνάρτησης

If a programmer does not need a class scope widget, a function scope widget may also be used. The advantages to function scope over class scope are the increased data hiding and reduced dependencies.

    {
      Gtk::Button aButton;
      aButton.show();
      ...
      app->run();
    }

##### Η δυναμική κατανομή με νέο και διαγραφή

Although, in most cases, the programmer will prefer to allow containers to automatically destroy their children using `Gtk::manage()` (see below), the programmer is not required to use `Gtk::manage()`. The traditional `new` and `delete` operators may also be used.

    Gtk::Button* pButton = new Gtk::Button("Test");

    // do something useful with pButton

    delete pButton;

Here, the programmer deletes `pButton` to prevent a memory leak.

#### Διαχειριζόμενα γραφικά συστατικά

Εναλλακτικά, μπορείτε να επιτρέψετε ένα χειριστήριο περιέκτη του γραφικού συστατικού όταν το γραφικό συστατικό καταστρέφεται. Στις περισσότερες περιπτώσεις, θέλετε ένα γραφικό συστατικό να κρατήσει μόνο όσο ο περιέκτης είναι μέσα. Για ανάθεση της διαχείρισης χρόνου ζωής του γραφικού συστατικού στο περιέκτη του, δημιουργήστε το πρώτα με την `Gtk::manage()`και συσκευάστε το στον περιέκτη του με τις Gtk::Container::add(), Gtk::Box::pack_start(), ή μια παρόμοια μέθοδο. Τώρα, το γραφικό συστατικό θα καταστραφεί όποτε καταστρέφεται ο περιέκτης του.

##### Δυναμική κατανομή με manage() και add()

Η gtkmm παρέχει τη συνάρτηση `manage()` και τις μεθόδους add() για δημιουργία και καταστροφή γραφικών συστατικών. Κάθε γραφικό συστατικό εκτός από το παράθυρο ανωτάτου επιπέδου πρέπει να προστεθεί ή να συσκευαστεί σε έναν περιέκτη για να εμφανιστεί. Η συνάρτηση `manage()` σημειώνει ένα γραφικό συστατικό έτσι ώστε όταν το γραφικό συστατικό προστίθεται σε έναν περιέκτη, ο περιέκτης γίνεται υπεύθυνος για διαγραφή του γραφικού συστατικού.

    MyContainer::MyContainer()
    {
      Gtk::Button* pButton = Gtk::manage(new Gtk::Button("Test"));
      add(*pButton); //add *pButton to MyContainer
    }

Now, when objects of type MyContainer are destroyed, the button will also be deleted. It is no longer necessary to delete `pButton` to free the button's memory; its deletion has been delegated to the MyContainer object.

Φυσικά, ένας περιέκτης ανωτάτου επιπέδου δεν θα προστεθεί σε άλλον περιέκτη. Ο προγραμματιστής είναι υπεύθυνος για την καταστροφή του περιέκτη ανωτάτου επιπέδου χρησιμοποιώντας μία από τις παραδοσιακές τεχνικές της C++. Για παράδειγμα, το παράθυρο ανωτάτου επιπέδου σας μπορεί να είναι απλά ένα στιγμιότυπο στη συνάρτησή σας `main()`.

### Κοινόχρηστοι πόροι

Κάποια αντικείμενα, όπως Gdk::Pixbufs και Pango::Fonts, παίρνονται από μια κοινόχρηστη μνήμη. Συνεπώς δεν μπορείτε να δημιουργήσετε τα δικά σας στιγμιότυπα. Αυτές οι κλάσεις τυπικά κληρονομούν από την Glib::Object. Αντί να σας ζητιέται να αναφέρετε και να αποαναφέρετε αυτά τα αντικείμενα, η gtkmm χρησιμοποιεί τον έξυπνο δείκτη Glib::RefPtr<>. Το Cairomm έχει τον δικό του έξυπνο δείκτη, Cairo::RefPtr<>.

Objects such as Gdk::Pixbuf can only be instantiated with a create() function. For instance,

    Glib::RefPtr<Gdk::Pixbuf> pixbuf = Gdk::Pixbuf::create_from_file(filename);

You have no way of getting a bare Gdk::Pixbuf. In the example, `pixbuf` is a smart pointer, so you can do this, much like a normal pointer:

    int width = 0;
    if(pixbuf)
    {
      width = pixbuf->get_width();
    }

Όταν η `pixbuf` βγαίνει εκτός εμβέλειας μιας unref() θα συμβεί στο παρασκήνιο και δεν χρειάζεται να ανησυχείτε για αυτό πια. Δεν υπάρχει κανένα `new`, έτσι δεν υπάρχει κανένα `delete`.

If you copy a RefPtr, for instance

    Glib::RefPtr<Gdk::Pixbuf> pixbuf2 = pixbuf;

, or if you pass it as a method argument or a return type, then RefPtr will do any necessary referencing to ensure that the instance will not be destroyed until the last RefPtr has gone out of scope.

Δείτε το παράρτημα για λεπτομερείς πληροφορίες σχετικά με την RefPtr.

If you wish to learn more about smartpointers, you might look in these books:

- Bjarne Stroustrup, "The C++ Programming Language" Forth Edition - section 34.3

- Nicolai M. Josuttis, "The C++ Standard Library" - section 4.2

## Glade and Gtk::Builder

Αν και μπορείτε να χρησιμοποιήσετε τον κώδικα C++ για να δημιουργήσετε και να τακτοποιήσετε τα γραφικά συστατικά, αυτό μπορεί σύντομα να γίνει κουραστικό και επαναλαμβανόμενο. Και απαιτεί μια αναμεταγλώττιση για την εμφάνιση των αλλαγών. Η εφαρμογή Glade επιτρέπει να τακτοποιήσετε τα γραφικά συστατικά στην οθόνη και έπειτα να αποθηκεύσετε μια περιγραφή XML της διάταξης. Η εφαρμογή σας μπορεί τότε να χρησιμοποιήσει την API Gtk::Builder για να φορτώσει αυτό το αρχείο XML στον χρόνο εκτέλεσης και να πάρει έναν δείκτη στα ειδικά ονοματισμένα στιγμιότυπα γραφικού συστατικού.

This has the following advantages:

1. Less C++ code is required.

2. UI changes can be seen more quickly, so UIs are able to improve.

3. Designers without programming skills can create and edit UIs.

Χρειάζεστε ακόμα κώδικα C++ για να αντιμετωπίσετε αλλαγές διεπαφής χρήστη που προκλήθηκαν από ενέργειες χρήστη, αλλά η χρήση της Gtk::Builder για τη διάταξη γραφικού συστατικού επιτρέπει να εστιάσετε στην υλοποίηση αυτής της λειτουργίας.

### Φόρτωση του αρχείου .glade

Gtk::Builder must be used via a Glib::RefPtr. Like all such classes, you need to use a create() method to instantiate it. For instance,

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

This will instantiate the windows defined in the .glade file, though they will not be shown immediately unless you have specified that via the Properties window in Glade.

To instantiate just one window, or just one of the child widgets, you can specify the name of a widget as the second parameter. For instance,

    Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create_from_file("basic.glade", "treeview_products");

### Πρόσβαση γραφικών συστατικών

To access a widget, for instance to show() a dialog, use the get_widget() method, providing the widget's name. This name should be specified in the Glade Properties window. If the widget could not be found, or is of the wrong type, then the pointer will be set to nullptr.

    Gtk::Dialog* pDialog = nullptr;
    builder->get_widget("DialogBasic", pDialog);

Η Gtk::Builder ελέγχει για έναν μηδενικό δείκτη και ελέγχει ότι το γραφικό συστατικό είναι του αναμενόμενου τύπου και θα εμφανίσει προειδοποιήσεις στη γραμμή εντολών για αυτά.

Να θυμάστε ότι δεν δημιουργείτε ένα γραφικό συστατικό με τη get_widget(), απλά παίρνετε έναν δείκτη στο ήδη υπάρχον. Θα δεχτείτε πάντα έναν δείκτη στο ίδιο στιγμιότυπο, όταν καλείτε την get_widget() στην ίδια Gtk::Builder, με το ίδιο όνομα γραφικού συστατικού. Τα γραφικά συστατικά δημιουργούνται κατά τη διάρκεια της Gtk::Builder::create_from_file().

Η get_widget() επιστρέφει θυγατρικά γραφικά συστατικά που είναι `manage()`ed (δείτε το κεφάλαιο Διαχείριση μνήμης), έτσι θα διαγραφούν όταν ο γονικός τους περιέκτης διαγράφεται. Έτσι, αν πάρετε μόνο ένα θυγατρικό γραφικό συστατικό από την Gtk::Builder, αντί για ένα πλήρες παράθυρο, τότε πρέπει ή να το βάλετε σε έναν Container ή να το διαγράψετε. Η Windows (όπως η Dialogs) δεν μπορεί να διαχειριστεί, επειδή δεν έχουν γονικό περιέκτη, έτσι πρέπει να τα διαγράψετε σε κάποιο σημείο.

#### Παράδειγμα

Αυτό το απλό παράδειγμα εμφανίζει πώς να φορτώσετε ένα αρχείο Glade στον χρόνο εκτέλεσης και να προσπελάσετε τα γραφικά συστατικά με την Gtk::Builder.

Source Code

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <gtkmm.h>
    #include <iostream>

    Gtk::Dialog* pDialog = nullptr;

    static
    void on_button_clicked()
    {
      if(pDialog)
        pDialog->hide(); //hide() will cause main::run() to end.
    }

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

      //Load the GtkBuilder file and instantiate its widgets:
      auto refBuilder = Gtk::Builder::create();
      try
      {
        refBuilder->add_from_file("basic.glade");
      }
      catch(const Glib::FileError& ex)
      {
        std::cerr << "FileError: " << ex.what() << std::endl;
        return 1;
      }
      catch(const Glib::MarkupError& ex)
      {
        std::cerr << "MarkupError: " << ex.what() << std::endl;
        return 1;
      }
      catch(const Gtk::BuilderError& ex)
      {
        std::cerr << "BuilderError: " << ex.what() << std::endl;
        return 1;
      }

      //Get the GtkBuilder-instantiated Dialog:
      refBuilder->get_widget("DialogBasic", pDialog);
      if(pDialog)
      {
        //Get the GtkBuilder-instantiated Button, and connect a signal handler:
        Gtk::Button* pButton = nullptr;
        refBuilder->get_widget("quit_button", pButton);
        if(pButton)
        {
          pButton->signal_clicked().connect( sigc::ptr_fun(on_button_clicked) );
        }

        app->run(*pDialog);
      }

      delete pDialog;

      return 0;
    }

### Χρησιμοποιώντας παράγωγα γραφικά συστατικά

Μπορείτε να χρησιμοποιήσετε την Glade για την διευθέτηση προσαρμοσμένων γραφικών συστατικών που παράγονται από τις κλάσεις γραφικών συστατικών gtkmm. Αυτό κρατά τον κώδικά σας οργανωμένο και ενθυλακωμένο. Φυσικά δεν θα δείτε την ακριβή εμφάνιση και τις ιδιότητες του παραγόμενου γραφικού συστατικού σας στην Glade, αλλά μπορείτε να ορίσετε τη θέση του και τα θυγατρικά γραφικά συστατικά καθώς και τις ιδιότητες της βασικής κλάσης του gtkmm.

Use Gtk::Builder::get_widget_derived() like so:

    DerivedDialog* pDialog = nullptr;
    builder->get_widget_derived("DialogBasic", pDialog);

Η παραγόμενη κλάση σας πρέπει να έχει έναν κατασκευαστή που παίρνει έναν δείκτη στον υποκείμενο τύπο C και το στιγμιότυπο Gtk::Builder. Όλες οι σχετικές κλάσεις της gtkmm ορίζουν τύπο τον υποκείμενο τύπο τους της C ως BaseObjectType (Gtk::Dialog ορίζει τύπους BaseObjectType ως GtkDialog, για παράδειγμα).

You must call the base class's constructor in the initialization list, providing the C pointer. For instance,

    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder)
    : Gtk::Dialog(cobject)
    {
    }

You could then encapsulate the manipulation of the child widgets in the constructor of the derived class, maybe using get_widget() or get_widget_derived() again. For instance,

    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder)
    : Gtk::Dialog(cobject),
      m_builder(builder),
      m_pButton(nullptr)
    {
      //Get the Glade-instantiated Button, and connect a signal handler:
      m_builder->get_widget("quit_button", m_pButton);
      if(m_pButton)
      {
        m_pButton->signal_clicked().connect( sigc::mem_fun(*this, &DerivedDialog::on_button_quit) );
      }
    }

Starting with gtkmm 3.19.7, it's possible to pass additional arguments from get_widget_derived() to the constructor of the derived widget. For instance, this call to get_widget_derived()

    DerivedDialog* pDialog = nullptr;
    builder->get_widget_derived("DialogBasic", pDialog, true);

can invoke this constructor

    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder, bool warning)
    : Gtk::Dialog(cobject),
      m_builder(builder),
      m_pButton(nullptr)
    {
      // ....
    }

#### Παράδειγμα

Αυτό το παράδειγμα εμφανίζει πώς να φορτώσετε ένα αρχείο Glade στον χρόνο εκτέλεσης και να πώς να προσπελάσετε τα γραφικά συστατικά μέσα από μια παράγωγη κλάση.

Source Code

File: `deriveddialog.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_DERIVED_DIALOG_H
    #define GTKMM_EXAMPLE_DERIVED_DIALOG_H

    #include <gtkmm.h>

    class DerivedDialog : public Gtk::Dialog
    {
    public:
      DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& refGlade);
      DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& refGlade,
        bool is_glad);
      virtual ~DerivedDialog();

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

      Glib::RefPtr<Gtk::Builder> m_refGlade;
      Gtk::Button* m_pButton;
    };

    #endif //GTKMM_EXAMPLE_DERIVED_WINDOW_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "deriveddialog.h"
    #include <iostream>
    #include <cstring>

    int main (int argc, char **argv)
    {
      bool show_icon = false;
      bool is_glad = true;
      int argc1 = argc;
      if (argc > 1)
      {
        if (std::strcmp(argv[1], "--glad") == 0)
        {
          show_icon = true;
          is_glad = true;
          argc1 = 1; // Don't give the command line arguments to Gtk::Application.
        }
        else if (std::strcmp(argv[1], "--sad") == 0)
        {
          show_icon = true;
          is_glad = false;
          argc1 = 1; // Don't give the command line arguments to Gtk::Application.
        }
      }

      auto app = Gtk::Application::create(argc1, argv, "org.gtkmm.example");

      //Load the Glade file and instantiate its widgets:
      auto refBuilder = Gtk::Builder::create();
      try
      {
        refBuilder->add_from_file("derived.glade");
      }
      catch(const Glib::FileError& ex)
      {
        std::cerr << "FileError: " << ex.what() << std::endl;
        return 1;
      }
      catch(const Glib::MarkupError& ex)
      {
        std::cerr << "MarkupError: " << ex.what() << std::endl;
        return 1;
      }
      catch(const Gtk::BuilderError& ex)
      {
        std::cerr << "BuilderError: " << ex.what() << std::endl;
        return 1;
      }

      //Get the GtkBuilder-instantiated dialog:
      DerivedDialog* pDialog = nullptr;
      if (show_icon)
        // This call to get_widget_derived() requires gtkmm 3.19.7 or higher.
        refBuilder->get_widget_derived("DialogDerived", pDialog, is_glad);
      else
        refBuilder->get_widget_derived("DialogDerived", pDialog);
      if(pDialog)
      {
        //Start:
        app->run(*pDialog);
      }

      delete pDialog;

      return 0;
    }

File: `deriveddialog.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "deriveddialog.h"

    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& refGlade)
    : Gtk::Dialog(cobject),
      m_refGlade(refGlade),
      m_pButton(nullptr)
    {
      //Get the Glade-instantiated Button, and connect a signal handler:
      m_refGlade->get_widget("quit_button", m_pButton);
      if(m_pButton)
      {
        m_pButton->signal_clicked().connect( sigc::mem_fun(*this, &DerivedDialog::on_button_quit) );
      }
    }

    // The first two parameters are mandatory in a constructor that will be called
    // from Gtk::Builder::get_widget_derived().
    // Additional parameters, if any, correspond to additional arguments in the call
    // to Gtk::Builder::get_widget_derived().
    DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& refGlade,
      bool is_glad)
    : DerivedDialog(cobject, refGlade) // Delegate to the other constructor
    {
      // Show an icon.
      auto pImage = Gtk::manage(new Gtk::Image());
      pImage->set_from_icon_name(is_glad ? "face-smile" : "face-sad", Gtk::ICON_SIZE_DIALOG);
      pImage->show_all();
      get_content_area()->pack_start(*pImage);
    }

    DerivedDialog::~DerivedDialog()
    {
    }

    void DerivedDialog::on_button_quit()
    {
      hide(); //hide() will cause Gtk::Application::run() to end.
    }

## Διεθνοποίηση και τοπικοποίηση

Οι εφαρμογές gtkmm μπορούν εύκολα να υποστηρίξουν πολλαπλές γλώσσες, συμπεριλαμβανομένων μη ευρωπαϊκών γλωσσών όπως κινέζικα και γλώσσες από δεξιά προς τα αριστερά όπως αραβικά. Μια κατάλληλα γραμμένη και μεταφρασμένη εφαρμογή gtkmm θα χρησιμοποιήσει την κατάλληλη γλώσσα στον χρόνο εκτέλεσης με βάση το περιβάλλον του χρήστη.

Μπορεί να μην προβλέψετε την ανάγκη υποστήριξης πρόσθετων γλωσσών, αλλά δεν μπορείτε ποτέ να το αποκλείσετε. Φυσικά, είναι ευκολότερο να αναπτύξετε την εφαρμογή κατάλληλα από την αρχή αντί να την τροποποιήσετε αργότερα.

Η διαδικασία συγγραφής πηγαίου κώδικα που επιτρέπει την μετάφραση λέγεται `διεθνοποίηση`, συχνά συντομεύεται σε `i18n`. Η διεργασία `τοπικοποίηση`, μερικές φορές συντομευμένη ως `l10n`, παρέχει μεταφρασμένο κείμενο για άλλες γλώσσες, με βάση αυτόν τον πηγαίο κώδικα.

Η κύρια δραστηριότητα στην διεργασία διεθνοποίησης είναι η εύρεση των συμβολοσειρών που βλέπουν οι χρήστες και η σημείωσή τους για μετάφραση. Δεν χρειάζεστε να το κάνετε όλο μονομιάς - αν εγκαταστήσετε την απαραίτητη υποδομή του έργου σωστά, τότε η εφαρμογή σας θα δουλέψει κανονικά ανεξάρτητα από το πόσες συμβολοσειρές έχετε καλύψει.

Οι κυριολεκτικές συμβολοσειρές πρέπει να πληκτρολογηθούν στα αγγλικά, αλλά περιβαλόμενες από μια μακροεντολή. Το εργαλείο gettext (ή intltool) μπορεί τότε να εξάγει τις σημειωμένες συμβολοσειρές για μετάφραση και να αντικαταστήσει το μεταφρασμένο κείμενο στον χρόνο εκτέλεσης.

### Προετοιμασία του έργου σας

In the instructions below we will assume that you will not be using gettext directly, but intltool, which was written specifically for `GNOME`. intltool uses `gettext()`, which extracts strings from source code, but intltool can also combine strings from other files, for example from desktop menu details, and GUI resource files such as Glade files, into standard gettext `.pot/.po` files.

We also assume that you are using autotools (e.g. automake and autoconf) to build your project, and that you are using `./autogen.sh` from gnome-common or a similar `autogen.sh` file, which, among other things, takes care of some intltool initialization.

An alternative to gnome-common's `autogen.sh` may look like this:

    #! /bin/sh -e
    test -n "$srcdir" || srcdir=`dirname "$0"`
    test -n "$srcdir" || srcdir=.

    autoreconf --force --install --verbose --warnings=all "$srcdir"
    echo "Running intltoolize --copy --force --automake"
    intltoolize --copy --force --automake
    test -n "$NOCONFIGURE" || "$srcdir/configure" "$@"

Δημιουργήστε έναν υποκατάλογο με όνομα `po` στον ριζικό κατάλογο του έργου σας. Αυτός ο κατάλογος θα περιέχει τελικά όλες τις μεταφράσεις σας. Μέσα σε αυτόν, δημιουργήστε ένα αρχείο με όνομα `LINGUAS` και ένα αρχείο με όνομα `POTFILES.in`. Είναι κοινή πρακτική να δημιουργείτε επίσης ένα αρχείο `ChangeLog` στον κατάλογο `po`, έτσι ώστε οι μεταφραστές να μπορούν να παρακολουθούν τις αλλαγές της μετάφρασης.

Το `LINGUAS` περιέχει έναν αλφαβητικά ταξινομημένο κατάλογο κωδίκων που αναγνωρίζει τις γλώσσες για τις οποίες το πρόγραμμά σας μεταφράζεται (γραμμές σχολιασμού που ξεκινούν με ένα `#` αγνοούνται). Κάθε καταχωρισμένος κωδικός γλώσσας στο αρχείο `LINGUAS` πρέπει να έχει ένα αντίστοιχο αρχείο `.po`. Έτσι, αν το πρόγραμμά σας έχει γερμανική και ιαπωνική μετάφραση, το αρχείο σας `LINGUAS` θα μοιάζει ως εξής:

    # keep this file sorted alphabetically, one language code per line
    de
    ja

(Επιπλέον, θα έχετε τα αρχεία `ja.po` και `de.po` στον κατάλογό σας `po` που περιέχει την γερμανική και ιαπωνική μετάφραση, αντίστοιχα.)

Το `POTFILES.in` είναι ένας κατάλογος διαδρομών σε όλα τα αρχεία που περιέχουν συμβολοσειρές σημειωμένες για μετάφραση, ξεκινώντας από τον ριζικό κατάλογο του έργου. Έτσι, για παράδειγμα, αν οι πηγές του έργου σας είναι σε έναν υποκατάλογο με όνομα `src` και έχετε δύο αρχεία που περιέχουν συμβολοσειρές που πρέπει να μεταφραστούν, το αρχείο `POTFILES.in` μπορεί να μοιάζει ως εξής:

    src/main.cc
    src/other.cc

Αν χρησιμοποιείτε μια gettext άμεσα, μπορείτε μόνο να σημειώ σετε τις συμβολοσειρές για μετάφραση αν είναι στο αρχείο πηγαίου κώδικα. Όμως, αν χρησιμοποιείτε intltool, μπορείτε να σημειώσετε τις συμβολοσειρές για μετάφραση σε μια ποικιλία άλλων μορφών αρχείων, συμπεριλαμβάνοντας αρχεία διεπαφής χρήστη Glade, xml, .desktop files και πολλά περισσότερα. Έτσι, αν έχετε σχεδιάσει κάποια διεπαφή χρήστη της εφαρμογής σε Glade, τότε προσθέστε επίσης τα αρχεία σας `.glade` στον κατάλογο στο `POTFILES.in`.

Τώρα που υπάρχει μια θέση να βάλετε τις μεταφράσεις σας, χρειάζεται να αρχικοποιήσετε τις intltool και gettext. Προσθέστε τον ακόλουθο κώδικα στην `configure.ac`, αντικαθιστώντας το 'programname' με το όνομα του προγράμματός σας:

    IT_PROG_INTLTOOL([0.35.0])

    GETTEXT_PACKAGE=programname
    AC_SUBST(GETTEXT_PACKAGE)
    AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"],
                       [The domain to use with gettext])
    AM_GNU_GETTEXT([external])
    AM_GNU_GETTEXT_VERSION([0.17])

    PROGRAMNAME_LOCALEDIR=[${datadir}/locale]
    AC_SUBST(PROGRAMNAME_LOCALEDIR)

Αυτή η μεταβλητή `PROGRAMNAME_LOCALEDIR` θα χρησιμοποιηθεί αργότερα στο αρχείο `Makefile.am`, για να ορίσει μια μακροεντολή που θα χρησιμοποιηθεί όταν αρχικοποιήσετε την gettext στον πηγαίο κώδικά σας.

`AM_GLIB_GNU_GETTEXT` has been an alternative to `AM_GNU_GETTEXT` and `AM_GNU_GETTEXT_VERSION`, but `AM_GLIB_GNU_GETTEXT` is now deprecated, and shall not be used in new code.

In the top-level Makefile.am:

- Add `po` to the `SUBDIRS` variable. Without this, your translations won't get built and installed when you build the program

- Define `INTLTOOL_FILES` as:

      INTLTOOL_FILES = intltool-extract.in \
                       intltool-merge.in \
                       intltool-update.in

- Add `INTLTOOL_FILES` to the `EXTRA_DIST` list of files. This ensures that when you do a `make dist`, these commands will be included in the source tarball.

- Update your `DISTCLEANFILES`:

      DISTCLEANFILES = ... intltool-extract \
                       intltool-merge \
                       intltool-update \
                       po/.intltool-merge-cache

- Depending on the types of files that contain translatable strings, add code such as

      desktopdir = $(datadir)/applications
      desktop_in_files = programname.desktop.in
      desktop_DATA = $(desktop_in_files:.desktop.in=.desktop)
      @INTLTOOL_DESKTOP_RULE@

Στο `src/Makefile.am` σας, ενημερώστε το `AM_CPPFLAGS` σας για να προσθέσετε τον ακόλουθο προεπεξεργαστή ορισμού μακροεντολής:

    AM_CPPFLAGS = ... -DPROGRAMNAME_LOCALEDIR=\"${PROGRAMNAME_LOCALEDIR}\"

Αυτή η μακροεντολή θα χρησιμοποιηθεί όταν αρχικοποιείτε την `gettext` στον πηγαίο κώδικά σας.

### Σημειώνοντας συμβολοσειρές για μετάφραση

Οι κυριολεκτικές συμβολοσειρές πρέπει να πληκτρολογηθούν στον πηγαίο κώδικα στα αγγλικά, αλλά θα πρέπει να περιβάλλονται από μια κλήση στη συνάρτηση `gettext()`. Αυτές οι συμβολοσειρές θα εξαχθούν για μετάφραση και οι μεταφράσεις μπορούν να χρησιμοποιηθούν στον χρόνο εκτέλεσης αντί για τις αρχικές αγγλικές συμβολοσειρές.

Το πακέτο GNU gettext επιτρέπει να σημειώσετε συμβολοσειρές στον πηγαίο κώδικα, να εξάγετε αυτές τις συμβολοσειρές για μετάφραση και να χρησιμοποιήσετε τις μεταφρασμένες συμβολοσειρές στην εφαρμογή σας.

However, Glib defines `gettext()` support macros which are shorter wrappers in an easy-to-use form. To use these macros, include `<glibmm/i18n.h>`, and then, for example, substitute:

    display_message("Getting ready for i18n.");

with:

    display_message(_("Getting ready for i18n."));

For reference, it is possible to generate a file which contains all strings which appear in your code, even if they are not marked for translation, together with file name and line number references. To generate such a file named `my-strings`, execute the following command, within the source code directory:

    xgettext -a -o my-strings --omit-header *.cc *.h

Finally, to let your program use the translation for the current locale, add this code to the beginning of your `main.cc` file, to initialize gettext.

    bindtextdomain(GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR);
    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
    textdomain(GETTEXT_PACKAGE);

#### Πώς δουλεύει το gettext

Το σενάριο intltool / xgettext εξάγει τις συμβολοσειρές και τις βάζει σε ένα αρχείο `mypackage.pot`. Οι μεταφραστές της εφαρμογής σας δημιουργούν τις μεταφράσεις τους αντιγράφοντας πρώτα αυτό το αρχείο `.pot` σε ένα `localename.po`. Η τοπική ρύθμιση αναγνωρίζει μια γλώσσα και μια κωδικοποίηση για αυτήν τη γλώσσα, συμπεριλαμβανόμενων των μορφών ημερομηνίας και αριθμών. Αργότερα, το κείμενο στον πηγαίο κώδικα έχει αλλάξει, το σενάριο `msmerge` χρησιμοποιείται για ενημέρωση των αρχείων `localename.po` από το αναγεννημένο αρχείο `.pot`.

Την ώρα εγκατάστασης τα αρχεία `.po` μετατρέπονται σε δυαδική μορφή (με την επέκταση `.mo`) και τοποθετούνται σε ένα έναν κατάλογο όλου του συστήματος για αρχεία τοπικών ρυθμίσεων, για παράδειγμα `/usr/share/locale/`.

Όταν η εφαρμογή εκτελείται, η βιβλιοθήκη gettext ελέγχει τον κατάλογο όλου του συστήματος για να δει αν υπάρχει ένα αρχείο `.mo` για το περιβάλλον τοπικών ρυθμίσεων του χρήστη (μπορείτε να ορίσετε τις τοπικές ρυθμίσεις με, για παράδειγμα, "export LANG=de_DE.UTF-8" από μια κονσόλα bash). Αργότερα, όταν το πρόγραμμα φτάσει μια κλήση `gettext`, αναζητά μια μετάφραση της συγκεκριμένης συμβολοσειράς. Αν δεν βρεθεί καμιά, χρησιμοποιείται η αρχική συμβολοσειρά.

#### Δοκιμή και προσθήκη μεταφράσεων

To convince yourself that you've done well, you may wish to add a translation for a new locale. In order to do that, go to the `po` subdirectory of your project and execute the following command:

    intltool-update --pot

Αυτό θα δημιουργήσει ένα αρχείο με όνομα `programname.pot`. Τώρα, αντιγράψτε αυτό το αρχείο στο `languagecode.po`, όπως `de.po` ή `hu.po`. Προσθέστε επίσης αυτόν τον κώδικα γλώσσας στο `LINGUAS`. Το αρχείο `.po` περιέχει μια κεφαλίδα και έναν κατάλογο αγγλικών συμβολοσειρών, με χώρο για τις μεταφρασμένες συμβολοσειρές που θα εισαχθούν. Βεβαιωθείτε ότι ορίσατε την κωδικοποίηση του αρχείου `.po` (καθορισμένη στην κεφαλίδα, αλλά επίσης ως περιεχόμενο) στο `UTF-8`.

Είναι δυνατό συγκεκριμένες συμβολοσειρές να σημειωθούν ως `ασαφείς` στο αρχείο `.po` file. Αυτές οι μεταφράσεις δεν θα αντικαταστήσουν την αρχική συμβολοσειρά. Για να τις εμφανίσετε, αφαιρέστε απλά την ετικέτα `ασαφής`.

#### Πόροι

More information about what lies behind the internationalization and localization process is presented and demonstrated in:

- L10N Guidelines for Developers

- Intltool README

- How to use Git for GNOME translators

- gettext manual

- `gtkmm_hello` example package

- `gnomemm_hello` example package

### Αναμένεται UTF8

Μια σωστά διεθνοποιημένη εφαρμογή δεν θα κάνει υποθέσεις για τον αριθμό των ψηφιολέξεων σε έναν χαρακτήρα. Αυτό σημαίνει ότι δεν πρέπει να χρησιμοποιείτε αριθμητικό δείκτη για να περιδιαβείτε τους χαρακτήρες σε μια συμβολοσειρά και σημαίνει ότι δεν πρέπει να χρησιμοποιήσετε std::string ή τυπικές συναρτήσεις C όπως `strlen()`, επειδή κάνουν την ίδια υπόθεση.

Όμως, προφανώς αποφεύγετε ήδη γυμνούς πίνακες char* και αριθμητικούς δείκτες χρησιμοποιώντας την std::string, έτσι χρειάζεστε μόνο να ξεκινήσετε χρησιμοποιώντας στη θέση τους Glib::ustring. Δείτε το κεφάλαιο Βασικά για την Glib::ustring.

#### Glib::ustring and std::iostreams

Unfortunately, the integration with the standard iostreams is not completely foolproof. gtkmm converts Glib::ustrings to a locale-specific encoding (which usually is not UTF-8) if you output them to an ostream with `operator<<`. Likewise, retrieving Glib::ustrings from istream with `operator>>` causes a conversion in the opposite direction. But this scheme breaks down if you go through a std::string, e.g. by inputting text from a stream to a std::string and then implicitly converting it to a Glib::ustring. If the string contained non-ASCII characters and the current locale is not UTF-8 encoded, the result is a corrupted Glib::ustring. You can work around this with a manual conversion. For instance, to retrieve the std::string from a ostringstream:

    std::ostringstream output;
    output.imbue(std::locale("")); // use the user's locale for this stream
    output << percentage << " % done";
    label->set_text(Glib::locale_to_utf8(output.str()));

### Παγίδες

Υπάρχουν λίγα συνηθισμένα λάθη που πρέπει να βρείτε τελικά οι ίδιοι. Αλλά αυτή η ενότητα μπορεί να σας βοηθήσει να τα αποφύγετε.

#### Ίδιες συμβολοσειρές, διαφορετική σημασιολογία

Μερικές φορές δύο αγγλικές συμβολοσειρές είναι ταυτόσημες, αλλά έχουν διαφορετικά νοήματα σε διαφορετικά περιεχόμενα, έτσι μπορεί προφανώς να μην είναι ταυτόσημα όταν μεταφράζονται. Αφού οι αγγλικές συμβολοσειρές χρησιμοποιούνται ως κλειδιά αναζήτησης, αυτό προκαλεί προβλήματα.

Σε αυτές τις περιπτώσεις, θα πρέπει να προσθέσετε πρόσθετους χαρακτήρες στις συμβολοσειρές. Για παράδειγμα, χρησιμοποιήστε `"jumps[noun]"` και `"jumps[verb]"` αντί για απλώς `"jumps"` και αφαιρέστε τα πάλι έξω από την κλήση `gettext`. Αν προσθέτετε πρόσθετους χαρακτήρες θα πρέπει επίσης να προσθέσετε ένα σχόλιο για τους μεταφραστές πριν την κλήση της `gettext`. Τέτοια σχόλια θα εμφανιστούν στα αρχεία `.po`. Για παράδειγμα:

    // σημείωση στους μεταφραστές: μην μεταφράζετε το τμήμα "[noun]" είναι
    // εδώ απλά για να ξεχωρίσει τη συμβολοσειρά από μια άλλη συμβολοσειρά "jumps"
    text = strip(gettext("jumps[noun]"), "[noun]");

#### Σύνθεση των συμβολοσειρών

Οι προγραμματιστές της C χρησιμοποιούν την `sprintf()` για τη σύνθεση και συνένωση συμβολοσειρών. Η C++ ευνοεί τις ροές, αλλά δυστυχώς, αυτή η προσέγγιση κάνει δύσκολη τη μετάφραση, επειδή κάθε τμήμα κειμένου μεταφράζεται ξεχωριστά, χωρίς να επιτρέπει στους μεταφραστές να τις αναδιατάξουν σύμφωνα με τη γραμματική της γλώσσας.

Για παράδειγμα, αυτός ο κώδικας μπορεί να είναι προβληματικός:

    std::cout << _("Current amount: ") << amount
              << _(" Future: ") << future << std::endl;

    label.set_text(_("Really delete ") + filename + _(" now?"));

So you should either avoid this situation or use `Glib::ustring::compose()` which supports syntax such as:

    std::cout << Glib::ustring::compose(
                 _("Current amount: %1 Future: %2"), amount, future) << std::endl;

    label.set_text(Glib::ustring::compose(_("Really delete %1 now?"), filename));

#### Υποθέτοντας το εμφανιζόμενο μέγεθος των συμβολοσειρών

Δεν ξέρετε ποτέ πόσο χώρο θα πάρει μια συμβολοσειρά στην οθόνη όταν μεταφραστεί. Μπορεί πιθανόν να είναι διπλάσια από το μέγεθος της αρχικής αγγλικής συμβολοσειράς. Ευτυχώς, τα περισσότερα γραφικά συστατικά της gtkmm θα επεκταθούν στον χρόνο εκτέλεσης στο απαιτούμενο μέγεθος.

#### Σπάνιες λέξεις

Θα πρέπει να αποφεύγετε κρυπτογραφικές συντομεύσεις, αργκό, ή φρασεολογία. Είναι συνήθως δύσκολο να μεταφραστούν και είναι συχνά δύσκολες ακόμα και για μητρικούς ομιλητές να τις κατανοήσουν. Για παράδειγμα, προτιμήστε "application" από "app"

#### Χρήση χαρακτήρων μη ASCII στις συμβολοσειρές

Προς το παρόν, η gettext δεν υποστηρίζει χαρακτήρες μη ASCII (δηλαδή οποιονδήποτε χαρακτήρα με κωδικό πάνω από 127) στον πηγαίο κώδικα. Για παράδειγμα, δεν μπορείτε να χρησιμοποιήσετε το σύμβολο πνευματικών δικαιωμάτων (©).

Για την παράκαμψη του, μπορείτε να γράψετε ένα σχόλιο στον πηγαίο κώδικα ακριβώς πριν τη συμβολοσειρά, λέγοντας στους μεταφραστές να χρησιμοποιήσουν τον ειδικό χαρακτήρα, αν είναι διαθέσιμος στις γλώσσες τους. Για τα αγγλικά, μπορείτε τότε να κάνετε μια μετάφραση σε αγγλικά Αμερικής `en_US.po` που χρησιμοποιεί αυτόν τον ειδικό χαρακτήρα.

### Λήψη βοήθειας με τις μεταφράσεις

Αν το πρόγραμμά σας είναι ελεύθερου λογισμικού, υπάρχει ένα ολόκληρο υποέργο του `GNOME` αφιερωμένο για να σας βοηθήσει να κάνετε μεταφράσεις, το `GNOME`Έργο μετάφρασης.

Ο τρόπος που δουλεύει είναι ότι στέλνετε τον πηγαίο κώδικα σας σε ένα αποθετήριο git, όπου οι μεταφραστές μπορούν να το προσπελάσουν, έπειτα επικοινωνείτε με την ταχυδρομική λίστα του gnome-i18n και ζητάτε να προστεθεί το πρόγραμμά σας στο Κατάλογος ενοτήτων για μετάφραση.

Έπειτα επιβεβαιώνετε την ενημέρωση του αρχείου `POTFILES.in` στον υποκατάλογο `po/` (η `intltool-update -M` μπορεί να βοηθήσει) έτσι ώστε οι μεταφραστές να προσπελάζουν πάντα ενημερωμένα αρχεία `myprogram.pot` και να παγώνουν απλά τις συμβολοσειρές τουλάχιστον λίγες ημέρες πριν να κάνετε μια νέα έκδοση, ανακοινώντας την στο gnome-i18n. Ανάλογα με τον αριθμό των συμβολοσειρών που το πρόγραμμά σας περιέχει και το πόσο δημοφιλές είναι, οι μεταφράσεις θα αρχίσουν τότε να σημειώνονται σε αρχεία `languagename.po`.

Σημειώστε ότι οι περισσότερες ομάδες γλώσσας αποτελούνται μόνο από 1-3 άτομα, έτσι αν το πρόγραμμά σας περιέχει πολλές συμβολοσειρές, μπορεί να κρατήσει κάμποσο πριν οποιοσδήποτε έχει τον χρόνο να το κοιτάξει. Επίσης, οι περισσότεροι μεταφραστές δεν θέλουν να σπαταλούν τον χρόνο τους (η μετάφραση είναι μια πολύ χρονοβόρα εργασία), έτσι δεν αξιολογούν το έργο σας ως πραγματικά σοβαρό (με την έννοια ότι είναι βελτιωμένο και συντηρούμενο) μπορεί να αποφασίσουν να διαθέσουν τον χρόνο τους σε κάποιο άλλο έργο.

## Προσαρμοσμένα γραφικά συστατικά

Η gtkmm διευκολύνει την παραγωγή νέων γραφικών συστατικών κληρονομώντας από μια υπάρχουσα κλάση γραφικών συστατικών, είτε παράγοντας από έναν περιέκτη και προσθέτοντας θυγατρικά γραφικά συστατικά, ή παράγοντας από ένα γραφικό συστατικό μοναδικού στοιχείου και αλλάζοντας τη συμπεριφορά του. Αλλά μπορεί να βρείτε ενίοτε ότι δεν υπάρχει κατάλληλο αρχικό σημείο ήδη. Σε αυτήν την περίπτωση, μπορείτε να υλοποιήσετε ένα γραφικό συστατικό από την αρχή.

### Προσαρμοσμένοι περιέκτες

When deriving from Gtk::Container, you should override the following virtual methods:

- get_request_mode_vfunc(): Return what `Gtk::SizeRequestMode` is preferred by the container.

- get_preferred_width_vfunc(): Calculate the minimum and natural width of the container.

- get_preferred_height_vfunc(): Calculate the minimum and natural height of the container.

- get_preferred_width_for_height_vfunc(): Calculate the minimum and natural width of the container, if it would be given the specified height.

- get_preferred_height_for_width_vfunc(): Calculate the minimum and natural height of the container, if it would be given the specified width.

- on_size_allocate(): Position the child widgets, given the height and width that the container has actually been given.

- forall_vfunc(): Call the same callback for each of the children.

- on_add(): Add a child widget to the container.

- on_remove(): Remove a child widget from the container.

- child_type_vfunc(): Return what type of child can be added.

Οι εικονικές μέθοδοι get_request_mode_vfunc(), get_preferred_width_vfunc(), get_preferred_height_vfunc(), get_preferred_width_for_height_vfunc(), get_preferred_height_for_width_vfunc() και on_size_allocate() ελέγχουν τη διάταξη των θυγατρικών γραφικών συστατικών. Για παράδειγμα, αν ο περιέκτης σας έχει 2 θυγατρικά γραφικά συστατικά, με το ένα κάτω από το άλλο, η get_request_mode_vfunc() μπορεί να ζητήσει διάταξη ύψους προς πλάτος. Έπειτα η get_preferred_width_vfunc() σας μπορεί να αναφέρει το μέγιστο των πλατών των θυγατρικών γραφικών συστατικών και η get_preferred_height_for_width_vfunc() μπορεί να αναφέρει το άθροισμα των υψών τους. Αν θέλετε συμπλήρωση μεταξύ των θυγατρικών γραφικών συστατικών, τότε θα πρέπει να το προσθέσετε στο πλάτος και στο ύψος επίσης. Ο περιέκτης του γραφικού συστατικού θα χρησιμοποιήσει αυτό το αποτέλεσμα για να εξασφαλίσει ότι το γραφικό συστατικό σας έχει αρκετό χώρο και όχι μικρότερο. Εξετάζοντας κάθε γονικό του θυγατρικού συστατικού και το γονικό του, θα αποφασίσει τελικά η λογική για το μέγεθος του παραθύρου ανωτάτου επιπέδου.

Δεν υπάρχει εγγύηση ότι θα πάρετε το `Gtk::SizeRequestMode` που ζητήσατε. Συνεπώς και οι τέσσερις μέθοδοι της get_preferred_xxx_vfunc() πρέπει να επιστρέψουν λογικές τιμές.

Η on_size_allocate() δέχεται το ενεργό ύψος και πλάτος που ο γονικός περιέκτης έχει αποφασίσει να δώσσει στο γραφικό συστατικό του. Αυτό μπορεί να είναι περισσότερο από το ελάχιστο, ή ακόμα περισσότερο από το φυσικό μέγεθος, για παράδειγμα αν το παράθυρο ανωτάτου επιπέδου έχει επεκταθεί. Μπορεί να επιλέξετε να αγνοήσετε τον πρόσθετο χώρο και να αφήσετε μια κενή περιοχή, ή μπορείτε να επιλέξετε να επεκτείνετε τα θυγατρικά γραφικά συστατικά σας για να γεμίσετε τον χώρο, ή να επεκτείνετε τη συμπλήρωση μεταξύ των γραφικών συστατικών σας. Είναι ο περιέκτης σας, έτσι αποφασίζετε. Να μην ξεχάσετε να καλέσετε την set_allocation() μέσα στην υλοποίησή σας on_size_allocate() για να χρησιμοποιήσετε στην πραγματικότητα τον κατανεμημένο χώρο που έχει προσφερθεί από τον γονικό περιέκτη.

Εκτός και ο περιέκτης σας είναι ένα παράθυρο ανωτάτου επιπέδου που παράγεται από την Gtk::Window, θα πρέπει προφανώς να καλέσετε επίσης την Gtk::Widget::set_has_window(false) στον κατασκευαστή σας. Αυτό σημαίνει ότι ο περιέκτης σας δεν δημιουργεί την δικιά του Gdk::Window, αλλά χρησιμοποιεί το γονικό του παράθυρο. (Σημειώστε τη διαφορά μεταξύ Gtk::Window και Gdk::Window.) Αν ο περιέκτης σας δεν χρειάζεται τη δικιά του Gdk::Window και δεν παράγεται από την Gtk::Window, θα πρέπει επίσης να αντικαταστήσετε τη μέθοδο on_realize() όπως περιγράφηκε στην ενότητα προσαρμοσμένα γραφικά συστατικά. Και εκτός και ο περιέκτης σας σχεδιάζει άμεσα στο υποκείμενο Gdk::Window, θα πρέπει προφανώς να καλέσετε την set_redraw_on_allocate(false) για να βελτιώσετε την απόδοση.

Αντικαθιστώντας την forall_vfunc() μπορείτε να επιτρέψετε στις εφαρμογές να λειτουργούν σε όλα τα θυγατρικά γραφικά συστατικά του περιέκτη. Για παράδειγμα, η show_all_children() χρησιμοποιεί αυτό για να βρεί όλα τα θυγατρικά γραφικά συστατικά και να τα εμφανίσει.

Αν και ο περιέκτης σας μπορεί να έχει τη δική του μέθοδο ορισμού των θυγατρικών γραφικών συστατικών, θα πρέπει ακόμα να δώσετε μια υλοποίηση για τις εικονικές μεθόδους on_add() και on_remove() από τη βασική κλάση, έτσι ώστε οι μέθοδοι add() και remove() να κάνουν κάτι κατάλληλο αν κληθούν.

Η υλοποίηση της μεθόδου child_type_vfunc() πρέπει να αναφέρει τον τύπο του γραφικού συστατικού που μπορεί να προστεθεί στον περιέκτη σας, αν δεν είναι ακόμα πλήρης. Αυτή είναι συνήθως η Gtk::Widget::get_type() που δείχνει ότι ο περιέκτης μπορεί να περιέχει οποιαδήποτε κλάση παράγεται από την Gtk::Widget. Αν ο περιέκτης μπορεί να μην περιέχει οποιαδήποτε περισσότερα γραφικά συστατικά, τότε αυτή η μέθοδος πρέπει να επιστρέψει `G_TYPE_NONE`.

#### Παράδειγμα

Αυτό το παράδειγμα υλοποιεί έναν περιέκτη με δύο θυγατρικά γραφικά συστατικά, το ένα πάνω από το άλλο. Φυσικά, σε αυτήν την περίπτωση μπορεί να είναι πολύ πιο απλά να χρησιμοποιήσετε απλά μια κάθετη Gtk::Box.

Προσαρμοσμένος περιέκτης

Source Code

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "mycontainer.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      //Child widgets:
      Gtk::Box m_VBox;
      MyContainer m_MyContainer;
      Gtk::Button m_Button_One;
      Gtk::Label m_Label_Two;
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `mycontainer.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H
    #define GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H

    #include <gtkmm/container.h>

    class MyContainer : public Gtk::Container
    {
    public:
      MyContainer();
      virtual ~MyContainer();

      void set_child_widgets(Gtk::Widget& child_one, Gtk::Widget& child_two);

    protected:

      //Overrides:
      Gtk::SizeRequestMode get_request_mode_vfunc() const override;
      void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const override;
      void get_preferred_height_for_width_vfunc(int width, int& minimum_height, int& natural_height) const override;
      void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const override;
      void get_preferred_width_for_height_vfunc(int height, int& minimum_width, int& natural_width) const override;
      void on_size_allocate(Gtk::Allocation& allocation) override;

      void forall_vfunc(gboolean include_internals, GtkCallback callback, gpointer callback_data) override;

      void on_add(Gtk::Widget* child) override;
      void on_remove(Gtk::Widget* child) override;
      GType child_type_vfunc() const override;

      Gtk::Widget* m_child_one;
      Gtk::Widget* m_child_two;
    };

    #endif //GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_One("Child One"),
      m_Label_Two("Child 2", Gtk::ALIGN_END, Gtk::ALIGN_CENTER),
      m_Button_Quit("Quit")
    {
      set_title("Custom Container example");
      set_border_width(6);
      set_default_size(400, 200);

      add(m_VBox);

      //Add the child widgets to the custom container:
      m_MyContainer.set_child_widgets(m_Button_One, m_Label_Two);

      m_VBox.pack_start(m_MyContainer, Gtk::PACK_EXPAND_WIDGET);
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(6);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
                  &ExampleWindow::on_button_quit) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

File: `mycontainer.cc` (For use with gtkmm 3, not gtkmm 2)

    #include <iostream>
    #include <algorithm> // std::max
    #include "mycontainer.h"

    MyContainer::MyContainer()
    : m_child_one(nullptr), m_child_two(nullptr)
    {
      set_has_window(false);
      set_redraw_on_allocate(false);
    }

    MyContainer::~MyContainer()
    {
    /*
      // These calls to Gtk::Widget::unparent() are necessary if MyContainer is
      // deleted before its children. But if you use a version of gtkmm where bug
      // https://bugzilla.gnome.org/show_bug.cgi?id=605728
      // has not been fixed (gtkmm 3.7.10 or earlier) and the children are deleted
      // before the container, these calls can make the program crash.
      // That's because on_remove() is not called, when the children are deleted.
      if (m_child_one)
        m_child_one->unparent();

      if (m_child_two)
        m_child_two->unparent();
    */
    }

    void MyContainer::set_child_widgets(Gtk::Widget& child_one,
            Gtk::Widget& child_two)
    {
      m_child_one = &child_one;
      m_child_two = &child_two;

      m_child_one->set_parent(*this);
      m_child_two->set_parent(*this);
    }

    //This example container is a simplified VBox with at most two children.
    Gtk::SizeRequestMode MyContainer::get_request_mode_vfunc() const
    {
      return Gtk::SIZE_REQUEST_HEIGHT_FOR_WIDTH;
    }

    //Discover the total amount of minimum space and natural space needed by
    //this container and its children.
    void MyContainer::get_preferred_width_vfunc(int& minimum_width, int& natural_width) const
    {
      int child_minimum_width[2] = {0, 0};
      int child_natural_width[2] = {0, 0};

      if(m_child_one && m_child_one->get_visible())
        m_child_one->get_preferred_width(child_minimum_width[0], child_natural_width[0]);

      if(m_child_two && m_child_two->get_visible())
        m_child_two->get_preferred_width(child_minimum_width[1], child_natural_width[1]);

      //Request a width equal to the width of the widest visible child.
      minimum_width = std::max(child_minimum_width[0], child_minimum_width[1]);
      natural_width = std::max(child_natural_width[0], child_natural_width[1]);
    }

    void MyContainer::get_preferred_height_for_width_vfunc(int width,
       int& minimum_height, int& natural_height) const
    {
      int child_minimum_height[2] = {0, 0};
      int child_natural_height[2] = {0, 0};
      int nvis_children = 0;

      if(m_child_one && m_child_one->get_visible())
      {
        ++nvis_children;
        m_child_one->get_preferred_height_for_width(width, child_minimum_height[0],
                                                    child_natural_height[0]);
      }

      if(m_child_two && m_child_two->get_visible())
      {
        ++nvis_children;
        m_child_two->get_preferred_height_for_width(width, child_minimum_height[1],
                                                    child_natural_height[1]);
      }

      //The allocated height will be divided equally among the visible children.
      //Request a height equal to the number of visible children times the height
      //of the highest child.
      minimum_height = nvis_children * std::max(child_minimum_height[0],
                                                child_minimum_height[1]);
      natural_height = nvis_children * std::max(child_natural_height[0],
                                                child_natural_height[1]);
    }

    void MyContainer::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const
    {
      int child_minimum_height[2] = {0, 0};
      int child_natural_height[2] = {0, 0};
      int nvis_children = 0;

      if(m_child_one && m_child_one->get_visible())
      {
        ++nvis_children;
        m_child_one->get_preferred_height(child_minimum_height[0], child_natural_height[0]);
      }

      if(m_child_two && m_child_two->get_visible())
      {
        ++nvis_children;
        m_child_two->get_preferred_height(child_minimum_height[1], child_natural_height[1]);
      }

      //The allocated height will be divided equally among the visible children.
      //Request a height equal to the number of visible children times the height
      //of the highest child.
      minimum_height = nvis_children * std::max(child_minimum_height[0],
                                                child_minimum_height[1]);
      natural_height = nvis_children * std::max(child_natural_height[0],
                                                child_natural_height[1]);
    }

    void MyContainer::get_preferred_width_for_height_vfunc(int height,
       int& minimum_width, int& natural_width) const
    {
      int child_minimum_width[2] = {0, 0};
      int child_natural_width[2] = {0, 0};
      int nvis_children = 0;

      //Get number of visible children.
      if(m_child_one && m_child_one->get_visible())
        ++nvis_children;
      if(m_child_two && m_child_two->get_visible())
        ++nvis_children;

      if(nvis_children > 0)
      {
        //Divide the height equally among the visible children.
        const int height_per_child = height / nvis_children;

        if(m_child_one && m_child_one->get_visible())
          m_child_one->get_preferred_width_for_height(height_per_child,
                       child_minimum_width[0], child_natural_width[0]);

        if(m_child_two && m_child_two->get_visible())
          m_child_two->get_preferred_width_for_height(height_per_child,
                       child_minimum_width[1], child_natural_width[1]);
      }

      //Request a width equal to the width of the widest child.
      minimum_width = std::max(child_minimum_width[0], child_minimum_width[1]);
      natural_width = std::max(child_natural_width[0], child_natural_width[1]);
    }

    void MyContainer::on_size_allocate(Gtk::Allocation& allocation)
    {
      //Do something with the space that we have actually been given:
      //(We will not be given heights or widths less than we have requested, though
      //we might get more.)

      //Use the offered allocation for this container:
      set_allocation(allocation);

      //Get number of visible children.
      int nvis_children = 0;
      if(m_child_one && m_child_one->get_visible())
        ++nvis_children;
      if(m_child_two && m_child_two->get_visible())
        ++nvis_children;

      if(nvis_children <= 0)
        return;

      //Assign space to the children:
      Gtk::Allocation child_allocation_one;
      Gtk::Allocation child_allocation_two;

      //Place the first child at the top-left:
      child_allocation_one.set_x( allocation.get_x() );
      child_allocation_one.set_y( allocation.get_y() );

      //Make it take up the full width available:
      child_allocation_one.set_width( allocation.get_width() );

      if(m_child_one && m_child_one->get_visible())
      {
        //Divide the height equally among the visible children.
        child_allocation_one.set_height( allocation.get_height() / nvis_children);
        m_child_one->size_allocate(child_allocation_one);
      }
      else
        child_allocation_one.set_height(0);

      //Place the second child below the first child:
      child_allocation_two.set_x( allocation.get_x() );
      child_allocation_two.set_y( allocation.get_y() +
              child_allocation_one.get_height());

      //Make it take up the full width available:
      child_allocation_two.set_width( allocation.get_width() );

      //Make it take up the remaining height:
      child_allocation_two.set_height( allocation.get_height() -
              child_allocation_one.get_height());

      if(m_child_two && m_child_two->get_visible())
        m_child_two->size_allocate(child_allocation_two);
    }

    void MyContainer::forall_vfunc(gboolean, GtkCallback callback, gpointer callback_data)
    {
      if(m_child_one)
        callback(m_child_one->gobj(), callback_data);

      if(m_child_two)
        callback(m_child_two->gobj(), callback_data);
    }

    void MyContainer::on_add(Gtk::Widget* child)
    {
      if(!m_child_one)
      {
        m_child_one = child;
        m_child_one->set_parent(*this);
      }
      else if(!m_child_two)
      {
        m_child_two = child;
        m_child_two->set_parent(*this);
      }
    }

    void MyContainer::on_remove(Gtk::Widget* child)
    {
      if(child)
      {
        const bool visible = child->get_visible();
        bool found = false;

        if(child == m_child_one)
        {
          m_child_one = nullptr;
          found = true;
        }
        else if(child == m_child_two)
        {
          m_child_two = nullptr;
          found = true;
        }

        if(found)
        {
          child->unparent();

          if(visible)
            queue_resize();
        }
      }
    }

    GType MyContainer::child_type_vfunc() const
    {
      //If there is still space for one widget, then report the type of widget that
      //may be added.
      if(!m_child_one || !m_child_two)
        return Gtk::Widget::get_type();
      else
      {
        //No more widgets may be added.
        return G_TYPE_NONE;
      }
    }

### Προσαρμοσμένα γραφικά συστατικά

Παράγοντας άμεσα από την Gtk::Widget μπορείτε να κάνετε όλη τη σχεδίαση για το γραφικό συστατικό σας άμεσα, αντί μιας απλής διευθέτησης των θυγατρικών γραφικών συστατικών. Για παράδειγμα, μια Gtk::Label σχεδιάζει το κείμενο της ετικέτας, αλλά δεν το κάνει χρησιμοποιώντας άλλα γραφικά συστατικά.

When deriving from Gtk::Widget, you should override the following virtual methods. The methods marked (optional) need not be overridden in all custom widgets. The base class's methods may be appropriate.

- get_request_mode_vfunc(): (optional) Return what `Gtk::SizeRequestMode` is preferred by the widget.

- get_preferred_width_vfunc(): Calculate the minimum and natural width of the widget.

- get_preferred_height_vfunc(): Calculate the minimum and natural height of the widget.

- get_preferred_width_for_height_vfunc(): Calculate the minimum and natural width of the widget, if it would be given the specified height.

- get_preferred_height_for_width_vfunc(): Calculate the minimum and natural height of the widget, if it would be given the specified width.

- on_size_allocate(): Position the widget, given the height and width that it has actually been given.

- on_realize(): Associate a Gdk::Window with the widget.

- on_unrealize(): (optional) Break the association with the Gdk::Window.

- on_map(): (optional)

- on_unmap(): (optional)

- on_draw(): Draw on the supplied Cairo::Context.

Οι πρώτες 6 μέθοδοι στον προηγούμενο πίνακα αντικαταστάθηκαν επίσης στους προσαρμοσμένους περιέκτες. Περιγράφονται συνοπτικά στην ενότητα Προσαρμοσμένοι περιέκτες.

Τα περισσότερα προσαρμοσμένα γραφικά συστατικά χρειάζονται τη δικιά τους Gdk::Window για να σχεδιαστούν. Έπειτα μπορείτε να καλείτε την Gtk::Widget::set_has_window(true) στον κατασκευαστή σας. (Αυτή είναι η προεπιλεγμένη τιμή.) Αν δεν καλέσετε την set_has_window(false), πρέπει να αντικαταστήσετε την on_realize() και να καλέσετε τις Gtk::Widget::set_realized() και Gtk::Widget::set_window() από εκεί.

#### Custom Style Properties

You can add style properties to your widget class, whether it's derived directly from Gtk::Widget or from another widget class. The values of the style properties can be read from a CSS (Cascading Style Sheets) file. The users of your widget, or the users of an application program with your widget, can then modify the style of your widget without modifying the source code. Useful classes are Gtk::StyleProperty and Gtk::CssProvider. With Gtk::Widget::get_style_property() you can read the values of both your own style properties and those of your widget's base class. Note that style properties are not wrapped in gtkmm. See GTK+'s documentation for lists of existing style properties. The following example shows a simple use of a custom style property.

#### Παράδειγμα

Αυτό το παράδειγμα υλοποιεί ένα γραφικό συστατικό που σχεδιάζει ένα τρίγωνο Penrose.

Προσαρμοσμένο γραφικό συστατικό

Source Code

File: `mywidget.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_CUSTOM_WIDGET_MYWIDGET_H
    #define GTKMM_CUSTOM_WIDGET_MYWIDGET_H

    #include <gtkmm/widget.h>
    #include <gtkmm/cssprovider.h>
    #include <gtkmm/styleproperty.h>

    class MyWidget : public Gtk::Widget
    {
    public:
      MyWidget();
      virtual ~MyWidget();

    protected:

      //Overrides:
      Gtk::SizeRequestMode get_request_mode_vfunc() const override;
      void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const override;
      void get_preferred_height_for_width_vfunc(int width, int& minimum_height, int& natural_height) const  override;
      void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const override;
      void get_preferred_width_for_height_vfunc(int height, int& minimum_width, int& natural_width) const override;
      void on_size_allocate(Gtk::Allocation& allocation) override;
      void on_map() override;
      void on_unmap() override;
      void on_realize() override;
      void on_unrealize() override;
      bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr) override;

      //Signal handler:
      void on_parsing_error(const Glib::RefPtr<const Gtk::CssSection>& section, const Glib::Error& error);

      Gtk::StyleProperty<int> m_scale_prop;
      Glib::RefPtr<Gdk::Window> m_refGdkWindow;
      Glib::RefPtr<Gtk::CssProvider> m_refCssProvider;

      int m_scale;
    };

    #endif //GTKMM_CUSTOM_WIDGET_MYWIDGET_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "mywidget.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();
      virtual ~ExampleWindow();

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

      //Child widgets:
      Gtk::Box m_VBox;
      MyWidget m_MyWidget;
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_Button_Quit;
    };

    #endif //GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"

    ExampleWindow::ExampleWindow()
    : m_VBox(Gtk::ORIENTATION_VERTICAL),
      m_Button_Quit("Quit")
    {
      set_title("Custom Widget example");
      set_border_width(6);
      set_default_size(400, 200);

      add(m_VBox);
      m_VBox.pack_start(m_MyWidget, Gtk::PACK_EXPAND_WIDGET);
      m_MyWidget.show();

      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(6);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
      m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this, &ExampleWindow::on_button_quit) );

      show_all_children();
    }

    ExampleWindow::~ExampleWindow()
    {
    }

    void ExampleWindow::on_button_quit()
    {
      hide();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main(int argc, char *argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

File: `mywidget.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "mywidget.h"
    #include <gdkmm/general.h>  // for cairo helper functions
    #include <iostream>
    //#include <gtk/gtkwidget.h> //For GTK_IS_WIDGET()
    #include <cstring>

    // The MyWidget class uses API which was added in gtkmm 3.15.3 (Gtk::CssProviderError,
    // Gtk::CssProvider::signal_parsing_error() and Gtk::CssSection) and in gtkmm 3.15.2
    // (Gtk::StyleProperty).

    MyWidget::MyWidget() :
      //The GType name will actually be gtkmm__CustomObject_mywidget
      Glib::ObjectBase("mywidget"),
      Gtk::Widget(),
      //Install a style property so that an aspect of this widget may be themed
      //via a CSS style sheet file:
      m_scale_prop(*this, "example_scale", 500),
      m_scale(1000)
    {
      set_has_window(true);

      //This shows the GType name, which must be used in the CSS file.
      std::cout << "GType name: " << G_OBJECT_TYPE_NAME(gobj()) << std::endl;

      //This shows that the GType still derives from GtkWidget:
      //std::cout << "Gtype is a GtkWidget?:" << GTK_IS_WIDGET(gobj()) << std::endl;

      // Set the widget name to use in the CSS file.
      set_name("my-widget");

      // If you make a custom widget in C code, based on gtk+'s GtkWidget, there is
      // an alternative to gtk_widget_set_name(): Set a CSS name for your custom
      // class (instead of the widget instance) with gtk_widget_class_set_css_name()
      // (new in gtk+ 3.19.1). That's not possible for custom widgets defined in gtkmm.
      // gtk_widget_class_set_css_name() must be called in the class init function,
      // which can't be customized, when the widget is based on gtkmm's Gtk::Widget.
      //
      // Another alternative: The custom widget inherits the CSS name "widget" from
      // GtkWidget. That name can be used in the CSS file. This is not a very good
      // alternative. GtkWidget's CSS name is not documented. It can probably be
      // changed or removed in the future.

      m_refCssProvider = Gtk::CssProvider::create();
      auto refStyleContext = get_style_context();
      refStyleContext->add_provider(m_refCssProvider,
        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
      m_refCssProvider->signal_parsing_error().connect(
        sigc::mem_fun(*this, &MyWidget::on_parsing_error));

      try
      {
        m_refCssProvider->load_from_path("custom_gtk.css");
      }
      catch(const Gtk::CssProviderError& ex)
      {
        std::cerr << "CssProviderError, Gtk::CssProvider::load_from_path() failed: "
                  << ex.what() << std::endl;
      }
      catch(const Glib::Error& ex)
      {
        std::cerr << "Error, Gtk::CssProvider::load_from_path() failed: "
                  << ex.what() << std::endl;
      }
    }

    MyWidget::~MyWidget()
    {
    }

    Gtk::SizeRequestMode MyWidget::get_request_mode_vfunc() const
    {
      //Accept the default value supplied by the base class.
      return Gtk::Widget::get_request_mode_vfunc();
    }

    //Discover the total amount of minimum space and natural space needed by
    //this widget.
    //Let's make this simple example widget always need minimum 60 by 50 and
    //natural 100 by 70.
    void MyWidget::get_preferred_width_vfunc(int& minimum_width, int& natural_width) const
    {
      minimum_width = 60;
      natural_width = 100;
    }

    void MyWidget::get_preferred_height_for_width_vfunc(int /* width */,
       int& minimum_height, int& natural_height) const
    {
      minimum_height = 50;
      natural_height = 70;
    }

    void MyWidget::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const
    {
      minimum_height = 50;
      natural_height = 70;
    }

    void MyWidget::get_preferred_width_for_height_vfunc(int /* height */,
       int& minimum_width, int& natural_width) const
    {
      minimum_width = 60;
      natural_width = 100;
    }

    void MyWidget::on_size_allocate(Gtk::Allocation& allocation)
    {
      //Do something with the space that we have actually been given:
      //(We will not be given heights or widths less than we have requested, though
      //we might get more)

      //Use the offered allocation for this container:
      set_allocation(allocation);

      if(m_refGdkWindow)
      {
        m_refGdkWindow->move_resize( allocation.get_x(), allocation.get_y(),
                allocation.get_width(), allocation.get_height() );
      }
    }

    void MyWidget::on_map()
    {
      //Call base class:
      Gtk::Widget::on_map();
    }

    void MyWidget::on_unmap()
    {
      //Call base class:
      Gtk::Widget::on_unmap();
    }

    void MyWidget::on_realize()
    {
      //Do not call base class Gtk::Widget::on_realize().
      //It's intended only for widgets that set_has_window(false).

      set_realized();

      //Get the themed style from the CSS file:
      m_scale = m_scale_prop.get_value();
      std::cout << "m_scale (example_scale from the theme/css-file) is: "
          << m_scale << std::endl;

      if(!m_refGdkWindow)
      {
        //Create the GdkWindow:

        GdkWindowAttr attributes;
        memset(&attributes, 0, sizeof(attributes));

        Gtk::Allocation allocation = get_allocation();

        //Set initial position and size of the Gdk::Window:
        attributes.x = allocation.get_x();
        attributes.y = allocation.get_y();
        attributes.width = allocation.get_width();
        attributes.height = allocation.get_height();

        attributes.event_mask = get_events () | Gdk::EXPOSURE_MASK;
        attributes.window_type = GDK_WINDOW_CHILD;
        attributes.wclass = GDK_INPUT_OUTPUT;

        m_refGdkWindow = Gdk::Window::create(get_parent_window(), &attributes,
                GDK_WA_X | GDK_WA_Y);
        set_window(m_refGdkWindow);

        //make the widget receive expose events
        m_refGdkWindow->set_user_data(gobj());
      }
    }

    void MyWidget::on_unrealize()
    {
      m_refGdkWindow.reset();

      //Call base class:
      Gtk::Widget::on_unrealize();
    }

    bool MyWidget::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
    {
      const Gtk::Allocation allocation = get_allocation();
      const double scale_x = (double)allocation.get_width() / m_scale;
      const double scale_y = (double)allocation.get_height() / m_scale;
      auto refStyleContext = get_style_context();

      // paint the background
      refStyleContext->render_background(cr,
        allocation.get_x(), allocation.get_y(),
        allocation.get_width(), allocation.get_height());

      // draw the foreground
      const auto state = refStyleContext->get_state();
      Gdk::Cairo::set_source_rgba(cr, refStyleContext->get_color(state));
      cr->move_to(155.*scale_x, 165.*scale_y);
      cr->line_to(155.*scale_x, 838.*scale_y);
      cr->line_to(265.*scale_x, 900.*scale_y);
      cr->line_to(849.*scale_x, 564.*scale_y);
      cr->line_to(849.*scale_x, 438.*scale_y);
      cr->line_to(265.*scale_x, 100.*scale_y);
      cr->line_to(155.*scale_x, 165.*scale_y);
      cr->move_to(265.*scale_x, 100.*scale_y);
      cr->line_to(265.*scale_x, 652.*scale_y);
      cr->line_to(526.*scale_x, 502.*scale_y);
      cr->move_to(369.*scale_x, 411.*scale_y);
      cr->line_to(633.*scale_x, 564.*scale_y);
      cr->move_to(369.*scale_x, 286.*scale_y);
      cr->line_to(369.*scale_x, 592.*scale_y);
      cr->move_to(369.*scale_x, 286.*scale_y);
      cr->line_to(849.*scale_x, 564.*scale_y);
      cr->move_to(633.*scale_x, 564.*scale_y);
      cr->line_to(155.*scale_x, 838.*scale_y);
      cr->stroke();

      return true;
    }

    void MyWidget::on_parsing_error(const Glib::RefPtr<const Gtk::CssSection>& section, const Glib::Error& error)
    {
      std::cerr << "on_parsing_error(): " << error.what() << std::endl;
      if (section)
      {
        std::cerr << "  URI = " << section->get_file()->get_uri() << std::endl;
        std::cerr << "  start_line = " << section->get_start_line()+1
                  << ", end_line = " << section->get_end_line()+1 << std::endl;
        std::cerr << "  start_position = " << section->get_start_position()
                  << ", end_position = " << section->get_end_position() << std::endl;
      }
    }

File: `custom_gtk.css` (For use with gtkmm 3, not gtkmm 2)

    /* Example of a CSS style sheet with a custom style property.
     *
     * The name of the style property must have its canonical form, i.e. characters
     * other than ASCII letters, digits, and hyphens must be replaced by hyphens.
    */

    * {
      /* -<widget class name>-<style property canonical name>: <value>; */
      -gtkmm__CustomObject_mywidget-example-scale: 920;
    }

    #my-widget {
      background-color: rgb(255,0,0);
      color:            rgb(0,0,255);
    }

## Πολυνηματικά προγράμματα

### Οι περιορισμοί

Care is required when writing programs based on gtkmm using multiple threads of execution, arising from the fact that libsigc++, and in particular sigc::trackable, are not thread-safe. That's because none of the complex interactions that occur behind the scenes when using libsigc++ are protected by a mutex or other means of synchronization.

These interactions arise from the fact that, amongst other things, a class inheriting from sigc::trackable will, via that inheritance, have a std::list object keeping track of slots created by calls to `sigc::mem_fun()` representing any of its non-static methods (more particularly it keeps a list of callbacks which will null the connected slots on its destruction). Each sigc::slot object also keeps, via sigc::slot_rep, its own sigc::trackable object to track any sigc::connection objects which it needs to inform about its demise, and also has a function to deregister itself from any sigc::trackable on disconnection or destruction. sigc::signal objects also keep lists of slots, which will be updated by a call to their connect() method or calls to any sigc::connection object relating to such a connection.

#### Οι κανόνες

Αυτό απαιτεί έναν αριθμό από κανόνες να παρατηρούνται κατά την εγγραφή πολυνηματικών προγραμμάτων χρησιμοποιώντας την gtkmm. Αυτοί εκτίθενται παρακάτω, αλλά σημειώστε ένα σημείο ότι απαιτείται ιδιαίτερη φροντίδα όταν παράγεται κλάσεις από την sigc::trackable, επειδή τα αποτελέσματα δεν είναι διαισθητικά (δείτε ιδιαίτερα τα παρακάτω σημεία 4 και 5).

1. Χρησιμοποιήστε την Glib::Dispatcher για να καλέσετε συναρτήσεις gtkmm από νήματα εργασίας (αυτό αναφέρεται με περισσότερη λεπτομέρεια στην επόμενη ενότητα).

2. Ένα αντικείμενο sigc::signal πρέπει να θεωρείται ως κατεχόμενο από το νήμα που το δημιούργησε. Μόνο αυτό το νήμα συνδέει ένα αντικείμενο sigc::slot με το αντικείμενο σήματος και μόνο αυτό το νήμα πρέπει να emit() ή να καλεί την operator()() με το σήμα, ή να αδειάζει οποιοδήποτε συνδεμένο αντικείμενο sigc::slot. Ακολουθεί (μεταξύ άλλων) ότι οποιοδήποτε αντικείμενο σήματος που παρέχεται από το γραφικό συστατικό gtkmm πρέπει να λειτουργεί μόνο στο κύριο νήμα γραφικής διεπαφής χρήστη και οποιοδήποτε αντικείμενο παράγεται από την sigc::trackable να έχει τις μη στατικές μεθόδους του που αναφέρονται από τις συνδεμένες υποδοχές στο αντικείμενο σήματος που πρέπει να καταστραφεται μόνο σε αυτό το νήμα.

3. Οποιοδήποτε αντικείμενο sigc::connection πρέπει να θεωρείται ως κατεχόμενο από το νήμα στο οποίο η μέθοδος επιστρέφει το αντικείμενο sigc::connection που κλήθηκε. Μόνο αυτό το νήμα πρέπει να καλεί τις μεθόδους sigc::connection στο αντικείμενο.

4. A sigc::slot object created by a call to `sigc::mem_fun()` which references a method of a class deriving from sigc::trackable should never be copied to another thread, nor destroyed by a different thread than the one which created it.

5. Αν ένα ειδικό αντικείμενο κλάσης προέρχεται από την sigc::trackable, μόνο ένα νήμα πρέπει να δημιουργήσει αντικείμενα sigc::slot που αναπαριστούν οποιεσδήποτε μη στατικές μεθόδους της κλάσης καλώντας την `sigc::mem_fun()`. Το πρώτο νήμα για να δημιουργήσει μια τέτοια υποδοχή πρέπει να θεωρηθεί ως κάτοχος του σχετικού αντικειμένου για τον σκοπό της δημιουργίας παραπέρα υποδοχών αναφορικά με οποιαδήποτε από τις μη στατικές μεθόδους που χρησιμοποιούν αυτή τη συνάρτηση, ή αδειάζοντας αυτές τις υποδοχές αποσυνδέοντας τες ή καταστρέφοντας το ανιχνεύσιμο αντικείμενο.

6. Αν και η glib είναι η ίδια με ασφάλεια νήματος, οποιοιδήποτε συσκευαστές glibmm που χρησιμοποιούν libsigc++ δεν είναι. Έτσι για παράδειγμα, μόνο το νήμα στο οποίο ο κύριος βρόχος εκτελείται πρέπει να καλεί τις Glib::SignalIdle::connect(), Glib::SignalIO::connect(), Glib::SignalTimeout::connect(), Glib::SignalTimeout::connect_seconds για τον κύριο βρόχο, ή να χειρίζεται οποιοδήποτε αντικείμενο sigc::connection που επιστρέφεται από αυτές.

   The connect*_once() variants, Glib::SignalIdle::connect_once(), Glib::SignalTimeout::connect_once(), Glib::SignalTimeout::connect_seconds_once(), are thread-safe for any case where the slot is not created by a call to `sigc::mem_fun()` which represents a method of a class deriving from sigc::trackable.

### Χρήση Glib::Dispatcher

Οι συνδεμένες υποδοχές με αντικείμενα sigc::signal εκτελούν στο νήμα όποιες κλήσεις emit() ή operator()() στο σήμα. Η Glib::Dispatcher δεν συμπεριφέρεται ίδια: εκτελεί τις συνδεμένες υποδοχές της στο νήμα στο οποίο το αντικείμενο Glib::Dispatcher δομήθηκε (που πρέπει να έχει έναν κύριο βρόχο glib). Αν ένα αντικείμενο Glib::Dispatcher δομείται στο κύριο νήμα γραφικής διεπαφής χρήστη (που θα είναι συνεπώς το νήμα του δέκτη), οποιοδήποτε νήμα εργασίας μπορεί να το εκπέμψει και να έχει εκτελέσει με ασφάλεια τις συνδεμένες υποδοχές των συναρτήσεων gtkmm.

Μερικοί κανόνες ασφάλειας νημάτων με τη χρήση της Glib::Dispatcher εφαρμόζονται ακόμα. Όπως αναφέρθηκε, ένα αντικείμενο Glib::Dispatcher πρέπει να δομηθεί στο νήμα δέκτη (το νήμα του οποίου ο κύριος βρόχος θα εκτελέσει τις συνδεμένες υποδοχές του). Από προεπιλογή, αυτό είναι το κύριο νήμα του προγράμματος, αν και υπάρχει ένας κατασκευαστής Glib::Dispatcher που μπορεί να πάρει το αντικείμενο Glib::MainContext οποιουδήποτε νήματος που έχει έναν κύριο βρόχο. Μόνο το νήμα του δέκτη πρέπει να καλέσει την connect() στο αντικείμενο Glib::Dispatcher, ή να χειριστεί οποιοδήποτε σχετικό αντικείμενο sigc::connection, εκτός και πρόσθετος συγχρονισμός χρησιμοποιείται. Όμως, οποιοδήποτε νήμα εργασίας μπορεί να εκπέμψει με ασφάλεια στο αντικείμενο Glib::Dispatcher χωρίς οποιοδήποτε κλείδωμα μόλις το νήμα του δέκτη έχει συνδέσει τις υποδοχές, με την προϋπόθεση ότι είναι δομημένο πριν το νήμα εργασίας να ξεκινήσει (αν είναι δομημένο μετά την έναρξη του νήματος, απαιτείται κανονικά πρόσθετος συγχρονισμός για να εξασφαλιστεί η ορατότητα).

Πέρα από το γεγονός ότι συνδεμένες υποδοχές εκτελούνται πάντα στο νήμα δέκτη, τα αντικείμενα Glib::Dispatcher είναι παρόμοια με τα αντικείμενα sigc::signal<void>, Συνεπώς, δεν μπορούν να περάσουν αδέσμευτα ορίσματα ούτε να επιστρέψουν μια τιμή. Ο καλύτερος τρόπος να περάσουν αδέσμευτα ορίσματα είναι με ασφάλεια νήματος (ασύγχρονη) ουρά. Την ώρα της εγγραφής η glibmm δεν έχει κανένα, αν και οι περισσότεροι άνθρωποι που γράφουν πολυνηματικό κώδικα θα έχουν ένα διαθέσιμο για αυτούς (είναι σχετικά εύκολοι στην συγγραφή, αν και υπάρχουν λεπτές διακρίσεις στον συνδυασμό ασφάλειας νήματος με ισχυρή ασφάλεια εξαίρεσης).

Ένα αντικείμενο Glib::Dispatcher μπορεί να εκπεμφθεί από το νήμα δέκτη καθώς και από το νήμα εργασίας, αν και αυτό πρέπει να γίνει μέσα σε λογικά όρια. Σε συστήματα unix και παρεμφερή τα αντικείμενα Glib::Dispatcher μοιράζονται μια μοναδική κοινή διοχέτευση, που μπορεί, τουλάχιστον θεωρητικά, να γεμίσει ένα πολύ έντονα φορτωμένο σύστημα που εκτελεί ένα πρόγραμμα με έναν πολύ μεγάλο αριθμό αντικειμένων Dispatcher σε χρήση. Αν η διοχέτευση γεμίσει πριν ο κύριος βρόχος του νήματος δέκτη είχε μια ευκαιρία να τον διαβάσει για να τον αδειάσει και το νήμα δέκτη προσπάθησε να εκπέμψει και έτσι να γράψει σε αυτό όταν είναι σε αυτήν την κατάσταση, το νήμα δέκτη μπορεί να φράξει την εγγραφή, έτσι αδιέξοδο. Όπου το νήμα δέκτη πρόκειται να εκπέμψει, ένα κανονικό αντικείμενο sigc::signal<void> μπορεί φυσικά να χρησιμοποιηθεί στη θέση του.

### Παράδειγμα

Αυτό είναι ένα παράδειγμα προγράμματος με δύο νήματα, ένα νήμα GUI, όπως σε όλα τα προγράμματα της gtkmm και ένα με νήμα εργασίας. Το νήμα εργασίας δημιουργείται όταν πατάτε το πλήκτρο `Start work`. Διαγράφεται όταν η εργασία τελειώσει, όταν πατάτε το πλήκτρο `Stop work`, ή όταν πατάτε το πλήκτρο `Quit`.

A Glib::Dispatcher is used for sending notifications from the worker thread to the GUI thread. The ExampleWorker class contains data which is accessed by both threads. This data is protected by a std::mutex. Only the GUI thread updates the GUI.

Πολυνηματικά προγράμματα

Source Code

File: `exampleworker.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWORKER_H
    #define GTKMM_EXAMPLEWORKER_H

    #include <gtkmm.h>
    #include <thread>
    #include <mutex>

    class ExampleWindow;

    class ExampleWorker
    {
    public:
      ExampleWorker();

      // Thread function.
      void do_work(ExampleWindow* caller);

      void get_data(double* fraction_done, Glib::ustring* message) const;
      void stop_work();
      bool has_stopped() const;

    private:
      // Synchronizes access to member data.
      mutable std::mutex m_Mutex;

      // Data used by both GUI thread and worker thread.
      bool m_shall_stop;
      bool m_has_stopped;
      double m_fraction_done;
      Glib::ustring m_message;
    };

    #endif // GTKMM_EXAMPLEWORKER_H

File: `examplewindow.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLEWINDOW_H
    #define GTKMM_EXAMPLEWINDOW_H

    #include <gtkmm.h>
    #include "exampleworker.h"

    class ExampleWindow : public Gtk::Window
    {
    public:
      ExampleWindow();

      // Called from the worker thread.
      void notify();

    private:
      // Signal handlers.
      void on_start_button_clicked();
      void on_stop_button_clicked();
      void on_quit_button_clicked();

      void update_start_stop_buttons();
      void update_widgets();

      // Dispatcher handler.
      void on_notification_from_worker_thread();

      // Member data.
      Gtk::Box m_VBox;
      Gtk::ButtonBox m_ButtonBox;
      Gtk::Button m_ButtonStart;
      Gtk::Button m_ButtonStop;
      Gtk::Button m_ButtonQuit;
      Gtk::ProgressBar m_ProgressBar;
      Gtk::ScrolledWindow m_ScrolledWindow;
      Gtk::TextView m_TextView;

      Glib::Dispatcher m_Dispatcher;
      ExampleWorker m_Worker;
      std::thread* m_WorkerThread;
    };

    #endif // GTKMM_EXAMPLEWINDOW_H

File: `examplewindow.cc` (For use with gtkmm 3, not gtkmm 2)

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

    ExampleWindow::ExampleWindow() :
      m_VBox(Gtk::ORIENTATION_VERTICAL, 5),
      m_ButtonBox(Gtk::ORIENTATION_HORIZONTAL),
      m_ButtonStart("Start work"),
      m_ButtonStop("Stop work"),
      m_ButtonQuit("_Quit", /* mnemonic= */ true),
      m_ProgressBar(),
      m_ScrolledWindow(),
      m_TextView(),
      m_Dispatcher(),
      m_Worker(),
      m_WorkerThread(nullptr)
    {
      set_title("Multi-threaded example");
      set_border_width(5);
      set_default_size(300, 300);

      add(m_VBox);

      // Add the ProgressBar.
      m_VBox.pack_start(m_ProgressBar, Gtk::PACK_SHRINK);

      m_ProgressBar.set_text("Fraction done");
      m_ProgressBar.set_show_text();

      // Add the TextView, inside a ScrolledWindow.
      m_ScrolledWindow.add(m_TextView);

      // Only show the scrollbars when they are necessary.
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

      m_VBox.pack_start(m_ScrolledWindow);

      m_TextView.set_editable(false);

      // Add the buttons to the ButtonBox.
      m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

      m_ButtonBox.pack_start(m_ButtonStart, Gtk::PACK_SHRINK);
      m_ButtonBox.pack_start(m_ButtonStop, Gtk::PACK_SHRINK);
      m_ButtonBox.pack_start(m_ButtonQuit, Gtk::PACK_SHRINK);
      m_ButtonBox.set_border_width(5);
      m_ButtonBox.set_spacing(5);
      m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);

      // Connect the signal handlers to the buttons.
      m_ButtonStart.signal_clicked().connect(sigc::mem_fun(*this, &ExampleWindow::on_start_button_clicked));
      m_ButtonStop.signal_clicked().connect(sigc::mem_fun(*this, &ExampleWindow::on_stop_button_clicked));
      m_ButtonQuit.signal_clicked().connect(sigc::mem_fun(*this, &ExampleWindow::on_quit_button_clicked));

      // Connect the handler to the dispatcher.
      m_Dispatcher.connect(sigc::mem_fun(*this, &ExampleWindow::on_notification_from_worker_thread));

      // Create a text buffer mark for use in update_widgets().
      auto buffer = m_TextView.get_buffer();
      buffer->create_mark("last_line", buffer->end(), /* left_gravity= */ true);

      update_start_stop_buttons();

      show_all_children();
    }

    void ExampleWindow::on_start_button_clicked()
    {
      if (m_WorkerThread)
      {
        std::cout << "Can't start a worker thread while another one is running." << std::endl;
      }
      else
      {
        // Start a new worker thread.
        m_WorkerThread = new std::thread(
          [this]
          {
            m_Worker.do_work(this);
          });
      }
      update_start_stop_buttons();
    }

    void ExampleWindow::on_stop_button_clicked()
    {
      if (!m_WorkerThread)
      {
        std::cout << "Can't stop a worker thread. None is running." << std::endl;
      }
      else
      {
       // Order the worker thread to stop.
        m_Worker.stop_work();
        m_ButtonStop.set_sensitive(false);
      }
    }

    void ExampleWindow::update_start_stop_buttons()
    {
      const bool thread_is_running = m_WorkerThread != nullptr;

      m_ButtonStart.set_sensitive(!thread_is_running);
      m_ButtonStop.set_sensitive(thread_is_running);
    }

    void ExampleWindow::update_widgets()
    {
      double fraction_done;
      Glib::ustring message_from_worker_thread;
      m_Worker.get_data(&fraction_done, &message_from_worker_thread);

      m_ProgressBar.set_fraction(fraction_done);

      if (message_from_worker_thread != m_TextView.get_buffer()->get_text())
      {
        auto buffer = m_TextView.get_buffer();
        buffer->set_text(message_from_worker_thread);

        // Scroll the last inserted line into view. That's somewhat complicated.
        Gtk::TextIter iter = buffer->end();
        iter.set_line_offset(0); // Beginning of last line
        auto mark = buffer->get_mark("last_line");
        buffer->move_mark(mark, iter);
        m_TextView.scroll_to(mark);
        // TextView::scroll_to(iter) is not perfect.
        // We do need a TextMark to always get the last line into view.
      }
    }

    void ExampleWindow::on_quit_button_clicked()
    {
      if (m_WorkerThread)
      {
        // Order the worker thread to stop and wait for it to stop.
        m_Worker.stop_work();
        if (m_WorkerThread->joinable())
          m_WorkerThread->join();
      }
      hide();
    }

    // notify() is called from ExampleWorker::do_work(). It is executed in the worker
    // thread. It triggers a call to on_notification_from_worker_thread(), which is
    // executed in the GUI thread.
    void ExampleWindow::notify()
    {
      m_Dispatcher.emit();
    }

    void ExampleWindow::on_notification_from_worker_thread()
    {
      if (m_WorkerThread && m_Worker.has_stopped())
      {
        // Work is done.
        if (m_WorkerThread->joinable())
          m_WorkerThread->join();
        delete m_WorkerThread;
        m_WorkerThread = nullptr;
        update_start_stop_buttons();
      }
      update_widgets();
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "examplewindow.h"
    #include <gtkmm/application.h>

    int main (int argc, char* argv[])
    {
      auto app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

      ExampleWindow window;

      //Shows the window and returns when it is closed.
      return app->run(window);
    }

File: `exampleworker.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "exampleworker.h"
    #include "examplewindow.h"
    #include <sstream>
    #include <chrono>

    ExampleWorker::ExampleWorker() :
      m_Mutex(),
      m_shall_stop(false),
      m_has_stopped(false),
      m_fraction_done(0.0),
      m_message()
    {
    }

    // Accesses to these data are synchronized by a mutex.
    // Some microseconds can be saved by getting all data at once, instead of having
    // separate get_fraction_done() and get_message() methods.
    void ExampleWorker::get_data(double* fraction_done, Glib::ustring* message) const
    {
      std::lock_guard<std::mutex> lock(m_Mutex);

      if (fraction_done)
        *fraction_done = m_fraction_done;

      if (message)
        *message = m_message;
    }

    void ExampleWorker::stop_work()
    {
      std::lock_guard<std::mutex> lock(m_Mutex);
      m_shall_stop = true;
    }

    bool ExampleWorker::has_stopped() const
    {
      std::lock_guard<std::mutex> lock(m_Mutex);
      return m_has_stopped;
    }

    void ExampleWorker::do_work(ExampleWindow* caller)
    {
      {
        std::lock_guard<std::mutex> lock(m_Mutex);
        m_has_stopped = false;
        m_fraction_done = 0.0;
        m_message = "";
      } // The mutex is unlocked here by lock's destructor.

      // Simulate a long calculation.
      for (int i = 0; ; ++i) // do until break
      {
        std::this_thread::sleep_for(std::chrono::milliseconds(250));

        {
          std::lock_guard<std::mutex> lock(m_Mutex);

          m_fraction_done += 0.01;

          if (i % 4 == 3)
          {
            std::ostringstream ostr;
            ostr << (m_fraction_done * 100.0) << "% done\n";
            m_message += ostr.str();
          }

          if (m_fraction_done >= 1.0)
          {
            m_message += "Finished";
            break;
          }
          if (m_shall_stop)
          {
            m_message += "Stopped";
            break;
          }
        }

        caller->notify();
      }

      {
        std::lock_guard<std::mutex> lock(m_Mutex);
        m_shall_stop = false;
        m_has_stopped = true;
      }

      caller->notify();
    }

## Συνιστώμενες τεχνικές

Αυτή η ενότητα είναι απλά μια συγκέντρωση σοφίας, γενικές οδηγίες τεχνοτροπίας και συμβουλές για δημιουργία εφαρμογών gtkmm.

Χρήση των GNU autoconf και automake! Είναι οι φίλοι σας :). Η Automake εξετάζει τα αρχεία C, καθορίζει πώς εξαρτώνται μεταξύ τους και δημιουργεί ένα `Makefile`, έτσι ώστε τα αρχεία μπορούν να μεταγλωττιστούν με τη σωστή σειρά. Η Autoconf επιτρέπει αυτόματη διαμόρφωση εγκατάστασης λογισμικού, χειρισμό μεγάλου αριθμού ιδιομορφιών του συστήματος για αύξηση της φορητότητας.

Τα γραφικά συστατικά υποκλάσεων για καλύτερη οργάνωση του κώδικά σας. Θα πρέπει προφανώς να δημιουργήσετε υποκλάσεις στο κύριο Window σας τουλάχιστον. Έπειτα μπορείτε να κάνετε τα θυγατρικά γραφικά συστατικά σας και τα μέλη χειριστών σημάτων αυτής της κλάσης.

Δημιουργήστε τα δικά σας σήματα αντί να περάσετε ολόγυρα δείκτες. Τα αντικείμενα μπορούν να επικοινωνούν μεταξύ τους μέσα από σήματα και χειριστές σήματος. Αυτό είναι πολύ πιο απλό από αντικείμενα που κρατούν δείκτες μεταξύ τους και καλούν μεθόδους μεταξύ τους. Οι κλάσεις gtkmm χρησιμοποιούν ειδικές εκδόσεις της sigc::signal, αλλά θα πρέπει να χρησιμοποιήσετε κανονικά sigc::signals, όπως περιγράφεται στην τεκμηρίωση libsigc++.

### Χρόνος ζωής εφαρμογής

Οι περισσότερες εφαρμογές θα έχουν μόνο μια Window, ή μόνο ένα κύριο παράθυρο. Αυτές οι εφαρμογές μπορούν να χρησιμοποιήσουν την υπερφόρτωση Gtk::Application::run(Gtk::Window&). Εμφανίζει το παράθυρο και επιστρέφει όταν το παράθυρο έχει κρυφτεί. Αυτό μπορεί να συμβεί όταν ο χρήστης κλείνει το παράθυρο, ή όταν ο κώδικάς σας αποφασίζει να hide() το παράθυρο. Μπορείτε να αποτρέψετε τον χρήστη από το κλείσιμο του παραθύρου (για παράδειγμα, αν υπάρχουν αναποθήκευτες αλλαγές) αντικαθιστώντας την Gtk::Window::on_delete_event().

Τα περισσότερα από τα παραδείγματά μας χρησιμοποιούν αυτήν την τεχνική.

### Χρησιμοποιώντας ένα γραφικό συστατικό gtkmm

Όλα τα παραδείγματά μας τείνουν να έχουν την ίδια δομή. Ακολουθούν αυτά τα βήματα για τη χρήση μιας Widget:

1. Δηλώστε μια μεταβλητή του τύπου Widget που θέλετε να χρησιμοποιήσετε, γενικά ως μεταβλητή μέλους μιας παραγόμενης κλάσης περιέκτη. Μπορείτε επίσης να δηλώσετε έναν δείκτη στον τύπο γραφικού συστατικού και έπειτα να τον δημιουργήστε με `new` στον κώδικά σας. Ακόμα κι όταν χρησιμοποιείτε το γραφικό συστατικό μέσα από έναν δείκτη, είναι ακόμα προφανώς βέλτιστο να κάνετε αυτόν τον δείκτη μια μεταβλητή μέλους της κλάσης περιέκτη έτσι ώστε να μπορείτε να την προσπελάσετε αργότερα.

2. Ορίστε τα γνωρίσματα του γραφικού συστατικού. Αν το γραφικό συστατικό δεν έχει προεπιλεγμένο κατασκευαστή, τότε θα χρειαστείτε να αρχικοποιήσετε το γραφικό συστατικό στον κατάλογο αρχικοποίησης του κατασκευαστή της κλάσης περιέκτη.

3. Συνδέστε οποιοδήποτε σήμα που θέλετε να χρησιμοποιήσετε με τους κατάλληλους χειριστές.

4. Συσκευάστε το γραφικό συστατικό σε έναν περιέκτη χρησιμοποιώντας την κατάλληλη κλήση, π.χ. Gtk::Container::add() ή pack_start().

5. Καλέστε show() για να εμφανίσετε το γραφικό συστατικό.

Η Gtk::Widget::show() επιτρέπει στην gtkmm να ξέρει ότι έχουμε τελειώσει τη ρύθμιση των γνωρισμάτων του γραφικού συστατικού και ότι είναι έτοιμο να εμφανιστεί. Μπορείτε να χρησιμοποιήσετε την Gtk::Widget::hide() για να το εξαφανίσετε πάλι. Η σειρά με την οποία εμφανίζετε τα γραφικά συστατικά δεν είναι σημαντική, αλλά προτείνουμε να δείξετε τελευταίο το παράθυρο ανωτάτου επιπέδου· έτσι, ολόκληρο το παράθυρο θα εμφανιστεί με τα περιεχόμενά του ήδη σχεδιασμένα. Αλλιώς, ο χρήστης θα δει πρώτα ένα κενό παράθυρο, στο οποίο τα γραφικά συστατικά θα σχεδιαστούν σταδιακά.

## Συνεισφορά

Αυτό το έγγραφο, όπως πολύ άλλο μεγάλο λογισμικό εκεί, δημιουργήθηκε δωρεάν από εθελοντές. Αν έχετε γνώσεις για οποιαδήποτε όψη της gtkmm που δεν έχει ήδη τεκμηριωθεί, παρακαλούμε να σκεφτείτε τη συνεισφορά του σε αυτό το έγγραφο.

Ideally, we would like you to provide a patch to the `docs/tutorial/C/index-in.docbook` file. This file is currently in the `gtkmm-documentation` module in GNOME git.

Αν αποφασίσετε να συνεισφέρετε, παρακαλούμε στείλτε τη συνεισφορά σας στην ταχυδρομική λίστα gtkmm στο <gtkmm-list@gnome.org>. Επίσης, να ξέρετε ότι όλο αυτό το έγγραφο είναι ελεύθερο και οποιαδήποτε προσθήκη δώσετε πρέπει να είναι επίσης ελεύθερη. Δηλαδή, τα άτομα πρέπει να μπορούν να χρησιμοποιήσουν οποιοδήποτε τμήμα των παραδειγμάτων σας στα προγράμματά τους και αντίγραφα αυτού του εγγράφου (συμπεριλαμβανομένης της συνεισφορά σας) μπορούν να διανεμηθούν ελεύθερα.

## Ο έξυπνος δείκτης RefPtr

Η Glib::RefPtr είναι ένας έξυπνος δείκτης. Ειδικά, είναι ένας έξυπνος δείκτης μετρητή αναφοράς. Μπορεί να είσαστε εξοικειωμένοι με τις std::auto_ptr<>, std::unique_ptr<> και std::shared_ptr<>, που είναι επίσης έξυπνοι δείκτες. Η Glib::RefPtr<> είναι παρόμοια με την std::shared_ptr<>, που είναι επίσης μετρητής αναφοράς. Η Glib::RefPtr<> εισήχθη πολύ πριν να υπάρξει ένα έξυπνο σημείο μετρητή αναφοράς στην τυπική βιβλιοθήκη C++.

Reference

Ένας έξυπνος δείκτης δρα παρόμοια με έναν κανονικό δείκτη. Ιδού μερικά παραδείγματα.

### Αντιγραφή

Μπορείτε να αντιγράψετε RefPtrs, ακριβώς όπως σε κανονικούς δείκτες. Αλλά αντίθετα με τους κανονικούς δείκτες, δεν χρειάζεται να ανησυχείτε για τη διαγραφή του υποκείμενου στιγμιότυπου.

    Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    Glib::RefPtr<Gdk::Pixbuf> refPixbuf2 = refPixbuf;

Φυσικά αυτό σημαίνει ότι μπορείτε να αποθηκεύσετε τις RefPtrs σε τυπικούς περιέκτες, όπως std::vector ή std::list.

    std::list< Glib::RefPtr<Gdk::Pixbuf> > listPixbufs;
    Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    listPixbufs.push_back(refPixbuf);

### Αποαναφορά

Μπορείτε να αποαναφέρετε έναν έξυπνο δείκτη με τον τελεστή ->, για να καλέσετε τις μεθόδους του υποκείμενου στιγμιότυπου, ακριβώς όπως ένας κανονικός δείκτης.

    Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    int width = refPixbuf->get_width();

Αλλά αντίθετα με τους περισσότερους έξυπνους δείκτες, δεν μπορείτε να χρησιμοποιήσετε τον τελεστή * για να προσπελάσετε το υποκείμενο στιγμιότυπο.

    Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
    Gdk::Pixbuf& underlying = *refPixbuf; //Σφάλμα σύνταξης - δεν θα μεταγλωττίσει.

### Αλλαγή τύπου

Μπορείτε να μετατρέψετε μια RefPtrs σε βασικούς τύπους, ακριβώς όπως με τους κανονικούς δείκτες.

    Glib::RefPtr<Gtk::TreeStore> refStore = Gtk::TreeStore::create(columns);
    Glib::RefPtr<Gtk::TreeModel> refModel = refStore;

Αυτό σημαίνει ότι οποιαδήποτε μέθοδος που παίρνει ένα όρισμα const Glib::RefPtr<BaseType> μπορεί επίσης να πάρει έναν const Glib::RefPtr<DerivedType>. Η μετατροπή είναι σιωπηρή, ακριβώς όπως θα ήταν για έναν κανονικό δείκτη.

Μπορείτε επίσης να μετατρέψετε σε έναν παράγωγο τύπο, αλλά η σύνταξη είναι λίγο διαφορετική από ότι με έναν κανονικό δείκτη.

    Glib::RefPtr<Gtk::TreeStore> refStore =
    Glib::RefPtr<Gtk::TreeStore>::cast_dynamic(refModel);
    Glib::RefPtr<Gtk::TreeStore> refStore2 =
    Glib::RefPtr<Gtk::TreeStore>::cast_static(refModel);

### Έλεγχος για κενό

Ακριβώς όπως οι κανονικοί δείκτες, μπορείτε να ελέγξετε αν η RefPtr δείχνει κάπου.

    Glib::RefPtr<Gtk::TreeModel> refModel = m_TreeView.get_model();
    if(refModel)
    {
      int cols_count = refModel->get_n_columns();
      ...
    }

Αλλά αντίθετα με τους κανονικούς δείκτες, οι RefPtrs αρχικοποιούνται αυτόματα σε κενό, έτσι δεν χρειάζεται να θυμάστε να το κάνετε οι ίδιοι.

### Σταθερότητα

Η χρήση της λέξης-κλειδί `const` στην C++ δεν είναι πάντα σαφής. Μπορεί να μην καταλάβετε ότι ο const Something* δηλώνει έναν δείκτη σε έναν const Something. Ο δείκτης μπορεί να αλλαχθεί, αλλά όχι ο Something στον οποίο δείχνει.

Συνεπώς, η ισοδύναμη RefPtr του Something* για μια παράμετρο μεθόδου είναι const Glib::RefPtr<Something>& και ο ισοδύναμος του const Something* είναι const Glib::RefPtr<const Something>&.

Η `const ... &` γύρω και από τις δύο είναι απλά για αποτελεσματικότητα, όπως η χρήση της const std::string& αντί για την std::string για μια παράμετρο μεθόδου για αποφυγή περιττών αντιγραφών.

## Σήματα

### Σύνδεση χειριστών σημάτων

Οι κλάσεις γραφικών συστατικών gtkmm έχουν μεθόδους στοιχείων πρόσβασης σήματος, όπως Gtk::Button::signal_clicked(), που επιτρέπουν να συνδεθείτε με τον χειριστή σήματός σας. Χάρη στην ευελιξία της libsigc++, την βιβλιοθήκη επανάκλησης που χρησιμοποιείται από την gtkmm, ο χειριστής σήματος μπορεί να είναι σχεδόν κάθε είδος συνάρτησης, αλλά προφανώς θα θέλετε να χρησιμοποιήσετε μια μέθοδο κλάσεων. Μεταξύ των κωδικοποιητών C της GTK+, αυτοί οι χειριστές σήματος ονομάζονται συχνά επανακλήσεις.

Ιδού ένα παράδειγμα ενός χειριστή σήματος που συνδέθηκε σε ένα σήμα:

    #include <gtkmm/button.h>

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

    main()
    {
        Gtk::Button button("Hello World");
        button.signal_clicked().connect(sigc::ptr_fun(&on_button_clicked));
    }

Υπάρχουν μάλλον πολλά να σκεφτείτε για αυτόν τον (μη λειτουργικό) κώδικα. Πρώτα ας αναγνωρίσουμε τα εμπλεκόμενα μέρη:

- Ο χειριστής σήματος είναι on_button_clicked().

- Το συνδέουμε στο αντικείμενο Gtk::Button που λέγεται `button`.

- Όταν το πλήκτρο εκπέμπει το σήμα του `clicked`, θα κληθεί η on_button_clicked() will be called.

Τώρα ας κοιτάξουμε στη σύνδεση ξανά:

        ...
        button.signal_clicked().connect(sigc::ptr_fun(&on_button_clicked));
        ...

Σημειώστε ότι δεν περάσαμε έναν δείκτη στην on_button_clicked() άμεσα από τη μέθοδο connect() του σήματος. Αντίθετα, καλούμε `sigc::ptr_fun()` και περνάμε το αποτέλεσμα στην connect().

Η `sigc::ptr_fun()` δημιουργεί μια sigc::slot. Μια υποδοχή είναι ένα αντικείμενο που φαίνεται και αισθάνεται όπως μια συνάρτηση, αλλά στην πραγματικότητα είναι ένα αντικείμενο. Αυτά είναι επίσης γνωστά ως αντικείμενα συνάρτησης, ή functors. Η `sigc::ptr_fun()` δημιουργεί μια υποδοχή για μια αυτόνομη συνάρτηση ή στατική μέθοδο. Η `sigc::mem_fun()` δημιουργεί μια υποδοχή για μια μέθοδο μέλους ενός ιδιαίτερου στιγμιότυπου.

Ιδού ένα ελαφρώς μεγαλύτερο παράδειγμα υποδοχών σε δράση:

    void on_button_clicked();

    class some_class
    {
        void on_button_clicked();
    };

    some_class some_object;

    main()
    {
        Gtk::Button button;
        button.signal_clicked().connect( sigc::ptr_fun(&on_button_clicked) );
        button.signal_clicked().connect( sigc::mem_fun(some_object, &some_class::on_button_clicked) );
    }

Η πρώτη κλήση στην connect() είναι ακριβώς όπως αυτή που είδαμε την τελευταία φορά· τίποτα νέο εδώ.

Το επόμενο είναι πιο ενδιαφέρον. Η `sigc::mem_fun()` καλείται με δύο ορίσματα. Το πρώτο όρισμα είναι some_object, που είναι το αντικείμενο που η νέα μας υποδοχή θα δείχνει. Το δεύτερο όρισμα είναι ένας δείκτης σε μια από τις μεθόδους του. Αυτή η συγκεκριμένη έκδοση της `sigc::mem_fun()` δημιουργεί μια υποδοχή που, όταν "κληθεί", θα καλέσει τη μέθοδο στην οποία δείχνει του συγκεκριμένου αντικειμένου, σε αυτήν την περίπτωση στην some_object.on_button_clicked().

Ένα άλλο πράγμα που πρέπει να σημειώσετε για αυτό το παράδειγμα είναι ότι κάναμε την κλήση στην connect() δυο φορές για το ίδιο αντικείμενο σήματος. Αυτό είναι ολότελα θαυμάσιο - όταν το πλήκτρο πατιέται, και οι δύο χειριστές σήματος θα κληθούν.

Μόλις σας είπαμε ότι το σήμα `clicked` του πλήκτρου αναμένει να καλέσει μια μέθοδο χωρίς ορίσματα. Όλα τα σήματα έχουν απαιτήσεις όπως αυτό - δεν μπορείτε να αγκιστρώσετε μια συνάρτηση με δύο ορίσματα σε ένα σήμα που δεν περιμένει κανένα (εκτός και χρησιμοποιείτε έναν προσαρμογέα, όπως `sigc::bind()`, φυσικά). Συνεπώς, είναι σημαντικό να ξέρετε ποιος τύπος χειριστή σήματος θα αναμένεται για να συνδεθεί με το δοσμένο σήμα.

### Εγγραφή χειριστών σημάτων

Για την εύρεση του τύπου του χειριστή σήματος που μπορείτε να συνδέσετε με ένα σήμα, μπορείτε να το κοιτάξετε στην τεκμηρίωση αναφοράς ή στο αρχείο κεφαλίδας. Ιδού ένα παράδειγμα της δήλωσης σήματος που μπορείτε να δείτε στις κεφαλίδες gtkmm:

    Glib::SignalProxy1<bool, Gtk::DirectionType> signal_focus()

Πέρα από το όνομα του σήματος (`focus`), δύο πράγματα είναι σημαντικά να σημειώσετε εδώ: ο αριθμός που ακολουθεί τη λέξη SignalProxy στην αρχή (1, σε αυτήν την περίπτωση) και οι τύποι στη λίστα (bool και Gtk::DirectionType). Ο αριθμός δείχνει πόσα ορίσματα πρέπει να έχει ο χειριστής σήματος· ο πρώτος τύπος, bool, είναι ο τύπος που ο χειριστής σήματος πρέπει να επιστρέψει· και ο επόμενος τύπος, Gtk::DirectionType, είναι ο τύπος του πρώτου αυτού του σήματος και μόνο, όρισμα. Κοιτώντας στην τεκμηρίωση αναφοράς, μπορείτε να δείτε τα ονόματα των ορισμάτων επίσης.

Οι ίδιες αρχές εφαρμόζονται για σήματα που έχουν περισσότερα ορίσματα. Ιδού ένα με τρία (ελήφθησαν από `<gtkmm/textbuffer.h>`):

    Glib::SignalProxy3<void, const TextBuffer::iterator&, const Glib::ustrin&, int> signal_insert();

Ακολουθεί την ίδια μορφή. Ο αριθμός 3 στο τέλος του ονόματος τύπου δείχνει ότι ο χειριστής σήματος θα χρειαστεί τρία ορίσματα. Ο πρώτος τύπος στον κατάλογο τύπων είναι void, έτσι ώστε πρέπει να είναι ο τύπος επιστροφής του χειριστή σήματός μας. Οι ακόλουθοι τρεις τύποι είναι οι αποδεκτοί τύποι ορίσματος. Το πρωτότυπο του χειριστή σήματός μας μπορεί να μοιάζει με αυτό:

    void on_insert(const TextBuffer::iterator& pos, const Glib::ustring& text, int bytes)

### Αποσύνδεση χειριστών σημάτων

Ας κοιτάξουμε τη μέθοδο του σήματος `connect`:

    sigc::signal<void,int>::iterator signal<void,int>::connect( const sigc::slot<void,int>& );

Σημειώστε ότι η τιμή επιστροφής είναι του τύπου sigc::signal<void,int>::iterator. Αυτό μπορεί να είναι έμμεσα αλλαγμένο σε sigc::connection που με τη σειρά της μπορεί να χρησιμοποιηθεί για τον έλεγχο της σύνδεσης. Κρατώντας ένα αντικείμενο σύνδεσης μπορείτε να αποσυνδέσετε τον συσχετισμένο χειριστή σήματος χρησιμοποιώντας τη μέθοδο sigc::connection::disconnect().

### Αντικατάσταση προεπιλεγμένων χειριστών σημάτων

Μέχρι τώρα σας έχουμε πει να εκτελείτε ενέργειες σε απάντηση των πατημάτων πλήκτρου και το παρόμοιο χειριζόμενοι σήματα. Αυτός είναι σίγουρα ένας καλός τρόπος να γίνονται τα πράγματα, αλλά δεν είναι ο μόνος τρόπος.

Αντί για την επίπονη σύνδεση χειριστών σημάτων σε σήματα, μπορείτε να κάνετε απλά μια νέα κλάση που κληρονομεί από ένα γραφικό συστατικό - ας πούμε, ένα πλήκτρο - και έπειτα να αντικαταστήσετε τον προεπιλεγμένο χειριστή σήματος, όπως τον Button::on_clicked(). Αυτό μπορεί να είναι πιο απλό από την αγκίστρωση χειριστών σήματος για καθετί.

Η δημιουργία υποκλάσεων δεν είναι πάντα ο καλύτερος τρόπος πραγματοποίησης. Είναι χρήσιμος μόνο όταν θέλετε το γραφικό συστατικό να χειρίζεται το δικό του σήμα από μόνο του. Αν θέλετε κάποια άλλη κλάση να χειρίζεται το σήμα, τότε θα χρειαστείτε να συνδέσετε έναν ξεχωριστό χειριστή. Αυτό είναι ακόμα περισσότερο αληθές, αν θέλετε αρκετά αντικείμενα να χειρίζονται το ίδιο σήμα, ή αν θέλετε ένας χειριστής σήματος να απαντά στο ίδιο σήμα από διαφορετικά αντικείμενα.

Οι κλάσεις gtkmm σχεδιάζονται με την αντικατάσταση κατά νου· περιέχουν εικονικές μεθόδους μέλους με ειδικό σκοπό να αντικατασταθούν.

Ας κοιτάξουμε ένα παράδειγμα αντικατάστασης:

    #include <gtkmm/button.h>

    class OverriddenButton : public Gtk::Button
    {
    protected:
        virtual void on_clicked();
    }

    void OverriddenButton::on_clicked()
    {
        std::cout << "Hello World" << std::endl;

        // κλήση της έκδοσης της μεθόδου της κλάσης βάσης:
        Gtk::Button::on_clicked();
    }

Εδώ ορίζουμε μια νέα κλάση που λέγεται OverriddenButton, που κληρονομεί από την Gtk::Button. Το μόνο που αλλάζουμε είναι η μέθοδος on_clicked(), που καλείται όποτε η Gtk::Button εκπέμπει το σήμα `clicked`. Αυτή η μέθοδος εκτυπώνει "Hello World" στην `stdout` και έπειτα καλεί την αρχική υποκατεστημένη μέθοδο, για να επιτρέψει στην Gtk::Button να κάνει ό,τι θα είχε κάνει αν δεν είχε αντικατασταθεί.

Δεν χρειάζεται πάντα να καλέσετε τη γονική μέθοδο· υπάρχουν φορές που μπορεί να μην το θέλετε. Σημειώστε ότι, καλούμε τη γονική μέθοδο αφού γράψουμε "Hello World", αλλά μπορούμε να την έχουμε καλέσει πριν. Σε αυτό το απλό παράδειγμα, δεν πειράζει πολύ, αλλά υπάρχουν φορές που πειράζει. Με σήματα, δεν είναι τόσο εύκολη η αλλαγή λεπτομερειών όπως αυτή και μπορείτε να κάνετε κάτι εδώ που δεν μπορείτε να κάνετε καθόλου με συνδεμένους χειριστές σήματος: μπορείτε να καλέσετε τη γονική μέθοδο στο μέσο του προσαρμοσμένου κώδικά σας.

### Σύνδεση πρόσθετων ορισμάτων

If you use one signal handler to catch the same signal from several widgets, you might like that signal handler to receive some extra information. For instance, you might want to know which button was clicked. You can do this with `sigc::bind()`. Here's some code from the helloworld2 example.

    m_button1.signal_clicked().connect( sigc::bind<Glib::ustring>( sigc::mem_fun(*this, &HelloWorld::on_button_clicked), "button 1") );

This says that we want the signal to send an extra Glib::ustring argument to the signal handler, and that the value of that argument should be "button 1". Of course we will need to add that extra argument to the declaration of our signal handler:

    virtual void on_button_clicked(Glib::ustring data);

Of course, a normal "clicked" signal handler would have no arguments.

Η `sigc::bind()` δεν χρησιμοποιείται συνήθως, αλλά μπορείτε να την βρείτε χρήσιμη μερικές φορές. Αν είσαστε εξοικειωμένος με τον προγραμματισμό της GTK+, τότε θα έχετε προφανώς σημειώσει ότι αυτό είναι παρόμοιο με τα πρόσθετα ορίσματα `gpointer data` που όλα έχουν επανακλήσεις GTK+. Αυτό γενικά υπερχρησιμοποιείται στην GTK+ για το πέρασμα πληροφοριών που πρέπει να αποθηκευτούν ως μέλη δεδομένων σε ένα παράγωγο γραφικό συστατικό, αλλά μια παραγωγή γραφικού συστατικού είναι πολύ δύσκολη στη C. Έχουμε πολύ λιγότερη ανάγκη αυτής της επέμβασης στην gtkmm.

### Σήματα συμβάντος Χ

Η κλάση Widget έχει μερικά ειδικά σήματα που αντιστοιχούν με τα υποκείμενα συμβάντα X-Windows. Αυτά έχουν ως επίθημα από την `_event`· για παράδειγμα, η Widget::signal_button_press_event().

Μπορεί ενίοτε να βρείτε χρήσιμο τον χειρισμό συμβάντων Χ, όταν υπάρχει κάτι που δεν μπορείτε να πραγματοποιήσετε με κανονικά σήματα. Η Gtk::Button, για παράδειγμα, δεν στέλνει συντεταγμένες δείκτη ποντικιού με το σήμα της `clicked`, αλλά μπορείτε να χειριστείτε την `button_press_event`, αν χρειαστείτε αυτήν την πληροφορία. Τα συμβάντα Χ χρησιμοποιούνται επίσης συχνά για χειρισμό των πατημάτων πλήκτρου.

Αυτά τα σήματα συμπεριφέρονται λίγο διαφορετικά. Η επιστρεφόμενη τιμή από τον χειριστή σήματος δείχνει αν έχει "χειριστεί" πλήρως το συμβάν. Αν η τιμή είναι `false` τότε η gtkmm θα περάσει το συμβάν στον επόμενο χειριστή σήματος. Αν η τιμή είναι `true`, τότε κανένας άλλος χειριστής σήματος δεν θα χρειαστεί να κληθεί.

Ο χειρισμός ενός συμβάντος Χ δεν επηρεάζει τα άλλα σήματα του γραφικού συστατικού. Αν χειρίζεστε το `button_press_event` για την Gtk::Button, θα μπορείτε ακόμα να πάρετε το σήμα `clicked`. Εκπέμπονται (σχεδόν) ταυτόχρονα.

Σημειώστε επίσης ότι όλα τα γραφικά συστατικά δέχονται όλα τα συμβάντα Χ από προεπιλογή. Για να δεχτείτε πρόσθετα συμβάντα Χ, μπορείτε να χρησιμοποιήσετε τη Gtk::Widget::set_events() πριν την εμφάνιση του γραφικού συστατικού, ή την Gtk::Widget::add_events() μετά την εμφάνιση του γραφικού συστατικού. Όμως, μερικά γραφικά συστατικά πρέπει πρώτα να τοποθετηθούν μέσα σε ένα γραφικό συστατικό EventBox. Δείτε το κεφάλαιο Γραφικά συστατικά χωρίς παράθυρα X.

Here's a simple example:

    bool on_button_press(GdkEventButton* event);
    Gtk::Button button("label");
    button.signal_button_press_event().connect( sigc::ptr_fun(&on_button_press) );

Όταν το ποντίκι είναι πάνω από το πλήκτρο και ένα πλήκτρο του ποντικιού πατιέται, Θα κληθεί η on_button_press().

Ο GdkEventButton είναι μια δομή που περιέχει τις παραμέτρους του συμβάντος, όπως τις συντεταγμένες του δείκτη του ποντικιού την ώρα ποπυ το πλήκτρο πατήθηκε. Υπάρχουν αρκετοί διαφορετικοί τύποι δομών GdkEvent για τα ποικίλα συμβάντα.

#### Αλληλουχία χειριστή σήματος

By default, your signal handlers are called after any previously-connected signal handlers. However, this can be a problem with the X Event signals. For instance, the existing signal handlers, or the default signal handler, might return `true` to stop other signal handlers from being called. To specify that your signal handler should be called before the other signal handlers, so that it will always be called, you can specify `false` for the optional `after` parameter. For instance,

    button.signal_button_press_event().connect( sigc::ptr_fun(&on_mywindow_button_press), false );

Το συμβάν δίνεται πρώτα στο γραφικό συστατικό που συμβαίνει το συμβάν. Αν όλοι οι χειριστές σήματος σε αυτό το γραφικό συστατικό επιστρέψουν `false` (που δείχνει ότι το συμβάν δεν επεξεργάστηκε), τότε το σήμα θα διαδοθεί στο γονικό γραφικό συστατικό και θα εκπεμφθεί εκεί. Αυτό συνεχίζεται όλο τον δρόμο μέχρι το γραφικό συστατικό ανωτάτου επιπέδου, αν κανένας δεν χειριστεί το συμβάν.

### Εξαιρέσεις στους χειριστές σήματος

Όταν ένα πρόγραμμα ματαιώνεται λόγω μιας ανεπίλυτης εξαίρεσης C++, είναι μερικές φορές δυνατή η χρήση ενός αποσφαλματωτή για την εύρεση της θέσης όπου συνέβη η εξαίρεση. Αυτό είναι πιο δύσκολο από ό,τι συνήθως, αν η εξαίρεση συνέβη από έναν χειριστή σήματος.

Αυτή η ενότητα περιγράφει κυρίως τι μπορείτε να περιμένετε σε ένα σύστημα Linux, όταν χρησιμοποιείτε το αποσφαλματωτής gdb.

First, let's look at a simple example where an exception is thrown from a normal function (no signal handler).

    // without_signal.cc
    #include <gtkmm.h>

    bool throwSomething()
    {
      throw "Something";
      return true;
    }

    int main(int argc, char** argv)
    {
      throwSomething();
      Glib::RefPtr<Gtk::Application> app =
        Gtk::Application::create(argc, argv, "org.gtkmm.without_signal");
      return app->run();
    }

Here is an excerpt from a gdb session. Only the most interesting parts of the output are shown.

    > gdb without_signal
    (gdb) run
    terminate called after throwing an instance of 'char const*'

    Program received signal SIGABRT, Aborted.
    (gdb) backtrace
    #7  0x08048864 in throwSomething () at without_signal.cc:6
    #8  0x0804887d in main (argc=1, argv=0xbfffecd4) at without_signal.cc:12

You can see that the exception was thrown from `without_signal.cc`, line 6 (`throw "Something";`).

Now let's see what happens when an exception is thrown from a signal handler. Here's the source code.

    // with_signal.cc
    #include <gtkmm.h>

    bool throwSomething()
    {
      throw "Something";
      return true;
    }

    int main(int argc, char** argv)
    {
      Glib::signal_timeout().connect(sigc::ptr_fun(throwSomething), 500);
      Glib::RefPtr<Gtk::Application> app =
        Gtk::Application::create(argc, argv, "org.gtkmm.with_signal");
      app->hold();
      return app->run();
    }

And here's an excerpt from a gdb session.

    > gdb with_signal
    (gdb) run
    (with_signal:2703): glibmm-ERROR **:
    unhandled exception (type unknown) in signal handler

    Program received signal SIGTRAP, Trace/breakpoint trap.
    (gdb) backtrace
    #2  0x0063c6ab in glibmm_unexpected_exception () at exceptionhandler.cc:77
    #3  Glib::exception_handlers_invoke () at exceptionhandler.cc:150
    #4  0x0063d370 in glibmm_source_callback (data=0x804d620) at main.cc:212
    #13 0x002e1b31 in Gtk::Application::run (this=0x804f300) at application.cc:178
    #14 0x08048ccc in main (argc=1, argv=0xbfffecd4) at with_signal.cc:16

The exception is caught in glibmm, and the program ends with a call to `g_error()`. Other exceptions may result in different behaviour, but in any case the exception from a signal handler is caught in glibmm or gtkmm, and gdb can't see where it was thrown.

To see where the exception is thrown, you can use the gdb command `catch throw`.

    > gdb with_signal
    (gdb) catch throw
    Catchpoint 1 (throw)
    (gdb) run
    Catchpoint 1 (exception thrown), 0x00714ff0 in __cxa_throw ()
    (gdb) backtrace
    #0  0x00714ff0 in __cxa_throw () from /usr/lib/i386-linux-gnu/libstdc++.so.6
    #1  0x08048bd4 in throwSomething () at with_signal.cc:6
    (gdb) continue
    Continuing.
    (with_signal:2375): glibmm-ERROR **
    unhandled exception (type unknown) in signal handler

    Program received signal SIGTRAP, Trace/breakpoint trap.

If there are many caught exceptions before the interesting uncaught one, this method can be tedious. It can be automated with the following gdb commands.

    (gdb) catch throw
    (gdb) commands
    (gdb)   backtrace
    (gdb)   continue
    (gdb)   end
    (gdb) set pagination off
    (gdb) run

These commands will print a backtrace from each `throw` and continue. The backtrace from the last (or possibly the last but one) `throw` before the program stops, is the interesting one.

## Δημιουργία των σημάτων σας.

Τώρα που έχετε δει σήματα και χειριστές σήματος στην gtkmm, μπορεί να σας αρέσει να χρησιμοποιήσετε την ίδια τεχνική για να επιτρέψετε την αλληλεπίδραση μεταξύ των δικών σας κλάσεων. Αυτό είναι στην πραγματικότητα πολύ απλό χρησιμοποιώντας την βιβλιοθήκη libsigc++ άμεσα.

Αυτό δεν είναι καθαρά μια gtkmm ή ένα θέμα γραφικής διεπαφής χρήστη. Η gtkmm χρησιμοποιεί την libsigc++ για να υλοποιήσει τους συσκευαστές μεσολαβητή για το σύστημα σήματος GTK+, αλλά για νέα, μη GTK+ σήματα, μπορείτε να δημιουργήσετε καθαρά σήματα C++, χρησιμοποιώντας το πρότυπο sigc::signal<>.

For instance, to create a signal that sends 2 parameters, a bool and an int, just declare a sigc::signal, like so:

    sigc::signal<void, bool, int> signal_something;

You could just declare that signal as a public member variable, but some people find that distasteful and prefer to make it available via an accessor method, like so:

    class Server
    {
    public:
      //signal accessor:
      typedef sigc::signal<void, bool, int> type_signal_something;
      type_signal_something signal_something();

    protected:
      type_signal_something m_signal_something;
    };

    Server::type_signal_something Server::signal_something()
    {
      return m_signal_something;
    }

You can then connect to the signal using the same syntax used when connecting to gtkmm signals. For instance,

    server.signal_something().connect(
      sigc::mem_fun(client, &Client::on_server_something) );

### Παράδειγμα

Αυτό είναι ένα πλήρως λειτουργικό παράδειγμα που ορίζει και χρησιμοποιεί προσαρμοσμένα σήματα.

Source Code

File: `server.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_SERVER_H
    #define GTKMM_EXAMPLE_SERVER_H

    #include <sigc++/sigc++.h>

    class Server
    {
    public:
      Server();
      virtual ~Server();

      void do_something();

      //signal accessor:
      typedef sigc::signal<void, bool, int> type_signal_something;
      type_signal_something signal_something();

    protected:
      type_signal_something m_signal_something;
    };

    #endif //GTKMM_EXAMPLE_SERVER_H

File: `client.h` (For use with gtkmm 3, not gtkmm 2)

    #ifndef GTKMM_EXAMPLE_CLIENT_H
    #define GTKMM_EXAMPLE_CLIENT_H

    #include <sigc++/sigc++.h>

    //Client must inherit from sigc::trackable.
    //because libsigc++ needs to keep track of the lifetime of signal handlers.
    class Client : public sigc::trackable
    {
    public:
      Client();
      virtual ~Client();

      //Signal handler:
      void on_server_something(bool a, int b);
    };

    #endif //GTKMM_EXAMPLE_CLIENT_H

File: `client.cc` (For use with gtkmm 3, not gtkmm 2)

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

    Client::Client()
    {
    }

    Client::~Client()
    {
    }

    void Client::on_server_something(bool a, int b)
    {
      std::cout << "Client::on_server_something() called with these parameters: "
          << a << ", " << b << std::endl;
    }

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "server.h"
    #include "client.h"
    #include <iostream>

    int main(int, char**)
    {
      Server server;
      Client client;

      //Connect a Server signal to the signal handler in Client.
      server.signal_something().connect(sigc::mem_fun(client,
                  &Client::on_server_something) );

      std::cout << "Before Server::do_something()" << std::endl;

      //Tell the server to do something that will eventually cause it to emit the
      //"something" signal.
      server.do_something();    // Client::on_server_something() will run before
                                // Server::do_something() has completed.

      std::cout << "After Server::do_something()" << std::endl;

      return 0;
    }

File: `server.cc` (For use with gtkmm 3, not gtkmm 2)

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

    Server::Server()
    {
    }

    Server::~Server()
    {
    }

    Server::type_signal_something Server::signal_something()
    {
      return m_signal_something;
    }

    void Server::do_something()
    {
      m_signal_something.emit(false, 5);
    }

## Σύγκριση με άλλα συστήματα σηματοδότησης

(Μια παρένθεση: η GTK+ αποκαλεί αυτό το σχήμα "σηματοδότηση"· ο ανοιχτομάτης αναγνώστης με εμπειρία πακέτου εργαλείων GUI θα σημειώσει ότι αυτή η ίδια σχεδίαση εμφανίζεται συχνά κάτω από το όνομα "εκφώνηση-ακρόαση" (π.χ. στο σκελετό PowerPlant του Metrowerks για το Macintosh). Δουλεύει χοντρικά με τον ίδιο τρόπο: ένας ρυθμίζει την `εκφώνηση` και έπειτα συνδέει την `ακρόαση` με αυτήν· η εκφώνηση κρατά έναν κατάλογο των αντικειμένων που την ακούν και όταν κάποιος δώσει ένα μήνυμα στην εκφώνηση, καλεί όλα τα αντικείμενά της στον κατάλογό της με το μήνυμα. Στην gtkmm, τα αντικείμενα σήματος παίζουν τον ρόλο της εκφώνησης και οι υποδοχές παίζουν τον ρόλο της ακρόασης - κατά κάποιον τρόπο. Περισσότερο για αυτό αργότερα.)

Οι χειριστές σήματος gtkmm είναι ισχυρού τύπου, ενώ ο κώδικας C της GTK+ επιτρέπει τη σύνδεση μιας επανάκλησης με τον εσφαλμένο αριθμό και τύπο ορισμάτων, οδηγώντας σε ένα σφάλμα κατάτμησης στον χρόνο εκτέλεσης. Και, αντίθετα με την Qt, η gtkmm το πετυχαίνει χωρίς τροποποίηση της γλώσσας C++.

Αναφορικά με την αντικατάσταση χειριστών σημάτων: Μπορείτε να το κάνετε στον κόσμο της άμεσης C της GTK+ επίσης· για υτό είναι το σύστημα αντικειμένου του GTK. Αλλά στην GTK+, πρέπει να περάσετε μέσα από κάποιες περίπλοκες διαδικασίες για να πάρετε αντικειμενοστραφή χαρακτηριστικά όπως κληρονομικότητα και υπερφόρτωση. Στην C++, είναι απλό, αφού αυτά τα χαρακτηριστικά υποστηρίζονται στην ίδια τη γλώσσα· μπορείτε να επιτρέψετε στον μεταγλωττιστή να κάνει τη βρόμικη δουλειά.

Αυτή είναι μια από τις θέσεις όπου η ομορφιά της C++ πραγματικά εμφανίζεται. Κάποιος δεν θα σκεφτόταν να δημιουργήσει υποκλάση ενός γραφικού συστατικού GTK+ απλά για να αντικαταστήσει τη μέθοδό ενέργειας του· είναι απλά υπερβολικό πρόβλημα. Στην GTK+, χρησιμοποιείτε σχεδόν πάντα σήματα για να κάνετε τα πράγματα, εκτός και γράφετε ένα νέο γραφικό συστατικό. Αλλά λόγω των μεθόδων αντικατάστασης είναι τόσο εύκολο στη C++, είναι πλήρως πρακτικό - και λογικό - να δημιουργήσετε μια υποκλάση ενός πλήκτρου για αυτόν τον σκοπό.

## Η gtkmm και η Win32

Ένα από τα μεγάλα πλεονεκτήματα της gtkmm είναι ότι είναι διαλειτουργική. Τα προγράμματα gtkmm που είναι γραμμένα σε άλλα λειτουργικά όπως GNU/Linux μπορούν γενικά να μεταφερθούν στα Windows (και αντίστροφα) με λίγες τροποποιήσεις στην πηγή.

Η gtkmm προς το παρόν δουλεύει με τον MingW/μεταγλωττιστή GCC3.4 και την Microsoft Visual C++ 2005 ή μεταγενέστερες (συμπεριλαμβάνοντας τις ελεύθερα διαθέσιμες γρήγορες εκδόσεις) σε λειτουργικό Windows. Υπάρχει ένας εγκαταστάτης διαθέσιμος για gtkmm στην Microsoft Windows. Δείτε την https://wiki.gnome.org/Projects/gtkmm/MSWindows για οδηγίες χρήσης.

### Δόμηση της gtkmm σε Win32

Παρακαλούμε, δείτε https://wiki.gnome.org/Projects/gtkmm/MSWindows/BuildingGtkmm για οδηγίες δόμησης της gtkmm σε Windows.

## Εργασία με τον πηγαίο κώδικα gtkmm

Αν ενδιαφέρεστε να βοηθήσετε την ανάπτυξη της gtkmm, ή να διορθώσετε ένα σφάλμα στην gtkmm, θα χρειαστείτε προφανώς να δομήσετε την έκδοση ανάπτυξης της gtkmm. Όμως, δεν θα πρέπει να εγκαταστήσετε μια έκδοση ανάπτυξης πάνω στη σταθερή έκδοση. Αντίθετα, θα πρέπει να την εγκαταστήσετε δίπλα στην υπάρχουσα εγκατάσταση gtkmm, σε μια ξεχωριστή διαδρομή.

Ο πιο εύκολος τρόπος για να το κάνετε αυτό είναι η χρήση της jhbuild. Η jhbuild είναι ένα πρόγραμμα που διευκολύνει τη δόμηση λογισμικού GNOME υπολογίζοντας τις εξαρτήσεις και δομώντας τα πράγματα με τη σωστή σειρά. Αυτή η ενότητα θα σας δώσει μια σύντομη εξήγηση πώς να εγκαταστήσετε την jhbuild για να δομήσετε και να εγκαταστήσετε την gtkmm από το πηγαίο αποθετήριο (git). Για τις ενημερωμένες πληροφορίες της jhbuild, δείτε το εγχειρίδιο jhbuild. Αν χρειάζεστε βοήθεια χρησιμοποιώντας την jhbuild, θα πρέπει να ζητήσετε βοήθεια στην λίστα ταχυδρομείου gnome-love.

Σημειώστε ότι για τη δόμηση της gtkmm από το git, θα χρειαστείτε συχνά να δομήσετε όλες τις εξαρτήσεις από το git επίσης. Η jhbuild διευκολύνει από ότι κανονικά θα γινόταν, αλλά θα πάρει κάμποσο για να δομήσετε και να τις εγκαταστήσετε όλες. Θα αντιμετωπίσετε προφανώς προβλήματα δόμησης, αν και αυτά συνήθως διορθώνονται γρήγορα, αν τα αναφέρετε.

### Εγκατάσταση της jhbuild

To set up jhbuild, follow the basic installation instructions from the jhbuild manual. After you have installed jhbuild, you should copy the sample jhbuild configuration file into your home directory by executing the following command from the jhbuild directory:

    $ cp examples/sample.jhbuildrc ~/.jhbuildrc

The gtkmm module is defined in the `gnome-suites-core-deps-3.x.modules` moduleset, so edit your `.jhbuildrc` file and set your moduleset setting to the latest version e.g. like so:

    moduleset = 'gnome-suites-core-deps-3.12'

After setting the correct moduleset, you need to tell jhbuild which module or modules to build. To build gtkmm and all of its dependencies, set `modules` like so:

    modules = [ 'gtkmm' ]

Μπορείτε να δομήσετε αρκετές ενότητες ορίζοντας τη μεταβλητή `modules` σε ένα μεταπακέτο, π.χ. `meta-gnome-core`, ή καταχωρίζοντας περισσότερα από ένα ονόματα ενοτήτων. Η μεταβλητή `modules` καθορίζει ποιες ενότητες θα δομηθούν, όταν δεν ορίζετε ρητά τίποτα στη γραμμή εντολών. Μπορείτε πάντα να δομήσετε μια διαφορετική ομάδα ενοτήτων αργότερα ορίζοντας την στη γραμμή εντολών (π.χ. `jhbuild build gtkmm`).

Ορίζοντας ένα πρόθεμα

Από προεπιλογή, η διαμόρφωση της jhbuild ρυθμίζεται για να εγκαταστήσει όλο το λογισμικό που δομήθηκε με την jhbuild κάτω από το πρόθεμα `/opt/gnome`. Μπορείτε να επιλέξετε ένα διαφορετικό πρόθεμα, αλλά συνιστάται να κρατήσετε αυτό το πρόθεμα διαφορετικά από άλλο λογισμικό που έχετε ήδη εγκαταστήσει (μην το ορίσετε σε `/usr`!) Αν έχετε ακολουθήσει τις οδηγίες jhbuild, τότε αυτό το πρόθεμα ανήκει στον χρήστη σας, έτσι δεν χρειάζεται να εκτελέσετε την jhbuild ως `root`.

Όταν μεταφορτώσατε την jhbuild από το αποθετήριο git, παίρνετε έναν αριθμό αρχείων των `.modules`, ορίζοντας τις εξαρτήσεις μεταξύ ενοτήτων. Από προεπιλογή η jhbuild δεν χρησιμοποιεί τις μεταφορτωμένες εκδόσεις αυτών των αρχείων, αλλά διαβάζει τις τελευταίες εκδόσεις στο αποθετήριο git. Αυτό συνήθως θέλετε. Αν δεν το θέλετε, χρησιμοποιήστε τη μεταβλητή `use_local_modulesets` στο `.jhbuildrc`.

### Εγκατάσταση και χρήση της έκδοσης git της gtkmm

Once you've configured jhbuild as described above, building gtkmm should be relatively straightforward. The first time you run jhbuild, you should run the following sequence of commands to ensure that jhbuild has the required tools and verify that it is set up correctly:

    $ jhbuild bootstrap
    $ jhbuild sanitycheck

#### Εγκατάσταση της gtkmm με jhbuild

Αν όλα δούλεψαν σωστά, θα πρέπει να μπορείτε να δομήσετε την gtkmm και όλες τις εξαρτήσεις της από το git εκτελώντας την `jhbuild build` (ή, αν δεν ορίσατε την gtkmm στη μεταβλητή `modules`, με την εντολή `jhbuild build gtkmm`).

Αυτή η εντολή θα δομήσει και θα εγκαταστήσει μια σειρά ενοτήτων και θα πάρει προφανώς αρκετά την πρώτη φορά για να ολοκληρωθεί. Μετά την πρώτη φορά, όμως, θα πρέπει να πάτε λίγο γρηγορότερα, αφού χρειάζεται μόνο να αναδομήσετε τα αρχεία που αλλάξατε από την τελευταία δόμηση. Εναλλακτικά, αφού έχετε δομήσει και εγκαταστήσει την gtkmm την πρώτη φορά, μπορείτε να αναδομήσετε την gtkmm από μόνη της (χωρίς αναδόμηση όλων των εξαρτήσεων της) με την εντολή `jhbuild buildone gtkmm`.

#### Χρήση της έκδοσης git της gtkmm

Αφού έχετε εγκαταστήσει την έκδοση git της gtkmm, είσαστε έτοιμοι να ξεκινήσετε τη χρήση και τον πειραματισμό με αυτήν. Για να χρησιμοποιήσετε τη νέα έκδοση της gtkmm που μόλις εγκαταστήσατε, χρειάζεται να ορίσετε κάποιες μεταβλητές περιβάλλοντος έτσι ώστε το σενάριο `configure` σας να ξέρει πού θα βρει τις νέες βιβλιοθήκες. Ευτυχώς, η jhbuild προσφέρει μια εύκολη λύση σε αυτό το πρόβλημα. Η εκτέλεση της εντολής `jhbuild shell` θα ξεκινήσει έναν νέο φλοιό με ρυθμισμένες όλες τις σωστές μεταβλητές περιβάλλοντος. Τώρα αν ξαναρρυθμίσετε και δομήσετε το έργο σας όπως συνήθως κάνετε, πρέπει να το συνδέσετε με τις νέες εγκατεστημένες βιβλιοθήκες. Για επιστροφή στο προηγούμενό περιβάλλον σας, βγείτε απλά από τον φλοιό jhbuild.

Αφού έχετε δημιουργήσει το λογισμικό σας, θα χρειαστείτε να εκτελέσετε το πρόγραμμά σας μέσα σε περιβάλλον jhbuild επίσης. Για να το κάνετε αυτό, μπορείτε να χρησιμοποιήσετε πάλι την εντολή `jhbuild shell` για να ξεκινήσετε ένα νέο φλοιό με το εγκατεστημένο περιβάλλον jhbuild. Εναλλακτικά, μπορείτε να εκτελέσετε μια κι έξω την εντολή στο περιβάλλον jhbuild χρησιμοποιώντας την ακόλουθη εντολή: `jhbuild run command-name`. Σε αυτήν την περίπτωση, η εντολή θα εκτελεστεί με ορισμένες τις σωστές μεταβλητές περιβάλλοντος, αλλά θα επιστρέψει στο προηγούμενο περιβάλλον σας αφού εξέλθει το πρόγραμμα.

## Συσκευασία βιβλιοθηκών C με gmmproc

Η gtkmm χρησιμοποιεί το εργαλείο `gmmproc` για τη δημιουργία του περισσότερου πηγαίου κώδικά της, χρησιμοποιώντας αρχεία .defs που ορίζουν τις APIs των βιβλιοθηκών με βάση την GObject. Έτσι είναι αρκετά εύκολη η δημιουργία πρόσθετων συσκευαστών τεχνοτροπίας gtkmm ή άλλων βιβλιοθηκών με βάση glib/GObject.

Αυτό εμπεριέχει μια ποικιλία εργαλείων, μερικά από τα οποία ξεπερασμένα, αλλά τουλάχιστον δουλεύουν και χρησιμοποιήθηκαν με επιτυχία από αρκετά έργα.

### Η δομή δημιουργίας

Η παραγωγή του πηγαίου κώδικα για μια API συσκευαστή τεχνοτροπίας gtkmm απαιτεί τη χρήση εργαλείων όπως `gmmproc` και `generate_wrap_init.pl`. Θεωρητικά, μπορείτε να γράψετε τα δικά σας αρχεία δόμησης για να χρησιμοποιήσετε κατάλληλα, αλλά μια πολύ καλύτερη επιλογή είναι να χρησιμοποιήσετε την παρεχόμενη υποδομή δημιουργίας από την ενότητα mm-common. Για να ξεκινήσετε, βοηθά πολύ η επιλογή υπαρχουσών ενοτήτων σύνδεσης ως ένα παράδειγμα για να δείτε.

Για παράδειγμα, ας θεωρήσουμε ότι πακετάρουμε μια βιβλιοθήκη C που λέγεται libsomething. Παρέχει μια API με βάση GObject με επώνυμους τύπους, για παράδειγμα, SomeWidget και SomeStuff.

#### Αντιγραφή του έργου σκελετού

Typically our wrapper library would be called libsomethingmm. We can start by copying the skeleton source tree from the mm-common module.

      $ git clone git://git.gnome.org/mm-common
      $ cp -a mm-common/skeletonmm libsomethingmm

This provides a directory structure for the source .hg and .ccg files and the generated .h and .cc files, with `filelist.am` Automake include files that can specify the various files in use, in terms of generic Automake variables. The directory structure usually looks like this, after we have renamed the directories appropriately:

- `libsomethingmm`: The top-level directory.

  - `libsomething`: Contains the main include file and the pkg-config .pc file.

    - `src`: Contains .hg and .ccg source files.

    - `libsomethingmm`: Contains generated and hand-written .h and .cc files.

      - `private`: Contains generated `*_p.h` files.

As well as renaming the directories, we should rename some of the source files. For instance:

    $ for f in $(find libsomethingmm -depth -name '*skeleton*'); do \
        d="${f%/*}"; b="${f##*/}"; mv "$f" "$d/${b//skeleton/libsomething}"; \
      done

A number of the skeleton files must still be filled in with project-specific content later.

Σημειώστε ότι τα αρχεία που τελειώνουν σε `.in` θα χρησιμοποιηθούν για τη δημιουργία αρχείων με το ίδιο όνομα, αλλά χωρίς το επίθεμα `.in`, αντικαθιστώντας μερικές μεταβλητές με τις ενεργές τιμές κατά τη διάρκεια του σταδίου διαμόρφωσης.

#### Τροποποίηση αρχείων δόμησης

Τώρα επεξεργαζόμαστε τα αρχεία για να προσαρμόσουμε στις ανάγκες μας. Μπορείτε να προτιμήσετε τη χρήση ενός βοηθήματος πολλαπλού αρχείου αναζήτησης-αντικατάστασης για αυτό, όπως `regexxer`. Σημειώστε ότι σχεδόν όλα τα παρεχόμενα αρχεία με το πηγαίο δένδρο σκελετού περιέχουν κείμενο δεσμευτικού θέσης. Έτσι, οι αντικαταστάσεις πρέπει να εκτελεστούν καθολικά και να μην περιοριστούν στα αρχεία Automake και Autoconf.

Όλες οι αναφορές της `skeleton` πρέπει να αντικατασταθούν από το σωστό όνομα της βιβλιοθήκης C που συσκευάζεται, όπως "something" ή "libsomething". Με τον ίδιο τρόπο, όλα τα στιγμιότυπα της `SKELETON` πρέπει να αντικατασταθούν από "SOMETHING" ή "LIBSOMETHING" και όλες οι εμφανίσεις της `Skeleton` να αλλαχτούν σε "Something".

Παρόμοια, αντικαταστήστε όλα τα στιγμιότυπα της `Joe Hacker` με το όνομα του σκοπούμενου κατόχου πνευματικών δικαιωμάτων, που είσαστε προφανώς εσείς. Κάντε το ίδιο για τη διεύθυνση αλληλογραφίας `joe@example.com`.

##### configure.ac

In `configure.ac`,

- The `AC_CONFIG_SRCDIR()` line must mention a file in our source tree. We can edit this later if we don't yet know the names of any of the files that we will create.

- It is common for binding modules to track the version number of the library they are wrapping. So, for instance, if the C library is at version 1.23.4, then the initial version of the binding module would be 1.23.0. However, avoid starting with an even minor version number as that usually indicates a stable release.

- The `AC_CONFIG_HEADERS()` line is used to generate two or more configuration header files. The first header file in the list contains all configuration macros which are set during the configure run. The remaining headers in the list contain only a subset of configuration macros and their corresponding `config.h.in` file will not be autogenerated. The reason for this separation is that the namespaced configuration headers are installed with your library and define publically visible macros.

- The `AC_SUBST([SOMETHINGMM_MODULES], ['...'])` line may need to be modified to check for the correct dependencies.

- The `AC_CONFIG_FILES()` block must mention the correct directory names, as described above.

##### Αρχεία Makefile.am

Next we must adapt the various `Makefile.am` files:

- In `skeleton/src/Makefile.am` we must mention the correct values for the generic variables that are used elsewhere in the build system:

  `binding_name`

    The name of the library, such as libsomethingmm.

  `wrap_init_flags`

    Additional command-line flags passed to the `generate_wrap_init.pl` script, such as the C++ namespace and the parent directory prefix of include files.

- In `skeleton/skeletonmm/Makefile.am` we must mention the correct values for the generic variables that are used elsewhere in the build system:

  `lib_LTLIBRARIES`

    This variable must mention the correct library name, and this library name must be used to form the `_SOURCES`, `_LDFLAGS`, and `_LIBADD` variable names. It is permissible to use variables substituted by `configure` like `@SOMETHINGMM_API_VERSION@` as part of the variable names.

  `AM_CPPFLAGS`

    The command line options passed to the C preprocessor.

  `AM_CXXFLAGS`

    The command line options passed to the C++ compiler.

##### Δημιουργία αρχείων .hg και .ccg

Πρέπει τώρα να δημιουργήσουμε τα πρώτα μας αρχεία `.hg` και `.ccg`, για να συσκευάσουμε ένα από τα αντικείμενα στη βιβλιοθήκη C. Ένα ζεύγος παραδείγματος πηγαίων αρχείων που ήδη υπάρχει: `skeleton.ccg` και `skeleton.hg`. Δημιουργήστε αντίγραφα αυτών των αρχείων όπως χρειάζεται.

Πρέπει να αναφέρουμε όλα τα αρχεία μας `.hg` και `.ccg` στο αρχείο `skeleton/src/filelist.am`, τυπικά στη μεταβλητή `files_hg`.

Οποιαδήποτε πρόσθετα μη δημιουργούμενα πηγαία αρχεία `.h` και `.cc` μπορεί να τοποθετηθούν στο `skeleton/skeletonmm/` και καταχωρίζονται στο `skeleton/skeletonmm/filelist.am`, τυπικά στις μεταβλητές `files_extra_h` και `files_extra_cc`.

Στην ενότητα .hg and .ccg files μπορείτε να μάθετε για τη χρησιμοποιούμενη σύνταξη σε αυτά τα αρχεία.

### Δημιουργία των αρχείων .defs.

The `.defs` files are text files, in a lisp format, that describe the API of a C library, including its

- objects (GObjects, widgets, interfaces, boxed-types and plain structs)

- functions

- enums

- signals

- properties

- vfuncs

At the moment, we have separate tools for generating different parts of these `.defs`, so we split them up into separate files. For instance, in the `gtk/src` directory of the gtkmm sources, you will find these files:

`gtk.defs`

  Includes the other files.

`gtk_methods.defs`

  Objects and functions.

`gtk_enums.defs`

  Enumerations.

`gtk_signals.defs`

  Signals and properties.

`gtk_vfuncs.defs`

  vfuncs (function pointer member fields in structs), written by hand.

Το σενάριο `skeletonmm/codegen/generate_defs_and_docs.sh` δημιουργεί όλα τα αρχεία `.defs` και το αρχείο `*_docs.xml`, που περιγράφηκε στην ενότητα τεκμηρίωση.

#### Δημιουργία των μεθόδων .defs

This `.defs` file describes objects and their functions. It is generated by the `h2def.py` script which you can find in glibmm's `tools/defs_gen` directory. For instance,

    $ ./h2def.py /usr/include/gtk-3.0/gtk/*.h > gtk_methods.defs

#### Δημιουργία των απαριθμήσεων .defs

This `.defs` file describes enum types and their possible values. It is generated by the `enum.pl` script which you can find in glibmm's `tools` directory. For instance,

    $ ./enum.pl /usr/include/gtk-3.0/gtk/*.h > gtk_enums.defs

#### Δημιουργώντας τα σήματα και τις ιδιότητες .defs

This `.defs` file describes signals and properties. It is generated by the special `generate_extra_defs` utility that is in every wrapping project, such as `gtkmm/tools/extra_defs_gen/`. For instance

    $ cd tools/extra_defs_gen
    $ ./generate_extra_defs > gtk_signals.defs

Πρέπει να επεξεργαστείτε τον πηγαίο κώδικα του δικού σας εργαλείου `generate_extra_defs` για να δημιουργήσετε το `.defs` για τους τύπους GObject C που θέλετε να συσκευάσετε. Στο πηγαίο δένδρο σκελετού, το αρχείο πηγής ονομάζεται `codegen/extradefs/generate_extra_defs_skeleton.cc`. Αν δεν έχει ήδη γίνει, το αρχείο πρέπει να μετονομαστεί, με το βασικό όνομα της νέας σύνδεσης που αντικαθίσταται με το δεσμευτικό θέσης `skeleton`. Το αρχείο `codegen/Makefile.am` πρέπει επίσης να αναφέρει το νέο πηγαίο όνομα αρχείου.

Then edit the `.cc` file to specify the correct types. For instance, your `main()` function might look like this:

    #include <libsomething.h>

    int main(int, char**)
    {
      something_init();

      std::cout << get_defs(SOME_TYPE_WIDGET)
                << get_defs(SOME_TYPE_STUFF);
      return 0;
    }

#### Συγγραφή των vfuncs .defs

Αυτό το αρχείο `.defs` περιγράφει εικονικές συναρτήσεις (vfuncs). Πρέπει να γραφτεί με το χέρι. Δεν υπάρχει αρχείο σκελετού `skeleton/src/skeleton_vfunc.defs` για να ξεκινήσετε. Μπορείτε να κοιτάξετε επίσης στην gtkmm και στο αρχείο της `gtk/src/gtk_vfuncs.defs`.

### Τα αρχεία .hg και .ccg

Τα πηγαία αρχεία .hg και .ccg είναι πολύ παρόμοια. με τα πηγαία αρχεία .h και .cc της C++, αλλά περιέχουν πρόσθετες μακροεντολές, όπως `_CLASS_GOBJECT()` και `_WRAP_METHOD()`, από τις οποίες η `gmmproc` δημιουργεί κατάλληλο πηγαίο κώδικα C++, συνήθως στην ίδια θέση στην κεφαλίδα. Οποιοσδήποτε πρόσθετος πηγαίος κώδικας C++ θα αντιγραφεί κατά λέξη στο αντίστοιχο αρχείο .h ή .cc.

A .hg file will typically include some headers and then declare a class, using some macros to add API or behaviour to this class. For instance, gtkmm's `button.hg` looks roughly like this:

    #include <gtkmm/bin.h>
    #include <gtkmm/activatable.h>
    _DEFS(gtkmm,gtk)
    _PINCLUDE(gtkmm/private/bin_p.h)

    namespace Gtk
    {

    class Button
      : public Bin,
        public Activatable
    {
      _CLASS_GTKOBJECT(Button,GtkButton,GTK_BUTTON,Gtk::Bin,GtkBin)
      _IMPLEMENTS_INTERFACE(Activatable)
    public:

      _CTOR_DEFAULT
      explicit Button(const Glib::ustring& label, bool mnemonic = false);

      _WRAP_METHOD(void set_label(const Glib::ustring& label), gtk_button_set_label)

      ...

      _WRAP_SIGNAL(void clicked(), "clicked")

      ...

      _WRAP_PROPERTY("label", Glib::ustring)
    };

    } // namespace Gtk

The macros in this example do the following:

`_DEFS()`

  Specifies the destination directory for generated sources, and the name of the main .defs file that `gmmproc` should parse.

`_PINCLUDE()`

  Tells `gmmproc` to include a header in the generated private/button_p.h file.

`_CLASS_GTKOBJECT()`

  Tells `gmmproc` to add some typedefs, constructors, and standard methods to this class, as appropriate when wrapping a widget.

`_IMPLEMENTS_INTERFACE()`

  Tells `gmmproc` to add initialization code for the interface.

`_CTOR_DEFAULT`

  Add a default constructor.

`_WRAP_METHOD()`, `_WRAP_SIGNAL()`, `_WRAP_PROPERTY()`, and `_WRAP_CHILD_PROPERTY()`

  Add methods to wrap parts of the C API.

The .h and .cc files will be generated from the .hg and .ccg files by processing them with `gmmproc` like so, though this happens automatically when using the above build structure:

    $ cd gtk/src
    $ /usr/lib/glibmm-2.4/proc/gmmproc -I ../../tools/m4 --defs . button . ./../gtkmm

Σημειώστε ότι παρείχαμε την `gmmproc` με τη διαδρομή στα αρχεία μετατροπής .m4, τη διαδρομή στο αρχείο .defs, το όνομα ενός αρχείου .hg, τον πηγαίο κατάλογο και τον κατάλογο προορισμού.

Θα πρέπει να αποφύγετε να συμπεριλάβετε την κεφαλίδα C της κεφαλίδας σας C++, για να αποφύγετε τη μόλυνση του καθολικού χώρου ονόματος και την εξαγωγή περιττών δημόσιων API. Αλλά θα χρειαστείτε να συμπεριλάβετε τις απαραίτητες κεφαλίδες C από το αρχείο σας .ccg.

Οι μακροεντολές εξηγούνται πιο λεπτομερώς στις παρακάτω ενότητες.

#### Μετατροπές m4

The macros that you use in the .hg and .ccg files often need to know how to convert a C++ type to a C type, or vice-versa. gmmproc takes this information from an .m4 file in your `tools/m4/` directory. This allows it to call a C function in the implementation of your C++ method, passing the appropriate parameters to that C functon. For instance, this tells gmmproc how to convert a GtkTreeView pointer to a Gtk::TreeView pointer:

    _CONVERSION(`GtkTreeView*',`TreeView*',`Glib::wrap($3)')

Η `$3` θα αντικατασταθεί από το όνομα παραμέτρου όταν αυτή η μετατροπή χρησιμοποιείται από την gmmproc.

Some extra macros make this easier and consistent. Look in gtkmm's .m4 files for examples. For instance:

    _CONVERSION(`PrintSettings&',`GtkPrintSettings*',__FR2P)
    _CONVERSION(`const PrintSettings&',`GtkPrintSettings*',__FCR2P)
    _CONVERSION(`const Glib::RefPtr<Printer>&',`GtkPrinter*',__CONVERT_REFPTR_TO_P($3))

#### Αρχικοποιήσεις m4

Συχνά με τις μεθόδους συσκευασίας, είναι επιθυμητό να αποθηκεύσετε την επιστροφή της συνάρτησης C σε αυτό που λέγεται μια παράμετρος εξόδου. Σε αυτήν την περίπτωση, η μέθοδος C++ επιστρέφει τον void, αλλά μια παράμετρος εξόδου στην οποία αποθηκεύεται η τιμή της συνάρτησης C συμπεριλαμβάνεται στη λίστα ορισμάτων της μεθόδου C++. Η gmmproc επιτρέπει τέτοια λειτουργικότητα, αλλά οι κατάλληλες μακροεντολές αρχικοποίησης πρέπει να συμπεριληφθούν για να πουν στην gmmproc πώς να αρχικοποιήσετε την παράμετρο C++ από την επιστροφή της συνάρτησης C.

For example, if there was a C function that returned a GtkWidget* and for some reason, instead of having the C++ method also return the widget, it was desirable to have the C++ method place the widget in a specified output parameter, an initialization macro such as the following would be necessary:

    _INITIALIZATION(`Gtk::Widget&',`GtkWidget*',`$3 = Glib::wrap($4)')

Η `$3` θα αντικατασταθεί από το όνομα παραμέτρου εξόδου της μεθόδου C++ και η `$4` θα αντικατασταθεί από την επιστροφή της συνάρτησης C όταν αυτή η αρχικοποίηση χρησιμοποιείται από την gmmproc. Για ευκολία, η `$1` θα αντικατασταθεί επίσης από τον τύπο C++ χωρίς το συμπλεκτικό (&) και η `$2` θα αντικατασταθεί από τον τύπο C.

#### Μακροεντολές κλάσης

Η μακροεντολή κλάσης δηλώνει την ίδια την κλάση και τη σχέση της με τον υποκείμενο τύπο C. Δημιουργεί κάποιους εσωτερικούς κατασκευαστές, το μέλος `gobject_`, ορισμούς τύπους, τα στοιχεία πρόσβασης `gobj()`, καταχώριση τύπου και τη μέθοδο `Glib::wrap()` μεταξύ άλλων.

Άλλες μακροεντολές, όπως `_WRAP_METHOD()` και `_WRAP_SIGNAL()` μπορούν να χρησιμοποιηθούν μόνο μετά από μια κλήση στη μακροεντολή `_CLASS_*`.

##### _CLASS_GOBJECT

Αυτή η μακροεντολή δηλώνει έναν συσκευαστή για έναν τύπο που παράγεται από την GObject, αλλά του οποίου ο συσκευαστής δεν παράγεται από την Gtk::Object.

`_CLASS_GOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )`

For instance, from `accelgroup.hg`:

    _CLASS_GOBJECT(AccelGroup, GtkAccelGroup, GTK_ACCEL_GROUP, Glib::Object, GObject)

##### _CLASS_GTKOBJECT

Αυτή η μακροεντολή δηλώνει έναν συσκευαστή για έναν τύπο του οποίου ο συσκευαστής παράγεται από την Gtk::Object, όπως ένα γραφικό συστατικό ή διάλογο.

`_CLASS_GTKOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )`

For instance, from `button.hg`:

    _CLASS_GTKOBJECT(Button, GtkButton, GTK_BUTTON, Gtk::Bin, GtkBin)

Θα χρησιμοποιήσουμε τυπικά αυτή τη μακροεντολή όταν η κλάση παράγεται ήδη από την Gtk::Object. Για παράδειγμα, θα την χρησιμοποιήσετε όταν συσκευάζετε ένα γραφικό συστατικό GTK+, επειδή η Gtk::Widget παράγεται από Gtk::Object.

Μπορείτε επίσης να παράξετε κλάσεις μη γραφικού συστατικού από Gtk::Object έτσι ώστε να μπορεί να χρησιμοποιηθεί χωρίς Glib::RefPtr. Για παράδειγμα, μπορούν έπειτα να αρχικοποιηθούν με `Gtk::manage()` ή στη στοίβα ως μεταβλητή μέλους. Αυτό είναι βολικό, αλλά θα πρέπει να χρησιμοποιήσετε αυτό μόνον όταν είσαστε σίγουροι ότι η αληθινή μέτρηση αναφορών δεν χρειάζεται. Το θεωρούμε χρήσιμο για γραφικά συστατικά.

##### _CLASS_BOXEDTYPE

Αυτή η μακροεντολή δηλώνει έναν συσκευαστή για μια δομή μη GObject, καταχωρισμένη με `g_boxed_type_register_static()`.

`_CLASS_BOXEDTYPE( C++ class, C class, new function, copy function, free function )`

For instance, from Gdk::RGBA:

    _CLASS_BOXEDTYPE(RGBA, GdkRGBA, NONE, gdk_rgba_copy, gdk_rgba_free)

##### _CLASS_BOXEDTYPE_STATIC

Αυτή η μακροεντολή δηλώνει έναν συσκευαστή για μια απλή μεταβιβάσιμη δομή όπως GdkRectangle. Είναι παρόμοια με την `_CLASS_BOXEDTYPE`, αλλά η δομή C δεν παραχωρείται δυναμικά.

`_CLASS_BOXEDTYPE_STATIC( C++ class, C class )`

For instance, for Gdk::Rectangle:

    _CLASS_BOXEDTYPE_STATIC(Rectangle, GdkRectangle)

##### _CLASS_OPAQUE_COPYABLE

Αυτή η μακροεντολή δηλώνει έναν συσκευαστή για μια αδιαφανή δομή που έχει ελεύθερες συναρτήσεις και συναρτήσεις αντιγραφής. Οι νέες και ελεύθερες συναρτήσεις καθώς και οι συναρτήσεις αντιγραφής θα χρησιμοποιηθούν για αρχικοποίηση του προεπιλεγμένου κατασκευαστή, για αντιγραφή κατασκευαστή και καταστροφέα.

`_CLASS_OPAQUE_COPYABLE( C++ class, C class, new function, copy function, free function )`

For instance, from Glib::Checksum:

    _CLASS_OPAQUE_COPYABLE(Checksum, GChecksum, NONE, g_checksum_copy, g_checksum_free)

##### _CLASS_OPAQUE_REFCOUNTED

Αυτή η μακροεντολή δηλώνει έναν συσκευαστή για μια αδιαφανή δομή μετρημένης αναφοράς. Ο συσκευαστής C++ δεν μπορεί να είναι άμεσα αρχικοποιημένος και μπορεί μόνο να χρησιμοποιηθεί με την Glib::RefPtr.

`_CLASS_OPAQUE_REFCOUNTED( C++ class, C class, new function, ref function, unref function )`

For instance, for Pango::Coverage:

    _CLASS_OPAQUE_REFCOUNTED(Coverage, PangoCoverage, pango_coverage_new, pango_coverage_ref, pango_coverage_unref)

##### _CLASS_GENERIC

Αυτή η μακροεντολή μπορεί να χρησιμοποιηθεί για να συσκευάσει δομές που δεν προσαρμόζονται σε οποιαδήποτε ειδική κατηγορία.

`_CLASS_GENERIC( C++ class, C class )`

For instance, for Pango::AttrIter:

    _CLASS_GENERIC(AttrIter, PangoAttrIterator)

##### _CLASS_INTERFACE

Αυτή η μακροεντολή δηλώνει έναν συσκευαστή για έναν τύπο που παράγεται από GTypeInterface.

`_CLASS_INTERFACE( C++ class, C class, C casting macro, C interface struct, Base C++ class (optional), Base C class (optional) )`

For instance, from `celleditable.hg`:

    _CLASS_INTERFACE(CellEditable, GtkCellEditable, GTK_CELL_EDITABLE, GtkCellEditableIface)

Two extra parameters are optional, for the case that the interface derives from another interface, which should be the case when the GInterface has another GInterface as a prerequisite. For instance, from `loadableicon.hg`:

    _CLASS_INTERFACE(LoadableIcon, GLoadableIcon, G_LOADABLE_ICON, GLoadableIconIface, Icon, GIcon)

#### Μακροεντολές κατασκευαστή

Οι μακροεντολές `_CTOR_DEFAULT()` και `_WRAP_CTOR()` προσθέτουν κατασκευαστές συσκευάζοντας τις συγκεκριμένες συναρτήσεις C `*_new()`. Αυτές οι μακροεντολές θεωρούν ότι το αντικείμενο C έχει ιδιότητες με τα ίδια ονόματα όπως οι παράμετροι συνάρτησης, όπως συνήθως συμβαίνει, έτσι ώστε να μπορεί να παράσχει τις παραμέτρους άμεσα σε μια κλήση `g_object_new()`. Αυτοί οι κατασκευαστές στην πραγματικότητα δεν καλούν ποτέ τις συναρτήσεις C `*_new()`, επειδή η gtkmm πρέπει στην πραγματικότητα να αρχικοποιήσει παράγωγους GTypes και οι συναρτήσεις C `*_new()` νοούνται μόνο ως συναρτήσεις διευκόλυνσης για προγραμματιστές C.

When using `_CLASS_GOBJECT()`, the constructors should be protected (rather than public) and each constructor should have a corresponding `_WRAP_CREATE()` in the public section. This prevents the class from being instantiated without using a RefPtr. For instance:

    class TextMark : public Glib::Object
    {
      _CLASS_GOBJECT(TextMark, GtkTextMark, GTK_TEXT_MARK, Glib::Object, GObject)

    protected:
      _WRAP_CTOR(TextMark(const Glib::ustring& name, bool left_gravity = true), gtk_text_mark_new)

    public:
      _WRAP_CREATE(const Glib::ustring& name, bool left_gravity = true)

##### _CTOR_DEFAULT

Αυτή η μακροεντολή δημιουργεί έναν προεπιλεγμένο κατασκευαστή χωρίς ορίσματα.

##### _WRAP_CTOR

Αυτή η μακροεντολή δημιουργεί έναν κατασκευαστή με ορίσματα, ισοδύναμο με μια συνάρτηση C `*_new()`. Στην πραγματικότητα δεν καλεί τη συνάρτηση `*_new()`, αλλά θα δημιουργήσει απλά έναν ισοδύναμο κατασκευαστή με τους ίδιους τύπους ορίσματος. Παίρνει μια υπογραφή κατασκευαστή C++ και ένα όνομα συνάρτησης C.

It also takes an optional extra argument:

errthrow

  This tells gmmproc that the C `*_new()` has a final GError** parameter which should be ignored.

##### Κατασκευαστές κωδικοποίησης με το χέρι

When a constructor must be partly hand written because, for instance, the `*_new()` C function's parameters do not correspond directly to object properties, or because the `*_new()` C function does more than call `g_object_new()`, the `_CONSTRUCT()` macro may be used in the .ccg file to save some work. The `_CONSTRUCT` macro takes a series of property names and values. For instance, from `button.ccg`:

    Button::Button(const Glib::ustring& label, bool mnemonic)
    :
      _CONSTRUCT("label", label.c_str(), "use_underline", gboolean(mnemonic))
    {}

#### Macros that suppress generation of some code

Some macros suppress the generation of some code when they are used after a `_CLASS_*` macro. Some suppress the definition in the generated .cc file, others suppress both the declaration in the .h file and the definition in the .cc file.

##### _CUSTOM_DEFAULT_CTOR

Suppresses declaration and definition of default constructor in `_CLASS_BOXEDTYPE`, `_CLASS_BOXEDTYPE_STATIC` and `_CLASS_OPAQUE_COPYABLE`.

##### _CUSTOM_CTOR_CAST

Suppresses declaration and definition of the constructor that takes a pointer to the wrapped C object in `_CLASS_BOXEDTYPE` and `_CLASS_BOXEDTYPE_STATIC`.

Suppresses definition of the constructor that takes a pointer to the wrapped C object in `_CLASS_GOBJECT`, `_CLASS_GTKOBJECT`, `_CLASS_INTERFACE` and `_CLASS_OPAQUE_COPYABLE`.

##### _CUSTOM_DTOR

Suppresses definition of destructor in `_CLASS_GOBJECT` and `_CLASS_GTKOBJECT`.

##### _CUSTOM_WRAP_NEW

Suppresses definition of `Glib::wrap_new()` function in `_CLASS_GOBJECT`.

##### _CUSTOM_WRAP_FUNCTION

Suppresses definition of `Glib::wrap()` function in `_CLASS_GOBJECT`.

##### _NO_WRAP_FUNCTION

Suppresses declaration and definition of `Glib::wrap()` function in `_CLASS_GOBJECT`, `_CLASS_BOXEDTYPE`, `_CLASS_BOXEDTYPE_STATIC`, `_CLASS_OPAQUE_COPYABLE` and `_CLASS_INTERFACE`.

#### Μακροεντολές μεθόδου

##### _WRAP_METHOD

Αυτή η μακροεντολή παράγει τη μέθοδο C++ για να συσκευάσει μια συνάρτηση C.

`_WRAP_METHOD( C++ method signature, C function name)`

For instance, from `entry.hg`:

    _WRAP_METHOD(void set_text(const Glib::ustring& text), gtk_entry_set_text)

Η συνάρτηση C (π.χ. `gtk_entry_set_text`) περιγράφεται πληρέστερα στο αρχείο .defs και τα αρχεία `convert*.m4` περιέχουν την απαραίτητη μετατροπή από τον τύπο παραμέτρου C++ στον τύπο παραμέτρου C. Αυτή η μακροεντολή επίσης παράγει σχόλια τεκμηρίωσης doxygen με βάση τα αρχεία `*_docs.xml` και `*_docs_override.xml`.

There are some optional extra arguments:

refreturn

  Do an extra `reference()` on the return value, in case the C function does not provide a reference.

errthrow

  Use the last GError** parameter of the C function to throw an exception.

deprecated ["<text>"]

  Puts the generated code in #ifdef blocks. Text about the deprecation can be specified as an optional parameter.

constversion

  Just call the non-const version of the same function, instead of generating almost duplicate code.

newin "<version>"

  Adds a @newin Doxygen command to the documentation, or replaces the @newin command generated from the C documentation.

ifdef <identifier>

  Puts the generated code in #ifdef blocks.

slot_name <parameter_name>

  Specifies the name of the slot parameter of the method, if it has one. This enables `gmmproc` to generate code to copy the slot and pass the copy on to the C function in its final `gpointer user_data` parameter. The `slot_callback` option must also be used to specify the name of the glue callback function to also pass on to the C function.

slot_callback <function_name>

  Used in conjunction with the `slot_name` option to specify the name of the glue callback function that handles extracting the slot and then calling it. The address of this callback is also passed on to the C function that the method wraps.

no_slot_copy

  Tells `gmmproc` not to pass a copy of the slot to the C function, if the method has one. Instead the slot itself is passed. The slot parameter name and the glue callback function must have been specified with the `slot_name` and `slot_callbback` options respectively.

Selecting which C++ types should be used is also important when wrapping C API. Though it's usually obvious what C++ types should be used in the C++ method, here are some hints:

- Objects used via RefPtr: Pass the RefPtr as a const reference. For instance, `const Glib::RefPtr<Gtk::FileFilter>& filter`.

- Const Objects used via RefPtr: If the object should not be changed by the function, then make sure that the object is const, even if the RefPtr is already const. For instance, `const Glib::RefPtr<const Gtk::FileFilter>& filter`.

- Wrapping GList* and GSList* parameters: First, you need to discover what objects are contained in the list's data field for each item, usually by reading the documentation for the C function. The list can then be wrapped by a std::vector type. For instance, `std::vector< Glib::RefPtr<Gdk::Pixbuf> >`. You may need to define a Traits type to specify how the C and C++ types should be converted.

- Wrapping GList* and GSList* return types: You must discover whether the caller should free the list and whether it should release the items in the list, again by reading the documentation of the C function. With this information you can choose the ownership (none, shallow or deep) for the m4 conversion rule, which you should probably put directly into the .hg file because the ownership depends on the function rather than the type. For instance:

      #m4 _CONVERSION(`GSList*',`std::vector<Widget*>',`Glib::SListHandler<Widget*>::slist_to_vector($3, Glib::OWNERSHIP_SHALLOW)')

##### _WRAP_METHOD_DOCS_ONLY

Αυτή η μακροεντολή είναι παρόμοια με την `_WRAP_METHOD()`, αλλά δημιουργεί μόνο την τεκμηρίωση για τη μέθοδο C++ που συσκευάζει μια συνάρτηση C. Χρησιμοποιήστε το όταν πρέπει να κωδικοποιήσετε με το χέρι τη μέθοδο, αλλά θέλετε να χρησιμοποιήσετε την τεκμηρίωση που πρέπει να δημιουργηθεί αν η μέθοδος είχε δημιουργηθεί.

`_WRAP_METHOD_DOCS_ONLY(C function name)`

For instance, from `container.hg`:

    _WRAP_METHOD_DOCS_ONLY(gtk_container_remove)

There are some optional extra arguments:

errthrow

  Excludes documentation of the last GError** parameter of the C function.

newin "<version>"

  Adds a @newin Doxygen command to the documentation, or replaces the @newin command generated from the C documentation.

##### _IGNORE, _IGNORE_SIGNAL, _IGNORE_PROPERTY, _IGNORE_CHILD_PROPERTY

`gmmproc` will warn you on stdout about functions, signals, properties and child properties that you have forgotten to wrap, helping to ensure that you are wrapping the complete API. But if you don't want to wrap some functions, signals, properties or child properties, or if you chose to hand-code some methods then you can use the _IGNORE(), _IGNORE_SIGNAL(), _IGNORE_PROPERTY() or _IGNORE_CHILD_PROPERTY() macro to make `gmmproc` stop complaining.

    _IGNORE(C function name 1, C function name 2, etc)
    _IGNORE_SIGNAL(C signal name 1, C signal name 2, etc)
    _IGNORE_PROPERTY(C property name 1, C property name 2, etc)
    _IGNORE_CHILD_PROPERTY(C child property name 1, C child property name 2, etc)

For instance, from `flowbox.hg`:

    _IGNORE(gtk_flow_box_set_filter_func, gtk_flow_box_set_sort_func)
    _IGNORE_SIGNAL(activate-cursor-child, toggle-cursor-child, move-cursor)

##### _WRAP_SIGNAL

Αυτή η μακροεντολή παράγει το σήμα τεχνοτροπίας libsigc++ της C++ για να συσκευάσει ένα σήμα GObject. Στην πραγματικότητα παράγει μια δημόσια μέθοδο στοιχείου πρόσβασης, όπως `signal_clicked()`, που επιστρέφει ένα αντικείμενο μεσολάβησης. Η `gmmproc` χρησιμοποιεί το αρχείο .defs για να ανακαλύψει τους τύπους παραμέτρου C και το .m4 μετατρέπει αρχεία για να ανακαλύψει τον κατάλληλο τύπο μετατροπών.

`_WRAP_SIGNAL( C++ signal handler signature, C signal name)`

For instance, from `button.hg`:

    _WRAP_SIGNAL(void clicked(),"clicked")

Τα σήματα συνήθως έχουν δείκτες συνάρτησης στη δομή GTK, με μια αντίστοιχη τιμή απαρίθμησης και μια `g_signal_new()` στο αρχείο .c.

There are some optional extra arguments:

no_default_handler

  Do not generate an `on_something()` virtual method to allow easy overriding of the default signal handler. Use this when adding a signal with a default signal handler would break the ABI by increasing the size of the class's virtual function table.

custom_default_handler

  Generate a declaration of the `on_something()` virtual method in the `.h` file, but do not generate a definition in the `.cc` file. Use this when you must generate the definition by hand.

custom_c_callback

  Do not generate a C callback function for the signal. Use this when you must generate the callback function by hand.

refreturn

  Do an extra `reference()` on the return value of the `on_something()` virtual method, in case the C function does not provide a reference.

deprecated ["<text>"]

  Puts the generated code in #ifdef blocks. Text about the deprecation can be specified as an optional parameter.

newin "<version>"

  Adds a @newin Doxygen command to the documentation, or replaces the @newin command generated from the C documentation.

ifdef <identifier>

  Puts the generated code in #ifdef blocks.

exception_handler <method_name>

  Allows to use custom exception handler instead of default one. Exception might be rethrown by user-defined handler, and it will be caught by default handler.

detail_name <parameter_name>

  Adds a const Glib::ustring& parameter to the signal_something() method. Use it, if the signal accepts a detailed signal name, i.e. if the underlying C code registers the signal with the `G_SIGNAL_DETAILED` flag.

two_signal_methods

  Used in conjunction with the `detail_name` option to generate two signal_something() methods, one without a parameter and one with a parameter without a default value. With only the `detail_name` option one method is generated, with a parameter with default value. Use the `two_signal_methods` option, if it's necessary in order to preserve ABI.

##### _WRAP_PROPERTY

Αυτή η μακροεντολή δημιουργεί μια μέθοδο C++ για συσκευασία μιας ιδιότητας GObject C. Πρέπει να ορίσετε το όνομα της ιδιότητας και τον επιθυμητό τύπο C++ για την ιδιότητα. Η `gmmproc` χρησιμοποιεί το αρχείο .defs για να ανακαλύψει τον τύπο C και να μετατρέψει τα αρχεία .m4 για να βρει κατάλληλες μετατροπές τύπου.

`_WRAP_PROPERTY(C property name, C++ type)`

For instance, from `button.hg`:

    _WRAP_PROPERTY("label", Glib::ustring)

There are some optional extra arguments:

deprecated ["<text>"]

  Puts the generated code in #ifdef blocks. Text about the deprecation can be specified as an optional parameter.

newin "<version>"

  Adds a @newin Doxygen command to the documentation, or replaces the @newin command generated from the C documentation.

##### _WRAP_VFUNC

Αυτή η μακροεντολή παράγει τη μέθοδο C++ για να συσκευάσει μια εικονική συνάρτηση C.

`_WRAP_VFUNC( C++ method signature, C function name)`

For instance, from `widget.hg`:

    _WRAP_VFUNC(SizeRequestMode get_request_mode() const, get_request_mode)

The C function (e.g. `get_request_mode`) is described more fully in the `*_vfuncs.defs` file, and the `convert*.m4` files contain the necessary conversion from the C++ parameter type to the C parameter type. Conversions can also be written in the .hg file. Virtual functions often require special conversions that are best kept local to the .hg file where they are used.

There are some optional extra arguments:

refreturn

  Do an extra `reference()` on the return value of the `something_vfunc()` function, in case the virtual C function does not provide a reference.

refreturn_ctype

  Do an extra `reference()` on the return value of an overridden `something_vfunc()` function in the C callback function, in case the calling C function expects it to provide a reference.

keep_return

  Keep a copy of the return value in the C callback function, in case the calling C function does not expect to get its own reference.

errthrow

  Use the last GError** parameter of the C virtual function (if there is one) to throw an exception.

custom_vfunc

  Do not generate a definition of the vfunc in the `.cc` file. Use this when you must generate the vfunc by hand.

custom_vfunc_callback

  Do not generate a C callback function for the vfunc. Use this when you must generate the callback function by hand.

ifdef <identifier>

  Puts the generated code in #ifdef blocks.

slot_name <parameter_name>

  Specifies the name of the slot parameter of the method, if it has one. This enables `gmmproc` to generate code to copy the slot and pass the copy on to the C function in its final `gpointer user_data` parameter. The `slot_callback` option must also be used to specify the name of the glue callback function to also pass on to the C function.

slot_callback <function_name>

  Used in conjunction with the `slot_name` option to specify the name of the glue callback function that handles extracting the slot and then calling it. The address of this callback is also passed on to the C function that the method wraps.

no_slot_copy

  Tells `gmmproc` not to pass a copy of the slot to the C function, if the method has one. Instead the slot itself is passed. The slot parameter name and the glue callback function must have been specified with the `slot_name` and `slot_callbback` options respectively.

return_value <value>

  Defines non-default return value.

exception_handler <method_name>

  Allows to use custom exception handler instead of default one. Exception might be rethrown by user-defined handler, and it will be caught by default handler.

Ένας κανόνας στον οποίον ενδέχεται να υπάρχουν εξαιρέσεις: Αν η εικονική συνάρτηση C επιστρέφει έναν δείκτη σε ένα αντικείμενο που παράγεται από την GObject, δηλαδή ένα αντικείμενο με μετρημένες αναφορές, τότε η εικονική συνάρτηση C++ θα επιστρέψει ένα αντικείμενο Glib::RefPtr<>. Ένα από τα πρόσθετα ορίσματα refreturn ή refreturn_ctype απαιτείται.

##### _WRAP_CHILD_PROPERTY

This macro generates the C++ method to wrap a GtkContainer child property. (See GtkContainer for more information about child properties). Similarly to _WRAP_PROPERTY, you must specify the property name and the wanted C++ type for the property. `gmmproc` uses the .defs file to discover the C type and the .m4 convert files to discover appropriate type conversions.

`_WRAP_CHILD_PROPERTY(C child property name, C++ type)`

For instance, from `notebook.hg`:

    _WRAP_CHILD_PROPERTY("tab-expand", bool)

_WRAP_CHILD_PROPERTY() accepts the same optional arguments as _WRAP_PROPERTY().

#### Άλλες μακροεντολές

##### _IMPLEMENTS_INTERFACE

Αυτή η μακροεντολή δημιουργεί έναν κώδικα αρχικοποίησης για τη διεπαφή.

`_IMPLEMENTS_INTERFACE(C++ interface name)`

For instance, from `button.hg`:

    _IMPLEMENTS_INTERFACE(Activatable)

There is one optional extra argument:

ifdef <identifier>

  Puts the generated code in #ifdef blocks.

##### _WRAP_ENUM

Αυτή η μακροεντολή δημιουργεί μια απαρίθμηση C++ για να συσκευάσει μια απαρίθμηση C. Πρέπει να ορίσετε το επιθυμητό όνομα C++ και το όνομα της υποκείμενης απαρίθμησης C.

For instance, from `enums.hg`:

    _WRAP_ENUM(WindowType, GtkWindowType)

Αν η απαρίθμηση δεν είναι μια GType, πρέπει να περάσετε μια τρίτη παράμετρο NO_GTYPE. Αυτή είναι η περίπτωση όταν δεν υπάρχει συνάρτηση `*_get_type()` για την απαρίθμηση C, αλλά προσέξτε ότι δεν χρειάζεται μόνο να συμπεριλάβετε μια πρόσθετη κεφαλίδα για αυτήν τη συνάρτηση. Θα πρέπει επίσης να στείλετε ένα σφάλμα στην API C, επειδή όλες οι απαριθμήσεις πρέπει να καταχωριστούν ως GTypes.

_WRAP_ENUM() accepts the optional `newin` parameter. See _WRAP_METHOD().

For example, from `icontheme.hg`:

    _WRAP_ENUM(IconLookupFlags, GtkIconLookupFlags, NO_GTYPE)

##### _WRAP_ENUM_DOCS_ONLY

Αυτή η μακροεντολή δημιουργεί μια ομάδα τεκμηρίωσης Doxygen για την απαρίθμηση. Αυτό είναι χρήσιμο για απαριθμήσεις που δεν μπορούν να συσκευαστούν με `_WRAP_ENUM()` επειδή ορίζονται σύνθετα (ίσως χρησιμοποιώντας μακροεντολές C), αλλά η συμπερίληψη της δημιουργούμενης τεκμηρίωσης απαρίθμησης είναι ακόμα επιθυμητή. Χρησιμοποιείται με την ίδια σύνταξη ως `_WRAP_ENUM()` και επεξεργάζεται επίσης τις ίδιες επιλογές (αν και ο NO_GTYPE αγνοείται απλά επειδή δεν κάνει καμιά διαφορά όταν δημιουργεί μόνο την τεκμηρίωση απαρίθμησης).

##### _WRAP_GERROR

Αυτή η μακροεντολή δημιουργεί μια κλάση εξαίρεσης C++, που παράγεται από Glib::Error, με μια απαρίθμηση κώδικα και μια μέθοδο code(). Πρέπει να ορίσετε το επιθυμητό όνομα C++, το όνομα της αντίστοιχης απαρίθμησης C και το πρόθεμα για τις τιμές απαρίθμησης C.

Αυτή η εξαίρεση μπορεί τότε να δημιουργηθεί από μεθόδους που δημιουργούνται από _WRAP_METHOD() με επιλογή δημιουργία σφάλματος (errthrow).

_WRAP_GERROR() accepts the optional `newin` parameter. See _WRAP_METHOD().

For instance, from `pixbuf.hg`:

    _WRAP_GERROR(PixbufError, GdkPixbufError, GDK_PIXBUF_ERROR)

##### _MEMBER_GET / _MEMBER_SET

Χρησιμοποιήστε αυτές τις μακροεντολές αν συσκευάζετε μια απλή δομή ή τύπου πλαισίου που παρέχει άμεση πρόσβαση στα μέλη δεδομένων, για να δημιουργήσετε λήπτες και μεταλλάκτες (getters and setters) για τα μέλη δεδομένων.

`_MEMBER_GET(C++ name, C name, C++ type, C type)`

`_MEMBER_SET(C++ name, C name, C++ type, C type)`

For example, in `rectangle.hg`:

    _MEMBER_GET(x, x, int, int)

##### _MEMBER_GET_PTR / _MEMBER_SET_PTR

Χρησιμοποιήστε αυτές τις μακροεντολές για αυτόματη παροχή ληπτών και μεταλλακτών (getters and setters) για ένα μέλος δεδομένων που είναι τύπου δείκτη. Για τη συνάρτηση δεκτών, θα δημιουργήσει δύο μεθόδους, μια σταθερή και μια μη σταθερή.

`_MEMBER_GET_PTR(C++ name, C name, C++ type, C type)`

`_MEMBER_SET_PTR(C++ name, C name, C++ type, C type)`

For example, for Pango::Analysis in `item.hg`:

    // _MEMBER_GET_PTR(engine_lang, lang_engine, EngineLang*, PangoEngineLang*)
    // It's just a comment. It's difficult to find a real-world example.

##### _MEMBER_GET_GOBJECT / _MEMBER_SET_GOBJECT

χρησιμοποιήστε αυτές τις μακροεντολές για να δώσετε λήπτες και μεταλλάκτες (getters and setters) για ένα μέλος δεδομένων που είναι τύπου GObject που πρέπει να αναφερθεί πριν επιστραφεί.

`_MEMBER_GET_GOBJECT(C++ name, C name, C++ type, C type)`

`_MEMBER_SET_GOBJECT(C++ name, C name, C++ type, C type)`

For example, in Pangomm, `layoutline.hg`:

    _MEMBER_GET_GOBJECT(layout, layout, Pango::Layout, PangoLayout*)

#### Επεξεργασία παραμέτρου gmmproc

Η `gmmproc` επιτρέπει την επεξεργασία παραμέτρων στην υπογραφή μιας μεθόδου για τις μακροεντολές που επεξεργάζονται τις υπογραφές μεθόδων (όπως `_WRAP_METHOD()`, `_WRAP_CTOR()` και `_WRAP_CREATE()`) με ποικιλία τρόπων:

##### Αναδιάταξη παραμέτρου

For all the macros that process method signatures, it is possible to specify a different order for the C++ parameters than the existing order in the C function, virtual function or signal. For example, say that the following C function were being wrapped as a C++ method for the Gtk::Widget class:

            void gtk_widget_set_device_events(GtkWidget* widget, GdkDevice* device,
            GdkEventMask events);

However, changing the order of the C++ method's two parameters is necessary. Something like the following would wrap the function as a C++ method with a different order for the two parameters:

            _WRAP_METHOD(void set_device_events(Gdk::EventMask events{events},
            const Glib::RefPtr<const Gdk::Device>& device{device}),
            gtk_widget_set_device_events)

The `{c_param_name}` following the method parameter names tells `gmmproc` to map the C++ parameter to the specified C parameter within the `{}`. Since the C++ parameter names correspond to the C ones, the above could be re-written as:

            _WRAP_METHOD(void set_device_events(Gdk::EventMask events{.}, const
            Glib::RefPtr<const Gdk::Device>& device{.}),
            gtk_widget_set_device_events)

Παρακαλούμε σημειώστε ότι όταν αναδιατάσσονται παράμετροι για μια υπογραφή μεθόδου `_WRAP_SIGNAL()`, τα ονόματα παραμέτρου C πρέπει να είναι πάντα `p0`, `p1`, κλπ., επειδή το εργαλείο `generate_extra_defs` χρησιμοποιεί αυτά τα ονόματα παραμέτρων ανεξάρτητα από το ποια μπορεί να είναι τα ονόματα παραμέτρου της API της C. Έτσι είναι γραμμένο προς το παρόν το βοήθημα.

##### Προαιρετική επεξεργασία παραμέτρου

For all macros processing method signatures except `_WRAP_SIGNAL()` and `_WRAP_VFUNC()` it is also possible to make the parameters optional so that extra C++ methods are generated without the specified optional parameter. For example, say that the following `*_new()` function were being wrapped as a constructor in the Gtk::ToolButton class:

            GtkToolItem* gtk_tool_button_new(GtkWidget* icon_widget, const gchar*
            label);

Also, say that the C API allowed NULL for the function's label parameter so that that parameter is optional. It would be possible to have `gmmproc` generate the original constructor (with all the parameters) along with an additional constructor without that optional parameter by appending a `{?}` to the parameter name like so:

            _WRAP_CTOR(ToolButton(Widget& icon_widget, const Glib::ustring&
            label{?}), gtk_tool_button_new)

In this case, two constructors would be generated: One with the optional parameter and one without it.

##### Επεξεργασία παραμέτρου εξόδου

With `_WRAP_METHOD()` it is also possible for the return of the wrapped C function (if it has one) to be placed in an output parameter of the C++ method instead of having the C++ method also return a value like the C function does. To do that, simply include the output parameter in the C++ method parameter list appending a `{OUT}` to the output parameter name. For example, if `gtk_widget_get_request_mode()` is declared as the following:

            GtkSizeRequestMode gtk_widget_get_request_mode(GtkWidget* widget);

And having the C++ method set an output parameter is desired instead of returning a SizeRequestMode, something like the following could be used:

            _WRAP_METHOD(void get_request_mode(SizeRequestMode& mode{OUT})
            const, gtk_widget_get_request_mode)

The `{OUT}` appended to the name of the mode output parameter tells `gmmproc` to place the return of the C function in that output parameter. In this case, however, a necessary initialization macro like the following would also have to be specified:

            _INITIALIZATION(`SizeRequestMode&',`GtkSizeRequestMode',`$3 =
            (SizeRequestMode)($4)')

Which could also be written as:

            _INITIALIZATION(`SizeRequestMode&',`GtkSizeRequestMode',`$3 =
            ($1)($4)')

`_WRAP_METHOD()` also supports setting C++ output parameters from C output parameters if the C function being wrapped has any. Suppose, for example, that we want to wrap the following C function that returns a value in its C output parameter rect:

            gboolean gtk_icon_view_get_cell_rect(GtkIconView* icon_view,
            GtkTreePath* path, GtkCellRenderer* cell, GdkRectangle* rect);

To have `gmmproc` place the value returned in the C++ rect output parameter, something like the following `_WRAP_METHOD()` directive could be used:

            _WRAP_METHOD(bool get_cell_rect(const TreeModel::Path& path, const
            CellRenderer& cell, Gdk::Rectangle& rect{>>}) const,
            gtk_icon_view_get_cell_rect)

The `{>>}` following the rect parameter name indicates that the C++ output parameter should be set from the value returned in the C parameter from the C function. `gmmproc` will generate a declaration of a temporary variable in which to store the value of the C output parameter and a statement that sets the C++ output parameter from the temporary variable. In this case it may be necessary to have an `_INITIALIZATION()` describing how to set a Gdk::Rectangle& from a GdkRectangle* such as the following:

            _INITIALIZATION(`Gdk::Rectangle&',`GdkRectangle', `$3 =
            Glib::wrap(&($4))')

##### String Parameter Processing

A string-valued input parameter in a C++ method is usually a const Glib::ustring& or a const std::string&. In C code it's a const gchar*. When an empty string is converted to const gchar*, it can be converted either to `nullptr` or to a pointer to an empty string (with c_str()). Some parameters in some C functions accept a `nullptr`, and interpret it in a special way. Other parameters must not be `nullptr`.

The default conversion in `_WRAP_METHOD()` and similar directives is

- for mandatory parameters (with or without default values): empty string to empty string,

- for optional parameters (with appended `{?}`): empty string to `nullptr`.

If the default conversion is not the best conversion, append `{NULL}` to a mandatory parameter or `{?!NULL}` to an optional parameter (`!NULL` = not `NULL`). If you append both a C parameter name and `NULL`, separate them with a space: `{c_param_name NULL}`.

#### Βασικοί τύποι

Μερικοί από τους βασικούς τύπους που χρησιμοποιούνται στα APIs της C έχουν καλύτερες εναλλακτικές στη C++. Για παράδειγμα, δεν υπάρχει ανάγκη για έναν τύπο gboolean αφού η C++ έχει bool. Ο παρακάτω κατάλογος δείχνει μερικούς κοινά χρησιμοποιούμενους τύπους στις APIs C και σε τι μπορείτε να τους μετατρέψετε σε μια βιβλιοθήκη συσκευαστή C++.

Ισοδύναμοι βασικοί τύποι

Τύπος C Τύπος C++
- gboolean bool
- gint int
- guint guint
- gdouble double
- gunichar gunichar
- gchar*Glib::ustring (or std::string for filenames)

### Πηγαία αρχεία κωδικοποιημένα με το χέρι

Μπορεί να θέλετε να συμπεριλάβετε πρόσθετα πηγαία αρχεία που δεν θα δημιουργηθούν από την `gmmproc` και από τα αρχεία `.hg` και `.ccg`. Μπορείτε απλά να τα βάλετε στον κατάλογο `libsomething/libsomethingmm` και να τα αναφέρετε στο `Makefile.am` στις μεταβλητές `files_extra_h` και `files_extra_cc`.

### Αρχικοποίηση

Your library must be initialized before it can be used, to register the new types that it makes available. Also, the C library that you are wrapping might have its own initialization function that you should call. You can do this in an `init()` function that you can place in hand-coded `init.h` and `init.cc` files. This function should initialize your dependencies (such as the C function, and gtkmm) and call your generated `wrap_init()` function. For instance:

    void init()
    {
      Gtk::Main::init_gtkmm_internals(); //Sets up the g type system and the Glib::wrap() table.
      wrap_init(); //Tells the Glib::wrap() table about the libsomethingmm classes.
    }

Η υλοποίηση της μεθόδου `wrap_init()` στο `wrap_init.cc` δημιουργείται από το `generate_wrap_init.pl`, αλλά η δήλωση στο `wrap_init.h` είναι κωδικοποιημένη με το χέρι, έτσι θα χρειαστεί να ρυθμίσετε το `wrap_init.h` έτσι ώστε η συνάρτηση `wrap_init()` να εμφανίζεται στον σωστό χώρο ονόματος C++.

### Προβλήματα στη API της C.

Μπορεί να αντιμετωπίσετε μερικά προβλήματα στη βιβλιοθήκη που συσκευάζετε, ιδιαίτερα αν είναι ένα νέο έργο. Ιδού μερικά συνηθισμένα προβλήματα με λύσεις.

#### Αδύνατη η προδήλωση δομών

By convention, structs are declared in glib/GTK+-style headers like so:

    typedef struct _ExampleWidget ExampleWidget;

    struct _ExampleWidget
    {
      ...
    };

Ο πρόσθετος ορισμός τύπου επιτρέπει να χρησιμοποιηθεί η δομή σε μια κεφαλίδα χωρίς συμπερίληψη του πλήρους ορισμού της, απλά προδηλώνοντάς την, επαναλαμβάνοντας αυτόν τον τύπο ορισμού. Αυτό σημαίνει ότι δεν πρέπει να συμπεριλάβετε την κεφαλίδα της βιβλιοθήκης C στην κεφαλίδα της C++, κρατώντας την έξω από τη δημόσια API. Η `gmmproc` υποθέτει ότι αυτή η τεχνική χρησιμοποιήθηκε, έτσι θα δείτε σφάλματα μεταγλωττιστή αν αυτό δεν συμβαίνει.

This compiler error might look like this:

    example-widget.h:56: error: using typedef-name 'ExampleWidget' after 'struct'
    ../../libexample/libexamplemm/example-widget.h:34: error: 'ExampleWidget' has a previous declaration here
    make[4]: *** [example-widget.lo] Error 1

or this:

    example-widget.h:60: error: '_ExampleWidget ExampleWidget' redeclared as different kind of symbol
    ../../libexample/libexamplemm/example-widget.h:34: error: previous declaration of 'typedef struct _ExampleWidget ExampleWidget'

Αυτό είναι εύκολο να διορθώσετε στη βιβλιοθήκη C, γιαυτό στείλτε μια διόρθωση στον σχετικό συντηρητή.

#### Έλλειψη ιδιοτήτων

By convention, glib/GTK+-style objects have `*_new()` functions, such as `example_widget_new()` that do nothing more than call `g_object_new()` and return the result. The input parameters are supplied to `g_object_new()` along with the names of the properties for which they are values. For instance,

    GtkWidget* example_widget_new(int something, const char* thing)
    {
            return g_object_new (EXAMPLE_TYPE_WIDGET, "something", something, "thing", thing, NULL);
    }

Αυτό επιτρέπει στους συνδυασμούς γλωσσών να υλοποιήσουν τα δικά τους ισοδύναμα (όπως κατασκευαστές C++), χωρίς τη χρήση της συνάρτησης `*_new()`. Αυτό είναι συχνά απαραίτητο, έτσι ώστε να μπορούν στην πραγματικότητα να δημιουργήσουν μια παράγωγη GType, για να προσθέσουν τα δικά τους άγκιστρα για τους χειριστές σήματος και τις εικονικές συναρτήσεις (vfuncs).

Τουλάχιστον, η συνάρτηση `_new()` δεν πρέπει να χρησιμοποιήσει καμία ιδιωτική API (συναρτήσεις που είναι μόνο σε αρχείο .c). Ακόμα κι αν δεν υπάρχουν συναρτήσεις, μπορούμε μερικές φορές να ξαναεφαρμόσουμε 2 ή 3 γραμμές κώδικα σε μια συνάρτηση `_new()` όσο αυτές οι γραμμές κώδικα χρησιμοποιούν API που είναι διαθέσιμη σε μας.

Another workaround is to add a `*_construct()` function that the C++ constructor can call after instantiating its own type. For instance,

    GtkWidget* example_widget_new(int something, const char* thing)
    {
            ExampleWidget* widget;
            widget = g_object_new (EXAMPLE_TYPE_WIDGET, NULL);
            example_widget_construct(widget, "something", something, "thing", thing);
    }

    void example_widget_construct(ExampleWidget* widget, int something, const char* thing)
    {
            //Do stuff that uses private API:
            widget->priv->thing = thing;
            do_something(something);
    }

Η προσθήκη ιδιοτήτων και η επιβεβαίωση ότι αλληλεπιδρούν σωστά μεταξύ τους, είναι σχετικά δύσκολο να διορθωθεί στη βιβλιοθήκη C, αλλά είναι δυνατή, έτσι στείλτε ένα σφάλμα και προσπαθήστε να στείλετε μια διόρθωση στον σχετικό συντηρητή.

### Τεκμηρίωση

Γενικά, τα έργα τεχνοτροπίας gtkmm χρησιμοποιούν Doxygen, που διαβάζει ειδικά μορφοποιημένα σχόλια C++ και δημιουργεί τεκμηρίωση HTML. Μπορείτε να γράψετε αυτά τα σχόλια doxygen άμεσα στα αρχεία κεφαλίδας.

#### Επαναχρησιμοποίηση τεκμηρίωσης C

Μπορεί να θέλετε να επαναχρησιμοποιήσετε την τεκμηρίωση που υπάρχει για τη βιβλιοθήκη C που συσκευάζετε. Οι βιβλιοθήκες C τεχνοτροπίας GTK χρησιμοποιούν τυπικά gtk-doc και συνεπώς έχουν σχόλια πηγαίου κώδικα μορφοποιημένα για gtk-doc και κάποια πρόσθετη τεκμηρίωση σε αρχεία .sgml και .xml. Το σενάριο docextract_to_xml.py, από τον κατάλογο `tools/defs_gen` του glibmm, μπορεί να διαβάσει αυτά τα αρχεία και να δημιουργήσει ένα αρχείο .xml που μπορεί να χρησιμοποιήσει την `gmmproc` για να δημιουργήσει σχόλια doxygen. Η `gmmproc` θα προσπαθήσει ακόμα να μετασχηματίσει την τεκμηρίωση για να την κάνει πιο κατάλληλη για μια API C++.

For instance,

    ./docextract_to_xml.py -s ~/checkout/gnome/gtk+/gtk/ > gtk_docs.xml

Επειδή αυτός ο αυτόματος μετασχηματισμός δεν είναι πάντα κατάλληλος, μπορεί να θελήσετε να δώσετε χειρόγραφο κείμενο για μια συγκεκριμένη μέθοδο. Μπορείτε να το κάνετε αντιγράφοντας τον κόμβο XML για τη συνάρτηση από το αρχείο σας `something_docs.xml` στο αρχείο `something_docs_override.xml` και να αλλάξετε τα περιεχόμενα.

#### Διάρθρωση κατασκευής τεκμηρίωσης

Αν αντιγράφετε το πηγαίο δένδρο σκελετού σε mm-common και αντικαταστήσετε το κείμενο του δεσμευτικού θέσης, τότε θα έχετε ήδη κατάλληλα αρχεία `Makefile.am` και `Doxyfile.in`. Με την εγκατάσταση δόμησης mm-common, η λίστα των αρχείων εισόδου Doxygen δεν ορίζεται στο αρχείο ρυθμίσεων Doxygen, αλλά περνά από την `make` στην τυπική είσοδο της `doxygen`. Η λίστα αρχείων εισόδου ορίζεται από τη μεταβλητή `doc_input` στο αρχείο `Makefile.am`.