Quantcast
Channel: #CSS - Agentur kulturbanause
Viewing all 173 articles
Browse latest View live

contenteditable=“true“– HTML- & CSS live und ohne JavaScript editieren

$
0
0
content-editable

Wenn ein Anwender direkt auf der Website Inhalte oder Stile verändern kann, dann ist i.d.R. JavaScript im Spiel. Mit dem HTML-Attribut contenteditable, können HTML-Inhalte und CSS-Angaben auch ohne JavaScript editiert werden. Die Einsatzmöglichkeiten sind vielfältig und der Browser-Support ausgezeichnet.

HTML-Elemente editieren

Mit Hilfe des HTML-Attributs contenteditable und dem Wert true kann ein HTML-Element editierbar gemacht werden. Die Text-Inhalte können anschließend wie in einem input-Feld verändert werden.

Live-Beispiel

Dieser Absatz und die letzte Überschrift können direkt im Browser editiert werden. Probiert es aus!

Editierbare Elemente im Prototyping

Ich nutze das contenteditable="true"-Attribut gerne bei der Arbeit mit Prototypen. Die Möglichkeit Inhalte im Frontend zu editieren, ohne dass die Inhalte gespeichert werden ist beispielweise sehr praktisch, wenn man versucht die Textlängen nebeneinanderstehender Teaser-Boxen auf eine Länge zu formulieren. Ich habe zu diesem Zweck ein kleines Bookmarklet geschrieben, dass per Klick ausgewählte Elemente auf der Website editierbar macht.

ContentEditable-Bookmarklet
Vorschau des Bookmarklets

Prototyping Bookmarklet

Hier findet ihr das Bookmarklet und den Prototypen aus dem Screenshot. Klickt das Bookmarklet an, um es zu aktivieren oder zieht es per Drag and Drop in die Lesezeichen und aktiviert es von dort aus auf einer beliebigen Website. Anschließend könnt ihr per Klick Elemente auswählen und anschließend editieren.
In Chrome könnt ihr übrigens mit Enter neue Listenpunkte in der Navigation hinzufügen und mit Cmd + b Text fetten. Mit Cmd + i können Texte kursiv dargestellt werden.

CSS-Styles editieren

CSS-Angaben können bekanntlich auch innerhalb eines HTML-Dokuments über <style> notiert werden. Somit ist es möglich auch die Stile einer Website über contenteditable zu verändern.



<style contenteditable="true">
  /* CSS-Code */
</style>

Leider wird das style-Element vom Browser automatisch auf display:none; gesetzt. Daher müssen wir das Element zunächst sichtbar machen um den Inhalt editieren zu können.



style { display: block; }

Live-Beispiel

Im folgenden Style-Feld könnt ihr den CSS-Code dieser Website live editieren. Ändert beispielsweise die Farbe von Absätzen in red.

Links/Quellen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.


Das currentColor-Keyword von CSS

$
0
0
currentcolor

CSS-Code enthält naturgemäß viele Wiederholungen, was von Entwicklern regelmäßig kritisiert wird. Mit Hilfe von CSS-Präprozessoren wie Sass kann der Code DRYer (weniger repetitiv) gestaltet werden, doch auch CSS selbst stellt Funktionen bereit die Ähnlichkeit mit Variablen haben. Eine davon ist der currentColor-Wert.

currentColor merkt sich die Vordergrundfarbe

Ein Element kann in CSS eine Vordergrundfarbe (color) und eine Hintergrundfarbe (background-color) besitzen. Der Wert currentColor speichert die Vordergrundfarbe eines Elements und ermöglicht es diese Farbe auch anderen Eigenschaften zuzuweisen. Schauen wir und dazu folgendes Beispiel an:


h1 {
  color: lightgreen;
  border-bottom: 1px solid currentColor;
}

Beispiel anschauen

Die zuvor definierte Vordergrundfarbe lightgreen, kann über currentColor auch der Eigenschaft border-bottom zugewiesen werden. Das Keyword folgt dabei der CSS-Kaskade und kann auch in Kind-Elementen eingesetzt werden.

currentColor und SVG-Icons

Die sinnvollen Einsatzmöglichkeiten von currentColor sind überschaubar. Interessant wird die Eigenschaft aber u.a. im Zusammenspiel mit SVG-Icons. Hier kann über die CSS/SVG-Eigenschaft fill das Icon gemeinsam mit anderen Elementen umgefärbt werden. Icons in passender Farbe zu Links, Buttons oder Info-Boxen sind so kein Problem mehr.

Das folgende Beispiel verwendet ein SVG-Icon in einer Box.



/* Für die Funktion irrelevante
Eigenschaften sind gekürzt */

.info {
  color: lightblue;
  border: 1px solid currentColor;
}

#icon-warning {
  fill:currentcolor;
}

Beispiel anschauen

Browser-Support

Der Browser-Support ist überraschend gut. Alle modernen Browser inkl. IE9+ unterstützen das Keyword.

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

CSS Filter-Effekte

$
0
0
css-filter-effekte

Mit Hilfe von CSS-Filter-Effekten können die Elemente einer Website gestalterisch manipuliert werden. Ihr könnt z. B. Bilder in ihrer Farbe verändern, Schatten hinzufügen, die Deckkraft reduzieren oder Bilder und Texte weichzeichnen. In Kombination mit CSS Blend Modes stehen uns somit Photoshop-ähnliche Techniken im Browser zur Verfügung. Da CSS Filter mittlerweile in allen modernen Browser (außer dem IE) zur Verfügung stehen, möchte ich in diesem Beitrag die Funktionsweise kurz zusammenfassen.

Funktionsweise von CSS-Filtern

CSS Filter lassen sich sowohl auf Grafiken im HTML-Markup (<img>) als auch auf CSS-Hintergründe (background-image:url(…);) Texte, CSS-Elemente, SVG-Grafiken und Videos (<video>) anwenden. Es stehen nachfolgende Filter zur Verfügung.

Live-Beispiele aller Filter anzeigen

blur(Radius) – Weichzeichner

Mit dem blur()-Filter kann ein Gaußscher Weichzeichner angewendet werden. Je höher der Radius, desto stärker wird das Bild weichgezeichnet.

CSS-Filter blur()
CSS-Filter blur()
.blur {
    -webkit-filter: blur(2px);
    filter: blur(2px);
}

brightness(Wert) – Helligkeit

Mit dem brightness()-Filter kann ein Bild in der Helligkeit verändert werden. Ein Wert von 1 entspricht dem Standard. Werte unter 1 (z. B. 0.5) dunkeln das Bild ab, Werte über 1 (z. B. 1.5) hellen das Bild auf.

Der CSS-Filter brightness()
Der CSS-Filter brightness()
.brightness {
    -webkit-filter: brightness(1.5);
    filter: brightness(1.5);
}

contrast(Wert) – Kontrast

Mit dem contrast()-Filter wird der Kontrast eines Bildes verändert. Ein Wert unter 1 reduziert den Kontrast, ein Wert über 1 erhöht ihn.

Der CSS-Filter contrast()
Der CSS-Filter contrast()
.contrast {
    -webkit-filter: contrast(2);
    filter: contrast(2);
}

drop-shadow(X, Y, Weichzeichnung, Farbe) – Schlagschatten

Mit dem drop-shadow()-Filter kann einem Bild ein Schlagschatten hinzugefügt werden. Der Filter funktioniert ähnlich wie die box-shadow-Eigenschaft und führt folglich auch zu einem vergleichbaren visuellen Ergebnis. Allerdings erkennt der Filter Transparenzen in PNGs, so dass nur opake Bildbereiche einen Schatten werfen.

Der CSS-Filter drop-shadow()
Der CSS-Filter drop-shadow()
.drop-shadow {
    -webkit-filter: drop-shadow(5px 5px 3px rgba(0,0,0,0.7));
    filter: drop-shadow(5px 5px 3px rgba(0,0,0,0.7));
}

grayscale(wert) – Graustufe

Mit dem grayscale()-Filter kann ein Bild in Graustufen dargestellt werden. Ein Wert von 1 entspricht 100%.

Der CSS-Filter grayscale()
Der CSS-Filter grayscale()
.grayscale {
    -webkit-filter: grayscale(1);
    filter: grayscale(1);
}

hue-rotate(winkel) – Winkel im Farbkreis

Mit dem hue-rotate()-Filter kann der Farbwinkel des Bildes gedreht werden. Ein Wert von 0° lässt das Bild unverändert, der maximale Winkel beträgt 360°.

Der CSS-Filter hue-rotate()
Der CSS-Filter hue-rotate()
.hue-rotate {
    -webkit-filter: hue-rotate(45deg);
    filter: hue-rotate(45deg);
}

invert(wert) – Invertieren

Mit dem invert()-Filter können die Farben des Bildes umgekehrt werden. Ein Wert von 1 kehrt die Farben vollständig um.

Der CSS-Filter invert()
Der CSS-Filter invert()
.invert {
    -webkit-filter: invert(1);
    filter: invert(1);
}

opacity(wert) – Deckkraft/Opazität

Mit dem opacity()-Filter kann ein Bild transparent dargestellt werden. Ein Wert von 1 lässt das Bild verschwinden. Der Filter funktioniert exakt wie die opacity-Eigenschaft von CSS.

Der CSS-Filter opacity()
Der CSS-Filter opacity()
.opacity {
    -webkit-filter: opacity(.5);
    filter: opacity(.5);
}

saturate(wert) – Sättigung

Mit dem saturate()-Filter kann die Sättigung eines Bildes erhöht oder verringert werden. Werte über 1 erhöhen die Sättigung, Werte zwischen 1 und 0 verringern sie.

Der CSS-Filter saturate()
Der CSS-Filter saturate()
.saturate {
    -webkit-filter: saturate(2);
    filter: saturate(2);
}

sepia(wert) – Sepiafarben

Der Filter sepia() färbt das Bild in Sepiafarben um. Ein Wert von 1 entspricht einer Sepia-Färbung von 100%.

Der CSS-Filter sepia()
Der CSS-Filter sepia()
.sepia {
    -webkit-filter: sepia(1);
    filter: sepia(1);
}

Kombinierte Filter

CSS-Filter können auch kombiniert werden. Die einzelnen Filter werden dabei ohne Komma direkt nacheinander notiert. Mit Filterkombinationen sind beispielsweise Einfärbungen des Bildes, dezente Korrekturen oder Instagram-ähnliche Effekte möglich.

Kombinierte CSS-Filter sepia() und hue-rotate()
Kombinierte CSS-Filter sepia() und hue-rotate()
.sepia-hue-rotate {
    -webkit-filter: sepia(1) hue-rotate(120deg);
    filter: sepia(1) hue-rotate(120deg);
}
Kombinierte CSS-Filter sepia(), hue-rotate() und blur()
Kombinierte CSS-Filter sepia(), hue-rotate() und blur()
.sepia-hue-rotate-blur {
    -webkit-filter: sepia(.9) hue-rotate(280deg) blur(2px);
    filter: sepia(.9) hue-rotate(280deg) blur(2px);
}
Kombinierte CSS-Filter brightness() und contrast()
Kombinierte CSS-Filter brightness() und contrast()
.brightness-contrast {
	-webkit-filter: brightness(1.1) contrast(1.3);
	filter: brightness(1.1) contrast(1.3);
}

Browser-Support

Wie eingangs bereits erwähnt, sieht der Browser-Support zum Zeitpunkt der Veröffentlichung dieses Artikels bereits sehr gut aus. Lediglich die Internet Explorer-Reihe unterstützt die CSS Filter noch nicht. Eine detaillierte Liste entnehmt ihr bitte der Website Can I Use. Ein Polyfill findet ihr hier.

