Kurs Visual Basic

Kurs Visual Basic

RODZIAŁ I – Czym jest Visual Basic? Pierwsze uruchomienie. Pierwsza aplikacja.

Wielu młodych ludzi chciałoby nauczyć się samodzielnie tworzyć ciekawe programy komputerowe. Często

jednak nawet nie próbują nauczyć się programować, sądząc, że jest to czynność bardzo skomplikowana. To
nieprawda. W trakcie kursu napiszemy dwie proste, ale atrakcyjne aplikacje. Będzie to praktyczny program do
obliczania odsetek bankowych oraz przeglądarka plików graficznych. Przekonamy się też, że najprostszą aplikację
stworzymy za pomocą zaledwie kilku, może kilkunastu kliknięć myszą! Jak to jest możliwe? Przecież na ci dzień
słyszymy o tysiącach czy setkach tysięcy linii

kodu

, nad którymi pracują duże grupy programistów. Odpowiedź jest

prosta. Istnieją specjalne narzędzia do tworzenia programów komputerowych. Zawierają one gotowe elementy, takie
jak

przyciski

pola edycyjne

, menu i tym podobne, z których budujemy nasz program. Można porównać ten proces

do składania aplikacji z klocków. Jednym z takich narzędzi jest Visual Basic stworzony przez firmę Microsoft.
Nauczymy się szybko i sprawnie tworzyć aplikacje komputerowe. Przekonamy się, że programowanie jest prostsze,
niż nam dotychczas się wydawało.

Pierwsze uruchomienie!

Aby rozpocząć przygodę z programowaniem, musimy na komputerze zainstalować program Visual Basic. Na

szczęście proces instalacji jest prosty i wygląda tak, jak w wypadku każdej innej aplikacji. Nie ma więc potrzeby
dokładnego opisywania go. Po instalacji możemy przystąpić do pierwszego uruchomienia. Z menu Start

Start

wybieramy

pozycję Microsoft Visual Basic 6.0

Microsoft Visual Basic 6.0

. Pojawia się okno z wieloma ikonkami. Umożliwia ono wybranie typu

projektu

, który chcemy utworzyć. Visual Basic jest bardzo wszechstronnym narzędziem i jak widać, mamy bardzo

wiele możliwości. My nauczymy się pisać typowe aplikacje, zatem wybieramy Standard EXE

Standard EXE

i klikamy na Otwórz

Otwórz

Teraz dopiero widzimy właściwe okno, służące do projektowania aplikacji. Mnogość elementów może przyprawić o
zawrót głowy. Nie martwmy się jednak, bardzo szybko nauczymy się nimi sprawnie posługiwać. Przekonamy się, że
ten z pozoru skomplikowany układ jest bardzo funkcjonalny i ułatwia posługiwanie się całym pakietem. Zapoznajmy
się zatem z poszczególnymi składnikami.

W centralnej części ekranu znajduje się tak zwana

formatka A

. Będzie to główne okno aplikacji. Na niej

będziemy umieszczać takie elementy, jak przyciski,

etykiety

czy menu. Po lewej stronie widzimy pasek B

. Zawiera on

typowe elementy, z których będziemy budować program.
Elementy te nazywamy

kontrolkami

lub

komponentami

Po stronie prawej widzimy trzy okna. Okno C

pokazuje

części składowe projektu i zależności między nimi. D

okno właściwości obiektów. Tu możemy zdefiniować na
przykład napis, jaki będzie się znajdował na pasku tytułu
tworzonej aplikacji lub ustalić kolor tekstu znajdującego się
na etykiecie. Okno E

pozwala umieścić okno tworzonej

aplikacji w dowolnym miejscu ekranu. Na samej górze F

Zbiór instrukcji i rozkazów dla komputera. Kodem nazywamy zarówno instrukcje pisane przez programistów w jednym z języków

programowania, jak również ciągi zer i jedynek rozumiane przez procesor komputera.

Tak określa się wyróżnione prostokąty z napisami lub symbolami, które często spotykamy w programach Windows. Jeżeli klikniemy na

wybrany przycisk Windows, system wykona odpowiednią czynność, na przykład wyświetli okno dialogowe, rozwinie menu.

Elementy systemu Windows, pozwalające użytkownikowi na wprowadzenie różnych danych, najczęściej napisów.

Dokument wraz z jego modułami. Opisuje wygląd i zachowanie aplikacji.

Etykieta zawiera napis, który zostanie następnie wyświetlony w określonym miejscu formularza.

Inna nazwa komponentu. W Visual Basicu częściej mówi się o kontrolkach, w innych językach programowania o komponentach.

Terminy te można jednak stosować zamiennie. Termin komponent lepiej też odzwierciedla pełnione przez te obiekty funkcje, są
to bowiem elementy składowe aplikacji.

Część składowa Visual Basica, odzwierciedlająca element interfejsu Windows. Może to być przycisk, etykieta tekstowa, menu itp.

Komponenty układamy na formatce, budując w ten sposób aplikację.

znajduje się typowe menu oraz pasek narzędziowy. Zawiera on ikony symbolizujące często wykonywane funkcje,
takie jak Zapisz czy Kopiuj.

Czym są języki programowania?

Procesor komputera rozumie tylko ciągi zer i jedynek, które układają się w sterujące nim rozkazy. Dla człowieka,
co każdy chyba przyzna, jest to bardzo niepraktyczny sposób komunikacji. Dlatego też wymyślone zostały języki
programowania.
Umożliwiają one komunikację między człowiekiem, a komputerem. Każdy, kto interesuje się informatyką, z
pewnością słyszał o Basicu, Pascalu, Javie, C C++. To właśnie nazwy języków programowania.
Skoro jednak programowanie stało się bardziej zrozumiałe dla człowieka, jednocześnie musiało stać się mniej
zrozumiałe dla komputera. Tak jest faktycznie. Komputer nie jest w stanie bezpośrednio zrozumieć programu
zapisanego w jednym z języków. Program musi zostać najpierw przetłumaczony na wewnętrzny kod procesora.
Proces ten nazywamy kompilacją, a aplikację, która tego dokonuje – kompilatorem. Fragment programu napisany
w Visual Basicu może wyglądać na przykład następująco:

j = 0

For i = 0 To 9

j = j + i

Next i

Ten sam fragment po przetłumaczeniu na

kod maszynowy

procesora x86 ma postać:

01010101 10001011 11101100 10000011

11101100 00000010 11000111 01000110

11111110 00000000 00000000 11111111

01000110 11111110 10000011 01111110

11111110 00001001 00111110 11110111

00110011 11000000 11001001 11000011

Pierwsza aplikacja

Tylko kilka kliknięć i prawdziwy program gotowy

Skoro znamy już znaczenie poszczególnych elementów interfejsu Visual Basica, możemy zająć się pisaniem

pierwszej aplikacji. Jedynym zadaniem naszego programu będzie wyświetlenie na ekranie napisu, na przykład: Moja
pierwsza aplikacja. Zabierzmy się zatem do pracy. Przekonamy się, jak szybko można stworzyć własny program.

Wokół

formatki

widzimy małe kwadraty. Pozwalają one zamieniać rozmiar okna. Przeskalujmy je zatem w

poziomie, inaczej bowiem mógłby się nie zmieścić napis, który mamy zamiar dodać. Chwytamy za kwadrat i
przeciągamy całość w prawo.

Formatka nie mieści się w oknie, musimy je zatem również przeskalować. Robimy, to w taki sam sposób, w

jaki zmienia się rozmiar każdego okna w Windows – chwytając za bok i przeciągając, aż do uzyskania
pożądanego rozmiaru. To proste zadanie, które nikomu nie powinno sprawić kłopotu.

Pora dodać do aplikacji napis. Na znajdującej się po lewej stronie

palecie komponentów

klikamy na

ikonkę z literą A. Zostanie ona wyróżniona.

Na formatce możemy narysować teraz prostokątny kształt.

Po zwolnieniu przycisku myszy widzimy napis Label1

Label1

. W ten sposób dodaliśmy do naszej aplikacji tak zwaną

etykietę tekstową (ang. text label). Jest to element (kontrolka) Visual Basica, pozwalający na umieszczenie w oknie
aplikacji dowolnego, krótkiego tekstu.

Jedyny język, który może zrozumieć procesor komputera – bity danych (ciągi zer i jedynek). Kod maszynowy powstaje podczas

kompilacji kodu źródłowego i jest zachowany w postaci pliku, który może następnie zostać uruchomiony. Procesory różniące się
architekturą posługują się innymi językami maszynowymi, które nie są ze sobą kompatybilne, a więc na każdy taki procesor należy
wykonać oddzielną kompilację programu.

Element Visual Basica, który po uruchomieniu programu stanie się jednym z jego okien. Jest to element główny, który zawiera w sobie inne

komponenty, takie jak menu i pola tekstowe.

Jedno z okien Visual Basica, zawierające ikony, które symbolizują najczęściej używane komponenty. Umożliwia ono szybki wybór

wybranego elementu i umieszczenie go na formatce. Jest to jedno z najczęściej używanych okien.

Zauważmy, że na etykiecie znajduje się już domyślny napis. Musimy go oczywiście zmienić na nasz własny. Zatem

w oknie po prawej stronie ekranu odszukujemy

właściwości

Napis obok jest taki sam, jak na etykiecie. Na pewno jesteśmy więc w dobrym miejscu. Zmieniamy tekst na

Moja pierwsza aplikacja

Zauważmy, że jednocześnie zmienił się napis na etykiecie, a przecież o to właśnie nam chodziło!

Na pewno jednak nie jesteśmy w pełni usatysfakcjonowani. Napis jest przecież zbyt mały w stosunku do etykiety.

Postarajmy się to zmienić. W oknie odszukujemy właściwość Font

Font

. Klikamy na napis obok. Pojawia się wtedy

dodatkowy przycisk, klikamy na przycisk z małą kreską.

Widzimy standardowe okno Windows służące do ustalenia kroju czcionki. Wybieramy czcionkę Arial o wielkości

28 punktów.

Uruchamiamy program. W tym celu z menu Run

Run

wybieramy pozycję Start

Start

lub wciskamy klawisz F5. aplikacja

działa poprawnie. Jest to prawdziwy, działający w środowisku Windows program. Zauważmy, że okno ma typowe
przyciski służące do minimalizacji, maksymalizacji i zamykania oraz standardowe menu systemowe.

Właściwości obiektów

Do zmiany kroju czcionki oraz napisu na etykiecie używaliśmy okna Properties

Properties

. Okno to pozwala

modyfikować wygląd i zachowanie komponentów, takich jak formatki, etykiety tekstowe, przyciski itp. Widzimy tu
dwie kolumny. Pierwsza zawiera nazwy właściwości, druga wartości im przypisane. Przykładowo, aby zmienić napis
na etykiecie, odszukiwaliśmy w pierwszej kolumnie właściwość Caption

Caption

i zmienialiśmy jej wartość w kolumnie

drugiej na Moja pierwsza aplikacja

Moja pierwsza aplikacja

. Popracujemy więc jeszcze chwilę nad naszą aplikacją zmienimy kolor napisu

oraz tekst na pasku tytułu okna.

Klikamy na etykietę tekstową. W oknie odszukujemy właściwość ForeColor

ForeColor

. Klikamy na na przycisk z małą

strzałką.

Otwiera się nowe okienko, pozwalające na wybór koloru. Klikamy na zakładkę Palette

Palette

i wybieramy

odpowiadający nam kolor, na przykład czerwony.

Czas zmienić tekst na pasku tytułu okna naszej aplikacji. W tym celu w oknie właściwości obiektów musimy

przełączyć się na obiekt Form1

Form1

. Klikamy na przycisk z małą strzałką w dół i z listy rozwijalnej wybieramy Label1

Label1

Label

Odszukujemy właściwość Caption

Caption

i zmieniamy jej wartość na Moja aplikacja

Moja aplikacja

Zauważmy, że jednocześnie zmienił się napis na pasku tytułu formatki.

Ponownie uruchamiamy aplikację, z menu Run

Run

wybierając pozycję Start

Start

. Widzimy, że napis faktycznie zmienił

