Rozdział ten stanowi wprowadzenie do C++Buildera, jednego z najczęściej używanych narzędzi do tworzenia aplikacji internetowych, bazodanowych typu desktop i klient-serwer, programowania rozproszonego itp. C++Builder łączy w sobie charakterystyczne cechy środowiska typu RAD (ang. Rapid Applications Development – błyskawiczne tworzenie aplikacji) z funkcjonalnością ANSI C++. Jest narzędziem na wskroś uniwersalnym, przydatnym zarówno dla amatorów programowania, jak i profesjonalnych zespołów projektowych.
Podstawowe informacje na temat zalet C++Buildera i korzyści wynikających z jego zastosowania znajdziesz na stronie http://www.borland.com/bcppbuilder/ w punktach „Features & Benefits” i „New C++Builder Users”.
Zaawansowani programiści mogą rozdział ten pominąć; pozostali znajdą w nim informacje o podstawowych elementach C++Buildera, a także porównanie jego istotnych cech z innymi środowiskami projektowymi i wskazówki dotyczące przenoszenia na jego grunt aplikacji z tychże środowisk.
Zainteresowani Czytelnicy znajdą tu również wprowadzenie do Kyliksa – jednego z najciekawszych produktów ostatnich lat, będącego w istocie adaptacją Delphi i C++Buildera na gruncie Linuksa. Kylix pozwala tworzyć zaawansowane aplikacje w środowisku tego zdobywającego coraz większą popularność systemu z równą łatwością, jak w środowisku Windows. Większość zagadnień dotyczących C++Buildera, omawianych w tej książce, odnosi się także do Kyliksa.
W podrozdziale tym przedstawimy podstawowe elementy C++Buildera i zilustrujemy ich zastosowanie na przykładzie prostej aplikacji.
Jeżeli już zainstalowałeś C++Buildera na swoim komputerze i chciałbyś szybko wykonać za jego pomocą coś pożytecznego – nie ma na co czekać; już za chwilę staną się dla Ciebie jasne takie pojęcia, jak: projekt, komponenty VCL, inspektor obiektów i ich rola w środowisku IDE.
Pierwotnie programiści posługiwali się narzędziami dla DOS-a, uruchamianymi z wiersza poleceń. Kiedy MS Windows zdominowały rynek systemów operacyjnych, w naturalny sposób również i rynek kompilatorów zwrócił się w stronę tego środowiska; jednym z najbardziej znanych kompilatorów C dla Windows był kompilator C++ w wersji 3.1. Nie uprościło to bynajmniej samego procesu programowania, a wręcz przeciwnie: na programiście spoczywała odpowiedzialność za całokształt komunikacji z systemem operacyjnym – obsługa komunikatów, utrzymywanie odpowiedniego wyglądu okienek itp. Nawet prosty program powodujący tylko wyświetlanie pustego okienka miał rozmiar kilkustronicowy.
Sytuacja zmieniła się nieco (na korzyść programistów) po opracowaniu przez Borland narzędzia o nazwie ObjectWindows Library (OWL). OWL, zgodne ze standardami kompilatora wersji 3.1, przejmowało na siebie większość nużących szczegółów systemowych, pozwalając programiście skupić się na istocie rozwiązywanego problemu. Zostało ono rozbudowane wraz z wprowadzeniem na rynek nowego kompilatora C++ w wersji 5.0.
Prawdziwym przełomem okazało się pojawienie Delphi, narzędzia z kategorii RAD, będącego de facto czymś na kształt „wizualnego Pascala” – jeżeli trzymać się analogii do Visual Basica czy też Visual C. Niedługo później Borland opracował analogiczne narzędzie oparte na C++, nadając mu nazwę C++Builder. Korzysta ono z tych samych bibliotek co Delphi, ponadto posiada niemal identyczny interfejs użytkownika.[1] W porównaniu z innym popularnym kompilatorem – Visual C++ – charakteryzuje się większą łatwością tworzenia aplikacji i większą przenośnością tych ostatnich pomiędzy różnymi platformami.
Niewątpliwie dobre opanowanie języka programowania (również C++) wymaga kilku lat praktyki. Narzędzia kategorii RAD – np. C++Builder – mogą jednakże uczynić tę naukę bardziej efektywną, ponadto umożliwiają tworzenie nietrywialnych aplikacji już na wczesnym etapie tej drogi, a to za sprawą obiektowych komponentów VCL, skrywających w sobie wiele skomplikowanych możliwości i uwalniających użytkownika od żmudnego programowania.
Przystąpmy więc do konkretów; pominiemy przy tym wiele szczegółów dotyczących instalacji i obsługi C++Buildera, które znaleźć można w dokumentacji, a których wyczerpujący opis wymagałby odrębnej książki. Skoncentrujemy się za to na metodologii tworzenia konkretnej aplikacji.
Po prawidłowym zainstalowaniu C++Buildera i jego uruchomieniu ukaże się zintegrowane środowisko projektowe (IDE – Integrated Development Environment) przedstawione na rysunku 1.1. Składa się ono z trzech zasadniczych okien, za pośrednictwem których możliwe jest manipulowanie kontrolkami i komponentami, ustawianie ich właściwości oraz wpisywanie kodu programu.
Paleta komponentów
Menu główne
Pasek narzędziowy
Formularz
Inspektor obiektów
Edytor kodu
Rysunek 1.1. Środowisko zintegrowane C++Buildera 5
Biblioteka komponentów (ang. VCL – Visual Component Library) stanowi magazyn komponentów wykorzystywanych do tworzenia aplikacji. Poszczególne komponenty biblioteki odpowiadają poszczególnym komponentom gotowego programu – menu, przyciskom, listom wyboru, obrazkom itp. Komponenty te skrywają w sobie znaczną część kodu, przez co programista zwolniony jest w dużej części z kodowania podstawowych funkcji programu. Poszczególne aspekty zachowania się komponentów mogą być regulowane za pomocą ich właściwości (ang. properties) dostępnych za pośrednictwem inspektora obiektów (patrz rys. 1.1), bądź bezpośrednio w kodzie programu. Oprócz wykorzystywania gotowych komponentów zaawansowany programista ma możliwość tworzenia nowych komponentów, stosownie do swych potrzeb.
Poszczególne formularze aplikacji odpowiadają poszczególnym oknom działającego programu; gdy rozpoczynasz tworzenie nowej aplikacji, wyświetlony zostaje automatycznie pusty formularz, zwany formularzem głównym – w działającym programie stanie się on jego oknem głównym. Umieszczając na formularzu komponenty VCL oraz ustalając ich położenie i rozmiary, budujemy żądany interfejs użytkownika. Oprócz komponentów wizualnych istnieją również tzw. komponenty niewidoczne – na etapie projektowania są one reprezentowane przez odpowiednie ikony, natomiast w działającym programie nie są bezpośrednio widoczne w interfejsie użytkownika, jakkolwiek spełniają zadania nie mniej ważne od komponentów wizualnych. Przykładami komponentów niewidocznych są zegary (ang. timers), służące do odmierzania ustalonych odcinków czasu.
Paski przycisków (ang. speedbars) umożliwiają szybki dostęp do najczęściej wykorzystywanych opcji menu, jak: Run (uruchomienie aplikacji), Step Through (praca krokowa), View Form (oglądanie formularza) itp. Użytkownik ma możliwość przystosowywania zawartości pasków narzędziowych do swoich potrzeb.
Jedną z niezaprzeczalnych zalet środowiska IDE jest jego konfigurowalność. Zawartość dowolnego paska narzędziowego może być łatwo zmieniana poprzez dodawanie i usuwanie przycisków – wyjątkiem w tym względzie jest paleta komponentów, nie zawierająca przycisków, lecz (zgodnie z nazwą) komponenty VCL.
C++Builder zawiera następujące paski narzędziowe:
· Standard;
· View;
· Debug;
· Custom;
· Component Palette (paleta komponentów).
Aby zmienić zawartość dowolnego paska narzędziowego, wykonaj kolejno następujące czynności:
Rysunek 1.2. Okno dialogowe konfiguracji paska narzędziowego
Paleta komponentów, znajdująca się bezpośrednio pod menu głównym, stanowi zasobnik komponentów VCL. Komponenty te zorganizowane są w strony, odpowiadające poszczególnym kategoriom. Aby przenieść komponent na formularz, należy kliknąć jego ikonę w palecie komponentów, a następnie kliknąć w miejscu, w którym ma się on docelowo znaleźć. Jak już wcześniej wspomniano, wygląd i szczegóły funkcjonowania komponentów mogą być regulowane za pomocą właściwości, dostępnych za pośrednictwem inspektora obiektów lub bezpośrednio w kodzie programu.
Tym, co decyduje o dynamice działającego programu, są zdarzenia (ang. events). Aby wyjaśnić ich istotę, zbudujemy prostą aplikację w postaci pojedynczego przycisku na formularzu (rys. 1.3). Przyciski są niezwykle często spotykanymi elementami interfejsu użytkownika, który za ich pośrednictwem poleca aplikacji wykonanie określonych czynności.
Komponent odpowiadający przyciskowi umieszczony jest w palecie na stronie Standard pod nazwą Button; jego ikona przedstawia przycisk z napisem OK. Aby przenieść ów komponent na formularz, należy kliknąć najpierw tę ikonę, a następnie odpowiednie miejsce formularza.
Rysunek 1.3. Prosta aplikacja – pojedynczy przycisk na formularzu
Tak przygotowaną aplikację można już skompilować i uruchomić, lecz nie okaże się ona szczególnie użyteczna: klikanie w przycisk nie będzie powodowało żadnych widocznych efektów. Dzieje się tak dlatego, iż zdarzenie generowane w wyniku kliknięcia przycisku nie jest w żaden sposób obsługiwane. Darujmy sobie w tym momencie ścisłą definicję „zdarzenia”; na użytek tworzonej aplikacji można przyjąć, iż w wyniku wystąpienia zdarzenia wywoływana jest odpowiednia funkcja, zwana funkcją obsługi zdarzenia (ang. event handler). Aby przypisać funkcję obsługującą kliknięcie przycisku, zakończmy uruchomioną aplikację, powracając do etapu projektowania i kliknijmy ów przycisk dwukrotnie (lewym przyciskiem myszy); C++Builder wyświetli wówczas fragment kodu aplikacji z wygenerowanym szkieletem odpowiedniej funkcji obsługi:
void __fastcall TForm1::Button1Click(Tobject *Sender)
{
}
Ten sam efekt można wywołać, wybierając komponent Button1 w inspektorze obiektów, przechodząc na stronę Events i klikając dwukrotnie pozycję odpowiadającą zdarzeniu OnClick. Jak łatwo zauważyć, nazwa funkcji składa się z nazwy odpowiedniego komponentu (Button1) i nazwy zdarzenia (Click).
Po kliknięciu prawym przyciskiem myszy okna edytora kodu i wybraniu z menu kontekstowego pozycji Open Source/Header File C++Builder wyświetli następujący kod:
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
class TForm1 : public TForm
__published: // IDE-managed Components
TButton *Button1;
void __fastcall Button1Click(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TForm1(TComponent* Owner);
};
extern PACKAGE TForm1 *Form1;
#endif
Powyższy kod generowany jest automatycznie i jego szczegóły nie są w tej chwili szczególnie istotne; zamieściliśmy go tutaj raczej w celu pokazania, w jak dużym stopniu C++Builder potrafi wyręczyć programistę. Powróćmy jednak do naszej funkcji obsługi, obecnie jeszcze pustej. Sprawmy, by kliknięcie przycisku na formularzu powodowało zakończenie działania programu – w tym celu kliknijmy w oknie edytora kodu zakładkę Unit1.cpp i uzupełnijmy rzeczoną funkcję obsługi następująco:
ShowMessage("Witam!To jest aplikacja testowa. Naciśnij OK");
Close();
Teraz należy skompilować i uruchomić aplikację – można to zrobić na jeden z trzech sposobów:
· naciskając klawisz F9;
· wybierając opcję Run z menu Run;
· klikając przycisk (na pasku narzędziowym) w kształcie zielonego trójkącika.
Kliknięcie przycisku na formularzu w uruchomionym programie spowoduje teraz wywołanie funkcji TForm1::Button1Click, której treść jest raczej intuicyjnie jasna nawet dla początkującego programisty: otóż najpierw wyświetlone zostanie okienko ze standardowym komunikatem (polecenie „Naciśnij OK.” odnosi się do przycisku w tymże oknie, nie do naszego przycisku na formularzu – przyp. tłum.), po którego zamknięciu wywołana zostanie metoda Close() naszego formularza głównego, zamykająca ów formularz i tym samym kończąca wykonanie programu.
Pokażemy teraz, jak łatwo jest zbudować niewielkim wysiłkiem całkiem przyzwoity program – oczywiście jeżeli ma się pod ręką C++Buildera. Wybierz z menu głównego opcję File|New Application; C++Builder stworzy nowy projekt i wyświetli pusty formularz główny.
Przejdź na stronę Additional w palecie komponentów i kliknij komponent Image (rys. 1.4):
Image
Rysunek 1.4. Komponent Image
Kliknij następnie formularz – komponent Image zaprezentuje się w postaci czarnej ramki. Przejdź do inspektora obiektów, znajdź właściwość Stretch i ustaw ją na true.
Następnie przejdź na stronę Dialogs palety komponentów (być może konieczne okaże się przewinięcie palety w lewo) i kliknij najpierw komponent OpenDialog (rys. 1.5), a następnie kliknij w pobliżu lewego górnego narożnika formularza, gdzie powinna pojawić się ikona tego komponentu.
OpenDialog
Rysunek 1.5. Komponent OpenDialog
W inspektorze obiektów, wskazującym komponent OpenDialog1, znajdź właściwość Filter i wpisz w jej pole wartości następujący tekst:
Bitmapy|*.BMP
W ten oto sposób stworzyłeś komponent dialogowy, za pomocą którego będzie możliwy wybór plików z rozszerzeniem .BMP.
Kolej teraz na dwa przyciski, z których pierwszy inicjował będzie akcję wczytywania pliku, drugi natomiast posłuży do zakończenia pracy aplikacji. Komponent przycisku Button znajduje się w palecie na stronie Standard (rys. 1.6); w czasie jego klikania przytrzymaj klawisz Shift – spowoduje to, iż komponent pozostanie zaznaczony i każdorazowe kliknięcie w obszarze formularza powodować będzie umieszczenie na nim kolejnego przycisku, do czasu kliknięcia w białą strzałkę na początku palety. Dla naszej aplikacji potrzebne są dwa przyciski – C++Builder automatycznie nada im nazwy Button1 i Button2.
Button
Rysunek 1.6. Komponent Button
Wypadałoby nadać pierwszemu z przycisków tytuł adekwatny do roli, jaką ma on pełnić w aplikacji – w tym celu kliknij go, a następnie w inspektorze obiektów przypisz właściwości Caption napis Wczytaj.
Kolejnym komponentem naszej aplikacji będzie pasek statusu, na którym wyświetlana będzie nazwa wczytanego ostatnio pliku. Przejdź do strony Win32 w palecie komponentów i kliknij komponent StatusBar (rys. 1.7); gdy klikniesz formularz, pasek stanu automatycznie usadowi się przy jego dolnej krawędzi.
StatusBar
Rysunek 1.7. Komponent StatusBar
Używając inspektora obiektów ustaw właściwość SimplePanel paska StatusBar1 na true.
Należy teraz sprawić, by przycisk opatrzony tytułem „Wczytaj” istotnie powodował wczytanie pliku bitmapy; jak zapewne pamiętasz, jest to kwestia właściwego obsłużenia generowanego przez ów przycisk zdarzenia OnClick. Kliknij go dwukrotnie i uzupełnij wyświetlony szkielet funkcji zdarzeniowej do następującej postaci:
void __fastcall TForm1::Button1Click(TObject *Sender)
if (OpenDialog1->Execute())
Image1->Picture->LoadFromFile(OpenDialog1->FileName);
StatusBar1->SimpleText = OpenDialog1->FileName;
Wyświetlone okno edytora kodu przysłoniło formularz, ale to żaden kłopot – za pomocą klawisza F12 można łatwo przełączać się pomiędzy formularzem i odpowiadającym mu modułem kodu źródłowego; można w tym celu użyć również stosownego przycisku na pasku narzędziowym (rys. 1.8).
Rysunek 1.8. Przycisk przełączający pomiędzy edytorem kodu a f...
grzegorj