Links / Quellen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Formular-Styling mit CSS – Select-Listen, Radio-Buttons und Checkboxen individuell gestalten

$
0
0
formular-css

Die Gestaltung von Formularfeldern gehört zu den eher lästigen Aufgaben eines Web-Designers. Insbesondere Select-Listen, Radio-Buttons und Checkboxen ließen sich lange Zeit kaum mit CSS ansprechen, so dass für gewöhnlich mit JavaScript nachgeholfen werden musste, wenn eine individuelle Gestaltung gewünscht war. Mittlerweile lassen sich Formularfelder in modernen Browsern ohne JavaScript individuell gestalten. In diesem Zusammenhang möchte ich einige CSS-Snippets archivieren.

appearance: none;

Mit Hilfe des CSS-Befehls appearance: none; kann die Standard-Gestaltung von Bedienelementen im Browser deaktiviert werden. Das ist nicht nur hilfreich um Selectlisten, Radio-Buttons und Checkboxen zu gestalten, sondern auch um das Standard-Styling von Suchfeldern, Buttons und weiteren UI-Elementen zu entfernen, deren Gestaltung zunehmend vom Browser übernommen wird. Der appearance-Befehl ermöglicht es übrigens auch, dass Standard-Styling des Browsers/OS bewusst zuzuweisen.

Progressive Enhancement

Der appearance-Befehl funktioniert nicht im Internet Explorer. Damit es in alten Versionen des Browsers (<=IE9) nicht zu unerwünschten Effekten kommt, behalten wir in inkompatiblen Systemen das Standard-Aussehen der Eingabefelder bei. Nach dem Prinzip des Progressive Enhancement gestalten wir die Felder nur dann, wenn der Browser den Befehl auch unterstützt.

Select-Listen gestalten

Die individuelle Gestaltung von Select-Listen ist einfach. Über den appearance-Befehl entfernen wir zunächst das Standard-Styling.


/* remove standard-styles */
select {
  -webkit-appearance: none;
  -moz-appearance: none;
  appearance: none;
  border:none;
  border-radius: 0;
  font-size: 1em;
  width: 100%
}

Anschließend gestalten wir das Element mit CSS unseren Vorstellungen entsprechend. Ein individuelles Pfeil-Icon weisen wir in diesem Beispiel als CSS-background-image zu – eine DataURI bietet sich ebenfalls an.


/* styling */
select {
  width:100%;
  border: 1px solid #bbb;
  padding:.75em 1em .5em 1em;
  box-shadow: 0 2px 1px 0 rgba(0,0,0,0.2);
  background-color:white;
  background-image:url(select-arrow.png);
  background-position: right;
  background-repeat: no-repeat;
}

select:hover {
  box-shadow: 0 1px 1px 0 rgba(0,0,0,0.1);
}

Die Select-Liste im Vergleich: IE8, IE9, IE10 und – stellvertretend für die modernen Browser – Chrome
Die Select-Liste im Vergleich: IE8, IE9, IE10 und – stellvertretend für die modernen Browser – Chrome

Damit der Internet Explorer 10 den Pfeil des Browsers ebenfalls verliert, ist ein kleiner Hack nötig.


/* hide browser-styling (arrow) in IE10 */
select::-ms-expand {
  display:none;
}

Die inkompatiblen Browser (IE8 & IE9) identifizieren wir hier mit einer CSS-Klasse, die über einen Conditional Comment eingefügt wurde. Auch hier sind verschiedene Herangehensweisen denkbar. Wir entfernen somit die Pfeil-Grafik, da ansonsten zwei Pfeile in der Select-Liste angezeigt würden.


.lt-ie10 select {
    background-image: none;
}

Das option-Element gestalten

Das Drop-Down-Element der Select-Liste (<option>) lässt sich nur sehr eingeschränkt mit CSS ansprechen. In Webkit-Browsern haben wir – sofern ich recht informiert bin – keine Möglichkeit das <option>-Element zu gestalten. Firefox hingegen verwendet für <option> die Hintergrund- und Textfarbe des <select>-Elements, sofern <option> nicht selbst angesprochen wurde.

Gestaltetes option-Element in Firefox
Gestaltetes option-Element in Firefox

Mit folgendem Code erreicht ihr daher im Firefox eine Darstellung wie im Screenshot zu sehen:


select {
  /* irrelevante Eigenschaften gekürzt */
  border: 1px solid black;
  padding:.75em 1em .5em 1em;
  box-shadow: 0 2px 1px 0 rgba(0,0,0,1);
  background-color:#333;
  color:white;
}

option {
  background:#222;
  border-top:1px solid #444;
  padding:.3em 1em .3em 1em;
}

Radio-Buttons und Checkboxen gestalten

Radio-Buttons und Checkboxen benötigen etwas mehr Arbeit. Zunächst erledigen wir die Basis-Gestaltung für alte Versionen des Internet Explorers: Wir behalten die Browser-Standards bei, und passen nur die Positionierung und die Abstände ein wenig an.

Radio-Buttons und Checkboxen im Vergleich: IE8, IE9, IE10 und – stellvertretend für moderne Browser – Chrome
Radio-Buttons und Checkboxen im Vergleich: IE8, IE9, IE10 und – stellvertretend für moderne Browser – Chrome

In modernen Browsern blenden wir die Standard-UI-Element für Radio-Buttons und Checkboxen komplett aus. Wir identifizieren die modernen Browser über die Pseudoklasse :checked. Alle Browser die :checked verstehen, sind auch in der Lage die anderen notwendigen Befehle zu interpretieren.



/* remove standard-styles */
input {
  -webkit-appearance: none;
  -moz-appearance: none;
  appearance: none;
  border:none;
  border-radius: 0;
  font-size: 1em;
  width: 100%
}

/* graceful degradation for ie8 */
input[type='checkbox'],
input[type='radio'] {
  width:auto;
  float:left;
  margin-right: .75em;
  background:transparent;
  border:none;
}

input[type='checkbox']:checked,
input[type='checkbox']:not(:checked),
input[type='radio']:checked,
input[type='radio']:not(:checked) {
  background: transparent;
  position: relative;
  visibility: hidden;
  margin:0;
  padding:0;
}

input[type='checkbox'] + label,
input[type='radio'] + label {
  cursor: pointer;
}

Nachdem wir die Standard-UI-Elemente versteckt haben, fügen wir Sie als ::before-Pseudoelement des jeweiligen <label>-Elements wieder ein. Da man die Auswahlfelder auch durch Klicken auf <label> aktivieren kann, nutzen wir anschließend die Pseudoklasse :checked um das Pseudoelement ::before mit CSS umzugestalten, sobald ein Radio-Button oder eine Checkbox aktiviert wurde. Hier kann anstelle der schlichten CSS-Gestaltung natürlich auch eine Grafik eingesetzt werden.


input[type='checkbox']:checked + label::before,
input[type='checkbox']:not(:checked) + label::before,
input[type='radio']:checked + label::before,
input[type='radio']:not(:checked) + label::before {
    content:' ';
    display:inline-block;
    width: 17px;
    height:17px;
    position: relative;
    top:4px;
    border: 1px solid #bbb;
    background: white;
    margin-right: 1em;
    box-shadow: inset 0 1px 1px 0 rgba(0,0,0,.1);
}

input[type=radio]:checked + label::before,
input[type=radio]:not(:checked) + label::before {
  border-radius: 30px;
}

input[type='checkbox']:hover  + label::before,
input[type='radio']:hover  + label::before {
  background:#ddd;
  box-shadow: inset 0 0 0 2px white;
}

input[type='checkbox']:checked  + label::before,
input[type='radio']:checked  + label::before {
  background:black;
  box-shadow: inset 0 0 0 2px white;
}

Vollständiges Beispiel

Das Beispiel mit zusammengefassten Code-Passagen und zusätzlichem Styling für Textfelder könnt ihr euch hier anschauen.

Beispiel anzeigen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

CSS Feature Queries – @supports ()

$
0
0
CSS Feature Query

Wenn man herausfinden möchte welche Technologien von einem Browser unterstützt werden, führt der Weg häufig zum Hilfsmittel Modernizr. Das JavaScript-Framework schreibt u.a. CSS-Klassen in den <html>-Tag der Website von denen anschließend moderne Funktionen abhängig gemacht werden können. Diese Vorgehensweise ist im Moment gängige Praxis.
Alternativ zu einer JavaScript-basierten Lösung wie Modernizr könnt ihr auch das CSS Feature Query @supports () einsetzen um in Erfahrung zu bringen, welche CSS- und JavaScript-Techniken im Browser verwendet werden können. In diesem Beitrag möchte ich die CSS-Abfrage anhand eines anschaulichen Beispiels erklären.

Schritt 1 – Die Basis-Version

Die Beispiel-Website verwendet einen Header, eine Navigationsleiste und einen exemplarischen Inhaltsbereich, der nur dazu dient die Seite scrollbar zu machen. Im Idealfall wird die Navigationsleiste unter dem Header positioniert und verhält sich »sticky«. Sie bleibt also am oberen Ende des Browserfensters kleben, sobald man den Header weggescrolled hat.

Wir entwickeln das Beispiel nach dem Progressive-Enhancement-Konzept und beginnen mit der schlechtesten denkbaren Variante: Der Browser versteht weder den Befehl position:sticky;, noch die @supports ()-Abfrage. In diesem Fall befindet sich die Navigation unter dem Header, beide Elemente sind grau eingefärbt und scrollen ganz normal (position: static;).

Der schlechteste anzunehmende Fall: Der Browser versteht beide notwendigen Technologien nicht.

Der schlechteste anzunehmende Fall: Der Browser versteht beide notwendigen Technologien nicht.

In den nächsten Schritten optimieren wir diese Basis-Darstellung für modernere Systeme.

Schritt 2 – @supports ()

Nun kommt das Feature Query @supports () in Spiel. Mit Hilfe von @supports () können wir überprüfen ob ein Browser eine bestimmte Eigenschaft-Wert-Kombination unterstützt. Die Funktion nach der wir fragen wollen, wird in den runden Klammern notiert. Achtet darauf, dass kein Semikolon am Ende notiert wird!

Mit folgendem CSS-Code überprüfen wir, ob der Browser position: sticky versteht. Wenn ja, nutzen wir die Funktion, färben Header und Navi grün ein und wissen auch, dass der Browser @supports () versteht.


@supports (position: sticky) {
  .site-header {
    background: #9fe566;
  }

  .site-nav {
    position: sticky;
    background: #79c140;
  }
}
Der Idealfall: Der Browser versteht alle erforderlichen Befehle um das gewünschte Ergebnis darstellen zu können

Der Idealfall: Der Browser versteht alle erforderlichen Befehle um das gewünschte Ergebnis darstellen zu können

@supports not ()

Nun fügen wir noch einen Zwischenschritt ein, der in der Praxis vielleicht nicht zwingend notwendig ist, aus didaktischen Gründen in diesem Beispiel aber nicht fehlen sollte. Mit Hilfe von @supports not () können wir prüfen, ob der Browser den position:sticky;-Wert nicht unterstützt.

Sofern der Browser die Sticky-Funktion nicht versteht, färben wir alles rot ein und positionieren die Navigation mit position:fixed; immer ganz oben im Browser.


@supports not (position: sticky) {

  .site-header {
    background:#e56666;
    height:360px;
  }

  .site-nav {
    position: fixed;
    width:100%;
    background:#c03535;
  }
}
Ein Zwischenschritt: Der Browser versteht zwar nicht den sticky-Wert, aber die @supports ()-Abfrage

Ein Zwischenschritt: Der Browser versteht zwar nicht den sticky-Wert, aber die @supports ()-Abfrage

Live-Beispiel

