Specyfikacja pakietu JEWL.Windows
------------------------------------------------------------------------------
-- --
-- J E W L . W I N D O W S --
-- --
-- Pakiet do projektowania programów w trybie graficznym dla początkujących --
-- --
-- To jest duży pakiet, ale rozbicie go na mniejsze wymagałoby wielu --
-- podstawowych instancji by go użyć. --
-- --
-- Prawa (C) John English 2000. Adres kontaktowy: je@brighton.ac.uk --
-- To oprogramowanie zostało wydane zgodnie z założeniami GNU Powszechnej --
-- Licencji Publicznej i jest przeznaczone głównie dla użytku --
-- edukacyjnego. Skontaktuj się z autorem by zgłosić błędy, sugestie --
-- i modyfikacje. --
-- --
------------------------------------------------------------------------------
generic -- To jest podstawowy pakiet, który musi być
type Command_Type is (<>); -- zainstancjonowany z listą możliwych
-- komend mogących być wygenerowanymi jeśli okno
package JEWL.Windows is -- jest zamknięte, przycisk został zwolniony
-- lub opcja menu została wybrana.
----------------------------------------------------------------------------
-- Różne operacje
----------------------------------------------------------------------------
procedure Show_Message (Text : in String; -- wiadomość informująca
Title : in String := "Message");
procedure Show_Error (Text : in String; -- wiadomość o błędzie
Title : in String := "Error");
function Show_Query (Text : in String; -- pytanie tak/nie
Title : in String := "Query")
return Boolean;
procedure Play_Sound (Sound : in String); -- play a sound file
function Screen_Width return Natural; -- width of display screen
function Screen_Height return Natural; -- height of display screen
----------------------------------------------------------------------------
--
-- UŻYWANE TYPY
--
-- Za wyjątkiem Alignment_Type, następujące typy są zdefiniowane w
-- najwyższej części pakietu JEWL i są tutaj przypomniane:
--
-- Alignment_Type : używane by wyznaczyć wyrównanie tekstu w oknie.
-- Angle_Type : kąt określony jako wartość całkowita pomiędzy 0 a 359
-- stopni.
-- Colour_Type : kolor określony jako wartość RGB.
-- Font_Type : czcionka wyznaczona poprzez nazwę, wielkość i styl.
-- Point_Type : para współrzędnych (X,Y) w oknie.
-- Point_List : tablica par (X,Y).
--
----------------------------------------------------------------------------
type Alignment_Type is (Left, Centre, Right);
subtype Angle_Type is JEWL.Angle_Type;
subtype Colour_Range is JEWL.Colour_Range;
subtype Colour_Type is JEWL.Colour_Type;
subtype Font_Type is JEWL.Font_Type;
type Image_Type is private;
subtype Point_Type is JEWL.Point_Type;
subtype Point_List is JEWL.Point_List;
----------------------------------------------------------------------------
-- Zmiany nazw dla Amerykańskiej odmiany angielskiego
----------------------------------------------------------------------------
subtype Color_Range is Colour_Range;
subtype Color_Type is Colour_Type;
function Center return Alignment_Type renames Centre;
----------------------------------------------------------------------------
--
-- OPERACJE NA UZYWANYCH TYPACH
--
-- To są przypomnienia dla pewności operacji zdefiniowanych w macierzystym pakiecie
--
-- Operacje na kolorach:
-- Light : Generowanie rozjaśnionej wersji koloru, np. Light(Red).
-- Dark : Generowanie przyciemnionej wersji koloru, np. Dark(Green).
--
-- Operacje na czcionkach:
-- Font : Generowanie czcionki o wyznaczonych właściwościach.
-- Name : Pobranie nazwy używanej czcionki.
-- Size : Pobranie rozmiaru czcionki w punktach.
-- Bold : Sprawdzenie czy czcionka jest pogrubiona.
-- Italic : Sprawdzenie czy czcionka jest pochylona.
--
-- Operacje na obrazkach:
-- Image : Wczytaj obraz bitmapowy z pliku.
-- Valid : Sprawdź czy obrazek jest poprawny.
-- Width : Pobierz szerokość obrazka.
-- Height : Pobierz wysokość obrazka.
--
-- Operacje na współrzędnych:
-- Endpoint : Obliczenie punktu końcowego linii zaczynającej się w punkcie startowym,
-- z długości i kątem.
-- Inside : Sprawdzenie czy dany punkt jest w środku wyznaczonego prostokąta
-- (definiowane za pomocą dwóch współrzędnych położonych na przekątnej).
-- P1 + P2 : Dodaje dwie współrzędne (P1.X+P2.X, P1.Y+P2.Y).
-- P1 - P2 : Odejmuje dwie współrzędne (P1.X-P2.X, P1.Y-P2.Y).
--
----------------------------------------------------------------------------
function Light (Colour : JEWL.Colour_Type) return JEWL.Colour_Type
renames JEWL.Light;
function Dark (Colour : JEWL.Colour_Type) return JEWL.Colour_Type
renames JEWL.Dark;
function Font (Name : String;
Size : Positive;
Bold : Boolean := False;
Italic : Boolean := False) return JEWL.Font_Type
renames JEWL.Font;
function Name (Font : Font_Type) return String
renames JEWL.Name;
function Size (Font : Font_Type) return Natural
renames JEWL.Size;
function Bold (Font : Font_Type) return Boolean
renames JEWL.Bold;
function Italic (Font : Font_Type) return Boolean
renames JEWL.Italic;
function Image (Name : String) return Image_Type;
function Valid (Image : Image_Type) return Boolean;
function Width (Image : Image_Type) return Natural;
function Height (Image : Image_Type) return Natural;
function Endpoint (From : JEWL.Point_Type;
Length : Positive;
Angle : JEWL.Angle_Type) return JEWL.Point_Type
renames JEWL.Endpoint;
function Inside (Point : JEWL.Point_Type;
From : JEWL.Point_Type;
To : JEWL.Point_Type) return Boolean
renames JEWL.Inside;
function "+" (P1, P2 : Point_Type) return Point_Type
renames JEWL."+";
function "-" (P1, P2 : Point_Type) return Point_Type
renames JEWL."-";
----------------------------------------------------------------------------
--
-- STAŁE DLA UŻYWANYCH TYPÓW
--
-- Kąty : North, South, East i West
-- Kolory : Black, White, Red, Green, Blue, etc.
-- Czcionki : Default_Font (domyślna czcionka dla najwyższego okna) i
-- Parent_Font (ta sama czcionka, której używa okno macierzyste)
--
----------------------------------------------------------------------------
North : constant Angle_Type := 0;
South : constant Angle_Type := 180;
East : constant Angle_Type := 90;
West : constant Angle_Type := 270;
Black : constant Colour_Type := ( 0, 0, 0);
White : constant Colour_Type := (255,255,255);
Red : constant Colour_Type := (255, 0, 0);
Green : constant Colour_Type := ( 0,255, 0);
Blue : constant Colour_Type := ( 0, 0,255);
Gray : constant Colour_Type := (128,128,128);
Yellow : constant Colour_Type := (255,255, 0);
Cyan : constant Colour_Type := ( 0,255,255);
Magenta : constant Colour_Type := (255, 0,255);
Default_Font : constant Font_Type := Font("Arial",9);
Parent_Font : constant Font_Type := Font("",1);
----------------------------------------------------------------------------
--
-- WINDOW_TYPE TYP OKNO
--
-- Abstrakcyjna klasa dostarczająca podstawowe zachowania,
-- których używają wszystkie okna
--
----------------------------------------------------------------------------
type Window_Type is abstract tagged private;
Invalid_Window : exception; -- wznoszony podczas próby używania
-- nieprawidłowego (nie otwieralnego) okna
----------------------------------------------------------------------------
--
-- Operacje na oknach (wspólne dla wszystkich okien):
--
-- Show (Window, -- zrób okno widoczne lub nie, zależnie
-- Visible) -- od wartości Visible (domyślnie: True).
-- Hide (Window) -- zrób okno niewidoczne.
-- Focus (Window) -- nadaj oknu aktywność.
-- Visible (Window) -- zwróć True jeśli okno jest widoczne.
-- Get_Origin (Window) -- pobierz początek danego okna (górny lewy punkt)
-- Get_Width (Window) -- pobierz szerokość danego okna.
-- Get_Height (Window) -- pobierz wysokość danego okna.
-- Set_Origin (Window, -- nadaj początek (górny lewy punkt)
-- Origin) -- danego okna dla danej wartości.
-- Set_Size (Window, -- nadaj oknu tę szerokość
-- Width, -- (opcjonalnie)
-- Height) -- i tę wysokość (opcjonalnie).
-- Get_Font (Window) -- pobierz czcionkę danego okna
-- Set_Font (Window, -- ustaw czcionkę dla danego okna
-- Font)
--
----------------------------------------------------------------------------
procedure Show (Window : in Window_Type;
Visible : in Boolean := True);
procedure Hide (Window : in Window_Type);
procedure Focus (Window : in Window_Type);
function Visible (Window : Window_Type) return Boolean;
function Get_Origin (Window : Window_Type) return Point_Type;
function Get_Width (Window : Window_Type) return Natural;
function Get_Height (Window : Window_Type) return Natural;
procedure Set_Origin (Window : in Window_Type;
Origin : in Point_Type);
procedure Set_Size (Window : in Window_Type;
Width : in Natural := 0;
Height : in Natural := 0);
function Get_Font (Window : Window_Type) return Font_Type;
procedure Set_Font (Window : in Window_Type;
Font : in Font_Type);
----------------------------------------------------------------------------
--
-- PODKLASY OKIEN
--
-- Podstawowe podklasy okien to kontenery i kontrolki. Dzielą zachowanie wspólne
-- dla wszystkich okien, także dodają dodatkowe zachowania
--
-- Container_Type : abstrakcyjna typ-baza dla wszystkich kontenerów.
-- Control_Type : abstrakcyjna typ-baza dla wszystkich kontrolek.
--
----------------------------------------------------------------------------
type Container_Type is abstract new Window_Type with private;
type Control_Type is abstract new Window_Type with private;
----------------------------------------------------------------------------
--
-- KONTENERY
--
-- Kontenery są oknami, które mogą zawierać inne okna. Wszystkie okna poza
-- ramkami i dialogami (zobacz niżej) muszą się zawierać w innym kontenerze okna.
-- Istnieje kilka restrykcji dotyczących typów kontenerów, które mogą być
-- dołączone do okna (np. opcja menu musi być dołączona do menu).
--
-- Większość okien określa pochodzenie, szerokość i wysokość, których współrzędne
-- są liczone względem zawierającego je kontenera. Dodatnie szerokości i wysokości
-- są wartościami absolutnymi, ale zero i ujemne wartości szerokości i wysokości
-- są interpretowane, jako relatywne do szerokości i wysokości zawierającego je kontenera.
-- (tak więc szerokość 0 oznacza szerokość zawierającego kontenera, a wysokość -10
-- oznacza 10 pikseli mniej niż wysokość otaczającego kontenera.
--
-- Dostępnymi typami kontenerów okien są:
--
-- Frame_Type : główne okno z paskiem tytułowym, system menu, przyciski
-- minimalizacji i maksymalizacji oraz zamknięcia.
-- Dialog_Type : najwyżej położone okno, które jest używane do interakcji,
-- dezaktywuje pozostałe okna w czasie kiedy następuje interakcja.
-- Panel_Type : płaskie okno, które jest używane jako kontener dla innych podokien.
-- Menu_Type : menu, które może zawierać opcje menu oraz podmenu.
--
----------------------------------------------------------------------------
type Frame_Type is new Container_Type with private;
type Dialog_Type is new Container_Type with private;
type Panel_Type is new Container_Type with private;
type Menu_Type is new Container_Type with private;
----------------------------------------------------------------------------
--
-- RAMKI
--
-- Ramka jest najwyżej położonym okienkiem z paskiem tytułowym, systemem menu,
-- przyciskami minimalizacji i maksymalizacji oraz przyciskiem zamknięcia.
-- Zamykanie ramki generuje komendę. Ramki są normalnie widoczne, ale mogą zostać
-- ukryte, jeśli zachodzi taka potrzeba.
-- Ramka powinna być używana jako główne okienko dla aplikacji.
--
-- Operacje na ramkach:
--
-- Frame (Origin, -- tworzy ramkę na wyznaczonej pozycji
-- Width, -- o określonej szerokości
-- Height, -- i wysokości w pikselach,
-- Title, -- o określonym tytule w pasku tytułowym,
-- Command, -- generującą tę komendę, kiedy zamykane,
-- Font) -- używającą tej czcionki (domyślnie: Default_Font).
-- Frame (Width, -- tworzy ramkę o określonej szerokości
-- Height, -- i wysokości w pikselach, położoną losowo,
-- Title, -- o określonym tytule w pasku tytułowym,
-- Command, -- generującą tę komendę, kiedy zamykane,
-- Font) -- używającą tej czcionki (domyślnie: Default_Font).
--
-- Close (Frame) -- zamknij ramkę.
-- Valid (Frame) -- true dopóki ramka jest zamknięta.
--
-- Frame_Width -- zwraca szerokość brzegu ramki.
-- Frame_Height -- zwraca wysokość brzegu ramki.
--
-- Next_Command -- zwraca następną komendę generowaną przez jakąkolwiek
-- -- kontrolkę w istniejącej ramce.
-- Command_Ready -- sprawdź czy czeka na komendę
--
----------------------------------------------------------------------------
function Frame (Origin : Point_Type;
Width : Positive;
Height : Positive;
Title : String;
Command : Command_Type;
Font : Font_Type := Default_Font) return Frame_Type;
function Frame (Width : Positive;
Height : Positive;
Title : String;
Command : Command_Type;
Font : Font_Type := Default_Font) return Frame_Type;
procedure Close (Frame : in Frame_Type);
function Valid (Frame : Frame_Type) return Boolean;
function Frame_Width return Natural;
function Frame_Height return Natural;
function Next_Command return Command_Type;
function Command_Ready return Boolean;
----------------------------------------------------------------------------
--
-- DIALOGI
--
-- Dialog jest najwyższym okienkiem jak ramka, ale ma tylko przycisk zamykania
-- na swoim pasku tytułowym. Dialogi są przeznaczone do interakcji z użytkownikiem.
-- Kiedy dialog jest egzekwowany, staje się widoczny i wszystkie inne okna są dezaktywowane.
-- Uruchomienie dialogu trwa dopóki komenda generowana nie zamyka okna albo nie nastąpi
-- kliknięcie na przycisk dołączony do dialogu. Dialogi nie mają paska menu.
--
-- Operacje na dialogach
--
-- Dialog (Width, -- stwórz dialog o danej szerokości
-- Height, -- i wysokości w pikselach,
-- Title, -- o określonym tytule w pasku tytułowym,
-- Command, -- generujący tę komendę, kiedy jest zamykany,
-- Font) -- używający tej czcionki (domyślnie: Default_Font).
--
-- Execute (Dialog) -- uruchom dialog i zwróć kod komendy
-- -- użyty do wyjścia z niego.
--
-- Dialog_Width -- zwróć szerokość brzegu dialogu.
-- Dialog_Height -- zwróć wysokość brzegu dialogu.
--
----------------------------------------------------------------------------
function Dialog (Width : Positive;
Height : Positive;
Title : String;
Command : Command_Type;
Font : Font_Type := Default_Font) return Dialog_Type;
function Execute (Dialog : in Dialog_Type) return Command_Type;
function Dialog_Width return Natural;
function Dialog_Height return Natural;
----------------------------------------------------------------------------
--
-- PANELE
--
--
-- Operacje na panelach:
--
-- Panel (Parent, -- stwórz panel wewnątrz macierzystego kontenera,
-- Origin, -- o współrzędnych lewego górnego rogu relatywnych do macierzystego,
-- Width, -- o określonej szerokości
-- Height, -- i określonej wysokości,
-- Title, -- i tym napisie na brzegu (domyślnie: nic)
-- Font) -- używający tej czcionki (domyślnie: ta sama co Parent).
--
----------------------------------------------------------------------------
function Panel (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Title : String := "";
Font : Font_Type := Parent_Font) return Panel_Type;
----------------------------------------------------------------------------
--
-- MENU
--
-- Menu jest opuszczającą się listą opcji dołączoną do paska menu ramki.
-- Opcje w menu są albo opcjami menu (które generują komendę, kiedy są wybrane
-- podmenu (które wyświetlają kolejne menu, kiedy wybrane)
-- albo separatorami (poziome kreski używane by podzielić menu na podsekcje.
--
-- Jeśli tekst będący etykietą dla opcji menu zawiera znak "&", to znak,
-- który następuje jest podkreślony i menu może być aktywowane poprzez naciśnięcie
-- Alt + ten znak. Znak "&" nie jest wyświetlany.
--
-- Operacje na menu:
--
-- Menu (Parent, -- stwórz menu dołączone do ramki albo do menu
-- Text) -- o wyznaczonej etykiecie.
--
-- Menu_Height -- zwróć wysokość paska menu.
--
----------------------------------------------------------------------------
function Menu (Parent : Frame_Type'Class;
Text : String) return Menu_Type;
function Menu (Parent : Menu_Type'Class;
Text : String) return Menu_Type;
function Menu_Height return Natural;
----------------------------------------------------------------------------
--
-- KONTROLKI
--
-- Kontrolki są okienkami używanymi do interakcji. Zachowują wartości (np.
-- tekst Stringa), który może zostać ustawiony przez użytkownika, lub też
-- być dostępny i zmieniony przez sam program. Niektóre kontrolki (np. opcje
-- menu) generują wartości komend, które mogą być użyte jako włączniki akcji
-- w programie. Następujące operacje są wspólne dla wszystkich kontrolek:
--
-- Enable (Control, -- włącz lub wyłącz kontrolkę zależnie od
-- Enabled) -- wartości Enabled (domyślnie: True).
-- Disable (Control) -- wyłącz kontrolkę.
-- Enabled (Control) -- sprawdza czy kontrolka jest włączona.
--
----------------------------------------------------------------------------
procedure Enable (Control : in Control_Type;
Enabled : in Boolean := True);
procedure Disable (Control : in Control_Type);
function Enabled (Control : Control_Type) return Boolean;
----------------------------------------------------------------------------
--
-- Dostępne są następujące typy kontrolek:
--
-- Menuitem_Type : opcja menu, pojawia się w opuszczających się menu
-- Text_Control_Type : kontrolka mogąca zawierać pojedynczą linijkę tekstu
-- Multiline_Type : kontrolka mogąca zawierać wiele linii tekstu
-- Canvas_Type : płaskie okno do rysowania w nim kształtów
--
----------------------------------------------------------------------------
type Text_Control_Type is abstract new Control_Type with private;
type Multiline_Type is abstract new Control_Type with private;
type Canvas_Type is new Control_Type with private;
----------------------------------------------------------------------------
--
-- KONTROLKI TEKSTOWE
--
-- Kontrolki tekstowe zawierają pojedynczą linię tekstu String. Następujące
-- operacje są wspólne dla wszystkich kontrolek tekstowych:
--
-- Get_Length (Control) -- pobierz długość tekstu przypisanego do kontrolki.
-- Get_Text (Control) -- pobierz tekst przypisany do kontrolki jako
-- -- String o nieskończonym rozmiarze.
-- Get_Text (Control, -- pobierz tekst przypisany do kontrolki
-- Text, -- do tej zmiennej string o ustalonym rozmiarze
-- Length) -- i ustaw tę wartość całkowitą jako aktualną
-- -- długość skopiowanych znaków.
-- Set_Text (Control, -- ustaw tekst przypisany do kontrolki,
-- Text) -- do ustalonej wartości nowego tekstu.
--
----------------------------------------------------------------------------
function Get_Length (Control : Text_Control_Type) return Natural;
function Get_Text (Control : Text_Control_Type) return String;
procedure Get_Text (Control : in Text_Control_Type;
Text : out String;
Length : out Natural);
procedure Set_Text (Control : in Text_Control_Type;
Text : in String);
----------------------------------------------------------------------------
--
-- Dostępne typy kontrolek tekstowych:
--
-- Button_Type : przycisk, który generuje kod komendy po kliknięciu.
-- Label_Type : statyczna etykieta.
-- Editbox_Type : pojedyncze pole tekstowe na wpisanie tekstu.
--
-- Istnieje także podklasa kontrolki tekstowej:
--
-- Boolean_Control_Type : kontrolka tekstowa z niesprecyzowanym stanem Bool
--
----------------------------------------------------------------------------
type Button_Type is new Text_Control_Type with private;
type Label_Type is new Text_Control_Type with private;
type Editbox_Type is new Text_Control_Type with private;
type Boolean_Control_Type is abstract new Text_Control_Type with private;
----------------------------------------------------------------------------
--
-- PRZYCISKI
--
-- Przyciski są prostokątnymi kształtami z etykietą, które generują kod komendy,
-- kiedy zostaną naciśnięte. "Domyślnie" przyciski są wyświetlane z grubszym brzegiem
-- i reagują kiedy naciśniemy klawisz.
--
-- Button operations:
--
-- Button (Parent, -- stwórz przycisk w macierzystym kontenerze,
-- Origin, -- ze współrzędnymi góra lewo relatywnie do macierzystego,
-- Width, -- o zadanej szerokości,
-- Height, -- i zadanej wysokości,
-- Text, -- z zadaną etykietą tekstową,
-- Command, -- generujący tę komendę kiedy naciśnięty,
-- Default, -- ustaw jako "domyślny" przycisk (domyślnie: False),
-- Font) -- używający tej czcionki (domyślnie: tak samo jak Parent).
--
----------------------------------------------------------------------------
function Button (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Text : String;
Command : Command_Type;
Default : Boolean := False;
Font : Font_Type := Parent_Font) return Button_Type;
----------------------------------------------------------------------------
--
-- ETYKIETY
--
-- Etykieta to kontrolka przedstawiająca statyczny tekst, która może zostać użyta
-- do podpisywania innych kontrolek. Etykiety nie odpowiadają na akcje użytkownika,
-- ale ich wartości mogą być czytane i zmieniane przez program w ten sam sposób
-- jak każde inne kontrolki tekstu.
--
-- Operacje na etykietach:
--
-- Label (Parent, -- stwórz etykietę wewnątrz kontenera,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości,
-- Height, -- i określonej wysokości,
-- Text, -- i zapisaną ustalonym tekstem,
-- Align, -- wyrównanym do lewej, prawej lub środka (domyślnie: Left),
-- Font) -- używającą tej czcionki (domyślnie: ta sama co Parent).
--
----------------------------------------------------------------------------
function Label (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Text : String;
Align : Alignment_Type := Left;
Font : Font_Type := Parent_Font) return Label_Type;
----------------------------------------------------------------------------
--
-- EDYCYJNE POLE TEKSTOWE
--
-- Edycyjne pole tekstowe jest kontrolką tekstową zawierającą pojedynczą linię
-- tekstu, którego wartość może zostać wprowadzona przez użytkownika.
--
-- Operacje na edycyjnych polach tekstowych:
--
-- Editbox (Parent, -- stwórz edycyjne pole tekstowe wewnątrz kontenera,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości,
-- Height, -- i określonej wysokości,
-- Text, -- i zainicjalizowaną ustalonym tekstem,
-- Password, -- opcjonalnie ustaw, jako pole z hasłem,
-- Font) -- używające tej czcionki (domyślnie: ta sama co Parent).
--
-- Modified (Editbox) -- sprawdź czy użytkownik zmodyfikował pole.
--
----------------------------------------------------------------------------
function Editbox (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Text : String := "";
Password : Boolean := False;
Font : Font_Type := Parent_Font) return Editbox_Type;
function Modified (Editbox : Editbox_Type) return Boolean;
----------------------------------------------------------------------------
--
-- KONTROLKI BOOL
--
-- Kontrolki Bool są tekstowymi kontrolkami, które mogą zmieniać swój stan
-- pomiędzy włączonym a wyłączonym. Następujące operacje są wspólne dla wszystkich
-- kontrolek Bool:
--
-- Get_State (Control) -- pobierz aktualny stan kontrolki
-- Set_State (Control, -- ustaw aktualny stan kontrolki
-- State) -- do określonej wartości
--
----------------------------------------------------------------------------
function Get_State (Control : Boolean_Control_Type) return Boolean;
procedure Set_State (Control : in Boolean_Control_Type;
State : in Boolean);
----------------------------------------------------------------------------
--
-- Dostępne są następujące typy kontrolek Bool:
--
-- Checkbox_Type : pole zaznaczania, które może być zaznaczone albo odznaczone.
-- Radiobutton_Type : przycisk radio zaznaczony lub odznaczony.
--
----------------------------------------------------------------------------
type Menuitem_Type is new Boolean_Control_Type with private;
type Checkbox_Type is new Boolean_Control_Type with private;
type Radiobutton_Type is new Boolean_Control_Type with private;
----------------------------------------------------------------------------
--
-- OPCJE MENU
--
-- Opcje menu mogą być przyłączone tylko do menu. Kiedy menu jest kliknięte,
-- opuszcza się dodatkowe menu, które składa się z opcji menu (które wywołują
-- komendę kiedy zostaną kliknięte albo kolejne podmenu.
--
-- Każde menu i opcja menu zawiera słowny opis, w którym znak &" jest traktowany
-- specjalnie. "&" nie jest wyświetlany, ale następujący po nim znak
-- (np. 'X') będzie podkreślony, by zaznaczyć, że dana opcja może być wybrana poprzez
-- naciśnięcie Alt + 'X' kiedy menu jest widoczne.
--
-- Operacje na opcjach menu:
--
-- Menuitem (Parent, -- tworzy opcję menu przyłączoną do macierzystego menu
-- Text, -- z tym słownym opisem,
-- Command) -- generując tę komendę kiedy zostanie wybrane.
--
-- Separator (Parent) -- tworzy separator (nieaktywna pozioma kreska)
-- -- przymocowaną do macierzystego menu.
--
----------------------------------------------------------------------------
function Menuitem (Parent : Menu_Type'Class;
Text : String;
Command : Command_Type) return Menuitem_Type;
function Separator (Parent : Menu_Type'Class) return Menuitem_Type;
----------------------------------------------------------------------------
-- Opcje menu zachowują się troszkę inaczej niż inne kontrolki, więc następujące
-- operacje są przeładowane:
--
procedure Enable (Control : in Menuitem_Type;
Enabled : in Boolean := True);
function Enabled (Control : Menuitem_Type) return Boolean;
function Get_Length (Control : Menuitem_Type) return Natural;
function Get_Text (Control : Menuitem_Type) return String;
procedure Set_Text (Control : in Menuitem_Type;
Text : in String);
function Get_State (Control : Menuitem_Type) return Boolean;
procedure Set_State (Control : in Menuitem_Type;
State : in Boolean);
----------------------------------------------------------------------------
--
-- POLA ZAZNACZENIA
--
-- Pole zaznaczenia jest podpisaną kontrolką z przyłączonym na lewo kwadracikiem,
-- który może zostaćza znaczony lub odznaczony. Klikanie na polu zaznaczenia (lub -- naciskanie spacji, kiedy kontrolka jest wybrana) zmienia stany kontrolki.
--
-- Operacje na polu zaznaczenia:
--
-- Checkbox (Parent, -- tworzy pole zaznaczenia w kontenerze,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości,
-- Height, -- i określonej wysokości,
-- Text, -- podpisane tym tekstem,
-- Checked, -- o tym stanie początkowym (domyślnie: False),
-- Font) -- używając tej czcionki (domyślnie: tak samo jak Parent).
--
----------------------------------------------------------------------------
function Checkbox (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Text : String;
Checked : Boolean := False;
Font : Font_Type := Parent_Font) return Checkbox_Type;
----------------------------------------------------------------------------
--
-- PRZYCISKI RADIO
--
-- Przycisk radio jest kontrolką Bool z przyłączonym na lewo kółkiem, które może być
-- zaznaczone lub odznaczone. Przyciski radio przymocowane do tego samego kontenera
-- tworzą grupę. Kliknięcie na odznaczony przycisk radio ustawi ten przycisk do stanu
-- zaznaczonego i odznaczy pozostałe przyciski radio znajdujące się w tej samej grupie.
-- (np. te, które są dołączone do tego samego kontenera). Inaczej niż pole zaznaczenia,
-- przycisk radio nie może zostać odznaczony poprzez kliknięcie na niego jeśli jest sam;
-- możesz odznaczyć przycisk radio tylko kiedy jednocześnie zaznaczysz inny z tej samej
-- grupy.
--
-- Operacje na przyciskach radio:
--
-- Radiobutton (Parent, -- tworzy przycisk radio w kontenerze,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości,
-- Height, -- i określonej wysokości,
-- Text, -- podpisany tym tekstem,
-- Checked, -- i ustawiony domyślnie na tę wartość (domyślnie: False),
-- Font) -- używający tej czcionki (domyślnie: Default_Font).
--
----------------------------------------------------------------------------
function Radiobutton (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Text : String;
Checked : Boolean := False;
Font : Font_Type := Parent_Font)
return Radiobutton_Type;
----------------------------------------------------------------------------
--
-- KONTROLKI WIELOKROTNEJ LINII
--
-- Kontrolki wielokrotnej linii zawierają wiele linii tekstu o numerach linii
-- od 1 wzwyż. Dostęp do pojedynczych linii może odbywać się poprzez podanie
-- numeru linii. Użytkownik może wybrać określoną linię poprzez bezpośrednie
-- kliknięcie na niej myszką, albo używając klawiszy strzałek kiedy kontrolka jest
-- wybrana. Ustawienie numeru linii do której chcemy się dostać na 0 ustawi dostęp do
-- aktualnie wybranej linii. Jeśli żadna linia nie jest wybrana, aktualny numer
-- zostanie zwrócony jako 0 ale jego zawartość wciąż będzie dostępna.
-- Błąd Constraint_Error będzie zwrócony jeśli zajdzie próba dostępu do linii poniżej
-- ostatniej.
--
-- Następujące operacje sąwspólne dla wszystkich kontrolek wielokrotnej linii,
-- ale dokładny efekt ich działań może nieco się różnić dla aktualnego typu kontrolki.
--
-- Get_Count (Control) -- zwróć ilość linii tekstu w kontrolce.
-- Get_Line (Control) -- zwróć numer aktualnie wyświetlonej linii.
-- Get_Length (Control, -- pobierz długość określonej linii
-- Line) -- (domyślnie: aktualna linia).
-- Get_Text (Control, -- pobierz tekst określonej linii jako string
-- Line) -- o nieokreślonej długości (domyślnie: aktualna linia).
--
-- Get_Text (Control, -- pobierz tekst kontrolki
-- Line, -- z określonej linii (domyślnie: aktualna linia)
-- Text, -- do stringa o ustalonej długości,
-- Length) -- razem z ilością znaków przetransferowanych.
-- Set_Text (Control, -- ustaw tekst kontrolki
-- Line, -- w określonej linii
-- Text) -- do określonej wartości.
--
-- Select_Line (Control, -- wybierz linię o określonym numerze
-- Line) -- (domyślnie: 0, oznacza odznaczenie).
-- Append_Line (Control, -- dopisz linię do końca kontrolki,
-- Text) -- gdzie ten tekst zostanie dopisany.
-- Insert_Line (Control, -- wstaw nową linię powyżej określonej linii
-- Line, -- o tym numerze, gdzie
-- Text) -- ten tekst zostanie wstawiony.
-- Delete_Line (Control, -- skasuj określoną linię.
-- Line)
-- Delete_All (Control) -- skasuj wszystkie linie.
--
----------------------------------------------------------------------------
function Get_Count (Control : Multiline_Type) return Natural is abstract;
function Get_Line (Control : Multiline_Type) return Natural is abstract;
function Get_Length (Control : Multiline_Type;
Line : Natural := 0) return Natural is abstract;
function Get_Text (Control : Multiline_Type;
Line : Natural := 0) return String is abstract;
procedure Get_Text (Control : in Multiline_Type;
Line : in Natural := 0;
Text : out String;
Length : out Natural);
procedure Set_Text (Control : in Multiline_Type;
Text : in String;
Line : in Natural := 0) is abstract;
procedure Select_Line (Control : in Multiline_Type;
Line : in Natural := 0) is abstract;
procedure Append_Line (Control : in Multiline_Type;
Text : in String) is abstract;
procedure Insert_Line (Control : in Multiline_Type;
Text : in String;
Line : in Natural := 0) is abstract;
procedure Delete_Line (Control : in Multiline_Type;
Line : in Natural := 0) is abstract;
procedure Delete_All (Control : in Multiline_Type) is abstract;
----------------------------------------------------------------------------
--
-- Dostępne typy kontrolki wielokrotnej linii są następujące:
--
-- Listbox_Type : lista tekstowa w skrolowanym oknie
-- Combobox_Type : pole edycyjne z opuszczaną listą tekstową
-- Memo_Type : wieloliniowy edytor
--
----------------------------------------------------------------------------
type Listbox_Type is new Multiline_Type with private;
type Combobox_Type is new Multiline_Type with private;
type Memo_Type is new Multiline_Type with private;
----------------------------------------------------------------------------
--
-- LISTA TEKSTOWA
--
-- Lista tekstowa jest listą linii tekstu (pusta przy inicjalizacji). Linie są
-- posortowane domyślnie w porządku rosnącym, ale mogą pozostać nieposortowane
-- jeśli zachodzi taka potrzeba. Dla posortowanej listy pozycja, w której nowa linia jest
-- dodawana będzie ignorowana, z nową linią dopisywaną na odpowiedniej pozycji
-- odpowiedniej dla jej wartości, kiedy żadne linie nie zostały wybrane
-- zawartość aktualnej linii zostanie zwrócona jako pusty string ("").
--
-- Operacje na listach tekstowych:
--
-- Listbox (Parent, -- stwórz listę tekstową wewnątrz kontenera,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości,
-- Height, -- i określonej wysokości,
-- Font) -- używającą tej czcionki (domyślnie: ta sama co Parent).
--
----------------------------------------------------------------------------
function Listbox (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Font : Font_Type := Parent_Font) return Listbox_Type;
----------------------------------------------------------------------------
--
-- KOMBO
--
-- Kombo składa się z pola edycyjnego z opuszczaną listą tekstową.
-- Aktualnie wybrana linia jest wyświetlana w polu edycyjnym, i można ustalić
-- czy użytkownik jest w stanie sam zmienić tę wartość. Jeśli nie, tylko wartości
-- z listy tekstowej mogą być wybrane.
--
-- Jeśli zawartość pola edycyjnego pasuje do którejś z wartości z listy, pozycja
-- odpowiadająca tej linii w liście jest zwracana jako aktualnie wybrana wartość.
-- W przesuwnym wypadku numer aktualnej linii jest zwracany jako 0.
-- Dostęp do wartości aktualnej linii (linii 0) zwróci aktualną wartość pola edycyjnego.
--
-- Operacje na kombo:
--
-- Combobox (Parent, -- tworzy kombo wewnątrz kontenera,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości, którego wartość może być
-- Editable, -- ręcznie edytowana (domyślnie : True),
-- Font) -- używające tej czcionki (domyślnie: ta sama co Parent).
--
----------------------------------------------------------------------------
function Combobox (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Editable : Boolean := True;
Font : Font_Type := Parent_Font) return Combobox_Type;
----------------------------------------------------------------------------
--
-- POLA MEMO
--
-- Pole typu memo jest prostym edytorem tekstowym, z wielokrotnymi liniami tekstu,
-- podobnym do Notatnika. Jest kilka specyficznych operacji dodatkowych do
-- standardowych operacji na kontrolkach wielokrotnej linii. Użytkownik może wybrać
-- blok tekstu, zaznaczając kilka linii myszką (albo przesuwając kursor trzymając
-- jednocześnie klawisz shift) i może skopiować, podmienić lub skasować wybrany tekst.
-- pobrać linię i kolumnę pozycji początku i końca zaznaczonego tekstu i jego całkowitą
-- długość (która będzie zawierać jeden lub więcej znaków końca linii, jeśli zaznaczony
-- tekst przebiega więcej niż jedną linię.
--
-- Operacje na polach memo:
--
-- Memo (Parent, -- tworzy pole memo wewnątrz kontenera,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości
-- Height) -- i określonej wysokości
-- Font) -- używające tej czcionki (domyślnie: ta sama co Parent).
--
-- Get_Column (Memo) -- pobiera kolumnę pozycji aktualnego wyboru
-- Modified (Memo) -- sprawdza czy użytkownik zmodyfikował pole memo..
-- Cut_Selection (Memo) -- wycina aktualny wybór do schowka.
-- Copy_Selection (Memo) -- kopiuje aktualny wybór do schowka.
-- Paste_Selection (Memo) -- wkleja zawartość schowka do pola memo,
-- -- zastępując aktualnie wybrany tekst.
-- Undo_Change (Memo) -- cofa ostatnio wprowadzoną przez użytkownika zmianę do memo.
-- Show_Selection (Memo) -- skroluje memo więc aktualna pozycja jest widoczna na ekranie.
--
----------------------------------------------------------------------------
function Memo (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Font : Font_Type := Parent_Font) return Memo_Type;
function Get_Column (Memo : Memo_Type) return Natural;
function Modified (Memo : Memo_Type) return Boolean;
procedure Cut_Selection (Memo : in Memo_Type);
procedure Copy_Selection (Memo : in Memo_Type);
procedure Paste_Selection (Memo : in Memo_Type);
procedure Undo_Change (Memo : in Memo_Type);
procedure Show_Selection (Memo : in Memo_Type);
----------------------------------------------------------------------------
-- Większość operacji na wielokrotnych liniach jest zaimplementowana w różny sposób,
-- więc są tutaj przeładowane:
--
function Get_Count (Control : Listbox_Type) return Natural;
function Get_Count (Control : Combobox_Type) return Natural;
function Get_Count (Control : Memo_Type) return Natural;
function Get_Line (Control : Listbox_Type) return Natural;
function Get_Line (Control : Combobox_Type) return Natural;
function Get_Line (Control : Memo_Type) return Natural;
function Get_Length (Control : Listbox_Type;
Line : Natural := 0) return Natural;
function Get_Length (Control : Combobox_Type;
Line : Natural := 0) return Natural;
function Get_Length (Control : Memo_Type;
Line : Natural := 0) return Natural;
function Get_Text (Control : Listbox_Type;
Line : Natural := 0) return String;
function Get_Text (Control : Combobox_Type;
Line : Natural := 0) return String;
function Get_Text (Control : Memo_Type;
Line : Natural := 0) return String;
procedure Set_Text (Control : in Listbox_Type;
Text : in String;
Line : in Natural := 0);
procedure Set_Text (Control : in Combobox_Type;
Text : in String;
Line : in Natural := 0);
procedure Set_Text (Control : in Memo_Type;
Text : in String;
Line : in Natural := 0);
procedure Select_Line (Control : in Listbox_Type;
Line : in Natural := 0);
procedure Select_Line (Control : in Combobox_Type;
Line : in Natural := 0);
procedure Select_Line (Control : in Memo_Type;
Line : in Natural := 0);
procedure Append_Line (Control : in Listbox_Type;
Text : in String);
procedure Append_Line (Control : in Combobox_Type;
Text : in String);
procedure Append_Line (Control : in Memo_Type;
Text : in String);
procedure Insert_Line (Control : in Listbox_Type;
Text : in String;
Line : in Natural := 0);
procedure Insert_Line (Control : in Combobox_Type;
Text : in String;
Line : in Natural := 0);
procedure Insert_Line (Control : in Memo_Type;
Text : in String;
Line : in Natural := 0);
procedure Delete_Line (Control : in Listbox_Type;
Line : in Natural := 0);
procedure Delete_Line (Control : in Combobox_Type;
Line : in Natural := 0);
procedure Delete_Line (Control : in Memo_Type;
Line : in Natural:= 0);
procedure Delete_All (Control : in Listbox_Type);
procedure Delete_All (Control : in Combobox_Type);
procedure Delete_All (Control : in Memo_Type);
----------------------------------------------------------------------------
--
-- KADR
--
-- Kadr jest pustym prostokątem do rysowania, który opcjonalnie może generować
-- kod komendy, kiedy zostanie kliknięty.
-- Kadr ma przyporządkowaną czcionkę (domyślnie ta sama, co macierzystego okna),
-- kolor tła (początkowo białe), pędzel do rysowania linii (początkowo białe,
-- szerokość 1 px) i kolor wypełniania używany do kolorowania zamkniętych kształtów
-- (początkowo biały).
--
-- Łatwość ekspresji dostępna na kadrach tworzy z nich najbardziej skomplikowane
-- komponenty ze wszystkich, z ponad 20 dostępnymi operacjami.
-- Istnieją operacje do rysowania linii, prostokątów (z lub bez zaokrąglonych rogów)
-- elips, sekwencji linii, wielokątów i tekstu. Czcionka, rozmiar pędzla
-- kolor i kolor wypełnienia może być zmieniany w każdej chwili i będzie dotyczył
-- tylko następujących po tym operacji. Prostokąty mogą mieć zaokrąglone rogi,
-- o zadawanym współczynniku zaokrąglenia, który podaje wektory od punktu X i Y do
-- punktów, gdzie zaokrąglenie się rozpoczyna.
--
-- Wszystko narysowane na kadrze zwykle na nim zostaje, ale kadr może zostać
-- wyczyszczony albo aktualny stan może zostać zachowany i później przywrócony,
-- co daje podstawową możliwość cofania wykonanych kroków.
-- Na przykład zegar może zostać narysowany poprzez narysowanie koła,
-- zachowanie rysunku, potem domalowanie wskazówek. By zmienić pozycję
-- wystarczy przywrócić zachowany rysunek (wymazując w ten sposób aktualny)
-- i narysować wskazówki w nowej pozycji. Można zachować tylko jedną kopię
-- rysowanego obrazka, więc jeśli zachowasz po raz drugi, stracisz dane z pierwszego.
--
-- Kadr może zostać ustawiony by generować komendę, kiedy przycisk myszki zostanie
-- naciśnięty wewnątrz jego brzegów. Istnieją funkcje pobierające pozycję na, której
-- został naciśnięty przycisk myszki, testujące czy przycisk myszki wciąż jest
-- naciśnięty lub czy myszka poruszyła się. Jak długo przycisk myszki jest naciśnięty,
-- pozycja myszki jest śledzona nawet jeśli opuści ona kadr. Możesz wizualnie prześledzić
-- ścieżkę myszki, zachowując kadr kiedy myszka zostanie pierwszy raz naciśnięta, potem
-- wgrywając go z powrotem i rysując nową linię od pozycji początkowej do aktualnej.
--
-- Operacje na kadrach:
--
-- Canvas (Parent, -- tworzy kadr wewnątrz kontenera,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości,
-- Height, -- i określonej wysokości,
-- Font) -- używający tej czcionki (domyślnie: ta sama co Parent).
--
-- Canvas (Parent, -- tworzy kadr wewnątrz kontenera,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości,
-- Height, -- i określonej wysokości,
-- Command, -- który generuje tę komendę,
-- Font) -- i używa tej czcionki (domyślnie: ta sama co Parent).
--
-- Canvas (Parent, -- tworzy kadr wewnątrz kontenera,
-- Origin, -- o współrzędnych góra lewo relatywnie do macierzystego,
-- Width, -- o określonej szerokości,
-- Height, -- i określonej wysokości,
-- Command, -- który generuje tę komendę,
-- Keypress, -- i tę kiedy klawisz jest naciśnięty,
-- Font) -- i używa tej czcionki (domyślnie: ta sama co Parent).
--
-- Set_Colour (Canvas, -- ustawia kolor tła kadru
-- Colour) -- używając tego koloru (domyślnie: biały)
--
-- Erase (Canvas) -- czyści kadr,
-- -- wymazuje także zachowane rysunki.
-- Save (Canvas) -- zapisuje aktualny rysunek.
-- Restore (Canvas) -- przywraca zachowany rysunek, wymazując wszystko
-- -- narysowane później. Jeśli rysunek nie był wczśeniej
-- -- zachowywany lub okno było, używając Erase, nic
-- -- się nie stanie.
-- Set_Font (Canvas, -- ustaw nową czcionkę dla wszystkich następnych tekstów,
-- Font) -- rysowanych na kadrze.
-- Set_Pen (Canvas, -- ustaw pędzel do rysowania linii na kadrze
-- Colour, -- do tego koloru (domyślnie: czarny)
-- Width) -- i grubość (domyślnie: 1 piksel).
-- Set_Fill (Canvas, -- ustaw kolor dla następnych wypełnień
-- Colour) -- zamkniętych kształtów rysowanych na kadrze.
-- Set_Fill (Canvas) -- wyczyść kolor użyty do następnych wypełnień
-- -- zamkniętych kształtów rysowanych na kadrze.
-- Draw_Text (Canvas, -- napisz string tekstowy na kadrze
-- From, -- od punktu góra-lewo, gdzie
-- Text) -- to jest tekst, który będzie wypisany.
-- Draw_Text (Canvas, -- napisz string tekstowy na kadrze
-- From, -- w prostokącie między tym punktem
-- To, -- a tym punktem, gdzie
-- Text, -- to jest tekst, który będzie wypisany,
-- Align) -- z tym wyrównaniem (domyślnie: left).
-- Draw_Text (Canvas, -- napisz string tekstowy na kadrze
-- From, -- w prostokącie zaczynającym się od tego punktu
-- Width, -- o tej szerokości
-- Height, -- i tej wysokości, gdzie
-- Text, -- to jest tekst, który będzie wypisany,
-- Align) -- tym wyrównaniem (domyślnie: left).
--
-- Draw_Line (Canvas, -- narysuj linię na kadrze
-- From, -- od tego punktu
-- To) -- do tego punktu.
-- Draw_Line (Canvas, -- narysuj linię na kadrze
-- From, -- od tego punktu
-- Length, -- o tej długości
-- Angle) -- pod tym kątem.
-- Draw_Line_List (Canvas, -- narysuj linie na kadrze łączące
-- Points) -- punkty z tej listy.
--
-- Draw_Rectangle (Canvas, -- narysuj prostokąt na kadrze
-- From, -- o tego punktu narożnego
-- To, -- do tego punktu przeciwnie na przekątnej
-- Rounding) -- z tak zaokrąglonymi narożnikami
-- -- (domyślnie: brak zaokrąglenia).
-- Draw_Rectangle (Canvas, -- narysuj prostokąt na kadrze
-- From, -- od tego punktu góra lewo
-- Width, -- o tej szerokości
-- Height, -- i tej wysokości
-- Rounding) -- z tak zaokrąglonymi narożnikami
-- -- (domyślnie: brak zaokrąglenia).
--
-- Draw_Ellipse (Canvas, -- narysuj elipsę na kadrze
-- From, -- związaną przez prostokąt od tego punktu
-- To) -- do tego punktu.
-- Draw_Ellipse (Canvas, -- narysuj elipsę na kadrze
-- From, -- związaną przez prostokąt od tego punktu
-- Width, -- o tej szerokości,
-- Height) -- i tej wysokości
-- Draw_Circle (Canvas, -- narysuj koło na kadrze
-- Centre, -- o tym środku koła
-- Radius) -- i tym promieniu.
--
-- Draw_Polygon (Canvas, -- narysuj wielobok na kadrze
-- Points) -- o takich wierzchołkach.
--
-- Draw_Image (Canvas, -- narysuj obrazek na kadrze
-- From, -- od tego punktu
-- Image) -- używając tego obiektu-obrazka.
-- Draw_Image (Canvas, -- narysuj obrazek na kadrze
-- From, -- od tego punktu
-- To, -- do tego punktu (rozszerzając obrazek, by pasował).
-- Image) -- używając tego obiektu-obrazka.
-- Draw_Image (Canvas, -- narysuj obrazek na kadrze
-- From, -- od tego punktu
-- Width, -- o tej szerokości
-- Height, -- i tej wysokości
-- Image) -- używając tego obiektu-obrazka.
--
-- Mouse_Down (Canvas) -- sprawdź czy lewy przycisk myszki naciśnięty.
-- Mouse_Moved (Canvas) -- sprawdźczy poruszono myszką.
-- Start_Point (Canvas) -- pobierz punkt, gdzie przycisk myszki został
-- -- po raz pierwszy naciśnięty.
-- End_Point (Canvas) -- pobierz punkt gdzie przycisk myszki jest teraz.
-- -- (lub jego ostateczną pozycję, gdzie przycisk
-- -- myszki został puszczony).
-- Key_Code (Canvas) -- pobierz kod znaku ostatnio naciśniętego
-- -- klawisza.
--
----------------------------------------------------------------------------
function Canvas (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Font : Font_Type := Parent_Font) return Canvas_Type;
function Canvas (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Command : Command_Type;
Font : Font_Type := Parent_Font) return Canvas_Type;
function Canvas (Parent : Container_Type'Class;
Origin : Point_Type;
Width : Integer;
Height : Integer;
Command : Command_Type;
Keypress : Command_Type;
Font : Font_Type := Parent_Font) return Canvas_Type;
procedure Set_Colour (Canvas : in Canvas_Type;
Colour : in Colour_Type := White);
procedure Erase (Canvas : in Canvas_Type);
procedure Save (Canvas : in Canvas_Type);
procedure Restore (Canvas : in Canvas_Type);
procedure Set_Font (Canvas : in Canvas_Type;
Font : in Font_Type);
procedure Set_Pen (Canvas : in Canvas_Type;
Colour : in Colour_Type := Black;
Width : in Natural := 1);
procedure Set_Fill (Canvas : in Canvas_Type;
Colour : in Colour_Type);
procedure Set_Fill (Canvas : in Canvas_Type);
procedure Draw_Text (Canvas : in Canvas_Type;
From : in Point_Type;
Text : in String);
procedure Draw_Text (Canvas : in Canvas_Type;
From : in Point_Type;
To : in Point_Type;
Text : in String;
Align : in Alignment_Type := Left);
procedure Draw_Text (Canvas : in Canvas_Type;
From : in Point_Type;
Width : in Integer;
Height : in Integer;
Text : in String;
Align : in Alignment_Type := Left);
procedure Draw_Line (Canvas : in Canvas_Type;
From : in Point_Type;
To : in Point_Type);
procedure Draw_Line (Canvas : in Canvas_Type;
From : in Point_Type;
Length : in Positive;
Angle : in Angle_Type);
procedure Draw_Line_List
(Canvas : in Canvas_Type;
Points : in Point_List);
procedure Draw_Rectangle
(Canvas : in Canvas_Type;
From : in Point_Type;
To : in Point_Type;
Rounding : in Point_Type := (0,0));
procedure Draw_Rectangle
(Canvas : in Canvas_Type;
From : in Point_Type;
Width : in Positive;
Height : in Positive;
Rounding : in Point_Type := (0,0));
procedure Draw_Ellipse
(Canvas : in Canvas_Type;
From : in Point_Type;
To : in Point_Type);
procedure Draw_Ellipse
(Canvas : in Canvas_Type;
From : in Point_Type;
Width : in Positive;
Height : in Positive);
procedure Draw_Circle
(Canvas : in Canvas_Type;
Centre : in Point_Type;
Radius : in Positive);
procedure Draw_Polygon
(Canvas : in Canvas_Type;
Points : in Point_List);
procedure Draw_Image (Canvas : in Canvas_Type;
From : in Point_Type;
Image : in Image_Type);
procedure Draw_Image (Canvas : in Canvas_Type;
From : in Point_Type;
To : in Point_Type;
Image : in Image_Type);
procedure Draw_Image (Canvas : in Canvas_Type;
From : in Point_Type;
Width : in Natural;
Height : in Natural;
Image : in Image_Type);
function Start_Point (Canvas : Canvas_Type) return Point_Type;
function End_Point (Canvas : Canvas_Type) return Point_Type;
function Mouse_Down (Canvas : Canvas_Type) return Boolean;
function Mouse_Moved (Canvas : Canvas_Type) return Boolean;
function Key_Code (Canvas : Canvas_Type) return Character;
----------------------------------------------------------------------------
--
-- POSPOLITE DIALOGI
--
-- Zwykłe dialogi są przygotowanymi dialog które nie są traktowane jako normalne
-- okna (chociaż są robione by wyglądały tak samo, dla czytelności obrazu).
--
-- Operacje na pospolitych dialogach (wspólne dla wszystkich dialogów):
--
-- Execute (Dialog) -- uruchom dialog i zwróć True jeśli przycisk
-- -- OK został naciśnięty by zamknąć dialog inaczej False
--
----------------------------------------------------------------------------
type Common_Dialog_Type is abstract tagged private;
function Execute (Dialog : Common_Dialog_Type) return Boolean;
----------------------------------------------------------------------------
--
-- PODKLASY POSPOLITYCH DIALOGÓW
--
-- Dostępne podklasy pospolitych dialogów to kolorów, czcionek, i dialog plikowy.
--
-- Colour_Dialog_Type : dialog pozwalający wybrać użytkownikowi kolor.
-- Font_Dialog_Type : dialog pozwalający wybrać użytkownikowi czcionkę.
-- File_Dialog_Type : dialog pozwalający wybrać użytkownikowi plik.
--
----------------------------------------------------------------------------
type Colour_Dialog_Type is new Common_Dialog_Type with private;
type Font_Dialog_Type is new Common_Dialog_Type with private;
type File_Dialog_Type is abstract new Common_Dialog_Type with private;
----------------------------------------------------------------------------
--
-- DIALOG KOLORÓW
--
-- Dialog kolorów pozwala wybrać lub utworzyć użytkownikowi kolor.
--
-- Operacje na dialogach kolorów:
--
-- Colour_Dialog -- tworzy dialog kolorów.
-- Set_Colour (Dialog, -- ustawia początkowy kolor wyświetlany w dialogu
-- Colour) -- do tego koloru.
-- Get_Colour (Dialog) -- pobierz kolor zawarty w dialogu.
--
----------------------------------------------------------------------------
function Colour_Dialog return Colour_Dialog_Type;
procedure Set_Colour (Dialog : in Colour_Dialog_Type;
Colour : in Colour_Type);
function Get_Colour (Dialog : in Colour_Dialog_Type) return Colour_Type;
----------------------------------------------------------------------------
--
-- DIALOG CZCIONEK
--
-- Dialog czcionek pozwala wybrać użytkownikowi czcionkę.
--
-- Operacje na dialogach czcionek:
--
-- Font_Dialog -- tworzy dialog czcionek.
-- Set_Font (Dialog, -- ustawia początkową czcionkę wyświetlaną
-- Font) -- w dialogu jako tę czcionkę.
-- Get_Font (Dialog) -- pobiera czcionkę zawartą w dialogu.
--
----------------------------------------------------------------------------
function Font_Dialog return Font_Dialog_Type;
procedure Set_Font (Dialog : in Font_Dialog_Type;
Font : in Font_Type);
function Get_Font (Dialog : in Font_Dialog_Type) return Font_Type;
----------------------------------------------------------------------------
--
-- DIALOGI PLIKOWE
--
-- Dialogi plikowe pozwalają użytkownikowi wybrać plik lub wprowadzić jego nazwę.
-- Jest to typ abstrakcyjny, który jest opisany szerzej poniżej.
--
-- Operacje na dialogach plikowych (wspólne dla wszystkich dialogów plikowych):
--
-- Set_Name (Dialog, -- ustawia początkową nazwę pliku wyświetlaną
-- Name) -- w dialogu do tej nazwy.
-- Get_Name (Dialog) -- pobiera nazwę pliku zawartą w dialogu.
-- Add_Filter (Dialog, -- dodaje filtr dla dialogu
-- Text, -- o tym opisie
-- Filter) -- by pasował do takiej maski.
-- Set_Directory (Dialog, -- ustawia katalog inicjalizacyjny
-- Name) -- na ten katalog.
--
----------------------------------------------------------------------------
procedure Set_Name (Dialog : in File_Dialog_Type;
Name : in String);
function Get_Name (Dialog : in File_Dialog_Type) return String;
procedure Add_Filter (Dialog : in File_Dialog_Type;
Text : in String;
Filter : in String);
procedure Set_Directory (Dialog : in File_Dialog_Type;
Name : in String);
----------------------------------------------------------------------------
--
-- DIALOG OTWIERANIA PLIKU
--
-- Dialog otwierania pliku pozwala wybrać użytkownikowi lub wprowadzić nazwę
-- do użycia jako plik wejścia. Wybrana nazwa pliku musi odpowiadać istniejącemu
-- plikowi.
--
-- Operacje na dialogach otwierania plików:
--
-- Open_Dialog (Title) -- tworzy dialog otwierania plików o tym tytule.
--
----------------------------------------------------------------------------
type Open_Dialog_Type is new File_Dialog_Type with private;
function Open_Dialog (Title : String) return Open_Dialog_Type;
----------------------------------------------------------------------------
--
-- DIALOG ZACHOWYWANIA PLIKÓW
--
-- Dialog zachowywania plików pozwala użytkownikowi wybrać lub wprowadzić
-- nazwę pliku do użycia jako plik wyjścia. Jeśli parametr Create poniższej funkcji
-- jest True (tak jest domyślnie) i wybrany jest istniejący plik,
-- użytkownik zostanie zapytany czy wybrany plik ma być nadpisany. Jeśli jest False
-- i plik nie istnieje, użytkownik zostanie zapytany czy plik powinien zostać
-- utworzony.
--
-- Operacje na dialogach zachowywania plików:
--
-- Save_Dialog (Title, -- tworzy dialog zachowywania plików o tym tytule
-- Create) -- który poprosi użytkownika o powyższe czynności.
--
----------------------------------------------------------------------------
type Save_Dialog_Type is new File_Dialog_Type with private;
function Save_Dialog (Title : String;
Create : Boolean := True) return Save_Dialog_Type;
----------------------------------------------------------------------------
-- Zmiany nazw dla amerykańskiej odmiany angielskiego
----------------------------------------------------------------------------
procedure Set_Color (Canvas : in Canvas_Type;
Colour : in Colour_Type := White) renames Set_Colour;
subtype Color_Dialog_Type is Colour_Dialog_Type;
function Color_Dialog return Colour_Dialog_Type renames Colour_Dialog;
procedure Set_Color (Dialog : in Colour_Dialog_Type;
Colour : in Colour_Type) renames Set_Colour;
function Get_Color (Dialog : in Colour_Dialog_Type) return Colour_Type
renames Get_Colour;
private
-- detale implementacji
end JEWL.Windows;