• Tworzenie dziwacznych komunikatorów internetowych w przeglądarkach, jak Google Talk w GMailu, Facebook Chat czy komunikator NaszoKlasowy; do tego grona zalicza się również nieużywany przez nikogo w najbliższej przyszłości atlasowy candy,
• Oszukiwanie wszelkiej maści firewalli, które po zaszyfrowaniu transmisji SSLem (https) nie mogą rozróżnić normalnego przeglądania stron internetowych i korzystania z takiego komunikatora (oczywiście, można zablokować domeny itp, ale na to już nic się nie poradzi).

Obsługa BOSH w Gajimie

Podobno Pidgin również obsługuje BOSH, jednak jedynym klientem, który udało mi się zmusić do działania z BOSH, był Gajim. Konfigurację omówię na przykładzie kont atlasowych (chociażby tych na xmpp.fl9.eu), ale w przypadku innych serwerów wygląda to analogicznie – wystarczy zmienić BOSH Url.

Wchodzimy w konfigurację kont w Gajimie, wybieramy odpowiednie konto i przechodzimy na zakładkę Połączenie. Tam najbardziej interesuje nas Proxy – aby dodać nowe klikamy na Zarządzaj….

W nowootwartym oknie klikamy na Dodaj, aby dodać nowy serwer Proxy, nazwę wpisujemy dowolną, jako typ wybieramy BOSH i wypełniamy odpowiednim adresem pole BOSH URL. W przypadku kont atlasowych będzie to https://candy.atlas.fl9.eu/http-bind/. Obsługiwane jest tylko HTTPS, bo łączenie się z komunikatorem poprzez nieszyfrowane HTTP to IMHO czysta głupota, ale niektóre serwery mogą na to pozwalać. Certyfikat serwera jest niepodpisany, ale znając jego fingerprinty (SHA-256: DD 18 9C 96 EA 84 1E 76 8F 9B 0B E3 D6 3F D2 BA 99 30 75 86 83 5E F4 FC 93 2A 04 DB 5A BC E7 16, SHA-1: BE 12 8F 2E D1 58 07 B1 2E 00 DC 02 2F A9 D0 A6 32 47 AC 26) możemy być praktycznie pewni jego autentyczności.

Zamykamy okno Zarządzania Profilami Proxy i w zakładce Połączenie jako Proxy wybieramy stworzone przed chwilą połączenie poprzez BOSH. Od tej pory Gajim będzie łączył się tylko i wyłącznie za pośrednictwem wybranego adresu URL.

/opt/cross/avr/lib/gcc/avr/4.3.3/../../../../avr/lib/avr5/libc.a(cmpsf2.o):../../../libm/fplib/cmpsf2.S:58: multiple definition of `__ltsf2'
/opt/cross/avr/lib/gcc/avr/4.3.3/avr5/libgcc.a(_lt_sf.o):/usr/src/packages/BUILD/build/avr/avr5/libgcc/../../.././gcc/fp-bit.c:1287: first defined here
/opt/cross/avr/lib/gcc/avr/4.3.3/../../../../avr/lib/avr5/libc.a(floatsisf.o):../../../libm/fplib/floatsisf.S:46: multiple definition of `__floatsisf'
/opt/cross/avr/lib/gcc/avr/4.3.3/avr5/libgcc.a(_si_to_sf.o):/usr/src/packages/BUILD/build/avr/avr5/libgcc/../../.././gcc/fp-bit.c:1349: first defined here

Rozwiązaniem jest dodanie parametru -lm jako ostatniego parametru linkera.

Mój przykładowy plik Makefile, w którym poradziłem sobie z tym problemem:

FILE=gps
MCU=atmega328p
CFLAGS=-g -mmcu=$(MCU) -Wall -Wstrict-prototypes -Os -mcall-prologues -lm
PORT=/dev/ttyUSB0
DUDEOPTS=-c arduino -p m328p -P $(PORT) -b 57600

all: $(FILE).hex

help:
	@echo "Wpisz \"make\", aby zbudować program (stworzyć plik .hex)."
	@echo "Wpisz \"make load\", aby wrzucić program do mikrokontrolera."
	@echo "Wpisz \"make clean\", aby wyczyścić pliki."	

$(FILE).hex : $(FILE).out
	avr-objcopy -R .eeprom -O ihex $(FILE).out $(FILE).hex
$(FILE).out : $(FILE).o
	avr-gcc $(CFLAGS) -o $(FILE).out -Wl,-Map,$(FILE).map $(FILE).o -lm
$(FILE).o : $(FILE).c
	avr-gcc $(CFLAGS) -Os -c $(FILE).c 

load: $(FILE).hex
	stty -F $(PORT) hupcl
	avrdude $(DUDEOPTS) -e -U flash:w:$(FILE).hex

clean:
	rm -f *.o *.map *.out *.hex

