customdrawdemomain.cpp

delphi的的三方控件

	ALines->Add(R.Left, R.Top, R.Bottom - R.Top, 1, AColor);
	ALines->Add(R.Right - 1, R.Top, R.Right - R.Left, 1, AColor);
	ALines->Add(R.Left, R.Bottom - 1, R.Right - R.Left, 1, AColor);
}

bool __fastcall TCustomDrawDemoMainForm::DrawCellItem(TcxItemCustomDrawInfo* AItem, TcxCanvas* ACanvas,
	  TcxRowValueInfo* AValueInfo, TcxvgPainter* APainter, TObject* Sender)
{
  TcxStyle *AStyle;     
  int i;
  ((TcxVerticalGrid*)Sender)->ViewInfo->LinesInfo->Clear();
  for (i = 0; i < ((TcxVerticalGrid*)Sender)->ViewInfo->ViewRects->BandRects->Count; i++) {
	AddRectLines(((TcxVerticalGrid*)Sender)->ViewInfo->LinesInfo,
	  ((TcxVerticalGrid*)Sender)->ViewInfo->ViewRects->BandRects->Rects[i],
	  ((TcxVerticalGrid*)Sender)->ViewInfo->BandBorderColor);
  }
  AValueInfo->Transparent = (AValueInfo->ViewParams.Bitmap != NULL) &&
	(!AValueInfo->ViewParams.Bitmap->Empty);
  if (AItem->DrawingStyle == cdsDefaultDrawing){
	APainter->DrawRowValueCell(AValueInfo);
	DrawCellsLines(ACanvas, ((TcxVerticalGrid*)Sender)->OptionsView->GridLineColor,
	  AValueInfo->BoundsRect);
	DrawRightLine(ACanvas, ((TcxVerticalGrid*)Sender)->OptionsView->GridLineColor,
	  AValueInfo->BoundsRect);
	return true;
  }
  bool Result;
  if (AItem->DrawingStyle == cdsDependsOnData)
  {
	if (VarToStr(cxDBVerticalGridCustomer->Properties->Values[AValueInfo->RecordIndex]) == "Y")
      AStyle = CustomDrawDemoDataDM->stCustomer;
    else
      AStyle = CustomDrawDemoDataDM->stNoCustomer;
    ACanvas->Brush->Color = AStyle->Color;
    ACanvas->FillRect(AValueInfo->VisibleRect, NULL, False);
    OwnerDrawText(ACanvas, AValueInfo, AStyle->TextColor, AStyle->Font);
    DrawCellsLines(ACanvas, ((TcxVerticalGrid*)Sender)->OptionsView->GridLineColor,
      AValueInfo->BoundsRect);
    Result = true;
  }
  else{
    Result = DrawItem(AItem, ACanvas, cxRectInflate(AValueInfo->BoundsRect, 0, 0, 1, 1),
      (int)AItem->ColorScheme > 1);
    if (AItem->OwnerTextDraw)
      Result = Result & OwnerDrawText(ACanvas, AValueInfo, clGray, AItem->Font);
    else{
      AValueInfo->Transparent = true;
      Result = false;
    }
  }
  return Result;
}