Zum Veröffentlichungszeitpunkt dieses Artikels sind Safari, Firefox und Chrome die idealen Kandidaten um das Beispiel zu testen. Firefox versteht alle notwendigen Techniken, Chrome nur Teile davon. Safari versteht nichts.

Beispiel anschauen

Feature Queries mit »and« und »or« kombinieren

Es ist auch möglich Abfragen zu kombinieren. Dazu werden die Schlüsselwörter and oder or verwendet. Mit or könnt ihr prüfen, ob eine der nachfolgend notierten Eigenschaften unterstützt wird. Die or-Abfrage ist vor dem Hintergrund verschiedener Browser-Präfixe besonders interessant.


@supports (box-shadow: 0 2px 1px rgba(0,0,0,0.3)) or
          (-moz-box-shadow: 0 2px 1px rgba(0,0,0,0.3)) or
          (-webkit-box-shadow: 0 2px 1px rgba(0,0,0,0.3)) {

  .selector {
    -moz-box-shadow: 0 2px 1px rgba(0,0,0,0.3);
    -webkit-box-shadow: 0 2px 1px rgba(0,0,0,0.3);
    box-shadow: 0 2px 1px rgba(0,0,0,0.3);
  }

}

Mit and kann geprüft werden ob mehrere Eigenschaften unterstützt bzw. nicht unterstützt werden. Das ist vor allem dann interessant, wenn der gewünschte Effekt von mehreren CSS-Eigenschaften abhängig ist. Es übrigens nicht erlaubt and und or zu kombinieren.


@supports (-webkit-filter: blur(2px)) and (transition:all 1s ease-in-out) {

 img:hover {
    -webkit-filter: blur(2px);
    transition:all 1s ease-in-out;
 }

}

Browser-Support für CSS Feature Queries

Der Browser-Support sieht zum Veröffentlichungszeitpunkt dieses Artikels durchwachsen aus. Firefox, Chrome und Opera können Feature Queries interpretieren, der Internet Explorer und Safari nicht. Den detaillierten Browser-Support könnt ihr hier einsehen.

Links / Quellen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Sass: @for-Schleife zur Berechnung von Klassen-Selektoren im Gestaltungraster

$
0
0
Sass @for-Loop

In klassenbasierten CSS-Grids wird die Breite der Spalten im Gestaltungsraster mit Hilfe von Klassen gesteuert. Einen ausführlichen Artikel zu diesem Thema habe ich bereits veröffentlicht. Frameworks wie Bootstrap nehmen euch Arbeit ab, indem sie u.a. die Klassen und die jeweilige Breite vordefinieren. Mit Hilfe der @for-Schleifen in Sass könnt ihr euch ein individuelles System entwickeln. In diesem Beitrag archiviere ich das entsprechende Snippet.

@for-Schleifen in Sass

Mit einer @for-Schleife kann eine Anweisung mehrfach abgearbeitet und bei jedem Schleifendurchlauf verändert werden. Die Anzahl der Schleifendurchläufe steuern wir in diesem Beispiel über die Variable $grid-columns. Die Iterationsvariable $i wird bei jedem Durchlauf um 1 erhöht.

Das folgende Beispiel zeigt den SCSS-Code für ein 6-spaltiges Gestaltungsraster. Als Präfix für die Klassen-Selektoren verwende ich hier exemplarisch den Ausdruck »kulturbanause«.

$grid-columns: 6;
  @for $i from 1 through $grid-columns {
    .kulturbanause-#{$i} {
        width: percentage($i / $grid-columns);
  }
}

Der kompilierte CSS-Code sieht so aus:

.kulturbanause-1 {
  width: 16.66667%;
}

.kulturbanause-2 {
  width: 33.33333%;
}

.kulturbanause-3 {
  width: 50%;
}

.kulturbanause-4 {
  width: 66.66667%;
}

.kulturbanause-5 {
  width: 83.33333%;
}
.kulturbanause-6 {
  width: 100%;
}

Einen ergänzenden Artikel zum Thema »Semantische Raster« findet ihr hier.

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Feature Detection ohne Modernizr

$
0
0
feature-detection-css-js

Moderne Websites setzen fast ausnahmslos das Konzept »Feature Detection« ein, um in Erfahrung zu bringen, welche Techniken oder Funktionen von einem Browser unterstützt werden. Dazu wird i.d.R. die Feature Detection-Library Modernizr eingesetzt. Bei vielen Projekten halte ich Modernizr jedoch für überdimensioniert, da man häufig nur prüfen möchte ob JavaScript aktiviert ist, ob der Anwender einen Touch-Screen benutzt und ob SVGs eingesetzt werden können. In diesem Beitrag möchte ich daher einige JavaScript-Snippets archivieren, mit denen ihr die notwendigen Infos in Erfahrung bringen könnt ohne dafür die ganze Modernizr-Bibliothek laden zu müssen. In Zukunft werden in diesem Zusammenhang die Feature Queries von CSS sicher auch sehr interessant.

Grundvoraussetzung

Zunächst fügen wir – wie von Modernizr bereits bekannt – die Klasse .no-js in den <html>-Tag der Website ein. Mit Hilfe dieser Klasse können wir herausfinden, dass JavaScript nicht aktiviert ist. Im Folgenden wird nun mit Hilfe von JavaScript bzw. jQuery diese Klasse ausgetauscht und um weitere Klassen ergänzt.


<html class="no-js">

Prüfen ob JavaScript aktiviert ist

Als erstes prüfen wir ob JavaScript aktiv ist. Mit Hilfe von jQuery wird die Klasse .no-js durch .js ersetzt. Das funktioniert natürlich nur, wenn JavaScript aktiv ist.


// Prüfe ob JavaScript aktiviert ist
$('html').removeClass('no-js').addClass('js');

Prüfen ob ein Touch-Screen verwendet wird

Als nächstes prüfen wir ob der Anwender einen Touch-Screen einsetzt. Wenn ja wird dem <html>-Element die Klasse .touch hinzugefügt, wenn nicht .no-touch.


// Prüfe ob es sich um einen Touch-Screen handelt
function is_touch_device() {
  return !!('ontouchstart' in window);
}

if(is_touch_device()) {
  $('html').addClass('touch');
}
else {
  $('html').addClass('no-touch');
}

Prüfen ob SVG unterstützt wird

Um herauszufinden, ob SVG unterstützt wird, reicht folgender Code aus. Auch in diesem Fall fügen wir die Klasse .svg bzw. .no-svg in den <html>-Tag ein.


// Prüfe ob SVGs dargestellt werden können
if(!document.createElement('svg').getAttributeNS){
  $('html').addClass('no-svg');
} else {
  $('html').addClass('svg');
}

Beispiel anschauen

Die Dateiendung *.svg in <img>-Tags durch *.png ersetzen

Vor einiger Zeit habe ich einen Artikel veröffentlicht, in dem erklärt wird, wie mit Hilfe von Modernizr alle SVG-Grafiken im HTML-Code durch PNG-Grafiken ersetzt werden können. Diese Technik lässt sich auch ohne Modernizr einsetzen. Das folgende Beispiel zeigt, wie im HTML-Code alle Dateiendungen *.svg durch *.png ersetzt werden, sofern der Browser keine SVGs darstellen kann.


// Prüfe ob SVGs dargestellt werden können
if(!document.createElement('svg').getAttributeNS){
  $('html').addClass('no-svg');

  // Schreibe im HTML-Markup die Dateiendung *.svg auf *.png um.
  $('img[src$="svg"]').attr('src', function() {
    return $(this).attr('src').replace('.svg', '.png');
  });
} else {
  $('html').addClass('svg');
}

Feature Detection mit Old-School JavaScript

Die Beispiele in diesem Beitrag basieren allesamt auf jQuery. Es geht auch noch etwas schlanker, mit reinem JavaScript. Auf Github findet ihr in Form des Mini-Modernizr ein hilfreiches Snippet.

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

image-rendering: pixelated/crisp-edges – Bildinterpolation im Browser steuern

$
0
0
image-rendering-pixelated

Grafiken werden in flexiblen Web-Layouts häufig mit Hilfe des Browsers skaliert. Sofern es sich um Pixelgrafiken handelt, geht Qualität verloren, wenn die Grafik über ihre tatsächliche Größe hinaus skaliert wird. Das Bild wird unscharf. Aus diesem Grund werden Grafiken normalerweise kleiner skaliert. Doch auch diese Vorgehensweise hat Nachteile, denn es werden mehr Daten geladen als notwendig. Responsive Images und Techniken wie Downsampling schaffen hier Abhilfe, doch auch die Art wie der Browser die Bildskalierung berechnet, kann euch dabei helfen ein optisch besseres Ergebnis zu erreichen.

image-rendering

Mit der CSS-Eigenschaft image-rendering kann gesteuert werden, wie der Browser das Bild rendert. Sichtbar ist der Effekt aber erst, wenn das Bild skaliert wurde. Die CSS-Eigenschaft image-rendering ist also entfernt vergleichbar mit der Bildinterpolation in Photoshop. Auch hier stehen bei der Transformation von Grafiken verschiedene Interpolationsmethoden zur Verfügung.

Bildinterpolation in Photoshop

Bildinterpolation in Photoshop

image-rendering: auto;

Der Standard-image-rendering-Wert aller Browser ist auto, was der Interpolationsmethode »Bikubisch (Automatisch)« von Photoshop am ehesten entspricht. Der folgende Screenshot zeigt, wie eine Grafik normalerweise im Browser skaliert wird.

Standard-Bildskalierung im Browser. Das rot umrahmte Element ist die Originalgröße der Grafik

Standard-Bildskalierung im Browser. Das rot umrahmte Element ist die Originalgröße der Grafik

image-rendering: pixelated;

Mit folgendem CSS-Befehl kann die Rendering-Methode auf »Pixelwiederholung« gesetzt werden:


.pixelated {
  image-rendering: pixelated;
}

Hierbei werden alle Pixel auf glatte Zahlen gerundet. Das hat dann den Effekt, dass Kanten sehr scharf dargestellt werden.

Bildskalierung im Browser mit Hilfe des pixelated-Wertes von CSS. Das rot umrahmte Element ist die Originalgröße der Grafik

Bildskalierung im Browser mit Hilfe des pixelated-Wertes von CSS. Das rot umrahmte Element ist die Originalgröße der Grafik

image-rendering: crisp-edges;

Beim Wert crisp-edges, wird der Browser angewiesen einen Interpolations-Algorithmus zu verwenden, bei dem Kontraste und Farben erhalten bleiben und Kanten nicht unscharf werden. Das funktioniert sowohl beim Verkleinern als auch beim Vergrößern. In der Praxis fällt es häufig schwer einen Unterschied zwischen pixelated und crisp-edges wahrzunehmen.

Beispiel aller Werte anzeigen

Browser-Support

Der Browser-Support ist zum Veröffentlichungszeitpunkt dieses Beitrags noch recht unübersichtlich. Chrome und Opera unterstützen die Eigenschaft ohne Präfix, allerdings nur den Wert pixelated. Firefox und Safari benötigen einen Präfix, verstehen aber wiederum nur den crisp-edges-Wert …

Den exakten Browser-Support entnehmt ihr bitte der Website Caniuse.

Praxiseinsatz?

Die Interpolationsmethode »Pixelwiederholung« wird in Photoshop u.a. eingesetzt, wenn QR-Codes, Strichgrafiken, technische Zeichnungen, Infografiken oder Illustrationen die einen bewusst pixeligen Look haben (z. B. der 8 Bit-Stil) skaliert werden müssen. Im Browser kann ich mir vergleichbare Einsatzzwecke vorstellen.

Links / Quellen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.


Die CSS-Eigenschaft »object-fit« – Flexible Grafiken im HTML-Markup

