Widgets

Es gibt eine Vielzahl von Widgets, mit denen Sie Ihre Benutzeroberflächen erstellen können. Zu diesen Widgets gehören Schaltflächen, Kästchen, Schieberegler, Textfelder und Auswahlmenüs. Widgets können nur einmal gedruckt oder einem Bereich hinzugefügt werden. In den folgenden Abschnitten werden die grundlegenden Funktionen, das Design und die Bedienung der Widgets beschrieben. Weitere Informationen zum Gestalten von Widgets finden Sie im Abschnitt „Stil“. In den folgenden Beispielen werden die Widgets einfach in der Konsole print(). Weitere Informationen zum Hinzufügen von Widgets zu Bereichen finden Sie auf der Seite Bereiche und Layouts.

ui.Label

Labels sind einfach Bereiche, in denen Text angezeigt wird. Mit dem folgenden Code wird beispielsweise ein Label ausgegeben:

Code-Editor (JavaScript)

var label = ui.Label('Cool label!');
print(label);

Das sieht in etwa so aus:

ui_label.png

Lange Labels können Sie aufteilen, indem Sie ein Zeilenumbruchzeichen (\n) einfügen und das Argument der Stileigenschaft whiteSpace auf 'pre' festlegen:

print(ui.Label('Here is a:\nnew line', {whiteSpace: 'pre'}));

ui.Button

Eine Schaltfläche ist ein interaktives UI-Widget, auf das geklickt werden kann. Sie können eine Funktion angeben, die aufgerufen wird (die „Callback“-Funktion), wenn ein Nutzer auf die Schaltfläche klickt. Weitere Informationen zur Ereignisbehandlung mit Callback-Funktionen finden Sie auf der Seite „Ereignisse“. Im folgenden Beispiel wird der aktuelle Mittelpunkt der Karte ausgegeben, wenn auf den Button geklickt wird:

Code-Editor (JavaScript)

var button = ui.Button({
  label: 'Get Map Center',
  onClick: function() {
    print(Map.getCenter());
  }
});
print(button);

Das sieht in etwa so aus:

ui_button.png

ui.Checkbox

Ein Kästchen ist ein Widget, mit dem Nutzer ein Kästchen aktivieren oder deaktivieren können. Wenn sich der Status des Kästchens ändert, wird an die für das Widget registrierten Callbacks ein boolescher Wert übergeben, der angibt, ob das Kästchen jetzt angeklickt ist. Beispiel:

Code-Editor (JavaScript)

var checkbox = ui.Checkbox('Show SRTM layer', true);

checkbox.onChange(function(checked) {
  // Shows or hides the first map layer based on the checkbox's value.
  Map.layers().get(0).setShown(checked);
});

Map.addLayer(ee.Image('CGIAR/SRTM90_V4'));
print(checkbox);

Das ausgegebene Kästchen sollte in etwa so aussehen:

ui_checkbox.png

Wenn Sie das Kästchen anklicken, wird eine Ebene auf der Karte aktiviert. Wie andere UI-Komponenten kann auch die Karte des Code-Editors programmatisch bearbeitet werden. Weitere Informationen zum Map-Objekt finden Sie auf der Seite Bereiche und Layouts.

ui.Slider

Ein Schieberegler ist ein Widget, mit dem ein Nutzer einen Schieberegler anpassen kann, um eine Zahl innerhalb des Schiebereglerbereichs zu erhalten. Konfiguriere den Bereich entweder über den Konstruktor oder durch Festlegen der Eigenschaften des Schiebereglers. Im folgenden Beispiel wird der Schieberegler verwendet, um die Deckkraft der ersten Ebene auf der Karte festzulegen:

Code-Editor (JavaScript)

var slider = ui.Slider();

slider.setValue(0.9);  // Set a default value.
slider.onChange(function(value) {
  Map.layers().get(0).setOpacity(value);
});

Map.addLayer(ee.Image(255), {palette: 'blue'});
print(slider);

Der Schieberegler sollte in etwa so aussehen:

ui_slider.png

Der Wert des Schiebereglers wird rechts neben dem Schieberegler angezeigt.

ui.DateSlider

Das Widget DateSlider ähnelt dem Widget Slider, verarbeitet jedoch Datumsangaben explizit. Eine DateSlider, die so konfiguriert ist, dass ein Tag im Juni 2018 ausgewählt wird, sieht so aus:

