15.7 Behälter 

In der Einführung sind Sie bereits auf ein Behälter-Widget mit GtkBox gestoßen. Ohne den Behälter-Widget – gerne auch als Packing-Widgets bezeichnet – wäre es wohl aussichtslos, eine Anwendung zu erstellen. Denn gerade mithilfe der Behälter-Widgets entsteht das Layout des Fensters und somit der Anwendung.

15.7.1 Boxen – GtkBox 

Die wichtigsten und grundlegenden Behälter sind dabei die vertikalen und horizontalen Boxen. Diese werden immer dann verwendet, wenn mehrere Widgets nebeneinander und übereinander angeordnet werden sollen. Die Behälter-Widgets der Klasse GtkHBox und GtkVBox sind abgeleitet von der Oberklasse GtkBox. In der Abbildung sehen Sie den Klassenbaum von GtkBox.

In den meisten Fällen wird als Behälter GtkBox verwendet. Für den Fall, dass Sie sehr viele Zeilen und Spalten benötigen, können Sie entweder mehrere vertikale und horizontale Boxen in der richtigen Anordnung verwenden oder das Tabellen-Widget GtkTable. Ein Tabellen-Widget ist ein Behälter, mit dem Sie die weiteren Widgets in Zeilen und Spalten packen können.

Der Sinn und Zweck der Boxen – sei dies nun eine vertikale Box (Klasse GtkVBox mit der Typenkennung GTK_TYPE_VBOX) oder eine horizontale Box (Klasse GtkHBox mit der Typenkennung GTK_TYPE_HBOX) – ist immer derselbe. Boxen werden dazu verwendet, damit andere Widgets darin hineingepackt werden.

Folgende zwei Eigenschaften können einer Klasse GtkBox vom Typ GTK_TYPE_VBOX oder GTK_TYPE_HBOX vergeben bzw. können abgefragt werden:

In den Listings bisher wurden die einzelnen Widgets mit der Funktion gtk_box_pack_start_defaults() mit den Standardeinstellungen einer Box hinzugefügt. Mit den folgenden Funktionen können Sie ganz individuell für jedes einzelne Widget eine Angabe machen, wie dieses zur Box hinzugefügt (gepackt) werden soll.

void gtk_box_pack_start_defaults( GtkBox *box,
                                  GtkWidget *widget );
void gtk_pack_box_start( GtkBox *box, 
                         GtkWidget *widget, 
                         gboolean expand, 
                         gboolean fill,
                         guint padding );
void gtk_pack_box_end (  GtkBox *box,
                         GtkWidget *widget,
                         gboolean expand,
                         gboolean fill,
                         guint padding );

Der Unterschied der beiden Funktionen (.._start und .._end) ist, dass ein Widget mit der _end-Version vom Ende der vertikalen oder der rechten Seiten der horizontalen Box aus gepackt wird. Bei der _start-Version ist das Gegenteil der Fall.

Die ersten beiden Parameter der Funktionen gtk_pack_box_start() und gtk_pack_box_end() sind gleichbedeutend wie bei der Funktion gtk_box_pack_default(). box ist die Box, worin Sie das Widget widget hineinpacken wollen. Mit den nächsten drei Parametern können Sie die Darstellung des Widgets in der Box beeinflussen.

expand – Wird hier TRUE angegeben, darf sich das Widget ausdehnen. Befinden sich mehrere Widgets in dieser Box, wird der verfügbare Bereich unter diesen Widgets aufgeteilt, bei denen dieser Parameter ebenfalls TRUE ist.

fill – Wird für expand TRUE verwendet und für fill (ausfüllen) ebenfalls, wird der übrige Freiraum zwischen den Widgets selbst völlig ausgefüllt, anstatt sich nur zu zentrieren.

padding – Hier können Sie einen Wert in Pixeln angeben, womit ein Leerraum rund um das Widget »gepolstert« werden darf.

In den gleich folgenden beiden Beispielen wurde auf ein Widget mit einer Box als Behälter erst einmal verzichtet, da es ohnehin in fast jedem der noch folgenden Listings verwendet wird oder bereits verwendet wurde. Daher soll hier erst ein umfassender Blick auf andere Behälter-Widgets gemacht werden.

15.7.2 Aufteilungen, Register und Button-Box 

