* Alle Formen sind als Unterklassen von {@code Shape} implementiert. *
@@ -19,7 +20,6 @@ import java.awt.geom.Point2D; * Parametern initialisiert und einen, der die Werte einer anderen Form * desselben Typs übernimmt. In der Klasse {@link Circle} sind die Konstruktoren * beispielsweise so implementiert: - * *
* public Circle( double x, double y, double radius ) {
* super(x, y);
@@ -39,42 +39,42 @@ import java.awt.geom.Point2D;
public abstract class Shape extends BasicDrawable {
/**
- * x-Koordinate der Form.
+ * Speichert die x-Koordinate der Form.
*/
protected double x;
/**
- * y-Koordinate der Form.
+ * Speichert die y-Koordinate der Form.
*/
protected double y;
/**
- * Rotation in Grad um den Punkt (x, y).
+ * Speichert die Rotation in Grad um den Punkt (x, y).
*/
protected double rotation = 0.0;
/**
- * Skalierungsfaktor.
+ * Speichert den Skalierungsfaktor.
*/
protected double scale = 1.0;
/**
- * Ankerpunkt der Form.
+ * Speichert den Ankerpunkt.
*/
protected Options.Direction anchor = Options.Direction.CENTER;
/**
- * Setzt die x- und y-Koordinate der Form auf 0.
+ * Erstellt eine neue Form mit den Koordinaten {@code (0,0)}.
*/
public Shape() {
this(0.0, 0.0);
}
/**
- * Setzt die x- und y-Koordinate der Form.
+ * Erstellt eine Form mit den angegebenen Koordinaten.
*
- * @param x
- * @param y
+ * @param x Die x-Koordinate.
+ * @param y Die y-Koordinate.
*/
public Shape( double x, double y ) {
this.x = x;
@@ -82,7 +82,7 @@ public abstract class Shape extends BasicDrawable {
}
/**
- * Gibt die x-Koordinate der Form zurück.
+ * Liefert die aktuelle x-Koordinate der Form.
*
* @return Die x-Koordinate.
*/
@@ -100,7 +100,7 @@ public abstract class Shape extends BasicDrawable {
}
/**
- * Gibt die y-Koordinate der Form zurück.
+ * Liefert die aktuelle y-Koordinate der Form.
*
* @return Die y-Koordinate.
*/
@@ -109,57 +109,44 @@ public abstract class Shape extends BasicDrawable {
}
/**
- * Setzt die y-Koordinate der Form.
+ * Setzt die x-Koordinate der Form.
*
- * @param y Die neue y-Koordinate.
+ * @param y Die neue y-Koordinate der Form.
*/
public void setY( double y ) {
this.y = y;
}
/**
- * Gibt die Breite dieser Form zurück.
+ * Liefert die aktuelle Breite dieser Form.
*
* Die Breite einer Form ist immer die Breite ihrer Begrenzung,
* bevor Drehungen und andere Transformationen auf sie
* angewandt wurden.
*
- * Die Begrenzungen der tatsächlich gezeichneten Form kann mit
- * {@link #getBounds()} abgerufen werden.
+ * Die Begrenzungen der tatsächlich gezeichneten Form wird mit
+ * {@link #getBounds()} abgerufen.
*
- * @return
+ * @return Die Breite der Form.
*/
public abstract double getWidth();
/**
- * Gibt die Höhe dieser Form zurück.
+ * Liefert die aktuelle Höhe dieser Form.
*
* Die Höhe einer Form ist immer die Höhe ihrer Begrenzung,
* bevor Drehungen und andere Transformationen auf sie
* angewandt wurden.
*
- * Die Begrenzungen der tatsächlich gezeichneten Form kann mit
- * {@link #getBounds()} abgerufen werden.
+ * Die Begrenzungen der tatsächlich gezeichneten Form wird mit
+ * {@link #getBounds()} abgerufen.
*
- * @return
+ * @return Die Höhe der Form.
*/
public abstract double getHeight();
- @Override
- public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to, Options.Direction dir ) {
- Point2D apDir = getAbsAnchorPoint(dir);
- Point2D apInv = getAbsAnchorPoint(dir.inverse());
- setGradient(apInv.getX(), apInv.getY(), from, apDir.getX(), apDir.getY(), to);
- }
-
- @Override
- public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to ) {
- Point2D ap = getAbsAnchorPoint(CENTER);
- setGradient(ap.getX(), ap.getY(), Math.min(ap.getX(), ap.getY()), from, to);
- }
-
/**
- * Gibt die Rotation in Grad zurück.
+ * Liefert die Rotation in Grad.
*
* @return Rotation in Grad.
*/
@@ -176,14 +163,25 @@ public abstract class Shape extends BasicDrawable {
this.rotation += angle % 360;
}
- public void rotateTo( double angle ) {
- this.rotation = angle % 360;
- }
-
+ /**
+ * Dreht die Form um den angegebenen Winkel um das angegebene Drehzentrum.
+ *
+ * @param center Das Drehzentrum der Drehung.
+ * @param angle Der Drehwinkel.
+ */
public void rotate( Point2D center, double angle ) {
+ Validator.requireNotNull(center, "center");
rotate(center.getX(), center.getY(), angle);
}
+ /**
+ * Dreht die Form um den angegebenen Drehwinkel um die angegbenen
+ * Koordinaten als Drehzentrum.
+ *
+ * @param x x-Koordiante des Drehzentrums.
+ * @param y y-Koordiante des Drehzentrums.
+ * @param angle Drehwinkel in Grad.
+ */
public void rotate( double x, double y, double angle ) {
this.rotation += angle % 360;
@@ -198,6 +196,15 @@ public abstract class Shape extends BasicDrawable {
this.y = y2 + y;
}
+ /**
+ * Setzt die Drehung der Form auf den angegebenen Winkel.
+ *
+ * @param angle Drehwinkel in Grad.
+ */
+ public void rotateTo( double angle ) {
+ this.rotation = angle % 360;
+ }
+
/**
* Gibt den aktuellen Skalierungsfaktor zurück.
*
@@ -207,33 +214,91 @@ public abstract class Shape extends BasicDrawable {
return scale;
}
+ /**
+ * Setzt den Skalierungsfaktor auf den angegebenen Faktor.
+ *
+ * Bei einem Faktor größer 0 wird die Form vergrößert, bei einem Faktor
+ * kleiner 0 verkleinert. Bei negativen Werten wird die Form entlang der x-
+ * bzw. y-Achse gespiegelt.
+ *
+ * Das Seitenverhältnis wird immer beibehalten.
+ *
+ * @param factor Der Skalierungsfaktor.
+ */
public void scale( double factor ) {
scale = factor;
}
+ /**
+ * Skaliert die Form um den angegebenen Faktor.
+ *
+ * Bei einem Faktor größer 0 wird die Form vergrößert, bei einem Faktor
+ * kleiner 0 verkleinert. Bei negativen Werten wird die Form entlang der x-
+ * bzw. y-Achse gespiegelt.
+ *
+ * Die Skalierung wird zusätzlich zur aktuellen Skalierung angewandt. Wurde
+ * die Form zuvor um den Faktor 0.5 verkleinert und wird dann um 1.5
+ * vergrößert, dann ist die Form im Anschluss ein Drittel kleiner als zu
+ * Beginn ({@code 0.5 * 1.5 = 0.75}).
+ *
+ * @param factor Der Skalierungsfaktor.
+ */
public void scaleBy( double factor ) {
scale(scale * factor);
}
+ /**
+ * Liefert den aktuellen Ankerpunkt der Form.
+ *
+ * @return Der Ankerpunkt.
+ */
public Options.Direction getAnchor() {
return anchor;
}
/**
- * Setzt den Ankerpunkt der Form basierend auf der angegebenen
- * {@link Options.Direction Richtung}.
+ * Setzt den Ankerpunkt der Form auf die angegebene Richtung.
*
- * Für das Setzen des Ankers muss das
- * {@link #getBounds() begrenzende Rechteck} berechnet werden. Unterklassen
- * sollten die Methode überschreiben, wenn der Anker auch direkt gesetzt
- * werden kann.
+ * Jede Form hat einen Ankerpunkt, von dem aus sie gezeichnet wird. Jede
+ * {@link schule.ngb.zm.Options.Direction Richtung} beschreibt einen der
+ * Neun Ankerpunkte:
+ *
+ * NW────N────NE
+ * │ │
+ * │ │
+ * W C E
+ * │ │
+ * │ │
+ * SW────S────SE
+ *
+ *
+ * Für den Ankerpunkt {@link #CENTER} wird die Form also ausgehend von den
+ * Koordinaten {@link #x} und {@link #y} um die Hälfte der Breite nach links
+ * und rechts, sowie um die Hälfte der Höhe nach oben und unten gezeichnet.
+ * Fpr den Ankerpunkt {@link #NORTHWEST} dagegen um die gesamte Breite nach
+ * rechts und die Höhe nach unten.
+ *
+ * setAnchor(CENTER) │ setAnchor(NORTHWEST)
+ * ┌───────────┐ │
+ * │ │ │
+ * │ │ │
+ * │ (x,y) │ │ (x,y)─────────┐
+ * │ │ │ │ │
+ * │ │ │ │ │
+ * └───────────┘ │ │ │
+ * │ │ │
+ * │ │ │
+ * │ └───────────┘
+ *
+ *
+ * Der Ankerpunkt der Form bestimmt bei Transformationen auch die Position
+ * des Drehzentrums und anderer relativer Koordinaten bezüglich der Form.
*
- * @param anchor
+ * @param anchor Der Ankerpunkt.
*/
public void setAnchor( Options.Direction anchor ) {
- if( anchor != null ) {
- this.anchor = anchor;
- }
+ Validator.requireNotNull(anchor, "anchor");
+ this.anchor = anchor;
}
/**
@@ -242,7 +307,19 @@ public abstract class Shape extends BasicDrawable {
*
* Die Koordinaten des Ankerpunktes werden relativ zur oberen linken Ecke
* des Rechtecks mit der Breite {@code width} und der Höhe {@code height}
- * bestimmt.
+ * bestimmt. Der Ankerpunkt {@link #NORTHWEST} hat daher immer das Ergebnis
+ * {@code (0,0)} und {@link #SOUTHEAST} {@code (width, height)}.
+ *
+ * (0,0)───(w/2,0)───(w,0)
+ * │ │
+ * │ │
+ * │ │
+ * (0,h/2) (w/2,h/2) (w,h/2)
+ * │ │
+ * │ │
+ * │ │
+ * (0,h)───(w/2,h)───(w,h)
+ *
*
* @param width Breite des umschließenden Rechtecks.
* @param height Höhe des umschließenden Rechtecks.
@@ -259,11 +336,12 @@ public abstract class Shape extends BasicDrawable {
}
/**
- * Bestimmt den Ankerpunkt der Form relativ zum gesetzten
- * {@link #setAnchor(Options.Direction) Ankerpunkt}.
+ * Bestimmt die Koordinaten des angegebenen Ankers der Form relativ zum
+ * aktuellen {@link #setAnchor(Options.Direction) Ankerpunkt}.
*
- * @param anchor Die Richtung des Ankerpunktes.
+ * @param anchor Die Richtung des Ankers.
* @return Der relative Ankerpunkt.
+ * @see #getAnchorPoint(double, double, Options.Direction)
*/
public Point2D.Double getAnchorPoint( Options.Direction anchor ) {
double wHalf = getWidth() * .5, hHalf = getHeight() * .5;
@@ -276,11 +354,20 @@ public abstract class Shape extends BasicDrawable {
}
/**
- * Ermittelt die absoluten Koordinaten eines angegebenen
+ * Ermittelt die absoluten Koordinaten des angegebenen
* {@link #setAnchor(Options.Direction) Ankers}.
+ *
+ * Die absoluten Koordinaten werden bestimmt durch die Position der Form
+ * {@code (x,y)} plus die
+ * {@link #getAnchorPoint(Options.Direction) relativen Koordinaten} des
+ * Ankers.
*
- * @param anchor Die Richtung des Ankerpunktes.
+ * Wichtig: Die Berechnung berücksichtigt derzeit keine Rotationen
+ * und Transformationen der Form.
+ *
+ * @param anchor Die Richtung des Ankers.
* @return Der absolute Ankerpunkt.
+ * @see #getAnchorPoint(double, double, Options.Direction)
*/
public Point2D.Double getAbsAnchorPoint( Options.Direction anchor ) {
// TODO: Die absoluten Anker müssten eigentlich die Rotation berücksichtigen.
@@ -293,20 +380,22 @@ public abstract class Shape extends BasicDrawable {
/**
* Kopiert die Eigenschaften der angegebenen Form in diese.
*
- * Unterklassen sollten diese Methode überschreiben, um weitere
- * Eigenschaften zu kopieren (zum Beispiel den Radius eines Kreises).
- * Unterklassen sollten immer mit dem Aufruf {@code super.copyFrom(shape)}
- * die Basiseigenschaften kopieren.
+ * Unterklassen überschreiben diese Methode, um weitere Eigenschaften zu
+ * kopieren (zum Beispiel den Radius eines Kreises). Überschreibende
+ * Methoden sollten immer mit dem Aufruf {@code super.copyFrom(shape)} die
+ * Basiseigenschaften kopieren.
*
- * Die Methode sollte so viele Eigenschaften wie möglich von der anderen
- * Form in diese kopieren. Wenn die andere Form einen anderen Typ hat, dann
- * werden trotzdem die Basiseigenschaften (Konturlinie, Füllung, Position,
- * Rotation, Skalierung, Sichtbarkeit und Ankerpunkt) in diese Form kopiert.
- * Implementierende Unterklassen können soweit sinnvoll auch andere Werte
- * übernehmen. Eine {@link Ellipse} kann beispielsweise auch die Breite und
- * Höhe eines {@link Rectangle} übernehmen.
+ * Die Methode kopiert so viele Eigenschaften wie möglich von der
+ * angegebenen Form in diese. Wenn die andere Form einen anderen Typ hat,
+ * dann werden trotzdem die Basiseigenschaften (Konturlinie, Füllung,
+ * Position, Rotation, Skalierung, Sichtbarkeit und Ankerpunkt) in diese
+ * Form kopiert. Soweit sinnvoll übernehmen implementierende Unterklassen
+ * auch andere Werte. Eine {@link Ellipse} kopiert beispielsweise auch die
+ * Breite und Höhe eines {@link Rectangle}.
+ *
+ * Wird {@code null} übergeben, dann passiert nichts.
*
- * @param shape Die Originalform, von der kopiert werden soll.
+ * @param shape Die Originalform, von der kopiert wird.
*/
public void copyFrom( Shape shape ) {
if( shape != null ) {
@@ -335,9 +424,9 @@ public abstract class Shape extends BasicDrawable {
*
* Die Methode kann beliebig umgesetzt werden, um eine 1-zu-1-Kopie dieser - * Form zu erhalten. In der Regel sollte aber jede Form einen Konstruktor - * besitzen, die alle Werte einer andern Form übernimmt. Die gezeigte - * Implementierung dürfte daher im Regelfall ausreichend sein. + * Form zu erhalten. In der Regel besitzt aber jede Form einen Konstruktor, + * der alle Werte einer andern Form übernimmt. Die gezeigte Implementierung + * ist daher im Regelfall ausreichend. * * @return Eine genaue Kopie dieser Form. */ @@ -348,8 +437,8 @@ public abstract class Shape extends BasicDrawable { * zurück. Intern werden die AWT Shapes benutzt, um sie auf den * {@link Graphics2D Grafikkontext} zu zeichnen. *
- * Wenn diese Form nicht durch eine AWT-Shape dargestellt wird, kann die - * Methode {@code null} zurückgeben. + * Wenn diese Form nicht durch eine AWT-Shape dargestellt wird, liefert die + * Methode {@code null}. * * @return Eine Java-AWT {@code Shape} die diese Form repräsentiert oder * {@code null}. @@ -369,34 +458,85 @@ public abstract class Shape extends BasicDrawable { return new Bounds(this); } + /** + * Verschiebt die Form um die angegebenen Werte entlang der + * Koordinatenachsen. + * + * @param dx Verschiebung entlang der x-Achse. + * @param dy Verschiebung entlang der y-Achse. + */ public void move( double dx, double dy ) { x += dx; y += dy; } + /** + * Bewegt die Form an die angegebenen Koordinaten. + * + * @param x Die neue x-Koordinate. + * @param y Die neue y-Koordinate. + */ public void moveTo( double x, double y ) { this.x = x; this.y = y; } + /** + * Bewegt die Form an dieselben Koordinaten wie die angegebene Form. + * + * @param shape Eine andere Form. + */ public void moveTo( Shape shape ) { moveTo(shape.getX(), shape.getY()); } + /** + * Bewegt die Form zum angegebenen Ankerpunkt der angegebenen Form. + * + * @param shape Die andere Form. + * @param dir Die Richtung des Ankerpunktes. + * @see #moveTo(Shape, Options.Direction, double) + */ public void moveTo( Shape shape, Options.Direction dir ) { moveTo(shape, dir, 0.0); } /** - * Bewegt den Ankerpunkt dieser Form zu einem Ankerpunkt einer anderen Form. - * Mit {@code buff} kann ein zusätzlicher Abstand angegeben werden, um den - * die Form entlang des Ankerpunktes {@code anchor} verschoben werden soll. + * Bewegt den Ankerpunkt dieser Form zu einem Ankerpunkt einer anderen + * Form. + *
+ * Mit {@code buff} wird ein zusätzlicher Abstand angegeben, um den die Form + * entlang des Ankerpunktes {@code anchor} verschoben wird. + *
* Ist der Anker zum Beispiel {@code NORTH}, dann wird die Form um - * {@code buff} nach oben verschoben. + * {@code buff} oberhalb der oberen Kante der zweiten Form verschoben. + *
+ * Befinden sich die Formen zuvor in folgender Ausrichtung: + *
+ * ┌─────────┐ + * │ │ + * W B │ + * ┌─────┐ │ │ + * │ │ └─────────┘ + * W A │ + * │ │ + * └─────┘ + *+ *
+ * bringt sie der Aufruf {@code B.moveTo(A, DOWN, 0)} in diese Ausrichtung: + *
+ * B.moveTo(A, WEST, 0) │ B.moveTo(A, WEST, 10) + * │ + * ┌─────┬───┐ │ ┌┬────┬────┐ + * │ │ │ │ ││ │ │ + * │ A B│ │ │ ││ A B │ + * │ │ │ │ ││ │ │ + * └─────┴───┘ │ └┴────┴────┘ + ** - * @param shape - * @param dir - * @param buff + * @param shape Die andere Form. + * @param dir Die Richtung des Ankerpunktes. + * @param buff Der Abstand zum angegebenen Ankerpunkt. */ public void moveTo( Shape shape, Options.Direction dir, double buff ) { Point2D ap = shape.getAbsAnchorPoint(dir); @@ -406,15 +546,22 @@ public abstract class Shape extends BasicDrawable { } /** - * Richtet die Form entlang der angegebenen Richtung am Rand der - * Zeichenfläche aus. + * Bewegt die Form an den Rand der Zeichenfläche in der angegebenen + * Richtung. * - * @param dir Die Richtung der Ausrichtung. + * @param dir Die Richtung. */ public void alignTo( Options.Direction dir ) { alignTo(dir, 0.0); } + /** + * Bewegt die Form mit dem angegebenen Abstand an den Rand der Zeichenfläche + * in der angegebenen Richtung aus. + * + * @param dir Die Richtung. + * @param buff Der Abstand zum Rand. + */ public void alignTo( Options.Direction dir, double buff ) { Point2D anchorShape = Shape.getAnchorPoint(canvasWidth, canvasHeight, dir); Point2D anchorThis = this.getAbsAnchorPoint(dir); @@ -423,20 +570,58 @@ public abstract class Shape extends BasicDrawable { this.y += Math.abs(dir.y) * (anchorShape.getY() - anchorThis.getY()) + dir.y * buff; } + /** + * Bewegt den Ankerpunkt dieser Form in der angegebenen Richtung zum + * Gleichen Ankerpunkt der anderen Form. + * + * @param shape Die andere Form. + * @param dir Die Richtung des Ankerpunktes. + * @see #alignTo(Shape, Options.Direction, double) + */ public void alignTo( Shape shape, Options.Direction dir ) { alignTo(shape, dir, 0.0); } /** * Richtet die Form entlang der angegebenen Richtung an einer anderen Form - * aus. Für {@code DOWN} wird beispielsweise die y-Koordinate der unteren - * Kante dieser Form an der unteren Kante der angegebenen Form {@code shape} - * ausgerichtet. Die x-Koordinate wird nicht verändert. {@code buff} gibt - * einen Abstand ab, um den diese From versetzt ausgerichtet werden soll. + * aus. + *
+ * {@code buff} gibt einen Abstand ab, um den diese From versetzt + * ausgerichtet wird. + *
+ * Für {@link #DOWN} wird beispielsweise die y-Koordinate der unteren Kante + * dieser Form an der unteren Kante von {@code shape} ausgerichtet. Die + * x-Koordinate wird in dem Fall nicht verändert. + *
+ * Befinden sich die Formen beispielsweise in folgender Position: + *
+ * ┌─────┐ + * │ │ + * │ B │ + * ┌─────┐ │ │ + * │ │ └──D──┘ + * │ A │ + * │ │ + * └──D──┘ + *+ *
+ *
+ * werden sie durch {@code alignTo} so positioniert: + *
+ * B.alignTo(A, EAST, 0) │ B.alignTo(A, EAST, 10) + * │ + * ┌─────┐ ┌─────┐ │ ┌─────┐ + * │ │ │ │ │ │ │ ┌─────┐ + * │ A │ │ B │ │ │ A │ │ │ + * │ │ │ │ │ │ │ │ B │ + * └──D──┘ └──D──┘ │ └──D──┘ │ │ + * │ └──D──┘ + * │ + ** - * @param shape - * @param dir - * @param buff + * @param shape Die andere Form. + * @param dir Die Richtung. + * @param buff Der Abstand. */ public void alignTo( Shape shape, Options.Direction dir, double buff ) { Point2D anchorShape = shape.getAbsAnchorPoint(dir); @@ -446,16 +631,46 @@ public abstract class Shape extends BasicDrawable { this.y += Math.abs(dir.y) * (anchorShape.getY() - anchorThis.getY()) + dir.y * buff; } + /** + * @param shape + * @param dir + * @see #nextTo(Shape, Options.Direction, double) + */ public void nextTo( Shape shape, Options.Direction dir ) { nextTo(shape, dir, DEFAULT_BUFFER); } /** * Bewegt die Form neben eine andere in Richtung des angegebenen - * Ankerpunktes. Im Gegensatz zu - * {@link #moveTo(Shape, Options.Direction, double)} wird die Breite bzw. - * Höhe der Formen berücksichtigt und die Formen so platziert, dass keine - * Überlappungen vorhanden sind. + * Ankerpunktes. + *
+ * Im Gegensatz zu {@link #moveTo(Shape, Options.Direction, double)} wird + * die Breite bzw. Höhe der Formen berücksichtigt und die Formen so + * platziert, dass keine Überlappungen vorhanden sind. + *
+ * Befinden sich die Formen zuvor in folgender Ausrichtung: + *
+ * ┌─────┐ + * │ │ + * W B │ + * ┌──────┐ │ │ + * │ │ └─────┘ + * │ A E + * │ │ + * └──────┘ + *+ *
+ * bringt sie der Aufruf {@code B.nextTo(A, EAST, 0)} in diese Ausrichtung: + *
+ * B.nextTo(A, EAST, 0) │ B.nextTo(A, EAST, 10) + * │ + * ┌─────┬─────┐ │ ┌─────┐ ┌─────┐ + * │ │ │ │ │ │ │ │ + * │ A │ B │ │ │ A │ │ B │ + * │ │ │ │ │ │ │ │ + * └─────┴─────┘ │ └─────┘ └─────┘ + * │ + ** * @param shape * @param dir @@ -469,6 +684,19 @@ public abstract class Shape extends BasicDrawable { this.y += (anchorShape.getY() - anchorThis.getY()) + dir.y * buff; } + @Override + public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to, Options.Direction dir ) { + Point2D apDir = getAbsAnchorPoint(dir); + Point2D apInv = getAbsAnchorPoint(dir.inverse()); + setGradient(apInv.getX(), apInv.getY(), from, apDir.getX(), apDir.getY(), to); + } + + @Override + public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to ) { + Point2D ap = getAbsAnchorPoint(CENTER); + setGradient(ap.getX(), ap.getY(), Math.min(ap.getX(), ap.getY()), from, to); + } + /*public void shear( double dx, double dy ) { verzerrung.shear(dx, dy); }*/