kolor na czerwony, a na pasku tytułu widnieje wpisany przez nas tekst.

Zapisywanie projektu

Czas zapisać nasz projekt na dysku. Nie chcielibyśmy przecież stracić naszej pierwszej aplikacji.

Po zamknięciu aplikacji z menu File

File

wybieramy Save Project

Save Project

. W oknie służącym do wyboru nazwy katalogu i

pliku Visual Basic proponuje nazwę Form1.frm

Form1.frm

. Pozostawiamy ją bez zmian, katalog możemy natomiast wybrać

dowolnie. Klikamy na Zapisz

Zapisz

Niespodzianka. Program znowu proponuje zapis pliku. Nie zmieniamy jego nazwy i zapiszmy go w tym samym

katalogu, co poprzedni plik. Co się zatem stało? Dlaczego zapisywaliśmy projekt aż dwa razy? Wyjaśnienie jest
proste. Za pierwszym razem zapisaliśmy plik opisujący wygląd formatki (rozmiar, położenie na ekranie, napis na
pasku tytułu, opis etykiety tekstowej) i nadaliśmy mu nazwę Form1.frm. W punkcie drugim natomiast zapisaliśmy

Cecha komponentu. Opisuje ona jego wygląd lub funkcje. Właściwościami etykiety tekstowej są na przykład: kolor tekstu, rodzaj czcionki

oraz znajdujący się na niej napis. Każdy komponent ma własny zestaw właściwości.

plik konfiguracyjny dla całego projektu – Project1.vbp. To w tym pliku Visual Basic zapisuje informacje, na przykład
jakie i ile plików zawiera projekt oraz wiele innych opcji. Tak naprawdę bowiem na dysku zostało zapisane więcej
plików niż mogłoby się nam wydawać. Zajrzyjmy na chwilę do katalogu, gdzie zapisaliśmy projekt. Zobaczymy tam
aż cztery pliki. Wszystkie one są niezbędne do tego, abyśmy mogli pracować nad aplikacją. Od razu nasuwa się
pytanie, gdzie jest plik z rozszerzeniem .exe? Jest on przecież niezbędny, abyśmy mogli uruchamiać naszą aplikację.
Odpowiedź może z pozoru wydawać się dziwna, ale takiego pliku po prostu jeszcze nie ma. Dlaczego? Dlatego, że
nie kazaliśmy go wygenerować. Naprawmy zatem to niedopatrzenie.

Z meu File

File

wybieramy pozycję Make Project1.exe

Make Project1.exe

. Na ekranie ukazuje się okno.

Mamy możliwość wyboru nazwy pliku docelowego oraz katalogu, w którym ma on zostać zapisany. Nazwę

możemy pozostawić bez zmian, wybieramy natomiast katalog wskazany w punkcie 1

. Klikamy na OK

Zajrzyjmy teraz do katalogu, który wybraliśmy przed chwilą. Pojawi się tam plik o nazwie Project1.exe

Project1.exe

. Możemy

go teraz bez problemu uruchomić z poziomu systemu operacyjnego – to właśnie nasza aplikacja.

Czym są języki programowania?

Do pakietu Visual Basic 6 powstało kilka dodatków Service Pack. Zawierają one poprawki i uaktualnienia do tego
produktu. Najnowsza wersja Service Pack ma numer 5 można ją pobrać z witryny producenta pakietu – firmy
Microsoft. W tym celu należy połączyć się z adresem

http://msdn.microsoft.com/vbasic/

, a następnie wybrać

zakładkę Downloads

Downloads

i Software Updates

Software Updates

. W kolejnym oknie wybieramy Visual Basic 6.0

Visual Basic 6.0

oraz Visual basic 6.0

Visual basic 6.0

Service Pack 5

. Klikamy na Download Now

Download Now

. Na kolejnej stronie wybieramy English

English

i klikamy na GO

. W ten

sposób dotarliśmy do strony, z której możemy bezpośrednio pobrać pliki. Pełny plik instalacyjny zajmuje około 56
MB. Jeśli dysponujemy modemem o prędkości 56 Kbit/s, ściąganie zajmie nam ponad dwie godziny. Na szczęście
dodatek można pobrać również w postaci kilku plików o mniejszej objętości. Dzięki temu, jeśli połączenie zostanie
przerwane w trakcie transmisji jednego z plików, nie będziemy musieli ponownie ściągać całości. Po uruchomieniu
pliku z dodatkiem zostaniemy poproszeni o podanie, do którego katalogu zostaną rozpakowane pliki tymczasowe.
Po kliknięciu na OK

. rozpoczyna się procedura dekompresji. Kiedy zostanie zakończona, należy przejść do

katalogu, który określiliśmy przed chwilą, i uruchomić plik Setupsp5.exe

Setupsp5.exe

. Procedura instalacji dodatku przebiega

tak samo jak w wypadku każdego innego programu dla Windows.

RODZIAŁ II – Programowanie sterowane zdarzeniami. Zmienne i instrukcje. Pola

tekstowe, przyciski. Aplikacja do obliczania odsetek (projekt).

W poprzednim odcinku kursu poznaliśmy narzędzie do programowania – Visual Basic. Teraz nadszedł czas

na praktykę. Programowania najlepiej uczyć się na konkretnych przykładach. Dlatego dowiemy się, jak napisać
aplikację, obliczającą odsetki od lokaty bankowej. Najpierw poznamy kilka konstrukcji programistycznych oraz
dowiemy się, na czym polega programowanie sterowane

zdarzeniami

. Termin ten może się wydawać bardzo

skomplikowany, ale tak naprawdę nie kryje w sobie nic trudnego. Zdarzeniem nazywamy wykonanie czynności, na
przykład wybieranie pozycji z menu. Jako programiści możemy kazać pecetowi wykonać określoną operację, kiedy
pojawi się dane zdarzenie, na przykład sprawdzić, by po kliknięciu na przycisk wyświetlał się napis.

Uruchamiamy Visual Basic. Z menu Start wybieramy pozycję Microsoft Visual Basic 6.0

Microsoft Visual Basic 6.0

. w oknie New

New

wybieramy Standard EXE

Standard EXE

i klikamy na Otwórz

Otwórz

Na palecie komponentów odszukujemy komponent z małym prostokątem w środku i klikamy na niego. Zostanie on

wtedy zaznaczony.

Rysujemy na formatce przycisk.

Klikamy dwukrotnie na przycisk Command1

Command1

. W ten sposób informujemy Visual Basic, że chcemy przypisać do

zdarzenia o nazwie Click pewną czynność. Dlatego też otwiera się okno kodu umożliwiającego wpisywanie

instrukcji

programu.

Wpisujemy następujący tekst:

Private Sub Command1_Click()

MsgBox (“To działa!”)

End Sub

Jest to instrukcja powodująca wyświetlenie na ekranie napisu To działa! Zostanie ona wykonana, kiedy użytkownik
kliknie myszą na przycisk. Wskazuje na to sama nazwa zdarzenia – Click. Wpisana przed chwilą instrukcja powoduje
wywołanie dostępnej standardowo w Visual Basicu

funkcji

o nazwie MsgBox. Jako

parametr

przyjmuje ona ciąg

znaków (napis), jaki ma zostać wyświetlony na ekranie. Parametr to inaczej dane, których funkcja potrzebuje do
prawidłowego działania. Parametry funkcji wpisujemy w nawiasach okrągłych zaraz po jej nazwie. Zauważmy, że
jeżeli parametrem tym jest ciąg znaków, koniecznie należy ująć go w znaki cudzysłowu:
MsgBox („To działa!”)

MsgBox („To działa!”)

. Nie wolno o tym zapomnieć, gdyż inaczej program nie będzie działał.

Instrukcje i funkcje

Instrukcja jest to element języka programowania oznaczający wykonanie pewnej czynności, na przykład przypisanie
wartości zmiennej, wywołanie funkcji wyświetlającej na ekranie komunikat i tym podobne. Funkcje są to natomiast
grupy instrukcji realizujących pewne zadanie. Taką grupę instrukcji możemy napisać sami. Często korzystamy
jednak z przygotowanych przez twórców Visual Basica gotowych konstrukcji. Jedną z nich jest użyta przez nas
funkcja MsgBox, powodująca wyświetlenie okna dialogowego z napisem. Aby skorzystać z gotowej funkcji, należy
ją wywołać, to znaczy podać jej nazwę oraz parametry. W naszym przykładzie takim parametrem był ciąg znaków.
Inaczej mówiąc, wywołanie funkcji oznacza wykonanie zawartego w niej kodu. Zauważmy, jak bardzo zagłębiają
się pojęcia: instrukcje, funkcje i zdarzenia. Otóż kod jest to przypisana do zdarzenia Click instrukcja, powodująca
wywołanie funkcji o nazwie MsgBox.

W potocznym znaczeniu zdarzeniem może być dowolna czynność – wyłącznie dzwoniącego budzika albo spotkanie się dwóch osób.

Podobnie jest w programowaniu. Zdarzeniem nazywamy czynność użytkownika aplikacji, na przykład kliknięcie na przycisk.

Element języka programowania oznaczający wykonanie pewnej czynności. Instrukcją może być na przykład polecenie wyświetlenia na

ekranie okna dialogowego z napisem. Program komputerowy składa się z wielu instrukcji.

Wydzielony fragment programu komputerowego, przeznaczony do wykonania specjalizowanego zadania i zwrócenia jakiegoś wyniku.

Każda funkcja składa się z jednej lub wielu instrukcji.

Parametr funkcji to inaczej dane, które potrzebuje ona do prawidłowego działania. Jeśli na przykład jest to funkcja, której zadaniem jest

wyświetlenie na ekranie napisu, to parametrem dla niej jest właśnie ten napis. Uwaga! Czasem parametrem nazywa się także właściwość
jakiegoś obiektu określającą jego zachowanie czy wygląd. Nie jest to jednak określenie prawidłowe.

Uruchamiamy program, wybierając z menu Run

Run

polecenie Start

Start

. Na ekranie widzimy okno napisanej przez nas

aplikacji. Klikamy na przycisk Command1

Command1

Pojawia się nowe okienko z wpisanym przez nas w punkcie 5

napisem. Możemy sobie pogratulować – napisaliśmy

pierwszy program kierowany zdarzeniami!

Zamykamy okno działającego programu, klikając na przycisk ze znakiem X

. Następnie z menu File

File

wybieramy

pozycję Save Project

Save Project

. Plikowi z formatką nadajemy nazwę formatka1.frm

formatka1.frm

. Pamiętamy oczywiście o wybraniu

odpowiedniego katalogu! Klikamy na Zapisz

Zapisz

Plik nazywamy Projekt1.vbp

Projekt1.vbp

. Klikamy na Zapisz

Zapisz

Podpowiedzi Visual Basica

Kiedy wpisujemy instrukcje w okno kodu, Visual Basic pomaga nam, wyświetlając żółte okienko zawierające dane
używanej przez nas funkcji. Pojawia się ono w momencie rozpoznania przez program instrukcji, czyli na przykład
po wpisaniu MsgBox i wciśnięciu klawisza spacji. Dla początkującego użytkownika taka podpowiedź może być
jednak zupełnie niezrozumiała – okienko z danymi bardziej wtedy przeszkadza niż pomaga. Na szczęście istnieje
możliwość wyłączenia tej funkcji. W tym celu z menu Tools

Tools

wybieramy Options

Options

. Na ekranie pokazuje się okno

dialogowe. Usuwamy zaznaczenie z pozycji Auto Quick Info

Auto Quick Info

. Od tej chwili Visual Basic nie będzie już nam

podpowiadał.

Zmienne

Z programowaniem nieodłącznie związane jest pojęcie

zmiennej

. Czym jest zmienna? Otóż jest to miejsce

w programie, które pozwala nam na przechowywanie danych. Inaczej, jest to miejsce w pamięci komputera, w
którym przechowujemy potrzebne nam informacje. Czemu nazywamy tę konstrukcję zmienną? Zapewne dlatego, że
jej zawartość może zmieniać się w trakcie działania programu.

Każda zmienna ma swój

typ

, który określa, jakie dane może ona przechowywać. To proste. Jeśli chcemy

