Animowane powiadomienia Toast dla Delphi - może się komuś przyda

{******************************************************************************
  Toast Notification Component for Delphi VCL
  
  Author: FPERSON
  
  Description:
    A modern, customizable toast notification system for VCL applications.
    Provides non-intrusive popup notifications with support for multiple styles,
    animations, and flexible positioning. Compatible with Windows applications
    using the VCL framework.
    
  Features:
    - Multiple notification types (Success, Error, Warning, Info)
    - Smooth fade-in/fade-out animations
    - Customizable colors, fonts, and durations
    - Multiple position options (Top/Bottom, Left/Center/Right)
    - Queue management for multiple notifications
    - Shadow effects and modern UI design
    
  Usage:
    ShowToast('Message', ttSuccess);
    
  Requirements:
    - Delphi VCL (Visual Component Library)
    - Windows OS
	
------------------------------------------------------------
	
PL

  Opis:
    Nowoczesny, konfigurowalny system powiadomień toast dla aplikacji VCL.
    Zapewnia dyskretne wyskakujące powiadomienia z obsługą wielu stylów,
    animacji i elastycznego pozycjonowania. Kompatybilny z aplikacjami
    Windows wykorzystującymi framework VCL.
    
  Funkcje:
    - Wiele typów powiadomień (Sukces, Błąd, Ostrzeżenie, Info)
    - Płynne animacje pojawiania i zanikania
    - Konfigurowalne kolory, czcionki i czas wyświetlania
    - Wiele opcji pozycjonowania (Góra/Dół, Lewo/Środek/Prawo)
    - Zarządzanie kolejką dla wielu powiadomień
    - Efekty cienia i nowoczesny design
    
  Użycie:
    ShowToast('Wiadomość', ttSuccess);
    
  Wymagania:
    - Delphi VCL (Visual Component Library)
    - System operacyjny Windows
	
******************************************************************************}

unit ToastNotification;

interface

uses
  Winapi.Windows, Winapi.Messages, Vcl.ExtCtrls, Vcl.Controls, Vcl.Forms,
  Vcl.Graphics, System.Classes, System.SysUtils, System.Generics.Collections;

type
  { TToastPosition - Określa gdzie na ekranie ma pojawić się toast }
  TToastPosition = (tpBottom, tpTop, tpCenter);

  { TToastSettings - Rekord z konfiguracją wyglądu i zachowania toastu
    Pozwala na pełną personalizację: kolory, rozmiar, czas trwania, prędkość animacji i pozycję }
  TToastSettings = record
    BackgroundColor: TColor;  // Kolor tła toastu
    TextColor: TColor;        // Kolor tekstu
    FontSize: Integer;        // Rozmiar czcionki
    FontStyle: TFontStyles;   // Styl czcionki (pogrubienie, kursywa, etc.)
    Width: Integer;           // Szerokość toastu w pikselach
    Height: Integer;          // Wysokość toastu w pikselach
    Duration: Integer;        // Czas wyświetlania w milisekundach (2000 = 2 sekundy)
    AnimationSpeed: Integer;  // Prędkość animacji (ms między klatkami animacji)
    Position: TToastPosition; // Pozycja na ekranie (dół, góra, środek)
  end;

  { TToast - Klasa zarządzająca wyświetlaniem animowanych powiadomień toast
    DZIAŁANIE:
    1. Toast pojawia się z animacją wjazdu (20 klatek)
    2. Pozostaje widoczny przez określony czas (Duration)
    3. Zjeżdża z animacją wyjazdu (20 klatek)
    4. Automatycznie się niszczy po zakończeniu

    STACK:
    - Tosty wyświetlają się jeden nad drugim bez nakładania
    - Każdy nowy toast pojawia się nad poprzednim (dla tpBottom) lub pod (dla tpTop)
    - Automatyczne przesuwanie gdy toast znika

    UŻYCIE:
    TToast.Show(Self, 'Wiadomość'); // Domyślne ustawienia
    TToast.Show(Self, 'Sukces!', TToast.SuccessSettings); // Predefiniowany styl

    FUNKCJE ANIMACJI:
    - Wjazd: Płynne pojawienie się z pozycji startowej do docelowej
    - Czekanie: Toast pozostaje nieruchomy przez czas Duration
    - Zjazd: Płynne zniknięcie w kierunku zależnym od pozycji }
  TToast = class
  private
    FPanel: TPanel;          // Panel wyświetlający toast
    FTimer: TTimer;          // Timer sterujący animacją
    FStep: Integer;          // Aktualny krok animacji (0..TotalSteps)
    FShouldFree: Boolean;    // Flaga wskazująca czy obiekt powinien się zwolnić
    FSettings: TToastSettings; // Ustawienia toastu
    FTargetY: Integer;       // Docelowa pozycja Y (po zakończeniu wjazdu)
    FStartY: Integer;        // Początkowa pozycja Y (przed animacją wjazdu)
    FOwner: TComponent;      // Zapamiętany owner dla stacku

    class var FActiveToasts: TObjectList<TToast>;  // Lista aktywnych toastów (stack)

    // Metody prywatne
    procedure OnTimer(Sender: TObject);       // Główna pętla animacji
    procedure AnimateEntrance(Parent: TWinControl); // Animacja wjazdu
    procedure AnimateExit(Parent: TWinControl);     // Animacja zjazdu
    procedure FreeResources;                  // Bezpieczne zwolnienie zasobów
    procedure CalculatePosition(Parent: TWinControl); // Oblicza pozycję toastu w stacku
    procedure FinishToast;                    // Kończy animację i zwalnia obiekt

    class procedure UpdateToastPositions;     // Aktualizuje pozycje wszystkich toastów w stacku

  public
    // Konstruktory
    constructor Create(AOwner: TComponent; const Msg: string); overload;
    constructor Create(AOwner: TComponent; const Msg: string;
      const Settings: TToastSettings); overload;
    destructor Destroy; override;

    // Metody statyczne do wyświetlania toastu
    class procedure Show(AOwner: TComponent; const Msg: string); overload;
    class procedure Show(AOwner: TComponent; const Msg: string;
      const Settings: TToastSettings); overload;

    // Predefiniowane ustawienia dla różnych typów komunikatów
    class function DefaultSettings: TToastSettings; // Domyślne (szary)
    class function SuccessSettings: TToastSettings; // Sukces (zielony)
    class function ErrorSettings: TToastSettings;   // Błąd (czerwony)
    class function WarningSettings: TToastSettings; // Ostrzeżenie (pomarańczowy)
    class function InfoSettings: TToastSettings;    // Informacja (niebieski)

    // Konstruktory/destruktory klasowe
    class constructor Create;
    class destructor Destroy;
  end;