$
0
0
css-object-fit

Mit der CSS-Eigenschaft object-fit lassen sich Bilder und Videos, die im HTML-Markup liegen zentrieren und zuschneiden. Die CSS-Eigenschaft background-size, für die Positionierung von CSS-Hintergrundbildern dürfte jedem soweit ein Begriff sein. Mit der Eigenschaft object-fit ist diese Positionierung auch mit Grafiken und Videos, die im HTML-Code liegen möglich.

Die Syntax

Für die CSS-Eigenschaft object-fit gibt es fünf verschiedene Werte, die dem Element übergeben werden können, um es an seiner Content-Box auszurichten.

fill
Das Element wird so in der Größe angepasst, dass es das seine Content-Box ausfüllt. Das Element wird hierbei im Seitenverhältnis verzerrt.
contain
Das Element wird anhand seiner Content-Box angepasst, ohne dass die Seitenverhältnisse des Elements verändert werden.
cover
Das Element wird so in der Größe angepasst, dass es seine Content-Box vollständig ausfüllt ohne dabei sein Seitenverhältnis zu verlieren. Es wird folglich zugeschnitten, sofern das Seitenverhältnis nicht zufällig übereinstimmt.
none
Das Element wird in der Größe nicht an seine Content-Box angepasst. Die Größe wird durch den Standardalgorithmus zur Größenanpassung bestimmt.
scale-down
Das Element wird in der Größe so angepasst, als ob none oder contain angegeben wären – je nachdem welcher Wert eine kleinere Größe ergeben würde.

object-fit anwenden

Angewendet wird die object-fit-Eigenschaft direkt auf das Bild bzw. Video.


img {
  object-fit:cover;
}

Das Element richtet sich dann an seiner eigenen Content-Box aus. Seht euch dazu auch das folgende Beispiel an:

Beispiel anschauen

Browser-Support

Der Browser-Support ist zum Veröffentlichungszeitpunkt dieses Beitrags gut, allerdings unübersichtlich. Chrome, Firefox und Opera unterstützen die Eigenschaft ohne Präfix. Safari benötigt einen Präfix. Der Internet Explorer unterstützt die Eigenschaft nicht, aber es existiert ein Polyfill.

Den exakten Browser-Support entnehmt ihr bitte der Website Caniuse.

Links / Quellen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

CSS-Hack für den Internet Explorer 10 (IE10)

$
0
0
ie10-logo

Der Internet Explorer von Microsoft ist bekannt für die fehlerhafte Interpretation von CSS-Eigenschaften. Um das Problem zu lösen, greift man häufig auf Conditional Comments zurück, um gezielt einzelne Versionen des Internet Explorers anzusprechen und die Fehler zu korrigieren. Für den IE10+ existieren leider keine Conditional Comments mehr und ihr bekommt Schwierigkeiten, falls ihr speziell für diesen Browser Elemente gesondert ansprechen wollt. Doch mit einem CSS-Hack lässt sich das Problem lösen.

CSS-Hack: -ms-high-contrast im IE10

Mit dem Media Query -ms-high-contrast könnt ihr Elemente speziell für den Internet Explorer 10 ansprechen und stylen. Dieser Media Query ist eine Eigenschöpfung von Microsoft und ihr werdet ihn daher nicht in der W3C-Spezifikation finden.

Der Query wurde mit Windows 8 zusammen eingeführt und wird seit Microsofts Edge-Browser nicht mehr unterstützt. Gedacht war der Media Query zur Unterscheidung von Bildschirmen mit verschiedenen Kontraststufen. Durch den Vendor-Präfix -ms- ist dieser Hack – im Vergleich zu vielen anderen Hacks – sogar standardkonform. Zusätzlich gewährleistet der Präfix, dass dieser Media Query wirklich nur vom Internet Explorer interpretiert wird. Durch Kombination der Werte active und none wird immer der Internet Explorer 10 angesprochen, egal in welchem Kontrastmodus sich die Seite befindet.

Folgendes Code-Beispiel verdeutlicht die Funktionsweise:


.box {
  height: 100px;
  background: green;
}

/* Die Box bekommt nur im Internet Explorer 10 einen roten Hintergrund. */
@media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {
  .box {
    background: red;
  }
}

Quellen / Links

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Quantity Queries – Layout-Veränderungen über die Anzahl an Elementen steuern

$
0
0
quantity-queries

Im responsive Design wird i.d.R. mit Hilfe von Breakpoints das Layout umstrukturiert, sobald eine bestimmte Displaygröße erreicht ist. Schwierig wird es allerdings, wenn man zum Zeitpunkt der Entwicklung nicht weiß, wie breit ein bestimmtes Element ist. Beispielsweise weil die Ausgabe dynamisch erfolgt oder weil ein Kunde über das CMS selbstständig Inhalte ergänzen kann. Hier kommen die sog. Quantity Queries (Mengenabfragen) ins Spiel: Mit ihrer Hilfe kann die Darstellung verändert werden, sobald eine festgelegte Anzahl an Elementen unter- und/oder überschritten wird.

Das Grundprinzip

Quantity Queries ermöglichen es euch Breakpoints zu setzen, die von der Menge der Geschwister-Elemente in einem festgelegten Bereich abhängig sind. Somit lassen sich beispielsweise Navigationen verändern, sobald mehr als X Listenelemente einhalten sind. Quantity Queries erweitern die Möglichkeiten des responsive Design, da auf inhaltliche Änderungen - beispielsweise durch den Kunden - reagiert werden kann. Sie sind immer dann von Nutzen, wenn die Anzahl von Elementen in einem Bereich variieren kann und der Webdesigner nicht vorhersehen kann wie viele Elemente tatsächlich in diesem Bereich auftauchen.

Die Syntax

Quantity Queries funktionieren mit Hilfe eines komplexen CSS-Selektors. Mit :nth-last-child wird von hinten durch Geschwister-Elemente gezählt. Sobald die gewünschte Anzahl erreicht ist, werden alle Geschwister-Elemente angesprochen.

Im folgenden Beispiel verändert sich die Darstellung, sobald fünf oder mehr Listenpunkte zu einer Navigation hinzugefügt wurden. In der ersten Zeile des Beispiels wird von hinten durch die Anzahl der Listenpunkte gezählt bis der fünfte erreicht wurde. Wenn weniger als fünf <li>s vorhanden sind, greift der Selektor nicht. Sobald bis fünf gezählt werden kann, werden alle Geschwisterelemente ausgewählt. Das geschieht in der zweiten Zeile des Beispiels.

ul li:nth-last-child(n+5), 
ul li:nth-last-child(n+5) ~ li {
 background:red;
}

Wir haben euch eine interaktive Demo erstellt, in der ihr per Klick Listenpunkte hinzufügen oder entfernen könnt.

Beispiel anschauen

 

Die minimale Anzahl an Elementen abfragen

Der folgende und oben bereits kennengelernte Selektor reagiert, sobald weniger als fünf Elemente vorhanden sind.

.parent .child:nth-last-child(n+5), 
.parent .child:nth-last-child(n+5) ~ .child { }

Die maximale Anzahl an Elementen abfragen

Wenn ihr einen Selektor konstruieren möchtet, der so lange reagiert bis maximal fünf Elemente vorhanden sind, wählt folgende Schreibweise:

.parent .child:nth-last-child(-n+5):first-child, 
.parent .child:nth-last-child(-n+5):first-child ~ .child { }

Eine Ober- und Untergrenze festlegen

Wenn ihr sowohl eine Ober- als auch eine Untergrenze festlegen wollt, kombiniert die Selektoren. Der folgende Code ermöglicht eine Auswahl, wenn mehr als fünf und weniger als 10 Elemente vorhanden sind.

.parent .child:nth-last-child(n+5):nth-last-child(-n+10):first-child, 
.parent .child:nth-last-child(n+5):nth-last-child(-n+10):first-child ~ .child { }  

Da es etwas schwierig sein kann die Selektoren zu schreiben, wurde bereits ein entsprechendes Tool entwickelt, mit dessen Hilfe ihr die Abfragen generieren könnt.

Quantity Queries im Praxiseinsatz

In der Praxis gibt es viele sinnvolle Einsatzmöglichkeiten für Quantity Queries. Beispielsweise die bereits erwähnte Hauptnavigation. Angenommen ein Kunde hat über das CMS die Möglichkeit selbstständig Menüpunkte hinzuzufügen. Sobald er zu viele Menüpunkte hinzufügt, könntet ihr die Darstellung entsprechend abfangen. Das folgende interaktive Beispiel zeigt wie die Navigation von einer horizontalen Ausrichtung in eine vertikale Ausrichtung geändert wird, sobald mehr als sechs Menüpunkte vorhanden sind.

Beispiel anschauen

 

Eine weitere typische Einsatzmöglichkeit ist die Darstellung von Galerien. Im folgenden Beispiel ändern wir das Raster einer angedeuteten Bildergalerie jedes Mal, wenn ein Element hinzugefügt wird.

Beispiel anschauen

 

Browser-Support

Die Technologie hängt von CSS3-Selektoren ab, der Browsersupport beginnt daher beim IE9. Eine detaillierte Auswertung zeigt Can I Use.

Links / Quellen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Prozess- / Check-Out-Navigation mit CSS

$
0
0
prozessnavigation-css

Bei der Gestaltung von Prozess- bzw. Check-Out-Navigationen wird häufig auf Grafiken zurückgegriffen, um das gewünschte Aussehen zu erreichen.
In diesem Beitrag zeigen wir euch eine Lösung, wie ihr eine solche Navigation mit reinem CSS und ganz ohne Grafiken realisieren könnt. Wir gehen dabei auf eine Lösung mit floatenden Elementen und auf eine Lösung mit dem CSS Flexbox-Modell ein.

Das HTML-Gerüst

Wir verwenden sowohl bei dem Ansatz mit floatenden Elementen sowie bei der Lösung mit Flexbox das gleiche HTML-Gerüst für den Aufbau der Navigation.
Das <li>-Element des Navigationspunktes, auf dessen Seite sich der Anwender gerade befindet, erhält im Beispiel die Klasse current. Über diese Klasse wird zusätzlich die Farbgebung der vorherigen und somit schon erledigten Prozessschritte gesteuert.

<ul>
  <li class="current">
    <a href="#">
      <span>Menüpunkt</span>
    </a>
  </li>
  <li>
    <a href="#">
      <span>Menüpunkt</span>
    </a>
  </li>
  ...
</ul>

Der Basis-CSS-Code

Im Folgenden erklären wir euch die grundsätzliche Funktionsweise des CSS-Codes zur Gestaltung der Navigation.
Das <a>-Element erweitern wir um das Pseudoelement ::after. Dieses Pseudoelement positionieren wir absolut zum <a>-Element und lassen es rechts ein wenig überstehen. Es wird quadratisch angelegt und mit der CSS-Eigenschaft transition:rotate um 45° gedreht. So entsteht die gewünschte Pfeiloptik.

Das ::after-Pseudoelement wird gedreht und oben und unten abgeschnitten

Das ::after-Pseudoelement wird gedreht und oben und unten abgeschnitten

Um nun die unerwünschten Ecken oben und unten zu entfernen, weisen wir dem <li>-Element overflow:hidden zu. Nun verschwindet aber leider auch der soeben erzeugte Pfeil. Um diesen wieder sichtbar zu machen, geben wir dem <a>-Element ein margin nach rechts und ziehen bei dem <li>-Element durch ein negatives margin diesen Wert wieder ab. Das negative margin muss durch einen entsprechenden positiven Wert der Liste (<ul>) wieder hinzugefügt werden, damit diese nicht unerwünscht verschoben wird.

