Как избежать перерисовки компонентов при наложении в Delphi и Pascal

Delphi , Графика и Игры , Компоненты и Графика

При разработке графических приложений в Delphi и Pascal, особенно при использовании библиотеки BGRABitmap, разработчики часто сталкиваются с проблемами производительности при наложении компонентов. В форумной дискуссии пользователь hedgehog поднимал вопрос о скорости рендеринга графиков из 10000 точек, а также упоминал проблемы с перерисовкой при изменении размеров формы.

Одним из важных аспектов, который был затронут пользователем SandyG, является проблема перерисовки компонентов при их наложении друг на друга. Это может значительно влиять на производительность, особенно при сложной графике или анимациях.

Проблема перерисовки наложенных компонентов

Когда один компонент перекрывает другой, Windows может инициировать перерисовку всех затронутых областей. Это происходит из-за того, что система пытается обеспечить корректное отображение всех элементов интерфейса. Особенно это заметно при использовании сложных графических компонентов, таких как пользовательские элементы управления или компоненты с интенсивной отрисовкой.

Решения для оптимизации перерисовки

1. Использование Double Buffering

Самый простой способ избежать мерцания и избыточной перерисовки - включить двойную буферизацию:

type
  TMyGraphicControl = class(TGraphicControl)
  private
    FDoubleBuffered: Boolean;
  protected
    procedure Paint; override;
  public
    constructor Create(AOwner: TComponent); override;
  end;

constructor TMyGraphicControl.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FDoubleBuffered := True;
  ControlStyle := ControlStyle + [csOpaque];
end;

procedure TMyGraphicControl.Paint;
var
  Buffer: TBitmap;
begin
  if FDoubleBuffered then
  begin
    Buffer := TBitmap.Create;
    try
      Buffer.SetSize(Width, Height);
      // Отрисовка на буфере
      DrawOnCanvas(Buffer.Canvas);
      // Перенос на экран
      Canvas.Draw(0, 0, Buffer);
    finally
      Buffer.Free;
    end;
  end
  else
    inherited Paint;
end;

2. Оптимизация через Invalidate и Update

Вместо постоянной перерисовки, используйте селективную перерисовку только измененных областей:

type
  TChartControl = class(TCustomControl)
  private
    FDirtyRect: TRect;
    FNeedsFullRedraw: Boolean;
  public
    procedure InvalidateRect(ARect: TRect);
    procedure Paint; override;
  end;

procedure TChartControl.InvalidateRect(ARect: TRect);
begin
  if IsRectEmpty(FDirtyRect) then
    FDirtyRect := ARect
  else
    UnionRect(FDirtyRect, FDirtyRect, ARect);
  inherited InvalidateRect(FDirtyRect, False);
end;

procedure TChartControl.Paint;
begin
  if FNeedsFullRedraw or IsRectEmpty(FDirtyRect) then
  begin
    // Полная перерисовка
    DrawFullChart(Canvas);
    FDirtyRect := Rect(0, 0, 0, 0);
    FNeedsFullRedraw := False;
  end
  else
  begin
    // Частичная перерисовка
    Canvas.Lock;
    try
      DrawPartialChart(Canvas, FDirtyRect);
    finally
      Canvas.Unlock;
    end;
    FDirtyRect := Rect(0, 0, 0, 0);
  end;
end;

3. Использование ParentBackground и ControlStyle

Настройка стиля контроля может значительно улучшить производительность:

type
  TOptimizedControl = class(TCustomControl)
  public
    constructor Create(AOwner: TComponent); override;
  end;

constructor TOptimizedControl.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  // Отключаем автоматическую перерисовку фона
  ControlStyle := ControlStyle - [csParentBackground] + [csOpaque, csReplicatable];
  // Устанавливаем цвет фона явно
  Color := clWhite;
  // Отключаем двойную буферизацию по умолчанию (если используется своя)
  DoubleBuffered := True;
end;

4. Работа с Z-порядком компонентов

Правильное управление порядком наложения компонентов:

procedure TForm1.OptimizeComponentOrder;
begin
  // Перемещаем часто перерисовываемые компоненты наверх
  ChartControl.BringToFront;

  // Группируем статические компоненты
  Panel1.SendToBack;

  // Используем родительские панели для группировки
  GroupBox1.ParentBackground := False;
  GroupBox1.DoubleBuffered := True;
end;

5. Асинхронная отрисовка

Для сложных графиков реализуйте асинхронную отрисовку:

type
  TAsyncChartControl = class(TCustomControl)
  private
    FRenderThread: TThread;
    FBitmap: TBitmap;
    FRendering: Boolean;
  public
    procedure StartRender;
    procedure Paint; override;
  end;

type
  TRenderThread = class(TThread)
  private
    FControl: TAsyncChartControl;
    FData: array of TPointF;
  protected
    procedure Execute; override;
  public
    constructor Create(AControl: TAsyncChartControl; const AData: array of TPointF);
  end;