var
  DefaultToastSettings: TToastSettings; // Globalne domyślne ustawienia

implementation

{ TToast }

// ============================================================================
// INICJALIZACJA KLASOWA
// ============================================================================

{ Inicjalizacja statycznych pól klasy }
class constructor TToast.Create;
begin
  FActiveToasts := TObjectList<TToast>.Create(False); // False = nie zwalnia automatycznie
end;

{ Czyszczenie statycznych pól klasy }
class destructor TToast.Destroy;
begin
  FActiveToasts.Free;
end;

// ============================================================================
// INICJALIZACJA DOMYŚLNYCH USTAWIEŃ
// ============================================================================

{ Inicjalizuje globalne domyślne ustawienia toastu.
  Te ustawienia są używane gdy wywołujemy TToast.Show bez podania Settings. }
procedure InitializeDefaultSettings;
begin
  with DefaultToastSettings do
  begin
    BackgroundColor := $00333333; // Ciemny szary (RGB: 51, 51, 51)
    TextColor := clWhite;         // Biały tekst
    FontSize := 10;               // Rozmiar czcionki 10
    FontStyle := [fsBold];        // Pogrubiony tekst
    Width := 300;                 // Szerokość 300px
    Height := 45;                 // Wysokość 45px
    Duration := 2000;             // Czas wyświetlania: 2 sekundy
    AnimationSpeed := 15;         // Animacja: klatka co 15ms (~66 FPS)
    Position := tpBottom;         // Pozycja: na dole ekranu
  end;
end;

// ============================================================================
// PREDEFINIOWANE USTAWIENIA
// ============================================================================

{ Zwraca domyślne ustawienia toastu }
class function TToast.DefaultSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
end;

{ Ustawienia dla komunikatów sukcesu - zielone tło }
class function TToast.SuccessSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
  Result.BackgroundColor := $004CAF50; // Zielony Material Design
  Result.TextColor := clWhite;
end;

{ Ustawienia dla komunikatów błędu - czerwone tło }
class function TToast.ErrorSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
  Result.BackgroundColor := $00F44336; // Czerwony Material Design
  Result.TextColor := clWhite;
end;

{ Ustawienia dla komunikatów ostrzeżenia - pomarańczowe tło }
class function TToast.WarningSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
  Result.BackgroundColor := $00FF9800; // Pomarańczowy Material Design
  Result.TextColor := clBlack;         // Czarny tekst dla lepszej czytelności
end;

{ Ustawienia dla komunikatów informacyjnych - niebieskie tło }
class function TToast.InfoSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
  Result.BackgroundColor := $002196F3; // Niebieski Material Design
  Result.TextColor := clWhite;
end;

// ============================================================================
// PUBLICZNE METODY STATYCZNE
// ============================================================================

{ Wyświetla toast z domyślnymi ustawieniami.
  @param AOwner - Komponent właściciel (okno nadrzędne)
  @param Msg - Tekst do wyświetlenia }
class procedure TToast.Show(AOwner: TComponent; const Msg: string);
begin
  TToast.Create(AOwner, Msg);
end;

{ Wyświetla toast z niestandardowymi ustawieniami.
  @param AOwner - Komponent właściciel
  @param Msg - Tekst do wyświetlenia
  @param Settings - Niestandardowe ustawienia wyglądu i zachowania }
class procedure TToast.Show(AOwner: TComponent; const Msg: string;
  const Settings: TToastSettings);
begin
  TToast.Create(AOwner, Msg, Settings);
end;

// ============================================================================
// KONSTRUKTORY I DESTRUKTOR
// ============================================================================

{ Konstruktor z domyślnymi ustawieniami.
  Przekierowuje do konstruktora z niestandardowymi ustawieniami. }
constructor TToast.Create(AOwner: TComponent; const Msg: string);
begin
  Create(AOwner, Msg, DefaultToastSettings);
end;

{ Główny konstruktor tworzący i konfigurujący toast.
  KROKI TWORZENIA:
  1. Określa okno nadrzędne (ParentControl)
  2. Tworzy panel toastu z odpowiednimi właściwościami
  3. Dodaje toast do listy aktywnych (stack)
  4. Oblicza pozycję startową i docelową z uwzględnieniem innych toastów
  5. Uruchamia timer animacji }
constructor TToast.Create(AOwner: TComponent; const Msg: string;
  const Settings: TToastSettings);
var
  ParentControl: TWinControl;
begin
  inherited Create;

  FSettings := Settings;
  FShouldFree := False;
  FOwner := AOwner;

  // Określamy okno nadrzędne dla toastu
  if AOwner is TWinControl then
    ParentControl := TWinControl(AOwner)
  else
    ParentControl := Application.MainForm;

  // Tworzymy panel toastu
  FPanel := TPanel.Create(nil);
  try
    FPanel.Parent := ParentControl;

    // Konfiguracja wyglądu panelu
    FPanel.Caption := Msg;
    FPanel.Color := FSettings.BackgroundColor;
    FPanel.Font.Color := FSettings.TextColor;
    FPanel.Font.Size := FSettings.FontSize;
    FPanel.Font.Style := FSettings.FontStyle;
    FPanel.BevelOuter := bvNone;          // Bez obramowania
    FPanel.Width := FSettings.Width;
    FPanel.Height := FSettings.Height;
    FPanel.DoubleBuffered := True;        // Zapobiega migotaniu

    // Optymalizacje wydajnościowe
    FPanel.ParentBackground := False;
    FPanel.ParentDoubleBuffered := False;

    // WAŻNE: Dodaj toast do listy PRZED obliczeniem pozycji
    FActiveToasts.Add(Self);

    // Oblicz i ustaw pozycję (z uwzględnieniem stacku)
    CalculatePosition(ParentControl);

    // Pokazujemy i ustawiamy na wierzchu
    FPanel.Visible := True;
    FPanel.BringToFront;

    // Inicjalizacja animacji
    FStep := 0;
    FTimer := TTimer.Create(nil);
    FTimer.Interval := FSettings.AnimationSpeed;
    FTimer.OnTimer := OnTimer;
    FTimer.Enabled := True;
  except
    // W razie błędu bezpiecznie zwalniamy zasoby
    FActiveToasts.Remove(Self);
    FreeResources;
    raise;
  end;
end;

{ Destruktor - bezpiecznie zwalnia wszystkie zasoby }
destructor TToast.Destroy;
begin
  FreeResources;
  inherited;
end;

// ============================================================================
// METODY PRYWATNE - ZARZĄDZANIE STACKIEM
// ============================================================================

{ Aktualizuje pozycje wszystkich aktywnych toastów w stacku.
  Wywoływane gdy toast znika - pozostałe tosty płynnie zajmują jego miejsce }
class procedure TToast.UpdateToastPositions;
var
  I, Offset: Integer;
  Toast: TToast;
  ParentControl: TWinControl;
begin
  if FActiveToasts.Count = 0 then
    Exit;

  for I := 0 to FActiveToasts.Count - 1 do
  begin
    Toast := FActiveToasts[I];

    if not Assigned(Toast.FPanel) or not Assigned(Toast.FPanel.Parent) then
      Continue;

    ParentControl := TWinControl(Toast.FPanel.Parent);

    // Oblicz offset na podstawie wcześniejszych toastów
    Offset := 0;
    case Toast.FSettings.Position of
      tpBottom:
        begin
          // Dla każdego wcześniejszego toastu dodaj jego wysokość + odstęp
          var J: Integer;
          for J := 0 to I - 1 do
          begin
            if Assigned(FActiveToasts[J].FPanel) then
              Inc(Offset, FActiveToasts[J].FPanel.Height + 10);
          end;

          // Aktualizuj docelową pozycję (ale tylko jeśli toast już wjechał)
          if Toast.FStep > 20 then
          begin
            Toast.FTargetY := ParentControl.ClientHeight - Toast.FPanel.Height - 20 - Offset;
            Toast.FPanel.Top := Toast.FTargetY;
          end;
        end;

      tpTop:
        begin
          // Dla tpTop tosty układają się od góry w dół
          var J: Integer;
          for J := 0 to I - 1 do
          begin
            if Assigned(FActiveToasts[J].FPanel) then
              Inc(Offset, FActiveToasts[J].FPanel.Height + 10);
          end;

          if Toast.FStep > 20 then
          begin
            Toast.FTargetY := 20 + Offset;
            Toast.FPanel.Top := Toast.FTargetY;
          end;
        end;

      tpCenter:
        begin
          // Dla center każdy toast ma swoją pozycję z offsetem
          var J: Integer;
          for J := 0 to I - 1 do
          begin
            if Assigned(FActiveToasts[J].FPanel) then
              Inc(Offset, FActiveToasts[J].FPanel.Height + 10);
          end;

          if Toast.FStep > 20 then
          begin
            Toast.FTargetY := (ParentControl.ClientHeight - Toast.FPanel.Height) div 2 - Offset;
            Toast.FPanel.Top := Toast.FTargetY;
          end;
        end;
    end;
  end;
end;

// ============================================================================
// METODY PRYWATNE - LOGIKA ANIMACJI
// ============================================================================

{ Oblicza pozycję startową i docelową toastu w zależności od ustawień i stacku.
  Uwzględnia pozycję innych aktywnych toastów aby uniknąć nakładania }
procedure TToast.CalculatePosition(Parent: TWinControl);
var
  I, Offset: Integer;
begin
  // Pozycja pozioma - zawsze wyśrodkowana
  FPanel.Left := (Parent.ClientWidth - FPanel.Width) div 2;

  // Oblicz offset na podstawie innych aktywnych toastów
  Offset := 0;
  for I := 0 to FActiveToasts.Count - 1 do
  begin
    if FActiveToasts[I] <> Self then
    begin
      // Sprawdź czy toast ma ten sam FOwner i Position
      if (FActiveToasts[I].FOwner = FOwner) and
         (FActiveToasts[I].FSettings.Position = FSettings.Position) and
         Assigned(FActiveToasts[I].FPanel) then
      begin
        Inc(Offset, FActiveToasts[I].FPanel.Height + 10); // 10px odstępu między toastami
      end;
    end;
  end;

  // Pozycja pionowa zależna od ustawień i offsetu od innych toastów
  case FSettings.Position of
    tpBottom:
      begin
        FStartY := Parent.ClientHeight;                     // Start: poniżej ekranu
        FTargetY := Parent.ClientHeight - FPanel.Height - 20 - Offset; // Cel: 20px od dołu + offset
      end;
    tpTop:
      begin
        FStartY := -FPanel.Height;                         // Start: powyżej ekranu
        FTargetY := 20 + Offset;                           // Cel: 20px od góry + offset
      end;
    tpCenter:
      begin
        FStartY := Parent.ClientHeight;                    // Start: poniżej ekranu
        FTargetY := (Parent.ClientHeight - FPanel.Height) div 2 - Offset; // Cel: środek + offset
      end;
  end;

  // Ustaw początkową pozycję
  FPanel.Top := FStartY;
end;

{ Główna pętla animacji - wywoływana przez timer co AnimationSpeed ms.
  Fazy animacji:
  1. FStep 0-20: Animacja wjazdu (AnimateEntrance)
  2. FStep 21-(TotalSteps-20): Czekanie (toast nieruchomy)
  3. FStep (TotalSteps-19)-TotalSteps: Animacja zjazdu (AnimateExit) }
procedure TToast.OnTimer(Sender: TObject);
var
  P: TWinControl;
  TotalSteps: Integer;
begin
  if FShouldFree then
    Exit;

  // Bezpieczeństwo - sprawdzamy czy komponenty jeszcze istnieją
  if not Assigned(FPanel) or not Assigned(FPanel.Parent) then
  begin
    if Assigned(FTimer) then
      FTimer.Enabled := False;
    FreeResources;
    Exit;
  end;

  P := TWinControl(FPanel.Parent);
  Inc(FStep);

  // Oblicz całkowitą liczbę kroków animacji
  TotalSteps := (FSettings.Duration div FSettings.AnimationSpeed) + 40;

  // FAZA 1: ANIMACJA WJAZDU (pierwsze 20 kroków)
  if FStep <= 20 then
  begin
    AnimateEntrance(P);
  end
  // FAZA 2: CZEKANIE (toast widoczny bez ruchu)
  else if FStep <= TotalSteps - 20 then
  begin
    // Toast pozostaje w miejscu - nic nie robimy
  end
  // FAZA 3: ANIMACJA ZJAZDU (ostatnie 20 kroków)
  else
  begin
    AnimateExit(P);

    // Sprawdzamy czy toast zjechał poza ekran
    case FSettings.Position of
      tpBottom:
        if FPanel.Top >= P.ClientHeight then FinishToast;
      tpTop:
        if FPanel.Top <= -FPanel.Height then FinishToast;
      tpCenter:
        if FPanel.Top >= P.ClientHeight then FinishToast;
    end;
  end;
end;

{ Animacja wjazdu toastu na ekran.
  Używa interpolacji liniowej do płynnego przejścia z FStartY do FTargetY. }
procedure TToast.AnimateEntrance(Parent: TWinControl);
var
  Progress: Double;
begin
  // Progress rośnie od 0 do 1 w ciągu 20 kroków
  Progress := FStep / 20;

  // Interpolacja liniowa: pozycja = start + (cel - start) * progress
  FPanel.Top := Round(FStartY + (FTargetY - FStartY) * Progress);
end;

{ Animacja zjazdu toastu z ekranu.
  Określa kierunek zjazdu w zależności od pozycji toastu. }
procedure TToast.AnimateExit(Parent: TWinControl);
var
  ExitStep: Integer;
  Progress: Double;
  ExitStartY, ExitTargetY: Integer;
begin
  // Numer kroku w fazie zjazdu (0-20)
  ExitStep := FStep - (FSettings.Duration div FSettings.AnimationSpeed + 20);
  Progress := ExitStep / 20;

  // Określamy kierunek zjazdu
  case FSettings.Position of
    tpBottom:
      begin
        ExitStartY := FTargetY;            // Start zjazdu: pozycja docelowa
        ExitTargetY := Parent.ClientHeight; // Koniec zjazdu: poniżej ekranu
      end;
    tpTop:
      begin
        ExitStartY := FTargetY;            // Start zjazdu: pozycja docelowa
        ExitTargetY := -FPanel.Height;     // Koniec zjazdu: powyżej ekranu
      end;
    tpCenter:
      begin
        ExitStartY := FTargetY;            // Start zjazdu: pozycja docelowa
        ExitTargetY := Parent.ClientHeight; // Koniec zjazdu: poniżej ekranu
      end;
  else
    // Domyślnie: zjazd w dół
    ExitStartY := FTargetY;
    ExitTargetY := Parent.ClientHeight;
  end;

  // Interpolacja liniowa dla zjazdu
  FPanel.Top := Round(ExitStartY + (ExitTargetY - ExitStartY) * Progress);
end;

{ Kończy animację i inicjuje proces zwalniania obiektu.
  Usuwa toast ze stacku i aktualizuje pozycje pozostałych toastów }
procedure TToast.FinishToast;
begin
  if Assigned(FTimer) then
    FTimer.Enabled := False;

  FShouldFree := True;

  // Usuń ze stacku
  FActiveToasts.Remove(Self);

  // Aktualizuj pozycje pozostałych toastów
  UpdateToastPositions;

  // Bezpieczne zwolnienie przez kolejkę wiadomości
  PostMessage(Application.MainForm.Handle, WM_NULL, 0, 0);
  FreeResources;
end;

{ Bezpiecznie zwalnia wszystkie zasoby (timer i panel). }
procedure TToast.FreeResources;
begin
  // Zatrzymaj i zwolnij timer
  if Assigned(FTimer) then
  begin
    FTimer.Enabled := False;
    FreeAndNil(FTimer);
  end;

  // Ukryj i zwolnij panel
  if Assigned(FPanel) then
  begin
    FPanel.Visible := False;
    FreeAndNil(FPanel);
  end;
end;

// ============================================================================
// INICJALIZACJA GLOBALNA
// ============================================================================

initialization
  InitializeDefaultSettings;

end.

unit ToastExamples;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, ToastNotification;

type
  TMainForm = class(TForm)
    btnDone: TButton;
    lblTest: TLabel;
    btnError: TButton;
    btnWarning: TButton;
    btnInfo: TButton;
    btnCustom: TButton;
    btnMultiple: TButton;
    btnPositions: TButton;
    btnLargeToast: TButton;
    procedure btnDoneClick(Sender: TObject);
    procedure btnErrorClick(Sender: TObject);
    procedure btnWarningClick(Sender: TObject);
    procedure btnInfoClick(Sender: TObject);
    procedure btnCustomClick(Sender: TObject);
    procedure btnMultipleClick(Sender: TObject);
    procedure btnPositionsClick(Sender: TObject);
    procedure btnLargeToastClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  MainForm: TMainForm;

implementation

{$R *.dfm}

// ============================================================================
// Toast z niestandardowymi ustawieniami
// ============================================================================
procedure TMainForm.btnCustomClick(Sender: TObject);
begin
  // Tworzymy własne ustawienia od zera
  var CustomSettings := TToast.DefaultSettings; // Zaczynamy od domyślnych

  // Modyfikujemy to co chcemy
  CustomSettings.BackgroundColor := $00FF00FF; // Fioletowy (Magenta)
  CustomSettings.TextColor := clWhite;         // Bialy tekst
  CustomSettings.FontSize := 12;               // Większa czcionka
  CustomSettings.Width := 400;                 // Szerszy toast
  CustomSettings.Height := 60;                 // Wyższy toast
  CustomSettings.Duration := 5000;             // 5 sekund (zamiast 2)
  CustomSettings.Position := tpTop;            // Na górze ekranu

  TToast.Show(Self,
    'Toast z niestandardowymi ustawieniami!',
    CustomSettings
  );
end;

// ============================================================================
// Toast z komunikatem sukcesu (zielony)
// ============================================================================
procedure TMainForm.btnDoneClick(Sender: TObject);
begin
  TToast.Show(Self,
  'Operacja wykonana pomyślnie!',
  TToast.SuccessSettings
  );
end;
// ============================================================================
// Toast z komunikatem błędu (czerwony)
// ============================================================================
procedure TMainForm.btnErrorClick(Sender: TObject);
begin
  TToast.Show(Self,
    'Wystąpił błąd podczas wykonywania operacji!',
    TToast.ErrorSettings
  );
end;

// ============================================================================
// Toast informacyjny (niebieski)
// ============================================================================
procedure TMainForm.btnInfoClick(Sender: TObject);
begin
  TToast.Show(Self,
    'To jest informacja dla użytkownika.',
    TToast.InfoSettings
  );
end;

// ============================================================================
// Ustawiamy dłuższy czas dla Toast'a
// ===========================================================================
procedure TMainForm.btnLargeToastClick(Sender: TObject);
begin
  var Settings := TToast.InfoSettings;
  Settings.Duration := 8000; // Ostrzeżenie pokazujemy dłużej (8 sekundy)

  TToast.Show(Self,
    'Toast z 8 sekundowym wyświetleniem',
    Settings
  );
end;


// ============================================================================
// Wiele toastów jednocześnie (stack)
// ============================================================================
procedure TMainForm.btnMultipleClick(Sender: TObject);
begin
  // Tosty pojawią się jeden nad drugim
  TToast.Show(Self, 'Pierwszy toast', TToast.InfoSettings);
  TToast.Show(Self, 'Drugi toast', TToast.SuccessSettings);
  TToast.Show(Self, 'Trzeci toast', TToast.WarningSettings);
end;

// ============================================================================
// Różne pozycje toastów
// ============================================================================
procedure TMainForm.btnPositionsClick(Sender: TObject);
var
  TopSettings, CenterSettings, BottomSettings: TToastSettings;
begin
  // Toast na górze
  TopSettings := TToast.InfoSettings;
  TopSettings.Position := tpTop;
  TToast.Show(Self, 'Toast na górze ekranu', TopSettings);

  // Toast w środku
  CenterSettings := TToast.WarningSettings;
  CenterSettings.Position := tpCenter;
  TToast.Show(Self, 'Toast w środku ekranu', CenterSettings);

  // Toast na dole (domyślna pozycja)
  BottomSettings := TToast.SuccessSettings;
  BottomSettings.Position := tpBottom;
  TToast.Show(Self, 'Toast na dole ekranu', BottomSettings);
end;

// ============================================================================
// Toast z komunikatem błędu (czerwony)
// ============================================================================
procedure TMainForm.btnWarningClick(Sender: TObject);
begin
  TToast.Show(Self,
    'Uwaga! To jest ostrzeżenie.',
    TToast.WarningSettings
  );
end;

procedure TMainForm.FormCreate(Sender: TObject);
begin
  Self.Position := poScreenCenter;
  Self.Color := clWhite;
end;

end.

// Inline Variable Declarations (Variable Line)
// Możliwość deklarowania zmiennych bezpośrednio w miejscu ich użycia via C++ czy Python
procedure Example;
begin
  ShowMessage('Start');
  
  var MyNumber := 42;     // deklaracja w środku
  ShowMessage(MyNumber.ToString);
  
  var MyText := 'Hello';  // kolejna deklaracja dalej
  ShowMessage(MyText);
  
  var Result := MyNumber * 2;   // Bezpośrednio przed użyciem:
  ShowMessage('Wynik: ' + Result.ToString);
end;

procedure Example2;
begin
  if SomeCondition then
  begin
    var TempValue := GetSomeValue();
    ShowMessage(TempValue);
    // TempValue istnieje tylko w tym bloku if
  end;
  
  for var I := 1 to 10 do
  begin
    var Square := I * I;
    ShowMessage(Square.ToString);
  end;
end;

// Type Inference (wnioskowanie typów)
// Kompilator sam określa typ na podstawie przypisanej wartości:
var 
  Count := 10;           // Integer
  Price := 19.99;        // Extended/Double
  Name := 'Jan';         // String
  IsActive := True;      // Boolean

// Managed Records (rekordy zarządzane)
// Używamy managed records z konstruktorami i metodami
type
  TPerson = record
    Name: string;
    Age: Integer;
    class operator Initialize(out Dest: TPerson);
    constructor Create(AName: string; AAge: Integer);
  end;

var Person := TPerson.Create('Anna', 25);

// Custom Managed Records
// Kontrolujemy inicjalizację i finalizację
type
  TResource = record
  private
    FData: string;
  public
    class operator Initialize(out Dest: TResource);
    class operator Finalize(var Dest: TResource);
  end;

// Mi się to podoba, kod wygląda czytelniej, zmienne są deklarowane blisko miejsca użycia.

NodeHead := @Segment^.Data;
NodeTail := Pointer(NodeHead) + (AList^.NodeNumSegment - 1) * AList^.SizeNode;

while NodeHead < NodeTail do
begin
  NodeHead^.Segment := Segment;
  NodeHead^.Next    := Pointer(NodeHead) + AList^.SizeNode;

  Pointer(NodeHead) += AList^.SizeNode;
end;

// Get a pointer to the first and last node in the segment data block.
NodeHead := @Segment^.Data;
NodeTail := Pointer(NodeHead) + (AList^.NodeNumSegment - 1) * AList^.SizeNode;

// For each node in the node's data memory block, initialize a pointer to the segment it belongs to, as well as a link to
// the next node in that segment. In this way, a singly-linked list of all segment nodes is created, available in the bank.
while NodeHead < NodeTail do
begin
  NodeHead^.Segment := Segment;
  NodeHead^.Next    := Pointer(NodeHead) + AList^.SizeNode;

  Pointer(NodeHead) += AList^.SizeNode;
end;

/**
 * @file UserManager.h
 * @brief Zarządzanie kontami użytkowników w systemie
 * @author Jan Kowalski
 * @date 2026-02-11
 * @version 1.0
 */

#ifndef USER_MANAGER_H
#define USER_MANAGER_H

#include <string>
#include <memory>

/**
 * @class User
 * @brief Reprezentuje pojedynczego użytkownika w systemie
 * 
 * Klasa zawiera podstawowe informacje o użytkowniku oraz
 * metody do zarządzania jego kontem.
 */
class User {
private:
    int userId_;           ///< Unikalny identyfikator użytkownika
    std::string username_; ///< Nazwa użytkownika (3-50 znaków)
    bool isActive_;        ///< Status aktywności konta

public:
    /**
     * @brief Konstruktor tworzący nowego użytkownika
     * @param username Nazwa użytkownika (musi mieć 3-50 znaków)
     * @throw std::invalid_argument gdy nazwa jest nieprawidłowa
     */
    explicit User(const std::string& username);
    
    /**
     * @brief Aktywuje konto użytkownika i wysyła email powitalny
     * @return true jeśli aktywacja się powiodła, false w przeciwnym razie
     * @note Metoda loguje wszystkie próby aktywacji
     */
    bool activate();
    
    // Gettery
    int getUserId() const { return userId_; }
    const std::string& getUsername() const { return username_; }
    bool isActive() const { return isActive_; }
};

// Implementacja

User::User(const std::string& username) 
    : userId_(0), isActive_(false) {
    
    // Walidacja długości nazwy użytkownika
    if (username.length() < 3 || username.length() > 50) {
        throw std::invalid_argument("Nazwa musi mieć 3-50 znaków");
    }
    
    username_ = username;
}

bool User::activate() {
    // TODO: Dodać logowanie do pliku audytu
    // FIXME: Obsłużyć przypadek gdy email nie może być wysłany
    
    try {
        isActive_ = true;
        bool emailSent = sendWelcomeEmail(username_);
        
        /* HACK: Tymczasowe rozwiązanie
         * Należy przepisać po wdrożeniu nowego email API
         * planowane na Q2 2027
         */
        if (!emailSent) {
            logWarning("Email nie został wysłany do: " + username_);
        }
        
        return true;
        
    } catch (const std::exception& e) {
        // Wycofanie zmian w przypadku błędu
        isActive_ = false;
        throw;
    }
}

#endif // USER_MANAGER_H

// ToastNotification.pas
// Fixed and enhanced version of a toast notification system for Delphi VCL applications.
// CODE BY FPERSON (2026-02-14)

unit ToastNotification;

interface

uses
  Winapi.Windows, Winapi.Messages, Vcl.ExtCtrls, Vcl.Controls, Vcl.Forms,
  Vcl.Graphics, System.Classes, System.SysUtils, System.Math,
  Vcl.StdCtrls, System.Generics.Collections;

type
  TToastPosition = (tpBottom, tpTop, tpCenter);

 //Settings for a single toast
  TToastSettings = record
    BackgroundColor: TColor;
    TextColor: TColor;
    FontSize: Integer;
    FontStyle: TFontStyles;
    Width: Integer;
    Height: Integer;
    Duration: Integer;
    AnimationSpeed: Integer;
    Position: TToastPosition;
  end;

  TToast = class
  private
    FPanel: TPanel;
    FTimer: TTimer;
    FStep: Integer;
    FShouldFree: Boolean;
    FSettings: TToastSettings;
    FTargetY: Integer;
    FStartY: Integer;
    FOwner: TComponent;

    class var FActiveToasts: TObjectList<TToast>;
    class var FMeasureBitmap: TBitmap;

    procedure OnTimer(Sender: TObject);
    procedure AnimateEntrance(Parent: TWinControl);
    procedure AnimateExit(Parent: TWinControl);
    procedure FreeResources;
    procedure CalculatePosition(Parent: TWinControl);
    procedure FinishToast;

    class function CalculateStackOffset(Index: Integer; Owner: TComponent;
      Pos: TToastPosition): Integer;
    class procedure UpdateToastPositions;

  public
    constructor Create(AOwner: TComponent; const Msg: string); overload;
    constructor Create(AOwner: TComponent; const Msg: string;
      const Settings: TToastSettings); overload;
    destructor Destroy; override;

    class procedure Show(AOwner: TComponent; const Msg: string); overload;
    class procedure Show(AOwner: TComponent; const Msg: string;
      const Settings: TToastSettings); overload;

    class function DefaultSettings: TToastSettings;
    class function SuccessSettings: TToastSettings;
    class function ErrorSettings: TToastSettings;
    class function WarningSettings: TToastSettings;
    class function InfoSettings: TToastSettings;

    class constructor Create;
    class destructor Destroy;
  end;

var
  DefaultToastSettings: TToastSettings;

implementation

// constants for animation and layout
const
  TOAST_ANIMATION_STEPS = 20;
  TOAST_SPACING = 10;
  TOAST_MARGIN_VERTICAL = 20;
  TOAST_TEXT_PADDING = 40;
  TOAST_MAX_WIDTH = 600;
  TOAST_MIN_DURATION = 2000;
  TOAST_MAX_DURATION = 6000;
  TOAST_MS_PER_CHAR = 50;

{ TToast }

class constructor TToast.Create;
begin
  FActiveToasts := TObjectList<TToast>.Create(False);
  FMeasureBitmap := TBitmap.Create;
end;

class destructor TToast.Destroy;
begin
  FActiveToasts.Free;
  FMeasureBitmap.Free;
end;

procedure InitializeDefaultSettings;
begin
  with DefaultToastSettings do
  begin
    BackgroundColor := $00333333;
    TextColor := clWhite;
    FontSize := 10;
    FontStyle := [fsBold];
    Width := 300;
    Height := 45;
    Duration := 2000;
    AnimationSpeed := 15;
    Position := tpBottom;
  end;
end;

class function TToast.DefaultSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
end;

class function TToast.SuccessSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
  Result.BackgroundColor := $004CAF50;
  Result.TextColor := clWhite;
end;

class function TToast.ErrorSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
  Result.BackgroundColor := $00F44336;
  Result.TextColor := clWhite;
end;

class function TToast.WarningSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
  Result.BackgroundColor := $00FF9800;
  Result.TextColor := clBlack;
end;

class function TToast.InfoSettings: TToastSettings;
begin
  Result := DefaultToastSettings;
  Result.BackgroundColor := $002196F3;
  Result.TextColor := clWhite;
end;

class procedure TToast.Show(AOwner: TComponent; const Msg: string);
begin
  TToast.Create(AOwner, Msg);
end;

class procedure TToast.Show(AOwner: TComponent; const Msg: string;
  const Settings: TToastSettings);
begin
  TToast.Create(AOwner, Msg, Settings);
end;

constructor TToast.Create(AOwner: TComponent; const Msg: string);
begin
  Create(AOwner, Msg, DefaultToastSettings);
end;

constructor TToast.Create(AOwner: TComponent; const Msg: string;
  const Settings: TToastSettings);
var
  ParentControl: TWinControl;
begin
  inherited Create;

  FSettings := Settings;
  FShouldFree := False;
  FOwner := AOwner;

  if AOwner is TWinControl then
    ParentControl := TWinControl(AOwner)
  else
    ParentControl := Application.MainForm;

  FPanel := TPanel.Create(nil);
  try
    FPanel.Parent := ParentControl;
    FPanel.Caption := '';
    FPanel.Color := FSettings.BackgroundColor;
    FPanel.Font.Color := FSettings.TextColor;
    FPanel.Font.Size := FSettings.FontSize;
    FPanel.Font.Style := FSettings.FontStyle;
    FPanel.BevelOuter := bvNone;
    FPanel.StyleElements := [];

    // custom width based on text
    FMeasureBitmap.Canvas.Font.Assign(FPanel.Font);
    var TextWidth := FMeasureBitmap.Canvas.TextWidth(Msg) + TOAST_TEXT_PADDING;
    FPanel.Width := Max(FSettings.Width, Min(TOAST_MAX_WIDTH, TextWidth));

    FPanel.Height := FSettings.Height;

    //  create label for text
    var Lbl := TLabel.Create(FPanel);
    Lbl.Align := alClient;
    Lbl.Alignment := taCenter;
    Lbl.Layout := tlCenter;
    Lbl.WordWrap := True;
    Lbl.AutoSize := False;
    Lbl.Caption := Msg;
    Lbl.Font.Assign(FPanel.Font);
    Lbl.Transparent := True;
    Lbl.StyleElements := [];

    // calculate needed height for text
    FMeasureBitmap.Canvas.Font.Assign(Lbl.Font);
    var TextRect := Rect(0, 0, FPanel.Width - TOAST_TEXT_PADDING, 0);
    DrawText(FMeasureBitmap.Canvas.Handle, PChar(Msg), Length(Msg), TextRect,
             DT_CALCRECT or DT_WORDBREAK or DT_CENTER);
    var NeededHeight := TextRect.Height + 20;
    if NeededHeight > FSettings.Height then
      FPanel.Height := NeededHeight;

    Lbl.Parent := FPanel;

    // Adjust duration based on text length
    var CharCount := Length(Msg);
    FSettings.Duration := Max(TOAST_MIN_DURATION,
      Min(TOAST_MAX_DURATION, CharCount * TOAST_MS_PER_CHAR));

    FPanel.DoubleBuffered := True;
    FPanel.ParentBackground := False;
    FPanel.ParentDoubleBuffered := False;

    FActiveToasts.Add(Self);
    CalculatePosition(ParentControl);

    FPanel.Visible := True;
    FPanel.BringToFront;

    FStep := 0;
    FTimer := TTimer.Create(nil);
    FTimer.Interval := FSettings.AnimationSpeed;
    FTimer.OnTimer := OnTimer;
    FTimer.Enabled := True;
  except
    FActiveToasts.Remove(Self);
    FreeResources;
    raise;
  end;
end;

destructor TToast.Destroy;
begin
  FreeResources;
  inherited;
end;

// Helper function to calculate vertical offset for stacking toasts
class function TToast.CalculateStackOffset(Index: Integer; Owner: TComponent;
  Pos: TToastPosition): Integer;
var
  J: Integer;
begin
  Result := 0;
  for J := 0 to Index - 1 do
    if Assigned(FActiveToasts[J].FPanel) and
       (FActiveToasts[J].FOwner = Owner) and
       (FActiveToasts[J].FSettings.Position = Pos) then
      Inc(Result, FActiveToasts[J].FPanel.Height + TOAST_SPACING);
end;

class procedure TToast.UpdateToastPositions;
var
  I, Offset: Integer;
  Toast: TToast;
  ParentControl: TWinControl;
begin
  if FActiveToasts.Count = 0 then
    Exit;

  for I := 0 to FActiveToasts.Count - 1 do
  begin
    Toast := FActiveToasts[I];
    if not Assigned(Toast.FPanel) or not Assigned(Toast.FPanel.Parent) then
      Continue;

    ParentControl := TWinControl(Toast.FPanel.Parent);

    if Toast.FStep <= TOAST_ANIMATION_STEPS then
      Continue; // no need to adjust position during entrance animation

    Offset := CalculateStackOffset(I, Toast.FOwner, Toast.FSettings.Position);

    case Toast.FSettings.Position of
      tpBottom:
        Toast.FTargetY := ParentControl.ClientHeight - Toast.FPanel.Height -
          TOAST_MARGIN_VERTICAL - Offset;
      tpTop:
        Toast.FTargetY := TOAST_MARGIN_VERTICAL + Offset;
      tpCenter:
        Toast.FTargetY := (ParentControl.ClientHeight - Toast.FPanel.Height) div 2 - Offset;
    end;

    Toast.FPanel.Top := Toast.FTargetY;
  end;
end;

procedure TToast.CalculatePosition(Parent: TWinControl);
var
  Offset: Integer;
begin
  FPanel.Left := (Parent.ClientWidth - FPanel.Width) div 2;

  Offset := 0;
  for var I := 0 to FActiveToasts.Count - 1 do
  begin
    if (FActiveToasts[I] <> Self) and
       (FActiveToasts[I].FOwner = FOwner) and
       (FActiveToasts[I].FSettings.Position = FSettings.Position) and
       Assigned(FActiveToasts[I].FPanel) then
      Inc(Offset, FActiveToasts[I].FPanel.Height + TOAST_SPACING);
  end;

  case FSettings.Position of
    tpBottom:
      begin
        FStartY := Parent.ClientHeight;
        FTargetY := Parent.ClientHeight - FPanel.Height - TOAST_MARGIN_VERTICAL - Offset;
      end;
    tpTop:
      begin
        FStartY := -FPanel.Height;
        FTargetY := TOAST_MARGIN_VERTICAL + Offset;
      end;
    tpCenter:
      begin
        FStartY := Parent.ClientHeight;
        FTargetY := (Parent.ClientHeight - FPanel.Height) div 2 - Offset;
      end;
  end;

  FPanel.Top := FStartY;
end;

procedure TToast.OnTimer(Sender: TObject);
var
  TotalSteps: Integer;
begin
  if FShouldFree or not Assigned(FPanel) or not Assigned(FPanel.Parent) then
  begin
    if Assigned(FTimer) then
      FTimer.Enabled := False;
    FreeResources;
    Exit;
  end;

  Inc(FStep);
  TotalSteps := (FSettings.Duration div FSettings.AnimationSpeed) +
    (TOAST_ANIMATION_STEPS * 2);

  if FStep <= TOAST_ANIMATION_STEPS then
    AnimateEntrance(TWinControl(FPanel.Parent))
  else if FStep <= TotalSteps - TOAST_ANIMATION_STEPS then
    // waiting period - do nothing
  else
  begin
    AnimateExit(TWinControl(FPanel.Parent));

    case FSettings.Position of
      tpBottom:
        if FPanel.Top >= TWinControl(FPanel.Parent).ClientHeight then
          FinishToast;
      tpTop:
        if FPanel.Top <= -FPanel.Height then
          FinishToast;
      tpCenter:
        if FPanel.Top >= TWinControl(FPanel.Parent).ClientHeight then
          FinishToast;
    end;
  end;
end;

procedure TToast.AnimateEntrance(Parent: TWinControl);
begin
  var Progress := FStep / TOAST_ANIMATION_STEPS;
  FPanel.Top := Round(FStartY + (FTargetY - FStartY) * Progress);
end;

procedure TToast.AnimateExit(Parent: TWinControl);
var
  ExitStep: Integer;
  ExitTargetY: Integer;
begin
  ExitStep := FStep - (FSettings.Duration div FSettings.AnimationSpeed +
    TOAST_ANIMATION_STEPS);
  var Progress := ExitStep / TOAST_ANIMATION_STEPS;

  if FSettings.Position = tpTop then
    ExitTargetY := -FPanel.Height
  else
    ExitTargetY := Parent.ClientHeight;

  FPanel.Top := Round(FTargetY + (ExitTargetY - FTargetY) * Progress);
end;

procedure TToast.FinishToast;
begin
  if Assigned(FTimer) then
    FTimer.Enabled := False;

  FShouldFree := True;
  FActiveToasts.Remove(Self);
  UpdateToastPositions;

  if Assigned(Application) and Assigned(Application.MainForm) then
    PostMessage(Application.MainForm.Handle, WM_NULL, 0, 0);
  FreeResources;
end;

procedure TToast.FreeResources;
begin
  if Assigned(FTimer) then
  begin
    FTimer.Enabled := False;
    FreeAndNil(FTimer);
  end;

  if Assigned(FPanel) then
  begin
    FPanel.Visible := False;
    FreeAndNil(FPanel);
  end;
end;

initialization
  // Set default settings on initialization
  InitializeDefaultSettings;

end.