Dem ersten und letzten Menüpunkt weisen wir über die Pseudoklassen :first-child und :last-child spezielle Eigenschaften zu (z. B. entfernen wir bei dem letzten Menüpunkt den Pfeil wieder). Dem <span> weisen wir position:relative zu und positionieren ihn mit einem z-index über allen anderen Elementen. So gehen wir sicher, dass der Text nie vom ::after-Element überlagert wird.

ul {
  list-style: none;
  margin: 0 0 0 1.775em;
  padding: 0;
}

ul::before,
ul::after {
  content: '';
  display: table;
}

ul::after {
  clear: both;
}

li {
  float: left;
  overflow: hidden;
  margin-left: -1.775em;
}

li a {
  display: block;
  text-align: center;
  text-decoration: none;
  color: #fff;
  position: relative;
  background: green;
  padding-left: 2em;
  margin-right: 1.775em;
}

li a::after {
  content: '';
  position: absolute;
  right: -1.25em;
  top: 0.063em;
  width: 2.5em;
  height: 2.5em;
  background: green;
  -ms-transform: rotate(45deg);
  -webkit-transform: rotate(45deg);
  transform: rotate(45deg);
  border-color: #fff #fff transparent transparent;
  border-width: 0.125em;
  border-style: solid;
  z-index: 10;
}

li:first-child a {
  padding-left: 0.4em;
}

li:last-child a {
  padding-right: 0.8em;
  margin: 0;
}

li:last-child a::after {
  display: none;
}


li:hover a,
li:hover a::after {
  background: forestgreen;
}

li a:focus,
li a:focus::after,
li a:active,
li a:active::after {
  background: limegreen;
}

li.current a,
li.current a::after {
  background: darkgreen;
}

li.current ~ li a,
li.current ~ li a::after {
  background: lightgray;
}

li.current ~ li:hover a,
li.current ~ li:hover a::after {
  background: darkgray;
}

li.current ~ li a:focus,
li.current ~ li a:focus::after,
li.current ~ li a:active,
li.current ~ li a:active::after {
  background: gray;
}

span {
  position: relative;
  z-index: 100;
  display: block;
  padding: 0.8em 0 0.8em 0.4em;
}

Beispiel anzeigen

Navigation über volle Breite

Falls ihr die Navigation über die volle Breite eures Layouts laufen lassen wollt, stellen wir euch hier zwei Varianten zur Umsetzung vor. Wenn ihr die Anzahl der Navigationspunkte genau wisst, könnt ihr im oberen Code einfach eine Prozentangabe bei den <li>-Elementen hinzufügen. Zusammengerechnet müssen alle Listenpunkte 100% ergeben. Falls euch die genaue Anzahl der Navigationspunkte nicht bekannt ist solltet ihr über das CSS Flexbox-Modell nachdenken.

Der CSS-Code für die Flexbox-Lösung

Um eure Navigation mit Flexbox aufzubauen, müsst ihr am oben beschriebenen CSS-Code nur kleine Änderungen vornehmen. Dem <ul> müsst ihr die Angabe display:flex geben und dem <li> die Angabe flex:1. Nun müsst ihr noch dem <li> die Angabe float:left entziehen. Dementsprechend entfällt auch der Nutzen des Clearfixes, der über die Pseudoelemente ::before und ::after dem <ul> hinzugefügt wurde.
Jetzt erstreckt sich eure Navigation über die volle Breite eures Layouts, egal wie viele Navigationspunkte in eurer Navigation stehen.
Für weitere Informationen vom Flexbox-Modell von CSS können wir euch diesen Artikel empfehlen.

ul {
  list-style: none;
  margin: 0 0 0 1.775em;
  padding: 0;
  display: flex;
}

li {
  flex: 1;
  overflow: hidden;
  margin-left: -1.775em;
}
/* Alle weiteren Selektoren bleiben unverändert */

Beispiel anzeigen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Jonas Hellwig im Interview zu »Gestaltung & Code«

$
0
0
jonas-hellwig

Im Oktober startet die »WebTech Conference« in München. Im Interview mit dem Journalisten Thomas Wießeckel spricht Webdesigner Jonas Hellwig über Gestaltung und Code, ein Thema, das er auch als Trainer auf der »WebTech Conference« und der »International PHP Conference« umfassend beleuchtet.

Dieses Interview ist zuerst in gekürzter Form bei t3n erschienen. Hier könnt ihr die fehlenden zwei Drittel nachlesen.

Tom Wießeckel: Jonas, wir schreiben das Jahr 2015 – die Browser nähern sich langsam, was die Unterstützung der Funktionalitäten angeht. Wie siehst du die Situation aus deinem Tagesgeschäft heraus betrachtet?

Jonas Hellwig: Auf den ersten Blick scheinen die neuen Browser-Generationen in der Tat die wichtigsten CSS-Eigenschaften gleich oder zumindest recht ähnlich zu interpretieren. Aber wenn man sehr moderne Techniken wie Blend-Modes, Shapes, Filter, Grid-Module-Layouts etc. einsetzen möchte, dann ist die Kompatibilität nach wie vor recht unterschiedlich.

Die Zeiten in denen die Anpassung für ältere Browsergenerationen sehr zeitaufwändig und ärgerlich war sind allerdings vorbei. Das hat verschiedene Gründe. Einerseits werden die wirklich problembehafteten Browser wie der Internet Explorer 8 oder älter nur noch selten im Projekt berücksichtigt. Viel entscheidender ist aber, dass der Workflow sich verändert hat. Wir entwickeln Websites mittlerweile aus Sicht schwacher und kleiner Geräte und erweitern dann mittels Feature Detection nach und nach neuere Funktionen und mittels Media Queries größere Layout-Varianten (Stichwort Mobile First & Progressive Enhancement). Diese Herangehensweise führt zu weniger Problemen, da wir am Anfang eines Projekts merken, wenn etwas nicht funktioniert.

Auch unsere Kunden verstehen viel besser als früher, dass eine Website nicht in jedem Browser gleich aussehen muss. Wir achten allerdings auch penibel darauf, dass sie diesen Punkt zum Projektbeginn verstanden und akzeptiert haben. Aber das macht vieles leichter. Wir können moderne Effekte bereits heute problemlos einsetzen, wenn auf Kundenseite verstanden wurde, dass moderne Systeme dadurch einen Vorteil haben. Früher wurde es eher so verstanden, dass ältere Systeme einen Nachteil haben.

Tom Wießeckel: Auf der WebTech hältst du einen Workshop mit dem Titel »Gestaltung und Code«, in dem du erklärst, wie sich grafische Bestandteile einer Website mit Code umsetzen lassen. Ist das nicht ein gefährliches Unterfangen – gerade wenn man an die Browservielfalt und deren zahlreiche Unterschiede im Umgang mit den einzelnen Technologien angeht?

Jonas Hellwig: Teils teils. Ein Web Designer sollte wissen wie kompatibel die CSS- oder SVG-Eigenschaften sind, die verwendet werden müssen um die gewünschte Gestaltung zu erreichen. Im Idealfall schreibt er den CSS-Code natürlich direkt selbst. Aber wenn er nicht in der Lage ist einzuschätzen wie umsetzbar sein Design ist, dann sehe ich da ehrlich gesagt ein Problem.

Nun einmal angenommen er weiß, dass eine benötigte CSS-Eigenschaft nicht voll kompatibel mit allen gewünschten Browsern ist. Jetzt geht es darum abzuwägen wie schlimm das ist und welche Fallback-Lösungen zur Verfügung stehen. Wenn ich beispielsweise die Trennstriche in einer horizontalen Navigation mit Hilfe von transform:skew(-45deg); schräg stelle, weiß ich, das der Internet Explorer 8 keine Transformationen versteht. Wenn man nun nach dem Prinzip »Progressive Enhancement« vorgeht, dann ist die Navigation in inkompatiblen Browsern gerade ausgerichtet und in Browsern die CSS-Transforms verstehen eben schräg. Das finde ich absolut in Ordnung, solange beides für sich gut aussieht und gut funktioniert.

Bauchschmerzen habe ich bei unterschiedlichen Ergebnissen in verschiedenen Systemen, wenn das Element stilprägend ist, oder fest im Corporate Design des Kunden verankert ist. Aber das muss je nach Projekt abgewogen werden.
Die Kunst besteht nicht nur darin moderne Effekte einzusetzen, sondern saubere Fallback-Lösungen einzuplanen.

Tom Wießeckel: Um wie vieles wird es komplizierter, wenn man dann noch das Thema Responsive Web Design einbezieht?

Jonas Hellwig: Responsive Design verkompliziert die Sache zwar noch einmal – für mich aber nicht erheblich. Es ist auch hier eine Frage der Herangehensweise und des Workflows. Da bei uns Websites größtenteils im Browser gestaltet werden, testen wir regelmäßig, wie die Gestaltung sich in den verschiedenen Systemen verhält. Dazu gehört dann natürlich auch, dass von vorne herein alle Displaygrößen und Bedienkonzepte berücksichtigt werden. Und da können sich dann schon ein paar Kombinationsmöglichkeiten ergeben. Am gerade besprochenen Beispiel der schräg gestellten Navigation gäbe es beispielsweise folgende denkbare Szenarien:

  1. Der Browser versteht CSS-Transformationen. Die Navigation ist folglich schräg ausgerichtet.
  2. Der Browser versteht keine CSS-Transformationen. Die Navigation ist gerade ausgerichtet.
  3. Der Anwender nutzt einen Touch-Screen. Mouse-Over Effekte können nicht eingesetzt werden.
  4. Der Anwender nutzt eine Mouse. Wir können Mouse-Over-Effekte verwenden.
  5. Die »mobile Navigation« wird angezeigt.
  6. Die »Desktop Navigation« wird angezeigt.

Wenn ich nun alle Kombinationen in Photoshop gestaltet müsste wäre der Aufwand viel zu hoch und das Projekt ruck zuck in den roten Zahlen. Wenn direkt im Browser gearbeitet wird, müssen nur die einzelnen Zustände entwickelt werden. Kombinationen ergeben sich dann automatisch, was die Arbeit erheblich erleichtert. Und darüber hinaus sehen wir sofort, wenn etwas nicht wie geplant funktioniert.

Tom Wießeckel: Wie erklärst du dir, dass Technologien wie SVG, die schon einige Jahre alt sind, erst jetzt durchstarten?

Jonas Hellwig: Ich denke das hat verschiedene Gründe. Einerseits war der Prozess, ausgehend von wenigen kompatiblen Browser hin zum Status Quo mit einer sehr guten SVG-Kompatibilität langwierig und schleichend. Ich denke viele Designer und Webentwickler kennen das Format SVG namentlich schon lange, hatten aber immer im Hinterkopf, dass SVG zu inkompatibel für den produktiven Einsatz ist. Seit nun der IE8 in vielen Projekten nicht mehr berücksichtigt werden muss, kann SVG allerdings mehr oder weniger problemlos eingesetzt werden. Aber es gab nie die große Ankündigung »Hört her – ab sofort kann SVG verwendet werden«. Das sah vor kurzem beim Thema responsive Images (<picture> & Co.) schon etwas anders aus.

Ein weiterer Grund ist wahrscheinlich auch der Zeitpunkt zu dem SVG das Licht der Welt erblickt hat. Damals (2001) gab es Probleme wie hochauflösende Displays oder responsive Design noch nicht. Mit den Pixel basierten Bildformaten konnten man eigtl alles machen, was man wollte. Warum sollte man sich als Webdesigner also mit einem neuen, damals inkompatiblen Format herumschlagen, wenn es keine wirkliche Notwendigkeit dafür gab.
Zuletzt möchte ich auch nicht ausschließen, dass die Erstellung und die Bearbeitung von SVGs für einige Designer damals eine Herausforderung darstellte oder auch heute noch darstellt. Photoshop konnte lange Zeit mit SVGs gar nichts anfangen, Illustrator hatte früher deutlich schlechtere Export-Funktionen als heute. Man musste daher fast zwangsläufig nach dem Export aus Illustrator, Anpassungen am Code der SVG-Datei vornehmen. Das ist auch bei aktuellen Projekten häufig notwendig.