przechowywać liczby całkowite, musimy użyć zmiennej o typie pozwalającym na przypisanie jej liczb całkowitych.
Typy zmiennych, jakie oferuje nam Visual Basic, zostały przedstawione w ramce:

Typy zmiennych

Zmienne przechowujące wartości liczbowe

Nazwa typu

Rodzaj danych

Zakres

Byte
Integer
Long
Single
Double
Currency

Liczby całkowite
Liczby całkowite
Liczby całkowite
Liczby zmiennoprzecinkowe
Liczby zmiennoprzecinkowe
Liczby pieniężne

Od 0 do 255
Od –32 768 do 32 767
Od –2 147 483 648 do 2 147 483 647
Od 1,401298*10

-45

do 3,402823*10

Od 4,94065645841247*10

-324

do 1,79769313486231*10

308

Od –922 337 203 685 477,5808 do 922 337 203685 477,5807

Pozostałe zmienne

Nazwa typu

Rodzaj danych

String
Boolean
Date
Variant

Ciąg znaków (napisy)
Może przyjmować tylko dwie wartości True (prawda) i False (fałsz)
Data
Może przechowywać dane dowolnego typu

Każdą zmienną przed użyciem należy zadeklarować. Deklaracja polega na podaniu nazwy zmiennej, która

będzie jej identyfikatorem, oraz typu zmiennej, który mówi nam, jakiego rodzaju dane będzie ona przechowywać.

W języku programowania oznacza słowo, pod którym kryje się jakaś wartość. Wartość ta może się zmieniać, stąd nazwa – zmienna. Na

zmiennych zawierających liczby można wykonywać dowolne operacje arytmetyczne, na przykłada dodawać je do siebie lub mnożyć

Każda zmienna ma swój typ, który określa, jakiego rodzaju wartości może ona zapamiętywać. Na przykład zmienna o nazwie numer typu

całkowitoliczbowego może przechowywać wyłącznie liczby całkowite. Nie mogłaby ona natomiast przyjąć wartości będącej ułamkiem.

Wszystko to należy poprzedzić

słowem kluczowym

Dim

. Zobaczymy teraz zatem, w jaki sposób wykorzystuje się

zmienne w programie.

Powracamy do pracy w Visual Basikiem. Zapewne wciąż mamy otwarte okno kodu. Jeśli nie, z menu Windows

Windows

wybieramy pozycję Project1 – Form1 (Code)

Project1 – Form1 (Code)

Wpisujemy następujący ciąg znaków i wciskamy klawisz spacji:

Provate Sub Command1_Click()

Dim napis as

MsgBox (“To działa!”)

End Sub

Pokazuje się nowe okno z podpowiedziami. Przewijając w dół widoczną listę, możemy odszukać typ zmiennej

String

. Można też, co zwykle jest wygodniejsze, po prostu kontynuować pisanie.

Wpisany przez nas kod powinien wyglądać:

Private Sub Command1_Click()

Dim napis As String

MsgBox (“To działa!”)

End Sub

Dopisujemy kolejną instrukcję, przypisującą zmiennej napis ciąg znaków „To działa!”. Modyfikujemy też

instrukcję MsgBox:

Private Sub Command 1_Click()

Dim napis As String

Napis = “To działa!”

MsgBox (napis)

End Sub

Wpisany kod będzie działał następująco:

w linni A zadeklarowana została zmienna o nazwie napis i typie String; może ona przechowywać ciągi
znaków „To działa!”,

w linni B zmiennej napis został przypisany ciąg znaków „To działa!”,

w linni C zmienna napis została użyta jako parametr funkcji MsgBox.

Dzięki temu po kliknięciu na przycisk użytkownik zobaczy na ekranie okno dialogowe z napisem. Możemy

się o tym przekonać, uruchamiając program przez wybranie z menu Run pozycji Start. Można też skorzystać z
jednego z dwóch innych sposobów uruchamiania aplikacji podanych poniżej.

Pola tekstowe

Pola tekstowe to elementy służące użytkownikowi do wprowadzania znaków. Znamy je dobrze z używanych

na co dzień aplikacji. Na przykład edytor Word używa pól tekstowych, aby umożliwić użytkownikowi podanie
imienia i nazwiska. Są to zatem tak przydatne elementy Windows, że powinniśmy nauczyć się z nich korzystać. Jak
zwykle będziemy ćwiczyć na konkretnym przykładzie. Napiszemy prostą aplikację, zawierającą pole tekstowe i
przycisk – po kliknięciu na przycisk będzie pojawiać się okno dialogowe z wpisanym tekstem. Zabierzmy się więc do
pracy.

Zamykamy poprzedni projekt. W tym celu z menu File

File

wybieramy pozycję Remove Project

Remove Project

Jeśli nie zapisaliśmy zmian do ostatniej aplikacji, na pewno zobaczymy okno, czy chcemy zapisać zaminy w tych

plikach. Klikamy oczywiście na Yes

Yes

Jest to zarezerwowana nazwa będąca elementem języka programowania. Nazwy takiej nie można używać jako nazw zmiennych lub funkcji,

inaczej program nie będzie działał.

Tworzymy nowy projekt. Z menu File

File

wybieramy pozycję New Project

New Project

. W oknie dialogowym, które się pokazuje,

wybieramy Standard EXE

Standard EXE

i klikamy na OK

Na palecie komponentów znajdujemy ikonę z literami ab

. Na formatce rysujemy pole tekstowe.

Jak widać, w polu tekstowym znajduje się domyślny napis. Musimy go usunąć. W oknie właściwości obiektów

odszukujemy właściwość Text

Text

i usuwamy znajdujący się przy niej napis Text1

Text1

Z palety komponentów wybieramy ikonę w kształcie prostokąta. W znany już nam sposób dodajemy na formatkę

przycisk pod polem tekstowym. Nadszedł czas, aby napisać odpowiedni kod. Pomyślmy, mamy wyświetlić na ekranie
tekst wpisany przez użytkownika w pole tekstowe. W jaki sposób możemy ten tekst otrzymać? Odpowiedź jest
prosta: każde pole tekstowe ma właściwość o nazwie text, która zawiera szukany przez nas ciąg znaków. Nasze pole
nosi nazwę Text1, żeby więc wyświetlić wpisany przez użytkownika napis, musimy wykonać trzy następujące
czynności:

a) zadeklarować zmienną typu string o nazwie napis,
b) przypisać zmiennej napis właściwość text obiektu Text1. Używamy w tym celu znaku równości (=),
c) wywołać znaną nam już dobrze funkcję MsgBox ze zmienną napis jako parametrem.

Klikamy dwukrotnie na znajdujący się na formatce przycisk. W oknie kodu wpisujemy:

Private Sub

Command1_Click()

Dim

napis

As String

Napis = Text1.Text

MsgBox (napis)

End Sub

Uruchamiamy program, korzystając z dowolnego z pozostałych sposobów. W oknie wpisujemy napis test

test

. Może to

być oczywiście każdy inny test. Klikamy na Command1

Command1

Na ekranie widać nowe okno z wpisanym wcześniej tekstem. Wszystko działa więc zgodnie z założeniami.

Obliczamy odsetki

Wszystkie poznane dotychczas elementy przybliżają nas do napisania prawdziwej funkcjonalnej aplikacji.

Napiszemy bowiem program, który pozwoli nam na obliczenie odsetek od lokat bankowych. Zaczniemy od
stworzenia interfejsu. Chcielibyśmy aby wyglądał on następująco:

Przystąpmy zatem do pracy.

Projekt

Zamykamy okno programy, a następnie projekt, wybierając z menu File pozycję Remove Project. Widzimy

pytanie, czy chcemy zachować go na dysku. Nie będzie już nam potrzebny, klikamy więc na No.

Z menu File

File

wybieramy pozycję New Project

New Project

. Wybieramy ikonę Standard EXE

Standard EXE

i klikamy na OK

Na palecie komponentów klikamy na ikonę z małymi literami ab. Rysujemy na formatce trzy pola tekstowe.

Klikamy na pierwsze z nich. W oknie Properties

Properties

odszukujemy właściwość Text

Text

i usuwamy znajdujący się obok

tekst – w ten sposób kasujemy napis znajdujący się w pierwszym polu tekstowym.

Postępując analogicznie jak w punkcie 4

, usuwamy teksty znajdujące się w pozostałych polach tekstowych.

Rysujemy na formatce przycisk i zmieniamy jego właściwość Caption

Caption

na Oblicz

Oblicz

Dodajemy na formatkę siedem etykiet tekstowych, tak aby uzyskać widok:

W razie konieczności zwiększamy rozmiar formatki.

Zmieniamy napisy na etykietach oraz usuwamy tekst z etykiet Label4

Label4

i Label5

Label5

Label1

na Kwota lokaty

Kwota lokaty

Label2

na Okres lokaty (miesiące)

Okres lokaty (miesiące)

Label3

na Oprocentowanie

Oprocentowanie

Label6

na Kapitał

Kapitał

Label7

na Kwota odsetek

Kwota odsetek

Teraz projekt wygląda następująco:

Zmienimy jeszcze tylko wygląd etykiet, na których prezentowane będą wyniki.

Klikamy na element A

.W oknie Properties

Properties

znajdujemy właściwość BorderStyle

BorderStyle

i z rozwijalnej listy wybieramy

pozycję 1 – Fixed Single

1 – Fixed Single

. Dzięki temu etykieta otrzyma obramowanie symulujące wklęsłość i nasza aplikacja będzie

miała atrakcyjniejszy wygląd.

Tak jak w punkcie 9

zmieniamy wygląd etykiety B

. Teraz oba elementy służące do wyświetlania wyników

obliczeń są wyróżnione. Cały projekt wygląda zaś dokładnie tak, jak to zaplanowaliśmy. Zapisujemy go więc na
dysku, abyśmy mogli kontynuować nad nim pracę w kolejnym odcinku.

Z menu File

File

wybieramy pozycję Save Project

Save Project

. W pierwszym oknie dialogowym jako nazwę pliku podajemy

odsetki_formatka.frm

, Jak pamiętamy, zapisaliśmy w ten sposób plik opisujący wygląd formatki. W kolejnym oknie

podajemy nazwę Project Files (*.vbp)

Project Files (*.vbp)

. Tym razem zapisaliśmy pliki konfiguracyjne projektu. Przygotowaliśmy w

ten sposób cały interfejs naszej aplikacji.

RODZIAŁ III – Pętle. Instrukcje warunkowe. Pola wyboru. Aplikacja do obliczania

odsetek (wykonanie).

W poprzednim rozdziale rozpoczęliśmy tworzenie aplikacja służącej do obliczania odsetek od lokat

bankowych. Stworzyliśmy działający interfejs, pora napisać kod. Wcześniej powinniśmy jednak nauczyć się kilku
nowych konstrukcji programistycznych.

Poznamy za chwilę elementy Visual Basica nazywane

pętlami

. Służą one do wykonywania powtarzających

się czynności. Załóżmy na przykład, że chcemy wyświetlić trzy razy z rzędu okno dialogowe, zawierające kolejne
liczby 0, 1 i 2.

Wyświetlanie będziemy wywoływać, klikając na specjalny przycisk. Najpierw pojawi się okienko z zerem, po

kliknięciu na przycisk OK

– kolejne okienko z jedynką itd. Stosując dotychczas poznane metody, musielibyśmy

trzykrotnie wywołać funkcję MsgBox. Spróbujmy wykonać następujące ćwiczenie.

Zaczynamy od uruchomienia Visual Basica. Z menu Start

Start

wybieramy znaną nam pozycję Microsoft Visual Basic

Microsoft Visual Basic

6.0

. W oknie dialogowym, służącym do ustalenia typu projektu, wybieramy Standard EXE

Standard EXE

i klikamy na OK

Na palenie komponentów odszukujemy ikonę z mały prostokątem. W znany nam już sposób rysujemy na formatce

przycisk, a następnie dwukrotnie na niego klikamy.

Otwiera się okno kodu, w które wpisujemy:

Private Sub Command1_Click()

MsgBox (”0”)

MsgBox (”1”)

MsgBox (”2”)

End Sub