DateSlider.png

DateSlider ist nützlich, um Sammlungen zu filtern, wie im folgenden Beispiel gezeigt, in dem ein jährliches Komposit basierend auf dem in DateSlider festgelegten DateRange erstellt wird:

Code-Editor (JavaScript)

// Use a DateSlider to create annual composites of this collection.
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1');
// Use the start of the collection and now to bound the slider.
var start = ee.Image(collection.first()).date().get('year').format();
var now = Date.now();
var end = ee.Date(now).format();

// Run this function on a change of the dateSlider.
var showMosaic = function(range) {
  var mosaic = ee.Algorithms.Landsat.simpleComposite({
    collection: collection.filterDate(range.start(), range.end())
  });
  // Asynchronously compute the name of the composite.  Display it.
  range.start().get('year').evaluate(function(name) {
    var visParams = {bands: ['B4', 'B3', 'B2'], max: 100};
    var layer = ui.Map.Layer(mosaic, visParams, name + ' composite');
    Map.layers().set(0, layer);
  });
};

// Asynchronously compute the date range and show the slider.
var dateRange = ee.DateRange(start, end).evaluate(function(range) {
  var dateSlider = ui.DateSlider({
    start: range['dates'][0],
    end: range['dates'][1],
    value: null,
    period: 365,
    onChange: showMosaic,
    style: {width: '180px'}
  });
  Map.add(dateSlider.setValue(now));
});

// Initialize the map location at southern Africa.
Map.setCenter(23.861, -27.144, 6);

ui.Textbox

In einem Textfeld können Sie von Nutzern eingegebenen Text erfassen. Beispiel:

Code-Editor (JavaScript)

var textbox = ui.Textbox({
  placeholder: 'Enter text here...',
  onChange: function(text) {
    print('So what you are saying is ' + text + '?');
  }
});
print(textbox);

Das Textfeld sollte in etwa so aussehen:

ui_textbox.png

Der Callback wird nur ausgelöst, wenn der Nutzer die Texteingabe abgeschlossen und die Eingabetaste gedrückt hat oder wenn er außerhalb des Textfelds klickt.

ui.Select

Das Auswahl-Widget stellt ein Drop-down-Menü mit Optionen dar, aus denen der Nutzer eine auswählen kann. Das folgende Beispiel zeigt ein Drop-down-Menü, über das ein Nutzer einen Standort auswählen kann:

Code-Editor (JavaScript)

var places = {
  MTV: [-122.0849, 37.3887],
  PEK: [116.4056, 39.9097],
  ZRH: [8.536, 47.376]
};

var select = ui.Select({
  items: Object.keys(places),
  onChange: function(key) {
    Map.setCenter(places[key][0], places[key][1]);
  }
});

// Set a place holder.
select.setPlaceholder('Choose a location...');

print(select);

Das Auswahl-Widget sollte in etwa so aussehen:

ui_select.png

ui.Chart

Die Diagramme im Paket ui.Chart verhalten sich ähnlich wie die Diagramme im Paket Chart. Konkret ist ein ui.Chart eine dünne Schale um eine Instanz der ChartWrapper der Google Visualization API. Weitere Informationen zum Bearbeiten von ChartWrapper-Objekten finden Sie in dieser Referenz. Weitere Informationen zu den Hilfsfunktionen für Diagramme in Earth Engine finden Sie in der Dokumentation zu Diagrammen.

ui.Thumbnail

Mit dem Thumbnail-Widget können Sie eine Vorschau von ee.Image- und ee.ImageCollection-Objekten anzeigen lassen. Wenn ein ee.Image angegeben wird, zeigt das Widget ein statisches Bild an. Wenn ein ee.ImageCollection angegeben wird, wird eine Animation mit einem Frame pro Bild in der Eingabe angezeigt. Wie bei ee.Image.getThumbURL() und ee.ImageCollection.getVideoThumbURL() können Sie Parameter angeben, um das Format und die Abmessungen der resultierenden Miniaturansicht zu steuern:

Code-Editor (JavaScript)

// Create a box around an area in the Brazilian Amazon.
var box = ee.Geometry.Polygon([[
  [-62.9564, 2.5596], [-62.9550, 2.4313], [-62.8294, 2.4327], [-62.8294, 2.5596]
]]);

