Две беды у всех кнопок нижней полосы. Всплывающая подсказка появлялась прямо поверх кнопки, о которой рассказывает, и перехватывала щелчок: нажать кнопку было нельзя. Подсказка переехала в строку состояния — она в той же полосе, ничего не закрывает и меняется сразу после щелчка, не дожидаясь нового наведения. Строка состояния теперь занимает всё свободное место справа, пока рядом не показан ход работы, а самые длинные подсказки укорочены: раньше их обрезало на полуслове. Второй щелчок подряд виджетсет отдавал как двойной, и кнопка его не видела: быстрая очередь щелчков срабатывала через раз. У кнопки убран csDoubleClicks, а на случай, если двойной всё же дойдёт, он считается за обычный. Проверено: tests/lfmcheck, раздел «Кнопки нижней панели», и tests/buttonclicks.sh мышью на невидимом экране — по всем шести переключателям очереди из 1-5 щелчков отрабатываются полностью.
1548 lines
54 KiB
ObjectPascal
1548 lines
54 KiB
ObjectPascal
{
|
||
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.
|