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;