In den jetzt folgenden Listings werden die (Behälter-)Widgets GtkHPaned und GtkVPaned (mit den Typenkennungen GTK_TYPE_HPANED bzw. GTK_TYPE_VPANED) gezeigt, womit Sie mehrere verstellbare (sowohl horizontale als auch vertikale) Aufteilungen erzeugen können, wie Sie dies z. B. von FTP- oder Mailclient-Anwendungen her kennen. Des Weiteren wird ein Behälter mit mehreren Registern erzeugt (GtkNotebook von der Typenkennung GTK_TYPE_NOTEBOOK), wie Sie dies z. B. von Notizbüchern (oder Ringordnern) her kennen. Daneben werden Sie auch noch Behälter kennen lernen, die nur Buttons aufnehmen können.

/* gkt3.c */
/* Behälter:       */
/*    horizontale und vertikale Aufteilung (GtkPaned) */
/*    Register (GtkNootebook)                         */
/*    horizontale und vertikale Boxen                 */
#include <gtk/gtk.h>
#define NBOOK 6
#define BUF 35
#define BUTTONS 4
static gint
delete_Event(GtkWidget *widget, GdkEvent event, gpointer daten) {
  g_print("Das Fenster wird zerstoert!\n");
  /* Nur mit FALSE wird die Anwendung wirklich beendet */
  return FALSE;
}
static void end ( GtkWidget *widget, gpointer daten ) {
  g_print("Und tschuess!\n");
  gtk_main_quit();
}
int main(int argc, char **argv) {
  GtkWindow  *win;
  GdkPixbuf  *pic;
  GtkVPaned  *vpan;
  GtkHPaned  *hpan;
  GtkNotebook *nbook;
  GtkLabel    *nbook_content[NBOOK],
  *nbook_titel[NBOOK];
  GtkVButtonBox *vbutbox;
  GtkButton     *vbuttons[BUTTONS];
  GtkHButtonBox *hbutbox;
  GtkButton     *hbuttons[BUTTONS];
  guint i;
  gchar buf[BUF];
  gtk_init( &argc, &argv );
  /* Eine Grafik in einen Pixbuf laden */
  pic = gdk_pixbuf_new_from_file("icon/at-work.gif", NULL );
  /* Fenster mit folgenden Eigenschaften anlegen */
  win = g_object_new( GTK_TYPE_WINDOW,
                      "title", "Behaelter-Widgets",
                      "default-width",  300,
                      "default-height", 200,
                      "resizable", TRUE,
                      "window-position", GTK_WIN_POS_CENTER,
                      "border-width", 10,
                      "icon", pic,
                      NULL );
  /* vertikale Aufteilung erzeugen */
  vpan = g_object_new( GTK_TYPE_HPANED, NULL );
  /* horizontale Aufteilung erzeugen */
  hpan = g_object_new( GTK_TYPE_VPANED, NULL );
  /* vpan oben-links von hpan mit den */
  /* Standardparametern hinzufügen    */
  gtk_paned_add1( GTK_PANED(hpan), GTK_WIDGET(vpan) );
  /* ein neues Notizbuch erzeugen */
  nbook = g_object_new( GTK_TYPE_NOTEBOOK,
                        "enable-popup", TRUE,
                        NULL );
  /* nbook rechts-unten von vpan mit den */
  /* Standardparametern hinzufügen */
  gtk_paned_add2(GTK_PANED(vpan), GTK_WIDGET(nbook));
  /* Titel der Reiter mit entsprechendem Inhalt erzeugen  */
  /* und im Notizbuch hinzufügen */
  for(i=0; i < NBOOK; i++) {
    g_snprintf(buf,BUF,"Inhalt von GtkNotebook Seite %d",i+1);
    nbook_content[i] = g_object_new( GTK_TYPE_LABEL,
                                     "label", buf,
                                     NULL);
    g_snprintf(buf,BUF,"Seite %d",i+1);
    nbook_titel[i]   = g_object_new( GTK_TYPE_LABEL,
                                     "label", buf,
                                     NULL );
    gtk_notebook_append_page_menu(nbook,
                                  GTK_WIDGET(nbook_content[i]),
                                  GTK_WIDGET(nbook_titel[i]),
                                  NULL);
  }
  /* vertikale Button-Box erzeugen */
  vbutbox = g_object_new( GTK_TYPE_VBUTTON_BOX, NULL);
  /* horizontale Button-Box erzeugen */
  hbutbox = g_object_new( GTK_TYPE_HBUTTON_BOX, NULL);
  /* Buttons erzeugen und in die Button-Box packen */
  for(i=0; i < BUTTONS; i++ ) {
    g_snprintf(buf,BUF,"(v)Button %d",i+1);
    vbuttons[i] = g_object_new( GTK_TYPE_BUTTON,
                                "label", buf,
                                NULL);
    gtk_box_pack_start_defaults( GTK_BOX(vbutbox),
                                 GTK_WIDGET(vbuttons[i]));
    g_snprintf(buf,BUF,"(h)Button %d",i+1);
    hbuttons[i] = g_object_new( GTK_TYPE_BUTTON,
                                "label", buf,
                                NULL );
    gtk_box_pack_start_defaults( GTK_BOX(hbutbox),
                                 GTK_WIDGET(hbuttons[i]));
  }
  /* vbutbox oben-links von vpan mit den */
  /* Standardparametern hinzufügen       */
  gtk_paned_add1(GTK_PANED(vpan), GTK_WIDGET(vbutbox));
  /* hbutbox rechts-unten von hpan mit den */
  /* Standardparametern hinzufügen         */
  gtk_paned_add2(GTK_PANED(hpan), GTK_WIDGET(hbutbox));
  /* Signalhandler einrichten */
  g_signal_connect( win, "delete-event",
                    G_CALLBACK(delete_Event), NULL );
  g_signal_connect( win, "destroy",
                    G_CALLBACK(end), NULL );
  gtk_container_add(GTK_CONTAINER( win ), GTK_WIDGET( hpan ) );
  /* Fenster anzeigen */
  gtk_widget_show_all( GTK_WIDGET(win) );
  /* Hauptschleife von gtk */
  gtk_main();
  g_print("Die GTK-Hauptschleife wurde beendet\n");
  return 0;
}