// Visualize the image in RGB.
var image = ee.Image('LANDSAT/LE07/C02/T1_L2/LE07_233058_20011113')
                .select(['SR_B[1-3]'])  // blue, green, red reflectance
                .multiply(0.0000275).add(-0.2)  // apply scaling factors
                .visualize({
                  bands: ['SR_B3', 'SR_B2', 'SR_B1'],
                  min: 0,
                  max: 0.12,
                  gamma: 1.3
                });

// Print a thumbnail to the console.
print(ui.Thumbnail({
  image: image,
  params: {dimensions: '256x256', region: box, format: 'png'},
  style: {height: '300px', width: '300px'}
}));

Das Thumbnail sollte in etwa so aussehen:

ui_thumbnail.png

ui.Map

Ein ui.Map ist ein Karten-Widget. (Tatsächlich ist die Standard-Karte des Code-Editors eine Instanz dieser Klasse.) Wie andere Widgets können Sie eine Karte in der Konsole ausgeben. Sie können den Inhalt der Karte bearbeiten, indem Sie einzelne Ebenen löschen, abrufen oder festlegen. Im folgenden Beispiel wird eine Karte in der Konsole ausgegeben, die die Grenzen der Karte im Code-Editor zeigt:

Code-Editor (JavaScript)

// Make a little map.
var map = ui.Map();

// Make the little map display an inset of the big map.
var createInset = function() {
  var bounds = ee.Geometry.Rectangle(Map.getBounds());
  map.centerObject(bounds);
  map.clear();
  map.addLayer(bounds);
};

// Run it once to initialize.
createInset();

// Get a new inset map whenever you click on the big map.
Map.onClick(createInset);

// Display the inset map in the console.
print(map);

Die Übersichtskarte sollte in etwa so aussehen:

ui_map.png

In diesem Beispiel muss der Nutzer auf die große Karte klicken, damit der Kartenausschnitt in der kleinen Karte gezeichnet wird.

Sie können Ebenen auf der Karte auch bearbeiten, indem Sie layers() für die Karteninstanz aufrufen. layers() gibt ein ui.data.ActiveList zurück, ein Array-ähnliches Objekt. Wenn sie geändert wird, ändern sich auch die Ebenen auf der Karte. Weitere Informationen finden Sie im Abschnitt „ui.Map.Layer“.

ui.Map.Layer

Eine Ebene ist kein Widget, das wie ein ui.Button gestaltet werden kann. Es ist nur eine Datendarstellung der Ebene auf der Karte. Im folgenden Beispiel wird gezeigt, wie eine Karte aktualisiert wird, indem eine Ebene erstellt und die Eigenschaften der Ebene basierend auf Nutzereingaben aktualisiert werden:

Code-Editor (JavaScript)

var consoleMap = ui.Map({
  lon: -2.0174,
  lat: 48.6474,
  zoom: 13
});

// Create a Layer from this Sentinel-2 image
var image = ee.Image('COPERNICUS/S2_HARMONIZED/20150821T111616_20160314T094808_T30UWU');
var visParams = {bands: ['B4', 'B3', 'B2'], max: 2048, gamma: 1};
var layer = ui.Map.Layer(image, visParams);

// Update the map by updating the layers list.
var layers = consoleMap.layers();
layers.add(layer);

// Make a textbox to accept a gamma value.
// Update the layer when the gamma value is entered.
var gammaBox = ui.Textbox({
  value: 1,
  onChange: function(value) {
    // visParams is NOT an ActiveDictionary, so set it again.
    visParams.gamma = value;
    layer.setVisParams(visParams);
  }
});

print(ui.Label('Enter a gamma value:'));
print(gammaBox);
print(consoleMap);

ui.Map.CloudStorageLayer

Wenn Sie eine relativ rechenintensive Ebene anzeigen möchten (z.B. in einer App), kann es aus Leistungsgründen sinnvoll sein, Ihre Daten in einen Cloud Storage-Bucket zu exportieren. Diese statischen, reinen Visualisierungsebenen können die Reaktionsfähigkeit Ihrer Anwendungen und Skripts verbessern. Zu diesem Zweck können Sie mit Export.map.toCloudStorage() eine statische Darstellungsebene erstellen. Wenn Sie ein zuvor von Export.map.toCloudStorage() exportiertes TileSet verwenden möchten, erstellen Sie ein neues ui.Map.Layer aus einem angegebenen Cloud Storage-Bucket und -Pfad:

Map.add(ui.Map.CloudStorageLayer({
  bucket: 'earthenginepartners-hansen',
  path: 'tiles/gfc_v1.4/loss_year',
  maxZoom: 12,
  suffix: '.png'
}));

Wenn Sie ein Script ausführen, das eine Cloud Storage-Ebene lädt, wird möglicherweise die folgende Warnmeldung angezeigt:

Warnung zur Wolkenebene

ui.Map.DrawingTools

Im Code-Editor wird der Map standardmäßig eine Reihe von Geometrie-Zeichentools hinzugefügt. Sie können das Verhalten dieser Tools im Standard-Map ändern, indem Sie Map.drawingTools() aufrufen. So blenden Sie beispielsweise die Zeichentools aus:

Code-Editor (JavaScript)

Map.drawingTools().setShown(false);

Neu erstellte Karten enthalten standardmäßig keine Zeichentools. Sie können sie aber aktivieren, indem Sie die Methode drawingTools() für die Karte aufrufen:

Code-Editor (JavaScript)

var map = ui.Map();
// Prints true since drawingTools() adds drawing tools to the map.
print(map.drawingTools().getShown());
// Replace the default Map with the newly created map.
ui.root.widgets().reset([map]);

Die von den Zeichentools gezeichneten Geometrieebenen werden in ein ui.data.ActiveList eingefügt, auf das Sie durch Aufrufen von Map.drawingTools().layers() zugreifen können. Die Liste der Geometrieebenen reagiert auf Ereignisse wie andere aktive Listen, z. B. die Liste der Ebenen auf der Map, die von Map.layers() zurückgegeben wird. Im folgenden Beispiel wird gezeigt, wie Sie die Sichtbarkeit der von den Tools gezeichneten Geometrieebenen festlegen, die standardmäßig angezeigt werden:

Code-Editor (JavaScript)

Map.drawingTools().layers().forEach(function(layer) {
  layer.setShown(false);
});

Wenn Sie den Zeichentools eine Ebene programmatisch hinzufügen möchten, können Sie entweder die Methode addLayer für die Zeichentools aufrufen oder eine Ebene direkt der Ebenenliste hinzufügen:

Code-Editor (JavaScript)

var geometries = [ee.Geometry.Point([0,0]), ee.Geometry.Rectangle([[0,0], [1,1]])];
Map.drawingTools().addLayer(geometries, 'my_geometry1', 'red');

var layer = ui.Map.GeometryLayer(geometries, 'my_geometry2', 'blue');
Map.drawingTools().layers().add(layer);

Der Status der Zeichentools wird auch übernommen, wenn Sie eine App veröffentlichen. Wenn Sie die Zeichentools ein- oder ausgeblendet haben, werden sie auch in Ihrer App ein- oder ausgeblendet. Die Geometrien in Ihren Importen werden ebenfalls in Ihre App übernommen.

ui.Map.GeometryLayer

Eine GeometryLayer ist eine Sammlung von Geometrien, die als einzelnes Geometry, GeometryCollection oder FeatureCollection fungiert, das oben im Skript im Abschnitt „Imports“ hinzugefügt wird und im Code referenziert werden kann.

GeometryLayers, die mit den Zeichentools gezeichnet werden, haben ein Standardverhalten, das Sie durch die Angabe neuer Callback-Funktionen überschreiben können. Angenommen, Sie möchten, dass interaktive Änderungen an den Geometrien ein Ereignis auslösen. Wenn Sie ein bestimmtes Verhalten implementieren möchten, können Sie die Methoden onEdit(), onErase() oder onDraw() für die Tools festlegen, um auf Nutzeraktionen zu reagieren. Im folgenden Beispiel wird gezeigt, wie eine Berechnung ausgelöst und ein Label mit dem Berechnungsergebnis aktualisiert wird, wenn der Nutzer eine Geometrie hinzufügt, bearbeitet oder löscht:

Code-Editor (JavaScript)

// Load elevation data.
var srtm = ee.Image('NASA/NASADEM_HGT/001').select('elevation');
Map.addLayer(srtm, {min: 0, max: 5000}, 'SRTM');