Uruchamiamy aplikację, wybierając z menu Run

Run

pozycję Start

Start

Pokazuje się główne okno aplikacji. Klikamy na przycisk Command1

Command1

Wyświetla się pierwsze okno dialogowe zawierające cyfrę zero. Po kliknięciu na OK

. pojawią się kolejne okno, z

cyfrą jeden, a potem następne – z cyfrą dwa.

Nie powtarzaj się

Aby osiągnąć efekt trzykrotnego pojawienia się okna dialogowego, trzy razy wywołaliśmy poznaną w

poprzednim odcinku funkcję MsgBox. Całą tę procedurę można jednak zrealizować również za pomocą pętli.
Schematycznie wygląda ona następująco:

For zmienna = wartość początkowa To wartość końcowa
Instrukcje
Next zmienna

For, To i Next to instrukcje oznaczające pętlę. Cały zaś zapis oznacza: Przypisz zmiennej wartość

początkową, a następnie wykonuj instrukcje tak długo, aż zmienna osiągnie wartość końcową. Po każdym wykonaniu
instrukcji zwiększaj wartość zmiennej o jeden.

W oknie kodu usuwamy poprzednio wpisane instrukcje tak, aby pozostały jedynie:

Private Sub Command1_Click()

End Sub

Wpisujemy następujący ciąg instrukcji:

Jeżeli pisząc program, musimy jakąś czynność powtarzać wielokrotnie, to obudowujemy ją pętlą. Na ogół taka część kodu wykonywana

jest tak długo, aż zostanie spełniony warunek wyjścia z pętli. Jest to bardzo przydatne na przykład wtedy, kiedy z góry nie wiadomo, ile razy
będziemy musieli wykonać określoną czynność.

Private Sub Command1_Click()

For i = 0 To 2

MsgBox (i)

Next i

End Sub

Wpisany kod należy rozumieć następująco: Zaczynając od zmienne i równej 0, dopóki i nie osiągnie wartości

2, wykonuj instrukcję MsgBox

MsgBox

oraz zwiększaj i o 1.

Uruchamiamy program, korzystając z jednego z poznanych już sposobów. Widzimy, że osiągnęliśmy taki sam

efekt jak w poprzedniej wskazówce. A o to właśnie nam chodziło.

Liczymy odsetki

Wiemy już, w jaki sposób wykorzystywać pętlę. Czy jednak przydadzą się one w praktyce przy pisaniu

aplikacji do obliczania odsetek od lokat bankowych? Oczywiście tak! Za chwilę się o tym przekonamy.
Przypomnijmy sobie, jak wyglądał stworzony interfejs programu.

Użytkownik naszej aplikacji będzie podawał:

Kwotę, jaką chce zainwestować A

Okres inwestycji wyrażony w latach B

Oprocentowanie lokaty w stosunku rocznym C

Po kliknięciu na przycisk Oblicz pojawiają się dane:
Kwota kapitału razem z obliczonymi odsetkami D

Kwota odsetek E

Zakładamy, że odsetki dopisywane są do kapitału co rok. Mówiąc fachowo, będziemy obliczać odsetki dla

lokaty z kapitalizacją 12-miesięczną. Jaki jest wzór na obliczenie odsetek? Pomyślmy – po pierwszym roku
otrzymamy:

odsetki w pierwszym roku = kapitał * oprocentowanie / 100

W roku drugim musimy obliczać odsetki od kapitału powiększonego o odsetki z roku pierwszego, czyli:

odsetki w drugim roku = (kapitał + odsetki w pierwszym roku) * oprocentowanie / 100

Postępując w sposób analogiczny dla kolejnych lat, otrzymamy sumę odsetek dla pełnego okresu lokaty.

Widać już chyb wyraźnie, że do realizacji takiego

algorytmu

bardzo przydałaby się poznana wcześniej konstrukcja

pętli. Schematycznie powinna wyglądać następująco:

For i = 1 To lata
odsetki = kapitał * oprocentowanie / 100
suma odsetek = suma odsetek + odsetki

Sposób działania programu komputerowego lub pojedynczej funkcji w kodzie programu. Algorytm można przedstawić w postaci formuł

matematycznych, jednak w wypadku mniej skomplikowanych programów wystarcza zwykle opis słowny.

kapitał = kapitał + odsetki
Next i

Po wykonaniu takiej pętli otrzymamy zarówno sumę odsetek, jak i wartość całego kapitału. Po tym, czego

nauczyliśmy się już o pętlach, przeniesienie takiego zapisu na kod w Visual Basicu nie powinno sprawić nam
żadnego kłopotu. Przekonajmy się o tym.

Otwieramy zapisany w poprzednim rozdziale projekt. Z menu File

File

wybieramy pozycję Open Projekt

Open Projekt

. Jeżeli

chcemy zapisać poprzedni projekt na dysku twardym, klikamy na Yes

Yes

. Ponieważ był to jednak przykład, który nie

będzie nam już potrzebny w dalszej pracy, możemy równie dobrze zrezygnować z jego zapisywania, klikając na No

Pojawia się standardowe okno Windows służące do wyboru pliku. Odszukujemy na dysku plik z projektem

odsetki_projekt.vbp

i klikamy na przycisk Otwórz

Otwórz

. Visual Basic wczyta zapisany wcześniej projekt.

Spotkała nas zapewne niespodzianka. Na ekranie nie ma przygotowanej wcześniej formatki. Nie martwmy się

jednak, za chwilę przywołamy ją na ekran.

W oknie Properties

Properties

klikamy na znaczek plus przy Forms

Forms

. W ten sposób rozwijamy kolejną gałąź drzewa.

Na ekranie widzimy teraz listę wszystkich formatek, które zawiera bieżący projekt. W naszym wypadku na liście

jest oczywiste tylko jedna formatka. Klikamy zatem dwukrotnie na tą formatkę.

Widzimy znane nam dobrze okno projektu aplikacji.

Klikamy dwukrotnie na przycisk Oblicz

Oblicz

. Możemy rozpocząć tworzenie kodu aplikacji.

Działająca aplikacja

Najwyższy czas wyposażyć nasz program w kod realizujący zadanie obliczania odsetek. Znamy już

schematyczną postać pętli dokonującej obliczeń, stworzenie jej nie powinno nam zatem sprawić żadnego kłopotu.
Najpierw musimy jednak odczytać wszystkie dane wprowadzone przez użytkownika i przypisać je do odpowiednich
zmiennych. To najprostsza część naszego zadania.

Deklarujemy zmienne, które będą nam potrzebne do przechowywania danych. Przypomnijmy, że

Integer

oznacza

liczby całkowite, a

Single

liczby z częścią ułamkową.

Aby ułatwić sobie pracę, zmieniamy nazwy pól tekstowych, tak aby odzwierciedlały pełnione przez nie funkcje.

Przełączamy interfejs na widok formatki. Klikamy na A.

W oknie Properties

Properties

odszukujemy właściwość Name

Name

zmieniamy ją na poleKwota

poleKwota

Postępując analogicznie jak w punkcie 2

, zmieniamy nazwy elementów:

na poleOkresLokaty

poleOkresLokaty

na poleOprocentowanie

poleOprocentowanie

na etykietaKapitał

etykietaKapitał

na etykietaOdsetki

etykietaOdsetki

Odczytujemy wartości z pól tekstowych i przypisujemy je do zadeklarowanych w punkcie 1

zmiennych. W jaki

sposób można odczytać wartość z pola tekstowego? Na pewno pamiętamy to z poprzedniego rozdziału – trzeba

odwołać się do właściwości Test odpowiedniego pola. Przełączamy interfejs na widok kodu. Z menu Window

Window

wybieramy pozycję Project1 – Form1 (Code)

Project1 – Form1 (Code)

i dopisujemy następujący fragment:

Private Sub Command1_Click()

Dim kapital As Single

Dim lata As Integer

Dim oprocentowanie As Single

kapital = poleKwota.Text

lata = poleOkresLokaty.Text

oprocentowanie = poleOprocentowanie.Text

End Sub

W tej chwili pozostaje nam już tylko zadeklarować zmienne, które będą służyły do przechowywania kwoty odsetek

oraz napisać pętlę obliczającą wyniki. Znamy już schematyczną postać tej pętli. Nie powinniśmy więc mieć żadnego
problemu z przełożeniem jej na kod Visual Basica. W efekcie otrzymamy taki kod źródłowy:

Dim odsetki As Single

Dim suma_odsetek As Single

For i = i To lata

odsetki = kapital * oprocentowanie / 100

suma_odsetek = suma_odsetek + odsetki

kapital = kapital + odsetki

Next i

Jak widać, nie musieliśmy dokonywać prawie żadnych zmian. Nie wpisujmy jednak tych instrukcji (na razie)

do okna kodu.

Pozostaje nam napisać instrukcje, które wyświetlą wyniki obliczeń na ekranie. Do osiągnięcia prawidłowego efektu

wystarczy przypisać właściwości Caption

Caption

etykiety o nazwie etykietaKapital

etykietaKapital

wartość zmiennej kapital

kapital

oraz

właściwości Caption

Caption

etykiety etykietaOdsetki

etykietaOdsetki

wartość zmiennej suma_odsetek

suma_odsetek

. My jednak postąpimy inaczej.

Nasza aplikacja będzie wyglądać bardziej profesjonalnie, jeśli wyniki zostaną odpowiednio sformatowane.
Dokładniej chodzi o to, aby odsetki oraz kapitał były prezentowane zawsze w postaci z dwoma i tylko dwoma
miejscami po przecinku. Osiągniemy to korzystając z funkcji Format

Format

. Pozwala ona na przedstawienie liczby w

postaci określonej przez specjalny parametr. W naszym przypadku parametr ten powinien wyglądać następująco:
”#,##0,00”, dopisujemy fragment:

etykietaKapital.Caption = Format (kapital, ”#,##0,00”)

etykietaOdsetki.Caption = Format (suma_odsetek, ”#,##0,00”)

7 Ostatecznie po złożeniu wszystkich poznanych elementów kod przypisany do klawisza Oblicz będzie wyglądał w
taki sposób:

Private Sub Command1_Click()

Dim kapital As Single

Dim lata As Integer

Dim oprocentowanie As Single

kapital = poleKwota.Text

lata = poleOkresLokaty.Text

oprocentowanie = poleOprocentowanie.Text

Dim odsetki As Single

Dim suma_odsetek As Single

For i = i To lata

odsetki = kapital * oprocentowanie / 100

suma_odsetek = suma_odsetek + odsetki

kapital = kapital + odsetki

Next i

etykietaKapital.Caption = Format (kapital, ”#,##0,00”)

etykietaOdsetki.Caption = Format (suma_odsetek, ”#,##0,00”)

End Sub

Zmieniamy napis w tytule okna formatki na Odsetki

Odsetki

. Metodę wykonania tego zadania poznaliśmy w pierwszym

rozdziale.

Zapisujemy projekt na dysku. Wciskamy kombinację klawiszy Ctrl + S

Ctrl + S

lub wybieramy z menu File

File

pozycję Save

Save

Project

Uruchamiamy program jednym z poznanych sposobów. Od razu możemy wykonać testowe obliczenia. Szybko

przekonamy się, że aplikacja działa prawidłowo. Jeśli jesteśmy niedowiarkami, zawsze możemy użyć kalkulatora do
sprawdzenia poprawności wyników.

Generujemy

plik wykonywalny

.exe. Z menu File

File

wybieramy Make odsetki_projekt.exe

Make odsetki_projekt.exe

. W okno Make

Make

Projekt

wpisujemy jako nazwa pliku odsetki.exe

odsetki.exe

. Klikamy na OK

. W katalogu projektu pojawia się nowy plik

odsetki.exe

. To właśnie nasza aplikacja w postaci pliku wykonywalnego.

To nie jest liczba

Program do obliczania odsetek działa już zgodnie z założeniami. Nie wzięliśmy jednak pod uwagę jednej

rzeczy. Co się stanie, jeśli użytkownik pomyli się? Na przykład w jednym z pól tekstowych zamiast liczby wpisze
litery. Przeprowadźmy test.

Uruchamiamy aplikację z poziomu systemu operacyjnego. W miejscu przeznaczonym na kwotę lokaty wpisujemy:

to nie jest liczba

Klikamy na Oblicz

Oblicz

. Widzimy nowe okienko informujące o wystąpieniu błędu.

Klikamy na OK

. Aplikacja kończy działanie! Profesjonalny produkt nie powinien działać w ten sposób. Warto

byłoby zatem wyposażyć nasz program w funkcję kontrolującą, czy użytkownik podał prawidłowe dane.

Warunki

Aby móc zrealizować to najnowsze zadanie, musimy najpierw poznać nową konstrukcję Visual Basica –

Instrukcję warunkową

. Ma ona postać:

If warunek Then
Instrukcje1
Ele
Instrukcje2
End If

Zapis ten należy rozumieć w następujący sposób: Jeżeli warunek jest prawdziwy, wykonaj Instrukcje1. W

przeciwnym wypadku wykonaj instrukcje2. Najlepiej od razu wykonajmy odpowiedni przykład. Wykorzystamy przy
tym nową kontrolkę, której do tej pory jeszcze nie mieliśmy okazji poznać. Będzie to element CheckBox. Znamy go
dobrze z różnych aplikacji Windows. To typowe pole wyboru. Nasza przykładowa aplikacja będzie działała w sposób
następujący: Na formatce znajdzie się pole wyboru oraz przycisk. Po kliknięciu na przycisk pojawi się okienko z
napisem, czy pole wyboru jest zaznaczone, czy nie.

Plik, który można uruchomić. Pliki wykonywalne mają rozszerzenia: .bat .com .exe

Specjalna konstrukcja języka programowania, która pozwala na wykonanie różnych instrukcji w zależności od tego, czy spełniony jest

określony warunek. Warunek ten definiowany jest przez programistę. Dzięki temu program może reagować na różne sposoby, gdy
użytkownik wprowadza różne dane.

Tworzymy nowy projekt w Visual Basicu. Na palecie komponentów odszukujemy ikonę ze znacznikiem.

Rysujemy na formatce pole wyboru.

W oknie Properties

Properties

znajdujemy właściwość Caption

Caption

i zmieniamy jej wartość na Pole Wyboru

Pole Wyboru

Na palecie komponentów odszukujemy ikonę z małym prostokątem. Rysujemy na formatce przycisk. Całość

będzie wyglądała w tej chwili następująco.

Klikamy dwukrotnie na Command1. Musimy napisać kod sprawdzający, czy pole wyboru jest zaznaczone czy też

nie. Użyjemy oczywiście instrukcji warunkowej If. Jeszcze tylko nie wiemy, w jaki sposób sprawdzić stan pola
CheckBox. Na szczęście jest to bardzo proste. Należy zbadać, jaką wartość zawiera właściwość Value

Value

. Jeśli jest to

jeden, pole jest zaznaczone, jeśli zero – pole nie jest zaznaczone. W oknie kodu piszemy:

Private Sub Command1_Click()

If Check1.Value = 0 Then

MsgBox (”Pole nie jest zaznaczone”)

Else

MsgBox (”Pole jest zaznaczone”)

End If

End Sub

Uruchamiamy aplikację. Zaznaczamy pole wyboru i klikamy na Command1

Command1

. Widzimy nowe okno dialogowe.

Usuwamy zaznaczenie z pola wyboru i klikamy na Command1

Command1

. Również w tej sytuacji aplikacja działa zgodnie z

założeniami. Instrukcja warunkowa spełnia zatem swoje zadanie.

Profesjonalne odsetki

Skoro potrafimy już wykorzystywać instrukcje warunkowe, możemy przystąpić do zmodyfikowania aplikacji

obliczającej odsetki. Ma pracować poprawnie nawet wtedy, kiedy użytkownik poda nieprawidłowe dane. Powinna w
takiej sytuacji wyświetlić okno dialogowe z odpowiednim komentarzem. Przystąpmy zatem do pracy.

Wczytujemy projekt aplikacji do Visual Basica. Otwieramy okno formatki i klikamy dwukrotnie na przycisk

Oblicz

W tej chwili możemy przystąpić do modyfikacji kodu. Musimy skorzystać z dodatkowej funkcji o nazwie Val

Val

Przetwarza ona ciąg znaków na liczbę. Dokonajmy następującej zmiany w kodzie:

Private Sub Command1_Click()

Dim kapital As Single

Dim lata As Integer

Dim oprocentowanie As Single

kapital = Val(polekowa.Text)

lata = Val(poleOkresLokaty.Text)

oprocentowanie = Val(poleOprocentowanie.Text)

Wydawać by się mogło, że tak naprawdę nic się nie zmieniło. To jednak tylko pozorry. Już w tej chwili

osiągnęliśmy bardzo wiele! Przekonajmy się o tym.

Uruchamiamy aplikację. W pola tekstowe wpisujemy dowolne ciągi znaków klikamy na Oblicz

Oblicz

. Pojawiają się

zerowe wyniki, ale aplikacja działa – nie zamyka się. Dzieje się tak, dlatego, że funkcja Val

Val

po otrzymaniu

parametru, który nie jest liczbą, zwraca po prostu w wyniku zero. Jest to najbardziej prawidłowa liczba, dlatego też
aplikacja cały czas działa. Wynika z tego, że wystarczy teraz za pomocą instrukcji If sprawdzić, czy którakolwiek ze
zmiennych jest równa zero i jeśli tak jest, wyświetlić odpowiedni komunikat. Prawidłowa konstrukcja warunkowa dla
zmiennej kapital

kapital

wygląda następująco:

kapital = Val(poleKwota.Text)

If kapital <= 0 Then

MsgBox („Nieprawidłowa wartość kapitału!”)

Exit Sub

End If

Sprawdzamy tu, czy zmienna kapital jest równa zeru bądź mniejsza od zera. Jeśli tak, wykonujemy znaną nam

dobrze instrukcję MsgBox

MsgBox

oraz kończyny wykonywanie kodu. Służy do tego instrukcja Exit Sub

Exit Sub

Analogicznie konstrukcje z instrukcją warunkową If jak dla zmiennej kapital musimy dopisać dla zmiennych lata i

oprocentowanie. Pełny kod po wprowadzeniu wszystkich poprawek będzie wyglądał następująco:

Private Sub Command1_Click()

Dim kapital As Single

Dim lata As Integer

Dim oprocentowanie As Single

kapital = Val(poleKwota.Text)

If kapital <= 0 Then

MsgBox („Nieprawidłowa wartość kapitału!”)

Exit Sub

End If

lata = Val(poleOkresLokaty.Text)

If lata <= 0 Then

MsgBox (”Nieprawidłowa długość inwestycji!”)

Exit Sub

End If

oprocentowanie = Val(poleOprocentowanie.Text)

If oprocentowanie <= 0 Then

MsgBox (”Nieprawidłowe oprocentowanie!”)

Elit Sub

End If

Dim odsetki As Single

Dim suma_odsetek As Single

For i = i To lata

odsetki = capital * oprocentowanie / 100

suma_odsetek = suma_odsetek + odsetki

kapital = kapital + odsetki

Next i

etykietaKapital.Caption = Format (kapital, ”#,##0.00”)

etykietaOdsetki.Caption = Format (summa_odsetek, ”#,##0.00”)

End Sub

Jest on dosyć długi, ale wykorzystuje wyłącznie znane nam już konstrukcje. Jego zrozumienie na pewno nie sprawi
nam kłopotu. Wystarczy po kolei przeanalizować instrukcje.

Tworzymy plik wykonywalny. Z menu File

File

wybieramy pozycję o nazwie Make_odsetki_projekt.exe

Make_odsetki_projekt.exe

. Pokazuje

się dzięki temu okno dialogowe, umożliwiające nadanie nazwy plikowi wykonywalnemu oraz wybranie katalogu, w
którym plik ten zostanie utworzony. Po wpisaniu nazwy pliku klikamy na OK

. Visual Basic dokona kompilacji kodu

i po chwili nasz program będzie gotowy do pracy.

Zapisujemy projekt na dysku, wciskając kombinację klawiszy Ctrl + S

Ctrl + S

. Możemy sobie pogratulować. Napisaliśmy

naprawdę funkcjonalną aplikację.

RODZIAŁ IV – Komponenty obsługujące katalogi i pliki. Kontrolka obsługująca

obrazy. Przeglądarka plików graficznych.

Poznaliśmy wiele konstrukcji programistycznych oferowanych przez Visual Basica. Tym razem zapoznamy

się z kontrolkami, które umożliwiają stworzenie przeglądarki

plików graficznych

. Zobaczymy, że to zadanie wcale

nie jest skomplikowane.

Wybierz obraz

Przed przystąpieniem do tworzenia przeglądarki musimy wykonać kilka ćwiczeń, które nauczą nas korzystać z

całkiem nowych komponentów Visual Basica. Przekonamy się, że wyświetlenie grafiki czy standardowego okna
służącego do otwierania plików jest naprawdę proste. Naszym pierwszym zadaniem jest napisanie programu, który
pozwoli na wczytanie i obejrzenie pliku graficznego. Można powiedzieć, że będzie to prosta przeglądarka graficzna,
wyświetlająca na ekranie okno z dwoma przyciskami. Jeden będzie służył do zamykania aplikacji. Kliknięcie na drugi
spowoduje otwarcie okna dialogowego służącego do otwierania plików. Kiedy użytkownik wybierze plik graficzny,
zostanie wyświetlony on na ekranie. Przystąpmy do realizacji tego zadania.

Na palecie komponentów znajdujemy ikonę z małym rysunkiem graficznym i rysujemy na formatce prostokąt. Jest

to komponent o nazwie Imane

Imane

, służący do wyświetlania obrazów. Dodajemy również dwa przyciski tak, aby jeden z

nich znajdował się w dolnym-lewym rogu, a drugi w dolnym-prawym rogu.

Zmieniamy napisy na przycisku Command1

Command1

. Klikamy na niego. W oknie Properties

Properties

wybieramy właściwość

Caption

i zmieniamy znajdujący się przy niej napis na Zamknij

Zamknij

. Przycisk ten będzie zamykał aplikację.

Postępując analogicznie jak w punkcie 2

, zmieniamy napis na przycisku Command2

Command2

na Otwórz

Otwórz

. Musimy teraz

dodać na formatkę kontrolkę pozwalającą na wyświetlenie standardowego okna dialogowego służącego do otwierania
plików. Niestety, nie znajdziemy jej na palecie komponentów. Na szczęście szybko możemy to zmienić.

Klikamy prawym przyciskiem myszy na paletę komponentów i z podręcznego menu, które się pokazuje,

wybieramy pozycję o nazwie Components

Components

. Na ekranie pojawia się nowe okno dialogowe.

Na zakładce Controls

Controls

odszukujemy pozycję Microsoft Common Dialog Control 6.0

Microsoft Common Dialog Control 6.0

i zaznaczamy ją. Na palecie

komponentów pojawia się nowa ikona.

Klikamy na nową ikonę. Rysujemy na formatce w dowolnym miejscu prostokąt. Nie musimy przejmować się jego

rozmiarem, po zwolnieniu przycisku myszy obiekt zostanie automatycznie zmniejszony do rozmiarów ikony.

Musimy teraz napisać kod, który będzie wykonywał następujące czynności:

zadeklaruje zmienną nazwa,

wyświetli na ekranie okno dialogowe służące do wyboru plików,

przypisze zmiennej nazwa nazwę wybranego przez użytkownika pliku,

wczyta plik graficzny i wyświetli go na ekranie.

Do wczytania obrazka wykorzystujemy funkcję LoadPicture. Jako parametr podajemy nazwę pliku

graficznego, w naszym przypadku znajduje się ona w zmiennej nazwa.

Powinniśmy sprawdzić, czy dotychczas napisany kod jest prawidłowy. Uruchamiamy program.

Klikamy na Otwórz

Otwórz

i wybieramy dowolny plik graficzny w formacie JPG, GIF lub BMP i klikamy na Otwórz

Otwórz

Specjalny rodzaj pliku, w którym zapisywane są obrazy. Pliki graficzne mogą mieć różne formaty, najpopularniejsze z nich to GIF, BMP i

JPG. Aby obejrzeć obraz zapisany w takim pliku, musimy dysponować programem potrafiącym go odczytać.

Obraz wczytany z wybranego pliku pojawia się na ekranie. Działanie programu jest więc zgodne z założeniami.

W tej chwili pozostaje nam tylko wykonać dosłownie kilka kosmetycznych poprawek.

W oknie Properties

Properties

z rozwijalnej listy wybieramy Image1 Image

Image1 Image

. Znajdujemy właściwość Stretch

Stretch

i ustalamy

jej wartość na True

True

. Dzięki temu obraz zawsze będzie skalowany do rozmiarów okna.

Klikamy na dowolne miejsce formatki. W oknie Properties

Properties

odszukujemy właściwość Caption

Caption

i zmieniamy ją na

Przeglądarka

. Zmieniliśmy w ten sposób tytuł okna naszej aplikacji.

Klikamy dwukrotnie na Zamknij

Zamknij

. Musimy teraz napisać kod, który spowoduje zamknięcie aplikacji.

Wykorzystujemy do tego celu funkcję Unload Form1. W oknie kodu piszemy:

Private Sub Command1_Click()

Unload Form1

End Sub

14 Zapisujemy cały projekt na dysku twardym. Możemy nadać mu dowolną nazwę.

W ten sposób napisaliśmy program. Nie jest on może bardzo funkcjonalny (nie pozwala szybko przejrzeć

wielu plików), ale nauczyliśmy się dzięki temu wykorzystywać nowe komponenty. Przydadzą nam się podczas pracy
nad bardziej rozbudowaną przeglądarką.

Dyski, katalogi i pliki

Kiedy piszemy program komputerowy, bardzo często zachodzi konieczność zaprezentowania użytkownikowi

listy napędów dyskowych, katalogów czy plików. W jaki sposób zrealizować to zadanie? Oczywiście należy
skorzystać z odpowiednich komponentów. Wykonajmy zatem trzy proste zadania, dzięki którym nauczymy się
posługiwać się odpowiednimi kontrolkami.

Dyski

Tworzymy nowy projekt. Na palecie komponentów znajdujemy ikonę DriveListBox

DriveListBox

(ikona z małym folderem).

Rysujemy na formatce prostokąt. Po zwolnieniu przycisku myszy zamieni się on w listę rozwijalną zawierającą
dostępne w naszym komputerze napędy. Zauważmy, że o ile szerokość kontrolki możemy regulować dowolnie, to jej
wysokość ustalana automatycznie przez Visual Basic.

Dodajemy na formatkę typowy przycisk Command1

Command1

. Jego wielkość możemy dowolnie regulować. Napiszemy

teraz kod, który po kliknięciu na przycisk wyświetli na ekranie dodatkowe okno dialogowe z napisem mówiącym,
która litera dysku jest aktualnie wybrana w komponencie DriveListBox

DriveListBox

Klikamy dwukrotnie na przycisk Command1

Command1

. W okno kodu wpisujemy:

Private Sub Command1_Click()

Dim napis As String

napis = ”Aktualnie wybranym napędem jest ” + Drive1.Drive

MsgBox (napis)

End Sub

Deklarujemy zmienną napis A

. Przypisujemy jej ustalony tekst B

. Używamy zmiennej napis w wywołaniu

funkcji MsgBox

MsgBox

. Jak widać, aby programowo stwierdzić, jaki jest aktualnie wybrany napęd, należy odwołać się do

właściwości Drive

Drive

kontrolki Drive1

Drive1

. Nie pomylmy się! Dodana na formatkę kontrolka ma nazwę Drive1

Drive1

, a jej

właściwość nazywa się Drive

Drive

. Jeśli odwrócimy kolejność, program na pewno nie zadziała.

4 Uruchamiamy aplikację. Klikamy na Command1. widzimy okno dialogowe. Umiemy już zatem korzystać z
kolejnego komponentu!

Katalogi

Skoro potrafimy już obsługiwać kontrolkę wyświetlającą napędy, postarajmy się wykonać takie samo zadanie

z komponentem do obsługi katalogów. Nie będzie to skomplikowane zadanie.

Z poprzedniego projektu usuwamy kontrolkę Drive1

Drive1

. W tym celu klikamy na nią, tak by została zaznaczona, i

wciskamy klawisz Delete

Delete

Na palecie komponentów znajdujemy ikonę DirListBox

DirListBox

(z małym folderem). Rysujemy na formatce prostokąt. Po

zwolnieniu przycisku myszy na ekranie widzimy listę katalogów. Tym razem rozmiary kontrolki możemy dowolnie
zmieniać.

Klikamy dwukrotnie na Command1

Command1

. W oknie kodu musimy dokonać jedynie niewielkiej modyfikacji:

Private Sub Command1_Click ()

Dim napis As String

napis = ”Aktualnie wybranym katalogiem jest ” + Dir1.Path

MsgBox (napis)

End Sub

Pisząc Dir1.Path, otrzymujemy aktualnie wybrany katalog.

Uruchamiamy aplikację, wybieramy dowolny katalog i klikamy na Command1

Command1

. Pokazuje się nowe okno

dialogowe z napisem.

Pliki

Pozostał nam jeszcze do omówienia komponent, wyświetlający listę plików. Działa on nieco inaczej niż dwa

omówione już elementy programu. Przydatną funkcją byłaby tu możliwość wykrycia, kiedy użytkownik kliknął na
plik. Będziemy mogli wyświetlić ten plik na ekranie. Można powiedzieć, że wykrycie takiego zdarzenia jest
niezbędne przy pisaniu prawdziwej aplikacji. Zobaczmy więc, w jaki sposób to zrobić.

Z formatki usuwamy znajdujący się na niej komponent Dir1

Dir1

. Robimy to analogicznie jak w wypadku komponentu

Drive1

Usuwamy z formatki przycisk Command1

Command1

. Nie będzie już nam potrzebny.

Na palecie komponentów znajdujemy ikonę FileListBox

FileListBox

(w kształcie kartki, która ma zagięty róg). Rysujemy

prostokąt.

Dodajemy na formatkę etykietę tekstową.

Usuwamy napis znajdujący się na etykiecie. W oknie Properties

Properties

odszukujemy właściwość Caption

Caption

i usuwamy

znajdujący się obok tekst. Naszym zadaniem jest teraz spowodowanie, aby po kliknięciu na jeden z plików na
etykiecie pojawi się napis zawierający jego nazwę.

Klikamy dwukrotnie na okno z nawami plików. Okno kodu wygląda teraz następująco:

Private Sub Command1_Click ()

Dim napis As String

napis = ”Aktualnie wybranym katalogiem jest ” + Dir1.Path

MsgBox (napis)

End Sub

Private Sub File1_Click()

End Sub

Usuwamy cały wpis, który został po poprzednim przykładzie (zostawiając dwie ostatnie linijki).

wpisujemy instrukcje:

Private Sub File1_Click()

Label1.Caption = File1.FileName

End Sub

Będą one wykonywane za każdym razem, kiedy użytkownik kliknie na dowolnie wybrany plik. Ponieważ wpisana
instrukcja powoduje przypisanie nazwy pliku do właściwości Caption

Caption

etykiety, nazwa ta będzie za każdym razem

wyświetlana na ekranie.

Przeglądarka plików graficznych

Czas przystąpić do budowy prawdziwej i funkcjonalnej przeglądarki plików graficznych. Założenie jest takie,

że użytkownik naszej aplikacji będzie widział na ekranie listę napędów, katalogów i plików. Oczywiście po wybraniu
napędu automatycznie będzie uaktualniana lista katalogów, a po wybraniu katalogu – lista plików. Kliknięcie na
dowolny plik o formacie JPG, GIF lub BMP spowoduje wyświetlenie zawartego w nim obrazka na ekranie. W
przyszłości jeszcze bardziej rozbudujemy ten projekt, na razie postarajmy się wykonać przedstawione zadania.
Musimy oczywiście wykorzystać poznane przed chwilą komponenty.

Tworzymy nowy projekt. Na palecie komponentów odszukujemy ikonę obok „zegarka”. Rysujemy na formatce

komponent DriveListBox

DriveListBox

Na palecie komponentów znajdujemy ikonę z małym folderem. Rysujemy na formatce komponent DirListBox

DirListBox

Z palety komponentów wybieramy ikonę w kształcie małej kartki z zagiętym rogiem i rysujemy na formatce

komponent FileListBox

FileListBox

Na palecie komponentów odszukujemy ikonę z małym obrazkiem. Rysujemy na formatce komponent Imane

Imane

Zmieniamy nazwę projektu. W oknie Projekt – Project1

Projekt – Project1

klikamy na Project1 (Project1)

Project1 (Project1)

W oknie Properties

Properties

zmieniamy właściwość (Name)

(Name)

na Przeglądarka

Przeglądarka

Na wszelki wypadek zapisujemy projekt na dysku. Z pewnością nie chcielibyśmy stracić naszej pracy, gdyby

komputer niespodziewanie nam się zawiesił. Z menu File

File

wybieramy pozycję Save Projekt

Save Projekt

. Plikowi formatki i

plikowi projektu możemy nadać dowolnie wybrane nazwy, tak jak robiliśmy to już wielokrotnie.

Klikamy dwukrotnie na komponent wyświetlający literę dysku. W oknie kodu wpisujemy:

Private Sub Drive1_Change()

Dir1.Path = Drive1.Drive

End Sub

Instrukcja ta spowoduje, że po wybraniu napędu automatycznie zostanie uaktualniona lista katalogów.

Klikamy dwukrotnie na komponent wyświetlający listę katalogów. W okno kodu wpisujemy:

Private Sub Dir1_Change()

File1.Path = Dir1.Path

End Sub

Zauważmy, że wpisana instrukcja jest podobna do napisanej w punkcie 8

. Tym razem powoduje ona, że po wybraniu

katalogu automatycznie zostaje zaktualizowana lista plików.

Przetestujmy, czy wpisany kod faktycznie działa zgodnie z naszymi założeniami. Uruchamiamy program. Szybko

przekonamy się, że zmiana napędu z listy powoduje zmianę listy katalogów, a wybranie katalogu powoduje zmianę
na liście plików.

Wyświetlenie rysunku

Pozostała nam do wykonania najważniejsza część programu. Musimy napisać kod, który spowoduje

wyświetlenie na ekranie wybranego przez użytkownika pliku graficznego. Obrazek będzie wyświetlany przez
kontrolkę Image1

Image1

. Niezbędne jest użycie funkcji LoadPicture

LoadPicture

. Nie powinno nam to sprawić kłopotu –

wykorzystaliśmy ją już w punkcie 7 w Wybieraniu obrazu. Przystępujemy do pracy.

Klikamy dwukrotnie na kontrolkę File1

File1

. Kod, który teraz napiszemy, będzie wykonywany za każdym razem, kiedy

użytkownik kliknie na dowolnie wybrany z listy plik. Wpisujemy:

Pivate Sub File1_Click()

Dim nazwapliku As String

nazwapliku = File1.Path + ”\” + File1.filename

Image1.Picture = LoadPicture(nazwapliku)

End Sub

Deklarujemy zmienną Dim nazwapliku As String, która będzie przechowywać nazwę wybranego pliku wraz
z pełną ścieżką dostępu. Przypisujemy zmiennej nazwapliku

nazwapliku

odpowiednią wartość. Konstruujemy ją przez dodanie

do siebie ścieżki dostępu File1.Path

File1.Path

, znaku \

oraz właściwej nazwy pliku File1.filename

File1.filename

. Zmiennej nazwapliku

nazwapliku

używamy zaś jako parametru funkcji Image1.Picture = LoadPicture(nazwapliku). Dzięki temu

uzyskujemy na ekranie wybrany przez użytkownika plik graficzny.

Pozostało nam jeszcze wykonanie kilku kosmetycznych zmian. Zmienimy teraz napis na pasku tytułu formatki na

Przeglądarka graficzna

. W tym celu w oknie Properties

Properties

wybieramy z rozwijającej listy Form1 Form

Form1 Form

. Znajdujemy

właściwość Caption

Caption

i zmieniamy napis obok na Przeglądarka graficzna

Przeglądarka graficzna

. W tej chwili nasza aplikacja wyświetla

wszystkie pliki z wybranego przez użytkownika katalogu. My jednak wykorzystujemy tylko pliki graficzne JPG, GIF,
BMP. Powinniśmy zatem ograniczyć listę plików tylko do tych formatów. W tym celu musimy przypisać właściwości

Pattern

kontrolki File1

File1

odpowiednio spreparowany ciąg znaków. Dokładniej trzeba wpisać listę rozszerzeń plików,

które chcemy oglądać, oddzielając poszczególne wartości znakiem średnika.

W oknie Properties

Properties

wybieramy z rozwijanej listy pozycję File1 FileListBox

File1 FileListBox

. Odszukujemy właściwość Pattern

Pattern

wpisujemy ciąg znaków *.jpg; *.gif; *.bmp

*.jpg; *.gif; *.bmp

. Ostatnią rzeczą, którą musimy zrobić, jest zmuszenie naszej aplikacji do

skalowania wybranego obrazka, tak aby zajmował całą przestrzeń kontrolki Image1

Image1

. Jeśli tego nie zrobimy, przy

próbie załadowania większego pliku zobaczymy tylko jego fragment. Na szczęście operację skalowania wykonuje się
w bardzo prosty sposób. Skorzystamy po prostu ze znanej nam już właściwości Stretch

Stretch

W oknie Properties

Properties

z rozwijanej listy wybieramy pozycję Image1 Image

Image1 Image

. Odszukujemy właściwość Stretch

Stretch

ustawiamy jej wartość na True

True

Zapisujemy projekt na dysk. Nie zapomnijmy o tym! Po co ryzykować utratę całej pracy?

Wykonujemy test naszego programu. Uruchamiamy aplikację i wybieramy przykładowy plik graficzny.

Powinniśmy być zadowoleni. Napisaliśmy naprawdę efektowną aplikację. Nie spoczywajmy jednak na laurach. Naszą
przeglądarkę możemy jeszcze bardziej usprawnić i uatrakcyjnić. Warto byłoby na przykład dodać menu oraz
umożliwić użytkownikowi wybór, czy chce skalować obraz, czy nie.

RODZIAŁ V – Menu. Przeglądarka plików graficznych – ciąg dalszy.

Przygotowanie wersji instalacyjnej.

Potrafimy już napisać prawdziwy program. Naszą przeglądarkę można jednak udoskonalić. Gdy popatrzymy

uważnie, dostrzeżemy wiele szczegółów wymagających poprawy. W poprzednim rozdziale zaczęliśmy tworzyć
przeglądarkę plików graficznych. Powstał naprawdę efektowny program, za wcześnie jednak, by spocząć na laurach.
Naszą aplikację powinniśmy jeszcze usprawnić i uatrakcyjnić. Tym właśnie zajmiemy się w tym, niestety już
ostatnim rozdziale. Zacznijmy od dodania nowej, bardzo przydatnej funkcji. Otóż sprawimy, że użytkownik będzie
mógł zdecydować, czy wczytywany obrazek ma być skalowany, czy nie. W poprzedniej wersji naszego programu
czynności tej dokonywaliśmy za każdym razem. Dodamy więc do przeglądarki dodatkową opcję – element

checkbox

. Po zaznaczeniu go obraz będzie skalowany. Jeśli nie zostanie zaznaczony, wielkość obrazu nie będzie

zmieniana. Przystąpmy zatem do pracy.

Kodowania ciąg dalszy

Wczytujemy zapisany w poprzednim rozdziale projekt. Otwieramy widok formatki. Na palecie komponentów

odszukujemy ikonę ze znaczkiem w kształcie litery „v” i rysujemy kontrolkę Checkbox na formatce, tuż obok
elementu Drive1.

W oknie Properties

Properties

zmieniamy właściwość Caption

Caption

dodanego przed chwilą elementu na Skaluj obraz

Skaluj obraz

Pomyślmy teraz, w jaki sposób zrealizować skalowanie obrazu. Na pewno powinniśmy skorzystać z poznanej w
poprzednim rozdziale właściwości stretch, powodującej skalowanie obrazu, oraz instrukcji warunkowej if. Wydawać
by się mogło, że najprostsze rozwiązanie jest następujące:

Private Sub Check1_Click()

If Check1.Value = I Then

Image1.Stretch = True

Else

Image1.Stretch = False

End If

End Sub

Kod ten należy odczytywać następująco: jeśli pole wyboru jest zaznaczone, skaluj obraz, w przeciwnym

wypadku nie skaluj. Niestety, ta funkcja nie działa prawidłowo! Można się o tym przekonać, wpisując podane
instrukcje. Problem sprawia kontrolka Image. Otóż po ustawieniu właściwości stretch na false stara się ona na siłę
dopasować swoją wielkość do rozmiarów obrazu z pliku graficznego. W efekcie przybiera ona przypadkowe
rozmiary, a oryginalne wymiary nie są już potem przywracane! Musimy poradzić sobie z tym problemem.
Rozwiązanie jest następujące:

deklarujemy dwie dodatkowe zmienne, które będą przechowywały wysokość i szerokość komponentu
Image1,

przy każdej zmianie właściwości stretch wymuszamy zmianę wielkości kontrolki,

przy każdym wczytaniu obrazu również wymuszamy zmianę wielkości kontrolki.

Otwieramy okno kodu. Jeżeli nie ma go na ekranie, z menu View

View

wybieramy pozycję Code

Code

. Na samej górze okna

dopisujemy następujące deklaracje zmiennych:

Dim SizeX As Integer

Dim SizeY As Integer

Zmienna SizeX będzie przechowywała szerokość, a zmienna SizeY wysokości kontrolki Image1.

Powracamy do widoku formatki. Klikamy na nią dwukrotnie w dowolnym miejscu, w którym nie znajduje się

żaden element. Ponownie otwiera się okno kodu. Wpisane w nie instrukcje będą wykonywane przy każdym
uruchomieniu programu. Powodują one przypisanie zadeklarowanych w punkcie 3

zmiennym początkowych

rozmiarów kontrolki.

Inaczej pole wyboru. Element Windows pozwalający na zaznaczenie opcji. Tak samo nazywa się kontrolka Visual Basica umożliwiająca

dodanie takiego elementu do własnej aplikacji.

Klikamy dwukrotnie na pole wyboru Skaluj obraz

Skaluj obraz

. Otwiera się okno kodu. Wpisujemy następujący ciąg instrukcji:

Private Sub Check1_Click()

/If Check1.Value = 0 Then

/ Image1.Stretch = False

Else

\ Image1.Stretch = True

\End If

/Image1.Width = sizeX
B

_Image1.Height = sizeY

End Sub

Sprawdzamy najpierw stan pola wyboru A

, a następnie wymuszamy ustawianie wielkości komponentu Image1

. Musimy jeszcze dopisać instrukcje B

w jednym miejscu: w kodzie wykonywanym po kliknięciu na komponent

File1.

Klikamy dwukrotnie na komponent File1. do znajdujących się w nim instrukcji dopisujemy

Private Sub Check1_Click()

If Check1.Value = 0 Then

Image1.Stretch = False

Else

Image1.Stretch = True

End If

Image1.Width = sizeX
Image1.Height = sizeY

End Sub

Spróbujmy przetestować nasz program. Uruchamiamy aplikację. Wybieramy dowolny obrazek. Zaznaczamy pole

wyboru. Obraz zostaje ładnie przeskalowany do rozmiarów kontrolki. Wszystko zatem działa dokładnie tak, jak
zaplanowaliśmy.

Błędy

Mamy teraz zapewne ochotę pochwalić się naszą aplikację przed znajomymi. Powstrzymajmy się jednak

przez chwilę. Musimy jeszcze uodpornić przeglądarkę na pewien błąd. Co się bowiem stanie, jeśli wybrany przez
użytkownika plik nie będzie plikiem graficznym? Co prawda program nie wyświetla plików o rozszerzeniach innych
niż .jpg, .gif i .bmp, ale dokument może przecież być uszkodzony. A czy nasza aplikacja poradzi sobie, gdy ktoś dla
kawału zmieni rozszerzenie z .doc na .jpg? Prawdopodobnie któryś z naszych znajomych wykona właśnie taki lub
podobny test. Sprawdźmy, jak zareaguje aplikacja.

Przygotowujemy fałszywy plik z obrazem graficznym. Najlepiej zmienić rozszerzenie niepotrzebnego dokumentu

tekstowego na JPG.

Uruchamiamy przeglądarkę i wskazujemy spreparowany w punkcie 1

plik. Na ekranie pojawia się okno.

Klikamy na End

End

, aby zakończyć działanie programu. Jak widać, wybranie fałszywego pliku wywołuje bardzo

nieładne zachowanie aplikacji. Koniecznie zatem musimy rozwiązać ten problem. Na szczęście Visual Basic
dysponuje specjalną instrukcją, służącą do obsługi błędów. Ma ona postać:

On Error Goto XX

Zapis ten należy rozumieć następująco: Jeżeli wystąpi błąd, idź do miejsca w programie oznaczonego jako

XX. Poprawimy zatem nasz program tak, aby na dole formatki pojawiał się stosowny komunikat, jeżeli wybrany plik
nie będzie zawierał grafiki. Jeśli natomiast wskazany plik będzie prawidłowym plikiem graficznym, na formatce
wyświetli się jego nazwa.

Dodajemy na formatkę etykietę tekstową. Umieszczamy ją na dole ekranu.

Usuwamy znajdujący się na etykiecie tekst. W oknie Properties

Properties

odszukujemy właściwość Caption

Caption

i usuwamy

napis Label1

Label1

Klikamy dwukrotnie na kontrolkę File1. Modyfikujemy zawartość okna kodu, dodając instrukcje obsługi błędów.

Jeśli wystąpi błąd, zostanie wykonany blok instrukcji:

Pricvate Sub File1.Click()

On Error GoTo blad

Dim nazwa pliku As String

Nazwapliku = File1.Path + “\” + File1.FileName

Image1.Picture = LoadPicture(nazwapliku)

Image1.Width = sizeX

Image1.Height = sizeY

Label1.Caption = “Plik: “ + File1.FileName

Exit Sub

blad;

Image1.Picture = LoadPicture()
Label1.Caption = “Plik ‘” + File1.FileName + “’”
Label1.Caption = Label1.Caption + “ nie jest prawidłowym plikiem graficznym”

End Sub

Powoduje on wyświetlenie informacji, że wybrany plik nie jest prawidłowym plikiem z grafiką, oraz usunięcie

bieżącego obrazu z formatki.

Pozostaje nam sprawdzić, czy napisane przed chwilą instrukcje faktycznie spełniają postawione przed nimi

zadanie. Uruchamiamy aplikację i próbujemy wczytać prawdziwy plik graficzny. Obraz jest wyświetlany na ekranie,
na dole formatki znajduje się informacja o nazwie pliku. Spróbujmy teraz otworzyć spreparowany wcześniej
nieprawidłowy plik. Widzimy, że dotychczas wyświetlany obraz znika i na dole ekranu pojawia się informacja: Plik

Plik

‘grafika.jpg’ nie jest prawidłowym plikiem graficznym

Menu

Nasza przeglądarka jest już gotowa, dodamy jednak do niej jeszcze jeden element – menu. Przekonamy się, że

w Visual Basicu robi się wyjątkowo łatwo za pomocą modułu nazywanego edytorem menu (ang. Menu Editor).

Z menu Tools

Tools

wybieramy pozycję Menu Editor

Menu Editor

lub wciskamy kombinację klawiszy Ctrl+E

Ctrl+E

. Widzimy okno

dialogowe.

Definiujemy menu główne Plik

Plik

. W pole Caption

Caption

wpisujemy Plik

Plik

. Jednocześnie pojawia się dodatkowa pozycja w

dolnej części okna.

Musimy teraz nadać tej pozycji menu nazwę – inaczej nie moglibyśmy wykonywać na niej żadnych operacji. W

pole Name

Name

wpisujemy menuPlik

menuPlik

. Klikamy na OK

. Nasza formatka zyskuje w ten sposób menu główne. Do menu

Plik dodamy w sumie cztery pozycje, tak aby w efekcie osiągnąć strukturę:

Pik

Otwórz
Zamknij
Zakończ

Wciskamy kombinację klawiszy Ctrl+E

Ctrl+E

, aby ponownie otworzyć edytor menu. Pozycja, którą dodaliśmy przed

chwilą, jest teraz zaznaczona. Ponieważ chcemy zdefiniować podmenu zawarte w menu File

File

, klikamy na białe pole

tuż pod menu File

File

Pole to zostaje zaznaczone. Klikamy na znak ze strzałką w prawo. W ten sposób informujemy edytor, że chcemy

definiować podmenu. W pole Caption

Caption

wpisujemy Otwórz

Otwórz

, a w pole Name

Name

– menuOtwórz

menuOtwórz

Klikamy na białe pole. Zostaje ono zaznaczone.

Analogicznie jak w punkcie 5

definiujemy menu Zamknij

Zamknij

. Nadajemy mu nazwę menuZamknij

menuZamknij

W tej chwili naszej strukturze menu powinien pojawić się separator. Uzyskujemy go w taki sam sposób, jak każde

inne menu, należy jedynie wpisać w okno Caption

Caption

znak – (minus). W polu Name

Name

podajemy natomiast

menuSeparator

Ostatnia pozycja w naszej strukturze to Zakończ

Zakończ

. Temu menu, jak łatwo się domyślić, nadajemy nazwę

menuZakończ

. Po zakończeniu edycji menu klikamy na OK

. Od razu możemy zobaczyć efekt naszej pracy.

Menu i kod

Wyposażyliśmy naszą aplikację w menu, które jednak… nic nie robi. Nie powinno nas to dziwić, aplikacja

sama nie może domyślić się, jakie zadania ma wykonać po wybraniu przez użytkownika jednej z pozycji. Naszym
zadaniem jest poinformować ją o tym, czyli do każdego menu przypisać odpowiednie instrukcje kodu. Zatem po
wybraniu:



Otwórz

należy wyświetlić okno dialogowe i wczytać wybrany obrazek,



Zamknij

należy usunąć aktualnie wyświetlany obraz z ekranu,



Zakończ

należy zakończyć pracę aplikacji.

Zrealizowanie tych funkcji nie powinno przysporzyć nam większego problemu.

Dodajemy na formatkę komponent CommonDialog

CommonDialog

. Jeśli nie możemy go odszukać, zapewne nie został dodany do

palety. Zajrzyjmy do ramki Jak dodać komponent.

Jak dodać komponent

Standardowo na palecie komponentów znajdują się ikony tylko najczęściej używanych elementów. Czasami aby
zrealizować bardziej zaawansowane zadania, trzeba skorzystać z dodatkowych kontrolek. Musimy zatem wiedzieć,
w jaki sposób dodać je do palety. Będziemy mogli używać ich wtedy bez ograniczeń. Całą procedurę poznamy na
przykładzie kontrolki Common Dialog

Common Dialog

, pozwalającej między innymi na wyświetlenie okna dialogowego, służącego

do wyboru plików. Klikamy na paletę komponentów prawym przyciskiem myszy. Pokazuje się menu, z którego
wybieramy pozycję Components

Components

. Na ekranie widzimy nowe okno dialogowe. Zakładka Controls

Controls

zawiera listę

komponentów, z których możemy korzystać. Jeśli chcemy korzystać z komponentu Common Dialog

Common Dialog

musimy

odszukać i zaznaczyć element Microsoft Common Dialog Control 6.0

Microsoft Common Dialog Control 6.0

oraz kliknąć na przycisk OK

. Gdy to

zrobimy, na palecie komponentów pojawi się ikonka. Możemy teraz korzystać z nowej kontrolki bez ograniczeńm
tak jak z pozostałych widocznych na palecie komponentów.

Klikamy na dodaną przed chwilą kontrolkę. W oknie Properties

Properties

odszukujemy właściwość Filter

Filter

i wpisujemy ciąg

znaków obok niej: Pliki graficzne|*.jpg; *.gif; *.bmp

Pliki graficzne|*.jpg; *.gif; *.bmp

. Dzięki temu w oknie dialogowym będą wyświetlane tylko

pliki z rozszerzeniem .jpg .gif .bmp.

W widoku formatki z menu Plik

Plik

wybieramy pozycję Otwórz

Otwórz

. Otwiera się okno kodu, w którym widzimy:

Private Sub menuOtworz_Click()

End Sub

Wpisujemy instrukcje powodujące wyświetlenie standardowego okna dialogowego, służącego do wyboru plików,

oraz wyświetlające wybrany obraz na ekranie. Wykonujemy następujące czynności:

deklarujemy zmienną nazwa,

wyświetlamy na ekranie okno dialogowe służące do wyboru plików,

przypisujemy zmiennej nazwa nazwę wybranego przez użytkownika pliku,

wczytujemy plik graficzny i wyświetlamy go na ekranie,

zmieniamy rozmiar komponentu Image1,

wyświetlamy informację o wczytanym pliku na dole formatki.

Powinniśmy pamiętać przy tym o obsłudze błędu, kiedy wybrany zostanie plik nie zawierający grafiki G

Private Sub menuOtworz_Click()

On Error GoTo blad

Dim nazwa As String

CommnoDialog1.ShowOpen

nazwa = CommonDialog1.FileName

Image1.Picture = LoadPicture(nazwa)

Image1.Width = sizeX

Image1.Height = sizeY

__Label1.Caption = “Plik: “ + File1.FileName

\_Exit Sub

blad:

Image1.Picture = LoadPicture()

Label1.Caption = “Plik: ‘“ + File1.FileName + “’”

Label1.Caption = Label1.Caption + “ nie jest prawidłowym plikiem graficznym”

End Sub

Powracamy do widoku formatki. W menu Plik

Plik

klikamy myszką na pozycję Zamknij

Zamknij

. W okno kodu wpisujemy

instrukcję:

Private Sub menuZamknij_Click()

Image1.Picture = LoadPicture (””)

End Sub

Ma ona spowodować usunięcie aktualnie wyświetlanego obrazka z formatki. Pozostało nam przypisanie kodu

do menu Zakończ

Zakończ

. Zadaniem tej instrukcji oczywiście będzie powodowanie zakończenia pracy całej aplikacji. Jej

postać pamiętamy z pewnością z poprzedniego rozdziału.

Z menu Plik

Plik

wybieramy pozycję Zakończ

Zakończ

. W okno kodu wpisujemy:

Private Sub menuZakoncz_Click()

Unload Form1

End Sub

W ten sposób wyposażyliśmy przeglądarkę w menu. Dzięki temu na pewno będzie atrakcyjniejsza dla

użytkowników. Napisaliśmy też właśnie ostatnią instrukcję naszej aplikacji. Możemy być dumni – powstał naprawdę
ciekawy i funkcjonalny program.

Przygotowanie wersji instalacyjnej

Do przygotowania wersji instalacyjnej służy dodatkowy program Package and Deployment Wizard

Package and Deployment Wizard

Znajdziemy go w wersji Proffesional i Visual Studio. Spróbujmy odszukać tę aplikację w menu Start

Start

, Programy

Programy

na zakładce Microsoft Visual Basic

Microsoft Visual Basic

Po uruchomieniu programu na ekranie pokazuje się okno. Klikamy na Browse

Browse

i wybieramy projekt

imgbrowser.vbp

Nazwa projektu wraz z pełną ścieżką pojawia się w polu Select Project

Select Project

. Klikamy na ikonę Package

Package

Rozpoczyna się proces przygotowywania wersji instalacyjnej. Program sprawdza, czy w katalogu projektu znajduje

się najnowsza wersja aplikacji. Jeśli nie, spyta, czy chcemy dokonać kompilacji kodu. Klikamy na Tak

Tak

Kolejne okno pozwala na wybór typu pakietu instalacyjnego. Interesuje nas instalacja standardowa. Wybieramy

więc Standard Setup Package

Standard Setup Package

i klikamy na Next

Next

Pojawia się kolejne okno. Umożliwia ono wybór katalogu, w którym ma znaleźć się przygotowany pakiet

instalacyjny. Dokonujemy wyboru i klikamy na Next

Next

Jeżeli w punkcie 5

podaliśmy nieistniejący katalog, program pyta, czy chcemy go utworzyć. Klikamy oczywiście

Next

Kolejne okno to lista plików, które znajdują się w naszym pakiecie instalacyjnym. Jeżeli chcemy dodać plik,

klikamy na Add

Add

. W tym wypadku nie ma takiej potrzeby, klikamy więc na Next

Next

W tej chwili musimy zdecydować, czy pakiet instalacyjny ma być podzielony na kilka plików o określonej

wielkości, tak aby zmieściły się na przykład na dyskietkach, czy też chcemy użyć jednego dużego pliku. Nasz
program nie jest zbyt duży, wybieramy więc Single cab i klikamy na Next

Next

Podajemy tekst, jaki będzie wyświetlany podczas instalacji. Powinna być to nazwa naszej aplikacji.

W kolejnym oknie ustalamy, w którym miejscy menu Start

Start

zostanie zainstalowany nasz program.

Wybieramy katalog, w którym ma się znaleźć aplikacja. Użytkownik będzie miał oczywiści możliwość

dokonania własnego wyboru podczas instalacji.

Kolejne okno odnosi się do plików, które mają być współdzielone przez kilka aplikacji. Nie dotyczy to naszego

programu, klikamy więc na Next

Next

Wszystkie informacje niezbędne do utworzenia pakietu instalacyjnego są już zebrane. Wybieramy teraz nazwę,

pod jaką zostaną zapisane na dysku. Pozostawmy zaproponowaną przez program. Tak zapisane dane będziemy mogli
wykorzystać przy kolejnym tworzeniu wersji instalacyjnej. Klikamy na Finish

Finish

Po chwili pojawia się okno informujące o zakończeniu procesu tworzenia wersji instalacyjnej. Po kliknięciu na

Close

wracamy do okna Package & Deployment Wizard

Package & Deployment Wizard

. Zamykamy je, klikając na Close

Close

Zaglądamy do katalogu, który wybraliśmy jako docelowy dla tworzonego pakietu instalacyjnego. Widzimy w

nim trzy pliki. To właśnie nasza wersja instalacyjna.

Teraz możemy przesłać nasz program wszystkim znajomym. Pamiętajmy tylko, że wersja instalacyjna składa

się z trzech plików i jeśli chcemy ją komuś przekazać, musimy koniecznie przesłać wszystkie trzy. Oczywiście nic
nie stoi na przeszkodzie, aby korzystać tylko z pliku wykonywalnego wygenerowanego przez Visual Basic. Może to
nawet być wygodniejsze, ponieważ nie trzeba wtedy przechodzić całej procedury instalacyjnej. Program sprawia
jednak przez to wrażenie mniej profesjonalnego.

Wyszukiwarka

Podobne podstrony:
Kurs Visual Basic dla początkujących, Języki programowania
kurs+visual+basic%27a ZQI63ESWFA6RV2NSDJNG3PDNCTT5FCM7QKZEK5Q
praktyczny kurs visual basic net XPYVI3QBP3MCXRIFJRISPLODUH6ANI5R5DTEUTQ
ZAAWANSOWANY KURS VISUAL BASIC BY SLASH
Visual Basic Dla Aplikacji W Programach Word, Powerpoint I Excel Praktyczny Kurs Z Cwiczeniami
Visual Basic Przykładowe zadania , Studia i nauka, Visual Basic
Lab6, Visual Basic Lab 6a, Visual Basic Lab 3
Leksykon VISUAL BASIC, r00-05, Rozdział X
Visual Basic Zdarzenia , Studia i nauka, Visual Basic
visual basic
02 Wprowadzenie do Visual Basic cwiczenia przygotowujace
Makra programowanie w Visual Basic
Mastering Visual Basic NET Database Programming
Leksykon VISUAL BASIC, r01-05, Rozdział X
Visual Basic Operatory , Studia i nauka, Visual Basic

więcej podobnych podstron