Das Programm bei der Ausführung:

$ gcc -Wall -o gtk3 gtk3.c \
  `pkg-config gtk+-2.0 --cflags --libs`
$ ./gtk3

Aufteilungen – GtkPaned

Im Beispiel haben Sie jeweils eine vertikale und eine horizontale Schiebeleiste (Aufteilung) verwendet. Bei einer Aufteilung der Klassen GtkVPaned (Typenkennung: GTK_TYPE_VPANED) bzw. GtkHPaned (Typenkennung: GTK_TYPE_HPANED) kann an beiden Seiten je ein Widget gepackt werden. Bei GtkVPaned ist dies je ein Widget oberhalb und unterhalb der Schiebeleiste und bei GtkHPaned links und rechts von der Leiste. Um das Packen entsprechend vorzunehmen, werden hierfür die Funktionen gtk_paned_add1() und gtk_paned_add2() verwendet.

void gtk_paned_add1 ( GtkPaned *paned,
                      GtkWidget *child );
void gtk_paned_add2 ( GtkPaned *paned,
                      GtkWidget *child );

Als erstes Argument verwenden je beide Funktionen die Schiebeleiste (GtkPaned) und als zweites Argument ein Widget, das darin hineingepackt werden soll. Mit gtk_paned_add1() wird ein Widget links über und mit gtk_paned_add2() rechts unter die Schiebeleiste gepackt.

Sofern Sie ähnlich wie beim Packen von Boxen mit gtk_box_pack_start() auch die Größenveränderung des Widgets beeinflussen wollen, können Sie hierfür die Funktionen gtk_paned_pack1() und gtk_paned_pack2() verwenden.

/* links oben */
void gtk_paned_pack1 ( GtkPaned *paned,
                       GtkWidget *child,
                       gboolean resize,
                       gboolean shrink );
/* rechts unten */
void gtk_paned_pack2 ( GtkPaned *paned,
                       GtkWidget *child,
                       gboolean resize,
                       gboolean shrink );

Beide Funktionen sind bis zu den ersten beiden Parametern gleichwertig wie gtk_paned_add1() und gtk_panded_add2(). Zusätzlich können Sie hier noch mit dem dritten Parameter angeben, ob sich das Kind-Widget ausdehnen soll (darf), wenn die Größe des Widgets verändert wird. Mit dem vierten Argument bestimmen Sie hingegen, ob das Widget jenseits der Minimalgröße schrumpfen darf, wenn das Hauptfenster verkleinert wird.