procedure TAsyncChartControl.StartRender;
begin
  if FRendering then Exit;

  FRendering := True;
  FRenderThread := TRenderThread.Create(Self, FChartData);
  FRenderThread.FreeOnTerminate := True;
  FRenderThread.Start;
end;

procedure TRenderThread.Execute;
var
  Buffer: TBitmap;
  i: Integer;
begin
  Buffer := TBitmap.Create;
  try
    Buffer.SetSize(FControl.Width, FControl.Height);

    // Отрисовка на буфере
    Buffer.Canvas.Pen.Color := clBlack;
    Buffer.Canvas.MoveTo(Round(FData[0].X), Round(FData[0].Y));
    for i := 1 to High(FData) do
      Buffer.Canvas.LineTo(Round(FData[i].X), Round(FData[i].Y));

    // Передача результата в основной поток
    Synchronize(
      procedure
      begin
        FControl.FBitmap.Assign(Buffer);
        FControl.FRendering := False;
        FControl.Invalidate;
      end
    );
  finally
    Buffer.Free;
  end;
end;

Практические рекомендации

1. Минимизация перерисовки при изменении размеров

type
  TResizableChart = class(TCustomControl)
  private
    FResizing: Boolean;
  protected
    procedure WMSize(var Message: TWMSize); message WM_SIZE;
    procedure WMEraseBkgnd(var Message: TWMEraseBkgnd); message WM_ERASEBKGND;
  public
    procedure Paint; override;
  end;

procedure TResizableChart.WMSize(var Message: TWMSize);
begin
  FResizing := True;
  inherited;
  FResizing := False;
  // Откладываем перерисовку до завершения изменения размера
end;

procedure TResizableChart.WMEraseBkgnd(var Message: TWMEraseBkgnd);
begin
  // Отключаем стирание фона для уменьшения мерцания
  Message.Result := 1;
end;

procedure TResizableChart.Paint;
begin
  if FResizing then Exit; // Не перерисовываем во время изменения размера

  inherited Paint;
  // Основная отрисовка
end;

2. Использование BGRABitmap для оптимизации

Как показано в исходной дискуссии, использование BGRABitmap с оптимизациями может значительно улучшить производительность:

procedure TChartForm.DrawOptimizedChart(Bitmap: TBGRABitmap);
var
  arr: array of TPoint;
  i, n: Integer;
begin
  n := Length(FPoints);
  SetLength(arr, n);

  // Предварительный расчет координат
  for i := 0 to n-1 do
    arr[i] := Point(
      Round(FBorder + (FPoints[i].x - Fx0) * Fkx),
      Round(FBorder + (1.5 - FPoints[i].y) * Fky)
    );

  // Использование быстрых целочисленных функций
  Bitmap.DrawPolyLine(arr, BGRABlack, True);

  // Оптимизация соединений
  Bitmap.Canvas2D.lineJoinLCL := pjsBevel;
end;

3. Кэширование статических данных

type
  TCachedChart = class(TCustomControl)
  private
    FCacheBitmap: TBitmap;
    FCacheValid: Boolean;
    FDataChanged: Boolean;
  public
    procedure InvalidateData;
    procedure Paint; override;
  end;

procedure TCachedChart.InvalidateData;
begin
  FDataChanged := True;
  FCacheValid := False;
  Invalidate;
end;

procedure TCachedChart.Paint;
begin
  if not FCacheValid or FDataChanged then
  begin
    if not Assigned(FCacheBitmap) then
      FCacheBitmap := TBitmap.Create;

    FCacheBitmap.SetSize(Width, Height);
    DrawChartToCanvas(FCacheBitmap.Canvas);
    FCacheValid := True;
    FDataChanged := False;
  end;

  Canvas.Draw(0, 0, FCacheBitmap);
end;

Заключение

Оптимизация перерисовки компонентов при наложении в Delphi требует комплексного подхода. Ключевые моменты:

1. Используйте двойную буферизацию для предотвращения мерцания
2. Минимизируйте область перерисовки с помощью селективной инвалидации
3. Оптимизируйте Z-порядок компонентов
4. Используйте кэширование для статических данных
5. Реализуйте асинхронную отрисовку для сложных графиков

Эти подходы, в сочетании с оптимизациями BGRABitmap, описанными в исходной дискуссии, позволят создавать высокопроизводительные графические приложения с плавной анимацией и быстрым откликом на действия пользователя.

Создано по материалам из источника по ссылке.

Контекст описывает проблему перерисовки компонентов при их наложении в Delphi и Pascal, а также предлагает несколько методов оптимизации производительности графических приложений, включая двойную буферизацию, селективную перерисовку, управление Z-порядко

Комментарии и вопросы

Получайте свежие новости и обновления по Object Pascal, Delphi и Lazarus прямо в свой смартфон. Подпишитесь на наш Telegram-канал delphi_kansoftware и будьте в курсе последних тенденций в разработке под Linux, Windows, Android и iOS

:: Главная :: Компоненты и Графика ::