<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>adamczuk.net.pl &#187; selectors</title>
	<atom:link href="http://adamczuk.net.pl/tag/selectors/feed/" rel="self" type="application/rss+xml" />
	<link>http://adamczuk.net.pl</link>
	<description>Just another WordPress weblog</description>
	<lastBuildDate>Sun, 06 May 2012 22:34:15 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3.1</generator>
		<item>
		<title>Kolorowanie wierszy i kolumn w tabeli</title>
		<link>http://adamczuk.net.pl/2009/12/16/kolorowanie-wierszy-i-kolumn-w-tabeli/</link>
		<comments>http://adamczuk.net.pl/2009/12/16/kolorowanie-wierszy-i-kolumn-w-tabeli/#comments</comments>
		<pubDate>Wed, 16 Dec 2009 20:49:47 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[CSS]]></category>
		<category><![CDATA[XHTML]]></category>
		<category><![CDATA[html]]></category>
		<category><![CDATA[selectors]]></category>
		<category><![CDATA[table]]></category>

		<guid isPermaLink="false">http://adamczuk.net.pl/?p=236</guid>
		<description><![CDATA[Nowoczesny sposób na kolorowanie wierszy i kolumn w tabeli z wykorzystaniem selektorów potomka.]]></description>
			<content:encoded><![CDATA[<p><img src="http://adamczuk.net.pl/wp-content/uploads/2009/12/zebra-striping.jpg" alt="zebra-striping" title="zebra-striping" width="300" height="100" class="left size-full wp-image-237" /> Tabele to jedne z najpopularniejszych elementów jakie występują na stronach internetowych. Rozbudowana struktura tabel pozwala na osiągnięcie wspaniałych efektów poprzez zastosowanie stylów kaskadowych.<br />
<span id="more-236"></span></p>
<p>Przykłady stylizacji tabel zostały w 2006 roku zebrane przez niezawodny <a href="http://www.smashingmagazine.com/2006/12/29/css-based-tables-modern-solutions/">Smashing Magazine</a>. Czas w sieci upływa bardzo szybko, wiele z tych przykładów, jeśli nie wszystkie to przykłady przestarzałe. Jednak ten sam Smashing Magazine w nowszym artykule prezentuje naprawdę atrakcyjne <a href="http://www.smashingmagazine.com/2008/08/13/top-10-css-table-designs/">przykłady</a>. Niestety wygląd to nie wszystko.</p>
<h3>Problem</h3>
<p>Wielokrotnie zdarza się, że za ciekawym wyglądem tabeli kryje się nadmierna liczba klas, które dotyczą poszczególnych elementów. Podstawowa struktura tabeli składa się z trzech znaczników <code>&lt;table&gt;</code>, <code>&lt;tr&gt;</code> oraz <code>&lt;td&gt;</code>, które tworzą odpowiedni element tabeli, wiersze i poszczególne komórki.</p>
<p>Taka struktura nie pozwala na zbyt wiele, ponieważ odniesienie się do elementów poprzez selektory kontekstu jest wręcz niemożliwa. Jedyne dostępne rozwiązanie to wykorzystanie atrybutów <code>&lt;class&gt;</code> i selektorów klas.</p>
<p>Kolorowanie wierszy i kolumn wymaga użycia atrybutu <code>&lt;class&gt;</code> dla każdej komórki. Kolorowanie samych wierszy uzyskamy poprzez atrybuty<code>&lt;class&gt;</code> dla poszczególnych znaczników <code>&lt;tr&gt;</code>. Poniższe style określają kolor tła dla nieparzystego i parzystego wiersza oraz nieparzystej i parzystej kolumny.</p>
<pre><code>.odd-row {
	background: #eee;
}
.even-row {
	background: #ccc;
}
.odd-column {
	background: #fcc;
}
.even-column {
	background: #f44;
}</code></pre>
<p>Zamierzony efekt zostanie osiągnięty, ale kod naszej tabeli stanie się mniej czytelny, zarówno dla wyszukiwarek, jak i dla ludzie. Istnieje dobra alternatywa dla powyższego rozwiązania.</p>
<h3>Rozwiązanie pośrednie</h3>
<p>Konieczne zmiany dotyczą kodu tabeli. Struktura tabeli udostępnia elementy grupujące wiersze oraz kolumny. Znaczniki <code>&lt;thead&gt;</code>, <code>&lt;tbody&gt;</code> oraz <code>&lt;tfoot&gt;</code> grupują odpowiednio wiersze nagłówka, danych i stopki.</p>
<p>Analogiczne przeznaczenie ma znacznik <code>&lt;colgroup&gt;</code>, który obejmuje poszczególne kolumny tabeli, zdefiniowane przez znaczniki <code>&lt;col&gt;</code>.</p>
<p>Ważne jest zrozumienie kolejności wyświetlania warstw, które tworzą strukturę tabeli. Szczegółowy <a href="http://www.456bereastreet.com/archive/200410/bring_on_the_tables/">artykuł</a> na ten temat napisał Roger Johansson.</p>
<p>Zmodyfikowana struktura pozwala na użycie analogicznych stylów w arkuszu, jednak zamiast selektorów klasy korzystamy z selektorów kontekstu.</p>
<h3>Nowoczesne podejście</h3>
<p>Selektory potomka oferowane przez CSS3 umożliwiają jeszcze dokładniejsze odwołanie się do elementów w strukturze dokumentu. Niestety Internet Explorer <a href="http://adamczuk.net.pl/2009/01/08/obsluga-selektorow-css3-przez-przegladarki/">nie obsługuje</a> selektora potomka, co jest sporym mankamentem tego rozwiązania.</p>
<pre><code>col:nth-child(odd) {
	background: #faa;
}
col:nth-child(even) {
	background: #f44;
}
tbody tr:nth-child(odd) {
	background: transparent url(img/grey-10-transparent.png) 0 0 repeat;
}
tbody tr:nth-child(even) {
	background: transparent url(img/grey-50-transparent.png) 0 0 repeat;
}</code></pre>
<p>Właściwe dobranie kolorów tła oraz obrazów pozwala na uzyskanie właściwego kolorowania wierszy i kolumn. Wygląd <a href="http://adamczuk.net.pl/-/multiple-zebra-striping/">tabeli</a> jest dokładnie taki, jak oczekiwaliśmy. Dodatkowa zaleta tego podejścia to struktura tabeli wolna od zbędnych atrybutów <code>&lt;class&gt;</code>. </p>
<h3>Podsumowanie</h3>
<p>Przedstawione przykłady różnią się sposobem w jaki uzyskano efekt końcowy. Czytelniejsza struktura i lżejszy kod to wielka zaleta. Podobnych rozwiązań istnieje wiele, jednak nie stosuje się ich powszechnie z powodu braku wsparcia po stronie Internet Explorera.</p>
]]></content:encoded>
			<wfw:commentRss>http://adamczuk.net.pl/2009/12/16/kolorowanie-wierszy-i-kolumn-w-tabeli/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Tabele i style kaskadowe</title>
		<link>http://adamczuk.net.pl/2009/07/07/tabele-i-style-kaskadowe/</link>
		<comments>http://adamczuk.net.pl/2009/07/07/tabele-i-style-kaskadowe/#comments</comments>
		<pubDate>Tue, 07 Jul 2009 19:26:58 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[CSS]]></category>
		<category><![CDATA[XHTML]]></category>
		<category><![CDATA[html]]></category>
		<category><![CDATA[selectors]]></category>
		<category><![CDATA[striping]]></category>
		<category><![CDATA[table]]></category>
		<category><![CDATA[zebra]]></category>

		<guid isPermaLink="false">http://adamczuk.net.pl/?p=201</guid>
		<description><![CDATA[Prosta, szybka i nowoczesna zmiana wyglądu tabeli]]></description>
			<content:encoded><![CDATA[<p>Tabela jest jednym z podstawowych elementów HTML, a przeznaczeniem tabeli jest prezentacja danych tebelarycznych. Przed laty dzięki swoim właściwościom tabele były wykorzystywane na wiele różnych, niekoniecznie właściwych sposobów. Obecne technologie pozwalają na zmienienie wyglądu tabeli bardzo prosto i szybko, jednocześnie zachowując minimalną ilość znaczników, zamiast wiele klas.</p>
<p>Uzyskanie takich efektów umożliwia CSS3, który jest poprawnie obsługiwany przez nowoczesne przeglądarki. Trudno mówić o komercyjnym zastosowaniu takiego rozwiązania, kiedy Internet Explorer 8 <a href="http://adamczuk.net.pl/2009/01/08/obsluga-selektorow-css3-przez-przegladarki/">odmawia</a> poprawnej interpretacji wielu selektorów CSS3, w tym bardzo użytecznych selektorów potomka. Jednak praktycznie zapoznanie się z nowymi możliwościami CSS3, pozwoli na ich stosowanie chociażby w niekomercyjnych projektach lub własnych zastosowaniach.</p>
<p><span id="more-201"></span></p>
<h3>Wprowadzenie</h3>
<p>Pierwszym krokiem jest stworzenie struktury tabeli. Danymi źródłowymi były wartości indeksów na GPW, zaczerpnięte z serwisu <a href="http://gielda.wp.pl/POD,20,a,1,b,2,c,3,notowania.html">finansowego</a> Wirtualnej Polski. Jakie było moje zdziwienie, gdy kod dwukolorowej tabeli z kilkowa wierszami zawierał ponad 3000 znaków. Jednak takie są skutki formatowania danych w kodzie HTML, a także błędne wykorzystanie dostępnych technologii.</p>
<p>Minimalna struktura tabeli to znaczniki <code>&lt;table&gt;</code>, <code>&lt;tr&gt;</code> oraz <code>&lt;td&gt;</code>. Elementy te odpowiadają za tworzenie całej tabeli, kolejnych wierszy i poszczególnych komórek. W dalszej kolejności możemy dołączyć <code>&lt;thead&gt;</code>, <code>&lt;tbody&gt;</code>, a także <code>&lt;tfoot&gt;</code>, które dzielą całość tabeli na poszczególne sekcje: nagłówek, zawartość oraz stopkę. Wielu programistów zapomina o opisie tabeli, który zamieszczamy w tagu <code>&lt;caption&gt;</code>. Szczegółowe informacje na temat struktury tabeli w XHTML przedstawia <a href="http://www.w3.org/TR/2004/WD-xhtml2-20040722/mod-tables.html">specyfikacja</a> na stronie W3C.</p>
<p>Poniżej został przedstwiony skrócony kod tabeli, jaka była użyta w tym artykule.</p>
<pre><code>&lt;table&gt;
    &lt;caption&gt;Indeksy (WIG20 bez opóźnień)&lt;/caption&gt;
    &lt;thead&gt;
        &lt;tr&gt;
            &lt;th rowspan="2"&gt;czas&lt;/th&gt;
            &lt;th rowspan="2"&gt;nazwa&lt;/th&gt;
            &lt;th colspan="2"&gt;wartość [pkt]&lt;/th&gt;
            &lt;th colspan="2"&gt;zmiana&lt;/th&gt;
            &lt;th colspan="3"&gt;wartość [pkt]&lt;/th&gt;
        &lt;/tr&gt;
        &lt;tr&gt;
            &lt;th&gt;bieżąca&lt;/th&gt;
            &lt;th&gt;odniesienia&lt;/th&gt;
            &lt;th&gt;[pkt]&lt;/th&gt;
            &lt;th&gt;[%]&lt;/th&gt;
            &lt;th&gt;otwarcia&lt;/th&gt;
            &lt;th&gt;min&lt;/th&gt;
            &lt;th&gt;max&lt;/th&gt;
        &lt;/tr&gt;
    &lt;/thead&gt;
    &lt;tbody&gt;
        &lt;tr&gt;
            &lt;td&gt;16:40&lt;/td&gt;
            &lt;td&gt;WIG20&lt;/td&gt;
            &lt;td&gt;1 810,38&lt;/td&gt;
            &lt;td&gt;1 810,97&lt;/td&gt;
            &lt;td&gt;-0,59&lt;/td&gt;
            &lt;td&gt;-0,03&lt;/td&gt;
            &lt;td&gt;1 824,07&lt;/td&gt;
            &lt;td&gt;1 803,29&lt;/td&gt;
            &lt;td&gt;1 837,98&lt;/td&gt;
        &lt;/tr&gt;
        ...
    &lt;/tbody&gt;
&lt;/table&gt;</code></pre>
<p>Najważniejsza zaleta tabeli to czytelność danych, które są grupowane wierszami, kolumnami lub wierszami i kolumnami. Niestety zbyt małe odstępy między komórkami niekorzystnie wpływają na szukanie danych oraz ich porównywanie, co przedstawia pierwszy <a href="http://adamczuk.net.pl/-/modern-table/example-1.html">przykład</a>.</p>
<h3>Wersja podstawowa</h3>
<p>Selektory potomka dostępne w CSS3 odnoszą się do odpowiednich elementów potomnych danego rodzica. Tabela to powtarzający się zbiór określonych znaczników, a zatem idealnie nadaje się do zademonstrowania wspomnianych selektorów strukturalnych.</p>
<p>Najpierw zajmiemy się ustawieniem podstawowych właściwości dla naszej tabeli, jak tło, odstępy rozmiar czcionki dla wszystkich komórek.</p>
<pre><code>table {
    background: #aaa;
    font-family: sans-serif;
    font-size: 12px;
    border-spacing: 1px;
}</code></pre>
<p>Dotychczasowym sposobem na uzyskanie kolorowania wierszy w tabelach było stosowanie atrybutu <em>class</em> dla elementu <code>&lt;tr&gt;</code>. jeszcze trudniejsze było kolorowanie kolumn, które wymagało takiego zabiegu przy każdej komórce <code>&lt;td&gt;</code>. Jednak CSS3 pozwala na szybkie odnalezienie dowolnego elementu w strukurze DOM, pod warunkiem, że znamy jego rodzica.</p>
<p>Odnalezienie nieparzystych wierszy tabeli i ustawienie koloru tła umożliwia następujący selektor <code>tr:nth-child(2n+1)</code>. Możliwy jest, także bardziej ludzki zapis, czyli <code>tr:nth-child(odd)</code>.</p>
<pre><code>table tr:nth-child(odd) td {
    background: #eee;
}</code></pre>
<p>Analogicznie postępujemy w przypadku parzystych wierszy, do których zastosujemy selektor <code>tr:nth-child(2n)</code> lub <code>tr:nth-child(even)</code>.</p>
<pre><code>table tr:nth-child(even) td {
    background: #ccc;
}</code></pre>
<p>Kolejne reguły ustawiają kolor tła nagłówka, odstępy kolor czcionki. Informacje przedstawione w całej tabeli zostały wyrównane do prawej, pownieważ większość z kolumn zawiera dane liczbowe. Dwie pierwsze kolumny zostały wyrównane do lewej, dzięki selektorom potomka ustawionym dla komórek <code>td:nth-child(1)</code> i <code>td:nth-child(2)</code>.</p>
<pre><code>table th {
    background: #000;
    padding: 5px 10px;
    color: #fff;
}
table td {
    padding: 3px 5px;
    text-align: right;
}
td:nth-child(1),
td:nth-child(2) {
    text-align: left;
}</code></pre>
<p>Kilkanaście linijek kodu CSS zmienia znacząco wygląd naszej tabeli, co pokazuje <a href="http://adamczuk.net.pl/-/modern-table/example-2.html">kolejny</a> przykład. To nie koniec możliwości jakie oferuje CSS w przypadku stylowania tabel.</p>
<p>Możliwe jest ustawienie określonych właściwości dla poszczególnych kolumn, tak jak to miało miejsce w przypadku wyrównania zawartości pierwszej i drugiej kolumny. Bardzo przydatny jest opis tabeli umieszczony w znaczniku <code>&lt;caption&gt;</code>, który bez przeszkód modyfikujemy w stylach kaskadowych.</p>
<p>Jeśli szerokość naszej tabeli jest zbyt mała i chcemy zwiększyć jej rozmiar to z pomocą przychodzą następujące reguły:</p>
<pre><code>table {
    width: 100%;
    max-width: 1024px;
}</code></pre>
<p>Dzięki tym właściowościom nasza tabela dostosuje się do szerokości strony lub elementu, w którym jest umieszczona, nie przekraczając przy tym 1024 pikseli. W przypadku osadzenia tabeli w elemencie o zadanej szerokości, druga właściowość jest zbędna.</p>
<h3>Podsumowanie</h3>
<p>Dalsze możliwości stylizacji przykładowej tabeli są równie łatwe, dzięki zastosowaniu nowych selektorów. Wszystko zależy od naszych potrzeb i wyobraźni. Przeglądarki, które obsługują selektory CSS3 to Firefox 3.1+, Opera 9+, Safari 3+ oraz Chrome. Istnieje częściowe wsparcie dla wymienionych selektorów w przeglądarkach Internet Explorer, jednak nawet IE8 nie obsługuje sporej ich części.</p>
]]></content:encoded>
			<wfw:commentRss>http://adamczuk.net.pl/2009/07/07/tabele-i-style-kaskadowe/feed/</wfw:commentRss>
		<slash:comments>9</slash:comments>
		</item>
		<item>
		<title>Obsługa selektorów CSS 3 przez przeglądarki</title>
		<link>http://adamczuk.net.pl/2009/01/08/obsluga-selektorow-css3-przez-przegladarki/</link>
		<comments>http://adamczuk.net.pl/2009/01/08/obsluga-selektorow-css3-przez-przegladarki/#comments</comments>
		<pubDate>Wed, 07 Jan 2009 23:31:24 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[CSS]]></category>
		<category><![CDATA[Software]]></category>
		<category><![CDATA[browsers]]></category>
		<category><![CDATA[selectors]]></category>
		<category><![CDATA[webstandards]]></category>

		<guid isPermaLink="false">http://adamczuk.net.pl/?p=66</guid>
		<description><![CDATA[Porównanie najpopulaniejszych przeglądarek pod względem obsługi selektorów CSS 3.]]></description>
			<content:encoded><![CDATA[<p>Tworzenie aplikacji internetowych wymaga dziś od programistów znajomości <abbr title="eXtensible HyperText Markup Language">XHTML</abbr>, <abbr title="Cascading Style Sheet">CSS</abbr>, a także przestrzegania zasad dostępności i użyteczności. Jeżeli współczesne strony internetowe mają być zgodne ze standardami sieciowymi, a do tego iść w parze z trendem Web 2.0 to sytuacja musi ulec zmianie. Szczególnie, jeśli chodzi o obsługę selektorów CSS 3 w przeglądarkach<span id="more-66"></span></p>
<p>Nowoczesne przeglądarki, takie jak Opera, Safari czy Firefox bardzo sumiennie podchodzą do standardów sieciowych rekomendowanych przez <abbr title="World Wide Web Consorcium">W3C</abbr>. Rownież najmłodszy Google Chrome nie pozostaje w tyle za liderami przeglądarek.</p>
<p>Jedyną czarną owcą wśród tego dojrzałego towarzystwa jest Internet Explorer, który pod żadnym pozorem nie chce dostosować się do nowej sytuacji. Wprawdzie kolejne wersje przeglądarki Microsoftu dają nadzieję na przyszłość. Jednak zmiany następują zbyt wolno, aby wizja zrównania się z nowoczesnymi przeglądarkami była realna.</p>
<p>Nowe selektory CSS 3 dają programistom dużo więcej możliwości podczas tworzenia aplikacji internetowych. Zaawansowane selektory atrybutów, strukturalne pseudo-klasy czy wsparcie dla zawartości generowanej to standard. Jednak nie wszyscy dostrzegają plusy tego standardu.</p>
<p>Poniższa tabela przedstawia selektory CSS 3 i stopień ich obsługi przez najpopularniejsze przeglądarki internetowe. Jak można było się spodziewać IE w każdej wersji odstaje od całości. Wyniki testu zostały opracowane na podstawie <a href="http://www.css3.info/selectors-test/">testu</a> selektorów CSS 3.</p>
<table cellpadding="0" cellspacing="0">
<caption>Porównanie przeglądarek pod względem obsługi selektorów CSS 3</caption>
<thead>
<tr>
<th scope="col" width="12%">Selektor</th>
<th scope="col" width="12%" class="center">IE6</th>
<th scope="col" width="12%" class="center">IE7</th>
<th scope="col" width="12%" class="center">IE8</th>
<th scope="col" width="12%" class="center">Firefox3</th>
<th scope="col" width="12%" class="center">Opera9</th>
<th scope="col" width="12%" class="center">Safari</th>
<th scope="col" width="12%" class="center">Chrome</th>
</tr>
</thead>
<tbody>
<tr>
<td>*</td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E</td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>.class</td>
<td class="buggy"><span>buggy</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>#id</td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E F</td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E > F</td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E + F</td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E[attribute]</td>
<td class="failed"><span>failed</span></td>
<td class="buggy"><span>buggy</span></td>
<td class="buggy"><span>buggy</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E[attribute=value]</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E[attribute~=value]</td>
<td class="failed"><span>failed</span></td>
<td class="buggy"><span>buggy</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E[attribute|=value]</td>
<td class="failed"><span>failed</span></td>
<td class="buggy"><span>buggy</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:first-child</td>
<td class="failed"><span>failed</span></td>
<td class="buggy"><span>buggy</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:link</td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:visited</td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:lang()</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:before</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>::before</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:after</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>::after</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:first-letter</td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>::first-letter</td>
<td class="passed"><span>passed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:first-line</td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>::first-line</td>
<td class="passed"><span>passed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E[attribute^=value]</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E[attribute$=value]</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E[attribute*=value]</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>E ~ F</td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:root</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:last-child</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:only-child</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:nth-child()</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:nth-last-child()</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:first-of-type</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:last-of-type</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:only-of-type</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:nth-of-type</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:nth-last-of-type</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:empty</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:not()</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:target</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:enabled</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:disabled</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
<tr>
<td>:checked</td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="failed"><span>failed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
<td class="passed"><span>passed</span></td>
</tr>
</tbody>
</table>
<ul class="legend">
<li class="passed">Selektor obsługiwany</li>
<li class="buggy">Selektor częściowo obsługiwany</li>
<li class="failed">Selektor nieobsługiwany</li>
</ul>
<p>Bezapelacyjnie widać, że Internet Explorer nie radzi sobie z selektorami CSS3. IE8 obsługuje prawidłowo tylko 22 selektory. Mimo, że są wśród nich selektory złożone i selektory atrybutu to nadal jest kropla w morzu potrzeb. Firefox radzi są dużo lepiej w kwestii obsługi selektorów, ponieważ do pełni szczęścia brakuje tylko ośmiu strukturalnych pseudo-klas. Najlepiej wypadają przeglądarki z silnikiem KHTML/Webkit, a także Presto. Zarówno Opera9, Safari3, jak i Google Chrome w pełni obsługują selektory CSS 3.</p>
<p>Internet Explorer dalej pozostaje na szarym końcu, bez większych perspektyw na zmianę. W tej sytuacji najwięcej tracą użytkownicy, którzy nieświadomi każdego dnia używają przestarzałej przeglądarki, tym samym hamując rozwój internetu.</p>
<p>Pora, aby zmienić przeglądarkę na lepszą. Pora, aby programiści zaczęli wykorzystywać selektory CSS, ponieważ dają większe możliwości. W końcu pora, aby twórcy Internet Explorera zrozumieli, że użytkownicy oczekują lepszego produktu niż do tej pory.</p>
]]></content:encoded>
			<wfw:commentRss>http://adamczuk.net.pl/2009/01/08/obsluga-selektorow-css3-przez-przegladarki/feed/</wfw:commentRss>
		<slash:comments>14</slash:comments>
		</item>
		<item>
		<title>Selektory CSS 3</title>
		<link>http://adamczuk.net.pl/2009/01/07/selektory-css-3/</link>
		<comments>http://adamczuk.net.pl/2009/01/07/selektory-css-3/#comments</comments>
		<pubDate>Tue, 06 Jan 2009 23:25:22 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[CSS]]></category>
		<category><![CDATA[roger johansson]]></category>
		<category><![CDATA[selectors]]></category>
		<category><![CDATA[translation]]></category>
		<category><![CDATA[webstandards]]></category>

		<guid isPermaLink="false">http://adamczuk.net.pl/?p=62</guid>
		<description><![CDATA[Tłumaczenie artykułu Rogera Johanssona na temat selektorów CSS 3.]]></description>
			<content:encoded><![CDATA[<p>We wrześniu i październiku 2005 roku opublikowałem serię artykułów na temat selektorów CSS 2.1. Podsumowując, większość z opisanych tam selektorów można używać <em>dziś</em> w nowoczesnych przeglądarkach jak Mozilla/Firefox, Safari i Opera. Potrzebujemy jeszcze poczekać, aż Internet Expolorer zacznie równać do najlepszych. Deklaracja pełnego wsparcia dla selektorów CSS 2.1 w Internet Explorer 7 to dobra wiadomość.<span id="more-62"></span></p>
<p>Jeśli popatrzymy w przyszłość to specyfikacja CSS 3 oferuje wiele nowych i potężnych selektorów. Wiele z nich zostało już zaimplementowanych w nowoczesnych przeglądarkach. Niestety ich obsługa póki co jest dość niejednolita i programiści nie mogą do końca na nich polegać. W niektórych przypadkach stosowanie selektorów CSS 3 jest zasadne, więc warto przyjrzeć się im bliżej.</p>
<p>W tym artykule, odnoszę się do specyfikacji przedstawionej w <a href="http://www.w3.org/TR/2005/WD-css3-selectors-20051215/">Selectors W3C Working Draft 15 December 2005</a>. Nowe selektory opisane w tym dokumencie będą używane przez CSS 3, ale także inne języki programowania. Kiedy czytasz ten artykuł po miesiącach, albo nawet latach, może warto sprawdzić czy nie jest dostępna aktualniejsza wersja.</p>
<p>Nie zamierzam tu opisywać podstaw na temat selektorów CSS. Jeśli potrzebujesz przypomnienia wiadomości to dobrym miejscem na początek jest artykuł <a href="http://adamczuk.net.pl/2008/12/08/selektory-css-21-czesc-1/">Selektory CSS 21 &#8211; część 1</a>.</p>
<p>Na początku poznajmy nowe selektory CSS 3:</p>
<table cellpadding="0" cellspacing="0">
<caption>Przegląd selektorów CSS 3</caption>
<thead>
<tr>
<th scope="col">Selektor</th>
<th scope="col">Wzorzec</th>
<th scope="col">Opis</th>
</tr>
</thead>
<tbody>
<tr>
<td>Atrybut</td>
<td>E[att^=&#8221;val&#8221;]</td>
<td>Pasuje do dowolnego elementu E, którego atrybut <code>att</code> rozpoczyna się od wartości &#8220;val&#8221;.</td>
</tr>
<tr>
<td>Atrybut</td>
<td>E[att$=&#8221;val&#8221;]</td>
<td>Pasuje do dowolnego elementu E, którego atrybut <code>att</code> kończy się wartością &#8220;val&#8221;.</td>
</tr>
<tr>
<td>Atrybut</td>
<td>E[att*=&#8221;val&#8221;]</td>
<td>Pasuje do dowolnego elementu E, którego atrybut <code>att</code> zawiera wartość &#8220;val&#8221;.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:root</td>
<td>Pasuje do korzenia dokumentu. W przypadku HTML, korzeniem jest zawsze element HTML.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:nth-child(n)</td>
<td>Pasuje do dowolnego elementu E, który jest n-tym dzieckiem swojego rodzica.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:nth-last-child(n)</td>
<td>Pasuje do dowolnego elementu E, który jest n-tym dzieckiem swojego rodzica, licząc od ostatniego dziecka.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:nth-of-type(n)</td>
<td>Pasuje do dowolnego elementu E, który jest n-tym rodzeństwem swojego typu.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:nth-last-of-type(n)</td>
<td>Pasuje do dowolnego elementu E, który jest n-tym rodzeństwem swojego typu, licząc od ostatniego rodzeństwa.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:last-child</td>
<td>Pasuje do dowolnego elementu E, który jest ostatnim dzieckiem swojego rodzica.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:first-of-type</td>
<td>Pasuje do dowolnego elementu E, który pierwszym rodzeństwem swojego typu.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:last-of-type</td>
<td>Pasuje do dowolnego elementu E, który ostatnim rodzeństwem swojego typu.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:only-child</td>
<td>Pasuje do dowolnego elementu E, który jest jedynym dzieckiem swojego rodzica.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:only-of-type</td>
<td>Pasuje do dowolnego elementu E, który jest jedynym rodzeństwem swojego typu.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:empty</td>
<td>Pasuje do dowolnego elementu E, który nie ma dzieci, w tym także węzłów tekstu.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:target</td>
<td>Pasuje do elementu E, który jest celem danego adresu URL.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:enabled</td>
<td>Pasuje do dowolnego elementu E interfejsu użytkownika (kontrola formularza), który jest dostępny.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:disabled</td>
<td>Pasuje do dowolnego elementu E interfejsu użytkownika (kontrola formularza), który jest niedostępny.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:checked</td>
<td>Pasuje do dowolnego elementu E interfejsu użytkownika (kontrola formularza), który jest zaznaczony.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E::selection</td>
<td>Pasuje do dowolnego elementu E interfejsu użytkownika (kontrola formularza), który jest wybrany lub wyróżniony przez użytkownika.</td>
</tr>
<tr>
<td>Pseudo-klasa</td>
<td>E:not(s)</td>
<td>Pasuje do dowolnego elementu E, który nie pasuje do selektora prostego s.</td>
</tr>
<tr>
<td>Ogólne rodzeństwo</td>
<td>E ~ F</td>
<td>Pasuje do dowolnego elementu F, który jest poprzedzony elementem E.</td>
</tr>
</tbody>
</table>
<p>Nie martw się, jeśli coś nie jest do końca jasne. Każdy selektor zostanie w artykule dokładnie omówiony, również z przykładami użycia.</p>
<h3>Selektory dopasowania ciągu znaków</h3>
<p>Grupa ta jest nowa, a selektory w niej zawarte pozwalają programistom znaleźć elementy na podstawie części wartości atrybutu.</p>
<p>Przyjmijmy, że mamy dokument HTML o następującej strukturze:</p>
<pre><code>&lt;div id="nav-primary"&gt;&lt;/div&gt;
&lt;div id="content-primary"&gt;&lt;/div&gt;
&lt;div id="content-secondary"&gt;&lt;/div&gt;
&lt;div id="tertiary-content"&gt;&lt;/div&gt;
&lt;div id="nav-secondary"&gt;&lt;/div&gt;</code></pre>
<p>Poprzez użycie selektorów dopasowania możesz odnieść się do strukturalnych części dokumentu.</p>
<p>Następująca reguła ustawia kolor tła dla wszystkich elementów <code>div</code>, których <code>id</code> rozpoczyna się od &#8220;nav&#8221;:</p>
<pre><code>div[id^="nav"] { background:#ff0; }</code></pre>
<p>W tym wypadku selektor będzie pasował do <code>div#nav-primary</code> i <code>div#nav-secondary</code>.</p>
<p>Aby znaleźć elementy <code>div</code>, których <code>id</code> kończy się ciągiem &#8220;primary&#8221;, możesz użyć następującej reguły:</p>
<pre><code>div[id$="primary"] { background:#ff0; }</code></pre>
<p>Tym razem selektor będzie pasował do <code>div#nav-primary</code> i <code>div#content-primary</code>.</p>
<p>Następujące reguły stosują się do wszystkich elementów <code>div</code>, których <code>id</code> zawiera ciąg &#8220;content&#8221;:</p>
<pre><code>div[id*="content"] { background:#ff0; }</code></pre>
<p>Elementy, których dotyczy to reguła to <code>div#content-primary</code>, <code>div#content-secondary</code> i <code>div#tertiary-content</code>.</p>
<p>Selektory dopasowania ciągu znaków są w pełni wspierane przez ostatnie wersje przeglądarek: Mozilla, Firefox, Flock, Camino, Safari, OmniWeb i Opera, więc gdyby pominąć Internet Explorer moglibyśmy już zacząć ich używanie.</p>
<h3>Pseudo-klasa :target</h3>
<p>Adresy URL z względnym odnośnikiem to takie, które zawierają &#8220;#&#8221; i linkują na podstawie nazwy lub identyfikatora elementu w obrębie dokumentu. Stylizacja takiego elementu jest możliwa dzięki pseudo-klasie <code>:target</code>. Jeśli aktualny adres URL nie zawiera fragmentu z identyfikatorem to pseudo-klasa <code>:target</code> nie pasuje do żadnego elementu.</p>
<p>W przypadku wspomnianej wcześniej struktury HTML, następująca zasada tworzy kontur wokół elementu <code>div#content-primary</code> kiedy adres URL będzie zawierał identyfikator:</p>
<pre><code>div#content-primary:target { outline:1px solid #300; }</code></pre>
<p>Przykład takiego URL to <code>http://www.example.com/index.html#content-primary</code>.</p>
<p>Pseudo-klasa <code>:target</code> jest obecnie wspierana przez przeglądarki rodziny Mozilla i Safari.</p>
<h3>Pseudo-klasy interfejsu użytkownika</h3>
<h4>Pseudo-klasa :enabled i :disabled</h4>
<p>Pseudo-klasy<code>:enabled</code> i <code>:disabled</code> pozwalają programistom na określenie wyglądu elementów formularzy, które są dostępne lub niedostępne, pomimo tego, że przeglądarka sama stylizuje kontrolki formularzy. Poniższe reguły zmieniają kolory tła dla pól tekstowych w formularzu w zależności czy są one dostępne czy niedostępne:</p>
<pre><code>input[type="text"]:enabled { background:#ffc; }

input[type="text"]:disabled { background:#ddd; }</code></pre>
<h4>Pseudo-klasa :checked</h4>
<p>Pseudo-klasa <code>:checked</code> pozwala programistom na określenie wyglądu wybranych (aktywnych) kontrolek radio i checkbox w formularzach. Również w tym przypadku przeglądarka umożliwia stylizowanie elementów formularzy. Poniższe reguły CSS tworzą zieloną ramkę wokół wybranych (aktywnych) elementów radio i checkbox:</p>
<pre><code>input:checked { border:1px solid #090; }</code></pre>
<p>Opera oraz przeglądarki z rodziny Mozilla obsługują pseudo-klasy interfejsu użytkownika.</p>
<p>Należy zaznaczyć, że wygląd formularzy w przeglądarkach może się bardzo różnić, a same przeglądarki bardzo restrykcyjnie traktują zmiany kontrolek formularzy przez programistów. Więcej na ten temat możesz dowiedzieć się z artykułu <a href="http://www.456bereastreet.com/archive/200409/styling_form_controls/">Styling form controls</a> i <a href="http://www.456bereastreet.com/archive/200410/styling_even_more_form_controls/">Styling even more form controls</a>.</p>
<h3>Strukturalne pseudo-klasy</h3>
<p>Strukturalne pseudo-klasy pozwalają programistom odwołać się do elementów ze struktury dokumentu, do których dostęp poprzez selektory proste i złożone jest niemożliwy. Strukturalne pseudo-klasy są bardzo potężne, ale niestety nie wszystkie z nich są wspierane przez nowoczesne przeglądarki.</p>
<h4>Pseudo-klasa :root</h4>
<p>Pseudo-klasa <code>:root</code> odnosi się do do elementu korzenia dokumentu. Dla dokumentów HTML takim korzeniem jest zawsze element HTML, w takim razie poniższe reguły są takie same. Nie do końca, ponieważ <code>:root</code> ma większe znaczenie niż <code>html</code>):</p>
<pre><code>:root { background:#ff0; }
html { background:#ff0; }</code></pre>
<p>Pseudo-klasa <code>:root</code> jest aktualnie wspierana przez przeglądarki z rodziny Mozilla i Safari.</p>
<h4>Pseudo-klasa :nth-child()</h4>
<p>Pseudo-klasa <code>:nth-child()</code> odnosi się do elementu, który ma przed sobą określoną liczbę rodzeństwa w drzewie dokumentu. Wartość, która o tym decyduje, znajduje się w nawiasach i może być liczą, słowem kluczowym lub formułą.</p>
<p><strong>Numer</strong> <code>b</code> pasuje do <code>b</code>-tego dziecka. Następująca reguła stosuje się do wszystkich elementów <code>p</code>, które są trzecim dzieckiem swojego rodzica:</p>
<pre><code>p:nth-child(3) { color:#f00; }
</code></pre>
<p><strong>Słowa kluczowe</strong> <code>odd</code> i <code>even</code> można wykorzystać do elementów o indeksach nieparzystych i parzystych. Indeks pierwszego elementu to 1, więc ta reguła będzie pasować do każdego paragrafu, który jest pierwszym, trzecim, piątym i kolejnym dzieckiem swojego rodzica:</p>
<pre><code>p:nth-child(odd) { color:#f00; }</code></pre>
<p>Poniższa reguła pasuje do elementów <code>p</code>, które są drugim, czwartym, szóstym i kolejnym dzieckiem swojego rodzica.:</p>
<pre><code>p:nth-child(even) { color:#f00; }</code></pre>
<p><strong>Formuła</strong> <code>an + b</code> może być użyta do stworzenia bardziej złożonych  wzorów. W przykładowym wzorze, <code>a</code> reprezentuje ilość cykli, <code>n</code> to licznik, startujący od zera, a <code>b</code> przesunięcie wartości. Wszystkie wartości są liczbami całkowitymi. Aby wszystko dokładnie zrozumieć, zapoznaj się z poniższymi przykładami.</p>
<p>Poniższe reguły będą pasować do wszystkich elementów <code>p</code>, których indeks dzieli się przez 3. W pierwszej regule zero można pominąć, tak jak to zrobiliśmy zostało zapisane w drugiej regule:</p>
<pre><code>p:nth-child(3n+0) { color:#f00; }
p:nth-child(3n) { color:#f00; }</code></pre>
<p>Przesunięcie wartości służy do określenia momentu, w którym reguła zaczyna obowiązywać. Jeżeli mamy tabelę z 20 wierszami i chcemy zmienić kolor tła nieparzystych wierszy, ale dopiero od dziesiątego to stosujemy daną regułę:</p>
<pre><code>tr:nth-child(2n+11) { background:#ff0; }</code></pre>
<p>Dopóki <code>n</code> rozpoczyna się od 0, pierwszy element <code>tr</code>, przy którym reguła będzie się stosować to jedenasty element. Następnie będzie trzynasty, piętnasty i tak dalej.</p>
<p>Więcej szczegółów można znaleźć w sekcji <a href="http://www.w3.org/TR/css3-selectors/#nth-child-pseudo">:nth-child() pseudo-class</a> specyfikacji selektorów CSS3.</p>
<p>A jak wygląda wsparcie przeglądarek dla tych bardzo użytecznych selektorów? Z tego co wiem, to żadna z nich nie obsługuje w pełni, tych selektorów. Popraw mnie jeśli się mylę.</p>
<h4>Pseudo-klasa :nth-last-child()</h4>
<p>Pseudo-klasa <code>:nth-last-child()</code> działa tak samo jak pseudo-klasa <code>:nth-child()</code>, z tym wyjątkiem, że odnosi się do inaczej liczonego elementu w strukturze dokumentu. Inaczej mówiąc, rozpoczynamy liczenie od ostatniego dziecka, a nie pierwszego i liczymy wstecz. Poniższa reguła będzie pasowała do  przedostatniego elementu <code>tr</code> tabeli:</p>
<pre><code>tr:nth-last-child(2) { background:#ff0; }</code></pre>
<p>Pseudo-klasa <code>:nth-last-child()</code> nie jest wspierana przez żadną przeglądarkę.</p>
<h4>Pseudo-klasa :nth-of-type()</h4>
<p>Pseudo-klasa <code>:nth-of-type()</code> działa dokładnie jak pseudo-klasa <code>:nth-child()</code>, ale reguły odnoszą się tylko do elementów tego samego typu. Taka reguła pasuje do takich elementów <code>p</code>, które są trzecim elementem <code>p</code> swojego rodzica:</p>
<pre><code>p:nth-of-type(3) { background:#ff0; }</code></pre>
<p>Ten selektor jest użyteczny, kiedy chcemy być pewni, że rzeczywiście odnosimy się do trzeciego elementu <code>p</code>. Na początku można było dojść do wniosku, że odpowiada za to pseudo-klasa <code>nth-child</code>, ale <code>:nth-child(3)</code> obejmuje wszystkie elementy rodzeństwa, więc rezultat będzie inny chyba, że wszystkie elementy <code>p</code> mają jako rodzeństwo tylko i wyłącznie elementy <code>p</code>.</p>
<p>Pseudo-klasa <code>:nth-of-type()</code> nie jest obecnie wspierana przez żadne przeglądarki.</p>
<h4>Pseudo-klasa :nth-last-of-type()</h4>
<p>Pseudo-klasa <code>:nth-last-of-type()</code> dotyczy elementu, który ma określony number spośród rodzeństwa danego typu w strukturze dokumentu. Pseudo-klasa <code>:nth-last-child()</code> rozpoczyna liczenie od końca, a nie od początku oraz liczy elementy wstecz. Następująca reguła pasuje do każdego drugiego od końca rodzeństwa dla <code>p</code>:</p>
<pre><code>p:nth-last-of-type(2) { background:#ff0; }</code></pre>
<p>Pseudo-klasa <code>:nth-last-of-type()</code> nie jest obecnie wspierana przez przeglądarki.</p>
<h4>Pseudo-klasa :last-child</h4>
<p>Pseudo-klasa <code>:last-child</code> odnosi się do elementu. który jest ostatnim dzieckiem swojego rodzica. To dokładnie to samo co <code>:nth-last-child(1)</code>. Reguła ta pasuje do wszystkich elementów <code>p</code>, które są ostatnim dzieckiem elementu swojego rodzica:</p>
<pre><code>p:last-child { background:#ff0; }</code></pre>
<p>Pseudo-klasa <code>:last-child</code> działa w przeglądarkach z rodziny Mozilla. Opera nie wspiera jej wcale, a Safari tylko w częściowy sposób. O dziwo, działa to jak powinno w OmniWeb (wersja 5.1.1), pomimo faktu powiązania z Safari. Może to być spowodowane uwstecznieniem ostatniej wersji Apple WebKit, ponieważ OmniWeb korzysta przeważnie ze starszych wersji WebKit w porównaniu z Safari.</p>
<h4>Pseudo-klasa :first-of-type</h4>
<p>Pseudo-klasa <code>:first-of-type</code> obejmuje element, który jest pierwszym spośród rodzeństwa swojego typu. Działa dokładanie jak <code>:nth-of-type(1)</code>.</p>
<pre><code>p:first-of-type { background:#ff0; }</code></pre>
<p>Pseudo-klasa <code>:first-of-type</code> nie jest obecnie wspierana przez przeglądarki.</p>
<h4>Pseudo-klasa :last-of-type</h4>
<p>Pseudo-klasa <code>:last-of-type</code> obejmuje element, który jest ostatnim spośród rodzeństwa swojego typu. Działa dokładanie jak <code>:nth-last-of-type(1)</code>.</p>
<pre><code>p:last-of-type { background:#ff0; }</code></pre>
<p>Pseudo-klasa <code>:last-of-type</code> nie jest obecnie wspierana przez przeglądarki.</p>
<h4>Pseudo-klasa :only-child</h4>
<p>Pseudo-klasa <code>:only-child</code> odnosi się do elementu, którego rodzic nie ma innych dzieci. To samo <code>:first-child:last-child</code> lub <code>:nth-child(1):nth-last-child(1)</code>, ale z niższym priorytetem.</p>
<pre><code>p:only-child { background:#ff0; }</code></pre>
<p>Pseudo-klasa <code>:only-child</code> działa w przeglądarkach Mozilli. Safari zdaje się interpretować to jako <code>:first-child</code>, czyli powyższa reguła pasuje do wszystkich elementów <code>p</code> w dokumencie, które są pierwszym dzieckiem swojego rodzica.</p>
<h4>Pseudo-klasa :only-of-type</h4>
<p>Pseudo-klasa <code>:only-of-type</code> obejmuje swoim działaniem element, którego rodzic nie ma więcej dzieci danego typu. Działa tak samo, ale z mniejszym priorytetem jak <code>:first-of-type:last-of-type</code> lub <code>:nth-of-type(1):nth-last-of-type(1)</code>.</p>
<pre><code>p:only-of-type { background:#ff0; }
</code></pre>
<p>Pseudo-klasa <code>:only-of-type</code> nie jest aktualnie wspierana przez przeglądarki.</p>
<h4>Pseudo-klasa :empty</h4>
<p>Pseudo-klasa <code>:empty</code> odnosi się do elementu, który nie ma dzieci. Wliczamy do tego, także węzły tekstowe, więc w następującym przypadku, tylko pierwszy element jest pusty:</p>
<p>&lt;p&gt;&lt;/p&gt;<br />
&lt;p&gt;Text&lt;/p&gt;<br />
&lt;p&gt;&lt;em&gt;&lt;/em&gt;&lt;/p&gt;</code></pre>
<p>Następujące reguły CSS będą pasować do pierwszego elementu:</p>
<pre><code>p:empty { background:#ff0; }</code></pre>
<p>Pseudo-klasa <code>:empty</code> jest obecnie wspierana przez przeglądarki z rodziny Mozill. Safari błędnie stosuje te reguły do wszystkich elementów danego typu.</p>
<h3>Pseudo-klasa negacji</h3>
<p>Pseudo-klasa negacji, zapisana jako <code>:not(s)</code>, bierze prosty selektor s jako argument. Swoim zasięgiem obejmuje elementy, które nie są objęte działaniem selektora prostego. Przykładowo, następujące reguły CSS stosują się do wszystkich elementów, które nie są elementem <code>p</code>:</p>
<pre><code>:not(p) { border:1px solid #ccc; }</code></pre>
<p>Pseudo-klasa negacji działa aktualnie w przeglądarkach Mozilli i Safari.</p>
<h3>Pseudo-element ::selection</h3>
<p>Pseudo-element <code>::selection</code> pasuje do części elementu, który jest aktualnie wybrany lub wyróżniony przez użytkownika. Jedyna możliwość użycia tego selektora to zmiana wyglądu wybranego tekstu.</p>
<p>Tylko kilka właściwości CSS można stosować dla pseudo-klasy <code>::selection</code>: <code>color</code>, <code>background</code>, <code>cursor</code>, and <code>outline</code>.</p>
<p>Następująca reguła uczyni zaznaczony tekst czerwonym:</p>
<pre><code>::selection { color:#f00;	}</code></pre>
<p>Pseudo-element <code>::selection</code> działa obecnie tylko w przeglądarkach Safari. Implementacja tego selektora w Safari jest trochę nieprzewidywalna. Mozilla, póki co wspiera własne rozszerzenia <code>::-moz-selection</code>, a prefiks zostanie w przyszłości usunięty.</p>
<h3>Selektor ogólnego rodzeństwa</h3>
<p>Selektor ogólnego rodzeństwa składa się z dwóch selektorów prostych rozdzielonych znakiem &#8220;tyldy&#8221; (~). Pasuje do tych tych elementów drugiego selektora prostego, które są poprzedzone elementem pierwszego selektora. Oba elementy muszą mieć tego samego rodzica, ale drugi element nie musi być bezpośrednio poprzedzony pierwszym elementem. Podana reguła CSS obejmuje elementy <code>ul</code>, które są poprzedzone elementem <code>p</code> i mają tego samego rodzica:</p>
<pre><code>p ~ ul { background:#ff0; }</code></pre>
<p>Opera i przeglądarki rodziny Mozilla obsługują selektor ogólnego rodzeństwa.</p>
<h3>Niezbędne wsparcie po stronie przeglądarek</h3>
<p>Niektóre selektory CSS 3 są lepiej wspierane, a inne gorzej. Niestety, ale kilka najbardziej użytecznych selektorów nie jest wspieranych w ogóle. Wszystko to sprawia, że w obecnym czasie wykorzystanie selektorów przedstawionych w artykule jest trudne. Pozostaje jedynie czekanie na moment pełnego wsparcia selektorów CSS 3 przez przeglądarki, a póki co korzystanie z już obsługiwanych.</p>
<p>Więc, która przeglądarka <em>twoim</em> zdaniem jako pierwsza będzie wspierała większość lub wszystkie selektory CSS 3? Safari, Firefox czy Opera? A może nawet Internet Explorer?</p>
<p class="info">Ten artykuł jest tłumaczeniem oryginalnego tekstu <a href="http://www.456bereastreet.com/archive/200601/css_3_selectors_explained/">CSS 3 selectors explained</a>, którego autorem jest Roger Johansson.</p>
]]></content:encoded>
			<wfw:commentRss>http://adamczuk.net.pl/2009/01/07/selektory-css-3/feed/</wfw:commentRss>
		<slash:comments>8</slash:comments>
		</item>
		<item>
		<title>Selektory CSS 2.1 &#8211; część 3</title>
		<link>http://adamczuk.net.pl/2008/12/12/selektory-css-21-czesc-3/</link>
		<comments>http://adamczuk.net.pl/2008/12/12/selektory-css-21-czesc-3/#comments</comments>
		<pubDate>Thu, 11 Dec 2008 23:04:16 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[CSS]]></category>
		<category><![CDATA[selectors]]></category>
		<category><![CDATA[webstandards]]></category>

		<guid isPermaLink="false">http://adamczuk.net.pl/?p=38</guid>
		<description><![CDATA[Oto trzecia, a zarazem ostatnia część serii artykułów, które opisują selektory dostępne w CSS 2.1. Część 1 obejmuje postawy, takie jak selektor typu, selektor klasy, selektor uniwersalny czy selektory proste. Część 2 wyjaśnia działanie selektorów połączonych, sposób użycia grupowania oraz atrybutów selektorów. Tym razem przyjrzymy się bliżej pseudo-klasom i pseudo-elementom. Tak jak bardziej zaawansowane selektory, [...]]]></description>
			<content:encoded><![CDATA[<p>Oto trzecia, a zarazem ostatnia część serii artykułów, które opisują selektory dostępne w <abbr title="Cascading Style Sheets">CSS</abbr> 2.1. <a href="http://adamczuk.net.pl/2008/12/08/selektory-css-21-czesc-1/">Część 1</a> obejmuje postawy, takie jak selektor typu, selektor klasy, selektor uniwersalny czy selektory proste. <a href="http://adamczuk.net.pl/2008/12/10/selektory-css-21-czesc-2/">Część 2</a> wyjaśnia działanie selektorów połączonych, sposób użycia grupowania oraz atrybutów selektorów.<span id="more-38"></span></p>
<p>Tym razem przyjrzymy się bliżej pseudo-klasom i pseudo-elementom. Tak jak bardziej zaawansowane selektory, o których była mowa w drugiej części, pseudo-klasy i pseudo-elementy nie są w pełni obsługiwane przez wszystkie nowoczesne przeglądarki, na co należy zwrócić uwagę. Nie chciałbyś, aby zawartość twojej strony była niedostępna w przeglądarce, która nie obsługuje <abbr>CSS</abbr> opisanego tutaj.</p>
<h3>Pseudo-klasy i pseudo-elementy</h3>
<p>Pseudo-klasy i pseudo-elementy można używać do formatowania elementów, które nie są jawnie określone w strukturze dokumentu. Przykładowo w kodzie nie występuje element, który odnosi się do pierwszej linii paragrafu lub pierwszej litery innego tekstu.</p>
<h3>Pseudo-klasy</h3>
<p>Pseudo-klasy nie dopasowują elementów na podstawie ich nazwy, atrybutów lub zawartości</p>
<h4>:first-child</h4>
<p>Ta pseudo-klasa pasuje do elementu, który jest pierwszym dzieckiem innego elementu. Powiedzmy, że chcesz zmienić wygląd pierwszego paragrafu w artykule. Jeśli artykuł jest zawarty w elemencie <code>div</code> z atrybutem class równym “article” to poniższe reguły będą pasować do pierwszego elementu <code>p</code> w każdym artykule:</p>
<pre><code>div.article p:first-child {
  font-style:italic;
}</code></pre>
<p>Dla formatowania elementów <code>p</code>, które są pierwszymi dziećmi <em>dowolnego</em> elementu, możesz użyć następującej reguły:</p>
<pre><code>p:first-child {
  font-style:italic;
}</code></pre>
<h4>:link i :visited</h4>
<p><strong>Pseudo-klasa link</strong> dotyczy nieodwiedzonych i odwiedzonych linków. Obydwa stany wykluczają się wzajemnie, czyli link nie może być, w tym samym czasie odwiedzony i nieodwiedzony.</p>
<p>Pseudo-klasy te stosują się wyłącznie do hiperłączy określonych w kodzie jako kotwice. Oznacza to, że w <abbr title="HyperText Markup Language">HTML</abbr> są to elementy <code>a</code> z określonym atrybutem <code>href</code>. Poniższe selektory są identyczne, dopóki nie odnoszą się żadnych innych elementów.</p>
<pre><code>a:link
:link</code></pre>
<h4>:hover, :active i :focus</h4>
<p><strong>Dynamiczne pseudo-klasy</strong> można używać do zmiany wyglądu pewnych elementów w zależności od akcji wykonanych przez użytkownika.</p>
<p><strong><code>:hover</code></strong> obowiązuje kiedy użytkownik wskaże poprzez wskaźnik dany element, ale go nie aktywuje. Powszechnie oznacza to najechanie kursorem myszy na dany element.</p>
<p><strong><code>:active</code></strong> obowiązuje kiedy dany element jest aktywny w pewnym momencie. W przypadku użycia myszki oznacza to, że przycisk został naciśnięty i pozostaje wciśnięty, aż zostanie zwolniony.</p>
<p><strong><code>:focus</code></strong> obowiązuje kiedy dany element posiada focus, czyli jest ciągle aktywny. Oznacza to, że element oczekuje na pewną akcję, dla przykładu naciśnięcie klawisza klawiatury.</p>
<p>Dany element może pasować w tym samym czasie do kilku pseudo-klas. Przykładowo, element może posiadać focus, jak również być w stanie hover, w tym samych czasie.</p>
<pre><code>input[type=text]:focus {
  color:#000;
  background:#ffe;
}
input[type=text]:focus:hover {
  background:#fff;
}</code></pre>
<p>Pierwsza reguła pasuje do elementów <code>input</code>, które posiadają focus. Druga reguła pasuje do pól tekstowych w stanie focus i hover.</p>
<h4>:lang</h4>
<p>Pseudo-klasa języka jest używana do zmiany stylu elementów, które zawierają treść w określonym języku (chodzi tu język mówiony, a nie język znaczników). Poniższe reguły definiują cudzysłowy w języki szwedzkim:</p>
<pre><code>q:lang(sv) { quotes: "\201D" "\201D" "\2019" "\2019"; }</code></pre>
<p>Język w jakim jest treść dokumentu lub elementu jest określony przez atrybut <code>lang</code> w <abbr>HTML</abbr> i atrybut <code>xml:lang</code> w <abbr title="Extensible HyperText Markup Language">XHTML</abbr>.</p>
<h3>Pseudo-elementy</h3>
<p>Pseudo-elementy pozwalają autorom na formatowanie elementów, które normalnie są niedostępne jako węzły struktury dokumentu.</p>
<h4>:first-line</h4>
<p>Pseudo-element <code>:first-line</code> stosuje się do pierwszej linii tekstu w paragrafie. Może być stosowany wyłącznie do elementów, których właściowość <code>display</code> w <abbr>CSS</abbr> określona jest jako block, inline-block, table-caption lub table-cell.</p>
<p>Długość pierwszej linii tekstu zależy oczywiście od wielu czynników, takich jak rozmiar czcionki czy szerokość elementu, zawierającego tekst.</p>
<p>Poniższe reguły stosują się do pierwszej linii tekstu w paragrafie:</p>
<pre><code>p:first-line {
  font-weight:bold;
  color;#600;
}</code></pre>
<p>Zaznaczam, że istnieją ograniczenia w stosowaniu pewnych właściwości do pseudo-elementu <code>:first-line</code>. Zobacz <a href="http://www.w3.org/TR/CSS21/selector.html#first-line-pseudo" title="CSS 2.1, 5.12.1 The :first-line pseudo-element">The :first-line pseudo-element</a>, aby upewnić się, które właściwości mogą być używane.</p>
<h4>:first-letter</h4>
<p>Ten pseudo-element pozwala na zmianę pierwszej litery lub cyfry danego elementu. Może być stosowany tylko do elementów o wyświetlaniu typu block, list-item, table-cell, table-caption lub inline-block.</p>
<p>Poniższe reguły znajdą zastosowanie do pierwszego znaku w elemencie, o klasie “preamble”:</p>
<pre><code>.preamble:first-letter {
  font-size:1.5em;
  font-weight:bold;
}</code></pre>
<p>Tak jak  pseudo-element <code>:first-line</code>, również pseudo-element <code>:first-letter</code> ma pewne ograniczenia, dotyczące dozwolonych właściwości. Zobacz <a href="http://www.w3.org/TR/CSS21/selector.html#first-letter" title="CSS 2.1, 5.12.2 The :first-letter pseudo-element">The :first-letter pseudo-element</a>, aby mieć pewność, czy używasz dozwolonych właściwości.</p>
<h4>:before i :after</h4>
<p>Pseudo-elementy <code>:before</code> i <code>:after</code> pozwalają na dołączanie generowanej zawartości na początku i na końcu elementu.</p>
<p>Oto przykład użycia pseudo-elementu <code>:before</code> zaczerpnięty z artykułu <a href="http://www.456bereastreet.com/archive/200509/custom_borders_with_advanced_css/">Custom borders with advanced CSS</a> Rogera Johanssona:</p>
<pre><code>.cbb:before {
  content:"";
  display:block;
  height:17px;
  width:18px;
  background:url(top.png) no-repeat 0 0;
  margin:0 0 0 -18px;
}</code></pre>
<p>Przykład wykorzystania <code>:after</code> do załączenia <abbr title="Uniform Resource Locator">URL</abbr> po linku tekstowym:</p>
<pre><code>a:link:after {
  content: " (" attr(href) ") ";
}</code></pre>
<h3>Internet Explorer &#8211; problemy</h3>
<p>Zanim zaczniemy używać wszystkiego czego nauczyliśmy się o selektorach, należy wziąć pod uwagę, że Internet Explorer łącznie z IE6 nie wspiera całkowicie selektorów <abbr>CSS</abbr> 2.1. Problematyczne lub nieobsługiwane są następujące selektory:</p>
<ul>
<li>Selekror dziecka</li>
<li>Selektor sąsiedni</li>
<li>Selektor atrybutu</li>
<li>Selektor klas wielokrotnych</li>
<li>Pseudo-klasa <code>:first-child</code></li>
<li>Pseudo-klasy języków</li>
<li>Pseudo-elementy <code>:before</code> i <code>:after</code></li>
<li>Pseudo-klasa <code>:hover</code> działa tylko dla elementu <code>a</code></li>
<li>Pseudo-klasa <code>:focus</code> nie jest wspierana. Dla elementu <code>a</code>, który posiada focus, jest stosowana pseudo-klasa <code>:active</code></li>
</ul>
<p>Szczęśliwie, Internet Explorer 7 powinien w pełni wspierać selektory <abbr>CSS</abbr> 2.1.</p>
<h3>Masz moc &#8211; używaj jej właściwie</h3>
<p>To wszystko. Poznałeś wszystkie możliwości jakie oferują selektory <abbr>CSS</abbr> 2.1, powinieneś je teraz właściwie wykorzystać do formatowania swoich dokumentów. Stosuj je uważnie, aby utrzymywać znaczniki w porządku, jak również zwiększać dostępność i użyteczność. Pamiętaj także, co dzieje się w starszych przeglądarkach, które nie wspierają dla zaawansowanych selektorów  <abbr>CSS</abbr>.</p>
<p class="info">Ten artykuł jest tłumaczeniem oryginalnego tekstu <a href="http://www.456bereastreet.com/archive/200510/css_21_selectors_part_3/">CSS 2.1 selectors, Part 2</a>, którego autorem jest Roger Johansson.</p>
]]></content:encoded>
			<wfw:commentRss>http://adamczuk.net.pl/2008/12/12/selektory-css-21-czesc-3/feed/</wfw:commentRss>
		<slash:comments>4</slash:comments>
		</item>
		<item>
		<title>Selektory CSS 2.1 &#8211; część 2</title>
		<link>http://adamczuk.net.pl/2008/12/10/selektory-css-21-czesc-2/</link>
		<comments>http://adamczuk.net.pl/2008/12/10/selektory-css-21-czesc-2/#comments</comments>
		<pubDate>Wed, 10 Dec 2008 09:09:10 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[CSS]]></category>
		<category><![CDATA[selectors]]></category>
		<category><![CDATA[webstandards]]></category>

		<guid isPermaLink="false">http://adamczuk.net.pl/?p=18</guid>
		<description><![CDATA[Ten artykuł to druga część serii trzech artykułów, które opisują selektory dostępne w CSS 2.1. Część 1 dotyczy podstawowych zagadnień, czyli selektorów typu i klasy, jak również selektorów prostych i selektora uniwersalnego. W tej części przyjrzymy się bliżej zaawansowanym selektorom. Nie wszystkie z nich są w pełnie wspierane przez obecne przeglądarki, ale w przyszłości sytuacja [...]]]></description>
			<content:encoded><![CDATA[<p>Ten artykuł to druga część serii trzech artykułów, które opisują selektory dostępne w <abbr title="Cascading Style Sheets">CSS</abbr> 2.1. <a href="http://adamczuk.net.pl/2008/12/08/selektory-css-21-czesc-1/">Część 1</a> dotyczy podstawowych zagadnień, czyli selektorów typu i klasy, jak również selektorów prostych i selektora uniwersalnego.<br />
<span id="more-18"></span></p>
<p>W tej części przyjrzymy się bliżej zaawansowanym selektorom. Nie wszystkie z nich są w pełnie wspierane przez obecne przeglądarki, ale w przyszłości sytuacja na pewno ulegnie poprawie. Dlatego czas spędzony podczas nauki tych selektorów jest warty swojej ceny.</p>
<h3>Łączniki</h3>
<p>Łączniki używamy przy tworzeniu selektorów połączonych, składających się z dwóch lub więcej selektorów prostych. Dostępne łączniki to znaki białe (dowolna ilość tabulacji, odstęp lub innych znaków białych), znak <code>&gt;</code> oraz <code>+</code>. Wszystkie z nich są opisane w kolejnych sekcjach.</p>
<h3>Selektor potomka</h3>
<p>Selektor potomka tworzymy dzięki dwóm lub więcej selektorom prostym rozdzielonym znakiem białym. Reguły odnoszą się do elementów, które są potomkami elementu pasującego do pierwszego selektora prostego. W poniższym przykładzie mamy zasady dotyczące wszystkich elementów <code>p</code>, które są potomkami elementu <code>div</code>:</p>
<pre><code>div p { color:#f00; }</code></pre>
<p>Każdy z selektorów, który tworzy selektor potomka może być również selektorem prostym. W następnym przykładzie mamy reguły dla wszystkich elementów <code>p</code> z wartością class równą <code>info</code>, które znajdują się w elementach listy <code>li</code>, a te z kolei są zawarte w elemencie <code>div</code> o identyfikatorze <code>myid</code>.</p>
<pre><code>div#myid li p.info { color:#f00; }</code></pre>
<p>Selektor potomka pozwala na wskazanie elementu bez określania jego klasy lub identyfikatora, co pomaga utrzymać znaczniki w porządku. Przypuśćmy, że mamy listę nawigacyjną, zawierającą następujące znaczniki:</p>
<pre><code>&lt;ul id="nav"&gt;
  &lt;li&gt;&lt;a href="#"&gt;Link 1&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href="#"&gt;Link 2&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href="#"&gt;Link 3&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;</code></pre>
<p>Aby opisać elementy listy oraz odnośniki zawarte w liście nawigacyjnej możemy użyć następującego <abbr>CSS</abbr>:</p>
<pre><code>#nav li { display:inline; }
#nav a { font-weight:bold; }</code></pre>
<p>Reguły te nie będą pasowały do żadnych innych elementów listy ani odnośników w dokumencie. Jeżeli porównamy to rozwiązanie z przypadkiem, w którym każdy element listy i odnośnik posiada swoją klasę to zdamy sobie sprawę, że stosując selektor potomka nasz kod stanie się bardziej czytelny.</p>
<h3>Selektor dziecka</h3>
<p>Selektor dziecka odnosi się do bezpośredniego potomka danego elementu. Selektor dziecka zawiera dwa lub więcej selektory rozdzielone znakiem większości, czyli “&gt;”. Rodzic elementu występuje po lewej stronie “&gt;”, a dopuszczalne znaki białe wokół łącznika.</p>
<p>Reguła ta wpływa na wszystkie elementy <code>strong</code>, które są dziećmi elementu <code>div</code>:</p>
<pre><code>div &gt; strong { color:#f00; }</code></pre>
<p>Oczywiście tylko te elementy <code>strong</code>, które są <strong>bezpośrednimi potomkami</strong> elementu <code>div</code> będą objęte tą regułą. Jeżeli jakikolwiek inny element, znajduje się pomiędzy elementami <code>div</code> oraz <code>strong</code> to selektor nie będzie pasował. W następnym przykładzie tylko “Text one” będzie formatowany przez reguły opisane powyżej:</p>
<pre><code>&lt;div&gt;
  &lt;strong&gt;Text one&lt;/strong&gt;
  &lt;p&gt;&lt;strong&gt;Text two&lt;/strong&gt;&lt;/p&gt;
&lt;/div&gt;</code></pre>
<h3>Selektor sąsiedni</h3>
<p>Selektor sąsiedni tworzymy przez połączenie dwóch selektorów prostych znakiem “+”. Dopuszczalne jest występowanie białych znaków wokół łącznika. Selektor pasuje do elementu, który jest rodzeństwem pierwszego elementu. Elementy muszą mieć tego samego rodzica, a pierwszy z nich występować przez drugim.</p>
<pre><code>p + p { color:#f00; }</code></pre>
<p>Jeżeli zastosujemy powyższe reguły do następnego przykładu to formatowaniu ulegnie jedynie drugi paragraf, czyli “Paragraph two”:</p>
<pre><code>&lt;div&gt;
  &lt;p&gt;Paragraph one&lt;/p&gt;
  &lt;p&gt;Paragraph two&lt;/p&gt;
&lt;/div&gt;</code></pre>
<h3>Grupowanie</h3>
<p>Zdecydowaniem się wspomnieć o grupowaniu w tym momencie, ponieważ wiele osób, które uczy się <abbr>CSS</abbr> popełnia błąd wiążąc grupowanie z selektorami połączonymi.</p>
<p>Aby zastosować identyczne reguły do elementów opisanych różnymi selektorami możemy zgrupować je używając przecinka, zamiast powtarzać deklaracje dla każdego selektora. Błąd, który popełnia wiele osób to pominięcie części selektora. Przypuśćmy, że mamy następujące znaczniki.</p>
<pre><code>&lt;div id="news"&gt;
  &lt;h3&gt;News&lt;/h3&gt;
  &lt;ul&gt;
  &lt;li&gt;Item 1&lt;/li&gt;
  &lt;li&gt;Item 2&lt;/li&gt;
  &lt;/ul&gt;
&lt;/div&gt;</code></pre>
<p>Powiedzmy, że chcemy mieć taki sam margines dla nagłówka 3 stopnia oraz listy nieuporządkowanej, ale tylko jeśli znajdują się one w elemencie <code>div</code>, którego <code>id</code> to “news”. Oto <strong>zły</strong> sposób:</p>
<pre><code>div#news h3, ul {
  margin:0 2em;
}</code></pre>
<p>To <em>sprawi</em>, że obydwa elementy, zarówno <code>h3</code> i <code>ul</code> w warstwie <code>div#news</code> będą miały taki sam margines.  Problem w tym, że <strong>wszystkie</strong> elementy <code>ul</code> w strukturze dokumentu będą miały taki margines, a nie tylko te z warstwy <code>div#news</code>.</p>
<p>Oto <strong>prawidłowy</strong> sposób grupowania selektorów dla tego przypadku:</p>
<pre><code>div#news h3,
div#news ul {
  margin:0 2em;
}</code></pre>
<p>Więc, jeśli grupujemy selektory, nie zapominajmy określeniu ich w całości.</p>
<h3>Selektor atrybutu</h3>
<p>Selektor atrybutu dopasowuje elementy na podstawie obecności lub wartości atrybutu. Istnieją cztery możliwości dopasowania selektora atrybutu:</p>
<dl>
<dt><code>[att]</code></dt>
<dd>Pasuje do elementów, które posiadają atrybut <code>att</code>, bez względu na jego wartość.</dd>
<dt><code>[att=val]</code></dt>
<dd>Pasuje do elementów, które posiadają atrybut <code>att</code>, a jego wartość wynosi dokładnie “val”.</dd>
<dt><code>[att~=val]</code></dt>
<dd>Pasuje do elementów, których wartość atrybutu <code>att</code> jest listą wartości rozdzielonych spacjami, a sama lista zawiera wartość “val”. W tym przypadku wartość “val” nie może zawierać spacji.</dd>
<dt><code>[att|=val]</code></dt>
<dd>Pasuje do elementów, których wartość atrybutu <code>att</code> jest listą wartości rozdzielonych znakiem minus, a lista ta rozpoczyna się wartością “val”. Główne zastosowanie tego  rozwiązania to dopasowanie kodów języka, określonych w atrybucie <code>lang</code> (<code>xml:lang</code> w <abbr title="Extensible HyperText Markup Language">XHTML</abbr>), na przykład. “en”, “en-us”, “en-gb”, itp.</dd>
</dl>
<p>A więc jakieś przykłady. Następujący selektor stosuje poniższe reguły wszystkich elementów <code>p</code>, które posiadają atrybut <code>title</code>, bez względu na jego wartość:</p>
<pre><code>p[title] { color:#f00; }</code></pre>
<p>W kolejnym przykładzie, selektor formatuje wszystkie elementy <code>div</code>, których atrybut <code>class</code> równa się wartości <code>error</code>:</p>
<pre><code>div[class=error] { color:#f00; }</code></pre>
<p>W przypadku dopasowywania wszystkich elementów <code>td</code>, których wartość atrybutu <code>headers</code> zawiera “col1” możemy użyć następującego selektora:</p>
<pre><code>td[headers~=col1] { color:#f00; }</code></pre>
<p>Ostatecznie, selektor w kolejnym przykładzie pasuje do wszystkich elementów <code>p</code>, których wartość atrybutu <code>lang</code> rozpoczyna się od wartości <code>en</code>:</p>
<pre><code>p[lang|=en] { color:#f00; }</code></pre>
<p>Kilka selektorów atrybutu może być użyte w tym samym selektorze. To sprawia, że możliwe jest dopasowywanie kilku różnych atrybutów dla tego samego elementu. Następujące reguły znalazłyby zastosowanie przy wszystkich elementach <code>blockquote</code>, których atrybut <code>class</code> jest równy dokładnie “quote” i posiadają one atrybut<code>cite</code>, bez względu na jego wartość:</p>
<pre><code>blockquote[class=quote][cite] { color:#f00; }</code></pre>
<h3>Ciąg dalszy…</h3>
<p>To już koniec części drugiej. <a href="http://adamczuk.net.pl/2008/12/12/selektory-css-21-czesc-3/">Część 3</a> to ostatnia część serii artykułów na temat selektorów. Wyjaśnimy w niej selektory pseudo-klas i pseudo-elementów. W razie jakichkolwiek wątpliwości możecie przeczytać <a href="http://adamczuk.net.pl/2008/12/08/selektory-css-21-czesc-1/">Część 1</a>, aby lepiej zrozumieć całość.</p>
<p class="info">Ten artykuł jest tłumaczeniem oryginalnego tekstu <a href="http://www.456bereastreet.com/archive/200510/css_21_selectors_part_2/">CSS 2.1 selectors, Part 2</a>, którego autorem jest Roger Johansson.</p>
]]></content:encoded>
			<wfw:commentRss>http://adamczuk.net.pl/2008/12/10/selektory-css-21-czesc-2/feed/</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Selektory CSS 2.1 &#8211; część 1</title>
		<link>http://adamczuk.net.pl/2008/12/08/selektory-css-21-czesc-1/</link>
		<comments>http://adamczuk.net.pl/2008/12/08/selektory-css-21-czesc-1/#comments</comments>
		<pubDate>Mon, 08 Dec 2008 15:52:32 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[CSS]]></category>
		<category><![CDATA[selectors]]></category>
		<category><![CDATA[webstandards]]></category>

		<guid isPermaLink="false">http://adamczuk.net.pl/?p=5</guid>
		<description><![CDATA[Pierwszą rzeczą jakiej powinniśmy się nauczyć rozpoczynając pracę z CSS są selektory. Selektory są oczywiście podstawową częścią technologii CSS, ale tylko niewielu programistów potrafi wykorzystać ich pełne możliwości. Bardzo wiele możemy osiągnąć, dzięki stosowaniu atrybutów id i class, ale to nie jedyne możliwości. Znajomość wszystkich selektorów CSS, jakie udostępnia CSS 2.1 pozwoli nam na utrzymanie [...]]]></description>
			<content:encoded><![CDATA[<p>Pierwszą rzeczą jakiej powinniśmy się nauczyć rozpoczynając pracę z <abbr title="Cascading Style Sheets">CSS</abbr> są selektory. Selektory są oczywiście podstawową częścią technologii <abbr>CSS</abbr>, ale tylko niewielu programistów potrafi wykorzystać ich pełne możliwości. Bardzo wiele możemy osiągnąć, dzięki stosowaniu atrybutów id i class, ale to nie jedyne możliwości.<span id="more-5"></span></p>
<p>Znajomość wszystkich selektorów <abbr>CSS</abbr>, jakie udostępnia <abbr>CSS</abbr> 2.1 pozwoli nam na utrzymanie porządku w kodzie <abbr title="HyperText Markup Language">HTML</abbr>. Ograniczymy dzięki temu użycie zbędnych atrybutów <code>class</code> i dodatkowych znaczników <code>div</code> i <code>span</code>. Brzmi ciekawie?</p>
<p>Zatem gdzie tkwi powód rzadkiego wykorzystania wszystkich selektorów? Otóż największym powodem jest niewystarczające wsparcie ze strony Internet Explorer, łącznie z IE 6. Pozostałe nowoczesne przeglądarki obsługują selektory <abbr>CSS</abbr> 2.1 w całości lub w dużym stopniu. Dlatego należy być ostrożnym, ponieważ możemy mieć kłopoty z obsługą niektórych selektorów opisanych w tym artykule.</p>
<p>Pocieszający jest fakt, że Internet Explorer 7 oferuje dużo lepsze wsparcie dla selektorów. Mając na uwadze to, że kiedyś będziemy w stanie wykorzystać pełne możliwości selektorów, warto najpierw poznać ich przeznaczenie.</p>
<p>Selektorów <abbr>CSS</abbr> jest tak dużo, że pojedynczy artykuł byłby zbyt długi. Dla łatwiejszego znalezienia informacji artykuł został podzielony na 3 części:</p>
<ol>
<li>Część 1 wyjaśnia właściwości selektorów podstawowych, w tym selektorów: uniwersalnego, typu, id i klasy.</li>
<li>Część 2 przedstawia selektory połączone, grupowanie oraz atrybuty selektorów.</li>
<li>Część 3 opisuje wykorzystanie pseudo-klas i pseudo-elementów.</li>
</ol>
<h3>Selektor podstawowy</h3>
<p>Zacznijmy od czegoś prostego. Selektor <abbr>CSS</abbr> jest wzorcem, który pasuje tylko do konkretnych elementów w strukturze dokumentu. W momencie spełnienia wszystkich warunków, deklaracje i reguły są stosowane do elementu lub elementów, spełniających dany wzorzec. Rozważmy bardzo prostą regułę <abbr>CSS</abbr>.</p>
<pre><code>p { color:#f00; }</code></pre>
<p>Selektor to częścią reguł <abbr>CSS</abbr>, które występują przed otwierającym nawiasem klamrowym, “{“. Obecny w przykładzie selektor <code>p</code>, pasuje do wszystkich paragrafów w dokumencie i sprawia, że tekst paragrafów jest czerwony. Rzeczywiście nieskomplikowane.</p>
<h3>Przegląd selektorów</h3>
<p>Powyższy przykład był naprawdę prosty. Pozostałe selektory zamierzam opisać w dalszej części. Jednak zanim to zrobię, poniżej zamieszczam wszystkie selektory <abbr>CSS</abbr> 2.1 (dane zaczerpnięte z tabeli <a href="http://www.w3.org/TR/CSS21/selector.html#q1">CSS 2.1, 5.1 Pattern matching</a>):</p>
<table cellspacing="0">
<caption>Przegląd selektorów CSS 2.1</caption>
<thead>
<th scope="col">Selektor</th>
<th scope="col">Wzorzec</th>
<th scope="col">Opis</th>
</thead>
<tbody>
<tr>
<td>Uniwersalny</td>
<td>*</td>
<td>Pasuje do dowolnego elementu.</td>
</tr>
<tr>
<td>Typ</td>
<td>E</td>
<td>Pasuje do dowolnego elementu E.</td>
</tr>
<tr>
<td>Klasa</td>
<td>.info</td>
<td>Pasuje do dowolnego elementu, którego atrybut <code>class</code> zawiera wartość <code>info</code>.</td>
</tr>
<tr>
<td>Identyfikator</td>
<td>#footer</td>
<td>Pasuje do dowolnego elemntu, którego <code>id</code> równa się <code>footer</code>.</td>
</tr>
<tr>
<td>Potomek</td>
<td>E F</td>
<td>Pasuje do dowolnego elementu F, który jest potomkiem elementu E.</td>
</tr>
<tr>
<td>Dziecko</td>
<td>E &gt; F</td>
<td>Pasuje do dowolnego elementu F, który jest dzieckiem elementu E.</td>
</tr>
<tr>
<td>Sąsiędni</td>
<td>E + F</td>
<td>Pasuje do dowolnego elementu F występującego obok jako siostrzany element E.</td>
</tr>
<tr>
<td>Artybut</td>
<td>E[att]</td>
<td>Pasuje do dowolnego elementu E, który posiada artybut <code>att</code> bez względu na jego wartość.</td>
</tr>
<tr>
<td>Atrybut</td>
<td>E[att=val]</td>
<td>Pasuje do dowolnego elementu E, którego atrybut <code>att</code> jest dokładnie równy wartości <code>val</code>.</td>
</tr>
<tr>
<td>Atrybut</td>
<td>E[att~=val]</td>
<td>Pasuje do dowolnego elementu E, którego atrybut <code>att</code> posiada wartości rozdzielone spacjami, przy czym jeden z nich jest dokładnie równy <code>val</code>.</td>
</tr>
<tr>
<td>Atrybut</td>
<td>E[att|=val]</td>
<td>Pasuje do dowolnego elementu E, którego atrybut <code>att</code> posiada wartości rozdzielone myślnikami, przy czym pierwszy z nich jest równy <code>val</code>.</td>
</tr>
<tr>
<td>Pseudo-klasa :first-child</td>
<td>E:first-child</td>
<td>Pasuje do elementu E kiedy E jest pierwszym dzieckiem, swego rodzica.</td>
</tr>
<tr>
<td>Pseudo-klasa :link</td>
<td>E:link<br />
E:visited</td>
<td>Pasuje do nie odwiedzonych (:link) lub właśnie odwiedzonych (:visited) linków.</td>
</tr>
<tr>
<td>Pseudo-klasa :active</td>
<td>E:active<br />
E:hover<br />
E:focus</td>
<td>Pasuje do elementu E spełniającego określone warunki.</td>
</tr>
<tr>
<td>Pseudo-klasa :lang</td>
<td>E:lang(c)</td>
<td>Pasuje do elementu E, który jest napisany w języku c.</td>
</tr>
<tr>
<td>Pseudo-klasa :first-line</td>
<td>E:first-line</td>
<td>Pasuje do zawartości pierwszej linii danego elementu E.</td>
</tr>
<tr>
<td>Pseudo-element :first-letter</td>
<td>E:first-letter</td>
<td>Pasuje do pierwszej litery danego elementu E.</td>
</tr>
<tr>
<td>Pseudo-elementy :before i :after</td>
<td>E:before<br />
E:after</td>
<td>Używane do wstawiania generowanej zawartości przed i po zawartości elementu E.</td>
</tr>
</table>
<p>Wszystkie spośród tych selektorów opiszę szczegółowo w dalszej części artykułu. Niektóre z określeń, występujące w powyższej tabeli, jak również w dalszej części artykułu wymagają wyjaśnienia.</p>
<dl>
<dt>potomek</dt>
<dd>Element, który jest dzieckiem, wnukiem lub kolejnym potomkiem elementu w strukturze dokumentu.</dd>
<dt>przodek</dt>
<dd>Element, który jest rodzicem, dziadkiem lub wcześniejszym przodkiem elementu w strukturze dokumentu.</dd>
<dt>dziecko</dt>
<dd>Bezpośredni potomek danego elementu. Żaden inny element nie może znajdować się pomiędzy nimi.</dd>
<dt>rodzic</dt>
<dd>Bezpośredni przodek danego elementu. Żaden inny element nie może znajdować się pomiędzy nimi.</dd>
<dt>rodzeństwo</dt>
<dd>Element, który ma tego samego rodzica, co aktualny element.</dd>
</dl>
<h3>Selektory proste i połączone</h3>
<p>Selektory dzielimy na dwie główne kategorie: selektory proste i selektory połączone.</p>
<p><strong>Selektor prosty</strong> składa się z selektora typu lub selektora uniwersalnego, po którym występuje zero lub więcej atrybutów, identyfikatorów lub pseudo-klas. Poniższa reguła jest przykładem selektora prostego:</p>
<pre><code>p.info { background:#ff0; }</code></pre>
<p><strong>Selektor połączony</strong> (czasami nazywany selektorem kontekstowym) składa się z dwóch lub więcej rozdzielonych selektorów prostych. Poniżej mamy prosty przykład selektora połączonego:</p>
<pre><code>div p { font-weight:bold; }</code></pre>
<p>Powyższa reguła znajdzie zastosowanie do wszystkich elementów <code>p</code> które są potomkami elementu <code>div</code>.</p>
<p>Do selektora możemy dołączyć jeden pseudo-element. W przypadku selektora połączonego, dołączany pseudo-element musi znajdować się za ostatnim selektorem prostym.</p>
<p>Szczegóły dotyczące selektorów połączonych, samych połączeń oraz pseudo elementów znajdziemy w części 2 oraz części 3 tej serii.</p>
<h3>Selektor uniwersalny</h3>
<p>Uniwersalny selektor jest reprezentowany przez gwiazdkę, “*”, tym samym pasuje do wszystkich elementów w strukturze dokumentu. Dosyć trudno znaleźć go w stylach kaskadowych, ale selektor uniwersalny jest aktualnie często wykorzystywany z selektorem klasy i identyfikatora. Jeżeli selektor uniwersalny nie jest jedynym składnikiem selektora prostego to znak “*” możemy pominąć:</p>
<ul>
<li><code>.myclass</code> jest odpowiednikiem <code>*.myclass</code></li>
<li><code>#myid</code> jest odpowiednikiem <code>*#myid</code></li>
</ul>
<p>Jeden z popularnych sposobów wykorzystania selektora uniwersalnego to ustawienie zerowego marginesu oraz zerowego dopełnienia dla wszystkich elementów:</p>
<pre><code>* { margin:0; padding:0; }</code></pre>
<p>Opisana technika nosi czasami nazwę <a href="http://leftjustified.net/journal/2004/10/19/global-ws-reset/">Global White Space Reset</a>.</p>
<h3>Selektor typu</h3>
<p>Selektor typu pasuje do każdego elementu danego typu w dokumencie. Poniższa reguła pasuje zatem do wszystkich paragrafów w dokumencie i ustawia rozmiar czcionki w paragrafach na 2em:</p>
<pre><code>p { font-size:2em; }</code></pre>
<h3>Selektor klasy</h3>
<p>Selektor klasy jest reprezentowany przez znak kropki, “.”, tym samym elementu pasujące do danej klasy posiadają atrybut <code>class</code> z odpowiednią wartością. Następna reguła będzie stosowana do elementów <code>p</code>, należących do klasy “info”:</p>
<pre><code>p.info { background:#ff0; }</code></pre>
<p>Możemy określić kilka klas dla danego elementu. Atrybut <code>class</code> przechowuje wymagane nazwy klas rozdzielone znakiem spacji. Wówczas selektor klasy będzie odnosił się jedynie do tych elementów, które mają wymienione nazwy klas. Podana niżej reguła pasuje do elementów <code>p</code>, które posiadają obie wartości “info” oraz “error” w atrybucie klasy:</p>
<pre><code>p.info.error { color:#900; font-weight:bold; }</code></pre>
<p><strong>Uwaga:</strong> Selektory wielokrotnych klas nie działają w Internet Explorer 6, ale mają być wspierane w IE7.</p>
<p>Typ elementu nie musi być określony. Pozostawienie wolnego typu jest równoznaczne z użyciem selektora uniwersalnego zamiast selektora typu. Poniższa reguła będzie odnosiła się do wszystkich elementów klasy “info”, bez względu na ich typ:</p>
<pre><code>.info { background:#ff0; }</code></pre>
<h3>Selektor identyfikatora</h3>
<p>Selektor identyfikatora jest reprezentowany przez znak kratki, “#”, a odnosi się do elementów posiadających odpowiednią wartość atrybutu <code>id</code>. value. Kolejna reguła pasuje do wszystkich elementów, które mają atrybut <code>id</code> równy “info”, bez względu jakiego typu jest dany element:</p>
<pre><code>#info { background:#ff0; }</code></pre>
<p>Jeżeli dodatkowo określimy typ elementu, to reguła będzie obowiązywać tylko konkretny element.:</p>
<pre><code>p#info { background:#ff0; }</code></pre>
<p>Ważne jest, aby pamiętać o wyższości identyfikatora nad selektorem klasy. Wartość każdego identyfikatora musi być unikatowa w całym dokumencie, kiedy klasa może pojawić się wielokrotnie. Wówczas selektor identyfikatora stosuje się tylko do jednego elementu w strukturze dokumentu.</p>
<h3>Ciąg dalszy…</h3>
<p>W pierwszej części poznaliśmy podstawowe selektory. <a href="http://adamczuk.net.pl/2008/12/10/selektory-css-21-czesc-2/">Część 2</a> tego artykułu zawiera szczegółowy opis selektorów połączonych, jak również grupowania i atrybutów selektorów. <a href="http://adamczuk.net.pl/2008/12/12/selektory-css-21-czesc-3/">Część 3</a> pozwoli nam na poznanie właściwości pseudo-klas i pseudo-elementów.</p>
<p class="info">Ten artykuł jest tłumaczeniem oryginalnego tekstu <a href="http://www.456bereastreet.com/archive/200509/css_21_selectors_part_1/">CSS 2.1 selectors, Part 1</a>, którego autorem jest Roger Johansson.</p>
]]></content:encoded>
			<wfw:commentRss>http://adamczuk.net.pl/2008/12/08/selektory-css-21-czesc-1/feed/</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
	</channel>
</rss>