// Make a label to display mean elevation at drawn points.
var label = new ui.Label('Draw points to calculate mean elevation');
var inspector = new ui.Panel([label]);
Map.add(inspector);
// Don't make imports that correspond to the drawn points.
Map.drawingTools().setLinked(false);
// Limit the draw modes to points.
Map.drawingTools().setDrawModes(['point']);
// Add an empty layer to hold the drawn points.
Map.drawingTools().addLayer([]);
// Set the geometry type to be point.
Map.drawingTools().setShape('point');
// Enter drawing mode.
Map.drawingTools().draw();

// This function gets called when the geometry layer changes.
// Use debounce to call the function at most every 100 milliseconds.
var getAverageElevation = ui.util.debounce(function() {
  var points = Map.drawingTools().layers().get(0).toGeometry();
  var elevation = srtm.reduceRegion({
    reducer: ee.Reducer.mean(),
    geometry: points,
    scale: 30
  }).get('elevation');
  // Asynchronously evaluate the mean elevation.
  elevation.evaluate(showElevation);
}, 100);

// Set the callback function on changes of the geometry layer.
Map.drawingTools().onEdit(getAverageElevation);
Map.drawingTools().onDraw(getAverageElevation);
Map.drawingTools().onErase(getAverageElevation);

// Set the label to the result of the mean reduction.
function showElevation(elevation) {
  inspector.clear();
  var elevationLabel = ui.Label('Mean elevation: ' + elevation);
  inspector.add(elevationLabel);
}

Mit setLinked() wird die Verbindung zwischen den Tools zum Zeichnen von Geometrien und dem Abschnitt Importe des Code-Editors ein- und ausgeschaltet. In diesem Beispiel sind die Geometrietools nicht verknüpft, um zu verhindern, dass Importe erstellt werden. toGeometry wird verwendet, um die Ebene in ein ee.Geometry zu konvertieren. Wenn die importierte Ebene ein Feature oder FeatureCollection ist, können Sie das zugrunde liegende EE-Objekt mit getEeObject() abrufen. Beachten Sie auch die Verwendung von ui.util.debounce, um zu verhindern, dass jede Bewegung einer Geometrie die Callback-Funktion auslöst. Konkret wird die Funktion erst ausgelöst, wenn seit dem letzten Ereignis 100 Millisekunden vergangen sind. So wird sichergestellt, dass die Funktion nur ausgeführt wird, wenn der Nutzer die Bearbeitung abgeschlossen hat.

Eine Geometrieebene in den Importen ist mit einem Geometry oder GeometryCollection verknüpft. Sie kann daher nur Geometrien mit demselben geodätischen Zustand enthalten, da das GeoJSON-Format nur einen einzigen geodätischen Zustand für die Sammlung von Geometrien zulässt. Weitere Informationen finden Sie auf der Seite Geodätische und planare Geometrien. Wenn Sie die Geometrieebene in ein FeatureCollection konvertieren, indem Sie auf das Zahnradsymbol neben dem Ebenennamen klicken, können Sie geodätische und planare Geometrien zur selben Ebene hinzufügen. Wenn Sie ihn jedoch wieder in einen Geometry-Wert konvertieren, wird ein Fehler ausgegeben. Um dies zu vermeiden, konvertieren Sie entweder in eine FeatureCollection oder löschen Sie Geometrien, bis nur noch ein geodätischer Zustand in der Ebene vorhanden ist.

ui.Map.Linker

Wie eine Ebene ist ein Linker kein Widget, das sich gestalten lässt. Es ist ein Dienstprogramm im Hintergrund, mit dem die Bewegung mehrerer ui.Map-Instanzen synchronisiert werden kann:

Code-Editor (JavaScript)

// Add two maps to the screen.
var left = ui.Map();
var right = ui.Map();
ui.root.clear();
ui.root.add(left);
ui.root.add(right);

// Link the "change-bounds" event for the maps.
// When the user drags one map, the other will be moved in sync.
ui.Map.Linker([left, right], 'change-bounds');

ui.SplitPanel

Ein ui.SplitPanel ist nützlich, um Dinge nebeneinander zu vergleichen. Der Vorteil eines ui.SplitPanel gegenüber zwei normalen Bereichen besteht darin, dass ein Ziehpunkt verwendet werden kann, um einen Wischübergang zwischen den Bereichen in einem ui.SplitPanel zu erzielen. Im folgenden Beispiel wird ein ui.SplitPanel verwendet, um die spektralen Unterschiede von Brandnarben darzustellen:

Code-Editor (JavaScript)

// Load an image of the Santa Rosa, California 2017 fires.
var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_045033_20171011');

// Add a color-SWIR composite to the default Map.
Map.setCenter(-122.6624, 38.5011, 12);
Map.addLayer(image, {bands: ['B7', 'B5', 'B3'], max: 0.3}, 'color-SWIR');

// Make another map and add a color-NIR composite to it.
var linkedMap = ui.Map();
linkedMap.addLayer(image, {bands: ['B5', 'B4', 'B3'], max: 0.3}, 'color-NIR');
// Add a thermal image to the map.
linkedMap.addLayer(image, {
  bands: ['B11'],
  min: 290,
  max: 305,
  palette: ['gray', 'white', 'yellow', 'red']
}, 'Thermal');

// Link the default Map to the other map.
var linker = ui.Map.Linker([ui.root.widgets().get(0), linkedMap]);

// Make an inset map and add it to the linked map.
var inset = ui.Map();
inset.style().set({position: 'bottom-right', width: '300px', height: '250px'});
inset.setControlVisibility({all: false, mapTypeControl: true});
linkedMap.add(inset);

// Register a function to the linked map to update the inset map.
linkedMap.onChangeBounds(function() {
  var bounds = ee.Geometry.Rectangle(Map.getBounds());
  inset.centerObject(bounds);
  inset.layers().set(0, bounds);
});

// Create a SplitPanel which holds the linked maps side-by-side.
var splitPanel = ui.SplitPanel({
  firstPanel: linker.get(0),
  secondPanel: linker.get(1),
  orientation: 'horizontal',
  wipe: true,
  style: {stretch: 'both'}
});

// Set the SplitPanel as the only thing in root.
ui.root.widgets().reset([splitPanel]);

Beachten Sie, dass der Parameter wipe im Konstruktor ui.SplitPanel auf true festgelegt ist, damit der Nutzer den Ziehpunkt zwischen den beiden Visualisierungen hin- und herziehen kann.

Stil-Widgets

Der Stil eines Widgets wird durch das Wörterbuch der Stileigenschaften des Widgets gesteuert. Sie können auf das Wörterbuch zugreifen, indem Sie style() für das Widget aufrufen. Das von style() zurückgegebene Objekt ist eine Instanz von ui.data.ActiveDictionary. Das bedeutet, dass durch das Festlegen von Attributen des Stil-Dictionarys die Darstellung des Widgets automatisch aktualisiert wird. Die zulässigen Schlüssel für das Stil-Dictionary der einzelnen Widgets sind in den Referenzdokumenten des Widgets für den Aufruf style() beschrieben.

Die Stile des Widgets können mit dem Konstruktor festgelegt werden, indem style().set() oder style() mit einem Wörterbuchargument aufgerufen wird. Beispiel:

Code-Editor (JavaScript)

var redLabel = ui.Label('Big, Red Label');

redLabel.style().set('color', 'red');
redLabel.style().set('fontWeight', 'bold');
redLabel.style().set({
  fontSize: '32px',
  padding: '10px'
});

print(redLabel);

In diesem Beispiel wird das Label zuerst durch Aufrufen von style().set() mit Schlüssel- und Wertargumenten und dann durch Aufrufen von style().set() mit einem Wörterbuchargument formatiert. Der zweite Aufruf überschreibt den ersten nicht. Er fügt einzelne Stileigenschaften hinzu und ersetzt sie, anstatt das gesamte Stilwörterbuch zu ersetzen.

Weitere Informationen zu den Stiloptionen für Widgets finden Sie in dieser CSS-Referenz (Cascading Style Sheet) für die Stile, die in der style()-Dokumentation für jedes Widget aufgeführt sind. Die für Earth Engine-Widgets zulässigen Stile unterscheiden sich an mehreren Stellen von CSS-Stilen, insbesondere fontSize und fontWeight für font-style bzw. font-weight.

Das Styles-Dictionary enthält auch Schlüssel, die die Position des Widgets steuern. Weitere Informationen zur Verwendung von Positionseigenschaften finden Sie auf der Seite Bereiche und Layouts.