Zu einer Zeit in der Design und Entwicklung noch stärker getrennt waren als das heute der Fall ist, war die notwendige Anpassung des Codes mit Sicherheit kein Pluspunkt für die Verwendung von SVG. Denn die Erstellung der Grafiken fiel damals klar ins Ressort des Designers.

Tom Wießeckel: In deinem Tagesgeschäft arbeitest du mit Illustrator und Co. – liefern die Tools mittlerweile sauberen Code, den man bedenkenlos übernehmen kann?

Jonas Hellwig: Es hängt zwar sehr stark von der Gestaltung ab, aber im Normalfall muss man SVG-Files nach dem Export händisch anpassen und optimieren. Man kann zwar in Illustrator mittlerweile recht viel einstellen, aber oft entstehen bei der Bearbeitung leere Gruppen (<g>) o.ä. Dargestellt werden die Grafiken allerdings auch ohne Korrektur zuverlässig.

Der SVG-Export von Photoshop erlaubt aktuell gar keine Einstellungen. Man erzeugt in Photoshop daher SVG-Grafiken die deutlich größer sind als nötig und die sich schwer bis gar nicht optimieren lassen. Mehrere Pfade auf einer Ebene werden beispielsweise zu einem Objekt zusammengefasst, Kurvenpunkte werden immer mit mehreren Nachkommastellen exportiert usw. Aber Photoshop ist halt auch eine Bildbearbeitungssoftware.

Beim CSS-Export sieht es folgendermaßen aus: Der CSS-Export von Photoshop selbst ist unbrauchbar. Der CSS-Export von Illustrator schon besser. Adobe Extract führt ebenfalls zu ganz passablen Ergebnissen. Sehr gute Ergebnisse erzielt man mit kommerziellen Plugins von Drittanbietern.
Ein guter CSS-Export setzt allerdings – unabhängig vom Export-Tool – voraus, dass der Designer alles so gestaltet hat, dass es sich umsetzen lässt. Auch sollte man Elemente einzeln exportieren und nicht das ganze Photoshop-Layout in den Export schicken und erwarten, dass wie von Zauberhand sauberer CSS-Code daraus wird.

Tom Wießeckel: … und wie steht es mit dem Mehraufwand, wenn man sein Design modular aufbauen möchte?

Jonas Hellwig: Hier ist es eher der Prozess der Umstellung, der Designern Schwierigkeiten bereitet. Früher haben wir Layouts in Unterseiten und in Geräteklassen betrachtet. Da gab es eine Startseite und eine Unterseite und diese beiden Seitentypen für Smartphone, Tablet und Desktop. Schon war man bei sechs Layouts, was bekanntlich dazu geführt hat, dass dieser Workflow heute nicht mehr effizient ist.

Mittlerweile denkt man in Komponenten und Design-Modulen. Diese werden dann auf verschiedenen Geräten oder Seitentypen unterschiedlich kombiniert. Anstelle weniger großer Dateien, arbeiten wir mit vielen kleinen Dateien und Sinnabschnitten.

Diesen Wandel hin zur modularen Denkweise spüren wir auch in fast allen Tools: Photoshop exportiert längst Image-Assets, CSS-Präprozessoren erlauben die Verschachtelung von Dateien usw. Das mag auf den ersten Blick unübersichtlicher sein, langfristig führt es aber dazu, dass man viel organisierter arbeiten kann, Aufgaben besser delegieren kann und im Team besser gemeinsam an einem Projekt arbeiten kann. Wenn der Workflow also einmal sitzt, ist man schneller als bisher.

Tom Wießeckel: Aktuell sind gerade im Bereich CSS viele Techniken noch experimentell – wann denkst du, wird die Browserlandschaft so weit sein, dass man mit einer einheitlichen Basis ohne Hacks und Workarounds identische – oder zumindest gleichwertige – Ergebnisse erreicht?

Jonas Hellwig: Ich denke nicht, dass die Browser irgendwann auf einem einheitlichen Stand der Technik sind. Wir werden um Workarounds, Hacks, Vendor-Präfixe etc. also nicht herumkommen. Doch bereits heute ist es ja so, dass es zahlreiche Tools und Task-Runner gibt, die diese notwendigen Anpassungen für uns übernehmen. Früher musste man beispielsweise noch nachschauen welche Vendor-Präfixe für eine bestimmte CSS-Eigenschaft benötigt werden. Anschließend musste man sie schreiben.

Heute übernimmt diese Aufgabe ein Postprozessor der – wie im Falle des Autoprefixers den CSS-Code mit der Datenbank von CanIUse abgleicht und die Präfixe automatisch bei der Kompilierung des Sass/Less-Files hinzufügt. Schöne automatisierte Welt.

Tom Wießeckel: Abschließend eine Frage, die vielen unter den Nägeln brennt: Ist Microsoft noch immer das größte Sorgenkind für Webdesigner?

Jonas Hellwig: Webdesigner lieben es gegen den verhassten Internet Explorer zu wettern. Da ginge also ein Stück Kultur verloren, wenn dieser Browser plötzlich keine Probleme mehr bereiten würde. Aber Spaß beiseite. Es ist zwar enttäuschend, dass ein modernder Browser wie Edge keine SVG-Animationen mit SMIL unterstützt, aber gebessert hat sich die Microsoft-Fraktion in den letzten Jahren schon.

Ich persönlich habe mit dem Internet Explorer bis einschließlich Version 8 wenig Probleme. Vorausgesetzt man hat nicht den Anspruch, dass alles pixelgenau überall gleich aussieht.

Mobile iOS- oder Android-Browser sind aus meiner Erfahrung viel schlimmer und auch moderne Versionen von Chrome, Firefox und vor allem Safari können sehr lästige Bugs besitzen. Fehler in diesen Browsern sind viel schwieriger zu beheben, da sich die Systeme nicht so leicht gezielt ansprechen lassen.

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

CSS Keyframe-Animationen

$
0
0
css-keyframes

CSS-Animationen werden mittlerweile von allen modernen Browsern unterstützt und ersetzen daher in vielen Bereichen Effekte, die einst nur über JavaScript realisiert werden konnten. Neben den sog. CSS-Transitions sind vor allem die CSS-Keyframe-Animationen interessant. Mit Keyframe-Animationen können komplexe Animationsabläufe über sog. Schlüsselbilder (keyframes) erzeugt werden. Im Gegensatz zu Transitions, die eine Interaktion des Users voraussetzen, können Keyframe-Animationen auch selbstständig ablaufen.

Die Syntax

Eine Keyframe-Animation wird in zwei Teilen aufgebaut. Mit der @keyframes-Regel wird bestimmt, wie die Animation heißen soll, welche Schlüsselbilder es in der Animation gibt und welche CSS-Eigenschaften animiert werden sollen. Die simpelste Keyframe-Animation besteht aus zwei Schlüsselbildern, für den Beginn und das Ende der Animation.

@keyframes meine-animation {
  from {
    /* Eigenschaften zum Beginn der Animation */ 
  }

  to {
    /* Eigenschaften zum Ende der Animation */ 
  }
}

.mein-selektor {
  animation-name: meine-animation;
  animation-duration: 2s;
  animation-iteration-count: infinite;
  /* weitere animation-Eigenschaften */
}

Der zweite Teil der Animation wird im Selektor des Objekts, das animiert werden soll notiert. Dazu existieren die animation-Eigenschaften in CSS:

animation-name (Pflichtangabe)

Über die Eigenschaft animation-name definiert man welche Keyframes verwendet werden sollen. Es muss der in der @keyframes-Regel verwendete Name angegeben werden.

animation-duration (Pflichtangabe)

Mit animation-duration wird in Sekunden festgelegt wie lange die Animation dauern soll.

animation-iteration-count (Pflichtangabe)

Mit der Eigenschaft animation-iteration-count wird bestimmt wie oft die Animation ablaufen soll. Mögliche Werte sind das Schlüsselwort infinite für unendliche viele Wiederholungen. Ansonsten kann ein beliebiger Zahlwert angegeben werden.

Beispiel anschauen

animation-timing-function

Mit animation-timing-function wird bestimmt, wie die Animationskurve aussehen soll. Hier existieren die Schlüsselbegriffe ease, steps(<integer>, start), steps(<integer>, end), linear, ease-out, ease-in-out, ease-in für bereits vordefinierte Animationskurven. Wenn eine eigene Kurve verwendet werden soll, kann sie über ein Tool erzeugt und schließend in form von cubic-bezier(<number>, <number>, <number>, <number>) eingefügt werden. Der Standard-Wert ist ease.

Beispiel anschauen

animation-delay

Mit animation-delay wird eine Verzögerung der Animation in Sekunden festgelegt.

Beispiel anschauen

animation-direction

Mit animation-direction kann die Richtung der Animation festgelegt werden. Mögliche Werte sind normalreverse (die Animation wird rückwärts abgespielt), alternate-reverse (die Animation wird bei jedem ungeraden Durchlauf rückwärts abgespielt) und alternate (die Animation wird bei jedem geraden Durchlauf rückwärts abgespielt).

Beispiel anschauen

animation-fill-mode

Mit animation-fill-mode wird festgelegt, wie das Objekt sich verhalten soll, wenn die Animation gerade nicht läuft. Beispielsweise weil über animation-delay eine Verzögerung eingestellt wurde oder die Animation bereits abgelaufen ist. Es sind folgende Werte erlaubt: noneforwards (Zustand zum Ende der Animation), backwards (Zustand zum Beginn der Animation), both (kombinierte Werte aus dem Beginn und dem Ende der Navigation)

animation-play-state

Mit animation-play-state wird festgelegt ob die Animation abgespielt wird oder pausiert. Mit dem Wert running wird die Animation abgespielt, mit paused pausiert. Dies macht in Kombination mit Mouse-Over-Effekten oder JavaScript Sinn.

Beispiel anschauen

Kurzschreibweise

Die Kurzschreibweise für die oben genannten animation-Eigenschaften lautet animation. Die Werte müssen in folgender Reihenfolge angegeben werden.

.selektor {
  animation: [animation-name] [animation-duration] [animation-timing-function] [animation-delay] [animation-iteration-count] [animation-direction] [animation-fill-mode] [animation-play-state]
}

Komplexe Animationen

Innerhalb der @keyframes-Regel können beliebig viele Schlüsselbilder angegeben werden. Wenn es mehr als zwei sind, wird die Position auf der Zeitleiste in Prozent angegeben.

@keyframes meine-animation {
  0% {
    /* Eigenschaften zum Beginn der Animation */ 
  }
  50% {
    /* Eigenschaften nach der Hälfte der Animation */ 
  }
  100% { 
    /* Eigenschaften zum Ende der Animation */  
  }
}

Es können auch Werte zusammengefasst werden.

@keyframes meine-animation {
  0% {
    /* Eigenschaften zum Beginn der Animation */ 
  }
  25%, 75% {
    /* Eigenschaften von 1/4 bis 3/4 der Animation */ 
  }
  100% { 
    /* Eigenschaften zum Ende der Animation */  
  }
}

Beispiel 1: Objekte bewegen und Farbe wechseln

Das folgende Beispiel zeigt, wie eine Keyframe-Animation aufgebaut sein kann. Wir bewegen einen <div> zwischen vier Koordinaten und wechseln zusätzlich die Farbe.