bool __fastcall TCustomDrawDemoMainForm::OwnerDrawText(TcxCanvas* ACanvas,
  TcxRowValueInfo* AValueInfo, TColor ALineColor, TFont *AFont)
{
  bool Result = false;
  ACanvas->Pen->Color = ALineColor;
  ACanvas->Brush->Style = bsClear;
  ACanvas->Font = AFont;
  TRect ARect = cxRectInflate(AValueInfo->BoundsRect, -1, 0, 0, -1);
  ACanvas->Canvas->Rectangle(ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
  if (dynamic_cast<TcxCustomCheckBoxViewInfo*>(AValueInfo->EditViewInfo) != 0){
    AValueInfo->Transparent = true;
  }
  else
    if (dynamic_cast<TcxCustomTextEditViewInfo*>(AValueInfo->EditViewInfo) != 0){
      ACanvas->DrawTexT(((TcxCustomTextEditViewInfo*)AValueInfo->EditViewInfo)->Text,
        cxRectInflate(AValueInfo->BoundsRect, -2, -2), 0, true);
      Result = true;
    }
  return Result;
}

//---------------------------------------------------------------------------

bool __fastcall TCustomDrawDemoMainForm::DrawHeaderItem(TcxItemCustomDrawInfo* AItem, TcxCanvas* ACanvas,
      TcxCustomRowHeaderInfo* AHeaderViewInfo, TcxvgPainter* APainter, TObject* Sender)
{
  bool Result;
  TRect ARect;
  ((TcxVerticalGrid*)Sender)->ViewInfo->LinesInfo->Clear();
  if ((AItem->DrawingStyle == cdsDefaultDrawing)){
    APainter->DrawRowHeader(AHeaderViewInfo);
    DrawIndents(AHeaderViewInfo, cdaHeader, ACanvas, AHeaderViewInfo->ViewParams,
      APainter, AHeaderViewInfo->RowIndents);
    Result = true;
  }
  else{
    ARect = cxRectInflate(AHeaderViewInfo->HeaderRect, 0, 0, 1, 1);
    ARect.Left = AHeaderViewInfo->RowIndents->Items[0]->Bounds.Left;
    DrawItem(FCustomDrawInfo->Items[cdaHeader], ACanvas, ARect, (int)AItem->ColorScheme > 1);
    AHeaderViewInfo->Transparent = true;
    Result = false;
  }

  TcxViewParams ACategoryViewParams;
  ACategoryViewParams.Bitmap = cxDBVerticalGrid->Styles->Category->Bitmap;
  ACategoryViewParams.Color = cxDBVerticalGrid->Styles->Category->Color;
  DrawIndents(AHeaderViewInfo, cdaCategory, ACanvas, ACategoryViewParams,
    APainter, AHeaderViewInfo->CategoryIndents);
  if ((FCustomDrawInfo->Items[cdaHeader]->DrawingStyle == cdsDefaultDrawing) ||
     (FCustomDrawInfo->Items[cdaCategory]->DrawingStyle == cdsDefaultDrawing)){
    DrawRightLine(ACanvas, ((TcxVerticalGrid*)Sender)->OptionsView->GridLineColor,
      AHeaderViewInfo->HeaderRect);
    if (cxRectIsNull(AHeaderViewInfo->HeaderCellsRect))
      ARect =
         AHeaderViewInfo->RowIndents->Items[AHeaderViewInfo->RowIndents->Count - 1]->Bounds;
    else
      ARect = AHeaderViewInfo->HeaderCellsRect;
    TLineInfos ALineInfo = GetAdditionalLines((TcxDBVerticalGrid*)Sender, AHeaderViewInfo);
    DrawDefaultLines(ACanvas, ((TcxVerticalGrid*)Sender)->OptionsView->GridLineColor,
      AHeaderViewInfo, ARect, ALineInfo);
  }
  AHeaderViewInfo->LinesInfo->Clear();
  return Result;
}
//---------------------------------------------------------------------------

void __fastcall TCustomDrawDemoMainForm::DrawIndents(TcxCustomRowHeaderInfo* AHeaderViewInfo,
  TCustomDrawArea ACustomDrawArea, TcxCanvas* ACanvas, TcxViewParams AViewParams,
  TcxvgPainter* APainter, TIndentInfoList* AIndentInfoList)
{
  if (FCustomDrawInfo->Items[ACustomDrawArea]->DrawingStyle == cdsDefaultDrawing)
    for (int I = 0; I < AIndentInfoList->Count; I++){
      TIndentInfo *AInfo = AIndentInfoList->Items[I];
      APainter->Canvas->Brush->Color = AViewParams.Color;
      APainter->FillRect(cxRectInflate(AInfo->Bounds, 0, 0, 0, 1), AInfo->ViewParams.Bitmap);
    }
  else
  for (int I = 0; I < AIndentInfoList->Count; I++)
    DrawItem(FCustomDrawInfo->Items[ACustomDrawArea], ACanvas,
      cxRectInflate(AIndentInfoList->Items[I]->Bounds, 0, 0, 0, 1),  true);
}
//---------------------------------------------------------------------------

void __fastcall TCustomDrawDemoMainForm::DrawCellsLines(TcxCanvas* ACanvas,
  TColor AColor, TRect ARect)
{
  ACanvas->Brush->Color = AColor;
  ACanvas->FillRect(cxRectBounds(ARect.Left, ARect.Top - 1, ARect.Right - ARect.Left + 1, 1), NULL, False);
  ACanvas->FillRect(cxRectBounds(ARect.Left, ARect.Bottom, ARect.Right - ARect.Left + 1, 1), NULL, False);
}
//---------------------------------------------------------------------------

TLineInfos __fastcall TCustomDrawDemoMainForm::GetAdditionalLines(TcxDBVerticalGrid* Sender,
  TcxCustomRowHeaderInfo* AHeaderViewInfo)
{
  TLineInfos Result = TLineInfos();
  if (Sender->LayoutStyle != lsBandsView) return Result;
  for (int I = 0; I < Sender->ViewInfo->BandInfo->Count; I++)
    if (Sender->ViewInfo->BandInfo->Items[I].FirstRow == AHeaderViewInfo->Row){
      Result << liTop;
      if (Sender->ViewInfo->BandInfo->Items[I].RowsCount == 1)
        Result << liBottom;
    }
  for (int I = 0; I < Sender->ViewInfo->BandInfo->Count; I++)
    if ((Sender->PrevVisibleRow(Sender->ViewInfo->BandInfo->Items[I].FirstRow)
        == AHeaderViewInfo->Row) || (Sender->LastVisibleRow() == AHeaderViewInfo->Row)){
      Result << liBottom;
      break;
    }
  return Result;
}
//---------------------------------------------------------------------------

void __fastcall TCustomDrawDemoMainForm::DrawDefaultLines(TcxCanvas* ACanvas, TColor AColor,
      TcxCustomRowHeaderInfo* AHeaderViewInfo, TRect ARect, TLineInfos ALineInfos)
{
  FillRects(ALineInfos, AHeaderViewInfo, ACanvas, AColor);
  DrawCellsLines(ACanvas, AColor, ARect);
}
//---------------------------------------------------------------------------

void __fastcall TCustomDrawDemoMainForm::DrawRightLine(TcxCanvas* ACanvas, TColor AColor,
      TRect ARect)
{
  ACanvas->Brush->Color = AColor;
  ACanvas->FillRect(cxRectBounds(ARect.Right, ARect.Top, 1, ARect.Bottom - ARect.Top), NULL, False);
}
//---------------------------------------------------------------------------

bool __fastcall TCustomDrawDemoMainForm::DrawItem(TcxItemCustomDrawInfo *AItem, TcxCanvas *ACanvas,
  const TRect &R, bool AHorizontal)
{
  switch(AItem->DrawingStyle) {
    case cdsBkImage:
       ACanvas->FillRect(R, AItem->Bitmap, False); break;
    case cdsGradient:
      DrawGradient(ACanvas->Canvas, R,
        (TColor)ColorScheme[(int)AItem->ColorScheme][1],
        (TColor)ColorScheme[(int)AItem->ColorScheme][0],
        40, AHorizontal);
     break;
  };
  return (AItem->DrawingStyle != cdsDefaultDrawing);
}
//---------------------------------------------------------------------------

bool  __fastcall TCustomDrawDemoMainForm::DrawBackgroundItem(TcxItemCustomDrawInfo* AItem,
  TcxCanvas* ACanvas, const TRect R, TcxViewParams AViewParams, TObject* Sender)
{
  bool Result = false;
  if (AItem->DrawingStyle != cdsDefaultDrawing)
    Result = DrawItem(AItem, ACanvas, R, (int)AItem->ColorScheme > 1);
  return Result;
}
//---------------------------------------------------------------------------

bool TCustomDrawDemoMainForm::DrawCategoryItem(TcxItemCustomDrawInfo* AItem, TcxCanvas* ACanvas,
    TcxCategoryRowHeaderInfo* ACategoryViewInfo, TcxvgPainter* APainter, TObject* Sender)
{
  bool Result;
  ((TcxVerticalGrid*)Sender)->ViewInfo->LinesInfo->Clear();
  if (ACategoryViewInfo->RowIndents->Count > 0) {
    if (FCustomDrawInfo->Items[cdaHeader]->DrawingStyle != cdsDefaultDrawing) {
      int ADelta = ACategoryViewInfo->RowIndents->Items[0]->Bounds.Left - ACategoryViewInfo->HeaderRect.Left;
      TRect ARect = ACategoryViewInfo->HeaderRect;
      ARect.Left = ACategoryViewInfo->RowIndents->Items[0]->Bounds.Left;
      ARect.Right = ARect.Left + (((TcxVerticalGrid*)Sender)->ViewInfo->FullHeaderWidth - ADelta);
      DrawItem(FCustomDrawInfo->Items[cdaHeader], ACanvas, cxRectInflate(ARect, 0, 0, 0, 1), (int)FCustomDrawInfo->Items[cdaHeader]->ColorScheme > 1);
    }
    else {
      TcxViewParams ARowViewParams;
      ARowViewParams.Bitmap = cxDBVerticalGrid->Styles->Header->Bitmap;
      ARowViewParams.Color = cxDBVerticalGrid->Styles->Header->Color;
      DrawIndents(ACategoryViewInfo, cdaHeader, ACanvas, ARowViewParams, APainter, ACategoryViewInfo->RowIndents);
    }
  }
  if (AItem->DrawingStyle == cdsDefaultDrawing) {
    APainter->DrawRowHeader(ACategoryViewInfo);
    APainter->DrawRowHeaderCell(ACategoryViewInfo->CaptionsInfo->Items[0], false);
    Result = true;
  }
  else {
    DrawItem(AItem, ACanvas, cxRectInflate(ACategoryViewInfo->HeaderCellsRect, 0, 0, 1, 1), Integer(AItem->ColorScheme) > 1);
    ACategoryViewInfo->Transparent = true;
    Result = false;
  }
  DrawIndents(ACategoryViewInfo, cdaCategory, ACanvas, ACategoryViewInfo->ViewParams,
    APainter, ACategoryViewInfo->CategoryIndents);

  if ((FCustomDrawInfo->Items[cdaHeader]->DrawingStyle == cdsDefaultDrawing) ||
    (FCustomDrawInfo->Items[cdaCategory]->DrawingStyle == cdsDefaultDrawing)) {
    DrawRightLine(ACanvas, ((TcxVerticalGrid*)Sender)->OptionsView->GridLineColor, ACategoryViewInfo->HeaderRect);
    TLineInfos ALineInfo = GetAdditionalLines((TcxDBVerticalGrid*)Sender, ACategoryViewInfo);
    DrawDefaultLines(ACanvas, ((TcxVerticalGrid*)Sender)->OptionsView->GridLineColor, ACategoryViewInfo,
      ACategoryViewInfo->HeaderCellsRect, ALineInfo);
  }
  ACategoryViewInfo->LinesInfo->Clear();
  return Result;    
}
//---------------------------------------------------------------------------