nlve/src/uTheme.pas
4aiman aba9bd57e4 Кнопки внизу: подсказка не перехватывает щелчок, щелчки не теряются
Две беды у всех кнопок нижней полосы.

Всплывающая подсказка появлялась прямо поверх кнопки, о которой
рассказывает, и перехватывала щелчок: нажать кнопку было нельзя.
Подсказка переехала в строку состояния — она в той же полосе, ничего не
закрывает и меняется сразу после щелчка, не дожидаясь нового наведения.
Строка состояния теперь занимает всё свободное место справа, пока рядом
не показан ход работы, а самые длинные подсказки укорочены: раньше их
обрезало на полуслове.

Второй щелчок подряд виджетсет отдавал как двойной, и кнопка его не
видела: быстрая очередь щелчков срабатывала через раз. У кнопки убран
csDoubleClicks, а на случай, если двойной всё же дойдёт, он считается
за обычный.

Проверено: tests/lfmcheck, раздел «Кнопки нижней панели», и
tests/buttonclicks.sh мышью на невидимом экране — по всем шести
переключателям очереди из 1-5 щелчков отрабатываются полностью.
2026-09-30 15:44:29 +03:00

1548 lines
54 KiB
ObjectPascal
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

{
uTheme — собственные цвета для всего окна.
Зачем это нужно. Обычные элементы управления раскрашивает не программа,
а система: под Linux тема GTK, под Windows тема оформления. Одна и та же
программа поэтому выглядит по-разному, и на светлой теме тёмный таймлайн
оказывается вставленным в белую рамку. Здесь цвета заданы явно и
применяются принудительно, а не наследуются.
Кнопки пришлось написать свои. Системная кнопка под Windows свой цвет
не отдаёт вообще: LCL рисует её через службу оформления, и та кладёт
светлую подложку поверх любого заданного цвета. Проверено по исходникам
LCL (TCustomSpeedButton.PaintBackground всегда вызывает
ThemeServices.DrawElement).
Чего сделать нельзя, и это надо знать:
- полосы прокрутки внутри списков и журнала рисует система;
- рамка окна и её кнопки принадлежат оконному менеджеру;
- меню под gtk2 своими руками не рисуется — в LCL это прямо помечено
как неподдерживаемое (interfaces/gtk2/issues.xml). Зато сам gtk
принимает описание стиля текстом, и цвет меню задаётся так
(ApplyMenuStyle). Под Windows наоборот: строк стиля нет, зато
работает отрисовка пунктов своими руками (ApplyDarkMenu).
}
unit uTheme;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, Types, Controls, Graphics, Forms, StdCtrls, ExtCtrls,
ComCtrls, Grids, Menus, Dialogs, Math, IntfGraphics, FPimage,
LCLType, LCLIntf, LCLProc, uIconData;
const
{ Порядок байт в TColor — $00BBGGRR, а не привычный RGB. У серых цветов
все три байта равны, и перепутать нечего; у остальных в скобках
написано, что это за цвет на самом деле. }
ThemeWindow = TColor($202020); // фон окна
ThemeSurface = TColor($181818); // списки, журнал, таблицы
ThemePanel = TColor($262626); // полосы с кнопками
ThemeText = TColor($DCDCDC);
ThemeTextDim = TColor($909090); // недоступное и второстепенное
ThemeBorder = TColor($464646);
ThemeButton = TColor($3A3A3A);
ThemeButtonHover = TColor($4A4A4A);
ThemeButtonDown = TColor($2A2A2A);
ThemeAccent = TColor($1E5AC8); // оранжевый: включённый переключатель
ThemeAccentText = TColor($FFFFFF);
ThemeSelection = TColor($785434); // приглушённый синий: выделение
ThemeSelText = TColor($FFFFFF);
ThemeGridLine = TColor($3A3A3A);
ThemeLink = TColor($E0A060); // голубой: ссылка
type
{ Значок на кнопке.
Картинки вшиты в программу (uIconData): зависеть от того, лежит ли
рядом с ней файл, она не должна. Исходники — в icons_online, оттуда
же требование указать авторство, см. окно «О программе».
Цвет значку задаётся при отрисовке: берётся прозрачность точки, а
цвет — тот, каким сейчас рисуется кнопка. Поэтому один значок годится
и для тёмной кнопки, и для оранжевой, и для недоступной. }
TThemedIcon = (
tiNone,
tiSnap, // прилипание: края притягиваются к общей линии
tiRipple, // схлопывание: дыра между кусками закрывается
tiLog, // журнал: полоса с сообщениями
tiGlue, // курсор липнет к границам клипов
tiTarget, // курсор держится середины монтажа
tiSelectClips, // выделение рамкой: что задело, то и выделено
tiSelectRange // выделение по времени: от и до, по всем дорожкам
);
{ Полоска выполнения, которая рисует себя сама.
Системная берёт цвета у темы оформления и на тёмном окне остаётся
светлой — та же причина, по которой здесь своя кнопка и свои полосы
прокрутки.
Доля хранится числом от нуля до единицы, а не «позицией» и
«максимумом»: снаружи она всегда получается делением одного на
другое, и хранить обе части незачем. }
TThemedProgress = class(TGraphicControl)
private
FFraction: Double;
procedure SetFraction(const AValue: Double);
protected
procedure Paint; override;
public
constructor Create(AOwner: TComponent); override;
property Fraction: Double read FFraction write SetFraction;
end;
{ Кнопка, которая рисует себя сама.
Свойства Default, Cancel и ModalResult повторяют поведение обычной
кнопки: Enter и Esc в окне должны работать так же, иначе привычка
подводит на ровном месте. }
TThemedButton = class(TCustomControl)
private
FArrow: Boolean;
FSwatch: TColor;
FIcon: TThemedIcon;
FFlat: Boolean;
FDown: Boolean;
FHover: Boolean;
FPressed: Boolean;
FDefault: Boolean;
FCancel: Boolean;
FModalResult: TModalResult;
procedure SetArrow(AValue: Boolean);
procedure SetIcon(AValue: TThemedIcon);
procedure SetSwatch(AValue: TColor);
procedure DrawIcon(const ARect: TRect; AColor: TColor);
procedure SetFlat(AValue: Boolean);
procedure SetDown(AValue: Boolean);
procedure SetDefault(AValue: Boolean);
procedure SetCancel(AValue: Boolean);
procedure UpdateFormRoles;
protected
procedure Paint; override;
procedure Loaded; override;
procedure MouseEnter; override;
procedure MouseLeave; override;
procedure MouseDown(Button: TMouseButton; Shift: TShiftState;
X, Y: Integer); override;
procedure MouseUp(Button: TMouseButton; Shift: TShiftState;
X, Y: Integer); override;
procedure KeyDown(var Key: Word; Shift: TShiftState); override;
procedure KeyUp(var Key: Word; Shift: TShiftState); override;
{ Если двойной щелчок всё же дойдёт (виджетсет может послать его и
без csDoubleClicks), считаем его обычным нажатием. }
procedure DblClick; override;
procedure TextChanged; override;
class function GetControlClassDefaultSize: TSize; override;
public
constructor Create(AOwner: TComponent); override;
procedure Click; override;
procedure ExecuteDefaultAction; override;
procedure ExecuteCancelAction; override;
published
property Align;
property Anchors;
{ Рисовать треугольник вместо надписи. Знак «▼» из шрифта брать нельзя:
в системном шрифте Windows его может не оказаться, и вместо стрелки
выйдет пустой квадрат. Проверено под Wine — именно так и вышло. }
property Arrow: Boolean read FArrow write SetArrow default False;
property Cancel: Boolean read FCancel write SetCancel default False;
property Caption;
{ Значок вместо надписи. Надпись при этом не пропадает зря: её место —
подсказка, которая всплывает по наведению. }
property Icon: TThemedIcon read FIcon write SetIcon default tiNone;
{ Образец цвета вместо надписи: кнопка выбора цвета должна показывать
сам цвет, а не слово «выбрать». clNone — обычная кнопка. }
property Swatch: TColor read FSwatch write SetSwatch default clNone;
property Default: Boolean read FDefault write SetDefault default False;
property Down: Boolean read FDown write SetDown default False;
property Enabled;
{ Без рамки и без своей подложки, пока на кнопку не навели курсор.
Так выглядят названия в полосе меню: это не кнопки, и рисовать их
кнопками значит врать глазу. }
property Flat: Boolean read FFlat write SetFlat default False;
property Font;
property Hint;
{ Наведение и уход: главному окну они нужны, чтобы показывать
подсказку строкой состояния, а не всплывающим окном поверх кнопки. }
property OnMouseEnter;
property OnMouseLeave;
property ModalResult: TModalResult read FModalResult write FModalResult
default mrNone;
property ParentFont;
property ParentShowHint;
property ShowHint;
property TabOrder;
property TabStop default True;
property Visible;
property OnClick;
property OnMouseDown;
property OnMouseUp;
end;
{ Раскрашивает окно и всё, что в нём, включая вложенные панели.
Вызывается один раз после создания окна. }
procedure ApplyDarkTheme(AComponent: TComponent);
{ Подписывается на появление новых окон и красит их сама. Нужно, чтобы не
забыть про окно, которое создаётся где-то в глубине. Вызывается один раз
при запуске. }
procedure HookNewForms;
{ Меню в наших цветах отрисовкой своими руками. Действует только под
win32; под gtk2 цвет задаётся строкой стиля, см. ApplyMenuStyle. }
procedure ApplyDarkMenu(AMenu: TMenu);
{ Закрашивает остаток полосы меню — то место правее последнего названия,
которое не занято ни одним пунктом.
Нужно потому, что до него не дотянуться ни отрисовкой пунктов (это не
пункт), ни подложкой через SetMenuInfo (проверено под Wine: пункты
тёмные, полоса светлая). Полоса живёт в неклиентской части окна,
поэтому рисуем прямо в её область.
Под gtk2 ничего не делает: там всю полосу красит строка стиля. }
procedure PaintMenuBarTail(AForm: TCustomForm);
{ Что вышло у последней закраски: какие прямоугольники выдала система и
куда мы рисовали. Нужно, чтобы не гадать, почему полоса осталась
светлой. }
function MenuBarTailNote: string;
{ Цвета для меню, которое рисует не программа, а система.
Вызывать до создания окон: строка стиля разбирается один раз, и уже
созданные виджеты о ней не узнают.
Под gtk2 это единственный способ. Собственных средств у LCL там нет —
OwnerDraw, OnDrawItem и OnMeasureItem в gtk2 прямо помечены как
неподдерживаемые (lcl/interfaces/gtk2/issues.xml), и событие из
инспектора объектов просто никогда не наступит. Зато сам gtk принимает
описание стиля текстом.
Под win32 ничего не делает: там работает отрисовка своими руками через
ApplyDarkMenu. }
procedure ApplyMenuStyle;
{ Окно сообщения в наших цветах вместо системного.
Кнопки задаются готовым набором, как у MessageDlg, но рисуются нашими.
Возвращает mrOk, mrYes, mrNo или mrCancel. }
function ThemedMessageDlg(const ACaption, AText: string;
ADlgType: TMsgDlgType; AButtons: TMsgDlgButtons;
AHelpCtx: Longint = 0): TModalResult;
{ Вопрос со своими кнопками. Возвращает номер нажатой, считая с нуля, или
-1, если окно просто закрыли.
Нужен там, где готовых «Да / Нет / Отмена» не хватает: например,
третьей кнопкой «Больше не напоминать». }
function ThemedChoiceDlg(const ACaption, AText: string;
const ACaptions: array of string): Integer;
{ Ввод одной строки в тёмном окне. Системный InputQuery выглядел бы белым
пятном посреди тёмной программы. }
function ThemedInputDlg(const ACaption, APrompt: string;
var AValue: string): Boolean;
implementation
{$IFDEF LCLGTK2}
uses
glib2, gtk2;
{$ENDIF}
{$IFDEF WINDOWS}
{ Модуль Windows целиком подключать нельзя: он объявляет свои TRect и
RegisterClass, а имена в Паскале нечувствительны к регистру — и обычные
вызовы LCL начинают разбираться как системные. Поэтому берём ровно то,
что нужно, и ничего больше. }
type
TMenuInfoRec = record
cbSize: DWORD;
fMask: DWORD;
dwStyle: DWORD;
cyMax: UINT;
hbrBack: HBRUSH;
dwContextHelpID: DWORD;
dwMenuData: PtrUInt;
end;
const
MIM_BACKGROUND = $00000002;
MIM_APPLYTOSUBMENUS = $80000000;
function SetMenuInfo(AMenu: HMENU; const AInfo: TMenuInfoRec): LongBool;
stdcall; external 'user32' name 'SetMenuInfo';
{ Имя своё, а не DrawMenuBar: так называется и функция LCL, а имена в
Паскале нечувствительны к регистру. По той же причине своё имя у всех
остальных вызовов ниже. }
function SysDrawMenuBar(AWnd: HWND): LongBool;
stdcall; external 'user32' name 'DrawMenuBar';
type
TMenuBarInfoRec = record
cbSize: DWORD;
rcBar: TRect;
hMenu: HMENU;
hwndMenu: HWND;
Flags: DWORD; { два битовых признака, нам не нужны }
end;
const
{ Знаковое, как в заголовках Windows: -3. }
OBJID_MENU = LongInt(-3);
function SysGetMenuBarInfo(AWnd: HWND; AObject, AItem: LongInt;
var AInfo: TMenuBarInfoRec): LongBool;
stdcall; external 'user32' name 'GetMenuBarInfo';
function SysGetMenuItemRect(AWnd: HWND; AMenu: HMENU; AItem: UINT;
var ARect: TRect): LongBool;
stdcall; external 'user32' name 'GetMenuItemRect';
function SysGetMenuItemCount(AMenu: HMENU): Integer;
stdcall; external 'user32' name 'GetMenuItemCount';
function SysGetWindowDC(AWnd: HWND): HDC;
stdcall; external 'user32' name 'GetWindowDC';
function SysReleaseDC(AWnd: HWND; ADC: HDC): Integer;
stdcall; external 'user32' name 'ReleaseDC';
function SysFillRect(ADC: HDC; const ARect: TRect; ABrush: HBRUSH): Integer;
stdcall; external 'user32' name 'FillRect';
function SysGetWindowRect(AWnd: HWND; var ARect: TRect): LongBool;
stdcall; external 'user32' name 'GetWindowRect';
{$ENDIF}
type
{ Обработчики отрисовки живут в объекте: событиям нужны методы, а не
обычные процедуры. }
TThemePainter = class
procedure MenuDraw(Sender: TObject; ACanvas: TCanvas; ARect: TRect;
AState: TOwnerDrawState);
procedure MenuMeasure(Sender: TObject; ACanvas: TCanvas;
var AWidth, AHeight: Integer);
procedure ComboDraw(Control: TWinControl; Index: Integer; ARect: TRect;
State: TOwnerDrawState);
procedure FormAdded(Sender: TObject; AForm: TCustomForm);
end;
var
Painter: TThemePainter;
{ Перекрашенные значки: ключ «номер значка : цвет». }
IconCache: TStringList;
{$IFDEF WINDOWS}
{ Кисть под полосу меню. Создаётся один раз: Windows держит на неё
ссылку, пока меню живо, и удалять её раньше нельзя. }
MenuBrush: HBRUSH;
{$ENDIF}
const
MenuTextLeft = 26; { отступ слева: место под галочку }
MenuTextRight = 16; { отступ справа: место под стрелку подменю }
MenuGap = 28; { просвет между названием и сочетанием клавиш }
MenuBarSide = 10; { отступ по краям названия в полосе меню }
{ TThemedProgress }
constructor TThemedProgress.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FFraction := 0;
Height := 6;
Width := 120;
end;
procedure TThemedProgress.SetFraction(const AValue: Double);
var
V: Double;
begin
V := AValue;
if V < 0 then
V := 0;
if V > 1 then
V := 1;
{ Перерисовываем только при заметном изменении: полоска обновляется по
таймеру, и дёргать отрисовку на каждую тысячную незачем. }
if Abs(V - FFraction) < 0.002 then
Exit;
FFraction := V;
Invalidate;
end;
procedure TThemedProgress.Paint;
var
R: TRect;
W: Integer;
begin
R := ClientRect;
Canvas.Brush.Style := bsSolid;
Canvas.Brush.Color := ThemeButtonDown;
Canvas.FillRect(R);
W := Round(R.Right * FFraction);
if W > 0 then
begin
Canvas.Brush.Color := ThemeAccent;
Canvas.FillRect(Rect(0, 0, W, R.Bottom));
end;
Canvas.Brush.Style := bsClear;
Canvas.Pen.Color := ThemeBorder;
Canvas.Rectangle(R);
end;
{ TThemedButton }
constructor TThemedButton.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{ csHasDefaultAction говорит форме, что нашу кнопку осмысленно
вызывать по Enter; без этого Enter до неё не дойдёт. }
ControlStyle := ControlStyle + [csHasDefaultAction, csHasCancelAction];
{ Двойной щелчок кнопке не нужен, а вреден. Второе нажатие подряд
приходит как двойное и обычным щелчком не считается — нажатие просто
пропадало. Со стороны это выглядело как «нажимаю быстро — не
срабатывает, нажимаю медленно — срабатывает». }
ControlStyle := ControlStyle - [csDoubleClicks];
TabStop := True;
DoubleBuffered := True;
{ Без явного значения образец был бы чёрным (ноль — это clBlack), и
чёрные прямоугольники полезли бы на все кнопки разом. }
FSwatch := clNone;
with GetControlClassDefaultSize do
SetInitialBounds(0, 0, cx, cy);
end;
class function TThemedButton.GetControlClassDefaultSize: TSize;
begin
Result.cx := 100;
Result.cy := 28;
end;
procedure TThemedButton.SetSwatch(AValue: TColor);
begin
if FSwatch = AValue then
Exit;
FSwatch := AValue;
Invalidate;
end;
procedure TThemedButton.SetIcon(AValue: TThemedIcon);
begin
if FIcon = AValue then
Exit;
FIcon := AValue;
Invalidate;
end;
{ Значок в нужном цвете.
Картинка чёрная с прозрачностью, поэтому перекрашивается прямо по
точкам: прозрачность остаётся своя, цвет ставится наш. Результат
запоминается — цветов ровно три (обычный, на оранжевом, недоступный), и
пересчитывать их на каждую перерисовку незачем. }
function ThemedIconImage(AIcon: TThemedIcon; AColor: TColor):
TPortableNetworkGraphic;
var
Key: string;
Idx, X, Y: Integer;
Stream: TMemoryStream;
Img: TLazIntfImage;
Px: TFPColor;
R, G, B: Byte;
begin
Result := nil;
if AIcon = tiNone then
Exit;
Key := IntToStr(Ord(AIcon)) + ':' + IntToStr(AColor);
if IconCache = nil then
begin
IconCache := TStringList.Create;
IconCache.Sorted := True;
IconCache.OwnsObjects := True;
end;
Idx := IconCache.IndexOf(Key);
if Idx >= 0 then
Exit(TPortableNetworkGraphic(IconCache.Objects[Idx]));
Stream := TMemoryStream.Create;
try
case AIcon of
tiSnap: Stream.WriteBuffer(IconSnapData[0], Length(IconSnapData));
tiRipple: Stream.WriteBuffer(IconRippleData[0], Length(IconRippleData));
tiLog: Stream.WriteBuffer(IconLogData[0], Length(IconLogData));
tiGlue: Stream.WriteBuffer(IconGlueData[0], Length(IconGlueData));
tiTarget: Stream.WriteBuffer(IconTargetData[0], Length(IconTargetData));
tiSelectClips: Stream.WriteBuffer(IconSelectClipsData[0],
Length(IconSelectClipsData));
tiSelectRange: Stream.WriteBuffer(IconSelectRangeData[0],
Length(IconSelectRangeData));
else
Exit;
end;
Stream.Position := 0;
Result := TPortableNetworkGraphic.Create;
try
Result.LoadFromStream(Stream);
{ Порядок байт в TColor обратный привычному. }
R := AColor and $FF;
G := (AColor shr 8) and $FF;
B := (AColor shr 16) and $FF;
Img := Result.CreateIntfImage;
try
for Y := 0 to Img.Height - 1 do
for X := 0 to Img.Width - 1 do
begin
Px := Img.Colors[X, Y];
{ Прозрачное трогать незачем, а видимое красим целиком. }
if Px.Alpha = 0 then
Continue;
Px.Red := R * 257;
Px.Green := G * 257;
Px.Blue := B * 257;
Img.Colors[X, Y] := Px;
end;
Result.LoadFromIntfImage(Img);
finally
Img.Free;
end;
except
FreeAndNil(Result);
end;
finally
Stream.Free;
end;
{ Неудачу тоже запоминаем: иначе разбирать картинку заново пришлось бы
на каждой перерисовке. }
IconCache.AddObject(Key, Result);
end;
{ Значок рисуется без растягивания: картинка вшита ровно того размера, под
который сделана кнопка. Если кнопка оказалась крупнее — значок остаётся
своего размера и стоит по центру, а не расплывается. }
procedure TThemedButton.DrawIcon(const ARect: TRect; AColor: TColor);
var
Img: TPortableNetworkGraphic;
X, Y: Integer;
begin
Img := ThemedIconImage(FIcon, AColor);
if (Img = nil) or (Img.Width = 0) then
Exit;
X := (ARect.Left + ARect.Right - Img.Width) div 2;
Y := (ARect.Top + ARect.Bottom - Img.Height) div 2;
Canvas.Draw(X, Y, Img);
end;
procedure TThemedButton.Paint;
var
R: TRect;
Back, Fore: TColor;
TS: TSize;
CX, CY: Integer;
begin
R := ClientRect;
if not Enabled then
begin
Back := ThemeButtonDown;
Fore := ThemeTextDim;
end
else if FPressed then
begin
Back := ThemeButtonDown;
Fore := ThemeText;
end
else if FDown then
begin
Back := ThemeAccent;
Fore := ThemeAccentText;
end
else if FHover then
begin
Back := ThemeButtonHover;
Fore := ThemeText;
end
else if FFlat then
begin
Back := ThemePanel;
Fore := ThemeText;
end
else
begin
Back := ThemeButton;
Fore := ThemeText;
end;
Canvas.Brush.Color := Back;
Canvas.Brush.Style := bsSolid;
Canvas.FillRect(R);
if not (FFlat and not (FHover or FPressed or FDown)) then
begin
Canvas.Pen.Color := ThemeBorder;
Canvas.Pen.Style := psSolid;
Canvas.Brush.Style := bsClear;
Canvas.Rectangle(R);
end;
if FArrow then
begin
Canvas.Brush.Color := Fore;
Canvas.Brush.Style := bsSolid;
Canvas.Pen.Color := Fore;
CX := R.Right div 2;
CY := R.Bottom div 2;
{ Types.Point указан явно: модуль Windows объявляет тип POINT, а имена
в Паскале нечувствительны к регистру, и без уточнения Point(x, y)
разбирается как приведение типа с двумя аргументами. }
Canvas.Polygon([Point(CX - 5, CY - 2), Point(CX + 5, CY - 2),
Point(CX, CY + 4)]);
end
else if FSwatch <> clNone then
begin
{ Образец с рамкой: без неё белый цвет на светлой кнопке сливается. }
Canvas.Brush.Color := FSwatch;
Canvas.Brush.Style := bsSolid;
Canvas.Pen.Color := ThemeBorder;
Canvas.Rectangle(R.Left + 5, R.Top + 5, R.Right - 5, R.Bottom - 5);
end
else if FIcon <> tiNone then
DrawIcon(R, Fore)
else
begin
Canvas.Font.Assign(Font);
Canvas.Font.Color := Fore;
TS := Canvas.TextExtent(Caption);
Canvas.TextOut((R.Right - TS.cx) div 2, (R.Bottom - TS.cy) div 2, Caption);
end;
{ Рамка фокуса рисуется только там, где фокус вообще предусмотрен.
Кнопки полосы меню его не берут, а рамка на них появлялась и
выглядела как испорченный пункт. }
if Focused and TabStop then
begin
Canvas.Pen.Color := ThemeTextDim;
Canvas.Pen.Style := psDot;
Canvas.Rectangle(R.Left + 3, R.Top + 3, R.Right - 3, R.Bottom - 3);
Canvas.Pen.Style := psSolid;
end;
end;
procedure TThemedButton.Loaded;
begin
inherited Loaded;
{ Во время чтения формы родителя ещё нет, поэтому роль «кнопка по
умолчанию» назначается здесь, когда форма уже собрана. }
UpdateFormRoles;
end;
procedure TThemedButton.UpdateFormRoles;
var
F: TCustomForm;
begin
F := GetParentForm(Self);
if F = nil then
Exit;
if FDefault then
F.DefaultControl := Self
else if F.DefaultControl = Self then
F.DefaultControl := nil;
if FCancel then
F.CancelControl := Self
else if F.CancelControl = Self then
F.CancelControl := nil;
end;
procedure TThemedButton.SetArrow(AValue: Boolean);
begin
if FArrow = AValue then
Exit;
FArrow := AValue;
Invalidate;
end;
procedure TThemedButton.SetFlat(AValue: Boolean);
begin
if FFlat = AValue then
Exit;
FFlat := AValue;
Invalidate;
end;
procedure TThemedButton.SetDown(AValue: Boolean);
begin
if FDown = AValue then
Exit;
FDown := AValue;
Invalidate;
end;
procedure TThemedButton.SetDefault(AValue: Boolean);
begin
if FDefault = AValue then
Exit;
FDefault := AValue;
UpdateFormRoles;
end;
procedure TThemedButton.SetCancel(AValue: Boolean);
begin
if FCancel = AValue then
Exit;
FCancel := AValue;
UpdateFormRoles;
end;
procedure TThemedButton.MouseEnter;
begin
inherited MouseEnter;
FHover := True;
Invalidate;
end;
procedure TThemedButton.MouseLeave;
begin
inherited MouseLeave;
FHover := False;
FPressed := False;
Invalidate;
end;
procedure TThemedButton.MouseDown(Button: TMouseButton; Shift: TShiftState;
X, Y: Integer);
begin
inherited MouseDown(Button, Shift, X, Y);
if Button <> mbLeft then
Exit;
if Enabled and TabStop and CanFocus then
SetFocus;
FPressed := True;
Invalidate;
end;
procedure TThemedButton.MouseUp(Button: TMouseButton; Shift: TShiftState;
X, Y: Integer);
begin
FPressed := False;
Invalidate;
inherited MouseUp(Button, Shift, X, Y);
{ Click отсюда не вызывается.
Его вызывает сама LCL при отпускании внутри кнопки — TControl.
WMLButtonUp, с той же проверкой «внутри», какая напрашивается здесь.
Написанный руками вызов оказывался вторым, и каждый щелчок срабатывал
дважды. На кнопке-переключателе это значит «ничего не произошло»:
первое срабатывание меняло состояние, второе возвращало обратно.
Найдено на невидимом экране: в журнал легли две записи «обработчик
кнопки журнала вызван» на один щелчок мышью, тогда как то же действие
с клавиатуры давало одну. }
end;
procedure TThemedButton.DblClick;
begin
Click;
end;
procedure TThemedButton.KeyDown(var Key: Word; Shift: TShiftState);
begin
inherited KeyDown(Key, Shift);
if (Key = VK_SPACE) or (Key = VK_RETURN) then
begin
FPressed := True;
Invalidate;
end;
end;
procedure TThemedButton.KeyUp(var Key: Word; Shift: TShiftState);
begin
inherited KeyUp(Key, Shift);
if FPressed and ((Key = VK_SPACE) or (Key = VK_RETURN)) then
begin
FPressed := False;
Invalidate;
Click;
end;
end;
procedure TThemedButton.TextChanged;
begin
inherited TextChanged;
Invalidate;
end;
procedure TThemedButton.Click;
var
F: TCustomForm;
begin
inherited Click;
if FModalResult <> mrNone then
begin
F := GetParentForm(Self);
if (F <> nil) and (fsModal in F.FormState) then
F.ModalResult := FModalResult;
end;
end;
procedure TThemedButton.ExecuteDefaultAction;
begin
if FDefault and Enabled and Visible then
Click;
end;
procedure TThemedButton.ExecuteCancelAction;
begin
if FCancel and Enabled and Visible then
Click;
end;
{ TThemePainter }
procedure TThemePainter.MenuDraw(Sender: TObject; ACanvas: TCanvas;
ARect: TRect; AState: TOwnerDrawState);
var
Item: TMenuItem;
Back, Fore: TColor;
S: string;
Y, H: Integer;
begin
if not (Sender is TMenuItem) then
Exit;
Item := TMenuItem(Sender);
Back := ThemePanel;
Fore := ThemeText;
if odSelected in AState then
begin
Back := ThemeAccent;
Fore := ThemeAccentText;
end;
if (odDisabled in AState) or (not Item.Enabled) then
Fore := ThemeTextDim;
ACanvas.Brush.Color := Back;
ACanvas.Brush.Style := bsSolid;
ACanvas.FillRect(ARect);
if Item.IsLine then
begin
Y := (ARect.Top + ARect.Bottom) div 2;
ACanvas.Pen.Color := ThemeBorder;
ACanvas.Line(ARect.Left + 6, Y, ARect.Right - 6, Y);
Exit;
end;
ACanvas.Font.Color := Fore;
ACanvas.Brush.Style := bsClear;
H := ACanvas.TextHeight('Wg');
Y := ARect.Top + (ARect.Bottom - ARect.Top - H) div 2;
{ В полосе меню отступ слева другой: место под галочку и под сочетание
клавиш там не нужно, а с отступом раскрытого списка названия разошлись
бы с шириной, которую мы же и посчитали. }
if Item.IsInMenuBar then
begin
ACanvas.TextOut(ARect.Left + MenuBarSide, Y, Item.Caption);
Exit;
end;
if Item.Checked then
ACanvas.TextOut(ARect.Left + 8, Y, '•');
ACanvas.TextOut(ARect.Left + MenuTextLeft, Y, Item.Caption);
if Item.ShortCut <> 0 then
begin
S := ShortCutToText(Item.ShortCut);
if not (odSelected in AState) then
ACanvas.Font.Color := ThemeTextDim;
ACanvas.TextOut(ARect.Right - MenuTextRight - ACanvas.TextWidth(S), Y, S);
end;
end;
procedure TThemePainter.MenuMeasure(Sender: TObject; ACanvas: TCanvas;
var AWidth, AHeight: Integer);
var
Item: TMenuItem;
W: Integer;
begin
if not (Sender is TMenuItem) then
Exit;
Item := TMenuItem(Sender);
if Item.IsLine then
begin
AHeight := 7;
AWidth := 40;
Exit;
end;
AHeight := ACanvas.TextHeight('Wg') + 10;
if Item.IsInMenuBar then
begin
AWidth := ACanvas.TextWidth(Item.Caption) + MenuBarSide * 2;
Exit;
end;
W := MenuTextLeft + ACanvas.TextWidth(Item.Caption) + MenuTextRight;
if Item.ShortCut <> 0 then
Inc(W, MenuGap + ACanvas.TextWidth(ShortCutToText(Item.ShortCut)));
AWidth := W;
end;
procedure TThemePainter.ComboDraw(Control: TWinControl; Index: Integer;
ARect: TRect; State: TOwnerDrawState);
var
Combo: TComboBox;
Back, Fore: TColor;
S: string;
begin
if not (Control is TComboBox) then
Exit;
Combo := TComboBox(Control);
if odSelected in State then
begin
Back := ThemeSelection;
Fore := ThemeSelText;
end
else
begin
Back := ThemeSurface;
Fore := ThemeText;
end;
Combo.Canvas.Brush.Color := Back;
Combo.Canvas.Brush.Style := bsSolid;
Combo.Canvas.FillRect(ARect);
if (Index >= 0) and (Index < Combo.Items.Count) then
S := Combo.Items[Index]
else
S := '';
Combo.Canvas.Font.Color := Fore;
Combo.Canvas.Brush.Style := bsClear;
Combo.Canvas.TextOut(ARect.Left + 4,
ARect.Top + (ARect.Bottom - ARect.Top - Combo.Canvas.TextHeight('Wg')) div 2,
S);
end;
procedure TThemePainter.FormAdded(Sender: TObject; AForm: TCustomForm);
begin
ApplyDarkTheme(AForm);
end;
{ Раскрашивание }
procedure ApplyToControl(AControl: TControl); forward;
procedure ApplyToChildren(AControl: TWinControl);
var
I: Integer;
begin
for I := 0 to AControl.ControlCount - 1 do
ApplyToControl(AControl.Controls[I]);
end;
procedure ApplyToControl(AControl: TControl);
var
Grid: TStringGrid;
Combo: TComboBox;
begin
{ Свои контролы (таймлайн, наши кнопки) раскрашивают себя сами и трогать
их нельзя: заданный снаружи цвет им ничего не скажет, а сбросить
настройки может. }
if AControl is TThemedButton then
begin
ApplyToChildren(TWinControl(AControl));
Exit;
end;
if AControl is TForm then
begin
TForm(AControl).Color := ThemeWindow;
TForm(AControl).Font.Color := ThemeText;
end
else if AControl is TPanel then
begin
TPanel(AControl).ParentColor := False;
TPanel(AControl).Color := ThemePanel;
TPanel(AControl).ParentFont := False;
TPanel(AControl).Font.Color := ThemeText;
{ Объёмная рамка рисуется системными светлыми цветами и на тёмном
фоне выглядит грязной полосой. }
TPanel(AControl).BevelOuter := bvNone;
end
else if AControl is TMemo then
begin
TMemo(AControl).ParentColor := False;
TMemo(AControl).Color := ThemeSurface;
TMemo(AControl).ParentFont := False;
TMemo(AControl).Font.Color := ThemeText;
{ Рамку поля рисует система светлыми цветами, и на тёмном фоне она
выглядит белым прямоугольником. Границу и так видно по смене
оттенка фона. }
TMemo(AControl).BorderStyle := bsNone;
end
else if AControl is TListBox then
begin
TListBox(AControl).ParentColor := False;
TListBox(AControl).Color := ThemeSurface;
TListBox(AControl).ParentFont := False;
TListBox(AControl).Font.Color := ThemeText;
TListBox(AControl).BorderStyle := bsNone;
end
else if AControl is TComboBox then
begin
Combo := TComboBox(AControl);
Combo.ParentColor := False;
Combo.Color := ThemeSurface;
Combo.ParentFont := False;
Combo.Font.Color := ThemeText;
{ Список выпадающего списка система рисует своими цветами, если его не
забрать себе. csOwnerDrawFixed — тот же нередактируемый список, но
строки рисуем мы. }
if Combo.Style = csDropDownList then
Combo.Style := csOwnerDrawFixed;
if not Assigned(Combo.OnDrawItem) then
Combo.OnDrawItem := @Painter.ComboDraw;
end
else if AControl is TStringGrid then
begin
Grid := TStringGrid(AControl);
Grid.ParentColor := False;
Grid.Color := ThemeSurface;
Grid.ParentFont := False;
Grid.Font.Color := ThemeText;
Grid.FixedColor := ThemePanel;
Grid.GridLineColor := ThemeGridLine;
Grid.AlternateColor := ThemeSurface;
Grid.SelectedColor := ThemeSelection;
Grid.BorderStyle := bsNone;
end
else if AControl is TEdit then
begin
TEdit(AControl).ParentColor := False;
TEdit(AControl).Color := ThemeSurface;
TEdit(AControl).ParentFont := False;
TEdit(AControl).Font.Color := ThemeText;
TEdit(AControl).BorderStyle := bsNone;
end
else if AControl is TCheckBox then
begin
TCheckBox(AControl).ParentColor := False;
TCheckBox(AControl).Color := ThemePanel;
TCheckBox(AControl).ParentFont := False;
TCheckBox(AControl).Font.Color := ThemeText;
end
else if AControl is TLabel then
begin
TLabel(AControl).ParentFont := False;
TLabel(AControl).Font.Color := ThemeText;
TLabel(AControl).Transparent := True;
end
else if AControl is TSplitter then
begin
TSplitter(AControl).ParentColor := False;
TSplitter(AControl).Color := ThemeBorder;
end
else if AControl is TTrackBar then
begin
TTrackBar(AControl).ParentColor := False;
TTrackBar(AControl).Color := ThemePanel;
end;
if AControl is TWinControl then
ApplyToChildren(TWinControl(AControl));
end;
{ Цвет Паскаля хранит составляющие в обратном порядке, а gtk ждёт
привычную запись «решётка, красный, зелёный, синий». }
function GtkColorText(AColor: TColor): string;
begin
Result := Format('#%.2x%.2x%.2x',
[AColor and $FF, (AColor shr 8) and $FF, (AColor shr 16) and $FF]);
end;
procedure ApplyMenuStyle;
{$IFDEF LCLGTK2}
var
Rc: string;
{$ENDIF}
begin
{$IFDEF LCLGTK2}
Rc :=
'style "nlve-menu" {' + LineEnding +
' bg[NORMAL] = "' + GtkColorText(ThemePanel) + '"' + LineEnding +
' bg[PRELIGHT] = "' + GtkColorText(ThemeAccent) + '"' + LineEnding +
' bg[ACTIVE] = "' + GtkColorText(ThemePanel) + '"' + LineEnding +
' bg[INSENSITIVE] = "' + GtkColorText(ThemePanel) + '"' + LineEnding +
' fg[NORMAL] = "' + GtkColorText(ThemeText) + '"' + LineEnding +
' fg[PRELIGHT] = "' + GtkColorText(ThemeAccentText) + '"' + LineEnding +
' fg[ACTIVE] = "' + GtkColorText(ThemeText) + '"' + LineEnding +
' fg[INSENSITIVE] = "' + GtkColorText(ThemeTextDim) + '"' + LineEnding +
' text[NORMAL] = "' + GtkColorText(ThemeText) + '"' + LineEnding +
' base[NORMAL] = "' + GtkColorText(ThemePanel) + '"' + LineEnding +
'}' + LineEnding +
'class "GtkMenuBar" style "nlve-menu"' + LineEnding +
'class "GtkMenu" style "nlve-menu"' + LineEnding +
'class "GtkMenuItem" style "nlve-menu"' + LineEnding +
'widget_class "*<GtkMenuBar>*" style "nlve-menu"' + LineEnding +
'widget_class "*<GtkMenuItem>*" style "nlve-menu"' + LineEnding;
gtk_rc_parse_string(PChar(Rc));
{$ENDIF}
end;
var
TailNote: string = 'закраска полосы меню не вызывалась';
{ Идёт ли закраска прямо сейчас. См. пояснение у PaintMenuBarTail. }
TailBusy: Boolean = False;
function MenuBarTailNote: string;
begin
Result := TailNote;
end;
procedure PaintMenuBarTail(AForm: TCustomForm);
{$IFDEF LCLWIN32}
{ Защита от повторного входа.
Закраска вызывается из обработчика перерисовки рамки окна, а сама
рисует в эту рамку — и под Wine рисование снова просило перерисовку.
Получалась воронка: при появлении любого модального окна стек кончался
и программа падала с «stack overflow». Найдено на невидимом экране в
отдельном префиксе Wine: падало и из напоминания о зависимостях, и из
меню «Файл → Зависимости». }
{$ENDIF}
{$IFDEF LCLWIN32}
var
Info: TMenuBarInfoRec;
WinRect, ItemRect, Fill: TRect;
DC: HDC;
Count: Integer;
Menu: HMENU;
{$ENDIF}
begin
{$IFDEF LCLWIN32}
if TailBusy then
Exit;
if (AForm = nil) or (not AForm.HandleAllocated) or (MenuBrush = 0) then
begin
TailNote := 'полоса: нет окна или кисти';
Exit;
end;
if (AForm.Menu = nil) or (not AForm.Menu.HandleAllocated) then
begin
TailNote := 'полоса: у меню нет дескриптора';
Exit;
end;
Menu := AForm.Menu.Handle;
FillChar(Info{%H-}, SizeOf(Info), 0);
Info.cbSize := SizeOf(Info);
if not SysGetMenuBarInfo(AForm.Handle, OBJID_MENU, 0, Info) then
begin
TailNote := 'полоса: GetMenuBarInfo отказала';
Exit;
end;
Count := SysGetMenuItemCount(Menu);
if Count <= 0 then
begin
TailNote := 'полоса: пунктов не найдено';
Exit;
end;
{ Правый край последнего названия. Всё, что правее, — ничьё, его и
закрашиваем. }
if not SysGetMenuItemRect(AForm.Handle, Menu, Count - 1, ItemRect{%H-}) then
begin
TailNote := 'полоса: GetMenuItemRect отказала';
Exit;
end;
if not SysGetWindowRect(AForm.Handle, WinRect{%H-}) then
begin
TailNote := 'полоса: GetWindowRect отказала';
Exit;
end;
{ Обе рамки система выдаёт в координатах экрана, а рисуем мы в
координатах окна. }
Fill.Left := ItemRect.Right - WinRect.Left;
Fill.Top := Info.rcBar.Top - WinRect.Top;
Fill.Right := Info.rcBar.Right - WinRect.Left;
Fill.Bottom := Info.rcBar.Bottom - WinRect.Top;
TailNote := Format(
'полоса: пунктов %d, полоса экрана %d,%d..%d,%d, край пункта %d, ' +
'окно %d,%d, красим %d,%d..%d,%d',
[Count, Info.rcBar.Left, Info.rcBar.Top, Info.rcBar.Right,
Info.rcBar.Bottom, ItemRect.Right, WinRect.Left, WinRect.Top,
Fill.Left, Fill.Top, Fill.Right, Fill.Bottom]);
if (Fill.Right <= Fill.Left) or (Fill.Bottom <= Fill.Top) then
begin
TailNote := TailNote + ' — красить нечего';
Exit;
end;
TailBusy := True;
try
DC := SysGetWindowDC(AForm.Handle);
if DC = 0 then
begin
TailNote := TailNote + ' — окно не дало холста';
Exit;
end;
try
SysFillRect(DC, Fill, MenuBrush);
finally
SysReleaseDC(AForm.Handle, DC);
end;
finally
TailBusy := False;
end;
{$ENDIF}
end;
procedure ApplyDarkMenu(AMenu: TMenu);
procedure Walk(AItem: TMenuItem);
var
I: Integer;
begin
AItem.OnDrawItem := @Painter.MenuDraw;
AItem.OnMeasureItem := @Painter.MenuMeasure;
for I := 0 to AItem.Count - 1 do
Walk(AItem.Items[I]);
end;
{$IFDEF WINDOWS}
var
Info: TMenuInfoRec;
{$ENDIF}
begin
if AMenu = nil then
Exit;
{$IFDEF LCLWIN32}
Walk(AMenu.Items);
{ Сами пункты мы уже рисуем, но полосу меню и подложку раскрытого списка
рисует Windows, и до неё событиями не дотянуться. Цвет подложки
задаётся кистью через SetMenuInfo — другого способа нет.
MIM_APPLYTOSUBMENUS распространяет её на все вложенные списки. }
{ Дескриптор здесь только читается, а не создаётся. Обращение к Handle
создаёт его принудительно, и у всплывающего меню, до показа которого
ещё далеко, это ломает само меню: оно перестаёт открываться.
Цена отказа — тонкая рамка вокруг раскрытого списка остаётся системной;
сами пункты рисуются нами и цвет берут.
Отсюда следует, что для полосы меню эту процедуру надо звать дважды:
до присваивания окну — чтобы расставить обработчики отрисовки, и после
— когда дескриптор уже есть и подложку можно задать. }
if AMenu.HandleAllocated then
begin
FillChar(Info{%H-}, SizeOf(Info), 0);
Info.cbSize := SizeOf(Info);
Info.fMask := MIM_BACKGROUND or MIM_APPLYTOSUBMENUS;
Info.hbrBack := MenuBrush;
SetMenuInfo(AMenu.Handle, Info);
{ Полоса меню живёт в неклиентской части окна и сама себя не
перерисовывает: без этого новая подложка появилась бы только при
следующем изменении размера окна. }
if (AMenu.Parent is TCustomForm) and
TCustomForm(AMenu.Parent).HandleAllocated then
SysDrawMenuBar(TCustomForm(AMenu.Parent).Handle);
end;
{$ENDIF}
end;
procedure ApplyDarkTheme(AComponent: TComponent);
var
I: Integer;
begin
if AComponent = nil then
Exit;
if AComponent is TControl then
ApplyToControl(TControl(AComponent));
{ Меню — не контрол и в дерево контролов не попадает, поэтому его надо
искать среди компонентов окна отдельно. }
for I := 0 to AComponent.ComponentCount - 1 do
if AComponent.Components[I] is TMenu then
ApplyDarkMenu(TMenu(AComponent.Components[I]));
end;
procedure HookNewForms;
begin
Screen.AddHandlerFormAdded(@Painter.FormAdded);
end;
{ Окно сообщения }
{ Высота надписи с переносом.
Считать по общей ширине текста нельзя: в сообщении бывают свои переводы
строк, и оценка «ширина поделить на ширину поля» их не видит — текст
обрезается снизу. Здесь каждая строка считается отдельно, а пустые
строки дают пустой ряд. }
function WrappedTextHeight(ACanvas: TCanvas; const AText: string;
AWidth: Integer): Integer;
var
Lines: TStringList;
I, Rows, RowH: Integer;
begin
RowH := ACanvas.TextHeight('Wg');
Rows := 0;
Lines := TStringList.Create;
try
Lines.Text := AText;
if Lines.Count = 0 then
Rows := 1;
for I := 0 to Lines.Count - 1 do
if Lines[I] = '' then
Inc(Rows)
else
Inc(Rows, 1 + (ACanvas.TextWidth(Lines[I]) div AWidth));
finally
Lines.Free;
end;
Result := Rows * RowH + RowH div 2;
end;
function ThemedChoiceDlg(const ACaption, AText: string;
const ACaptions: array of string): Integer;
const
MarginX = 20;
MarginY = 18;
ButtonH = 30;
ButtonGap = 10;
var
Dlg: TForm;
Lbl: TLabel;
Btn: TThemedButton;
I, X, TotalW, Wid: Integer;
Widths: array of Integer;
begin
Result := -1;
if Length(ACaptions) = 0 then
Exit;
Dlg := TForm.CreateNew(nil);
try
Dlg.Caption := ACaption;
Dlg.BorderStyle := bsDialog;
Dlg.Position := poScreenCenter;
Dlg.Color := ThemeWindow;
Dlg.Font.Color := ThemeText;
Lbl := TLabel.Create(Dlg);
Lbl.Parent := Dlg;
Lbl.Left := MarginX;
Lbl.Top := MarginY;
Lbl.WordWrap := True;
Lbl.AutoSize := False;
Lbl.Width := 520;
Lbl.Caption := AText;
Lbl.Font.Color := ThemeText;
Lbl.Transparent := True;
Lbl.Height := WrappedTextHeight(Dlg.Canvas, AText, Lbl.Width);
{ Ширина у каждой кнопки своя: надписи разной длины, а одинаковая
ширина по самой длинной растянула бы «ОК» на пол-окна. }
SetLength(Widths, Length(ACaptions));
TotalW := 0;
for I := 0 to High(ACaptions) do
begin
Wid := Dlg.Canvas.TextWidth(ACaptions[I]) + 32;
if Wid < 90 then
Wid := 90;
Widths[I] := Wid;
Inc(TotalW, Wid);
end;
Inc(TotalW, ButtonGap * High(ACaptions));
Dlg.ClientWidth := Lbl.Width + MarginX * 2;
if TotalW + MarginX * 2 > Dlg.ClientWidth then
Dlg.ClientWidth := TotalW + MarginX * 2;
Dlg.ClientHeight := MarginY + Lbl.Height + MarginY + ButtonH + MarginY;
X := (Dlg.ClientWidth - TotalW) div 2;
for I := 0 to High(ACaptions) do
begin
Btn := TThemedButton.Create(Dlg);
Btn.Parent := Dlg;
Btn.SetBounds(X, Dlg.ClientHeight - MarginY - ButtonH, Widths[I],
ButtonH);
Btn.Caption := ACaptions[I];
{ Номер кнопки возвращается через ModalResult: mrNone равен нулю,
поэтому считаем с единицы и вычитаем её обратно. }
Btn.ModalResult := I + 1;
Btn.Default := I = 0;
Btn.Cancel := I = High(ACaptions);
Inc(X, Widths[I] + ButtonGap);
end;
Result := Dlg.ShowModal - 1;
if Result > High(ACaptions) then
Result := -1;
finally
Dlg.Free;
end;
end;
function ThemedInputDlg(const ACaption, APrompt: string;
var AValue: string): Boolean;
var
Dlg: TForm;
Lbl: TLabel;
Edit: TEdit;
BtnOk, BtnCancel: TThemedButton;
begin
Result := False;
Dlg := TForm.CreateNew(nil);
try
Dlg.Caption := ACaption;
Dlg.BorderStyle := bsDialog;
Dlg.Position := poScreenCenter;
Dlg.ClientWidth := 360;
Dlg.ClientHeight := 130;
Lbl := TLabel.Create(Dlg);
Lbl.Parent := Dlg;
Lbl.SetBounds(16, 16, 328, 20);
Lbl.Caption := APrompt;
Edit := TEdit.Create(Dlg);
Edit.Parent := Dlg;
Edit.SetBounds(16, 40, 328, 26);
Edit.Text := AValue;
BtnOk := TThemedButton.Create(Dlg);
BtnOk.Parent := Dlg;
BtnOk.SetBounds(136, 84, 100, 30);
BtnOk.Caption := 'Готово';
BtnOk.ModalResult := mrOk;
BtnOk.Default := True;
BtnCancel := TThemedButton.Create(Dlg);
BtnCancel.Parent := Dlg;
BtnCancel.SetBounds(244, 84, 100, 30);
BtnCancel.Caption := 'Отмена';
BtnCancel.ModalResult := mrCancel;
BtnCancel.Cancel := True;
ApplyDarkTheme(Dlg);
Edit.SetFocus;
if Dlg.ShowModal <> mrOk then
Exit;
AValue := Trim(Edit.Text);
Result := AValue <> '';
finally
Dlg.Free;
end;
end;
function ThemedMessageDlg(const ACaption, AText: string;
ADlgType: TMsgDlgType; AButtons: TMsgDlgButtons;
AHelpCtx: Longint): TModalResult;
const
MarginX = 20;
MarginY = 18;
ButtonW = 120;
ButtonH = 30;
ButtonGap = 10;
var
Dlg: TForm;
Lbl: TLabel;
Btn: TThemedButton;
Order: array[0..3] of TModalResult = (mrOk, mrYes, mrNo, mrCancel);
Names: array[0..3] of string = ('ОК', 'Да', 'Нет', 'Отмена');
Flags: array[0..3] of TMsgDlgBtn = (mbOK, mbYes, mbNo, mbCancel);
I, Count, X, TotalW: Integer;
begin
Dlg := TForm.CreateNew(nil);
try
Dlg.Caption := ACaption;
Dlg.BorderStyle := bsDialog;
Dlg.Position := poScreenCenter;
Dlg.Color := ThemeWindow;
Dlg.Font.Color := ThemeText;
Count := 0;
for I := 0 to High(Flags) do
if Flags[I] in AButtons then
Inc(Count);
if Count = 0 then
Count := 1;
Lbl := TLabel.Create(Dlg);
Lbl.Parent := Dlg;
Lbl.Left := MarginX;
Lbl.Top := MarginY;
Lbl.WordWrap := True;
Lbl.AutoSize := False;
Lbl.Width := 520;
Lbl.Caption := AText;
Lbl.Font.Color := ThemeText;
Lbl.Transparent := True;
{ Высоту надписи считаем по её содержимому: сообщения бывают и в одну
строку, и в десять. }
Lbl.Height := WrappedTextHeight(Dlg.Canvas, AText, Lbl.Width);
TotalW := Count * ButtonW + (Count - 1) * ButtonGap;
Dlg.ClientWidth := Lbl.Width + MarginX * 2;
if TotalW + MarginX * 2 > Dlg.ClientWidth then
Dlg.ClientWidth := TotalW + MarginX * 2;
Dlg.ClientHeight := MarginY + Lbl.Height + MarginY + ButtonH + MarginY;
X := (Dlg.ClientWidth - TotalW) div 2;
for I := 0 to High(Flags) do
begin
if not (Flags[I] in AButtons) then
Continue;
Btn := TThemedButton.Create(Dlg);
Btn.Parent := Dlg;
Btn.SetBounds(X, Dlg.ClientHeight - MarginY - ButtonH, ButtonW, ButtonH);
Btn.Caption := Names[I];
Btn.ModalResult := Order[I];
Btn.Default := (Order[I] = mrOk) or (Order[I] = mrYes);
Btn.Cancel := (Order[I] = mrCancel) or
((Order[I] = mrNo) and not (mbCancel in AButtons));
Inc(X, ButtonW + ButtonGap);
end;
Result := Dlg.ShowModal;
finally
Dlg.Free;
end;
{ ADlgType пока ни на что не влияет: значков у нас нет, а разный цвет
рамки под сообщение об ошибке только отвлекает. Параметр оставлен,
чтобы вызовы читались как прежние. }
if ADlgType = mtCustom then ;
end;
initialization
Painter := TThemePainter.Create;
{$IFDEF WINDOWS}
MenuBrush := CreateSolidBrush(ThemePanel);
{$ENDIF}
{ Без этого форма не сможет создать нашу кнопку при чтении .lfm: имя
класса ищется в списке зарегистрированных. }
RegisterClass(TThemedButton);
finalization
Painter.Free;
IconCache.Free;
end.