<div class="mein-element"></div>
.mein-element {
  height:120px;
  width:120px;
  background:silver;
  border-radius: 100%;
  position: absolute;
  animation-name:meine-animation;
  animation-duration:4s;
  animation-iteration-count:infinite;
}

@keyframes meine-animation {
  0%, 100% {
    background-color:red;
    top:50px;
    left:50px;
  }

  25% {
    background-color:gold;
    top:50px;
    left:600px;
  }

  50% {
    background-color:lime;
    top:600px;
    left:600px;
  }

  75% {
    background-color: blue;
    top:600px;
    left:50px;
  }
}

Beispiel anschauen

Mit weiteren Elementen und der animation-delay-Eigenschaft, kann der Effekt noch ansprechender gestaltet werden:

<div class="mein-element"></div>
<div class="mein-element"></div>
<div class="mein-element"></div>
<div class="mein-element"></div>
.mein-element:nth-of-type(2) {
  animation-delay:1s;
  animation-fill-mode:backwards;
}

.mein-element:nth-of-type(3) {
  animation-delay:2s;
  animation-fill-mode:backwards;
}

.mein-element:nth-of-type(4) {
  animation-delay:3s;
  animation-fill-mode:backwards;
}

/* Der übrige CSS-Code ist mit oben gezeigten Beispiel identisch */

Beispiel anschauen

Beispiel 2: Animierte Grafik

Das zweite Beispiel zeigt einen Hai der im Meer schwimmt. Der Hai selbst bewegt sich dabei nur minimal nach links und rechts, der Effekt entsteht in erster Linie durch die Verschiebung des Hintergrunds. Das Beispiel verwendet mehrere Hintergrundbilder um ohne überflüssige HTML-Elemente auszukommen. Darüber hinaus wird in diesem Beispiel die Kurzschreibweise für Animationen verwendet.

<div></div>
div {
  width:800px;
  height:600px;
  background-color:#034557;
  background-image: url(hai.png), url(fische.png);
  background-position: top 150px left 120px, 110px 90px;
  background-repeat: no-repeat, repeat-x;
  animation:ocean .75s infinite linear;
}

@keyframes ocean {
  0%{
    background-position: top 150px left 120px, 110px 90px;
  }

  50% {
    background-position: top 150px left 100px, 362px 90px; /* Die Fische werden um die Häfte der Breite der fische.png-Grafik verschoben */
  }

  100% {
    background-position: top 150px left 120px, 615px 90px; /* Die Fische werden um die volle Breite der fische.png-Grafik verschoben */ 
  }
}

Beispiel anschauen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Text mit CSS vertikal zentrieren

$
0
0
vertikal-zentrieren

Texte auf einer Website horizontal zu zentrieren sollte für die meisten Webdesigner kein Problem darstellen. Auch wie gefloatete und absolut positionierte Elemente horizontal zentriert werden können haben wir bereits in einem Beitrag erklärt. Eine vertikale Zentrierung von Texten ist da schon etwas komplizierter. In diesem Artikel erklären wir euch, wie ihr mit wenigen CSS-Angaben zum Ziel kommt und ansprechende gestalterische Ergebnisse erzielt. Insbesondere im Responsive Webdesign kann diese Technik von Vorteil sein.

Die Voraussetzung im HTML-Code

Um Text in einem Element vertikal zentrieren zu können, muss euer Text-Element (im Beispiel eine <h2>) das einzige direkte Kind-Element sein. Weitere Verschachtelungen innerhalb des Text-Elements sind möglich, aber euer Element darf keine weiteren Geschwister-Elemente besitzen. In folgendem Beispiel wollen wir die <h2> vertikal zentriert im Container mit der Klasse .header ausrichten.

<div class="header">
  <h2>Überschrift</h2>
</div>

/* Überschrift mit weiterer Verschachtelung */
<div class="header">
  <h2>Überschrift
    <span>mit Untertitel</span>
  </h2>
</div>

Die CSS-Angaben display: table; und display: table-cell;

Nun müsst ihr dem umliegendem Element, also dem Element, an dem ihr später euren Text ausrichten wollt, die CSS-Angabe display: table; geben. Das Element verhält sich jetzt genau so, wie eine Tabelle im HTML. Falls euer Element vorher ein Block-Element war und ihr die gleichen Breitenverhältnisse wieder herstellen wollt, müsst ihr im die Breite mit width: 100%; manuell zuweisen. Zusätzlich solltet ihr dem Element eine Höhe geben, um später auch einen Effekt zu sehen. Die Angabe height verhält sich durch eure vorherigen Angaben ähnlich der Angabe min-height, die allerdings in diesem Beispiel nicht mehr greifen würde.

.header {
  display: table;
  width: 100%;
  height: 10em;
}

Als nächstes gebt ihr dem Text-Element die Angabe display: table-cell;, damit es sich so verhält wie eine Tabellen-Zelle in HTML. Eine Angabe der Breite eures Text-Elements ist nicht notwendig, da es sich standardmäßig an seinem Elternelement ausrichtet. Mit der Angabe vertical-align: middle; könnt ihr nun den Text vertikal mittig an seinem Elternelement ausrichten.

h2 {
  display: table-cell;
  vertical-align: middle;
}

Beispiel anschauen

Mit Flexbox vertikal zentrieren

Eine weitere Möglichkeit Inhalte vertikal in ihrem Elternelement zu zentrieren bietet das Flexbox-Modell von CSS. Hierbei erhält lediglich das Elternelement spezielle Angaben zur Positionierung. Mit der Angabe display:flex; aktiviert ihr das Flexbox-Modell innerhalb des Eltern-Elements. Um den Text nun vertikal zu zentrieren benötigt ihr zusätzlich die Angabe align-items:center;. Soll euer Text auch horizontal zentriert sein, erreicht ihr das mit justify-content:center;. Falls ihr mit dem Flexbox-Modell arbeiten wollt, überprüft vorher bei caniuse.com ob alle, für euer Projekt relevanten Browser, dieses Modell bereits verstehen. Einen Einführungsartikel zu Flexbox haben wir hier veröffentlicht.

.header {
  display: flex;
  align-items: center;
  justify-content: center;
}

Beispiel anschauen

Nützliche Hilfsmittel

Natürlich gibt es auch Online-Tools, die euch dabei helfen können Texte und Elemente vertikal und horizontal zu zentrieren. Einige dieser nützlichen Tools findet ihr auf best-web-design-tools.com. Tools zum Thema Flexbox findet ihr hier.

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.


Gezeichnete SVG-Pfade mit CSS animieren

$
0
0
svg-css-line-draw-animation

Mit SVG/CSS-Animationen lassen sich ansehnliche Effekte erzeugen. Sehr beliebt ist beispielsweise der sog. »Line-Draw-Effect«, bei dem ein Pfad animiert gezeichnet wird. Um den Effekt herzustellen, behilft man sich einem Trick im Zusammenhang mit gestrichelten Linien. In diesem Beitrag erklären wir das Grundprinzip anhand eines leicht nachvollziehbaren Beispiels.

SVG- und CSS-Basisgestaltung

Zunächst muss ein entsprechender SVG-Pfad gezeichnet werden. Dazu kann Illustrator, Inkscape oder ein anderes Vektor-Programm genutzt werden. Was ihr bei der Erstellung von SVG-Grafiken beachten solltet, haben wie hier bereits zusammengefasst.

Das Endergebnis sieht nun wie folgt aus: Innerhalb von <svg> wird ein Pfad-Objekt (<path>) erzeugt. Dieser Pfad erhält das Class-Attribut »object«. Innerhalb des d-Attributs werden die Kurvenpunkte notiert.

<!-- gekürzter Code! -->
<svg>
  <path class="object" d="M116.6,250c-15.4,43.1-20.6, … "/>
</svg>

Der Pfad erhält über CSS einen transparenten Hintergrund (fill) eine Kontur-Farbe (stroke) und eine Kontur-Stärke (stroke-width).

.object {
  fill:none; 
  stroke:grey;
  stroke-width:4;
}

Strichelung und Verschiebung für die Pfadkontur einstellen

Als nächstes kommen die bereits erwähnten gestrichelten Linien zum Einsatz. Wie aus Photoshop oder Illustrator bekannt, kann bei Vektor-Objekten die Kontur gestrichelt dargestellt werden. Es kann sowohl die Länge der Strichelung, als auch die Länge der Abstände zwischen den Strichen festgelegt werden.

  • Über die CSS-Eigenschaft stroke-dasharray wird festgelegt wie lang die Strichelungen bzw. Abstände zwischen den Strichen sind.
  • Mit der CSS-Eigenschaft stroke-dashoffset wird die Strichelung auf dem Pfad verschoben. 

Der Trick funktioniert nun so: Sowohl die Länge der Strichelung (stroke-dasharray) als auch die Verschiebung mittels stroke-dashoffset muss so lang sein, wie der Pfad der gezeichnet werden soll. Es entsteht eine gestrichelte Linie mit sichtbaren Segmenten in Länge des Pfads und mit Lücken in Länge des Pfads. Das sichtbare Segment wird nun so verschoben, dass es genau auf dem Pfad sitzt. Ihr seht also keinen Unterschied zu einer nicht-gestrichelten Kontur. Im nächsten Schritt, wird die Kontur auf dem Pfad verschoben, wodurch der gezeichnete Look entsteht.

Länge des SVG-Pfads mit JavaScript ermitteln

Lästig ist, dass ihr wissen müsst wie lang der Pfad ist, damit ihr die Strichelung exakt einstellen könnt. Um die Länge des Pfads in Erfahrung zu bringen kann folgendes JavaScript eingesetzt werden:

var path = document.querySelector('.object');
var length = path.getTotalLength();
console.log(length);

Kopiert das Snippet in einen <script>-Abschnitt am Ende eures Dokuments. Anschließend steht die Länge des Pfads in der JavaScript-Konsole und kann auf den Code übernommen werden.

Der CSS-Code für das Pfad-Objekt sieht nun so aus:

.object {
  stroke:grey;
  stroke-width:4;
  stroke-dasharray: 1665.7286376953125;
  stroke-dashoffset: 1665.7286376953125;
  fill:none;
}

Pfad animieren

Nun kommt die Animation ins Spiel. Mit Hilfe einer CSS-Keyframe-Animation verschieben wir die gestrichelte Kontur auf den Pfad.

.object {
  …
  animation: dash 2s linear forwards;
}

@keyframes dash {
  to {
    stroke-dashoffset: 0;
  }
}

Das war auch schon alles. Das fertige Beispiel könnt ihr euch hier anschauen:

Beispiel anschauen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Hintergrund-Grafiken mit CSS positionieren

$
0
0
css-positionierung-hinterguende

Mit CSS lassen sich Hintergrund-Grafiken einbinden und positionieren. Welche Möglichkeiten man bei der Positionierung dieser Grafiken hat, wollen wir euch in diesem Artikel zeigen. Dabei gehen wir neben der CSS-Eigenschaft background-position auch auf die Eigenschaften background-clip und background-origin ein und zeigen euch anhand von Beispielen ihre Auswirkungen auf die Hintergrundgrafik.

Grundlagen der Positionierung mit CSS

Die CSS-Eigenschaft background-position ist für die Positionierung von CSS-Hintergrund-Grafiken verantwortlich. Eine Grafik (background-image) ist folglich Pflicht, damit die Eigenschaft Wirkung zeigt. Für das bessere Verständnis, gehen wir in den folgenden Beispielen von einem sich nicht wiederholenden Hintergrund (background-repeat: no-repeat;) aus. Sollte euch die grundsätzliche Verwendung von Hintergrundgrafiken nicht geläufig sein, schaut euch zunächst diesen Artikel an.