Podkreśliłem linię, w której należało dodać ów parametr.

• Można w find użyć -links +1, aby znaleźć wszystkie pliki, których licznik dowiązań twardych ma wartość większą niż 1 (wiedząc, że każdy plik w *niksie to tak naprawdę jest dowiązanie twarde do jakiegoś inode szukamy takich plików, przy których tych dowiązań twardych jest więcej niż jedno), ale to zwróci również pliki, do których dowiązania znajdują się poza wskazanym drzewem katalogów.
• Można również znaleźć wszystkie takie pliki, a następnie wewnątrz pętli while wywołać kolejny raz find z parametrem -samefile. Jednak to powoduje przeszukanie całego drzewa katalogów wraz z każdą iteracją pętli, a więc jeśli mamy duże drzewo, to czas operacji może być naprawdę długi.

Rozwiązanie? Trzeba znaleźć wszystkie pliki regularne (-type f) do których istnieje ponad jedno dowiązanie twarde (-links +1). Wszystko dobrze, ale normalne wywołanie find w ten sposób zwróci nam wszystkei takie pliki w dość losowej kolejności. Do osiągnięcia naszego celu potrzebowaliśmy, aby były mniej-więcej posortowane – aby wszystkie dowiązania do jednego pliku były obok siebie. Jak to osiągnąć? find potrafi wypluwać dane nie tylko w prosty sposób, poprzez -print, ale również trochę bardziej potężny przy pomocy -printf. Wiemy również, że każde dowiązanie symboliczne wskazujące na ten sam plik musi mieć ustawiony ten sam numer inode. Tak więc, korzystając z -printf "%i %p\n" wypiszemy sobie wszystkie dowiązania wraz z ich numerami inode na przedzie, a następnie przy pomocy sort posortujemy tak, aby wszystkie dowiązania do jednego inode znalazły się obok siebie.

Kod prezentuje się mniej więcej następująco:

#!/bin/bash
find $1 -type f -links +1 -printf "%i %p\n" | sort | while read a
do
    # w zmiennej $a mamy obecnie przetwarzaną linię
    inode=`echo $a | cut -d' ' -f1`
    path=`echo $a | cut -d' ' -f2`
done

Teraz, jeśli obecny $inode różni się od tego, który znajdował się w poprzedniej iteracji pętli, to możemy być pewni, że już więcej na dowiązanie do poprzedniego pliku nie natrafimy. Tak więc wystarczy coś wykombinować, np. zmienne globalne przechowujące ostatnio znaleziony inode, i wszystko gra.

Dlaczego while a nie for?

Różnica jest prosta, ale ważna. W przypadku takiej pętli:

for i in *
do
    # coś robimy
done

cała zawartość * ląduje w wierszu poleceń. To się może wydawać drobnostką, ale jeśli jest tego bardzo dużo, to może się posypać – w końcu maksymalna długość polecenia w linii komend jest ograniczona. Spójrzmy teraz na konstrukcję z while:

find $1 -print | while read zmienna
do
    # coś robimy
done

Wygląda trochę bardziej skomplikowanie, ale zaleta jest znaczna. Mianowicie, tutaj wynik działania polecenia find nie ląduje w linii poleceń, ale idzie za pośrednictwem potoku do polecenia while, które przekazuje każdą otrzymaną w ten sposób linię do polecenia read. Wiemy, że potok może mieć praktycznie nieskończoną długość, więc tutaj problemu takiego, jak w przypadku for nie ma.

Zobacz też:

• Strona podręcznika dla find
• Strona podręcznika dla cut
• Strona podręcznika dla sort

Po odczekaniu powinien pojawić się komunikat o prawidłowym działaniu systemu Edukacja. Informuje on o tym, że wszystkie procedury są wykonywane zgodnie z planem.

Następnie naszym oczom ukazuje się komunikat zapewniający, że operatorzy czuwają i konserwują system na bieżąco, a więc możemy spać spokojnie i bez obaw używać systemu, ponieważ wiemy, że znajduje się pod czujnym okien specjalistów.

Po chwili konserwacja zostaje wykonana (wiadomo, godzina 13:00 w dzień zapisów to najlepszy moment na wykonywanie konserwacji, ponieważ można natychmiast sprawdzić, czy dokonane poprawki dobrze znoszą wysokie natężenie ruchu), a my możemy się zalogować.

Należy jednak uważać – ze względów bezpieczeństwa użytkownik, który przez dłuższy czas nie wykonuje żadnej operacji w systemie zostaje automatycznie wylogowany z systemu. Dlatego też, jeśli dłużej niż 1ns nie będziemy wykonywać żadnej operacji pokaże nam się następujący komunikat:

Warto zwrócić uwagę na pełną transparentność systemu Edukacja.CL. Niektóre systemy po prostu zwracają komunikat o błędzie, natomiast EduCL gra w otwarte karty i nie ukrywa niczego przed użytkownikiem:

Po chwili jednak sie powstrzymuje i nie zasypuje użytkowników tyloma informacjami, pokazując jedynie esencję problemu:

Po chwili jesteśmy w stanie zapisać się na pewną ilość przedmiotów, choć możliwe, że w trakcie zapisów będziemy musieli powtórzyć całą opisaną tu procedurę od początku. Nie ma się co martwić, ponieważ tak naprawdę wszystko jest…

Przepraszam za skriny w jpg, ale w gorączce chwili i przypływie adrenaliny nie zwróciłem na to uwagi, a KSnapshot uznał, że domyślnie będzie zapisywał w tym formacie.

Grę tę kupiłem w okolicy Bożego Narodzenia na wyprzedaży Steam. Jeśli ktoś o niej nie słyszał, podpowiem, kto jest producentem – Rockstar. Ten sam, który utrzymuje poziom serii GTA. Co więcej, Bully jest grą opartą na tym samym silniku, co GTA z serii III. Z tą różnicą, że dzieje się w szkole, a głównym bohaterem jest piętnastolatek. Co za tym idzie, nie mamy do dyspozycji prawdziwych broni, a przeciwnicy nie giną, a jedynie „odpadają”. Czy to jest jakiś problem? Ani trochę.

Walka jest wciągająca i daje dużo zabawy. Zamiast zwykłych broni mamy procę, superprocę, petardy, jajka, proszek na swędzenie, smródbombę, karabin na kartofle… Brzmi to dziwnie, ale gra się naprawdę wyśmienicie (zwłaszcza superprocą, która jest wyposażona w… lunetę snajperską). Co więcej, możemy walczyć tym, co znajdziemy na ziemi. Kij bejzbolowy, cegłówka, linijka? Cokolwiek. Walka bynajmniej nie jest trudna, więc nie ma co oczekiwać wyzwań, ale daje naprawdę dużo frajdy (wspomniałem, że można nauczyć sie combosów?). Pod koniec każdej potyczki gracz ma możliwość zadrwić z przeciwnika – nic to nie daje, poza satysfakcją wykręcenia ręki denerwującemu przeciwnikowi.

Jeśli ktoś grał w GTA, to nie zawiedzie się na Bully. Dużo misji pobocznych, dodatkowe misje od przechodniów, zbieranie kart do gry i gumer recepturek, dodatkowe „domki”, w których po odblokowaniu można zapisywać grę. Zróżnicowane pojazdy – od deskorolki, poprzez różne rodzaje rowerów, traktorek-kosiarkę do trawy, na skuterach kończąc. Mamy całe wesołe miasteczko wraz z atrakcjami do dyspozycji. No i „gangi” – grupy uczniów (nerdzi, bogaczki, sportowcy itd), którzy w zależności od postępów w grze są pozytywnie bądź negatywnie nastawieni w stosunku do gracza. Są też zróżnicowane placówki w mieście, które mamy do dyspozycji – szkoła, ryneczek, osiedle domków jednorodzinnych, slumsy, park industrialny, a nawet… zakład dla umysłowo chorych.

Misje są zróżnicowane, i można je wykonywać tak samo, jak w GTA – niektóre można pominąć, a każdą rozpoczynamy w odpowiednich miejscach. Ponadto należy uczęszczać na lekcje – ucieczka z lekcji powoduje wzrost poziomu poszukiwań (do momentu zakończenia zajęć o odpowiedniej godzinie). Lekcji nie trzeba kończyć z pozytywną oceną, ale warto, ponieważ osiągamy przez to wymierne korzyści. Większość lekcji polega na wykonywaniu poleceń na ekranie (tak, jak skakanie samochodem w niektórych misjach San Andreas, kojarzą się od razu gry takie, jak Dance Dance Revolution), choć niektóre są zdecydowanie inne. Nie będę ich tutaj opisywał, ale z pewnością można stwierdzić, że zajęcia lekcyjne nie są nudne. Każdy przedmiot składa się z pięciu zajęć, po zaliczeniu których nie trzeba już na ów przedmiot uczęszczać – ominięcie zajęć nie skutkuje podwyższonym poziomem poszukiwań.

Wady gry

Ta gra to konwersja z PlayStation, trzeba to powiedzieć głośno i wyraźnie. W związku z tym gra na klawiaturze jest o wiele mniej przyjemna niż na kontrolerze – na szczęście kupiłem sobie za 20pln w Saturnie na promocji joypada z dwoma analogami (które są potrzebne do gry). Podpinam go, zaczynam grać… i nic, gra go nie wykrywa. Co się okazuje? Gra wymaga kontrolera od XBox 360. Jaki jest tego powód? Żaden, ponieważ praktycznie te kontrolery nie dają niczego, czego moja tania podróba kontrolera z PS2 nie daje, poza inaczej ułożonymi przyciskami. Można użyć emulatora kontrolerów x360, który działa, i przy pomocy którego grałem. Fakt, nie jest to najstabilniejsze rozwiązanie na świecie – gra wywala się przy wychodzeniu do początkowego menu, co jednak nie ma wpływu na rozgrywkę, jeśli gra się długimi posiedzeniami i nie próbuje się wczytywać gry podczas grania. Wywalanie się gry w trakcie wychodzenia również nie przeszkadza, ale czuję się, jakbym grał w źle krakowanego pirata. No ale cóż, lepsze to, niż klawiatura.

No i, jak to zwykle przy konwersjach bywa, gra nie jest najlepiej zoptymalizowana. Działa wolno, potrafi przyciąć na moim (wiekowym) sprzęcie, ale na nowszych maszynach nie powinno być żadnych problemów.

Soundtrack

Muzyka w grze jest bardzo przyjemna. Zmienia się w zależności od pory dnia, pory roku (wspomniałem, że wygląd otoczenia zmienia się w zależności od pory roku?), czynności lub rodzaju misji. Instrumentalne melodyjki wpadają w ucho, i nie przeszkadza fakt, że są zapętlone. Nie, poważnie, o ile muzyki tej nie nagrałbym sobie do samochodu (tak, jak muzykę z GTA4 nagrałem), to do tej gry jest dobrana idealnie.

Podsumowanie

Rockstar ponownie stanął na wysokości zadania. Polecam tę grę, zwłaszcza, że w sklepach można ją wyhaczyć za ~30pln w Ekstra Klasyce. Kilka godzin dobrej zabawy, pełnej żartów, typowo Rockstarowego humoru (przykład – pocałunek od dziewczyny daje bonusowe punkty zdrowia – pamiętasz, co dawało takie punkty w GTA III?), pościgów rowerowych, strzelanin z procy i różnego rodzaju misji, które pasują tylko do gry tego rodzaju, lecz dają tak wiele radości z gry, że tego po prostu nie można przegapić.

Kod znajduje się poniżej, a tutaj ja postaram się opisać po kolei, co się dzieje.

Linia 5 inicjalizuje SDL. Można zamiast SDL_INIT_EVERYTHING użyć SDL_INIT_JOYSTICK, jednak obsługa zdarzeń wymaga inicjalizacji podsystemu wideo, a więc postanowiłem inicjalizować wszystko.

W liniach 8 i 9 pobieramy liczbę dżojstików w systemie za pomocą funkcji SDL_NumJoysticks(), a następnie wyświetlamy nazwę każdego za pomocą funkcji SDL_JoystickName(i), gdzie parametrem jest numer dżojstika. Linii tej nie podświetlałem, bo w sumie nie ma tam nic ciekawego.

W linii 18 włączamy tryb zdarzeń w obsłudze dżojstika. O co chodzi? Sprawa jest w sumie prosta. Normalnie można dżojstik obsłużyć na chama, wywołując nieskończoną pętlę, w każdej iteracji aktualizując stan dżojstika i robiąc z tym co trzeba. Takie rozwiązanie ma jednak kilka wad:

• Trzeba samemu sprawdzać, czy coś się wydarzyło na dżojstiku
• Trzeba samodzielnie odświeżać stan dżojstika za pomocą funkcji SDL_JoystickUpdate()
• Marnujemy zasoby komputera, nie robiąc nic poza sprawdzaniem, czy coś nowego się nie wydarzyło

O wiele lepszym rozwiązaniem jest system oparty na Zdarzeniach (ang. Event). Jak to działa? Również możemy wykorzystać nieskończoną pętlę (chociaż możemy też sprawdzać, czy mamy jeszcze jakieś zdarzenie do obsłużenia, to nie będziemy się tym tutaj zajmować). Róznica polega jednak na tym, że w tym wypadku wywołanie funkcji SDL_WaitEvent() powoduje uśpienie programu do momentu otrzymania zdarzenia. Po otrzymaniu zdarzenia (którego źródłem może być nie tylko dżojstik, ale i np. klawiatura, ale my włączyliśmy jedynie dżojstik) za pomocą switcha obsługujemy zdarzenie – w tym wypadku jedynie ruch osi dżojstika. W podobny sposób można obsłużyć przyciski na dżojstiku, jednak jako, że urządzenie, którym dysponuję przycisków nie posiada, to tego nie zaimplementowałem.

#include <iostream>
#include <SDL/SDL.h>

int main(int argc, char **argv) {
    if (SDL_Init(SDL_INIT_EVERYTHING) == -1) {
      std::cerr << "SDL nie inicjalizuje się";
      return 1;
    }

    // Wypisujemy nazwy wszystkich dżojstików w systemie
    for (int i=0;i<SDL_NumJoysticks();i++) {
      std::cout << i << ": " << SDL_JoystickName(i) << std::endl;
    }

    // Otwieramy dżojstik
    SDL_Joystick *joy = SDL_JoystickOpen(0);

    SDL_JoystickEventState(SDL_ENABLE);

    SDL_Event event;

    while (true) {
      SDL_WaitEvent(&event);  // Czekamy na zdarzenie od dżojstika
      switch (event.type) {
        case SDL_JOYAXISMOTION:  // Ruch osią dżojstika
          std::cout << "axis: " << event.jaxis.axis
            << " val: " << event.jaxis.value << std::endl;
        default:
          break;
      }
    }

    // Zamykamy dżojstik
    if (SDL_JoystickOpened(0))
      SDL_JoystickClose(joy);
    return 0;
}

Jak widać, sprawa jest bardzo prosta – pozostaje jedynie dorobienie praktycznej funkcjonalności do naszego programu. Więcej informacji o obsłudze dżojstika można znaleźć w dokumentacji SDL, tam też znajdują się przykładowe kody źródłowe. Oczywiście, obsługę zdarzeń najlepiej byłoby wykonać na osobnym wątku, aby nasza aplikacja nie usypiała się całkowicie co chwilę, ale to również wybiega poza ramy tego, co chciałem tutaj przedstawić.

Zaśnieżona ulica Wileńska. Trzeba przyznać, że w tym roku zima nie zaskoczyła drogowców, i pługi całkiem sprawnie odśnieżały i posypywały piaskiem większość dróg w Oleśnicy.

Na rynku – budki. Nie wiem tylko, czy jarmark odbył się wczoraj (bo wczoraj też jakieś stały, i nawet ludzie się przy nich kręcili), czy też może zacznie się później.

Niektórzy dzielnie kibicują zimie w urozmaicaniu nam życia.

Parking, w przypadku którego nikt nie zadaje sobie trudu odśnieżania, zamienia się w plac zabaw dla kierowców. Nie ma tam ludzi ani aut, a sam parking jest na tyle duży, że można na nim bezpiecznie potrenować panowanie nad samochodem.

Szron na przedniej szybie samochodu, od wewnątrz. Na początku jazdy trzeba w jednej ręce trzymać skrobaczkę. Na zdjęciu widać efekt ~15-20 minut jazdy, więc trochę już stopniało. Takie są uroki starszych samochodów.

Płyn do mycia szyb, który przez zapomnienie przeleżał mrozy w schowku. Niby z alkoholem, ale producent nigdzie nie obiecuje, że płyn będzie mrozoodporny.

Mój kod oparłem na przykładowym kodzie znalezionym w internecie. Dopisałem do niego co nieco, utknąłem przy próbie wysyłania czegokolwiek – gniazdko WinSock, które próbowałem tworzyć, było błędne, a ja nie miałem czasu prowadzić dochodzenia, czemu tak się dzieje ;) Jeśli wiesz, chętnie usłyszę w komentarzach i poprawię. Na razie jednak podzielę się tym, co mam.

Kod znajduje się na samym dole, podświetliłem tam linie, o których mówię. Na początku definiujemy kilka struktur, które są potrzebne do działania windowsowym funkcjom. Na ich temat nie ma się co rozpisywać, ponieważ wszystko znajdziemy w dokumentacji Microsoftu (mała rada – jeśli zechce wam się sciągać ich przykładowy kod, to przestrzegam – i tak niewiele pomaga, przynajmniej mi nie pomógł).

Linia 62 – funkcja BluetoothFindFirstRadio robi dokładnie to, co mówi jej nazwa – znajduje pierwszy adapter w systemie i zwraca obiekt HBLUETOOTH_RADIO_FIND, będący czymś w rodzaju identyfikatora wyszukiwania adapterów. Jeśli nie ma żadnego adaptera w systemie, to funkcja zwraca null, co później sprawdzamy. W pętli zaczynającej się od linii 71 dodajemy znaleziony adapter do wektora adapterów. Do działania pętli wykorzystujemy fakt, że BluetoothFindNextRadio zwraca fałsz, jeśli nie znajdzie więcej adapterów, a jeśli znajdzie, to zwraca prawdę, a element, na który wskazuje drugi argument, zostaje wypełniony danymi o znalezionym adapterze – tak samo, jak w przypadku funkcji znajdującej pierwszy adapter.

W linii 91 ustawiamy w strukturze zawierającej konfigurację skanowania otoczenia to, którym adapterem chcemy skanować. Dalej sposób wyszukiwania urządzeń w pobliżu odbywa się w sposób analogiczny, co wyszukiwanie adapterów.

W linii 124 parujemy się z urządzeniem. Funkcja ta jest o tyle miła, że wyświetla Windowsowe okienko parowania, pytające o PIN i co tylko – tak więc nic poza tym nie musimy robić. Po zakończeniu tej funkcji telefon i komputer będzie sparowany… albo i nie. W każdym bądź razie, próbowaliśmy.

W linii 127 tworzymy nowe gniazdo WinSock, przystosowane do komunikacji poprzez Bluetooth. I tutaj zaczynają się schody – następujące po tym sprawdzanie poprawności socketa zawsze przerywa pracę programu. Tutaj właśnie leży główny błąd w moim kodzie. Kilka linijek niżej widzimy ustawianie adresu urządzenia docelowego i próbę wysyłania danych w tamtym kierunku, jednak nie miałem okazji sprawdzić, na ile to jest poprawne.

Linie 152 i 155 zamykają wyszukiwanie adapterów i urządzeń w pobliżu. Nie zapominajmy pozostawić po sobie porządku ;) Nie jestem pewien, czy nie powinno się zamykać wyszukiwania zaraz po dokonaniu owego przeszukiwania – spróbujcie, jeśli nie spowoduje to błędu, to to byłby lepszy sposób. Ja nie spróbuję, bo jestem zbyt leniwy, żeby odpalać teraz Windowsa i sprawdzać.

Aby zobaczyć źródło, kliknij poniżej na show source – uznałem, że lepiej napisać, bo średnio rzuca się w oczy.

#include "stdafx.h"

#include <Ws2bth.h>
#include <BluetoothAPIs.h>
#include <Bthsdpdef.h>
#include <stdio.h>
#include <WinSock2.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <bthdef.h>

#include <vector>

#pragma comment(lib, "Irprops.lib")

BLUETOOTH_FIND_RADIO_PARAMS m_bt_find_radio = {
  sizeof(BLUETOOTH_FIND_RADIO_PARAMS)
};

BLUETOOTH_RADIO_INFO m_bt_info = {
  sizeof(BLUETOOTH_RADIO_INFO),
  0,
};

BLUETOOTH_DEVICE_SEARCH_PARAMS m_search_params = {
  sizeof(BLUETOOTH_DEVICE_SEARCH_PARAMS),
  1,
  0,
  1,
  1,
  1,
  15,
  NULL
};

BLUETOOTH_DEVICE_INFO m_device_info = {
  sizeof(BLUETOOTH_DEVICE_INFO),
  0,
};

HANDLE m_radio = NULL;
HBLUETOOTH_RADIO_FIND m_bt = NULL;
HBLUETOOTH_DEVICE_FIND m_bt_dev = NULL;

// lista znalezionych adapterów
std::vector<HANDLE> radios;

// lista znalezionych urządzeń
std::vector<BLUETOOTH_DEVICE_INFO> devices;

int wmain(int argc, wchar_t **args) {
	unsigned int j=MAXINT; // numer urządzenia, które będziemy parować
	BLUETOOTH_DEVICE_INFO wybrane; // wybrane urządzenie, z którym chcemy się łączyć
	SOCKET sck;
	SOCKADDR_BTH sadr;
	char inc[20];

	wprintf(L"Szukanie adapterow Bluetooth...\n");

	// znajdujemy pierwszy adapter bluetooth
	m_bt = BluetoothFindFirstRadio(&m_bt_find_radio, &m_radio);

	// jeśli m_bt to null, to system nie znalazł żadnych adapterów Bluetooth.
	if (m_bt == NULL) {
		wprintf(L"Nie znaleziono adapterow Bluetooth");
		return 1;
	}

	// dodajemy znaleziony adapter do listy
	do {
		// dodajemy ten adapter do listy znalezionych adapterów
		radios.push_back(m_radio);
		// jeśli znaleźliśmy kolejny adapter, to również dodajmy go do listy
	} while (BluetoothFindNextRadio(&m_bt_find_radio, &m_radio));

	// Przestajemy szukać adapterów Bluetoot

	// wyświetlmy listę
	for (unsigned int i=0;i<radios.size();i++) {
		BluetoothGetRadioInfo(m_radio,&m_bt_info);
		wprintf(L"Adapter nr. %d:\r\n", i);
		wprintf(L"\tNazwa:\t\t%s\r\n", m_bt_info.szName);
		wprintf(L"\tMAC\t\t%02x:%02x:%02x:%02x:%02x:%02x\r\n", m_bt_info.address.rgBytes[1], m_bt_info.address.rgBytes[0], m_bt_info.address.rgBytes[2], m_bt_info.address.rgBytes[3], m_bt_info.address.rgBytes[4], m_bt_info.address.rgBytes[5]);
		wprintf(L"\tKlasa:\t\t0x%08x\r\n", m_bt_info.ulClassofDevice);
		wprintf(L"\tProducent:\t0x%04x\r\n", m_bt_info.manufacturer);
	}

	// zakładamy na razie, że wybrany został zerowy adapter
	// ustawmy więc w opcjach wyszukiwania ten właśnie adapter
	m_search_params.hRadio = radios[0];

	// zaczynamy szukać urządzeń dostępnych poprzez bluetooth
	wprintf(L"\nSzukam urzadzen widocznych poprzez Bluetooth...\n\n");
	m_bt_dev = BluetoothFindFirstDevice(&m_search_params, &m_device_info);

	//BluetoothSelectDevices(*m_search_params);

	do {
		devices.push_back(m_device_info);
	} while(BluetoothFindNextDevice(m_bt_dev,&m_device_info));

	// wyświetlmy te urządzenia
	for (unsigned int i=0;i<devices.size();i++) {
		m_device_info = devices[i];
		wprintf(L"Urzadzenie %d:\r\n", i);
		wprintf(L"\tNazwa:\t\t%s\r\n", m_device_info.szName);
		wprintf(L"\tMAC:\t\t%02x:%02x:%02x:%02x:%02x:%02x\r\n", m_device_info.Address.rgBytes[1], m_device_info.Address.rgBytes[0], m_device_info.Address.rgBytes[2], m_device_info.Address.rgBytes[3], m_device_info.Address.rgBytes[4], m_device_info.Address.rgBytes[5]);
		wprintf(L"\tKlasa:\t\t0x%08x\r\n", m_device_info.ulClassofDevice);
		wprintf(L"\tPolaczony:\t%s\r\n", m_device_info.fConnected ? L"tak" : L"nie");
		wprintf(L"\tParowany:\t%s\r\n", m_device_info.fAuthenticated ? L"tak" : L"nie");
		wprintf(L"\tPamietany:\t%s\r\n", m_device_info.fRemembered ? L"tak" : L"nie");
	}

	// wybierzmy urządzenie, z którym będziemy się parować
	do {
		printf("Z ktorym urzadzeniem parowac? (nr) ");
		scanf_s("%u",&j); // pobieramy numer urządzenia do parowania
	} while (j > devices.size());

	wybrane = devices[j];

	// parujmy urządzenia
	BluetoothAuthenticateDevice(NULL,radios[0],&wybrane,NULL,MITMProtectionNotRequired);

	// łączymy się z wybranym urządzeniem
	sck = socket(AF_BTH,SOCK_STREAM,BTHPROTO_RFCOMM);

	if (sck == INVALID_SOCKET) {
		printf("Blad przy tworzeniu gniazda");
		BluetoothFindDeviceClose(m_bt_dev);
		BluetoothFindRadioClose(m_bt);
		system("pause");
		return 2;
	}

	sadr.addressFamily = AF_BTH;
	sadr.btAddr = wybrane.Address.ullLong;

	// dokonujemy połączenia
	connect(sck,(SOCKADDR *) &sadr,sizeof(sadr));

	send(sck,OBEX_CONNECT,sizeof(OBEX_CONNECT),0);
	recv(sck,&(inc[0]),25,0);

	printf("%s",inc);

	// zamykamy gnizado
	closesocket(sck);

	// Przestajemy szukać urządzeń Bluetooth
	BluetoothFindDeviceClose(m_bt_dev);

	// Przestajemy szukać adapterów Bluetooth
	BluetoothFindRadioClose(m_bt);

	system("pause");
	return 0;
}

Instalacja

Vimwiki jest dostępny jako tzw. vimball, ja jednak preferuję zwykłe rozpakowanie archiwum w moim ~/.vim/. Pobieramy archiwum vimwiki-x.zip ze strony pobierania vimwiki i rozpakowujemy w ~/.vim/. I już po instalacji.

Konfiguracja

Domyślna konfiguracja jest dobra i teoretycznie nie trzeba nic zmieniać, ja jednak chciałem, żeby pliki z wiki były zapisywane w moim katalogu Dropboksa. Otwieramy więc plik ~/.vimrc i dodajemy następującą linię:

let g:vimwiki_list = [{'path': '~/Dropbox/wiki/', 'path_html': '~/Dropbox/Public/wiki/'}]

Co oznaczają poszczególne elementy?

• path – ścieżka do plików wiki
• path_html – ścieżka do katalogu, gdzie mają pojawić się wygenerowane pliki html

Krótki kurs vimowania

Otwieramy gvim, upewniamy sie, że jesteśmy w trybie normalnym, a nie trybie wprowadzania. Powinniśmy widzieć coś takiego. Dla porównania, vim w trybie wprowadzania wygląda w ten sposób. Różnica jest subtelna, ale ważna. W trybie normalnym wprowadzane są komendy, a w trybie wprowadzania piszemy tekst – najprawdopodobniej najwięcej czasu będziesz spędzał w trybue wprowadzania, ponieważ wtedy vim zachowuje się jak zwykły edytor tekstu. Oto, co powinieneś/powinnaś wiedzieć o zabawie w vimie:

1. Przechodzisz do trybu wpisywania naciskając klawisz i na klawiaturze. Małe i. Spowoduje to edycję tekstu od znaku, na którym obecnie znajduje się kursor. Zamiast i możesz wcisnąć a, a rozpoczniesz edycję za znakiem, na którym znajduje się kursor. Jeśli bardzo chcesz, to możesz nacisnąć duże litery – I rozpocznie edycję na początku linii, a A rozpocznie edycję na końcu linii, ale myślę, że na razie nie musisz zaprzątać sobie tym głowy.
2. Wychodzisz z trybu wprowadzania do trybu normalnego klawiszem ESC.
4. W trybie normalnym musisz znać dwie komendy: wyjście i zapisanie pliku. Komendę poprzedzasz dwukropkiem, czyli znakiem :. Tak więc, w trybie normalnym:
   • :w (jak write) zapisuje plik
   • :q (jak quit) wychodzi z programu – jeśli chcemy wyjść bez zapisywania, należy wymusić to poprzez wykrzyknik, czyli wpisać :q!

Posiadając te informacje jesteśmy już w stanie wygodnie pisać w vimie. Polecić mogę jeszcze tylko prostą sciągawkę z vima i mój plik konfiguracyjny vimrc, dzięki któremu można bez problemu używać myszki w gvimie, mieć podświetlanie składni itp.

Zaczynamy notować

Będąc w trybie normalnym wpisz \ww, aby przejść do strony głównej swojego nowego wiki. Teraz naciśnij i, aby przejść do trybu wpisywania, i piszesz. Wypróbujmy więc formatowanie owego wiki – spróbuj przepisać to, co ja poniżej:

Wynik tego kodu wygląda w ten sposób. Jeśli nie widzisz kolorowania składni, upewnij się, czy w pliku .vimrc masz wszystkie wymagane ustawienia. Kolejny raz polecam mój plik .vimrc. Po skończonej edycji zapisz plik naciskając ESC i wpisując :w, potwierdzając polecenie klawiszem Enter.

Najważniejszą funkcją w wiki są odnośniki pomiędzy stronami. My tworzymy je wpisując [[Tytuł strony]], albo po prostu wpisując coś przy użyciu CamelCase, czyli np TytułStrony. Zauważysz, że po wpisaniu takiego odnośnika zmieni kolor na czerwony. Oznacza to, że strona docelowa nie została jeszcze utworzona. Klawiszem ESC wyjdź z trybu wpisywania do trybu normalnego, najedź kursorem na odnośnik i naciśnij Enter. Bum, przeniosło Cię na nową, pustą stronę! Powpisuj coś i zapisz ją. Jak teraz wrócić do strony głównej wiki? Będąc w trybie normalnym naciśnij Backspace. Zauważysz pewnie, że kolor odnośnika zmienił się z czerwonego na inny, informując Cię, że dana strona istnieje.

Eksport wiki do HTML

Chociaż eksport do HTML jest zbędny – wszystkie nasze informacje są zapisane w wygodnych do odczytu plikach tekstowych – czasem chcielibyśmy podzielić się naszymi notatkami z innymi. W tym celu możemy skorzystać z dwóch komend generujących pliki html:

• :VimwikiAll2HTML – eksportuje wszystkie zapisane strony wiki do HTML
• :Vimwiki2HTML – eksportuje obecną stronę do HTML (pamiętaj o zapisaniu zmian!)

Pliki te są zapisywane są w katalogu, który ustawiliśmy w vimrc pod hasłem path_html.

Mam nadzieję, że ten poradnik trochę przekona was do vima. Jest to bardzo wygodny edytor tekstu, i choć na początek wydaje się dość skomplikowany, to są to tylko pozory. Szczerze mówiąc, ten wpis został napisany w vimie, ponieważ jest to po prostu o wiele wygodniejsze, niż pisanie w edytorze wbudowanym w przeglądarkę. Nie opisałem tutaj wszystkich możliwości Vimwiki, a jedynie podstawy. Można, przykładowo, za jego pomocą prowadzić dziennik.

A wy jak wykorzystujecie Vimwiki? Jeśli ten poradnik się przydał, nie zapomnij napisać w komentarzu, co tworzysz za jego pomocą!

Pościg za Daewoo Tico. Kierowca był pijany. Opinia użytkownika:

Kobieta społeczniak! po co sie ludzie wpierdalają w nie swoje sprawy!

Pijany motocyklista ucieka 220km/h przed policją. Nie ma nawet prawa jazdy.

jp na 100%! koleś umie jeździć to sobie przyświrował dla żartu, a potem się kulturalnie zatrzymał, a pijany pewnie wcale niebył nawet, tylko mu przybili:)

prze huj szacun dla goscia ….

po co go gonią debile , spokojnie by dojechał do domu i tyle.

A to tylko dwa wybrane filmiki. Pocieszam się tym, że autorami takich bzdur mogą być chyba tylko gimnazjaliści… co niestety nie znaczy, że nie mogą kierować pojazdami. Ale nic nie możemy na to poradzić.