public/web-development/presentation.git

			@@ -2125,6 +2125,1295 @@
			</code>
			</pre>
			</section>
			<section>
			<h3>this</h3>
			<pre>
			<code class="js" data-trim data-line-numbers>
			class MyClass {
			constructor(a) {
			this.a = a;
			}

			getA() {
			return this.a;
			}
			}

			const x = new MyClass(5);
			const y = new MyClass(10);

			console.log(x.getA());
			console.log(y.getA());
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			5
			10
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			global.a = 5;

			function foo() {
			this.a += 10;
			}

			foo();

			console.log(a);
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			15
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			class MyClass {
			/* ... */
			setA() {
			function f() {
			this.a += 100;
			}
			f();
			}
			}

			const x = new MyClass(5);

			x.setA();

			console.log(x.getA());
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			TypeError: Cannot read property 'a' of undefined
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			class MyClass {
			/* ... */
			setA() {
			const me = this;
			function f() {
			me.a += 100;
			}
			f();
			}
			}

			const x = new MyClass(5);

			x.setA();

			console.log(x.getA());
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			105
			</code>
			</pre>
			</section>
			<section>
			<h3>Arrow-Funktionen</h3>
			<ul>
			<li>Kompakte Schreibweise einer normalen Funktion</li>
			<li>Bei Einzeilern ist das <code>return</code> nicht notwendig</li>
			<li>this-Pointer des aktuellen Kontextes wird beibehalten</li>
			</ul>
			<pre>
			<code class="js" data-trim data-line-numbers>
			// Einzeiler
			const f1 = _ => 1;
			const f2 = () => 1;
			const f3 = (x) => x * x;
			const f4 = (x, y) => x + y;

			// Mehrzeiler
			const f5 = (x, y) => {
			return x * y;
			};
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			class MyClass {
			/* ... */
			setA() {
			const f = () => {
			this.a += 100;
			}
			f();
			}
			}

			const x = new MyClass(5);

			x.setA();

			console.log(x.getA());
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			105
			</code>
			</pre>
			</section>
			<section>
			<h3>Generator-Funktionen</h3>
			<pre>
			<code class="js" data-trim data-line-numbers>
			function* generator() {
			let i = 0;

			while(true) {
			yield i;
			i++;
			}
			}

			const g = generator();

			console.log(g.next().value);
			console.log(g.next().value);
			console.log(g.next().value);
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			1
			2
			3
			</code>
			</pre>
			</section>
			<section>
			<h3>Generator-Funktionen</h3>
			<pre>
			<code class="js" data-trim data-line-numbers>
			function* generator() {
			yield 1;
			yield 2;
			yield 3;
			}

			const g = generator();

			for (const i of g) {
			console.log(i);
			}
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			1
			2
			3
			</code>
			</pre>
			</section>
			<section>
			<h3>Nützliche Array-Funktionen</h3>
			</section>
			<section>
			Aufgabe: Schreibe ein Programm, das den Gesamtumsatz aus dem ersten Halbjahr berechnet
			<pre>
			<code class="js" data-trim data-line-numbers>
			const revenues = [
			{month: 0, revenue: 1000},
			{month: 1, revenue: 2000},
			{month: 2, revenue: 3000},
			{month: 3, revenue: 4000},
			{month: 4, revenue: 5000},
			{month: 5, revenue: 6000},
			{month: 6, revenue: 6000},
			{month: 7, revenue: 5000},
			{month: 8, revenue: 4000},
			{month: 9, revenue: 3000},
			{month: 10, revenue: 2000},
			{month: 11, revenue: 1000}
			];

			let totalRevenue = 0;

			/* ... */

			console.log(totalRevenue);
			</code>
			</pre>
			</section>
			<section>
			Lösung
			<pre>
			<code class="js" data-trim data-line-numbers>
			totalRevenue = revenues
			.filter((revenue) => revenue.month < 6)
			.map((revenue) => revenue.amount)
			.reduce((sum, amount) => sum + amount, 0);
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			21000
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			const a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

			a.filter((e) => e > 2); // Filterung
			a.map((e) => e * 2); // Umformung
			a.reduce((p, e) => p + e, 0); // Zusammenrechnung / Reduzierung
			a.some((e) => e > 5); // true wenn min. ein Element die Bedingung erfüllt
			a.every((e) => e > 5); // true wenn alle Elemente die Bedingung erfüllen
			</code>
			</pre>
			</section>
			<section>
			<h3>Map</h3>
			<ul>
			<li>auch als "assoziatives Array" bezeichnet</li>
			<li>iterierbare Liste</li>
			<li>ideal zur Assoziation von z.B. Hashes zu Objekt-Instanzen o.ä.</li>
			<li>nutzbar ab es6 / es2015</li>
			<li>löst herkömmliche Objekte als Hash-Map ab</li>
			</ul>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			const m = new Map();

			m.set("a", 0);
			m.set("a", 1);
			m.set("b", 2);

			m.has("c"); // => false

			m.delete("b");

			console.log(m.get("a")); // => 1
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			m.forEach((k, v) => console.log(k, v)) // => "a" 1 ...

			for (const entry of m.entries()) {
			console.log(entry); // => ["a", 1] ...
			}

			for (const key of m.keys()) {
			console.log(key); // => "a" ...
			}

			for (const value of m.values()) {
			console.log(value); // => "1" ...
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Set</h3>
			<ul>
			<li>enthält nur einzigartige Werte</li>
			<li>iterierbare Liste</li>
			<li>ideale Struktur, wenn einzelne Werte einzigartig sein sollen</li>
			<li>nutzbar ab es6 / es2015</li>
			<li>löst individuelle Lösungen mittels Arrays und Array.prototype.indexOf o.ä. ab</li>
			</ul>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			const s = new Set();

			s.add("a");
			s.add("a");

			s.has("c"); // => false

			s.delete("a");

			console.log(s.size); // => 0
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			s.forEach((k, v) => console.log(k, v)) // => "a" "a" ...

			for (const entry of m.entries()) {
			console.log(entry); // => ["a", "a"] ...
			}

			for (const key of m.keys()) {
			console.log(key); // => "a"...
			}

			for (const value of s.values()) {
			console.log(value); // => "a" ...
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>DOM-Events</h3>
			<ul>
			<li>funktionale Ausführung von Code</li>
			<li>Trigger können Klicks, Scrollen, Tastendrücke, Änderungen der Fenstergröße usw. sein</li>
			</ul>
			</section>
			<section>
			<img data-src="/assets/images/dom-events.svg">
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			function doSomething(e) {
			console.log("capture");
			}

			function click(e) {
			console.log("bubble");
			}

			div.addEventListener("click", doSomething, true);

			button.addEventListener("click", click, false /* default */);
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			capturing
			bubble
			</code>
			</pre>
			</section>
			<section>
			<p>Aufgabe: Erweitere das vorherige Beispiel so, dass das div-Element einen weiteren Click-Handler bekommt,
			der den Text "bubble2" anzeigt, nachdem "bubble" in der Konsole geloggt wurde.</p>

			<p>Erwartete Ausgabe:</p>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			capturing
			bubble
			bubble2
			</code>
			</pre>
			</section>
			<section>
			<p>Lösung:</p>
			<pre>
			<code class="js" data-trim data-line-numbers>
			function doSomething(e) {
			console.log("capture");
			}

			// neu
			function doSomething2(e) {
			console.log("bubble2");
			}

			function click(e) {
			console.log("bubble");
			}

			div.addEventListener("click", doSomething, true);
			div.addEventListener("click", doSomething2, false); // neu

			button.addEventListener("click", click, false /* default */);
			</code>
			</pre>
			</section>
			<section>
			Die Bubble-Phase stoppen
			<pre>
			<code class="js" data-trim data-line-numbers>
			function click(e) {
			e.stopPropagation()
			}
			</code>
			</pre>
			</section>
			<section>
			<p>Aufgabe: Ändere das Ergebnis des vorherigen Beispiels, sodass die Bubble-Phase auf Ebene des button-Elements gestoppt wird. Was ändert sich in der Ausgabe?</p>
			</section>
			<section>
			<p>Lösung:</p>
			<pre>
			<code class="js" data-trim data-line-numbers>
			function doSomething(e) {
			console.log("capture");
			}

			function doSomething2(e) {
			console.log("bubble2");
			}

			function click(e) {
			e.stopPropagation();
			console.log("bubble");
			}

			div.addEventListener("click", doSomething, true);
			div.addEventListener("click", doSomething2, false);

			button.addEventListener("click", click, false /* default */);
			</code>
			</pre>
			</section>
			<section>
			Events programatisch triggern:
			<pre>
			<code class="js" data-trim data-line-numbers>
			button.dispatchEvent(new Event("click"));
			</code>
			</pre>
			</section>
			<section>
			Events sind synchron:
			<pre>
			<code class="js" data-trim data-line-numbers>
			doSomethingElse();

			button.dispatchEvent(new Event("click"));

			doAnotherThing(); // wird erst ausgeführt, wenn zuvor alle Event-Handler fertig sind
			</code>
			</pre>
			</section>
			<section>
			<h3>Strings</h3>
			<pre>
			<code class="js" data-trim data-line-numbers>
			const empty1 = "";
			const empty1 = '';

			const s1 = 'abc';
			const s2 = "abc";

			const s3 = 'a"b"c';
			const s4 = "a\"b\"c";

			const s5 = 'a\'b\'c';
			const s6 = "a'b'c";

			const s7 = `a'b'"c"`;
			</code>
			</pre>
			</section>
			<section>
			<h5>Strings zusammenfügen</h5>
			<pre>
			<code class="js" data-trim data-line-numbers>
			const age = 10;

			// Konkatenation
			const s = "My age is " + number + "!";

			// Interpolation
			const s = `My age is ${number}!`;

			// => "My age is 10!"
			</code>
			</pre>
			</section>
			<section>
			<h5>Template Strings</h5>
			<pre>
			<code class="js" data-trim data-line-numbers>
			function sayHello() {
			return "Hello";
			}

			let interpolation = `${sayHello()}`;

			// => "Hello"

			interpolation = `5 + 5 = ${5+5}`;

			// => "5 + 5 = 10"
			</code>
			</pre>
			</section>
			<section>
			lit
			<pre>
			<code class="js" data-trim data-line-numbers>
			return html`<div>hello world!</div>`
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="js" data-trim data-line-numbers>
			function myTag() {
			console.log(arguments);

			// return 5;
			// return true;
			return "abc";
			}

			let interpolation = myTag`a ${5} b ${6} c`;

			// => "abc"
			</code>
			</pre>
			<pre>
			<code class="bash" data-trim data-line-numbers>
			Arguments(3) [Array(3), 5, 6]
			0 : (3) ['a ', ' b ', ' c', raw: Array(3)]
			1 : 5
			2 : 6
			</code>
			</pre>
			</section>
			<section>
			<h5>Aufgabe</h5>
			<p>Schreibe ein Tag, welches die Zahlen aus den dynamischen Ausdrücken zusammenrechnet (<code>strings.js</code>)</p>
			</section>
			<section>
			<h5>Lösung</h5>
			<pre>
			<code class="js" data-trim data-line-numbers>
			function add(parts, ...numbers) {
			return numbers.reduce((p, c) => p + c, 0);
			}

			let sum = add`a ${5} b ${6} c`;

			console.log(sum);

			// => 11
			</code>
			</pre>
			</section>
			<section>
			<h5>Rest-Operator</h5>
			<pre>
			<code class="js" data-trim data-line-numbers>
			function add(...numbers) {
			return numbers.reduce((p, c) => p + c, 0);
			}

			add(1, 2, 3); // => 6
			</code>
			</pre>
			<pre>
			<code class="js" data-trim data-line-numbers>
			const o1 = {a: 1, b: 2};
			const o2 = {x: 5, y: 6, ...o1};
			</code>
			</pre>
			<pre>
			<code class="js" data-trim data-line-numbers>
			const a1 = [4, 5, 6];
			const a2 = [1, 2, 3, ...a1];
			</code>
			</pre>
			</section>
			<section>
			<h3>Relevante Browser-APIs</h3>
			</section>
			<section>
			<h5>window</h5>
			<pre>
			<code class="js" data-trim data-line-numbers>
			window.innerWidth; // innere Auflösung des sichtbaren Fensters
			window.innerHeight;
			window.outerWidth; // äußere Auflösung des Browserfensters inklusive Adresszeile usw.
			window.outerHeight;

			window.addEventListener(); // Events an das äußerste "Dach"-Element hängen
			</code>
			</pre>
			</section>
			<section>
			<h5>location</h5>
			<pre>
			<code class="js" data-trim data-line-numbers>
			location.href; // aktuelle URL
			location.host; // aktuelle Domain, z.B. "www.google.de"
			location.protocol; // aktuelles Protokoll, z.B. "https:"
			</code>
			</pre>
			</section>
			<section>
			<h5>Navigator</h5>
			<pre>
			<code class="js" data-trim data-line-numbers>
			navigator.language; // bevorzugte Browsersprache, z.B. "de"
			navigator.userAgent; // z.B. "Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) [...]"
			navigator
			.mediaDevices
			.getDisplayMedia(); // Fordere Erlaubis zum Streamen von Anwendungen oder Bildschirmen an
			</code>
			</pre>
			</section>
			<section>
			<h5>Document</h5>
			<pre>
			<code class="js" data-trim data-line-numbers>
			document.body; // <body>-Element der Seite
			document.activeElement; // aktives Element der Seite, welche gerade den Fokus besitzt
			document.cookie; // für die aktuelle Seite gesetzte Cookies
			document.execCommand("copy"); // Texte in die Zwischenablage zu schreiben
			document.createElement("div"); // erzeuge neues DOM-Element mit angegebenen Tag
			</code>
			</pre>
			</section>
			<section>
			<h5>LocalStorage</h5>
			<pre>
			<code class="js" data-trim data-line-numbers>
			// auf 5MB Daten pro Domain begrenzt
			localStorage.getItem(key); // Element holen
			localStorage.setItem(key, value); // Element setzen
			localStorage.removeItem(key); // Element entfernen
			</code>
			</pre>
			</section>
			</section>
			<section>
			<section>
			<h2>CSS</h2>
			<img data-src="/assets/images/css-sucks.png">
			</section>
			<section>
			<h3>Warum CSS?</h3>
			<ul>
			<li>Erhöhte Zugänglichkeit des Inhalts</li>
			<li>Wiederverwendbarkeit</li>
			</ul>
			</section>
			<section>
			<h3>Syntax</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			selector [, selector2, selector3, ...] {
			property1: value;
			property2: value;
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Beispiel</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			html, body {
			width: 100%;
			height: 100%;
			margin: 0;
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Selektoren</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			/* Elemente */
			html, body {...}

			/* IDs */
			#my-id {...}

			/* Klassen */
			.my-class {...}

			/* Pseudo-Klassen */
			div:hover {...}

			/* Attribute */
			div[my-attribut="abc"] {...}

			/* Kombinationen */
			div.my-class#my-id {...}
			</code>
			</pre>
			</section>
			<section>
			<h3>Variablen</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			html {
			--my-background-color: #abcdef;
			}

			html div {
			background-color: var(--my-background-color, white);
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Das <code>display</code>-Attribut</h3>
			</section>
			<section>
			<p>block</p>
			<img data-src="/assets/images/css-display-block.svg">
			<ul>
			<li>untereinander angeordnet</li>
			<li>nehmen sich die volle Breite</li>
			<li><code>width</code> und <code>height</code> möglich</li>
			</ul>
			</section>
			<section>
			<p>inline</p>
			<img data-src="/assets/images/css-display-inline.svg">
			<ul>
			<li>Standard bei <code>Custom Elements</code></li>
			<li>nur so groß wie der content</li>
			<li><code>width</code> und <code>height</code> nicht möglich</li>
			<li>nebeneinander angeordnet</li>
			</ul>
			</section>
			<section>
			<p>inline-block</p>
			<img data-src="/assets/images/css-display-inline-block.svg">
			<ul>
			<li>Mischform von <code>block</code> und <code>inline</code></li>
			<li>nur so groß wie der content</li>
			<li><code>width</code> und <code>height</code> möglich</li>
			<li>nebeneinander angeordnet</li>
			</ul>
			</section>
			<section>
			<p>none</p>
			<img data-src="/assets/images/css-display-none.svg">
			<ul>
			<li>unsichtbar</li>
			<li>Platz wird nicht länger beansprucht, so als wenn das Element nicht im DOM wäre</li>
			</ul>
			</section>
			<section>
			<h3>Das <code>position</code>-Attribut</h3>
			</section>
			<section>
			<p>static</p>
			<img data-src="/assets/images/css-position-static.svg">
			<ul>
			<li>Standard</li>
			<li>Element wird am Ort der Verankerung im HTML dargestellt</li>
			</ul>
			</section>
			<section>
			<p>relative</p>
			<img data-src="/assets/images/css-position-relative.svg">
			<ul>
			<li>Verschiebung zur eigentlichen <code>static</code>-Position, z.B. mittels <code>left: 20px</code></li>
			</ul>
			</section>
			<section>
			<p>absolut</p>
			<img data-src="/assets/images/css-position-absolute.svg">
			<ul>
			<li>relative Verschiebung zum nächsten nicht-<code>static</code>-Parent (sonst <code>window</code>)</li>
			</ul>
			</section>
			<section>
			<h3>Aufgabe</h3>
			<p>Implementiere folgendes Beispiel-Menü</p>
			<iframe data-src="/assets/html/css-menu.html"></iframe>
			</section>
			<section>
			<h3>Lösung</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			.menu-item {
			display: inline-block;

			position: relative;
			}

			.menu-item .children {
			display: none;

			position: absolute;
			}

			.menu-item:hover .children {
			display: block;
			}
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="html" data-trim data-line-numbers>
			<script type="text/template">
			<div class="menu">
			<div class="menu-item">Eins</div>
			<div class="menu-item">
			Hover Me!
			<div class="children">
			<div>Item 1</div>
			<div>Item 2</div>
			</div>
			</div>
			<div class="menu-item">Drei</div>
			</div>
			</script>
			</code>
			</pre>
			</section>
			<section>
			<h3>Viewport</h3>
			<pre>
			<code class="html" data-trim data-line-numbers>
			<!DOCTYPE html>
			<html>
			<head>
			<meta charset="utf-8"></meta>
			<meta
			name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"
			>
			</head>
			<body>
			...
			</body>
			</html>
			</code>
			</pre>
			<p>Ein Muss für alle responsiven Seiten</p>
			</section>
			<section>
			<pre>
			<code class="bash" data-trim data-line-numbers="">
			npm install -g http-server
			cd pfad/zum/projekt
			http-server --port 8080
			</code>
			</pre>
			</section>
			<section>
			<h3>Einheiten</h3>
			<pre>
			<code class="css" data-trim data-line-numbers="">
			div {
			width: 1px; /* Pixel */
			width: 1pt; /* Points */
			width: 1em; /* Breite des "M" in der Schriftgröße des Elements */
			width: 1rem; /* Breite des "M" in der Schriftgröße des HTML-Elements */
			width: 1vw; /* Prozent der View Width */
			width: 1%; /* Prozent des Elternelements */

			width: 5fr; /* Fraction (nur im CSS Grid verfügbar) */
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Aufgabe</h3>
			<p>Größeneinheiten in einer HTML-Datei ausprobieren</p>
			</section>
			<section>
			<h3>CSS Flexbox</h3>
			<pre>
			<code class="css" data-trim data-line-numbers="">
			.container {
			display: flex; /* soll ein flexibler Container sein */
			display: inline-flex;

			flex-direction: column; /* Kinder spaltenweise anordnen */
			flex-direction: row; /* Kinder zeilenweise anordnen */

			align-items: center;
			justify-content: center;

			gap: 20px; /* Abstände zwischen den Achsen */
			}

			.child {
			flex-grow: 1; /* Anteiliger Platz, wenn mehr als nötig da ist */
			flex-shrink: 1; /* Anteiliger Platz, wenn weniger als nötig da ist */
			flex-basis: 20px; /* Grundlage zur Berechnung der finalen Größe */
			order: 1; /* Erlaubt die Darstellung in anderer Reihenfolge als durch das HTML vorgegeben */
			}
			</code>
			</pre>
			</section>
			<section>
			<img data-src="/assets/images/css-flexbox-axes.drawio.svg">
			</section>
			<section>
			<h3>Aufgabe</h3>
			<p>Mit CSS Flexbox rumspielen</p>
			</section>
			<section>
			<h3>CSS Grid</h3>
			</section>
			<section>
			<h3>Terminologie</h3>
			<img data-src="/assets/images/css-grid-terminology.drawio.svg">
			</section>
			<section>
			<pre>
			<code class="css" data-trim data-line-numbers="">
			.grid {
			display: grid; /* inline-grid; */

			grid-template-columns: 1fr 1fr 1fr;
			grid-template-rows: 1fr 1fr;

			gap: 5px 10px;
			}
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="html" data-trim data-line-numbers="">
			<div class="grid">
			<span>A</span>
			<span>B</span>
			<span>C</span>
			<span>D</span>
			<span>E</span>
			<span>F</span>
			</div>
			</code>
			</pre>
			</section>
			<section>
			<iframe data-src="/assets/html/css-grid-example-1.html"></iframe>
			</section>
			<section>
			<pre>
			<code class="css" data-trim data-line-numbers="">
			.grid {
			grid-template-columns: [left] 1fr [column1] 1fr [column2] 1fr [right];
			grid-template-rows: [top] 1fr [row1] 1fr [bottom];
			}

			.a {
			grid-column: 2 / span 2;
			grid-row: 1;
			}

			.b {
			grid-column: left / column2;
			grid-row: 2;
			}
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="html" data-trim data-line-numbers="">
			<div class="grid">
			<span class="a">A</span>
			<span class="b">B</span>
			</div>
			</code>
			</pre>
			</section>
			<section>
			<iframe data-src="/assets/html/css-grid-example-2.html"></iframe>
			</section>
			<section>
			<pre>
			<code class="css" data-trim data-line-numbers="">
			.grid {
			grid-template-areas:
			"header header header"
			"content content content";
			}

			.a {
			grid-area: header;
			}

			.b {
			grid-area: 2 / 1 / 2 / 3; /* start-row / start-column / end-row / end-column */
			/* alternativ auch Namen der Lines möglich */
			}
			</code>
			</pre>
			</section>
			<section>
			<iframe data-src="/assets/html/css-grid-example-3.html"></iframe>
			</section>
			<section>
			<h3>Aufgabe</h3>
			<p>Implementiere folgendes Design:</p>
			<iframe data-src="/assets/html/css-grid-excercise.html"></iframe>
			</section>
			<section>
			<h3>Lösung</h3>
			<pre>
			<code class="css" data-trim data-line-numbers="">
			.grid {
			display: grid;

			grid-template-rows: 1fr 5fr 1fr;

			gap: 2px;

			grid-template-areas:
			"navigation header header header"
			"navigation content content content"
			"footer footer footer footer"
			}

			.navigation {
			grid-area: navigation;
			}

			.header {
			grid-area: header;
			}

			.content {
			grid-area: content;
			}

			.footer {
			grid-area: footer;
			}
			</code>
			</pre>
			</section>
			<section>
			<pre>
			<code class="html" data-trim data-line-numbers="">
			<div class="grid">
			<div class="area navigation">Navigation</div>
			<div class="area header">Header</div>
			<div class="area content">Content</div>
			<div class="area footer">Footer</div>
			</div>
			</code>
			</pre>
			</section>
			<section>
			<h4>Platzierug des Inhalts</h4>
			<pre>
			<code class="css" data-trim data-line-numbers="">
			.grid {
			align-items: center;
			justify-items: center;
			}
			</code>
			</pre>
			</section>
			<section>
			<iframe data-src="/assets/html/css-grid-example-4.html"></iframe>
			</section>
			<section>
			<h3>Media Queries</h3>
			<ul>
			<li>"Medienabfragen"</li>
			<li>Styles auf Basis von Eigenschaften des Ausgabemediums</li>
			<li>Große Bildschirme, kleine Bildschirme, Printmedien...</li>
			<li>Hinweis: Sollten immer als letztes (unten) in einem Stylesheet sein</li>
			</ul>
			</section>
			<section>
			<h3>Syntax</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			@media screen and (min-width: 640px) and (max-width: 1024px) {
			.navigation {
			display: none;
			}
			}
			</code>
			</pre>
			<p>Bedeutung: Wenn die Seite auf einem Display angezeigt wird, welches zwischen 640px und 1024px in der Breite anzeigen kann, dann blende die Navigation aus</p>
			</section>
			<section>
			<h3>Werte für die Ausgabemedien (optional, Standard ist "all")</h3>
			<ul>
			<li>all</li>
			<li>screen</li>
			<li>print</li>
			</ul>
			</section>
			<section>
			<h3>Werte für die Eigenschaften mit Typ und Erklärung (kleiner Auszug)</h3>
			<ul>
			<li>width (Number, Breite)</li>
			<li>height (Number, Höhe)</li>
			<li>orientation (portrait \| landscape, Quer- oder Hochformat)</li>
			<li>hover (none \| hover, Hat Zeiger zum Hovern)</li>
			<li>forced-colors (none \| active, erzwungene Farbpalette z.B. bei Sehbehinderung)</li>
			</ul>
			</section>
			<section>
			<h3>Aufgabe</h3>
			<p>Entwerfe eine kleine Seite mit @media und zeige ein beliebiges Element ab einer bestimmten Höhe oder Breite an (die Größe des Displays kann dynamisch mit den Entwicklertools im Gerätesimulator geändert werden)</p>
			</section>
			<section>
			<h3>Aufgabe</h3>
			<p>Passe die Vorlage "media-queries-responsive-layout.html" mit @media-Queries so an, dass das Menü links ab einer maximalen Breite von 480 Pixel und kleiner nach links oben in die Ecke minimiert wird und nur per Hover wieder 50% Breite und 100% Höhe bekommt</p>
			</section>
			<section>
			<img data-src="/assets/images/media-queries-excercise.png">
			</section>
			<section>
			<h3>Lösung</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			@media screen and (max-width: 480px) {
			.menu {
			grid-area: unset;

			position: absolute;
			}

			.menu:hover {
			height: 100%;
			width: 50%;
			}

			.grid {
			grid-template-columns: 0fr 5fr;
			}
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Transform</h3>
			<ul>
			<li>rein optisch, d.h. "physische" Größe bleibt erhalten</li>
			<li>eine Art "Shader" auf Grafikebene</li>
			<li>Effekte wie Drehung, Vergrößerung, Verschiebung usw.</li>
			</ul>
			</section>
			<section>
			<h3>Syntax</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			.foo {
			transform: translateX(20px) translateY(20px);
			transform-origin: left;
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Mögliche Effekte</h3>
			<ul>
			<li>translate</li>
			<li>rotate</li>
			<li>scale</li>
			<li>scew</li>
			</ul>
			<p>Die meisten besitzen zusätzlich spezifischere X-, Y- oder 3D-Versionen</p>
			</section>
			<section>
			<h3>Aufgabe</h3>
			<p>Probiere die genannten Transform-Effekte in einer beliebigen Seite aus</p>
			</section>
			<section>
			<h3>Transition</h3>
			<ul>
			<li>Elemente können "weich" verändert werden</li>
			<li>Mögliche Attribute, deren Änderungen animiert werden können sind z.B. <code>width</code>, <code>height</code>, <code>transform</code>, <code>color</code> und viele weitere</li>
			<li>Das Attribut <code>display</code> lässt sich jedoch nicht animieren</li>
			</ul>
			</section>
			<section>
			<h3>Syntax</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			.foo {
			width: 100%;
			background-color: red;
			/* transition: [Attribut] [Dauer] [Zeitfunktion] */
			transition: width 1s ease-out;
			}

			.foo:hover {
			width: 50%;
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Beispiel</h3>
			<iframe data-src="/assets/html/css-transition.html"></iframe>
			</section>
			<section>
			<h3>Animation</h3>
			<ul>
			<li>Es können zusätzlich eigene Animationen entworfen werden</li>
			<li>Definition per <code>Keyframes</code></li>
			</ul>
			</section>
			<section>
			<h3>Syntax</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			.foo {
			animation-duration: 3s;
			animation-name: slidein;
			}

			@keyframes slidein {
			from {
			margin-left: 100%;
			width: 300%;
			}

			to {
			margin-left: 0%;
			width: 100%;
			}
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Alternative Syntax</h3>
			<pre>
			<code class="css" data-trim data-line-numbers>
			.foo {
			/* ... */
			}

			@keyframes slidein {
			1% {
			margin-left: 100%;
			}

			100% {
			margin-left: 0%;
			}
			}
			</code>
			</pre>
			</section>
			<section>
			<h3>Beispiel</h3>
			<iframe data-src="/assets/html/css-animation.html"></iframe>
			</section>
			</section>
			</div>
			</div>
			@@ -2141,7 +3430,7 @@
			hash: true,
			slideNumber: "c/t",
			transition: "fade",


			// Learn about plugins: https://revealjs.com/plugins/
			plugins: [ RevealMarkdown, RevealHighlight, RevealNotes ]
			});