Tworzenie aplikacji
Ustawienie właściwości formularza | Dodawanie kontrolek do formy | Ustawienie właściwości kontrolek | Dodawanie menu do aplikacji | Dodawanie kodu programu | Testowanie aplikacji
Przykładowa aplikacja
Tworzenie aplikacji w Visual Basic składa się z wykonywania trzech podstawowych kroków:
ustawienie interfejsu (wyglądu) aplikacji
ustawienie właściwości
pisanie kodu programu
Visual Basic jest narzędziem programistycznym, które umożliwia szybkie i łatwe tworzenie i modyfikowanie aplikacji. Zwykle wykonuje się wielokrotnie trzy powyższe kroki, aby sprawdzić i dopasować wygląd i zachowanie aplikacji.
Można dodać element sterujący do formularza, ustawić jego właściwości, dodać odpowiedni kod i uruchowmić aplikację, aby sprawdzić jej działanie. Jeżeli trzeba zmienić działanie lub wygląd można zmienić właściwości i kod programu, po czym, sprawdzić działanie wprowadzonych zmian. Potem można dodać kolejny element sterujący i powtórzyć czynności. Można również dodać wszystkie potrzebne elementy interfejsu, ustawić wszystkie właściwości i dodać cały kod programu i dopiero wtedy sprawdzić działanie aplikacji.
Pierwszym działaniem przy tworzeniu aplikacji w Visual Basic jest ustawienie interfejsu.
Typowe aplikacje działające pod kontrolą systemu Microsoft Windows mają wiele typowych i charakterystycznych cech i elementów. Standaryzacja interfejsów użytkownika Windows powoduje łatwość uczenia się działania aplikacji Windows. Ta standaryzacja ułatwia również zadanie programistom, ponieważ nie zachodzi konieczność definiowania nowego interfejsu dla każdej tworzonej aplikacji. Przy tworzeniu aplikacji w Visual Basic, większość pracy polegającej na projektowaniu interfejsu użytkownika jest już wykonana lub bardzo uproszczona. Formularze i elementy sterujące pozwalają na szybkie i łatwe dodawanie typowych składników interfejsu aplikacji. Elementy sterujące, zwane kontrolkami, umożliwiają stosowanie typowych składników aplikacji systemu Windows, wyglądających i zachowujących się zgodnie z ich przeznaczeniem. Elementy te mają zdefiniowane pewne typowe cechy i zachowania, np. okna tekstowe umożliwiają wprowadzanie tekstu i mają migający wskaźnik a przyciski poleceń mają charakterystyczny prostokątny wygląd i tekst identyfikujący działanie. Żadna ze zdefiniowanych cech nie wymaga pisania kodu programu, a jedynie wybrania lub ustawienia odpowiednich właściwości (większość z nich jest ustawiona na domyślne wartości).
Aby jednak te elementy wykonywały określone zadania należy dopisać kod programu.
Ustawienie właściwości formularza
Okno formularza, jest pierwszym oknem zainteresowania programisty. Wydaje się ono dość niepozorne w stosunku do innych okien platformy Visual Basic, ale to formularz stanowi podstawę tworzonej aplikacji. Jest on głównym oknem tworzonej aplikacji. Na nim będą się znajdowały wszystkie elementy interfejsu użytkownika. Gdy użytkownik uruchomi tworzoną aplikację, zobaczy okno formularza ze znajdującymi się na nim elementami.
Pierwszą czynnością przy tworzeniu nowej aplikacji jest ustawienie właściwości formularza. Część właściwości można ustawić w oknie Properties, część w kodzie programu a część w oknie Form.
Jeżeli formularz (forma) jest wybrany to wokół niego pojawiają się kwadratowe wskaźniki. Jeżeli kursor myszki zostanie przesunięty nad taki wskaźnik, to można zmienić rozmiar formy. Wskaźnik pod formą pozwala na zmianę jej wysokości, wskaźnik po prawej stronie formy pozwala na zmianę jej szerokości, a wskaźnik w prawym dolnym rogu formy pozwala na równoczesną zmianę obydwu rozmiarów. Aby to zrobić, należy zatrzymać kursor myszki nad wskaźnikiem, przycisnąć lewy przycisk myszy i trzymając wciśnięty przesunąć kursor myszki w odpowiednią stronę. Zwolnienie lewego klawisza myszy akceptuje wprowadzenie nowego rozmiaru.
Innym sposobem na zmianę rozmiarów formy jest zmiana właściwości w oknie Properties. Właściwość Height jest odpowiedzialna za wysokość formy, a właściwość Width za jej szerokość. Aby zmienić wartość właściwości należy ustawić kursor myszki nad okienkiem określającym wartość właściwości (z prawej strony okieka z nazwą właściwości) i kliknąć. Należy wprowadzić nową wartość i zatwierdzić wciskając ENTER lub klikając myszką poza tym okienkiem.
Kolejną właściwością, jaką należy zmienić jest właściwość Name. Wprawdzie Visual Basic automatycznie ustawia właściwość Name, jednak wprowadzenie swojej nazwy kojarzącej się z działaniem lub zawartością formy (elementu) ułatwia pisanie kodu i zarządzanie aplikacją. Nazwę formy należy wybrać zgodnie z konwencją nazywania obiektów. Można np. nazwać formę - frmKalkulator lub frmListaAdresatow. Właściwość Name wykorzystywana jest do odwoływania się do formy w czasie wykonywania programu.
W oknie Properties należy ustawić właściwość BorderStyle, odpowiedzialną za rodzaj obramowania formy, wybierając odpowiednią wartość z rozwijanej listy.
Właściwość Caption odpowiedzialna jest za napis wyświetlany na pasku tytułowym formy. Domyślnie Visual Basic wstawia tam domyślną nazwę obiektu, jednak dobrze jest wpisać tam nazwę aplikacji, aby użytkownik widział nazwę aplikacji w oknie i na pasku zadań Windows.
Właściwość ControlBox określa, czy forma będzie zawierać przyciski Minimalizuj, Maksyamalizuj, Zamknij. Aby wyłączyć poszczególne przyciski należy zmienić właściwości MinButton i MaxButton.
Właściwość Icon pozwala wybrać ikonę formy, która będzie wyświetlana na pasku zadań Windows.
Forma z ustawionymi właściwościami jest gotowym szkieletem do tworzenia interfejsu użytkownika.
Dodawanie kontrolek do formy
Kontrolki to elementy interfejsu użytkownika, które umieszczone na formie spełniają określone działania. Visual Basic dostarcza zestaw standartowych kontrolek, wśród których znajdują się: CommandButton - przycisk poleceń, Label - etykieta, TextBox - okno tekstowe, OptionButton - pole opcji, CheckBox - pole wyboru, ListBox - pole listy, VScrollBar, HScrollBar - paski przewijania, i inne.
Standartowe kontrolki znajdują się na palecie narzędzi (okno Toolbox). W miarę potrzeb można powiększyć paletę narzędzi o dodatkowe kontrolki przez wybranie polecenia Components menu Project, które wywołuje okno Components.
Aby dodać odpowiednią kontrolkę do formularza, można wykorzystać jeden z dwóch sposobów:
Ustawienie właściwości kontrolek
Po narysowaniu kontrolki na formularzu można zmienić jej właściwości. Część właściwości można ustawić w oknie Properties, część w kodzie programu a część w oknie Form.
Jeżeli kontrolka jest wybrana to wokół niej pojawiają się kwadratowe wskaźniki. Jeżeli kursor myszki zostanie przesunięty nad taki wskaźnik, to można zmienić rozmiar kontrolki. Wskaźniki nad i pod kontrolką pozwalają na zmianę jej wysokości, wskaźniki po prawej i lewej stronie kontrolki pozwalają na zmianę jej szerokości, a wskaźnik w rogach kontrolki pozwalają na równoczesną zmianę obydwu rozmiarów. Aby to zrobić, należy zatrzymać kursor myszki nad wskaźnikiem, przycisnąć lewy przycisk myszy i trzymając wciśnięty przesunąć kursor myszki w odpowiednią stronę. Zwolnienie lewego klawisza myszy akceptuje wprowadzenie nowego rozmiaru.
Aby przesunąć kontrolkę na formularzu, należy przesunąć kursor myszki nad kontrolkę, wcisnąć lewy przycisk myszki i trzymając, przesunąć kursor myszki. Szary prostokąt reprezentuje nową pozycję kontrolki. Aby zaakceptować nową pozycję, należy zwolnić lewy przycisk myszki. W miejsce szarego prostokąta pojawi się przesunięta kontrolka.
Aby usunąć kontrolkę z formy, należy wybrać kontrolkę i wcisnąć klawisz DEL.
Innym sposobem na zmianę rozmiarów i położenia kontrolki jest zmiana właściwości w oknie Properties. Właściwość Height jest odpowiedzialna za wysokość kontrolki, a właściwość Width za jej szerokość. Właściwości Left, Top odpowiedzialne są za położenie kontrolki na formie. Aby zmienić wartość właściwości należy ustawić kursor myszki nad okienkiem określającym wartość właściwości (z prawej strony okieka z nazwą właściwości) i kliknąć. Należy wprowadzić nową wartość i zatwierdzić wciskając ENTER lub klikając myszką poza tym okienkiem.
Kolejną właściwością, jaką należy zmienić jest właściwość Name. Wprawdzie Visual Basic automatycznie ustawia właściwość Name, jednak wprowadzenie swojej nazwy kojarzącej się z działaniem lub zawartością kontrolki ułatwia pisanie kodu i zarządzanie aplikacją. Nazwę kontrolki należy wybrać zgodnie z konwencją nazywania obiektów. Można np. nazwać pole tekstowe - txtLiczba lub txtNazwisko. Właściwość Name wykorzystywana jest do odwoływania się do kontrolki w czasie wykonywania programu.
Pozostałe właściwości są różne dla różnych kontrolek. Najczęściej zmieniane są właściwości:
Alignment - sposób wyrównania tekstu w kontrolce, Align - wyrównanie kontrolki na formie, AutoSize - automatyczne dopasowanie rozmiaru kontrolki, BorderStyle - rodzaj obramowania kontrolki, Caption - tekst zawarty w kontrolce, Enabled - dostępność kontrolki przez użytkownika, Style - sposób wyświetlania kontrolki, TabIndex - numer kontrolki na formie, Text - tekst kontrolki, ToolTipText - podpowiedź dla użytkownika, Value - wartość kontrolki, Visible - widzialność kontrolki.
Powtarzając powyższe czynności można dodać do formularza wiele różnych kontrolek i ustawić ich właściwości.
1. Należy kliknąć dwukrotnie na odpowiedniej kontrolce w oknie Toolbox. Wybrana kontrolka pojawi się na formularzu. Będzie się znajdować na środku formularza i będzie mieć domyślny rozmiar. Jeżeli w tym miejscu znajduje się już jakiś element, to zostanie on przesłonięty.
Można zmienić rozmiar i pozycję kontrolki na formularzu.
2. Na palecie narzędzi należy wybrać odpowiednią kontrolkę, przez jednokrotne kliknięcie na ikonie kontrolki. Kursor myszki należy przenieść nad formularz, w miejsce, gdzie będzie znajdował się jeden z rogów kontrolki. Należy przycisnąć lewy klawisz myszki. Kursor zmieni kształt na krzyży. Teraz, trzymając wciśnięty klawisz, należy przesunąć kursor myszki w miejsce, gdzie będzie się znajdował przeciwległy róg kontrolki. Szary prostokątny reprezentuje pozycję i rozmiar tworzonej kontrolki. Aby zaakceptować rozmiar kontrolki, należy zwolić lewy klawisz myszki. Szary prostokąt zniknie a w jego miejsce pojawi się kontrolka.
Ustawienie właściwości kontrolek
Po narysowaniu kontrolki na formularzu można zmienić jej właściwości. Część właściwości można ustawić w oknie Properties, część w kodzie programu a część w oknie Form.
Jeżeli kontrolka jest wybrana to wokół niej pojawiają się kwadratowe wskaźniki. Jeżeli kursor myszki zostanie przesunięty nad taki wskaźnik, to można zmienić rozmiar kontrolki. Wskaźniki nad i pod kontrolką pozwalają na zmianę jej wysokości, wskaźniki po prawej i lewej stronie kontrolki pozwalają na zmianę jej szerokości, a wskaźnik w rogach kontrolki pozwalają na równoczesną zmianę obydwu rozmiarów. Aby to zrobić, należy zatrzymać kursor myszki nad wskaźnikiem, przycisnąć lewy przycisk myszy i trzymając wciśnięty przesunąć kursor myszki w odpowiednią stronę. Zwolnienie lewego klawisza myszy akceptuje wprowadzenie nowego rozmiaru.
Aby przesunąć kontrolkę na formularzu, należy przesunąć kursor myszki nad kontrolkę, wcisnąć lewy przycisk myszki i trzymając, przesunąć kursor myszki. Szary prostokąt reprezentuje nową pozycję kontrolki. Aby zaakceptować nową pozycję, należy zwolnić lewy przycisk myszki. W miejsce szarego prostokąta pojawi się przesunięta kontrolka.
Aby usunąć kontrolkę z formy, należy wybrać kontrolkę i wcisnąć klawisz DEL.
Innym sposobem na zmianę rozmiarów i położenia kontrolki jest zmiana właściwości w oknie Properties. Właściwość Height jest odpowiedzialna za wysokość kontrolki, a właściwość Width za jej szerokość. Właściwości Left, Top odpowiedzialne są za położenie kontrolki na formie. Aby zmienić wartość właściwości należy ustawić kursor myszki nad okienkiem określającym wartość właściwości (z prawej strony okieka z nazwą właściwości) i kliknąć. Należy wprowadzić nową wartość i zatwierdzić wciskając ENTER lub klikając myszką poza tym okienkiem.
Kolejną właściwością, jaką należy zmienić jest właściwość Name. Wprawdzie Visual Basic automatycznie ustawia właściwość Name, jednak wprowadzenie swojej nazwy kojarzącej się z działaniem lub zawartością kontrolki ułatwia pisanie kodu i zarządzanie aplikacją. Nazwę kontrolki należy wybrać zgodnie z konwencją nazywania obiektów. Można np. nazwać pole tekstowe - txtLiczba lub txtNazwisko. Właściwość Name wykorzystywana jest do odwoływania się do kontrolki w czasie wykonywania programu.
Pozostałe właściwości są różne dla różnych kontrolek. Najczęściej zmieniane są właściwości:
Alignment - sposób wyrównania tekstu w kontrolce, Align - wyrównanie kontrolki na formie, AutoSize - automatyczne dopasowanie rozmiaru kontrolki, BorderStyle - rodzaj obramowania kontrolki, Caption - tekst zawarty w kontrolce, Enabled - dostępność kontrolki przez użytkownika, Style - sposób wyświetlania kontrolki, TabIndex - numer kontrolki na formie, Text - tekst kontrolki, ToolTipText - podpowiedź dla użytkownika, Value - wartość kontrolki, Visible - widzialność kontrolki.
Powtarzając powyższe czynności można dodać do formularza wiele różnych kontrolek i ustawić ich właściwości.
Dodawanie menu do aplikacji
Większość poleceń i opcji aplikacji systemu Windows dostępnych jest z menu aplikacji. Visual Basic umożliwia programiście szybkie i łatwe projektowanie menu dla tworzonych aplikacji.
Kontrolka Menu różni się nieco od innych kontrolek Visual Basic. Nie występuje ona w oknie narzędzi Toolbox a jest wywoływana przez użycie Menu Editor.
Menu Editor jest oknem dialogowym, które można wywołać z okna formularza przez użycie klawisza skrótu CTRL+E, kliknięcie ikony Menu Editor na pasku narzędziowym lub wybranie pozycji Menu Editor z menu Tools.
Menu Editor składa się z narzędzi do opisu menu, które pozwoli na określenie paska menu, poleceń i klawiszy skrótów tworzonej aplikacji. Pozwala dodać menu z rozwijalnymi listami poleceń (podmenu), linie separujące (separator bars), znaczniki (checkboxes) i klawisze skrótu.
Każdy element menu (polecenie, separator albo podmenu) posiada swój własny zestaw właściwości. Menu Editor ułatwia ustawienie tych właściwości.
W oknie Caption należy wpisać odpowiedni nagłówek (tytuł) menu (np. &Plik). Jest to tekst, który pojawi się w menu. Znak & określa klawisz szybkiego dostępu. Znak znajdujący się bezpośrednio za & jest znakiem szybkiego dostępu i w menu jest podkreśloną literą. Aby wywołać menu z klawiatury można przycisnąć ALT+klawisz_dostępu (w tym przypadku ALT+P).
Aby wstawić separator do menu należy w polu Caption wstawić znak - (minus).
W polu Name należy wstawić nazwę menu (np. mnuPlik). Jest to nazwa, która będzie wykorzystywana do odwoływania się do pozycji menu.
Programiści zwykle stosują przedrostek mnu do nazw pozycji menu (np. mnuPlik dla pozycji Plik, mnuPlikNowy dla pozycji Nowy w menu Plik).
W polu Shortcut można wybrać klawisz skrótu, którego wciśnięcie wywoła bezpośrednio pozycję menu. Klawisze skrótów nie są dostępne dla menu rozwijanych, a jedynie dla pozycji menu lub pozycji podmenu (nie można przypisać klawisza skrótu do menu Plik, ale można do pozycji Nowy w menu Plik).
Klawisze strzałek pozwalają na przechodzenie po pozycjach menu i tworzenie podmenu. Strzałka w prawo powoduje przesunięcie pozycji na niższy poziom (do podmenu), strzałka w lewo na wyższy poziom. Poziom pozycji wyznacza, gdzie pojawi się ona w hierarchi menu aplikacji. Pozycje głównego menu (Plik, Edycja) pojawiają się na pasku menu aplikacji. Pozycje niższego poziomu (Nowy, Otwórz, Zapisz, Zapisz jako, Koniec) pojawiają się wewnątrz rozwijanego menu pozycji głównych. Pozycje podmenu (Binarny, Sekwencyjny) pojawiają się na kolejnych menu rozwijanych.
Można określić do czterech poziomów pozycji menu.
Strzałki w górę i w dół pozwalają na przesuwanie się po elementach menu.
Aby dodać kolejny element menu należy wcisnąć klawisz Next.
Aby wstawić nową pozycję w środek menu, należy przesunąć zaznaczenie na odpowiednią pozycję i wcisnąć kalwisz Insert.
Aby usunąć pozycję menu należy ją zaznaczyć i wcisnąć klawisz Delete.
Pole Enabled ustawia właściwość Enabled pozycji określającą dostępność pozycji.
Pole Visible określa pokazanie lub ukrycie pozycji menu.
Pole Checked pozwala na wstawienie znacznika (chcekbox) do pozycji menu.
Pole WindowList pozwala na automatyczne wstawienie listy otwartych okien w aplikacjach MDI.
Po zakończeniu tworzenia pozycji menu, należy klinąć OK.
Dodawanie kodu programu
Umieszczając na formularzach kontrolki i nadając im odpowiednie właściwości, można tworzyć efektowne aplikacje. Jednak nie będą one w pełni funkcjonalne, ponieważ kontrolki standartowo wykonują tylko podstawowe zadania. Np. okienko tekstowe pozwala wprowadzać i zaznaczać tekst a przycisk poleceń może wyglądać jak wciśnięty lub wyciśnięty, ale nie potrafi zakończyć aplikacji (nawet jeżeli takie jest jego docelowe znaczenie) dopóki nie zostanie dopisany odpowiedni kod programu, który to wykona. Funkcjonalność kontrolek zależy od programisty. To on musi stworzyć kod programu, który odpowiednio zareaguje na jakieś zachowanie użytkownika. Kod programu jest zbiorem instrukcji odpowiedzialnych za przetwarzanie danych, przyjmowania ich, wyprowadzanie i komunikowania się z użytkownikiem.
Aby wyświetlić kod programu dla obiektu należy:
kliknąć dwukrotnie na obiekcie
wybrać obiekt i wcisnąć F7
wybrać obiekt i wybrać pozycję Code z menu View
wybrać obiekt i kliknąć przycisk View Code w oknie Project
Visual Basic zawsze pokazuje kod programu w oknie działającym jak edytor tekstu. Można w nim dokonywać podstawowych operacji takich jak wstawianie, usuwanie, kopiowanie, wklejanie, przenoszenie tekstu. Mino, że Visual Basic jest raczej środowiskiem graficznym, wprowadzany kod programu jest tekstem.
Programowanie zdarzeniowe
Programy tworzone w Visual Basic są programami zdarzeniowymi. Kod procedury jest wywoływany przez wystąpnienie jakiegoś zdarzenia. Najczęściej są to zdarzenia użytkownika, np. wciśnięcie klawisza, lub przesunięcie kursora myszki. Program czeka na działanie użytkownika, czyli na zdarzenie i reaguje na to zdarzenie przez uruchomienie odpowiedniej procedury obsługi zdarzenia po czym kontynuuje oczekiwanie na kolejne zdarzenie.
Zdarzenia występują dla wszystkich elementów w interfejsie użytkownika, form, kontrolek, menu, okien tekstowych, okien obrazów itd. Każdy obiekt ma zapewnioną obsługę każdego zdarzenia. Np. jeżeli program ma wykonać jakieś działanie po wciśnięciu przycisku, należy dodać odpowiedni kod programu do procedury zdarzenia Click kontrolki CommandButton. Przesunięcie kursora myszki nad jakimś obiektem wywoła zdarzenie MouseMove tego obiektu i tam należy dopisać odpowiedni kod.
Wszystkie procedury zdarzeniowe mają swoje unikalne nazwy zbudowane zawsze w ten sam sposób:
NazwaObiektu_NazwaZdarzenia()
Nawiasy nie są częścią nazwy, mogą zawierać parametry przekazywane do procedury. Nazwy procedur zdarzeniowych zależą od Visual Basic a nie od programisty. Np. dla przycisku o nazwie cmdAnuluj procedura zdarzenia Click zawsze będzie miała nazwę cmdAnuluj_Click(). Procedura tego zdarzenia będzie wykonana tylko wtedy, gdy użytkownik kliknie przycisk o nazwie cmdAnuluj.
Dwukrotne kliknięcie obiektu w fazie projetowania wywoła okno kodu ustawione na domyślnej procedurze zdarzenia odpowiedniej dla obiektu. Np. dwukrotne kliknięcie na przycisku cmdAnuluj wywoła okno kodu ustawione na procedurę zdarzenia cmdAnuluj_Click().
Visual Basic automatycznie wstawia linie początku i końca procedury. Programista musi dopisać jej ciało.
Aby wybrać procedurę innego zdarzenia, należy rozwinąć listę Procedure/Event Box okna Code i wybrać odpowiednie zdarzenie.
Aby wybrać procedurę dla innego obiektu, należy rozwniąć listę ObjectBox i wybrać odpowiedni obiekt.
Jeżeli z listy ObjectBox wybrana zostanie pozycja (General) to lista Procedure/Event Box zmieni wartość na (Declarations) a okno kodu ustawi się na miejsce deklaracji ogólnych.
Jeżeli dodane zostaną jakieś funkcje lub procedury to będzie można je wybrać z listy Procedure/Event Box.
Procedury
Procedury i funkcje nie odpowiadają na zdarzenia, lecz są wykonywane, gdy zostaną wywołane z innej części programu.
Procedura jest szeregiem instrukcji, które są wykonywane jako jedna całość, gdy procedura zostanie wywołana. Procedury Sub (procedury) wykonują określone działania ale nie zwracają wartości. Procedury Function (funkcje) wykonują określone działania i zwracają wartość do miejsca, skąd zostały wywołane.
Aby dodać procedurę lub funkcję do programu należy wybrać pozycję Add Procedure z menu Tools.
W polu Name należy wpisać nazwę procedury. Należy wybrać jedną z opcji ramki Type: Sub (proceudra Sub), Function (funkcja Function), Property (właściwość Property), Event (zdarzenie). Z opcji Scope należy wybrać zasięg procedury: Public (procedury publiczne), Private (procedury prywatne). Pole All local variables as Static oznacza, że wszystkie zmienne procedury będą statyczne.
Innym sposobem dodania procedury lub funkcji jest wpisanie jej nagłówka w oknie Code, pomiędzy innymi procedurami. Visual Basic automatycznie dopisze rozkaz końca procedury.
Funkcje i procedury mogą być wywoływane z dowolnego miejsca kodu programu (w zasięgu procedury). Procedurę moża wywołać podając jej nazwę lub wykorzystując rozkaz Call. Funkcję wywołuje się podając jej nazwę, ale ponieważ zwraca ona wartość, to wartość ta musi być przekazana do jakiegoś wyrażenia, najczęściej do zmiennej.
Część procedur i funkcji może skorzystać z przekazanych do nich parametrów, aby wykonać działania z zastosowaniem ich wartości. Istnieją dwa sposoby przekazywania parametrów do procedur: przez wartość (przekazana zostaje wartość zmiennej) i przez referencję (przekazana zostaje sama zmienna).
Oprócz możliwości dodawania swoich procedur i funkcji, Visual Basic udostępnia szereg funkcji wbudowanych, które wykonują różnorodne zadania. Zamiast pisać swoją funkcję można wywołać funkcję wbudowaną i wykorzystać jej działanie. Funkcje te skracają czas i ułatwiają tworzenie kodu programu.
Funkcje daty i czasu wykonują różne operacje związane z czasem (np. funkcja Time() zwraca aktualny czas), Funkcje formatujące pozwalają sformatować dane według potrzeb, żeby je wyświetlić na ekranie, Funkcje wejścia/wyjścia wykonują różne operacje wejścia/wyjścia, jak np. obsługę plików i katalogów (np. funkcja CurDir() zwraca bieżący folder), Funkcje konwersji danych pozwalają na konwersję danych różnych typów (np. funkcja Str() zamienia liczbę na łańcuch znaków), Funkcje matematyczne wykonują różnorodne działania matematyczne (np. Sin() oblicza sinus z podanej liczby), Funkcje tekstowe pozwalają na różnorodne operacje na łańcuchach tekstowych (np. LCase() zamienia litery łańcucha na małe), Funkcje testujące dane pozwalają sprawdzić typ danych. Visual Basic posiada również szereg innych funkcji, jak np. QBColor() i RGB() do obsługi kolorów.
Wszystkie te funkcje są zawarte w Visual Basic i ich wykorzystanie wymaga jedynie podania nazwy funkcji.
Visual Basic umożliwia również korzystanie z zewnętrznych funkcji, poprzez wykorzystanie wywołań Windows API. Są to funkcje zawarte w bibliotekach DLL systemu Windows. Użycie tych funkcji wymaga najpierw zadeklarowania funkcji z podaniem jej nazwy i lokalizacji (pliku, w którym się znajduje). Pozwala to na wykorzystanie ogromnej liczby różnorodnych funkcji, wykorzystywanych przez szereg aplikacji systemu Windows i przez sam system. Korzystanie z tych funkcji jest często dość skomplikowane i stosują je zaawansowani programiści.
Oprócz ogólnych funkcji wbudowanych, Visual Basic dostarcza również procedury i funkcje wykonywane dla konkretnego obiektu.
Metody
Metody są szczególnym rodzajem procedur i funkcji. Wykonują one swoje działanie "na zlecenie" konkretnego obiektu. Można je uznać za zestaw działań, które może wykonać ten obiekt. Metoda wykorzystuje parametry obiektu i wynik swojego działania zwraca do obiektu. Przy wywołaniu metody należy podać nazwę obiektu, kropkę i nazwę wywoływanej metody.
obiekt.Metoda
Różne metody są dostępne dla różnych obiektów i chociaż mają takie same nazwy mogą wykonywać różne działania, w zależności od rodzaju obiektu, który je wywołuje. Część metod jest dostępna dla większości obiektów (jak np. metoda ZOrder, która ustala kolejność obiektów na poziomach graficznych), a część jest charakterystyczna tylko dla obiektów jednego typu (jak np. metoda ShowOpen kontrolki CommonDialog, która wyświetla okno dialogowe Open File). Metody pozwalają na łatwe zarządzanie obiektami i zawartymi w nich elementami (np. AddItem dodaje elementy do list, RemoveItem usuwa elementy z list, Move przesuwa obiekt, Refresh odświeża zawartość obiektu, Hide ukrywa obiekt itd.).
Właściwości
Podobnie jak wywołuje się metody, można odwołać się do właściwości obiektu. Część właściwości dostępna jest tylko w fazie projektowania i nie można się do nich odwołać w fazie wykonywania programu (a więc z kodu programu), natomiast część właściwości dostępna jest tylko w fazie wykonywania programu i nie można ich ustawić w fazie projektowania aplikacji. Właściwości obiektu określają pewne cechy obiektu, jak np. położenie, wygląd, zachowanie. Aby z kodu programu uzyskać dostęp do właściwości należy skorzystać ze składni:
obiekt.Właściwość
Jest to ogólna składnia dla wszystkich właściwości dostępnych z kodu programu wszystkich obiektów. Ponieważ właściwości zwracają jakieś wartości lub przyjmują nowe, w kodzie programu należy wykorzystać rozkazay podstawienia nowej wartości do właściwości lub odczytanej wartości właściwości do jakiegoś innego wyrażenia (najczęściej do zmiennej). Aby podstawić wartość właściwości należy skorzystać ze składni:
obiekt.Właściwość = Wartość lub obiekt.Właściwość = Wyrażenie.
Aby pobrać wartość właściwości należy skorzystać ze składni:
Wyrażenie = obiekt.Właściwość, najczęściej Zmienna = obiekt.Właściwość.
O ile w oknie Properties można wybrać jedną z dostępnych wartości z rozwijanej listy (dla niektórych właściwości), to w kodzie programu wszystkie wartości trzeba przypisać "ręcznie". Visual Basic 5 ułatwia to rozwijając listę dostępnych właściwości i metod.
Visual Basic pozwala przechowywać różnego rodzaju dane. Dane te można podzielić na trzy kategorie: dane liczbowe, dane łańcuchowe (tekstowe) i inne dane (specjalne). Aby pracować z odpowiednimi danymi trzeba wybrać jeden z dopuszczalnych w Visual Basic typów danych, np. aby pracować z liczbami trzeba wybrać jeden z liczbowych typów danych, aby pracować z łańcuchami trzeba wybrać jeden z łańcuchowych typów danych. Inne typy danych to typy specjalne, np. takie, które przechowują datę i czas lub takie, które przyjmują wartości True i False.
Zmienne
Visual Basic umożliwia przechowywanie danych, które mogą się zmieniać w trakcie trwania aplikacji. Określone miejsce w pamięci, które służy do przechowywania danych nazywane jest zmienną.
Z punktu widzenia programisty zmienna jest elementem, którego wartość może ulegać zmianie podczas wykonywania programu. Na przykład, zmienna X może zmieniać się od 0, do -1, do 32767 i następnie znowu do 0 podczas trwania pojedynczej procedury.
Z punktu widzenia komputera zmienna jest jednym obszarem w pamięci, którego zawartość może zmieniać się podczas wykonywania programu. Dla komputera zmienna X może zajmować dwa bajty (16 bitów) pamięci przez cały czas trwania programu, podczas gdy jej zawartość może zmieniać się od 0 do -1, do 32767 i ponownie do 0.
W Visual Basicu wszystkie zmienne są tworzone jednakowo: na przykład zmienna, która jest przechowywana w pamięci jako sekwencja bitów 01001111, reprezentuje literę O - jeżeli zmienna jest znakiem, lub liczbę 79 - jeżeli zmienna jest liczbą całkowitą. Przez zdeklarowanie zmiennej jako określonego typu danych określa się dla Visual Basic typ danych przechowywanych przez zmienną.(sposób interpretacji danej przechowywanej w pamięci). Ponieważ zmienna jest obszarem pamięci, trudno byłoby odwoływać się do zmiennej przez podanie adresu tego obszaru pamięci i długości, jaką zmienna zajmuje w pamięci. Dlatego należy określić typ zmiennej i przypisać jej nazwę, a Visual Basic sam zadba o to, żeby korzystać z dobrego obszaru pamięci i wykorzystywać tyle miejsca ile jest potrzebne dla tej zmiennej.
W Visual Basic można używać tyle zmiennych, ile jest potrzebnych w programie (na ile wystarczy zasobów komputera). Jednak aby używać zmienną, trzeba ją najpierw zadeklarować, podając jej nazwę i typ. Do deklaracji zmiennych w programie używa się rozkazów: Dim, Private, Public. Składnia tych rozkazów jest taka sama, o różnią się one zasięgiem deklarowanych zmiennych:
Dim NazwaZmiennej As TypZmiennej
NazwaZmiennej jest nazwą, zgodną z konwencją nazywania zmiennych, która będzie wykorzystywana w programie do odwołania się do zmiennej. TypZmiennej jest jednym z dopuszczalnych w Visual Basic typem danych. Rozkaz ten wydziela pewien obszar w pamięci komputera o długości zależnej od TypuZmiennej i umożliwia dostęp do niego przez podanie NazwyZmiennej. To jaka wartość jest przechowywana w zmiennej zależy od programisty. Jeżeli przy deklaracji zmiennej nie zostanie podany TypZmiennej, to Visual Basic automatycznie przyjmie, że jest to zmienna typu Variant. Ten typ zmiennych pozwala na przechowywanie różnych wartości w zmiennej. Najczęściej używa się ich, jeżeli nie wiadomo, jaki rodzaj wartości zostanie wprowadzony do zmiennej (może to być liczba, później łańcuch, później wartość True itd.) Chociaż używanie zmiennych typu Variant jest wygodnym rozwiązaniem, to jednak zajmują one więcej miejsca w pamięci niż inne typy zmiennych, co zużywa więcej pamięci i może spowalniać działanie aplikacji. Dlatego, jeżeli znany jest typ danych jakie mają być przechowywane w zmiennej, to lepiej jest określić TypZmiennej w czasie deklaracji zmiennej (np. jeżeli pobierane będzie od użytkownika nazwisko, to można określić TypZmiennej na String, lub np. String*40 - łańcuch 40-o znakowy, a jeżeli pobierany będzie wiek, to można określić TypZmiennej na Byte), w ten sposób nie będzie niewykorzystanych obszarów pamięci.
Po zadeklarowaniu zmiennej Visual Basic automatycznie podstawia jej domyślną wartość, zależną od typu zmiennej.
Zmiennej numerycznej nadawana jest wartość 0,
Zmiennej łańcuchowej o stałej długości przypisywany jest łańcuch o zerowej długości (""),
Zmienna łańcuchowa o stałej długości zostanie wypełniona zerami,
Zmienna typu Variant jest inicjowana jako Empty,
Każdy element typu użytkownika jest inicjowany jak pojedyncza zmienna określonego typu.
Aby nadać zmiennej inną wartość należy użyć instrukcji przypisania:
NazwaZmiennej = Wartość
Jest to instrukcja, która przypisuje zmiennej o podanej NazwieZmiennej wartość wyrażenia Wartość, która znajduje się po prawej stronie znaku =.
Dość specyficznym rodzajem zmiennych są tablice. Tablica jest zbiorem zmiennych tego samego typu danych. Jest ona stosowana do zgrupowania razem zmiennych zależnych. Zamiast przchowywać wiele zmiennych tego samego rodzaju o różnych nazwach, można stworzyć jedną zmienną tablicową o określonej ilości elementów.
Tablica jest deklarowana podobnie jak zwykła zmienna, tylko, że za nazwą zmiennej w deklaracji zmiennej podaje się rozmiar tablicy (ilość elementów tablicy). Visual Basic umożliwia tworzenie tablic wielowymiarowych, których elementy muszą być identyfikowane przez kilka wartości indeksów (można tworzyć tablice, aż do 60-wymiarowych).
Elementy tablicy są indeksowane, każdy z nich posiada swój indeks (pozycję w tablicy). Aby odnieść się do pojedynczego elementu tablicy, należy umieścić jego numer indeksu w nawiasach na końcu nazwy tablicy. Może wykorzystanie jednej nazwy i numerów do odwoływania się do poszczególnych zmiennych wydaje się trudniejsze niż stworzenie wielu zmiennych i przypisanie im charakterystycznych nazw, jednak rozkazy organizujące (jak np. pętle programowe) znacznie ułatwiają i przyspieszają dostęp do zmiennych tablicowych. Np. zamiast przypisywać każdej zmiennej tą samą wartość, można zrobić pętlę, która będzie kolejno zmieniać numer indeksu i po kolei każdemu elementowi tablicy przypisywać określoną wartość. Jest to użyteczne szczególnie przy dużej ilości zmiennych.
Elementy tablic wykorzystywane są dokładnie tak samo jak zwykłe zmienne, różnią się od nich tylko nazwą zawierającą indeks.
Stałe
Oprócz zmiennych, które mogą zmieniać swoją wartość w czasie działania programu, Visual Basic umożliwia również wykorzystanie stałych, których wartość nie może ulec zmianie. Stałe użytkownika są deklarowane przez użycie rozkazu Const:
Const NazwaStałej As TypStałej = Wartość
NazwaStałej jest nazwą, zgodną z zasadami nazywania zmiennych, która charakateryzuje stałą w programie. TypStałej jest typem danych przechowywanych przez stałą. Wartość jest wartością przechowywaną przez stałą.
Stałe ułatwiają pisanie kodu programu, w którym często trzeba wykorzystywać tą samą wartość. Np. zamiast za każdym razem wpisywać wartość 3,141562 można zadeklarować stałą o nazwie np. sngPi o wartości 3,141562 i w programie zamiast tej wartości wpisywać łatwiejszą do zapamiętania nazwę stałej. Jeżeli trzeba będzie zmienić wartość, to wystarczy to zrobić tylko przy deklaracji stałej, zamiast każdego miejsca programu, w którym wartość została użyta.
Oprócz stałych wprowadzonych przez programistę, Visual Basic dostarcza szereg stałych wykorzystywanych przez różne obiekty Visual Basic (np. stała vbShapeCircle, określa rodzaj kształtu kontrolki Shape, a stała vbBlack określa wartość koloru czarnego dla metod i funkcji graficznych).
Visual Basic dostarcza szereg konstrukcji programowych zwanych instrukcjami. Zestaw instrukcji jest swoistym językiem Visual Basic.
Rozkazy
Część rozkazów zachowuje się jak procedury. Wykonują one określone działania, gdy zostaną wywołane. Rozkazy te pozwalają na wykonywanie wielu bardzo różnorodnych operacji.
Np. rozkaz Dim wykorzystywany jest do deklarowania zmiennych, rozkaz Sub wykorzystywany jest do tworzenia procedur a rozkaz Call wykorzystywany jest do wywoływania procedur. Oprócz rozkazów obsługi zmiennych i procedur, Visual Basic dostarcza również rozkazy do obsługi form, np. rozkaz Load ładuje formę do pamięci, a rozkaz UnLoad usuwa ją z pamięci. Przy pomocy rozkazów można również uzyskać dostęp do plików i folderów, np. Open otwiera plik, Close zamyka go, ChDir zmienia bieżący folder a MkDir tworzy nowy folder.
Wszystkie rozkazy wywołuje się zgodnie z ich składnią. Najczęściej rozkaz wywołuje się przy uzyciu składni:
Rozkaz Parametry
Rodzaj parametrów i sposób ich użycia zależy od składni poszczególnych rozkazów. Rozkazy nie zwracają żadnej wartości, a Visual Basic 5 ułatwia używanie składnni rozkazów przez system podpowiedzi.
Oprócz rozkazów działających jak procedury, Visual Basic dostarcza szereg rozkazów organizujących działania aplikacji. Można używać rozkazów tworzących pętle programowe lub podejmujące decyzje.
Pęlte są zbiorem instrukcji, które należy wykonać wielokrotnie. Zamiast przepisywać kilka razy ten sam blok rozkazów, można go umieścić w pętli. Program dyktuje ile razy pętla ta wykona zawarty w niej blok instrukcji i jakie mają być warunki zakończenia jej działania. Pętle są przydatne np. przy wielokrotnym przetwarzaniu złożonych danych.
W Visual Basic istnieje kilka rodzajów pętli. Pętle typu Do wymagają zastosowania wyrażenia porównania. Wykorzystują do tego operatory porównania. Pętla typu Do While wykonuje zawarty w niej blok instrukcji dopóki wyrażenie porównania jest prawdziwe. Gdy stanie się ono fałszywe, pętla ta kończy swoje działanie. Pętla typu Do Until kontynuuje swoje działanie tak długo, jak długo podany warunek jest fałszywy. Gdy stanie się prawdziwy pętla ta kończy swoje działanie.
Nieco innym rodzajem pętli jest pętla For. Wykonuje ona swoje działanie dopóki zmienna o podanej wartości początkowej nie osiągnie podanej wartości końcowej. Wartość tej zmiennej jest zwiększana przy każdym wykonaniu pętli o podaną wartość kroku. Ta pętla jest najczęściej wykorzystywana, gdy znana jest wymagana liczba powtórzeń.
Instrukcje wyboru (warunkowe) pozwalają programowi na podejmowanie "samodzielnych" decyzji na podstawie przeprowadzonych analiz. Pozwalają one na rozgałęzienia programu i wykonywanie tych bloków rozkazów, które w danej chwili są konieczne. Instrukcje te podejmują decyzję, którą część programu należy wykonać w zależności od tego, czy sprawdzany warunek daje w wyniku prawdę czy fałsz. Instrukcje wyboru korzystają z operatorów porównania aby sprawdzić czy podany warunek jest prawdziwy czy fałszywy. Wynikiem wykonania operacji porównania może być tylko jedna z dwóch wartości TRUE (prawda) lub FALSE (fałsz). W zależności od tej wartości instrukcje wyboru mogą wykonać jeden z dostępnych bloków kodu. Najprostszą tego typu instrukcją jest If. Aby wymusić sprawdzanie różnych warunków przed podjęciem odpowiedniej decyzji można zagnieżdżać instrukcje warunkowe lub stosować bardziej rozbudowane instrukcje, takie jak Select Case.
Operatory
Operatory wykonują operacje arytmetyczne, logiczne, łańcuchowe, podstawienia lub porównania.
Visual Basic zapewnia pełen zestaw operatorów. Operatory te podlegają zasadom pierwszeństwa.
Jeżeli w wyrażeniu wystąpi kilka operatorów, każda część jest obliczana i sprawdzana w oparciu o kolejność priorytetów operatorów.
Jeżeli wyrażenie zawiera operatory należące do różnych kategorii, najpierw wykonywane są działania operatorów arytmetycznych, potem operatorów porówniania i operatorów logicznych.
Wszystkie operatory porówniania mają taki sam prirytet i wykonywane są w takim porządku w jakim znajdują się w wyrażeniu w kolejności od lewej do prawej.
Operatory logiczne i arytmetyczne wykonywane są w porządku określonym przez priorytety:
Arytmetyczne |
Porówniania |
Logiczne |
Potęga (^) |
Równe (=) |
Not |
Zmiana znaku (-) |
Nierówne (<>) |
And |
Mnożenie (*) i dzielenie (/) |
Mniejsze (<) |
Or |
Dzielenie całkowite (\) |
Większe (>) |
Xor |
Moduł (Mod) |
Mniejsze lub równe (<=) |
Eqv |
Dodawanie (+) i odejmowanie (-) |
Większe lub równe (>=) |
Imp |
Łączenie łańcuchów (&) |
Like |
|
Jeżeli mnożenie i dzielenie wystąpią razem wykonywane są w kolejności od lewej do prawej.
Jeżeli dodawanie i odejmowanie wystąpią razem wykonywane są w kolejności od lewej do prawej.
Nawiasy okrągłe () mogą być używane, aby zmienić kolejność wykonywania działań. Działania zawarte w nawiasach zawsze są wykonywane przed działaniami poza nawiasami. Wewnątrz nawiasów obowiązuje kolejność wykonywania działań zgodna z priorytetami.
Operator łączenia łańcuchów (&) nie jest operatorem arytmetycznym, ale ma swój priorytet i występuje za wszystkimi operatorami arytmetycznymi i przed operatorami logicznymi.
Operator Like ma taki priorytet jak wszystkie operatory porównania.
Operator Is jest obiektowym odpowiednikiem operatora porównania. Nie porównuje on obiektów ale ich wartości, sprawdza czy dwa odwołania do obiektów odnoszą się do tego samego obiektu.
Kolejnym krokiem tworzenia aplikacji jest
Testowanie aplikacji
W tworzonej aplikacji zazwyczaj znajduje się wiele błędów.
Błędy składniowe są łatwe do poprawienia, ponieważ Visual Basic sam je sygnalizuje. Część jest wykrywana już w czasie pisania kodu programu, a część przy próbie skompilowania. Błędy wykonania ujawniają się dopiero podczas wykonywania programu.
Najtrudniejsze do zlokalizowania są błędy logiczne, ponieważ nie są sygnalizowane przez Visual Basic. Wynikają one z błędu programisty. Dla Visual Basic są poprawnymi instrukcjami, natomiast aplikacja nie działa zgodnie z założeniami programisty.
Najlepszym sposobem na wykrycie błędów jest uruchomienie aplikacji.
Visual Basic dostarcza narzędzia, które pomagają śledzić zachowanie aplikacji podczas działania. Jednym z takich narzędzi jest Debugger. Daje on możliwość śledzenia wszystkich szczegółów pracy programu i kontrolowanie wartości zmiennych.
Visual Basic zapewnia szeroki asortyment narzędzi do wykrywania błędów i cech, które pomagają zlokalizować i poprawić błędy w kodzie:
Tryb przerwania/edycji i kontynuacji
Tryb przerwania zatrzymuje uruchomioną aplikację, ale pozostawia jej bieżące zmienne i ustawienia właściwości. Jest jakby zaprezentowaniem stanu programu w określonej chwili podczas jego działania. W trybie przerwania można zbadać i zmienić bieżące wartości i właściwości, wprowadzić znaczne modyfikacje kodu i określić, jakie instrukcje aplikacji będą uruchomione jako następne. Po zakończeniu edycji, można kontynuować uruchomienie programu. Ta bardzo przydatna cecha jest nazywana edytuj i kontynuuj.
Aby wejść w tryb przerwania należy:
Po uruchomieniu programu wybrać z menu Run, Break (nacisnąć Ctrl+Break lub kliknąć przycisk Break na pasku narzędziowym).
Aby zbadać i zmienić kod, należy wyświetlić odpowiednie okno Code i zmienić go w miarę potrzeby.
Aby kontynuować działanie programu, należy nacisnąć F5 lub wybrać z menu Run, Start lub kliknąć przycisk Start na pasku narzędziowym.
Wyrażenia Watch
Wyrażenia Watch umożliwiają monitorowanie wartości określonych zmiennych, właściwości i wyrażeń w czasie działania programu. Wyrażenia Watch są wyświetlone w obszarze Watch okna Debug w trybie przerwania (poza wyrażeniami Watch, które pojawiają się w ich własnym okienku dialogowym). Można przerwać wykonanie programu, kiedy wyrażenie Watch ulega zmianie lub ma wartość True.
Aby dodać wyrażenie Watch do programu należy:
W czasie projektowania lub podczas trybu przerwania wybrać z menu Debug, Add Watch, aby otworzyć okienko dialogowe Add Watch.
W okienku tekstowym Expression należy wpisać zmienną, właściwość lub wyrażenie, które ma być obserwowane.
W Context należy wybrać moduł(y) i procedurę(y), w których ma być obserwowana zmienna, właściwość lub wyrażenie. Zawężenie zakresu obserwacji umożliwia przyśpieszenie działania wykrywacza błędów.
W Watch Type należy wybrać Watch Expression (aby tylko obserwować), Break When Value Is True (aby przerwać działanie programu, kiedy wartość wyrażenia Watch ma wartość True) lub Break When Value Changes (aby zatrzymać, kiedy wartość wyrażenia ulega zmianie).
Aby przeprowadzić stałą obserwację - to znaczy, aby oglądać bieżącą wartość zmiennej, właściwości lub wyrażenia należy:
Po wejściu w tryb przerwania, wybrać właściwą zmienną, właściwość lub wyrażenie w odpowiednim oknie Code lub na obszarze Code okna Debug,
Wybrać z menu Debug, Quick Watch lub nacisnąć Shift-+F9 albo kliknąć przycisk Quick Watch na pasku narzędziowym.
Punkt przerwania
Punkt przerwania określa konkretny wiersz kodu, gdzie Visual Basic zatrzyma działanie programu i wejdzie w tryb przerwania. Umożliwia to zbadanie stanu programu (wartości zmiennych, wydruku ekranu i tak dalej) w specyficznym miejscu działania programu.
Aby ustawić lub usunąć punkt przerwania dla wiersza kodu należy:
W czasie projektowania lub podczas trybu przerwania umieścić wskaźnik (kursor) w wierszu i wybrać z menu Debug, Toggle Breakpoint lub nacisnąć F9, albo kliknąć przycisk Toggle Breakpoint na pasku narzędziowym.
Wykonywanie krokowe
Wykonywanie krokowe umożliwia "przechodzenie przez" wykonywanie pojedynczej jednostki kodu - jednej instrukcji, jednej procedury, jednego modułu itd. Po wykonaniu określonej jednostki kodu Visual Basic automatycznie wchodzi w tryb przerwania, umożliwiając obserwowanie wyników. Może to ułatwić znalezienie części kodu, w której pojawił się błąd.
Step Into
Polecenie Step Into przechodzi do następnej instrukcji w programie. Jeżeli ta instrukcja jest wywołana z innej procedury, Step Into przechodzi do pierwszej instrukcji z tej procedury. Należy używać Step Into w celu znajdowania błędów programu na "mikroskopijnym" poziomie przez przechodzenie przez wszystkie jego instrukcje jedna po drugiej.
Aby użyć polecenia Step Into należy:
W trybie przerwania wybrać z menu Debug, Step Into lub wcisnąć F8, lub kliknąć przycisk Step Into na pasku narzędziowym.
Step Over
Polecenie Step Over przechodzi do następnej instrukcji w procedurze. Jeżeli ta instrukcja jest wywołaniem następnej procedury, Step Over przechodzi "nad" tą procedurą i zatrzymuje się na następnej instrukcji bieżącej procedury. Można go używać do znajdowania błędów w programie na nieco wyższym poziomie niż Step Into, przez przechodzenie przez kolejne procedury jako całość.
Aby użyć polecenia Step Over należy:
W trybie przerwania wybrać z menu Debug, Step Over lub nacisnąć Shift+F8, lub kliknąć przycisk Step Over na pasku narzędziowym.
Run To Cursor
Polecenie Run To Cursor przechodzi do określonej instrukcji w dalszej części kodu. Należy do używać do szybkiego przechodzenia do właściwych instrukcji w programie.
Aby użyć polecenia Run To Cursor należy:
W trybie przerwania wyświetlić instrukcję kodu, do której program ma przejść i kliknąć ją, aby tam umieścić kursor. Następnie wybrać z menu Debug, Run To Cursor lub nacisnąć Ctrl+F8.
Wywołania
Wywołania umożliwiają oglądanie - w trybie przerwania - spisu aktualnie aktywnych wywołań procedur programów. Kiedy wykonywany jest kod procedury, procedura jest dodawana do listy aktywnych procedur. Jeżeli procedura wywołuje inną procedurę Sub lub Function, wywołana procedura jest również dodawana do listy itd. dla wszystkich aktywnych procedur. Ta cecha może pomóc śledzić przebieg programu i wybrać możliwe lokalizacje błędów logicznych.
Aby obejrzeć aktualnie aktywne odwołania do procedur należy w oknie Call Stack:
W trybie przerwania wybrać z menu View, Call Stack lub nacisnąć Crl+L.
Kompilowanie aplikacji
Po stworzeniu projekty można do skompilować, aby uzyskać plik uruchomieniowy .EXE. Aby to zrobić należy:
Wybranie pozycji Make <NazwaProjektu>.EXE z menu File
Wybrać stację i folder docelowy
Potwierdzić przyciskiem OK
Jeżeli projekt wykorzystuje dodatkowe pliki .OCX należy je skopiować do folderu WINDOWS/SYSTEM. Można również użyć Application Setup Wizard, aby stworzyć wersję instalacyjną aplikacji, wraz ze wszystkimi niezbędnymi dodatkowymi plikami.
Przykładowa aplikacja
Proces tworzenia aplikacji za pomocą programu Visual Basic zostanie zilustrowany przykładem. Pierwszym krokiem jest zdefiniowanie zdarzeń i projektu graficznego aplikacji. W naszym przypadku będzie to zegarek cyfrowy. Będzie on wyświetlał datę a pod nią czas. Zarówno datę jak i czas będzie można ukryć, a także będzie można wybrać rodzaj i kolor wyświetlanych czcionek oraz sposób ich formatowania. Kliknięcie prawym przyciskiem myszy na dacie lub czasie będzie rozwijać odpowiednie menu pop-up
Tworzenie aplikacji zaczynamy od ustalenia właściwości formy:
Właściwość |
Wartość |
Opis |
frmZegar |
nazwa formy |
|
Zegar |
tytuł formy |
|
1500 |
wysokość formy |
|
3000 |
wysokość formy |
Pozostałe właściwości zostawiamy domyślne.
Do formy dodajemy teraz dwie kontrolki Label. Pierwsza będzie wyświetlała datę, druga czas. W oknie Properties ustalamy właściwości pierwszej:
Właściwość |
Wartość |
Opis |
lblData |
nazwa kontrolki |
|
True |
automatyczna zmiana rozmiaru kontrolki |
|
0 - Transparent |
rodzaj tła kontrolki |
|
00:00:00 |
tekst kontrolki (ten tekst i tak nie będzie wyświetlany, bo tu będzie wyświetlana data) |
|
Font.Size |
12 |
rozmiar czcionki (okno dialogowe Czcionka) |
1000 |
pozycja lewej krawędzi kontrolki |
|
100 |
pozycja górnej krawędzi kontrolki |
I właściwości drugiej kontrolki Label wyświetlającej czas:
Właściwość |
Wartość |
Opis |
lblCzas |
nazwa kontrolki |
|
True |
automatyczna zmiana rozmiaru kontrolki |
|
0 - Transparent |
rodzaj tła kontrolki |
|
00:00:00 |
tekst kontrolki (ten tekst i tak nie będzie wyświetlany, bo tu będzie wyświetlany czas) |
|
Font.Size |
12 |
rozmiar czcionki (okno dialogowe Czcionka) |
1000 |
pozycja lewej krawędzi kontrolki |
|
400 |
pozycja górnej krawędzi kontrolki |
Sekundowe zmiany wartości czasu wyświetlane w kontrolkach, realizuje kontrolka Timer. W oknie Properties ustalamy jej właściwości:
Właściwość |
Wartość |
Opis |
tmrZegar |
nazwa kontrolki |
|
True |
włączenie kontrolki |
|
1000 |
czas w milisekundach, po którym generowane jest zdarzenie Timer (1000 odpowiada 1 sekundzie) |
|
100 |
położenie kontrolki (nie ma znaczenia, ponieważ kontrolka nie jest widoczna w czasie działania programu) |
|
400 |
położenie kontrolki (nie ma znaczenia, ponieważ kontrolka nie jest widoczna w czasie działania programu) |
Aby umożliwić użytkownikowi zmianę czcionek i kolorów dołączamy do formy kontrolkę CommonDialog. Standartowo nie jest ona dołączana do okna Toolbox, należy więc otworzyć okno Components (wcisnąć CTRL+T lub wybrać polecenie Components... menu Project). W oknie tym należy zaznaczyć pozycję Microsoft Common Dialog Control 5.0. Należy zaznaczyć pole wyboru obok tej nazwy i wcisnąć przycisk OK. Kontrolka CommonDialog pojawi się w oknie Toolbox. Należy ją dołączyć do formy i ustawić właściwości w oknie Properties:
Właściwość |
Wartość |
Opis |
cdlOknaDialogowe |
nazwa kontrolki |
|
100 |
położenie kontrolki (nie ma znaczenia, ponieważ kontrolka nie jest widoczna w czasie działania programu) |
|
0 |
położenie kontrolki (nie ma znaczenia, ponieważ kontrolka nie jest widoczna w czasie działania programu) |
Do formy dodajemy teraz menu (ikona MenuEditor na pasku narzędziowym, CTRL+E, polecenie MenuEditor z menu Tools) i ustawiamy właściwości:
Pozycja i właściwości menu |
|||||||
Opis |
|||||||
&Zegar |
mnuZegar |
|
|
V |
|
||
... |
K&olor |
mnuZegarKolor |
|
|
V |
umożliwia zmianę koloru tła |
|
... |
- |
mnuZegarSeparator1 |
|
|
V |
linia separująca menu |
|
... |
&Koniec |
mnuZegarKoniec |
|
|
V |
kończy program |
|
&Data |
mnuData |
|
|
V |
opcje wyświetlania daty |
||
... |
&Pokaż |
mnuDataPokaz |
|
V |
V |
pokazuje i ukrywa datę |
|
... |
&Ustaw |
mnuDataUstaw |
|
|
V |
ustawia nową datę |
|
... |
- |
mnuDataSeparator1 |
|
|
V |
linia separująca menu |
|
... |
&Czcionka |
mnuDataCzcionka |
|
|
V |
umożliwia wybór czcionki i jej koloru |
|
... |
&Format |
mnuDataFormat |
|
|
V |
umożliwia wybór formatu wyświetlanej daty |
|
...... |
&Długa |
mnuDataFormatFormaty |
1 |
V |
V |
wyświetla datę w formacie długim |
|
...... |
ś&rednia |
mnuDataFormatFormaty |
2 |
|
V |
wyświetla datę w formacie średnim |
|
...... |
&Krótka |
mnuDataFormatFormaty |
3 |
|
V |
wyświetla datę w formacie krótkim |
|
&Czas |
mnuCzas |
|
|
V |
opcje wyświetlania czasu |
||
... |
&Pokaż |
mnuCzasPokaz |
|
V |
V |
pokazuje i ukrywa czas |
|
... |
&Ustaw |
mnuCzasUstaw |
|
|
V |
ustawia nowy czas |
|
... |
- |
mnuCzasSeparator1 |
|
|
V |
linia separująca menu |
|
... |
&Czcionka |
mnuCzasCzcionka |
|
|
V |
umożliwia wybór czcionki i jej koloru |
|
... |
&Format |
mnuCzasFormat |
|
|
V |
umożliwia wybór formatu wyświetlanego czasu |
|
...... |
&Długi |
mnuCzasFormatFormaty |
1 |
V |
V |
wyświetla czas w formacie długim |
|
...... |
ś&redni |
mnuCzasFormatFormaty |
2 |
|
V |
wyświetla czas w formacie średnim |
|
...... |
&Krótki |
mnuCzasFormatFormaty |
3 |
|
V |
wyświetla czas w formacie krótkim |
|
&Menu |
mnuCzas |
|
|
|
pop-up menu formy |
||
... |
&Ukryj menu |
mnuMenuUkryj |
|
|
V |
pokazuje i ukrywa menu |
|
... |
- |
mnuMenuSeparator1 |
|
|
V |
linia separująca menu |
|
... |
&Data |
mnuMenuData |
|
V |
V |
pokazuje i ukrywa datę |
|
... |
&Czas |
mnuMenuCzas |
|
V |
V |
pokazuje i ukrywa czas |
|
Podmenu Format menu Data i Czas zawiera pozycje Długi, średni i Krótki. Aby formatować sposób wyświetlania daty i czasu, można użyć funkcji Format(). Funkcja ta daje możliwość formatowania daty i czasu w trzech predefiniowanych rodzajach, właśnie: długim, średnim i krótkim. Można więc łatwo wykorzystać możliwości tej funkcji i wprowadzić takie formatowanie daty i czasu do programu. Dlatego też, w menu pojawiły się odpowiednie pozycje. Pozycje Długa menu Data\Format i Długi menu Czas\Format mają ustawione właściwości Checked na True (znacznik V), ponieważ przy uruchomieniu programu data i czas będą wyświetlane w takich właśnie formatach. Polecenia te mają taką samą nazwę (właściwość Name) i różne indeksy, określające położenie tych poleceń wewnątrz tablicy kontrolek o nazwie mnuDataFormatFormaty i mnuCzasFormatFormaty. Użycie tablicy kontrolek i indeksowania skraca kod programu, ponieważ zamiast pisać osobną procedurę dla każdego polecenia, możemy napisać jedną a Indeks, który zostanie przekazany do tej procedury przez Visual Basic, będzie określał, które polecenie zostało wybrane.
Menu Menu jest niewidocznym menu, które zostanie wykorzystane jako menu pop-up formy frmZegar i będzie wyświetlane, gdy użytkownik klinkie prawym przyciskiem na formie.
Po dodaniu kontrolek i menu do formy wygląda ona tak:
Po dodaniu menu i kontrolek oraz ustawieniu ich właściwości przechodzimy do pisania kodu programu.
Zaczniemy od polecenia Option Explicit. Wymusza ono deklarowanie każdej używanej zmiennej. W ten sposób łatwiej będzie kontrolować poprawność pisanego kodu, ponieważ błędne wpisanie nazwy zmiennej będzie sygnalizowane przez Visual Basic jako błąd (gdyby nie było rozkazu Option Explicit, to błędne wpisanie nazwy zmiennej spowodowałoby stworzenie nowej zmiennej o tej nazwie i przeważnie trudny do znalezienia błąd logiczny).
Rokaz Option Explicit należy dopisać do sekcji deklaracji ogólnych (General Declarations). Aby to zrobić otwieramy okno Code. Można otworzyć to okno przez wybranie polecenia Code menu View, wcisnięcie F7 lub kliknięcie dwukrotnie na formie lub dowolnej kontrolce, a następnie wybranie z listy ObjectBox - z lewej na górze - (General), a z listy Procedure/EventsBox - z prawej na górze - (Declarations)).
Okno Code wyświetli zawartość tej sekcji.
Jeżeli w opcjach Visual Basic (zakładka Editor okna Options polecenia Options menu Tools) opcja Require Variable Declarations jest zaznaczona, to rozkaz Option Explicit jest dopisywany automatycznie przy tworzeniu formy. Jeżeli go nie ma, to go dopisujemy:
Teraz dodamy kod do polecenia Koniec menu Zegar.
Gdy użytkownik wybierze to polecenie, to program powinien zakończyć swoje działanie. Musimy więc dopisać kod do zdarzenia Click menu mnuZegarKoniec. Aby to zrobić rozwijamy na formie menu Zegar i klikamy polecenie Koniec. Okno Code otworzy się na procedurze mnuZegarKoniec_Click() (można również otworzyć to okno przez wybranie polecenia Code menu View, wcisnięcie F7 lub kliknięcie dwukrotnie na formie lub dowolnej kontrolce, a następnie wybranie z listy ObjectBox - z lewej na górze - mnuZegarKoniec, a z listy Procedure/EventsBox - z prawej na górze - Click).
Okno Code wyświetli pierwszą i ostatnią linię procedury mnuZegarKoniec_Click:
Private Sub mnuZegarKoniec_Click() |
Do ciała procedury musimy wstawić kod, który zakończy program. Można do tego celu użyć rozkazu End, który automatycznie kończy program. Jednak rozwiązaniem preferowanym przez wielu programistów jest użycie rozkazu UnLoad, który wykorzystuje podaną nazwę formy, aby usunąć ją z pamięci (jeżeli jest tylko jedna forma w pamięci, to zakończy on działanie programu i zwolni całą zajmowaną pamięć). Użyjemy więc rozkaz UnLoad z nazwą formy frmZegar:
Private Sub mnuZegarKoniec_Click() |
Dodajmy teraz kod do zdarzenia Load formy frmZegar, które występuje, gdy forma jest ładowana do pamięci (a więc przy uruchomieniu programu). Wybieramy w oknie Code obiekt frmZegar i procedurę zdarzenia Load. Visual Basic automatycznie wstawia początek i koniec procedury.
Po załadowaniu programu data i czas mają być wyświetlane w długich formatach. Musimy więc gdzieś przechowywać informację o formatach wyświetlania daty i czasu. W tym celu zadeklarujemy sobie dwie zmienne, jedna będzie przechowywać format daty a druga czasu. Ponieważ zmienne te będą wykorzystywane nie tylko przez zdarzenie Load, ale również np. przez zdarzenie Timer kontrolki tmrZegar (aby co sekundę zmieniać wyświetlany czas), więc zadeklarujemy te zmienne jako globalne i będą one dostępne przez wszystkie procedury. W tym celu powracamy do sekcji deklaracji ogólnych (wybieramy (General) i (Declarations)) i dopisujemy deklaracje zmiennych. Ponieważ zmienne mają być dostępne dla wszystkich procedur (a więc publiczne) użyjemy do ich deklaracji rozkazu Public. A ponieważ funkcja Format() wymaga podania formatów w postaci łańcuchów, więc deklarowane zmienne będą łańcuchowe:
Option Explicit 'wymuszenie deklaracji zmiennych |
Teraz możemy powrócić do procedury zdarzenia Form_Load() i przypisać tam wartości zmiennym gstrFormatDaty i gstrFormatCzasu, jakie przyjmą one po uruchomieniu programu. Predefiowane formaty funkcji Format to: Long Date, Medium Date, Short Date, Long Time, Medium Time i Short Time. Ponieważ początkowo data i czas mają być wyświetlane w formatach długich, więc wykorzystamy formaty Long Date i Long Time:
Private Sub Form_Load() |
Do zdarzenia Form_Load należy też dodać kod, który wyświetli bieżący czas i datę. Jeżeli tego nie dodamy, to do pierwszego wystąpienia zdarzenia Timer (a więc przez 1 sekundę) zamiast daty i czasu będą wyświetlane wartości, ustawione w oknie Properties (00:00:00).
Musimy dopisać kod programu, który zmieni tekst wyświetlany w kontrolkach lblData i lblCzas. Ale takie samo zadanie będzie musiał wykonać kod programu, który będzie zawarty w procedurze zdarzenia Timer. Tam też trzeba będzie wyświetlić nowe wartości daty i czasu w kontrolkach lblData i lblCzas. Zamiast więc dwa razy pisać ten sam kod, możemy wpisać go raz do zdarzenia tmrZegar_Timer() i wywołać tą procedurę ze zdarzenia Form_Load().
Przechodzimy więc do obiektu tmrZegar i zdarzenia Timer. Dodajemy tam kod, który pobierze aktualny czas i datę (przy użyciu funkcji Date() i Time()) oraz sformatuje te wartości przy użyciu funkcji Format zgodnie z formatowami zawartymi w zmiennych gstrFormatDaty i gstrFormatCzasu.
Możemy również dodać rozkaz, który zmieni tekst wyświetlany na pasku tytułowym formy, aby również wyświetlał czas. Gdy forma zostanie zminimalizowana, to przy jej ikonie będzie wyświetlany aktualny czas.
Private Sub tmrZegar_Timer() |
Teraz możemy do zdarzenia Form_Load() dodać wywołanie procedury zdarzenia tmrZegar_Timer(), aby przy uruchomieniu programu wyświetlić bieżącą datę i czas:
Private Sub Form_Load() |
Wprawdzie użycie rozkazu Call, aby wywołać procedurę, nie jest obowiązkowe, jednak podkreśla, że używana jest inna procedura programu.
Po wyświetleniu nowych wartości daty i czasu dobrze było by umieścić kontrolki centralnie na środku wysokości i szerokości formy. Można odpowiedni kod dodać do zdarzenia Form_Load(), ale taki sam kod trzeba będzie wykonać, gdy użytkownik zmieni rozmiar formy (aby znowu umieścić kontrolki na środku formy) lub gdy użytkownik zmieni czcionkę lub format wyświetlania daty lub czasu, co spowoduje zmianę szerokości lub wysokości etykiet. Dodamy więc osobną procedurę, którą będziemy wywoływać za każdym razem, gdy zajdzie taka potrzeba.
Dodajemy więc do programu procedurę UstawEtykiety. Aby to zrobić należy wybrać polecenie AddProcedurę z menu Tools. W oknie dialogowym należy wpisać nazwę procedury, ustawić typ na Sub i zakres na Public.
Można również wpisać w oknie Code pierwszą linię (nagłówek) procedury, a Visual Basic sam uzupełni nazwę. Nie można jednak zrobić tego wewnątrz innej procedury, trzeba wpisać tę linię pomiędzy innymi procedurami, lub na końcu, za ostatnim rozkazem End...
Do tej procedury dodajemy kod, który umieści kontrolki lblData i lblCzas na środku wysokości i szerokości formy. Wykorzystamy do tego właściwości Left, Top kontrolek, dla określenia ich pozycji, Height, Width kontrolek, żeby pobrać ich wysokość i szerokość oraz ScaleHeight, ScaleWidth formy, aby pobrać rozmiar wewnętrznego obszaru formy (bez ramek, menu i paska tytułowego).
Aby umieścić kontrolkę na środku szerokości formy musimy: pobrać szerokość formy, odjąć od niej szerokość kontrolki, a pozostała różnica jest niewykorzystanym obszarem szerokości formy. Jeżeli podzielimy ją przez 2, to otrzymamy obszar, który będzie między brzegiem kontrolki a brzegiem formy, zarówno z lewej jak i z prawej strony kontrolki. Możemy więc na tej pozycji ustalić położenie lewego brzegu kontrolki. Podobnie postępujemy z drugą kontrolką Label.
Aby ustalić położenie pionowe kontrolek, musimy sprawdzić, która kontrolka jest wyświetlana. Jeżeli wyświetlana jest tylko kontrolka lblData to od wysokości formy odejmujemy wysokość kontrolki i dzielimy różnicę przez 2. Jeżeli widoczna jest tylko kontrolka lblCzas to wykonujemy te same obliczenia dla jej wysokości. Jeżeli jednak widoczne są obydwie kontrolki to od wysokości formy musimy odjąć sumę wysokości obydwu kontrolek oraz odległości między nimi. Jeżeli tę różnicę podzielimy przez 2, to uzykamy wysokość, na której będzie się zaczynać górna kontrolka. Aby określić pozycję dolnej kontrolki musimy do położenia górnej kontrolki dodać jej wyokość oraz odległość między kontrolkami. W ten sposób uzyskamy ułożenie kontrolek centralnie pionowo i poziomo na formie.
Public Sub UstawEtykiety() |
Możemy teraz wywołać tą procedurę ze zdarzenia Form_Load(), aby ułożyć etykiety centralnie po uruchomieniu programu. Możemy również wywołać ją ze zdarzenia Resize formy, aby ustawić etykiety centralnie, po każdej zmianie rozmiaru przez użytkownika. Ponieważ zdarzenie Resize jest wywoływane przy urchomieniu programu, po zdarzeniu Load, nie musimy wywoływać procedury UstawEtykiety ze zdarzenia Form_Load(), ponieważ i tak zostanie ona wywołana ze zdarzenia Form_Resize(). Dodajmy więc wywołanie procedury UstawEtykiety do zdarzenia Form_Resize():
Private Sub Form_Resize() |
W ten sposób po uruchomieniu programu wyświetlana będzie data i czas w kontrolkach lblData i lblCzas ustawianych na środku formy. Co sekundę będzie wywoływane zdarzenie tmrZegar_Timer, które wprowadzi nowy czas i datę do etykiet, a po zmianie rozmiau przez użytkownika, etykiety ustawią się na środku formy. Wybranie polecenia Koniec z menu Zegar zakończy działanie programu.
Gdy mamy proceduę, która ustawia etykiety na środku formy, możemy napisać kod, który będzie powodował zmianę formatu wyświetlania daty i czas. Po zmianie formatu mogą zmienić się rozmiary kontrolek, więc trzeba będzie wywołać procedurę ustawiającą kontrolki na formie.
Gdy użytkownik wybierze jeden z formatów daty, wywołane zostanie zdarzenie mnuDataFormatFormaty_Click. Ponieważ wszystkie polecenia w menu określające format daty mają taką samą nazwę mnuDataFormatFormaty, więc przy wywołaniu zdarzenia Click, Visual Basic poda indeks polecenia, które zostało wybrane. Ponieważ w fazie projektowania ustaliliśmy te indeksy na wartości 1 do 3, wiemy który indeks odpowiada któremu poleceniu.
Ponieważ w menu zaznaczamy znacznikiem V, który format aktualnie jest używany, więc musimy zaznaczyć odpowiedni format, który wybrał użytkownik. W tym celu najpierw ustawiamy właściwości Checked wszystkich poleceń mnuDataFormatFormaty na False. W ten sposób w menu nie będzie zaznaczonego znacznikiem V polecenia. Następnie ustawiamy właściwość Checked tego polecenia, które wybrał użytkownik (a którego indeks został przekazany do procedury mnuDataFormatFormaty_Click). Znacznik V pojawi się przy tym formacie, który wybrał użytkownik. Następnie w zależności od wartości przekazanego Indeksu podstawiamy odpowiednią wartość formatowania do zmiennej globalnej gstrFormatDaty. Zmienna ta będzie później wykorzystana przez zdarzenie tmrZegar_Timer, aby wyświetlić nową wartość w etykiecie. Po podstawieniu nowej wartości do zmiennej globalnej możemy wywołać zdarzenie tmrZegar_Timer, aby natychmmiastowo wyświelić datę w nowym formacie, lub możemy poczekać, aż wystąpi to zdarzenie (mniej niż 1 sekundę) i samo wyświetli datę w nowym formacie.
Private Sub mnuDataFormatFormaty_Click(Index As Integer) |
Podobnie postępujemy w przypadku zmiany formatu wyświetlania czasu. Dopisujemy odpowiedni kod do procedury zdarzenia mnuCzasFormatFormaty_Click:
Private Sub mnuCzasFormatFormaty_Click(Index As Integer) |
Dodamy teraz kod programu, który umożliwi zmianę czcionki etykiet. Kod ten musi być zawarty w procedurach zdarzeń mnuDataCzcionka_Click i mnuCzasCzcionka_Click. Ponieważ obie procedury będą wykonywały to samo zadanie (pobierały nowe ustawienia czcionki) tylko, że dla różnych kontrolek, więc zamiast pisać dwukrotnie ten sam kod zrobimy jedną osobną procedurę, której jako parametr będziemy przekazywać nazwę odpowiedniej kontrolki (lblData lub lblCzas).
Do zmiany czcionki wykorzystamy kontrolkę CommonDialog. Wyświetla ona okno Czcionka, w którym można wybrać nazwę, rozmiar, kolor i styl czcionki. Aby wykorzystać tę kontrolkę do wyświetlenia okna Czcionka należy najpierw ustawić właściwość Flags. We właściwości tej ustawia się rodzaj czcionek wyświetlanych przez okno Czcionka (ekranowe, drukarkowe, obyda typy itd.) oraz dodatkowe atrybuty okna dialogowego. Ponieważ nasz zegar będzie wyświetlany tylko na ekranie, do właściwości Flags wstawimy wartość określającą czcionki ekranowe (gdybyśmy nie wstawili żadnej wartości to okno Czcionka nie wyświetliłoby żadnych dostępnych czcionek). Dodamy tam również wartość umożliwiającą nadanie czcionkom atrybutów Podkreślenie i Przkreślenie.
Jeżeli ustawimy właściwość Flags i wywołamy metodę ShowFont, aby wyświetlić okno Czcionka, to otworzy się ono wyświetlając listę dostępnych czcionek ekranowych i ich atrybutów, ale bez wybranej czcionki domyślnej. Gdyby użytkownik chciał zmienić tylko rozmiar aktualnie używanej czcionki, musiałby wybrać odpowiednią nazwę czcionki, atrybuty, kolor i rozmiar. Aby to ułatwić możemy przez wywołaniem metody ShowFont przesłać do kontrolki cdlOknaDialogowe atrybuty czcionki aktualnie używanej. Okno Czcionka otworzy się wtedy na aktualnie używanej czcionce, i jeżeli użytkownik będzie chciał zmienić tylko rozmiar czcionki, to zrobi to bez konieczności ustawiania innych atrybutów.
Atrybuty czcionki przechowywane są przez etykiety we właściwości Font, a jej kolor we właściwości ForeColor. Kontrolka CommonDialog przechowuje te informacje we właściwościach: FontName, FontSize, FontBold, FontItalic, FontStrikethru, FontUnderline oraz Color.
Tworzymy więc procedurę ZmienCzcionke i przekazujemy do niej jako parametr nazwę kontrolki. Ustawiamy właściwość Flags i przepisujemy atrybuty aktualnie wykorzystywanej czcionki etykiety do kontrolki CommonDialog, po czym wywołujemy metodę ShowFont. Następnie atrybuty nowo wybranej czcionki przepisujemy do etykiety. Jeżeli użytkownik przyciśnie Anuluj to kontrolka CommonDialog zwróci takie wartości jakie zostały do niej zapisane przed wywołaniem metody ShowFont. Na koniec procedury ustawiamy etykiety centralnie na formie (ponieważ ich rozmiar mógł się zmienić).
Public Sub ZmienCzcionke(Kontrolka As Control) |
Teraz w procedurach zdarzeń mnuDataCzcionka_Click i mnuCzasCzcionka_Click wystarczy tylko wywołać procedurę ZmienCzcionke i przekazac jako parametr nazwy kontrolek lblData i lblCzas.
Private Sub mnuDataCzcionka_Click() |
Private Sub mnuCzasCzcionka_Click() |
Możemy teraz przejść do poleceń menu ustawiających datę (mnuDataUstaw) i czas (mnuCzasUstaw). Wykorzystujemy zdarzenie Click, aby wykonać kod, który ustawi nową datę i czas.
Aby ustawić datę i czas wykorzystujemy rozkazy Date i Time. Aby pobrać datę i czas od użytkownika wykorzystamy funkcję InputBox. Wyświetla ona okno dialogowe, w którym użytkownik może wpisać dowolny łańcuch znaków. Aby ułatwić mu wprowadzanie nowej daty lub czasu, możemy wyświelić w oknie InputBox wartość domyślną, która będzie wyświetlana w oknie wprowadzania zanim użytkownik zmieni ją lub wpisze coś innego.
Gdy użytkownik wprowadzi już nową wartość musimy sprawdzić, czy jest to poprawna data lub czas. Wykorzystamy do tego funkcję IsDate.
Private Sub mnuCzasUstaw_Click() |
Private Sub mnuDataUstaw_Click() |
Dopiszemy procedurę zdarzenia mnuZegarKolor_Click, która zmieni kolor tła formy. Wykorzystamy do tego kontrolkę CommonDialog i jej metodę ShowColor. Podobnie jak przy zmianie czcionki, najpierw przekażemy bieżący kolor do kontrolki CommonDialog, potem wywołamy metodę ShowColor a zwrócony kolor ustawimy jako kolor tła.
Private Sub mnuZegarKolor_Click() |
Dopiszemy kod, który będzie ukrywał i pokazywał datę. Będzie on uruchamiany, gdy użytkownik wybierze polecenie Pokaż menu Data lub polecenie Data menu Menu (jest to menu pop-up, które będzie wyświetlane, gdy użytkownik kliknie prawym klawiszem myszy na formie). Ponieważ polecenia te mają takie samo znaczenie i występuje przy nich znacznik V, należy zadbać, aby wywołanie jednego z nich miało wpływ na znaczniki obydwu (jeżeli Data\Pokaz jest zaznaczone, to Menu\Data też musi być). Kod procedury musi więc równocześnie zmieniać wartość właściwości Checked obydwu poleceń na przeciwną (przy użyciu operatora Not). Musi również zmieniać właściwość Visible kontrolki lblData, aby ją ukrywać lub pokazywać. Ponieważ na początku kontrolka lblData jest widoczna, a polecenie Data\Pokaz jest zaznaczone, więc wystarczy zmieniać właściwość Visible kontrolki lblData na przeciwną równocześnie ze zmianą właściwości Checked poleceń Data\Pokaż i Menu\Data.
Po tym należy wyłować procedurę, która ustawi nowe pozycje kontrolek na formie.
Private Sub mnuDataPokaz_Click() |
Procedura mnuMenuData_Click, która ma wykonać dokładnie tę samą funkcję może teraz jedynie wywołać procedurę mnuDataPokaz_Click:
Private Sub mnuMenuData_Click() |
Identycznie postępujemy w stosunku do poleceń ukrywających i pokazujących czas:
Private Sub mnuCzasPokaz_Click() |
Private Sub mnuMenuCzas_Click() |
Dodajemy kod proceury, która będzi ukrywać i pokazywać menu. Będzie ona zmieniać właściwość Visible poleceń menu na przeciwną przy użyciu operatora Not. Dodatkowo, gdy menu będzie widoczne, to polecenie "Ukryj menu" będzie się zmieniać na "Pokaż menu".
Private Sub mnuMenuUkryj_Click() |
Pozostało jeszcze dodanie menu pop-up, gdy użytkownik kliknie prawym przyciskiem myszy. Nie można wykorzystać zdarzenia Click, ponieważ nie zwraca ono wartości określającej, który przycisk został naciśnięty. Zamiast niego należy wykorzystać zdarzenie MouseDown lub MouseUp.
Procedura tego zdarzenia wykorzysta metodę PopupMenu formy frmZegar, aby wyświetlić menu o podanej nazwie. Dla formy rozwijane będzie menu pop-up Menu.
Private Sub Form_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single) |
Podobnie będą wyglądały procedury dla kontrolek lblData i lblCzas:
Private Sub lblCzas_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single) |
Private Sub lblData_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single) |
To już cały kod jaki należało dodać do aplikacji.
Kolejny etap to uruchomienie (znalezienie ewentualnych błędów i edycja).
Następnie wybieramy polecenie Project1 Properties z menu Project. W oknie dialogowym w polu Project Name wpisujemy Zegar, w polu Project Description opis programu. Dodatkowe paramety możemy ustalić na zakładce Make. Zatwierdzamy przyciskiem OK. Możemy jeszcze zmienić właściwość Icon formy i wybieramy polecenie Make Zegar.exe menu File. Wybieramy ścieżkę i nazwę pliku i zatwierdzamy OK. Visual Basic skompiluje projekt do pliku wykonywalnego, który będzie działał bez środowiska Microsft Visual Basic.
Można również jeszcze rozbudować aplikację. Można np. wymusić, aby zegar był zawsze wyświetlany na wierzchu (nad wszystkimi innymi działającymi aplikacjami), można dorobić kod, który będzie automatycznie uruchamiał zegar przy włączaniu Windows, lub można wykorzystać rejestr systemu, aby przechowywać ustawienia użytkownika i zawsze uruchamiać zegar z takimi atrybutami, jakie ustawił sobie użytkownik.
Przykłady działania aplikacji:
Oto cały kod programu:
Option Explicit 'wymuszenie deklaracji zmiennych |
Private Sub Form_Load() |
Private Sub Form_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single) |
Private Sub Form_Resize() |
Private Sub lblCzas_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single) |
Private Sub lblData_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single) |
Private Sub mnuCzasCzcionka_Click() |
Private Sub mnuCzasFormatFormaty_Click(Index As Integer) |
Private Sub mnuCzasPokaz_Click() |
Private Sub mnuCzasUstaw_Click() |
Private Sub mnuDataCzcionka_Click() |
Private Sub mnuDataFormatFormaty_Click(Index As Integer) |
Private Sub mnuDataPokaz_Click() |
Private Sub mnuDataUstaw_Click() |
Private Sub mnuMenuCzas_Click() |
Private Sub mnuMenuData_Click() |
Private Sub mnuMenuUkryj_Click() |
Private Sub mnuZegarKolor_Click() |
Private Sub mnuZegarKoniec_Click() |
Private Sub tmrZegar_Timer() |
Public Sub UstawEtykiety() |
Public Sub ZmienCzcionke(Kontrolka As Control) |
Wyszukiwarka
Podobne podstrony:
Visual Basic Przykładowe zadania , Studia i nauka, Visual Basic
Visual Basic Zdarzenia , Studia i nauka, Visual Basic
Visual Basic Operatory , Studia i nauka, Visual Basic
Visual Basic Kontrolki , Studia i nauka, Visual Basic
Visual Basic Platforma programistyczna, Studia i nauka, Visual Basic
Visual Basic Błędy , Studia i nauka, Visual Basic
Visual Basic Stałe, Studia i nauka, Visual Basic
Visual Basic Właściwości , Studia i nauka, Visual Basic
inne visual basic net w praktyce blyskawiczne tworzenie aplikacji jacek matulewski ebook
Visual Basic NET w praktyce Blyskawiczne tworzenie aplikacji 2
Visual Basic NET w praktyce Blyskawiczne tworzenie aplikacji
Visual Basic NET w praktyce Blyskawiczne tworzenie aplikacji vbnepr
Visual Basic NET w praktyce Blyskawiczne tworzenie aplikacji
Visual Basic NET w praktyce Blyskawiczne tworzenie aplikacji vbnepr 2
Visual Basic NET w praktyce Blyskawiczne tworzenie aplikacji vbnepr
Tworzenie aplikacji w Visual Studio 08 v ?z ekranów
więcej podobnych podstron