Der Standard-Wert für die Positionierung einer Hintergrundgrafik ist immer die linke obere Ecke des jeweiligen Elements. Standardmäßig werden zwei Werte zugewiesen – die Verschiebung auf der horizontalen (X) und die Ausrichtung auf der vertikalen (Y) Achse. Sollte nur ein Wert angegeben werden, so bestimmt dieser immer die horizontale Position der Grafik. Die vertikale Position wird dann automatisch mittig gesetzt.

/* Da keine Positionierung angegeben wurde, wirkt der Standardwert. Das Hintergrundbild wird an der linken oberen Ecke des DIV-Containers positioniert */
div {
  background-image: url(image.png);
  background-repeat: no-repeat;
}

Beispiel anschauen

Schlüsselwörter und numerische Angaben

Als Werte für die Positionierung können Schlüsselwörter, numerische Angaben oder eine Kombination aus beidem verwendet werden.
Schlüsselwörter für die horizontale Positionierung sind: left, right und center.
Für die vertikale Positionierung lauten die Schlüsselwörter top, bottom und center. Möchte man also beispielsweise das Hintergrundbild rechts unten positionieren würde der Code wie folgt aussehen:

div {
  background-position: right bottom;
}

Beispiel anschauen

Numerische Werte können unter anderem in px, em oder Prozent angegeben werden. Hierbei bestimmt wie gehabt, der erste Wert die horizontale und der zweite Wert die vertikale Positionierung. In folgendem Beispiel ist die Hintergrund-Grafik 20px vom linken Rand und 30% vom oberen Rand des DIV-Containers positioniert.

div {
  background-position: 20px 30%;
}

Beispiel anschauen

Durch Kombination von Schlüsselwörtern und numerischen Angaben habt ihr die Möglichkeit Abstände von bestimmten Seiten des Elements anzugeben. Hierzu gibt man als erstes das Schlüsselwort (z. B. right) an, und danach numerisch den Abstand, welcher von diesem Rand erzeugt werden soll. Möchtet ihr also eine Hintergrundgrafik 20px vom rechten Rand und 1em vom unteren Rand entfernt anzeigen, muss der Code wie folgt aussehen:

div {
  background-position: right 20px bottom 1em;
}

Beispiel anschauen

Die CSS-Eigenschaft background-clip

Mit der CSS-Eigenschaft background-clip bestimmt ihr, über welche Boxen des Box-Models sich die Hintergrundgestaltung erstrecken soll. Der Standard-Wert ist border-box. Weitere mögliche Werte wären padding-box und content-box. Möchte man einem Element also zum Beispiel den Wert content-box zuweisen, geschieht das mit folgendem Code:

div {
  background-clip: content-box;
  background-position: right 20px bottom 1em;
  padding: 2em; 
  /* Weitere, für dieses Beispiel unwichtige Eigenschaften */
}
Mit background-clip beschnittene Grafik

Mit background-clip auf die Content-Box beschnittene Grafik

Der Hintergrund wird nun ausschließlich in der Content-Box angezeigt. Der Screenshot zeigt, dass in diesem Fall die Padding-Box transparent ist und die Grafik daher optisch angeschnitten wird.

Beispiel anschauen

Um ein besseres Verständnis für diese Eigenschaft zu bekommen, empfehlen wir den Artikel über das Box-Model zu verinnerlichen.

Die CSS-Eigenschaft background-origin

Die CSS-Eigenschaft background-origin legt mit Hilfe des Box-Models den Ausgangspunkt für die Positionierung der Hintergrund-Grafik fest. Die zu verwendenden Werte lauten ebenfalls: padding-box, border-box und content-box. Als Standard-Wert wird die padding-box verwendet. Mit folgendem Code orientiert sich die Hintergrundgrafik an der Content-Box. Da padding vergeben wurde, wirkt die Grafik nun optisch eingerückt.

div {
  background-origin: content-box;
  background-position: 0 0;
  padding: 1em;
  /* Weitere, für dieses Beispiel unwichtige Eigenschaften */
}

 

Mit background-origin positionierte Grafik

Mit background-origin in der Content-Box positionierte Grafik

Beispiel anschauen

Hintergründe verzerren und skalieren

Wenn ihr erfahren möchtet wie Hintergrundgrafiken verzerrt und skaliert werden können, schaut euch diesen Beitrag an.

Quellen / Links

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Parallelogramme mit CSS erstellen

$
0
0
css-parallelogram

Im modernen Webdesign wird häufig auf rechteckige Gestaltungselemente zurückgegriffen. Ein Parallelogramm kann diese klaren Strukturen brechen und mehr Abwechslung ins Layout bringen. Wie ihr mit Hilfe von CSS ganz einfach Parallelogramme erstellen könnt bei denen der enthaltene Text nicht verzerrt wird, erklären wir euch in diesem Artikel anhand des Beispiels einer Navigation.

Der HTML-Grundaufbau

Beim HTML-Grundaufbau der Navigation gibt es keine weiteren Besonderheiten. Standardmäßig befinden sich alle Links in einer ungeordneten Liste. Der spätere CSS-Code lässt sich aber auch auf alle Block-Elemente, ob einzeln stehend oder verschachtelt, anwenden.

<ul>
  <li><a href="#">Menüpunkt</a></li>
  <li><a href="#">Menüpunkt</a></li>
  <li><a href="#">Menüpunkt</a></li>
  <li><a href="#">Menüpunkt</a></li>
</ul>

CSS-Parallelogramm mit Transformation und Pseudoelement erstellen

Um aus den einzelnen Links des Menüs Parallelogramme zu erzeugen, müssen die <a>-Tags zu Block-Elementen (display: block;) gemacht werden und relativ positioniert werden (position: relative;).

a {
  display: block;
  position: relative;
}

Das Pseudoelement ::after

Anschließend kommt das Pseudoelement ::after zum Einsatz. Dieses Element wird absolut zum <a>-Tag positioniert und mit den Angaben top, right, bottom und left über dessen gesamte Fläche ausgedehnt. Um es sichtbar zu machen, bekommt es eine Hintergrundfarbe.

a::after {
  content: '';
  position: absolute;
  top: 0;
  right: 0;
  bottom: 0;
  left: 0;
  background: darkblue;
}

Die Ausrichtung auf der z-Achse verschieben

Schaut man sich nun das Ergebnis im Browser an, wird man blaue Rechtecke sehen, die den Text der Menüpunkte überdecken. Mit Hilfe eines negativen z-index (z-index: -1;) schieben wir das soeben erzeugte Pseudoelement nach hinten und machen so den Text wieder sichtbar.

a::after {
  ...
  z-index: -1;
}

Aus dem Rechteck ein Parallelogramm erzeugen

Um nun aus den erzeugten Rechtecken ein Parallelogramm zu machen benötigt ihr nur noch die CSS-Eigenschaft transform. Als Wert gebt ihr skew und den von euch gewünschten Winkel der Neigung an.

a::after {
  ...
  transform: skew(-45deg);
}

Der vollständige CSS-Code

Den vollständigen CSS-Code könnt ihr untenstehend sehen. Des Weiteren findet ihr dort auch ein Funktionsbeispiel. Solltet ihr weitere Fragen zu den Pseudoelementen ::before und ::after haben empfehlen wir euch diesen Artikel.

a {
  display: block;
  position: relative;
}

a::after {
  content: '';
  position: absolute;
  top: 0;
  right: 0;
  bottom: 0;
  left: 0;
  z-index: -1;
  transform: skew(-45deg);
}

Beispiel anschauen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Kommaseparierte Listen mit CSS

$
0
0
css-komma-list

Eine HTML-Liste wird üblicherweise untereinander und mit Aufzählungszeichen dargestellt. Häufig wünscht man sich jedoch auch eine horizontale Darstellung, bei der die einzelnen Listenelemente nebeneinander stehen und mit Komma von einander getrennt sind. Nur hinter dem letzten Element soll natürlich kein Komma mehr stehen. Mit Hilfe der CSS-Pseudoklasse :not und des -Pseudoelements ::after kann die gewünschte Ansicht elegant hergestellt werden.

Listenpunkte mit Komma trennen

Der Aufbau ist denkbar einfach: Zunächst werden die Listenpunkte per Float, Inline-Block oder Flexbox horizontal nebeneinander ausgerichtet. Anschließend verwenden wir das Pseudoelement ::after um nach jedem Listenpunkt ein Komma einzufügen.

Da allerdings nach dem letzten Listenpunkt kein Komma angezeigt werden soll, und wir zum Entfernen des Kommas auch keinen zusätzlichen CSS-Selektor verwenden möchten, kommt die Pseudoklasse :not() ins Spiel. Innerhalb von :not() kann festgelegt werden, was nicht zutreffen darf, damit das Element selektiert wird. Daher notieren wir innerhalb von :not() die Pseudoklasse :last-child.

li:not(:last-child)::after {
  content:', ';

Beispiel anschauen

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Bildunterschriften mit CSS immer perfekt ausrichten

$
0
0
bildunterschriften-ausrichten-css

Die Gestaltung von Bildunterschriften kann mitunter lästig werden. Es ist schwierig zu entscheiden ob der Text zentriert oder linksbündig unter dem Bild angezeigt werden soll, da die Textmenge oft stark variiert. Zentrierte Bildunterschriften sehen bei kurzen Texten gut aus. Linksbündig passt besser wenn die Bildunterschrift mehrere Zeilen umfasst. Was also tun?

In diesem Beitrag findet ihr ein CSS-Snippet, dass automatisch dafür sorgt, dass kurze Bildunterschriften zentriert werden, und mehrzeilige Bildunterschriften linksbündig ausgerichtet werden.

Lange Bildunterschriften automatisch linksbündig anzeigen

Der Trick ist denkbar einfach. Ein Bild mit Bildunterschrift besteht i.d.R. aus dem Container-Element <figure>, sowie den enthaltenen Elementen <img> und <figcaption>.

<figure>
  <img src="bild.png" alt /> 
  <figcaption>Hier steht eine sehr lange Bildunterschrift. Sie ist so lang, dass Sie in zwei Zeilen läuft und daher linksbündig angezeigt wird. </figcaption>
</figure>

Innerhalb von <figure> wird der Text nun zunächst zentriert.

figure {
  text-align: center; 
}

Anschließend wird innerhalb der Bildunterschrift <figcaption> der Text linksbündig ausgerichtet und das Element auf display:inline-block; gesetzt.

figcaption {
  display: inline-block; 
  text-align: left;
}

Das war auch schon alles: Wenn die Bildunterschrift kürzer ist als das Bild breit ist, wird <figcaption> aufgrund des Inline-Block-Verhaltens innerhalb von <figure> zentriert. Der in <figcaption> enthaltene Text ist natürlich immer noch linksbündig, doch das sieht man nicht.

Die Bildunterschrift hat einen gelben Hintergrund erhalten, damit die Positionierung besser erkennbar ist

Die Bildunterschrift hat einen gelben Hintergrund erhalten, damit die Positionierung besser erkennbar ist

Erst wenn die Bildunterschrift so lang wird, dass das <figcaption>-Element über die volle Breite von <figure> läuft, sieht man, dass der Text linksbündig ist. Mehrzeilige Bildbeschreibungen werden daher automatisch linksbündig angezeigt.

Beispiel anschauen

Links / Quellen:

Jetzt bist Du gefragt

Gefällt Dir dieser Beitrag oder bist du anderer Meinung? Hast du Anregungen, Ergänzungen, einen Fehler gefunden oder ist dieser Beitrag nicht mehr aktuell? Dann freuen wir uns auf deinen Kommentar.

Viewing all 173 articles
Browse latest View live