david
47aaf11578
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@38 05c56307-c608-d34a-929d-697000501d7a
514 lines
18 KiB
ObjectPascal
514 lines
18 KiB
ObjectPascal
{********************************************************************}
|
|
{ }
|
|
{ Developer Express Visual Component Library }
|
|
{ ExpressSkins Library }
|
|
{ }
|
|
{ Copyright (c) 2006-2009 Developer Express Inc. }
|
|
{ ALL RIGHTS RESERVED }
|
|
{ }
|
|
{ The entire contents of this file is protected by U.S. and }
|
|
{ International Copyright Laws. Unauthorized reproduction, }
|
|
{ reverse-engineering, and distribution of all or any portion of }
|
|
{ the code contained in this file is strictly prohibited and may }
|
|
{ result in severe civil and criminal penalties and will be }
|
|
{ prosecuted to the maximum extent possible under the law. }
|
|
{ }
|
|
{ RESTRICTIONS }
|
|
{ }
|
|
{ THIS SOURCE CODE AND ALL RESULTING INTERMEDIATE FILES }
|
|
{ (DCU, OBJ, DLL, ETC.) ARE CONFIDENTIAL AND PROPRIETARY TRADE }
|
|
{ SECRETS OF DEVELOPER EXPRESS INC. THE REGISTERED DEVELOPER IS }
|
|
{ LICENSED TO DISTRIBUTE THE EXPRESSSKINS AND ALL ACCOMPANYING }
|
|
{ VCL CONTROLS AS PART OF AN EXECUTABLE PROGRAM ONLY. }
|
|
{ }
|
|
{ THE SOURCE CODE CONTAINED WITHIN THIS FILE AND ALL RELATED }
|
|
{ FILES OR ANY PORTION OF ITS CONTENTS SHALL AT NO TIME BE }
|
|
{ COPIED, TRANSFERRED, SOLD, DISTRIBUTED, OR OTHERWISE MADE }
|
|
{ AVAILABLE TO OTHER INDIVIDUALS WITHOUT EXPRESS WRITTEN CONSENT }
|
|
{ AND PERMISSION FROM DEVELOPER EXPRESS INC. }
|
|
{ }
|
|
{ CONSULT THE END USER LICENSE AGREEMENT FOR INFORMATION ON }
|
|
{ ADDITIONAL RESTRICTIONS. }
|
|
{ }
|
|
{********************************************************************}
|
|
|
|
unit dxSkinscxSchedulerPainter;
|
|
|
|
interface
|
|
|
|
uses
|
|
Windows, SysUtils, Classes, cxSchedulerCustomResourceView, cxDateUtils,
|
|
cxSchedulerCustomControls, dxSkinsCore, dxSkinsLookAndFeelPainter,
|
|
cxLookAndFeels, cxLookAndFeelPainters, cxGraphics, Graphics, cxGeometry,
|
|
cxSchedulerUtils, Math, cxScheduler, cxClasses;
|
|
|
|
type
|
|
|
|
{ TcxSchedulerSkinViewItemsPainter }
|
|
|
|
TcxSchedulerSkinViewItemsPainter = class(TcxSchedulerExternalPainter)
|
|
private
|
|
procedure DrawCaption(ACanvas: TcxCanvas; const ATextAreaBounds: TRect;
|
|
AAlignmentHorz: TAlignment; AAlignmentVert: TcxAlignmentVert;
|
|
AMultiLine, AShowEndEllipsis: Boolean; const AText: string;
|
|
AFont: TFont; ATextColor: TColor);
|
|
procedure DrawClippedElement(ACanvas: TcxCanvas; AElement: TdxSkinElement;
|
|
ABorders: TcxBorders; R: TRect);
|
|
function IsSkinAvalaible: Boolean;
|
|
function SkinInfo: TdxSkinLookAndFeelPainterInfo;
|
|
// Headers
|
|
procedure DrawHorizontalHeader(AViewInfo: TcxSchedulerDayHeaderCellViewInfo);
|
|
procedure DrawVerticalHeader(AViewInfo: TcxSchedulerDayHeaderCellViewInfo);
|
|
public
|
|
procedure DoCustomDrawButton(AViewInfo: TcxSchedulerMoreEventsButtonViewInfo;
|
|
var ADone: Boolean); override;
|
|
procedure DoCustomDrawDayHeader(AViewInfo: TcxSchedulerDayHeaderCellViewInfo;
|
|
var ADone: Boolean); override;
|
|
//
|
|
function NeedDrawSelection: Boolean; override;
|
|
function DrawCurrentTimeFirst: Boolean; override;
|
|
//
|
|
procedure DrawAllDayArea(ACanvas: TcxCanvas; const ARect: TRect;
|
|
ABorderColor: TColor; ABorders: TcxBorders; AViewParams: TcxViewParams;
|
|
ASelected: Boolean; ATransparent: Boolean); override;
|
|
procedure DrawCurrentTime(ACanvas: TcxCanvas; AColor: TColor; AStart: TDateTime;
|
|
ABounds: TRect); override;
|
|
procedure DrawEvent(AViewInfo: TcxSchedulerEventCellViewInfo); override;
|
|
procedure DrawTimeGridHeader(ACanvas: TcxCanvas; ABorderColor: TColor;
|
|
AViewInfo: TcxSchedulerCustomViewInfoItem; ABorders: TcxBorders;
|
|
ASelected: Boolean); override;
|
|
procedure DrawTimeLine(ACanvas: TcxCanvas; const ARect: TRect;
|
|
AViewParams: TcxViewParams; ABorders: TcxBorders;
|
|
ABorderColor: TColor); override;
|
|
procedure DrawTimeRulerBackground(ACanvas: TcxCanvas; const ARect: TRect;
|
|
ABorders: TcxBorders; AViewParams: TcxViewParams; ATransparent: Boolean); override;
|
|
procedure DrawShadow(ACanvas: TcxCanvas; const ARect, AVisibleRect: TRect;
|
|
ABuffer: TBitmap); override;
|
|
function MoreButtonSize(ASize: TSize): TSize; override;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses Types;
|
|
|
|
type
|
|
TcxCustomSchedulerAccess = class(TcxCustomScheduler);
|
|
|
|
const
|
|
cxHeaderStateToButtonState: array[Boolean] of TcxButtonState =
|
|
(cxbsNormal, cxbsHot);
|
|
|
|
{ TcxSchedulerSkinViewItemsPainter }
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawClippedElement(ACanvas: TcxCanvas;
|
|
AElement: TdxSkinElement; ABorders: TcxBorders; R: TRect);
|
|
begin
|
|
ACanvas.SaveClipRegion;
|
|
ACanvas.SetClipRegion(TcxRegion.Create(R), roIntersect);
|
|
try
|
|
with AElement.Image.Margins.Rect do
|
|
begin
|
|
if not (bLeft in ABorders) then
|
|
Dec(R.Left, Left);
|
|
if not (bTop in ABorders) then
|
|
Dec(R.Top, Top);
|
|
if not (bRight in ABorders) then
|
|
Inc(R.Right, Right);
|
|
if not (bBottom in ABorders) then
|
|
Inc(R.Bottom, Bottom);
|
|
end;
|
|
AElement.Draw(ACanvas.Handle, R);
|
|
finally
|
|
ACanvas.RestoreClipRegion;
|
|
end;
|
|
end;
|
|
|
|
function TcxSchedulerSkinViewItemsPainter.IsSkinAvalaible: Boolean;
|
|
begin
|
|
Result := Painter.InheritsFrom(TdxSkinLookAndFeelPainter);
|
|
end;
|
|
|
|
function TcxSchedulerSkinViewItemsPainter.SkinInfo: TdxSkinLookAndFeelPainterInfo;
|
|
begin
|
|
GetExtendedStylePainters.GetPainterData(Painter, Result);
|
|
end;
|
|
|
|
function TcxSchedulerSkinViewItemsPainter.MoreButtonSize(ASize: TSize): TSize;
|
|
begin
|
|
if IsSkinAvalaible and (SkinInfo.SchedulerMoreButton <> nil) then
|
|
Result := SkinInfo.SchedulerMoreButton.Size
|
|
else
|
|
Result := ASize;
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DoCustomDrawButton(
|
|
AViewInfo: TcxSchedulerMoreEventsButtonViewInfo; var ADone: Boolean);
|
|
begin
|
|
inherited DoCustomDrawButton(AViewInfo, ADone);
|
|
if not ADone and IsSkinAvalaible then
|
|
begin
|
|
ADone := SkinInfo.SchedulerMoreButton <> nil;
|
|
if ADone then
|
|
begin
|
|
with AViewInfo do
|
|
SkinInfo.SchedulerMoreButton.Draw(Canvas.Handle, Bounds, Byte(IsDown));
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawCaption(ACanvas: TcxCanvas;
|
|
const ATextAreaBounds: TRect; AAlignmentHorz: TAlignment;
|
|
AAlignmentVert: TcxAlignmentVert; AMultiLine, AShowEndEllipsis: Boolean;
|
|
const AText: string; AFont: TFont; ATextColor: TColor);
|
|
const
|
|
AlignmentsHorz: array[TAlignment] of Integer =
|
|
(cxAlignLeft, cxAlignRight, cxAlignHCenter);
|
|
AlignmentsVert: array[TcxAlignmentVert] of Integer =
|
|
(cxAlignTop, cxAlignBottom, cxAlignVCenter);
|
|
MultiLines: array[Boolean] of Integer = (cxSingleLine, cxWordBreak);
|
|
ShowEndEllipsises: array[Boolean] of Integer = (0, cxShowEndEllipsis);
|
|
begin
|
|
with ACanvas do
|
|
if AText <> '' then
|
|
begin
|
|
Brush.Style := bsClear;
|
|
Font := AFont;
|
|
Font.Color := ATextColor;
|
|
DrawText(AText, ATextAreaBounds, AlignmentsHorz[AAlignmentHorz] or
|
|
AlignmentsVert[AAlignmentVert] or MultiLines[AMultiLine] or
|
|
ShowEndEllipsises[AShowEndEllipsis]);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawHorizontalHeader(
|
|
AViewInfo: TcxSchedulerDayHeaderCellViewInfo);
|
|
begin
|
|
with AViewInfo do
|
|
begin
|
|
Painter.DrawHeader(Canvas, Bounds, TextRect, Neighbors, Borders,
|
|
cxHeaderStateToButtonState[Selected], AlignHorz, AlignVert, MultiLine,
|
|
ShowEndEllipsis, '', Font, TextColor, 0, nil);
|
|
DrawCaption(Canvas, TextRect, AlignHorz, AlignVert, MultiLine,
|
|
ShowEndEllipsis, DisplayText, Font, TextColor);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawVerticalHeader(
|
|
AViewInfo: TcxSchedulerDayHeaderCellViewInfo);
|
|
var
|
|
ABitmap: TcxBitmap;
|
|
R: TRect;
|
|
begin
|
|
with AViewInfo do
|
|
begin
|
|
ABitmap := TcxBitmap.CreateSize(Bounds);
|
|
try
|
|
ABitmap.cxCanvas.WindowOrg := Bounds.TopLeft;
|
|
cxBitBlt(ABitmap.Canvas.Handle, Canvas.Handle, ABitmap.ClientRect, Bounds.TopLeft, SRCCOPY);
|
|
ABitmap.Rotate(raPlus90, True);
|
|
|
|
R := ABitmap.ClientRect;
|
|
Painter.DrawHeader(ABitmap.cxCanvas, R, R, Neighbors, Borders, cxbsNormal,
|
|
taCenter, vaCenter, False, False, '', Font, TextColor, Color, nil);
|
|
|
|
if RotateText then
|
|
begin
|
|
ABitmap.Rotate(ra0, True);
|
|
DrawCaption(ABitmap.cxCanvas, R, AlignHorz, AlignVert, MultiLine,
|
|
ShowEndEllipsis, DisplayText, Font, TextColor);
|
|
ABitmap.Rotate(raPlus90);
|
|
end
|
|
else
|
|
begin
|
|
ABitmap.Rotate(raPlus90, True);
|
|
R.BottomRight := cxPoint(R.Bottom, R.Right);
|
|
DrawCaption(ABitmap.cxCanvas, R, AlignHorz, AlignVert, MultiLine,
|
|
ShowEndEllipsis, DisplayText, Font, TextColor);
|
|
end;
|
|
|
|
cxBitBlt(Canvas.Handle, ABitmap.Canvas.Handle, Bounds, cxNullPoint, SRCCOPY);
|
|
finally
|
|
ABitmap.Free;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DoCustomDrawDayHeader(
|
|
AViewInfo: TcxSchedulerDayHeaderCellViewInfo; var ADone: Boolean);
|
|
begin
|
|
inherited DoCustomDrawDayHeader(AViewInfo, ADone);
|
|
ADone := IsSkinAvalaible;
|
|
if ADone then
|
|
with AViewInfo do
|
|
if RotateHeader or RotateText then
|
|
DrawVerticalHeader(AViewInfo)
|
|
else
|
|
DrawHorizontalHeader(AViewInfo);
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawAllDayArea(ACanvas: TcxCanvas;
|
|
const ARect: TRect; ABorderColor: TColor; ABorders: TcxBorders;
|
|
AViewParams: TcxViewParams; ASelected: Boolean; ATransparent: Boolean);
|
|
var
|
|
ADoCustomDraw: Boolean;
|
|
AElement: TdxSkinElement;
|
|
begin
|
|
if IsSkinAvalaible then
|
|
begin
|
|
AElement := SkinInfo.SchedulerAllDayArea[ASelected];
|
|
ADoCustomDraw := AElement = nil;
|
|
if not ADoCustomDraw then
|
|
DrawClippedElement(ACanvas, AElement, ABorders, ARect);
|
|
end
|
|
else
|
|
ADoCustomDraw := True;
|
|
|
|
if ADoCustomDraw then
|
|
inherited DrawAllDayArea(ACanvas, ARect, ABorderColor, ABorders, AViewParams,
|
|
ASelected, ATransparent);
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawCurrentTime(ACanvas: TcxCanvas;
|
|
AColor: TColor; AStart: TDateTime; ABounds: TRect);
|
|
var
|
|
ADoCustomDraw: Boolean;
|
|
AElement: TdxSkinElement;
|
|
ANow: TDateTime;
|
|
Y, I: Integer;
|
|
begin
|
|
if IsSkinAvalaible then
|
|
begin
|
|
AElement := SkinInfo.SchedulerCurrentTimeIndicator;
|
|
ADoCustomDraw := AElement = nil;
|
|
if not ADoCustomDraw then
|
|
begin
|
|
ANow := TimeOf(Now) - TimeOf(AStart);
|
|
if (ANow < 0) or (ANow >= HourToTime) then Exit;
|
|
Y := Trunc(ABounds.Top + (ANow * cxRectHeight(ABounds)) / HourToTime);
|
|
Dec(ABounds.Right);
|
|
Inc(ABounds.Left, 5);
|
|
with AElement.Image.Size do
|
|
ABounds := cxRectSetTop(ABounds, Y - cy div 2, cy);
|
|
for I := 0 to 1 do
|
|
AElement.Draw(ACanvas.Handle, ABounds, I);
|
|
end;
|
|
end
|
|
else
|
|
ADoCustomDraw := True;
|
|
|
|
if ADoCustomDraw then
|
|
inherited DrawCurrentTime(ACanvas, AColor, AStart, ABounds);
|
|
end;
|
|
|
|
function TcxSchedulerSkinViewItemsPainter.NeedDrawSelection: Boolean;
|
|
begin
|
|
Result := not IsSkinAvalaible;
|
|
end;
|
|
|
|
function TcxSchedulerSkinViewItemsPainter.DrawCurrentTimeFirst: Boolean;
|
|
begin
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawEvent(
|
|
AViewInfo: TcxSchedulerEventCellViewInfo);
|
|
const
|
|
AShadowSize = 4;
|
|
ASelectedFlags: array[Boolean] of TdxSkinElementState = (esNormal, esHot);
|
|
var
|
|
ADone: Boolean;
|
|
AElement: TdxSkinElement;
|
|
AMask: TdxSkinElement;
|
|
ASkinInfo: TdxSkinLookAndFeelPainterInfo;
|
|
|
|
function CheckRect(const ARect: TRect): TRect;
|
|
begin
|
|
if AViewInfo.Selected and (ASkinInfo.SchedulerAppointmentBorderSize <> nil) then
|
|
begin
|
|
with ASkinInfo.SchedulerAppointmentBorderSize do
|
|
begin
|
|
Result := Rect(ARect.Left, ARect.Top - Value, ARect.Right + Value,
|
|
ARect.Bottom + Value);
|
|
if IsRectEmpty(AViewInfo.TimeLineRect) then
|
|
Dec(Result.Left, Value)
|
|
else
|
|
Dec(Result.Left, cxTimeLineWidth);
|
|
end;
|
|
end
|
|
else
|
|
Result := ARect;
|
|
end;
|
|
|
|
procedure DrawShadowLine(const AShadow: TdxSkinElement; const ARect: TRect);
|
|
begin
|
|
if AShadow <> nil then
|
|
AShadow.Draw(AViewInfo.Canvas.Handle, ARect);
|
|
end;
|
|
|
|
procedure DrawShadows(ASkinInfo: TdxSkinLookAndFeelPainterInfo);
|
|
begin
|
|
with AViewInfo do
|
|
if EventViewData.DrawShadows and (EventViewData.Bitmap <> nil) and
|
|
not Hidden and not Selected and ShowTimeLine then
|
|
begin
|
|
DrawShadowLine(ASkinInfo.SchedulerAppointmentShadow[False],
|
|
Rect(Bounds.Left + AShadowSize, Bounds.Bottom - AShadowSize,
|
|
Bounds.Right + AShadowSize, Bounds.Bottom + AShadowSize));
|
|
DrawShadowLine(ASkinInfo.SchedulerAppointmentShadow[True],
|
|
Rect(Bounds.Right - AShadowSize, Bounds.Top + AShadowSize,
|
|
Bounds.Right + AShadowSize, Bounds.Bottom - AShadowSize));
|
|
end;
|
|
end;
|
|
|
|
procedure DrawLabeledEvent(ALabelColor: TColor);
|
|
const
|
|
AImageIndexs: array[Boolean] of Integer = (1, 0);
|
|
var
|
|
ABitmap, AMaskBmp, ASourceBmp: TcxBitmap;
|
|
R: TRect;
|
|
begin
|
|
if AMask = nil then Exit;
|
|
R := AViewInfo.Bounds;
|
|
OffsetRect(R, -R.Left, -R.Top);
|
|
AMaskBmp := TcxBitmap.CreateSize(R, pf32bit);
|
|
ASourceBmp := TcxBitmap.CreateSize(R, pf32bit);
|
|
try
|
|
ASourceBmp.Canvas.Brush.Color := ALabelColor;
|
|
ASourceBmp.Canvas.FillRect(R);
|
|
AMask.Draw(AMaskBmp.Canvas.Handle, R, AImageIndexs[IsRectEmpty(AViewInfo.TimeLineRect)]);
|
|
ABitmap := TcxBitmap.CreateSize(R, pf32bit);
|
|
try
|
|
cxBitBlt(AMaskBmp.Canvas.Handle, AMaskBmp.Canvas.Handle, AMaskBmp.ClientRect, cxNullPoint, NOTSRCCOPY);
|
|
cxBitBlt(ABitmap.Canvas.Handle, AMaskBmp.Canvas.Handle, ABitmap.ClientRect, cxNullPoint, SRCCOPY);
|
|
cxBitBlt(ABitmap.Canvas.Handle, ASourceBmp.Canvas.Handle, ABitmap.ClientRect, cxNullPoint, SRCERASE);
|
|
cxBitBlt(AViewInfo.Canvas.Handle, AMaskBmp.Canvas.Handle, AViewInfo.Bounds, cxNullPoint, SRCAND);
|
|
cxBitBlt(AViewInfo.Canvas.Handle, ABitmap.Canvas.Handle, AViewInfo.Bounds, cxNullPoint, SRCINVERT);
|
|
finally
|
|
ABitmap.Free;
|
|
end;
|
|
finally
|
|
AMaskBmp.Free;
|
|
ASourceBmp.Free;
|
|
end;
|
|
end;
|
|
|
|
function GetSeparatorColor(ABorderColor: TdxSkinColor): TColor;
|
|
begin
|
|
Result := clDefault;
|
|
if ABorderColor <> nil then
|
|
Result := ABorderColor.Value;
|
|
if (Result = clNone) or (Result = clDefault) then
|
|
Result := AViewInfo.SeparatorColor;
|
|
end;
|
|
|
|
begin
|
|
ASkinInfo := SkinInfo;
|
|
ADone := ASkinInfo <> nil;
|
|
if ADone then
|
|
begin
|
|
with ASkinInfo do
|
|
begin
|
|
AElement := SchedulerAppointment[IsRectEmpty(AViewInfo.TimeLineRect)];
|
|
AMask := SchedulerAppointmentMask;
|
|
end;
|
|
ADone := (AElement <> nil) and (AMask <> nil);
|
|
if ADone then
|
|
with AViewInfo do
|
|
begin
|
|
Canvas.SaveClipRegion;
|
|
try
|
|
Canvas.SetClipRegion(TcxRegion.Create(
|
|
cxRectInflate(CheckRect(ClipRect), 0, 0, AShadowSize, AShadowSize)),
|
|
roSet);
|
|
Canvas.ExcludeClipRect(TimeLineRect);
|
|
DrawShadows(ASkinInfo);
|
|
SeparatorColor := GetSeparatorColor(ASkinInfo.SchedulerAppointmentBorder);
|
|
AElement.Draw(Canvas.Handle, CheckRect(Bounds), 0, ASelectedFlags[Selected]);
|
|
if Event.LabelColor <> clDefault then
|
|
DrawLabeledEvent(Event.LabelColor);
|
|
Transparent := True;
|
|
finally
|
|
Canvas.RestoreClipRegion;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if not ADone then
|
|
inherited DrawEvent(AViewInfo);
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawTimeGridHeader(ACanvas: TcxCanvas;
|
|
ABorderColor: TColor; AViewInfo: TcxSchedulerCustomViewInfoItem;
|
|
ABorders: TcxBorders; ASelected: Boolean);
|
|
var
|
|
ADoCustomDraw: Boolean;
|
|
AElement: TdxSkinElement;
|
|
begin
|
|
ADoCustomDraw := True;
|
|
if IsSkinAvalaible then
|
|
begin
|
|
AElement := SkinInfo.SchedulerTimeGridHeader[ASelected];
|
|
ADoCustomDraw := AElement = nil;
|
|
if not ADoCustomDraw then
|
|
with AViewInfo do
|
|
DrawClippedElement(ACanvas, AElement, ABorders, Bounds);
|
|
end;
|
|
if ADoCustomDraw then
|
|
inherited DrawTimeGridHeader(ACanvas, ABorderColor, AViewInfo, ABorders,
|
|
ASelected);
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawTimeLine(ACanvas: TcxCanvas;
|
|
const ARect: TRect; AViewParams: TcxViewParams; ABorders: TcxBorders;
|
|
ABorderColor: TColor);
|
|
var
|
|
ADoCustomDraw: Boolean;
|
|
AElement: TdxSkinElement;
|
|
begin
|
|
ADoCustomDraw := True;
|
|
if IsSkinAvalaible then
|
|
begin
|
|
AElement := SkinInfo.SchedulerTimeLine;
|
|
ADoCustomDraw := AElement = nil;
|
|
if not ADoCustomDraw then
|
|
DrawClippedElement(ACanvas, AElement, ABorders, ARect);
|
|
end;
|
|
if ADoCustomDraw then
|
|
inherited DrawTimeLine(ACanvas, ARect, AViewParams, ABorders, ABorderColor);
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawTimeRulerBackground(
|
|
ACanvas: TcxCanvas; const ARect: TRect; ABorders: TcxBorders;
|
|
AViewParams: TcxViewParams; ATransparent: Boolean);
|
|
var
|
|
ADoCustomDraw: Boolean;
|
|
AElement: TdxSkinElement;
|
|
begin
|
|
ADoCustomDraw := True;
|
|
if IsSkinAvalaible then
|
|
begin
|
|
AElement := SkinInfo.SchedulerTimeRuler;
|
|
ADoCustomDraw := AElement = nil;
|
|
if not ADoCustomDraw then
|
|
DrawClippedElement(ACanvas, AElement, ABorders, ARect);
|
|
end;
|
|
if ADoCustomDraw then
|
|
inherited DrawTimeRulerBackground(ACanvas, ARect, ABorders, AViewParams,
|
|
ATransparent);
|
|
end;
|
|
|
|
procedure TcxSchedulerSkinViewItemsPainter.DrawShadow(ACanvas: TcxCanvas;
|
|
const ARect, AVisibleRect: TRect; ABuffer: TBitmap);
|
|
begin
|
|
if not IsSkinAvalaible then
|
|
inherited DrawShadow(ACanvas, ARect, AVisibleRect, ABuffer);
|
|
end;
|
|
|
|
initialization
|
|
ExternalPainterClass := TcxSchedulerSkinViewItemsPainter;
|
|
|
|
finalization
|
|
ExternalPainterClass := TcxSchedulerExternalPainter;
|
|
|
|
end.
|