2006.02_Diagram części Twojego komputera_[Programowanie].pdf

programowanie

Diagram części

Twojego komputera

Marek Sawerwain

się napisaniem programu,

który będzie wyświetlał

kilka podstawowych in-

formacji o komputerze, na którym został

uruchomiony (będą one dotyczyć typu pro-

cesora, karty graicznej oraz muzycznej).

Nie będziemy tych danych wyświetlać

w postaci tylko i wyłączenie tekstowej,

ale postaramy się o utworzenie nieskompli-

kowanego diagramu.

Program napiszemy dla środowiska

GNOME. „Wielka stopa” posiada w swym

arsenale jeden bardzo przydatny widget

– jest nim obiekt Canvas . Znakomicie

nadaje się on do tworzenia diagramów,

więc warto wykorzystać bogate możli-

wości tej kontrolki we własnym pro-

gramie.

Pętla GUI jest realizowana samo-

dzielnie przez GNOME, więc tuż po wy-

konaniu funkcji gtk_main() kontrolę nad

naszym programem przejmuje środo-

wisko graiczne. Nie musimy się trosz-

czyć np. o przewijanie zawartości okna

z diagramem bądź jego odświeżanie

– tym zajmuje się GNOME oraz biblio-

teka GTK+.

Utworzenie interfejsu

Interfejs programu, podobnie jak w po-

przednich aplikacjach, które opisywali-

śmy na łamach Linux+, tworzymy za

pomocą Glade i nie korzystamy z pliku

glade , ale z kodu wygenerowanego samo-

czynnie przez „budowniczego interfejsu”

po wybraniu przycisku Buduj (ang. Build ).

Tym razem jest to projekt GNOME, więc

nie ograniczamy się tylko i wyłącznie do

biblioteki GTK+. Z tego powodu inicjali-

zacja systemu GUI dokonywana w fun-

kcji main zaczyna się w następujący spo-

sób:

Budowa naszego programu

Na początku warto dokładnie prześle-

dzić, jakie czynności należy wykonać

w tworzonym programie. Pokazuje to

Rysunek 1. Tym razem nie musimy kon-

struować specjalnej pętli, aby śledzić zda-

rzenia pojawiające się w trakcie funk-

cjonowania programu, gdyż nasz pro-

gram tylko raz rysuje diagram. Z tego

powodu pierwsze czynności to inicjaliza-

cja biblioteki Kudzu oraz interfejsu użyt-

kownika. Najważniejsze zagadnienie to

odczyt informacji, które mają pojawić się

na tworzonym diagramie, oraz naryso-

wanie samego diagramu. W związku

z tym, z obiektu „rysowanie diagramu”

wychodzi pięć pozostałych obiektów, które

reprezentują funkcje odpowiedzialne za

zbieranie informacji o poszczególnych

komponentach.

argc, argv, GNOME_PARAM_

APP_DATADIR, NULL, NULL);

DVD

Po uruchomieniu Linux+ Live

DVD można przetestować

stworzoną aplikację oraz ją

samodzielnie przekompilować.

W ten sposób nasz program staje się peł-

noprawnym programem dla środowiska

GNOME. Po wywołaniu tej funkcji two-

rzymy okno główne naszej aplikacji:

Na płycie CD/DVD

Na płycie CD/DVD znajduje się

kod źródłowy programu.

MainWin = create_MainWin ();

Jest to, jak widać, identyczna czynność

jak przy programach korzystających tylko

38 luty 2006

W tym miesiącu zajmiemy

gnome_program_init

("harddraw", "1.0",

LIBGNOMEUI_MODULE,

C/C++/Canvas/Kudzu

programowanie

Kompilacja programu

Do kompilacji programu wszystkie po-

trzebne pakiety z pewnością znajdują się

w dystrybucji używanej przez Czytelni-

czkę/Czytelnika. GNOME to element stały

dla znakomitej większości dystrybucji, po-

dobnie jak biblioteka Kudzu. Jest ona sto-

sowana do wykrywania sprzętu i jego

koniguracji podczas inicjacji systemu.

Z tego powodu warto sprawdzić, czy w sys-

temie, w którym chcemy skompilować

opisywany w artykule program, znajdują

się pakiety dla developerów.

Najprostszy skrypt makeile , który

przeprowadzi kompilację, może przedsta-

wiać się następująco:

Podczas tworzenia interfejsu w Glade nie

zostały określone wymiary diagramu,

a dokładniej obszaru, na jakim będzie on

rysowany. Robimy to teraz w następują-

cy sposób:

Listing 1. Odczyt ilości dostępnej

pamięci RAM

void total_memory_get () {

int linelen ;

FILE * f = NULL ;

f = fopen ( "/proc/meminfo" , "r" );

if ( f != NULL ) {

getline (& tmp01 ,

gnome_canvas_set_scroll_region

(GNOME_CANVAS (CanvasArea),

-300, 0, 800, 400);

Kolejne czynności to uzyskiwanie infor-

macji oraz rysowanie samego diagramu

(funkcja canvas_setup() ). Po narysowaniu

diagramu podłączamy dodatkowe sygna-

ły. Jest to m.in. obsługa przycisku zamy-

kania okienka. Funkcją gtk_widget_show

(MainWin); wyświetlamy okno programu

na ekranie. Ostatnim krokiem jest urucho-

mienie głównej pętli GUI, jak zwykle funk-

cją gtk_main(); .

& linelen , f );

tmp01 [ strlen ( tmp01 )- 1 ]= 0 ;

strcpy (& totalmemory [ 0 ] ,

strstr ( tmp01 , ":" )+ 7 );

if ( tmp01 ) free ( tmp01 );

}

fclose ( f );

}

all:

gcc -c src/interface.c

-I./src `pkg-conig --clags

Następne wyrażenie, jak widzimy z Listin-

gu 1, wpisuje 0 na końcu zmiennej tmp01 ,

w której jest przechowywana informa-

cja o dostępnej pamięci – przedstawia

się ona w następujący sposób tekst :

liczba . Naszym zadaniem jest uzyska-

nie liczby, więc wystarczy odczytać tekst

leżący na prawo od dwukropka. W tym

celu znakomicie nadaje się funkcja strstr .

Ostatecznie, umieszczenie w zmiennej

totalmemory poprawnej wartości sprowa-

dza się do następującej linii kodu:

gtk+-2.0 libgnomeui-2.0`

Odczytanie informacji

o dostępnej pamięci RAM

i procesorze

Uzyskanie informacji o dostępnej pamię-

ci RAM oraz podstawowych informacji

o procesorze to zadania względnie łatwe,

pod warunkiem, że wiemy, gdzie szukać

tego typu informacji. Najlepszym źródłem

jest katalog /proc oraz dwa następują-

ce pliki: meminfo , w którym, zgodnie z naz-

wą, znajdują się informacje o pamięci,

oraz cpuinfo , gdzie zawarte są wszystkie

najważniejsze informacje na temat proce-

sora.

Listing 1 przedstawia kod krótkiej

funkcji, która odczytuje informacje o dos-

tępnej pamięci RAM. Plik /proc/meminfo

to plik tekstowy, a potrzebne nam infor-

macje znajdują się w pierwszej linii pli-

ku.

-I./src `pkg-conig --clags

gtk+-2.0 libgnomeui-2.0`

-I./src `pkg-conig --clags

gtk+-2.0 libgnomeui-2.0`

interface.o support.o -lkudzu

gthread-2.0 gtk+-2.0 libgnomeui-2.0`

strstr(tmp01,":")+7);

strcpy(&totalmemory[0],

-lpci `pkg-conig --libs

Dwie pierwsze linie kompilują kod wygene

rowany przez program Glade. Trzecia li-

nia reguły all jest odpowiedzialna za kom-

pilację kodu naszej aplikacji. Ostatnia

czwarta linia dokonuje konsolidacji osta-

tecznej postaci programu. Ponieważ używa-

my biblioteki Kudzu, musimy dołączyć dwie

istotne biblioteki: -lkudzu -lpci . Pierwsza

z nich jest bezpośrednio odpowiedzial-

na za bibliotekę, a druga dołącza funk-

cje do poprawnej obsługi szyny PCI, gdyż

większość urządzeń jest podłączona wła-

śnie za pomocą PCI (w pewnym sensie

nawet karta graiczna, choć podłączona

przez AGP, jest także widziana z poziomu

szyny PCI).

Warto jeszcze dopowiedzieć, w jakim

celu należy do wyniku strstr dodać war-

tość siedem – w ten sposób przesuwa-

my wskaźnik o siedem znaków, które są

w rzeczywistości spacjami.

Odczytanie informacji o procesorze

odbywa się w dość podobny sposób, co

potwierdza Listing 2. Tym razem musimy

odczytać więcej linii tekstu, ale potrzebne

będą nam tylko cztery.

Sposób postępowania w tym przy-

padku różni się tylko obecnością pętli

for , w której odczytujemy linię tekstu za

pomocą getline . Umieszczamy zero na

końcu tekstu, a następnie przydzielamy

pamięć odpowiedniemu elementowi w ta-

blicy info :

Każdy, kto po raz pierwszy zajrzy

do katalogu proc , zawsze się dziwi, iż

większość plików jest zerowej długo-

ści. Plik meminfo także posiada taki roz-

miar, ale zawiera cenne informacje. Ich

wydobycie zaczynamy od otworzenia

pliku, tak jak to czynimy z każdym in-

nym plikiem:

f=fopen("/proc/meminfo", "r");

i wyłączenie z GTK+. Następnym krokiem

jest uzyskanie referencji do widgetu:

Po sprawdzeniu, czy udało się ten plik

otworzyć, wystarczy odczytać jedną linię

tekstu za pomocą funkcji getline (jest to

funkcja standardowa, a jej prototyp znaj-

duje się w pliku stdio.h ):

info[i]=malloc(strlen(tmp01)-1);

(MainWin, "CanvasArea");

Pozostaje nam jeszcze tylko skopiować

fragment tekstu na prawo od dwukropka:

getline(&tmp01, &linelen, f);

strcpy(info[i], strstr(tmp01,":")+2);

www.lpmagazine.org

-I./include

gcc -c src/support.c

-I./include

gcc -c maincode.c

-I./include

gcc -o harddraw maincode.o

CanvasArea=lookup_widget

programowanie

Listing 2. Odczyt informacji o procesorze

z pliku /proc/cpuinfo

wszystkich urządzeń, gdyż skupimy się

na napędach optycznych, dyskach twar-

dych, kartach dźwiękowych oraz kartach

graicznych.

W programie funkcje zajmujące się

uzyskaniem tych informacji posiadają

następujące nazwy: cdrom_list() , hd_

list() , audio_list() oraz video_list() .

Wszystkie funkcje są zbudowane w dość

podobny sposób, jak zostało to pokazane

na Listingu 3. Dla przykładu opiszę, w jaki

sposób odczytujemy informacje o dostęp-

nych napędach optycznych.

W pierwszej kolejności należy odpo-

wiednio zadeklarować zmienną, w której

znajdzie się lista dostępnych urządzeń:

struct device **devlist; . Kolejnym

ważnym krokiem jest uzyskanie listy

urządzeń należących do potrzebnej klasy.

Ponieważ interesują nas napędy optyczne,

to ta klasa urządzeń jest reprezentowana

przez stałą CLASS_CDROM . Ostatecznie, aby

uzyskać listę urządzeń, wystarczy skorzy-

stać z funkcji probeDevices . Sprawdzi ona,

czy w systemie są dostępne urządzenia

określonego typu bez ich inicjalizacji oraz

koniguracji:

for (x = 0; devlist[x]; x++)

{// treść pętli }

void get_cpu_info () {

int i , linelen ;

FILE * f = NULL ;

f = fopen ( "/proc/cpuinfo" , "r" );

if ( f != NULL ) {

tmp01 = NULL ;

for ( i = 0 ; i < 18 ; i ++) {

getline (& tmp01 , & linelen , f );

tmp01 [ strlen ( tmp01 )- 1 ]= 0 ;

info [ i ]= malloc ( strlen

Funkcja probeDevices tak konstruuje listę,

iż po ostatnim wpisie zostaje umieszczona

wartość NULL. W pętli, jak widać, wyko-

rzystujemy ten fakt, aby opisać warunek

zakończenia pętli, podając tylko wyraże-

nie devlist[x] .

Treść pętli dla urządzeń typu CD-

ROM przedstawia się następująco:

sprintf(tmptxt, "device: /dev/

->desc); strcat(&cdromdesc[0],

strstr ( tmp01 , ":" )+ 2 );

}

if ( tmp01 ) free ( tmp01 );

}

fclose ( f );

}

->device, devlist[x]

&tmptxt[0]); cdrom_count++;

W pierwszej linii kodu instrukcją sprintf

tworzymy dwie linie tekstu, gdzie umie-

szczamy nazwę urządzenia, do którego

podłączony jest napęd CD-ROM. Od-

czytujemy także nazwę symboliczną, przy-

czym zazwyczaj będzie to nazwa pro-

ducenta, oznaczenie napędu itd. Uzyskane

dwie linie tekstu są umieszczane w zmien-

nej tmptxt , a jej zawartość jest dołącza-

na do zmiennej tekstowej cdromdesc .

Zwiększamy także licznik napędów CD-ROM

dostępnych w systemie – cdrom_count .

W ten sposób za pomocą Kudzu uzyska-

my informacje o tym, ile napędów jest

dostępnych w systemie, w którym został

uruchomiony program.

W podobny sposób uzyskujemy in-

formacje o pozostałych komponentach.

W ten sposób odczytamy wszystkie osiem-

naści linii z pliku.

Informacje

z systemu Kudzu

Pozostałe informacje o tym, co znajduje

się w komputerze, uzyskamy za pomocą

biblioteki Kudzu . W naszym programie,

aby zastosować pochodzące z niej funkcje,

należy dołączyć odpowiedni plik nagłów-

kowy:

( CLASS_CDROM, probeBus, PROBE_ALL);

Wszystkie dostępne urządzenia znajdą się

w tablicy devlist , którą możemy przeglą-

dać oraz odczytywać potrzebne informa-

cje. Najłatwiej tę czynność wykonać za

pomocą pętli for :

#include <kudzu/kudzu.h>

Zanim uzyskamy listę urządzeń znajdu-

jących się w komputerze, należy zaini-

cjalizować w odpowiedni sposób system

Kudzu:

initializeDeviceList();

initializeBusDeviceList(probeBus);

Warto zwrócić uwagę na to, w jaki sposób

została zadeklarowana zmienna probeBus :

BUS_UNSPEC & ~BUS_SERIAL;

Oznacza to, iż Kudzu będzie przeszuki-

wać urządzenia znajdujące się na dowol-

nej szynie, ale nie będzie to złącze sze-

regowe (tzw. porty COM, które ostat-

nio już wychodzą z użycia). Po inicjali-

zacji Kudzu jesteśmy gotowi do odczy-

tu urządzeń. Nie będziemy odczytywać

Rysunek 1. Najważniejsze zdarzenia w programie

40 luty 2006

%s\ndesc: %s\n", devlist[x]

( tmp01 )- 1 );

strcpy ( info [ i ] ,

devlist = probeDevices

enum deviceBus probeBus =

C/C++/Canvas/Kudzu

programowanie

Listing 3. Odczyt informacji o karcie graicznej z systemu Kudzu

Zanim przystąpimy do rysowania dia-

gramu, należy dysponować wskazaniem

na obiekt root widgetu AreaCanvas , w któ-

rym jest rysowany cały diagram. Uzys-

kanie obiektu root jest łatwe i przedstawia

się następująco:

void video_list () {

struct device ** devlist ;

int x ;

char tmptxt [ 512 ];

devlist = probeDevices ( CLASS_VIDEO , probeBus , PROBE_ALL );

if ( devlist ) {

for ( x = 0 ; devlist [ x ]; x ++) {

if ( strcmp ( devlist [ x ]-> driver , "unknown" )) {

sprintf ( tmptxt , "driver: %s \n desc: %s \n " ,

(GNOME_CANVAS (CanvasArea));

Później musimy wywołać funkcję video_

list . Jej zadaniem jest wykrycie typu

karty graicznej oraz utworzenie komu-

nikatu tekstowego, który znajduje się

w diagramie. Bezpośrednio po wywoła-

niu tej funkcji sprawdzamy, czy zmien-

na video_count jest większa od zera, co

oznacza, iż musimy wiedzieć, czy jakakol-

wiek karta graiczna została wykryta przez

Kudzu. Jeśli udało się poprawnie wykryć

kartę, to obliczamy przesunięcie wzglę-

dem osi Y. Jest to istotne, ponieważ wcze-

śniej wyświetlamy informacje o napędach

i dyskach. Ich ilość w systemie nie jest

naturalnie stała i można mieć np. jeden

napęd CDROM i dwa albo trzy dyski

twarde. Ponieważ wszystkie informacje

o napędach są wyrównane do prawej

strony, to zmienia się tylko ich pozycja

pionowa zapisywana w zmiennej last_y .

Odstęp pomiędzy poszczególnymi warto-

ściami wynosi dokładnie 10 punktów (nie

są to piksele, ale wewnętrzne jednostki

obiektu Canvas).

Narysowanie prostokąta jest równo-

ważne utworzeniu obiektu i w tym celu

devlist [ x ]-> driver , devlist [ x ]-> desc );

if ( strlen ( devlist [ x ]-> device ) > video_strlen )

video_strlen = strlen ( devlist [ x ]-> device );

if ( strlen ( devlist [ x ]-> desc ) > video_strlen )

video_strlen = strlen ( devlist [ x ]-> desc );

strcat (& videodesc [ 0 ] , & tmptxt [ 0 ]);

video_count ++;

}

freeDeviceList ();

}

Potwierdza to także Listing 3. Względem

przykładu, który omówiłem powyżej,

dodatkowo sprawdzamy długość ciągu

znaków opisujących urządzenie. Infor-

macja ta jest przydatna, aby na rysunku

utworzyć prostokąt odpowiedniej wiel-

kości, w którym zmieści się cały komu-

nikat.

wdę dwie czynności: odczytujemy infor-

macje o sprzęcie (w sposób opisany

w poprzednich akapitach) oraz doko-

nujemy wizualizacji tych informacji.

Jej fragmenty zostały przedstawione

na Listingu 4. Funkcja ta jest znacznie

dłuższa, ale technika rysowania poszcze-

gólnych fragmentów diagramy jest po-

dobna, więc przedstawię ją na przykła-

dzie karty graicznej.

Rysujemy diagram

Wiemy już, w jaki sposób odczytać po-

trzebne informacje – dzięki Kudzu może-

my uzyskać jeszcze więcej informacji

o sprzęcie, więc zachęcam do modyikacji

programu, np. dodając informację o karcie

sieciowej. Teraz należy zastanowić się,

w jaki sposób narysować diagram.

Jeden ze sposobów zdradza Rysunek 2.

Jak widać, w lewej dolnej części znajduje

się ikona komputera, z której za pomo-

cą strzałek wskazujemy na pozosta-

łe części diagramu. W odpowiednich

prostokątach prezentujemy informacje

o karcie graicznej i dźwiękowej, wyświe-

tlamy ilość dostępnej pamięci RAM

oraz kilka informacji o procesorze.

Dwa najwyżej umieszczone prostokąty

po prawej stronie odnoszą się do na-

pędów optycznych oraz twardych dys-

ków.

Funkcja, która zajmuje się rysowa-

niem diagramu, nosi nazwę canvas_

setup() . Wykonujemy w niej tak napra-

Rysunek 2. Przykładowy diagram sprzętowy wygenerowany przez program HardDraw

www.lpmagazine.org

root = gnome_canvas_root

programowanie

Listing 4. Najważniejsze fragmenty funkcji rysującej diagram

poprawne określenie szerokości prosto-

kąta. Warto w tym momencie raz jesz-

cze przeczytać Listing 3, aby zobaczyć,

w jaki sposób nadawana jest wartość tej

zmiennej.

Gdy prostokąt jest narysowany, to

drugie wywołanie konstruktora z funk-

cją gnome_canvas_text_get_type , która

odpowiada za obiekt reprezentujący

tekst, spowoduje, że w narysowanym

prostokącie zostanie umieszczony tekst

z krótkim opisem typu karty graicz-

nej. W przypadku obiektu canvas ważna

jest kolejność rysowania obiektów, gdyż

ten narysowany wcześniej może zostać

zakryty przez ten narysowany później.

W naszym przypadku celowo rysuje-

my w pierwszej kolejności prostokąt,

a dopiero później dodajemy komunikat

tekstowy.

void canvas_setup () {

char txt [ 512 ];

double last_x = 0 , last_y = 0 ;

root = gnome_canvas_root ( GNOME_CANVAS ( CanvasArea ));

/* usunięte fragmenty */

/* video list box */

video_list ();

video_strlen =( video_strlen + 4 )* 10 ;

if ( video_count > 0 ) {

videos_x = 210 ;

if ( last_y == 0 )

last_y = 30 ;

else

last_y += 10 ;

videos_y = last_y ;

last_y = videos_y +( audio_count )* 50 ;

videos_box = gnome_canvas_item_new ( root , gnome_canvas_

rect_get_type () , "x1" , videos_x , "y1" , videos_y ,

Strzałki

Ostatnie zadanie, które wykonujemy w funk-

cji canvas_setup , to narysowanie strzałek

pomiędzy ikoną komputera a poszcze-

gólnymi prostokątami. Jak widać na Ry-

sunku 2, w zależności od miejsca umiesz-

czenia prostokąta, strzałki są skierowa-

ne albo w ścianę dolną, albo w lewą.

Przykładowe wywołanie funkcji draw_

arrow jest następujące:

"outline_color" , "black" , "ill_color" , "white" ,

"width_pixels" , 2 , NULL );

gnome_canvas_item_new ( root , gnome_canvas_text_get_type () ,

"y" , videos_y +( video_count )* 30 ,

"justiication" , GTK_JUSTIFY_CENTER ,

"font" , "monospace bold 10" ,

"ill_color" , "irebrick" ,

NULL );

}

/* usunięte fragmenty */

/* arrow to boxes */

draw_arrow ( cpu_box , - 95 , 290 , 0 );

/* pozostałe strzałki */

}

draw_arrow(cpu_box, -95, 290,0);

Pierwszy argument to obiekt prostokąt, do

którego chcemy skierować strzałkę. Dwie

następne wielkości to współrzędne począt-

ku. W ostatnim argumencie umieszcza-

my numer ściany, do której ma być skiero-

wana strzałka. Zero oznacza ścianę dolną,

a jedynka ścianę lewą.

Technika rysowania strzałki jest dość

prosta i sprowadza się odczytania współ-

rzędnych x1 , y1 , x2 , y2 obiektu, do którego

chcemy skierować strzałkę:

wykorzystujemy uniwersalny konstruktor

o nazwie gnome_canvas_item_new :

prostokąt umieścić pod poprawnymi

współrzędnymi. Lewy górny róg to

parametry o nazwach x1 , y1 , natomiast

x2 , y2 to prawy dolny róg. Jak widać,

wykorzystujemy zmienną video_count ,

choć naturalnie w przypadku kart gra-

icznych zazwyczaj mamy do czynie-

nia tylko z jedną. Podobna zmienna

jest potrzebna w przypadku twardych

dysków oraz dla napędów optycznych.

Jej wartość decyduje o wysokości prosto-

kąta. W ten sposób opis urządzeń będzie

w całości mieścił się w rysowanym pro-

stokącie. Podobne znaczenie pełni

zmienna video_strlen . Ponieważ kartę

graiczną opisujemy dwiema liniami

tekstu, w zmiennej video_strlen jest

zawarta ilość znaków dłuższej z linii.

Znajomość tej wartości pozwala nam na

videos_box = gnome_canvas_item_new

"x1",videos_x,"y1", videos_y,

get_type (),

"y2", videos_y+(video_count)*50,

tx1 = GNOME_CANVAS_RECT

"x2", videos_x+video_strlen,

(dst_box)->re.x1;

ty1 = GNOME_CANVAS_RECT

"width_pixels", 2, NULL);

(dst_box)->re.y1;

tx2 = GNOME_CANVAS_RECT

"ill_color", "white",

(dst_box)->re.x2;

ty2 = GNOME_CANVAS_RECT

Pierwszy argument to obiekt root ,

a następnym jest typ zwracany przez

funkcję. W naszym przypadku funkcja

gnome_canvas_rect_get_type reprezen-

tuje prostokąt (ang. rectangle ). Później

następują parametry niezbędne, aby

(dst_box)->re.y2;

Drugi etap to wyznaczenie dwóch punk-

tów: początkowego i końcowego. GNOME

wykorzystuje typ GnomeCanvasPoints ,

aby przechowywać kolejne współrzę-

42 luty 2006

"x2" , videos_x + video_strlen , "y2" , videos_y +( video_count )* 50 ,

"x" , videos_x + video_strlen / 2 ,

"text" , & videodesc [ 0 ] ,

(root, gnome_canvas_rect_

"outline_color", "black",

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: