README

CWStudio Components Library

Nowoczesne komponenty VCL w stylu Windows 11 / WinUI 3 dla Delphi

Modern Windows 11 / WinUI 3 styled VCL components for Delphi

🇵🇱 Wersja polska

CWStudio to zestaw nowoczesnych, wysokiej jakości komponentów VCL dla środowiska Delphi, zaprojektowanych w celu nadania aplikacjom desktopowym wyglądu znanego z systemu Windows 11 / WinUI 3. Komponenty bazują na oficjalnych tokenach kolorystycznych Fluent UI v9 i wspierają motyw jasny oraz ciemny — z automatyczną detekcją ustawień Windows.

✨ Kluczowe cechy

• Wygląd Windows 11 / WinUI 3 — wszystkie komponenty są stylizowane spójnie i zgodnie z najnowszymi wytycznymi Microsoft.
• Pełna obsługa motywów Light / Dark z automatyczną synchronizacją z motywem systemowym.
• Renderowanie GDI+ — gładkie krawędzie, antyaliasing, zaokrąglone narożniki.
• Wydajność — buforowanie podwójne, brak migotania, płynne animacje.
• DPI-aware — komponenty poprawnie skalują się na monitorach HiDPI.
• Open Source — całkowicie darmowe do użytku w projektach komercyjnych i niekomercyjnych.

📦 Komponenty

Kontenery i panele

Przyciski

🎯 Obsługa akcji (Action) — TCWSButton, TCWSCheckBox, TCWSRadioButton i TCWSSwitch mają właściwość Action, która wiąże je z TAction z TActionList — dokładnie jak standardowe kontrolki VCL. Akcja steruje Caption, Enabled, Visible, Hint (oraz Checked w kontrolkach przełączanych), a kliknięcie wykonuje OnExecute. Ręczne ustawienie właściwości odłącza ją od akcji (semantyka linkowania po wartości, jak w VCL).

Pola wprowadzania danych

Listy i siatki

Wskaźniki postępu

Menu

Etykiety

Kształty

Komponenty pomocnicze

Moduły kolorów Fluent

🌗 Motyw podąża za systemem — kolory motywu (jasny / ciemny) zmieniają się automatycznie w zależności od ustawień systemu Windows. Komponenty nasłuchują zmiany motywu Windows (np. przełączenie Ustawienia → Personalizacja → Kolory → Tryb) i przemalowują się w locie, a każdy zarejestrowany handler dostaje powiadomienie, dzięki czemu cała aplikacja pozostaje spójna bez restartu.

Przykład — moduł kolorów (CWSFluentColorsMulti)

uses
  CWSFluentColorsMulti;

procedure TForm1.FormCreate(Sender: TObject);
begin
  RegisterThemeChange(HandleThemeChange);
  FluentApplySystemTheme;            // automatycznie z rejestru Windows
  HandleThemeChange;                 // pierwsze pomalowanie
end;

procedure TForm1.HandleThemeChange;
begin
  Color           := flNeutralBackground1;
  Label1.Font.Color := flNeutralForeground1;
  Invalidate;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  UnregisterThemeChange(HandleThemeChange);
end;

Przykład — motyw zalogowanego użytkownika (CWSInteractiveUserTheme)

Standardowe wykrywanie motywu czyta HKCU, więc aplikacja uruchomiona na koncie NT AUTHORITY\SYSTEM (np. przez ServiceUI.exe z Intune / MDT) dostaje ustawienia konta usługi, a nie zalogowanego użytkownika — i zawsze pokazuje motyw jasny. Ten unit ustala sesję interaktywną, jej SID, i czyta AppsUseLightTheme wprost z HKEY_USERS\<SID>.

uses
  CWSFluentColorsMulti, CWSInteractiveUserTheme;

procedure TForm1.FormCreate(Sender: TObject);
begin
  RegisterThemeChange(ApplyTheme);   // tylko rejestracja — okno nie ma jeszcze uchwytu
end;

procedure TForm1.FormShow(Sender: TObject);
begin
  StartFollowingUserTheme;           // ustawia motyw i startuje obserwację zmian
  ApplyTheme;                        // pierwsze pomalowanie — jawnie, nie licz na callback
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  StopFollowingUserTheme;
  UnregisterThemeChange(ApplyTheme);
end;

⚠️ Wołaj StartFollowingUserTheme w FormShow, nie w FormCreate — w FormCreate zmienna globalna formularza jest jeszcze nil, a okno nie ma uchwytu.

Diagnostyka: ustaw ThemeLogEnabled := True (albo uruchom aplikację z przełącznikiem /themelog), aby zapisać przebieg wykrywania do %TEMP%\CWSTheme.log (pod kontem SYSTEM: C:\Windows\Temp). ThemeDiagnostics zwraca ten sam stan jako gotowy tekst — SID procesu, numery sesji, SID użytkownika i wykryty motyw.

🎨 Wzornik kolorów — CWSFluentColors_palette.html

W repozytorium znajduje się interaktywny wzornik kolorów CWSFluentColors_palette.html — otwórz go w przeglądarce, aby przejrzeć wszystkie tokeny Fluent UI v9 z CWSFluentColors.pas (warianty Light i Dark). Pozwala on:

• filtrować tokeny po nazwie (np. Brand, Background, Hover),
• podejrzeć paletę na jasnym i ciemnym tle (przełącznik Light / Dark),
• kliknięciem próbki skopiować kolor jako HEX (#0f6cbd) lub Delphi TColor ($00BD6C0F) — format wybiera przełącznik Copy as, który zmienia też wartości wyświetlane na próbkach; prawy klik zawsze kopiuje wartość Delphi,
• kliknięciem nazwy skopiować nazwę tokena do schowka.

Dzięki temu łatwo dobrać i dopasować kolory ustawiane we właściwościach komponentów (np. BorderColor, CellHighlightColor, BckHoverColor, FillColor).

🔧 Wymagania systemowe

• Embarcadero Delphi / RAD Studio z frameworkiem VCL. Biblioteka powstała i jest rozwijana w RAD Studio 13.1 Florence (kompilator 37.0); zalecane RAD Studio 11 Alexandria lub nowsze.
• Platformy docelowe: Win32 oraz Win64.
• System operacyjny:
  • Windows 10 lub nowszy do uruchomienia aplikacji (TCWSDimOverlay korzysta z okien warstwowych WS_EX_LAYERED oraz API DWM).
  • Windows 11 (build 22000) lub nowszy dla pełnego wyglądu Windows 11 — komponent TCWSDimOverlay (i inne warstwowe okna, np. cienie TCWSPopupMenu) używa DWMWA_WINDOW_CORNER_PREFERENCE do rysowania zaokrąglonych narożników. Na starszych systemach komponenty działają poprawnie, lecz narożniki pozostają proste (płynna degradacja).
• Brak wymaganych zależności firm trzecich — pakiety linkują się wyłącznie ze standardowymi rtl i vcl.
• Ikony — komponenty z ikonami (np. TCWSButton, TCWSMenuButton, TCWSLabelTrend) przyjmują dowolny standardowy TCustomImageList (właściwości Images / ImageIndex) lub glif z fontu ikon. Nie są potrzebne żadne dodatkowe biblioteki.

🚀 Instalacja

Biblioteka jest podzielona na dwa pakiety. Zbudowano w RAD Studio 13.1 Florence (kompilator 37.0).

📥 Instalacja przez GetIt (zalecana)

1. Pobierz plik CWStudioComponents-github.json z najnowszego wydania.
2. W RAD Studio: Tools → GetIt Package Manager → Load Local Package i wskaż pobrany plik (wymaga aktywnej subskrypcji Update Subscription).
3. Zaakceptuj licencję. GetIt sam pobierze paczkę z GitHuba, zbuduje oba pakiety dla Win32 i Win64, doda ścieżki do Library path / Browsing path i zarejestruje pakiet projektowy w IDE 32- i 64-bitowym.
4. Zrestartuj IDE, gdy GetIt o to poprosi.

Paczka trafia do $(BDSCatalogRepository)\CWStudio-Components-Library\<wersja>. Szczegóły: GetIt/README.md.

Jeśli wcześniej instalowałeś bibliotekę ręcznie, najpierw usuń stare wpisy z Library path oraz stare pliki CWStudio_Components*.bpl z $(BDSCOMMONDIR)\Bpl i $(BDSCOMMONDIR)\Bpl\Win64.

🔨 Instalacja ręczna ze źródeł

1. Zbuduj pakiety (runtime przed design-time, dla obu platform)

1. Otwórz grupę projektów CWStudio_Components.groupproj w RAD Studio.

2. Wybierz platformę Win32, następnie:

   • prawy klik CWStudio_ComponentsRT → Build,
   • prawy klik CWStudio_ComponentsDT → Build.

3. Przełącz platformę na Win64 i powtórz oba Build (runtime będzie redystrybuowany także dla aplikacji 64-bit).

   Alternatywnie z linii poleceń (po rsvars.bat):

   batCopy

   msbuild CWStudio_Components.groupproj /t:Build /p:Config=Release /p:Platform=Win32
   msbuild CWStudio_Components.groupproj /t:Build /p:Config=Release /p:Platform=Win64

2. Zainstaluj pakiet projektowy

Prawy klik CWStudio_ComponentsDT → Install. Wtedy:

• komponenty pojawią się na palecie w zakładkach CWStudio_Panels / _Buttons / _Edits / _ProgressBars / _Menus / _ScrollBoxes / _Forms / _ListBoxes / _Grids / _Labels.

3. Dodaj ścieżki do biblioteki

Aby Twoje aplikacje kompilowały się z komponentami, w Tools → Options → Language → Delphi → Library (dla każdej platformy: Win32 i Win64) dodaj do Library path katalog z plikami .dcu (folder ze źródłami lub .\Win32\Release / .\Win64\Release). Folder źródeł warto dodać też do Browsing path (debugowanie do kodu komponentów).

🧩 Użycie w aplikacji i redystrybucja

• Bez pakietów runtime (domyślnie — Link with runtime packages = false): komponenty są wkompilowane statycznie w .exe. Nie trzeba nic dołączać.
• Z pakietami runtime: dodaj CWStudio_ComponentsRT do Runtime Packages projektu i wraz z aplikacją dystrybuuj CWStudio_ComponentsRT.bpl (Win32 lub Win64) oraz .bpl zależności. Pakiet design-time nie jest potrzebny użytkownikowi końcowemu.

🛠️ Rozwiązywanie problemów

• F2039: Could not create output file ...bpl — pakiet jest aktualnie załadowany w IDE. Odinstaluj go (Component → Install Packages) lub zamknij RAD Studio przed budowaniem z linii poleceń.
• E2466: Never-build package requires always-build package — pakiety CWStudio używają {$IMPLICITBUILD ON}. Nie ustawiaj pakietu design-time na {$IMPLICITBUILD OFF}.

🖥️ Aplikacja demo

W folderze CWStudio_demo znajduje się przykładowa aplikacja VCL (demo.dproj) pokazująca komponenty w działaniu — przyciski, pola edycji, panele, siatki i listy, wskaźniki postępu, scrollboxy, menu systemowe, warstwę przyciemniającą z dialogiem oraz przełączanie motywu jasny / ciemny przez CWSFluentColorsMulti. Menu boczne zbudowane jest z TCWSStoreButton, a każda strona to osobna forma osadzana w obszarze treści.

Wymagania demo:

• zainstalowane pakiety CWStudio (patrz 🚀 Instalacja),
• SVGIconImageList — ikony w formularzach demo (TSVGIconImageList). Same komponenty CWStudio tej biblioteki nie wymagają.

Od wersji 1.9.25 demo nie zależy od komponentów ErrorSoft (EsVclComponents) — TEsShape w oknie głównym zastąpił TCWSSettingsPanel, a nieużywane moduły ES.* zostały usunięte z uses.

Otwórz CWStudio_demo\demo.dproj, wybierz platformę Win32 lub Win64 i uruchom (F9).

⚖️ Wymagane przypisanie autorstwa

Używając tych komponentów, proszę o umieszczenie odpowiedniej informacji w swojej aplikacji (np. w oknie „O programie"):

„Ta aplikacja wykorzystuje komponenty CWStudio autorstwa Czesława Włudarczyka"

🗓️ Co nowego

Najnowsza wersja — 1.9.37:

• Poprawka TCWSMemo: ReadOnly = True nie blokuje już właściwości kolorów tła. Dla pola tylko do odczytu kolor był zapisany na sztywno ($F5F5F5), więc BackgroundColor, BackgroundHoverColor i BackgroundFocusColor nie miały żadnego wpływu. Teraz o wyglądzie stanu read-only decyduje nowa właściwość ReadOnlyColor (domyślnie clNone): przy clNone działa normalny łańcuch tło / hover / focus — tak samo jak w TCWSEdit, a ustawienie konkretnego koloru (np. $F5F5F5) przywraca poprzedni wyszarzony wygląd.
• Poprawka TCWSMemo: przełączenie ReadOnly w czasie działania programu odświeża też obszar tekstu — SetReadOnly odmalowywał tylko ramkę rysowaną przez kontrolkę, zostawiając kolor wewnętrznego memo z poprzedniego stanu.

Wersja 1.9.36:

• Zmiana TCWSStringGrid: przewijanie i wielkość kciuków działają tak samo jak w TCWSDBGrid — na pasku pionowym i poziomym. Kciuk jest proporcjonalny do widocznej części zawartości (minimum 20 px przy 96 DPI), więc maleje po dodaniu wierszy/kolumn i rośnie po ich usunięciu. Przewijanie liczone jest w pikselach, dzięki czemu wiersze i kolumny o różnych rozmiarach nie powodują nierównego ruchu kciuka, a kciuk dochodzi do końca toru dokładnie przy ostatnim wierszu/kolumnie. Podczas przeciągania kciuk płynnie podąża za kursorem, a siatka przeskakuje do najbliższego wiersza/kolumny.
• Poprawka TCWSStringGrid: paski przewijania reagują na zmiany wykonane bezpośrednio na wewnętrznej siatce — zmianę szerokości kolumny/wysokości wiersza myszą, Grid.RowCount, DeleteRow, DeleteColumn itp.

Wersja 1.9.35:

• Poprawka TCWSStringGrid: brak pustego miejsca pod ostatnim wierszem i za ostatnią kolumną po powiększeniu okna — tak samo jak w TStringGrid z VCL. Gdy siatka jest przewinięta do końca i kontrolka rośnie, wiersze i kolumny przesuwają się tak, żeby ostatni wiersz/kolumna dochodziły do krawędzi. Zakres przewijania (pionowego i poziomego) jest liczony od końca danych, więc suwak zawsze dociera dokładnie do ostatniego wiersza/kolumny.
• Zmiana TCWSStringGrid: kciuk suwaka ma stałą długość (30 px przy 96 DPI, skalowane z DPI) — jak natywny suwak w Vcl.Grids; nie zmienia rozmiaru razem z oknem ani liczbą wierszy/kolumn.

Wersja 1.9.34:

• Nowość pakiet GetIt — bibliotekę można zainstalować przez Tools → GetIt Package Manager → Load Local Package, wskazując CWStudioComponents-github.json z wydania na GitHubie (zob. Instalacja przez GetIt).
• Poprawka TCWSScrollBox: kontrolki z alBottom / alRight dokują do końca zawartości — tak samo w designerze i w czasie działania. W designerze kontrolka alBottom lądowała na dole pierwszego ekranu (w środku dłuższej zawartości), a w czasie działania nachodziła na ostatnią kontrolkę. Teraz trafia za resztę zawartości, a przewijany obszar obejmuje jej wysokość.
• Poprawka TCWSScrollBox: marginesy wydłużają przewijany obszar — przy AlignWithMargins dolny i prawy margines kontrolki (także bez wyrównania) jest wliczany do rozmiaru zawartości, więc ostatnia kontrolka nie dotyka krawędzi.

Pełna historia zmian znajduje się w pliku CHANGELOG.md.

❤️ Wsparcie autora

Jeśli komponenty CWStudio okazały się przydatne i chcesz wesprzeć dalszy rozwój biblioteki — postaw mi wirtualną kawę lub przekaż darowiznę. Każde wsparcie pomaga utrzymać i rozbudowywać projekt:

💛 paypal.me/czeslaw80

📄 Licencja

Biblioteka jest udostępniona na licencji MIT — możesz jej używać, modyfikować i rozpowszechniać w dowolnych projektach komercyjnych lub niekomercyjnych. Warunkiem jest zachowanie informacji o autorstwie i treści licencji (zobacz sekcję ⚖️ Wymagane przypisanie autorstwa oraz plik LICENSE).

🇬🇧 English version

CWStudio is a library of modern, high-quality VCL components for Delphi, designed to give your desktop applications the look and feel of Windows 11 / WinUI 3. Every component is based on the official Fluent UI v9 color tokens and supports both light and dark themes — with automatic detection of the current Windows setting.

✨ Key features

• Windows 11 / WinUI 3 look & feel — every control styled consistently with the latest Microsoft guidelines.
• Light & Dark theme support with automatic system theme synchronization.
• GDI+ rendering — smooth edges, antialiasing, rounded corners.
• Performance-first — double buffering, no flicker, smooth animations.
• DPI-aware — controls scale correctly on HiDPI monitors.
• Open Source — completely free for commercial and non-commercial projects.

📦 Components

Containers & panels

Buttons

🎯 Action support (Action) — TCWSButton, TCWSCheckBox, TCWSRadioButton and TCWSSwitch expose an Action property that links them to a TAction in a TActionList, exactly like the stock VCL controls. The action drives Caption, Enabled, Visible, Hint (and Checked on the toggle controls), and a click executes OnExecute. Setting a property by hand unlinks it from the action (value-linking semantics, as in the VCL).

Input controls

Lists & grids

Progress indicators

Menus

Labels

Shapes

Helper components

Fluent color modules

🌗 The theme follows the system — the theme colors (light / dark) change automatically according to the Windows setting. The components listen for Windows theme changes (e.g. toggling Settings → Personalization → Colors → Mode) and repaint on the fly, and every registered handler is notified, so the whole app stays consistent with no restart.

Example — color module (CWSFluentColorsMulti)

uses
  CWSFluentColorsMulti;

procedure TForm1.FormCreate(Sender: TObject);
begin
  RegisterThemeChange(HandleThemeChange);
  FluentApplySystemTheme;            // auto-detect from Windows registry
  HandleThemeChange;                 // first paint
end;

procedure TForm1.HandleThemeChange;
begin
  Color           := flNeutralBackground1;
  Label1.Font.Color := flNeutralForeground1;
  Invalidate;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  UnregisterThemeChange(HandleThemeChange);
end;

Example — logged-on user's theme (CWSInteractiveUserTheme)

The standard theme detection reads HKCU, so an application running under NT AUTHORITY\SYSTEM (e.g. started by ServiceUI.exe from Intune / MDT) gets the service account's settings rather than the logged-on user's — and always comes up light. This unit determines the interactive session and its SID, and reads AppsUseLightTheme straight from HKEY_USERS\<SID>.

uses
  CWSFluentColorsMulti, CWSInteractiveUserTheme;

procedure TForm1.FormCreate(Sender: TObject);
begin
  RegisterThemeChange(ApplyTheme);   // registration only — the window has no handle yet
end;

procedure TForm1.FormShow(Sender: TObject);
begin
  StartFollowingUserTheme;           // applies the theme and starts watching for changes
  ApplyTheme;                        // first paint — explicitly, do not rely on the callback
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  StopFollowingUserTheme;
  UnregisterThemeChange(ApplyTheme);
end;

⚠️ Call StartFollowingUserTheme from FormShow, not from FormCreate — in FormCreate the form's global variable is still nil and the window has no handle.

Diagnostics: set ThemeLogEnabled := True (or start the application with the /themelog switch) to write the detection trace to %TEMP%\CWSTheme.log (under SYSTEM: C:\Windows\Temp). ThemeDiagnostics returns the same state as ready-made text — process SID, session ids, user SID and the detected theme.

🎨 Color swatch — CWSFluentColors_palette.html

The repository ships an interactive color swatch CWSFluentColors_palette.html — open it in a browser to browse every Fluent UI v9 token from CWSFluentColors.pas (Light and Dark variants). It lets you:

• filter tokens by name (e.g. Brand, Background, Hover),
• preview the palette on a light or dark page background (Light / Dark toggle),
• click a swatch to copy its color as HEX (#0f6cbd) or Delphi TColor ($00BD6C0F) — the Copy as toggle picks the format and also switches the values shown on the swatches; a right-click always copies the Delphi value,
• click a token name to copy the token name to the clipboard.

This makes it easy to pick and match the colors you set on component properties (e.g. BorderColor, CellHighlightColor, BckHoverColor, FillColor).

🔧 System requirements

• Embarcadero Delphi / RAD Studio with the VCL framework. The library was created and is developed in RAD Studio 13.1 Florence (compiler 37.0); RAD Studio 11 Alexandria or newer recommended.
• Target platforms: Win32 and Win64.
• Operating system:
  • Windows 10 or newer to run your application (TCWSDimOverlay uses WS_EX_LAYERED layered windows and the DWM API).
  • Windows 11 (build 22000) or newer for the full Windows 11 look — TCWSDimOverlay (and other layered windows such as the TCWSPopupMenu shadow) uses DWMWA_WINDOW_CORNER_PREFERENCE to draw rounded corners. On older systems the components still work correctly, but corners stay square (graceful degradation).
• No required third-party dependencies — the packages link only against the standard rtl and vcl.
• Icons — the icon-bearing components (e.g. TCWSButton, TCWSMenuButton, TCWSLabelTrend) accept any standard TCustomImageList (the Images / ImageIndex properties) or an icon-font glyph. No extra libraries are needed.

🚀 Installation

The library is split into two packages (following the standard Delphi architecture). Built with RAD Studio 13.1 Florence (compiler 37.0).

📥 Installing through GetIt (recommended)

1. Download CWStudioComponents-github.json from the latest release.
2. In RAD Studio: Tools → GetIt Package Manager → Load Local Package and select the downloaded file (requires an active Update Subscription).
3. Accept the license. GetIt downloads the payload from GitHub, builds both packages for Win32 and Win64, adds the Library path / Browsing path entries and registers the design-time package in both the 32-bit and the 64-bit IDE.
4. Restart the IDE when GetIt asks for it.

The package is installed into $(BDSCatalogRepository)\CWStudio-Components-Library\<version>. Details: GetIt/README.md.

If you installed the library manually before, first remove the old Library path entries and the old CWStudio_Components*.bpl files from $(BDSCOMMONDIR)\Bpl and $(BDSCOMMONDIR)\Bpl\Win64.

🔨 Manual installation from sources

1. Build the packages (runtime before design-time, for both platforms)

1. Open the CWStudio_Components.groupproj project group in RAD Studio.

2. Select the Win32 platform, then:

   • right-click CWStudio_ComponentsRT → Build,
   • right-click CWStudio_ComponentsDT → Build.

3. Switch the platform to Win64 and repeat both builds (the runtime is redistributed for 64-bit apps too).

   Or from the command line (after rsvars.bat):

   batCopy

   msbuild CWStudio_Components.groupproj /t:Build /p:Config=Release /p:Platform=Win32
   msbuild CWStudio_Components.groupproj /t:Build /p:Config=Release /p:Platform=Win64

2. Install the design-time package

Right-click CWStudio_ComponentsDT → Install. Then:

• the components appear on the palette under CWStudio_Panels / _Buttons / _Edits / _ProgressBars / _Menus / _ScrollBoxes / _Forms / _ListBoxes / _Grids / _Labels.

3. Add the library paths

So your applications compile against the components, in Tools → Options → Language → Delphi → Library (for each platform: Win32 and Win64) add the folder containing the .dcu files (the source folder, or .\Win32\Release / .\Win64\Release) to the Library path. Adding the source folder to the Browsing path lets you step into the component code while debugging.

🧩 Using it in an application & redistribution

• Without runtime packages (default — Link with runtime packages = false): the components are statically linked into the .exe. Nothing extra to ship.
• With runtime packages: add CWStudio_ComponentsRT to the project's Runtime Packages and ship CWStudio_ComponentsRT.bpl (Win32 or Win64) plus the dependency .bpls alongside your app. The design-time package is not needed by end users.

🛠️ Troubleshooting

• F2039: Could not create output file ...bpl — the package is currently loaded in the IDE. Uninstall it (Component → Install Packages) or close RAD Studio before building from the command line.
• E2466: Never-build package requires always-build package — CWStudio packages use {$IMPLICITBUILD ON}. Do not set the design-time package to {$IMPLICITBUILD OFF}.
• unit ... already in package ... — an older, combined CWStudio package is still installed. Uninstall it (Component → Install Packages) before installing the RT/DT pair.

🖥️ Demo application

The CWStudio_demo folder contains a sample VCL application (demo.dproj) that shows the components in action — buttons, edits, panels, grids and lists, progress indicators, scroll boxes, the system menu, the dim overlay with a dialog, and light / dark theme switching through CWSFluentColorsMulti. The sidebar is built from TCWSStoreButtons, and each page is a separate form embedded in the content area.

Demo requirements:

• the CWStudio packages installed (see 🚀 Installation),
• SVGIconImageList — the icons on the demo forms (TSVGIconImageList). The CWStudio components themselves do not need this library.

Since version 1.9.25 the demo no longer depends on ErrorSoft components (EsVclComponents) — TEsShape on the main form was replaced by a TCWSSettingsPanel, and the unused ES.* units were removed from the uses clauses.

Open CWStudio_demo\demo.dproj, pick the Win32 or Win64 platform and run it (F9).

⚖️ Attribution

When using these components, please include appropriate attribution in your application (e.g., in the About box):

"This application uses CWStudio components by Czesław Włudarczyk"

🗓️ What's new

Latest release — 1.9.37:

• Fixed TCWSMemo: ReadOnly = True no longer overrides the background color properties. A read-only memo used a hard-coded color ($F5F5F5), so BackgroundColor, BackgroundHoverColor and BackgroundFocusColor had no effect. The read-only look is now controlled by the new ReadOnlyColor property (clNone by default): with clNone the normal background / hover / focus chain applies — the same as in TCWSEdit — and setting a concrete color (e.g. $F5F5F5) restores the previous greyed-out look.
• Fixed TCWSMemo: toggling ReadOnly at run time repaints the text area too — SetReadOnly only repainted the owner-drawn frame and left the inner memo in the previous state’s color.

Release 1.9.36:

• Changed TCWSStringGrid: scrolling and thumb size work the same way as in TCWSDBGrid — on both the vertical and the horizontal bar. The thumb is proportional to the visible share of the content (at least 20 px at 96 DPI), so it shrinks when rows/columns are added and grows when they are removed. Scrolling is measured in pixels, so rows and columns of different sizes no longer make the thumb move unevenly, and the thumb reaches the end of the track exactly at the last row/column. While dragged, the thumb follows the cursor smoothly and the grid snaps to the nearest row/column.
• Fixed TCWSStringGrid: the scrollbars follow changes made directly on the inner grid — resizing a column/row with the mouse, Grid.RowCount, DeleteRow, DeleteColumn and so on.

Release 1.9.35:

• Fixed TCWSStringGrid: no empty space below the last row or right of the last column after the window grows — the same as the VCL TStringGrid. When the grid is scrolled to the end and the control gets bigger, rows and columns shift so the last row/column stays at the edge. The scroll range (vertical and horizontal) is computed from the end of the data, so the scrollbar always reaches exactly the last row/column.
• Changed TCWSStringGrid: the scrollbar thumb has a fixed length (30 px at 96 DPI, scaled with DPI) — like the native Vcl.Grids scrollbar; it does not resize with the window or the number of rows/columns.

Release 1.9.34:

• New GetIt package — install the library with Tools → GetIt Package Manager → Load Local Package using CWStudioComponents-github.json from the GitHub release (see Installing through GetIt).
• Fixed TCWSScrollBox: alBottom / alRight children dock to the end of the content — the same in the designer and at runtime. In the designer an alBottom child landed at the bottom of the first screen (in the middle of a longer content), and at runtime it covered the last control. It now goes after the rest of the content and the scrolled area includes its height.
• Fixed TCWSScrollBox: margins extend the scrolled area — with AlignWithMargins the bottom and right margin of a child (unaligned ones too) counts towards the content size, so the last control does not touch the edge.

The full change history is kept in CHANGELOG.md.

❤️ Support the author

If you find CWStudio useful and would like to support the ongoing development of the library, you can buy me a coffee or make a donation. Every contribution helps keep the project alive and growing:

💛 paypal.me/czeslaw80

📄 License

The library is released under the MIT license — you may use, modify, and redistribute it in any project, commercial or non-commercial, provided that the copyright notice and attribution are preserved (see the ⚖️ Attribution section and the LICENSE file).

Zrobione z ❤️ do Delphi · Made with ❤️ for Delphi

by Czesław Włudarczyk