Folgende zwei Eigenschaften stehen Ihnen außerdem für das Widget GtkPaned zur Verfügungen:

Notizbuch – GtkNotebook

Das Notizbuch (GtkNotebook; Typenkennung: GTK_TYPE_NOTEBOOK) besteht aus mehreren Reitern, die beim Anklicken auch jeweils eine neue Seite beinhalten. Um zum Notizbuch weitere Seiten und Reiter hinzuzufügen, stehen Ihnen mindestens folgende Funktionen zur Verfügung (wovon Sie ja im Beispiel die Funktion gtk_notebook_append_page_menu() verwenden):

void gtk_notebook_append_page_menu ( GtkNotebook *notebook,
                                     GtkWidget *child,
                                     GtkWidget *tab_label,
                                     GtkWidget *menu_label );
void gtk_notebook_prepend_page_menu ( GtkNotebook *notebook,
                                      GtkWidget *child,
                                      GtkWidget *tab_label,
                                      GtkWidget *menu_label );
void gtk_notebook_insert_page_menu ( GtkNotebook *notebook,
                                     GtkWidget *child,
                                     GtkWidget *tab_label,
                                     GtkWidget *menu_label,
                                     gint position );

Die einzelnen Argumente haben bei allen drei Funktionen dieselbe Bedeutung. Das erste Argument ist das Widget GtkNotebook selbst, wo ein neuer Eintrag hinzugefügt werden soll. Mit dem zweiten Argument geben Sie den Inhalt der Seite an, den Sie in das Notizbuch hineinpacken wollen. Hierbei können Sie natürlich (fast) jedes beliebige andere Widget, wie im Beispiel mit GtkLabel gesehen, hineinpacken. Mit dem dritten Argument gibt man normalerweise die Beschriftung (Reitername) für die neue Seite an, wobei rein theoretisch auch hier ein beliebiges Widget verwendet werden könnte (ob das jetzt Sinn macht, sei dahingestellt). Im Beispiel wurde auch hierzu GtkLabel verwendet. Das vierte Argument könnte ein weiteres Beschriftungs-Widget aufnehmen, das für das Schnellzugriffsmenü der einzelnen Reiter dient. Dieses Menü erreichen Sie über einen Rechtsklick auf irgendeinen der Reiter. Wollen Sie, dass sich hier derselbe Eintrag, wie der Name des Reiters selbst (drittes Argument), befindet, können Sie hier auch NULL angeben.

Der Unterschied der Funktionen gtk_notebook_append_page_menu() und gtk_notebook_prepend_page_menu() liegt darin, dass mit _append_ der neue Eintrag hinten und mit _prepend_ der neue Eintrag vorne eingefügt wird. Die Funktion gtk_notebook_insert_page_menu() hingegen hat noch ein fünftes Argument, womit der Menüeintrag an einer beliebigen Stelle bestimmt (angefangen von links (vorne) = 0) werden kann.

Entfernen können Sie einen Notizbucheintrag wieder mit gtk_notebook_remove_page():

void gtk_notebook_remove_page ( GtkNotebook *notebook,
                                gint page_num );

Hierzu müssen Sie neben der Angabe des Notizbuches (erstes Argument) auch die Position (angefangen von vorne mit 0) des Eintrags angeben, der entfernt werden soll.

Die Eigenschaften, die Sie für ein neues Notizbuch von der Klasse GtkNootebook (Typenkennung: GTK_TYPE_NOTEBOOK) vergeben können, finden Sie wieder in der folgenden Tabelle aufgelistet.

Button-Boxen – Gtk*ButtonBox

Die Button-Boxen GtkVButtonBox (Typenkennung: GTK_TYPE_VBUTTON_BOX) und GtkHButtonBox (Typenkennung: GTK_TYPE_HBUTTON_BOX) sind abgeleitete Klassen von GtkVBox und GtkHBox. Diese Behälter-Widgets eignen sich überall dort, wo Sie Button in einer vertikalen oder horizontalen Reihenfolge anordnen müssen. Ansonsten verhalten sich Button-Boxen bezüglich ihrer Eigenschaften, die vorhanden sind, genauso wie die normalen Boxen. Hinzu kommt noch die zusätzliche Eigenschaft layout-style, womit Sie angeben können, wie die Knöpfe in der Box angeordnet werden sollen. Mögliche Werte hierfür wären:

GTK_BUTTONBOX_DEFAULT_STYLE – Standardeinstellung lassen

GTK_BUTTONBOX_SPREAD – gleichmäßig verteilen

GTK_BUTTONBOX_EDGE – an den Enden der Box platzieren

GTK_BUTTONBOX_START – am Anfang der Box gruppieren

GTK_BUTTONBOX_END – am Ende der Box gruppieren

15.7.3 Tabellen – GtkTable 

Neben den Boxen sind Tabellen (Klasse GtkTable; Typenkennung: GTK_TYPE_TABLE) sehr gut geeignet, um das Layout der Software zusammenzupacken. Ähnlich wie bei einer Tabellenkalkulation lassen sich die Widgets hiermit in Zeilen und Spalten anordnen. Ebenso wie auf die Boxen, so werden Sie auch auf die Tabellen noch das eine oder andere Mal in diesem Kapitel stoßen, so dass hier nur ein kurzes Beispiel angeführt werden soll, das mehr oder weniger nur die Packfunktionen der Tabellen demonstriert.

/* gtk3b.c */
/* Behälter:        */
/*    Tabellen-Demo */
#include <gtk/gtk.h>
#define BUTTONS 3
static gint
delete_Event(GtkWidget *widget, GdkEvent event, gpointer daten) {
  g_print("Das Fenster wird zerstoert!\n");
  /* Nur mit FALSE wird die Anwendung wirklich beendet */
  return FALSE;
}
static void end ( GtkWidget *widget, gpointer daten ) {
  g_print("Und tschuess!\n");
  gtk_main_quit();
}
int main(int argc, char **argv) {
  GtkWindow  *win;
  GdkPixbuf  *pic;
  GtkTable   *table;
  GtkButton  *button1, *button2, *button3;
  gtk_init( &argc, &argv );
  /* Eine Grafik in einen Pixbuf laden */
  pic = gdk_pixbuf_new_from_file("icon/at-work.gif", NULL );
  /* Fenster mit folgenden Eigenschaften anlegen */
  win = g_object_new( GTK_TYPE_WINDOW,
                      "title", "Eine einfache Tabelle",
                      "default-width",  300,
                      "default-height", 200,
                      "resizable", TRUE,
                      "window-position", GTK_WIN_POS_CENTER,
                      "border-width", 10,
                      "icon", pic,
                      NULL );
  button1 = g_object_new( GTK_TYPE_BUTTON,
                     "label","Kein Schrumpfen\nkein Expandieren",
                     NULL);
  button2 = g_object_new( GTK_TYPE_BUTTON,
                    "label","Expandiert und schrumpft\nvertikal",
                    NULL);
  button3 = g_object_new( GTK_TYPE_BUTTON,
           "label","Expandiert und schrumpft\n in beide Seiten",
           NULL);
  table = g_object_new( GTK_TYPE_TABLE,
                        "n-columns", 2,
                        "n-rows", 2,
                        NULL);
  /* Signalhandler einrichten */
  g_signal_connect( win, "delete-event",
                    G_CALLBACK(delete_Event), NULL );
  g_signal_connect( win, "destroy",
                    G_CALLBACK(end), NULL );
  /* Inhalt der Tabelle mit verschiedenen Optionen erstellen */
  gtk_table_attach ( GTK_TABLE (table), GTK_WIDGET(button1),
                     0, 1, 0, 1,
                     GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach ( GTK_TABLE (table), GTK_WIDGET(button2),
                     0, 1, 1, 2,
                     GTK_FILL, GTK_FILL|GTK_EXPAND|GTK_SHRINK,
                     0, 0);
  gtk_table_attach ( GTK_TABLE (table), GTK_WIDGET(button3),
                     1, 2, 1, 2,
                     GTK_FILL | GTK_EXPAND | GTK_SHRINK,
                     GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
  gtk_container_add(GTK_CONTAINER( win ), GTK_WIDGET( table ) );
  /* Fenster anzeigen */
  gtk_widget_show_all( GTK_WIDGET(win) );
  /* Hauptschleife von gtk */
  gtk_main();
  g_print("Die GTK-Hauptschleife wurde beendet\n");
  return 0;
}

Das Programm bei der Ausführung:

$ gcc -Wall -o gtk3b gtk3b.c \
  `pkg-config gtk+-2.0 --cflags --libs`
$ ./gtk3b

Das Tabellen-Packing-Widget mit der Klasse GtkTable (Typenkennung: GTK_TYPE_TABLE) funktioniert im Prinzip genauso wie das der vertikalen bzw. horizontalen Boxen. Nur verwenden Sie für das Packen eines Widgets x/y-Koordinaten. Sie können sich das Ganze wie bei einem Tabellenkalkulationsprogramm vorstellen. Sie erzeugen mithilfe der Eigenschaften n-rows für Zeilen und n-columns für Spaltenanzahl eine Tabelle. Dann geben Sie bei den entsprechenden Packfunktionen die Koordinaten an, in welcher Reihe und Spalte das Widget platziert werden soll.

Die Funktionen, mit denen Sie das Packen mit Tabellen realisieren können, lauten:

void gtk_table_attach_defaults( GtkTable *table,
                                GtkWidget *widget,
                                quint left_attach,
                                quint right_attach,
                                quint top_attach,
                                quint bottom_attach );
GtkWidget *gtk_table_attach ( GtkTable *table,
                              GtkWidget *widget,
                              quint left_attach,
                              quint right_attach,
                              quint top_attach,
                              quint bottom_attach,
                              GtkAttachOptions xoptions,
                              GtkAttachOptions yoptions,
                              quint xpadding,
                              quint ypadding );

Die einfachste Version, einzelne Widgets in den Tabellenbehälter zu packen, ist mit der Funktion gtk_table_attach_defaults() gegeben. Damit packen Sie das Widget (zweiter Parameter) in die Tabelle (erster Parameter). Die Angabe der Spalte lautet von left_attach für links nach right_attach für rechts und für die Zeile von top_attach für oben bis bottom_attach für unten. Ein Codeausschnitt zum besseren Verständnis mit anschließender Abbildung (15.11) dazu:

/* Erzeugen einer 3x2-Tabelle */
table = gtk_table_new(3,2,TRUE);
/* ein Widget an die linke obere Ecke einfügen */
gtk_table_attach_defaults(GTK_TABLE(table), button1, 0,1, 0,1);
/* ein Widget an der linken unteren Ecke hinzufügen */
gtk_table_attach_defaults(GTK_TABLE(table), button2, 0,1, 1,2);
/* ein Widget an der rechten unteren Ecke hinzufügen */
gtk_table_attach_defaults(GTK_TABLE(table), button3, 2,3, 1,2);

Wollen Sie hingegen mehr als die Standardeinstellung zum Packen der Widgets in eine Tabelle verwenden, müssen Sie die Funktion gtk_table_attach() verwenden. Hier sind noch weitere vier Parameter neben gtk_table_attach_defaults() hinzugekommen. Für xoptions und yoptions vom Typ GtkAttachOptions können Sie noch folgende symbolische Konstanten verwenden:

GTK_EXPAND – Widget breitet sich aus, falls überschüssiger Platz vorhanden ist (siehe Box-Widget).

GTK_FILL – Das Widget füllt den zusätzlichen Platz ganz aus (siehe Box-Widget).

GTK_SHRINK – Das Widget lässt sich verkleinern, und zwar, falls nötig, kleiner als seine Zelle.

Die einzelnen Optionen lassen sich auch mit dem bitweisen ODER-Operator (|) verknüpfen.

Mit xpadding und ypadding können Sie den Abstand in Pixeln vom Nachbarn rechts/links bzw. oben/unten angeben. Ich finde, das zuvor gezeigte ausführbare Beispiel zeigt die Bedeutungen der einzelnen Argumente recht eindeutig.

Folgende Eigenschaften können außer der Spalten- und Reihenanzahl noch an die Tabelle GtkTable übergeben werden:

15.7.4 Ausrichtung – GtkAlignment 

GtkAlignment (von der Typenkennung GTK_TYPE_ALIGNMENT) ist ein Behälter, worin Sie Widgets hineinpacken und nach bestimmten Eigenschaften ausrichten können. Hier die möglichen Eigenschaften für diesen Behälter-Widget: