Strona używa cookies (ciasteczek). Dowiedz się więcej o celu ich używania i zmianach ustawień. Korzystając ze strony wyrażasz zgodę na używanie cookies, zgodnie z aktualnymi ustawieniami przeglądarki.    X

Pisanie programów w GTKmm dla początkujących

Przeglądając internet, a dokładniej tę jego część, w której bywają użytkownicy Linuksa, natknąłem się na temat pisania programów okienkowych. Zauważyłem, że spora część początkujących programistów (głównie tych używających środowiska graficznego GNOME), ma spory dylemat przy wyborze biblioteki do budowy interfejsu graficznego. Z jednej strony wszyscy im polecają Qt twierdząc, że jest łatwe, napisane z myślą o C++ i posiada sporą dokumentację. Gdyby tego było mało, w internecie jest coraz więcej prostych kursów Qt w języku polskim, co jest często kluczowym argumentem. Z drugiej zaś strony, użytkownicy GNOME woleliby pisać aplikacje używając GTK+. Niestety GTK+ było pisane z myślą o C, a GTKmm prócz dokumentacji w języku angielskim, nie posiada żadnych kursów czy poradników w naszym ojczystym języku. Zapora stojąca przed GTKmm okazuje się tym większa, że na pierwszy rzut oka składnia nawet prostych programów napisanych przy użyciu tej biblioteki wydaje się o wiele bardziej skomplikowana, niż programów napisanych przy użyciu Qt. Dla tych wszystkich, których przeraża biblioteka GTKmm i odrzuca myśl o pisaniu programów w Qt korzystając ze środowiska GNOME, przygotowałem krótkie i mam nadzieję, że maksymalnie zrozumiałe dla każdego początkującego programisty, wprowadzenie do biblioteki GTKmm.

Wymagania odnośnie czytelnika

Niestety nie da się zacząć pisać własnych programów okienkowych nie znając w ogóle języka programowania. Jako, że tekst ten ma za zadanie zaprezentować bibliotekę przeznaczoną dla języka C++, konieczna jest jego znajomość. Oczywiście nie trzeba umieć wszystkiego ani mieć napisanych programów na tysiące linii kodu. Szczerze mówiąc, to wystarczy znać go po łebkach. Konieczne jest jednak rozumienie samej idei programowania oraz rozumienie tego, czym jest klasa, a czym jest obiekt tej klasy. Trzeba też wiedzieć czym są metody danej klasy oraz konstruktory. Warto znać też takie pojęcia jak wskaźnik, referencja czy przestrzeń nazw. Jeśli, przy którymś z nich czujesz, że znalazłeś się sam na pustyni, to znaczy, że próbujesz wskoczyć od razu na głęboką wodę. Oczywiście być może poradzisz sobie z napisaniem programów przedstawionych w tym kursie, jednak najważniejsze jest, by zrozumieć ich działanie. Dlatego jeśli uważasz, że Twoja znajomość C++ jest zbyt skromna lub nie znasz go wcale, to polecam świetną książkę Jerzego Grębosza pt. "Symfonia C++ Standard". Książka ta powinna rozwiać większość tajemnic, które skrywa w sobie język C++.

Oprócz podstawowej znajomości C++ niezbędny też będzie kompilator C++. Osobiście do przykładów będę używać kompilatora g++, który można łatwo zainstalować w każdej dystrybucji Linuksa. Niezbędna będzie także sama biblioteka GTKmm. Użytkownicy Debiana i najprawdopodobniej Ubuntu muszą zainstalować pakiet libgtkmm-2.4-dev. W innych dystrybucjach nazwa potrzebnego pakietu nie powinna się zbytnio różnić. Konieczny będzie także edytor tekstu z kolorowaniem składni. Ja w przykładach będę używać gedita. Wszystkie przykłady wykonywałem na dystrybucji Linuksa, więc umiejętność podstawowego poruszania się po tym systemie także może być konieczna.

r   e   k   l   a   m   a

Lekcja pierwsza - pierwszy program

Naukę GTKmm zaczniemy od napisania prostego programu, który wyświetli nam okienko z nazwą "Witaj świecie!". Jak wspomniałem wcześniej, konieczne jest rozumienie pojęć klasa, obiekt, konstruktor i metoda, gdyż wszystkie programy będziemy pisać obiektowo. Aby uzyskać nasze okienko będziemy potrzebowali trzech plików. Są to odpowiednio:

main.cpp - nasz główny plik, który uruchomi okienko
okno.h - plik, w którym znajdzie się definicja naszej klasy okno
okno.cpp - tutaj znajdzie się definicja konstruktora i destruktora naszej klasy

Zacznijmy od pliku main.cpp:

#include <gtkmm.h>
#include "okno.h"

int main(int argc, char *argv[])
{
    Gtk::Main kit(argc, argv);
    
    Okno okienko;
    
    Gtk::Main::run(okienko);

    return 0;
}

W porównaniu do "czystego" C++, pojawiło się tutaj kilka nowych elementów. Przejdźmy więc do analizy naszego pliku:

Linia 1: wczytujemy plik nagłówka biblioteki gtkmm.
Linia 2: wczytujemy plik nagłówkowy zawierający definicję naszej klasy.
Linia 4: tutaj mamy standardową definicję głównej funkcji naszego programu.
Linia 6: pierwsza nowa rzecz w naszym programie. Powołujemy tutaj do życia obiekt klasy Main o nazwie kit przekazując mu zmienne argc i argv. Konstruktor tego obiektu sprawdzi przekazane mu argumenty pod kątem standardowych opcji, które można wpisać przy wywoływaniu programu z wiersza poleceń. Każdy program napisany przy użyciu biblioteki gtkmm musi posiadać obiekt klasy Main. Klasa Main pochodzi z przestrzeni nazw Gtk czyli z naszej biblioteki gtkmm.
Linia 8: powołujemy do życia obiekt naszej klasy Okno, który nazwaliśmy sobie okienko.
Linia 10: do głównej pętli naszego programu o nazwie run przekazujemy nasz obiekt okienko. Pętla ta zapewni jego wyświetlenie na ekranie i zakończy się wraz z zamknięciem okienka. Pętla run jest statyczną metodą z klasy Main, która to znajduje się w przestrzeni nazw Gtk.
Linia 12: Zwrócenie 0 przez funkcję main.

Podsumujmy:
1) Wczytujemy bibliotekę gtkmm i definicję naszej klasy Okno.
2) Powołujemy do życia obiekt kit, który sprawdzi przekazane do programu argumenty
3) Powołujemy obiekt naszej klasy Okno o nazwie okienko
4) Przekazujemy do głównej pętli programu nasz obiekt okienko, który zostanie wyświetlony na ekranie

Przyjrzyjmy się teraz naszej klasie Okno znajdującej się w pliku okno.h:

#ifndef OKNO_H
#define OKNO_H

#include <gtkmm.h>

class Okno : public Gtk::Window
{
public:
    Okno();
    virtual ~Okno();
};

#endif // OKNO_H

Jak widać klasa jest bardzo prosta. Posiada tylko konstruktor i destruktor. Zacznijmy jednak od początku:

Linia 1 i 2: jest to strażnik, który powinien znaleźć się w pliku nagłówkowym każdej klasy. Chroni on nas przed dwukrotnym wczytaniem definicji klasy
Linia 4: linia znana z pliku main.cpp. Tak jak i tam, tak i tu wczytuje ona plik nagłówkowy biblioteki gtkmm.
Linia 6: definicja naszej klasy okno. Klasa ta dziedziczy po klasie Window z biblioteki gtkmm, dzięki czemu posiada wszystkie właściwości i metody zawarte w klasie Window. Nasza klasa Okno po prostu staje się standardowym okienkiem z Gtk, jednak będziemy mogli ją dostosować do własnych potrzeb.
Linia 9: deklaracja konstruktora naszej klasy.
Linia 10: deklaracja wirtualnego destruktora naszej klasy.
Linia 13: zakończenie strażnika

Podsumujmy:
1) Wczytujemy plik nagłówkowy biblioteki gtkmm.
2) Tworzymy nową klasę Okno, która dziedziczy właściwości i metody po klasie Window z przestrzeni nazw Gtk
3) Tworzymy deklarację konstruktora i destruktora

Ostatni plik to okno.cpp. W nim znajduje się definicja konstruktora naszej klasy okno i w nim będziemy implementować elementy i zachowanie naszego okna. Oto jego kod:

#include "okno.h"

Okno::Okno()
{
    set_title("Witaj świecie!");
}

Okno::~Okno()
{
}

Przeanalizujmy go więc:

Linia 1: tutaj następuje wczytanie pliku nagłówkowego zawierającego naszą definicję klasy, której konstruktor i destruktor zamierzamy zdefiniować.
Linia 3: tutaj rozpoczyna się definicja konstruktora klasy Okno
Linia 5: w tym miejscu wywołujemy metodę przekazując jej argument w formie tekstu "Witaj świecie". Metodę tą nasza klasa Okno odziedziczyła po klasie Window. Metoda set_title ustawi tytuł naszego okienka na podany przez nasz tekst.
Linia 8: pusta definicja destruktora klasy Okno.

Podsumujmy:
1) Wczytujemy plik nagłówkowy naszej klasy okno.
2) Definiujemy konstruktor, który wywołuje odziedziczoną metodę set_title
3) Metoda set_title ustawia tytuł okienka
4) Definiujemy pusty destruktor

Gdy już mamy wszystkie trzy pliki zapisane na dysku i mam nadzieję, że rozumiemy ich zawartość, pora na kompilację, linkowanie i uruchomienie naszego programu. Uruchamiamy konsolę naszego systemu i przechodzimy do katalogu, w którym znajduje się nasz program komendą cd np.:

$ cd /home/igor/Nauka/GTK+/WitajSwiecie

Następnie przeprowadzamy kompilację naszych plików źródłowych informując przy tym kompilator, że korzystamy z biblioteki gtkmm:

$ g++ main.cpp okno.cpp -o WitajSwiecie `pkg-config gtkmm-2.4 --libs --cflags`

Gdy nasze pliki zostaną skompilowane i nie wyskoczą żadne błędy, w katalogu pojawi się plik wykonywalny programu o nazwie WitajSwiecie. Proponuję abyśmy go teraz uruchomili klikając na niego dwa razy (lub raz, w zależne od ustawień). Powinno nam się ukazać okienko podobne do tego:

Jeśli tak jest, to znaczy, że właśnie napisałeś swój pierwszy program w GTKmm. Mam nadzieję, że nie było to aż tak ciężkie, jakby się mogło wydawać? Teraz już wystarczy do naszego okienka wstawić napisy, przyciski i pola do wpisywania danych, a następnie dodać do nich odpowiednie akcje, by nasz program zaczął żyć i wykonywać jakieś bardziej lub mniej pożyteczne zadania. Jak tego dokonać opowiem w następnych lekcjach tego poradnika. 

Komentarze