ITS_OP/SRC/PLUGIN/00.FRAME/PlugInChart/PlugInChartF.cpp

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

#include <vcl.h>
#include "ITSSkinF.h"
#include "ITSUtilF.h"
#include "ITSDbF.h"
#include "AppGlobalF.h"
#include "ITSLangTransF.h"
#pragma hdrstop

#include "PlugInChartF.h"
#include "PlugInSetChartF.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "Chart"
#pragma link "DBChart"
#pragma link "Series"
#pragma link "TeEngine"
#pragma link "TeeProcs"
#pragma link "cxButtons"
#pragma link "cxCheckBox"
#pragma link "cxContainer"
#pragma link "cxControls"
#pragma link "cxDropDownEdit"
#pragma link "cxEdit"
#pragma link "cxGraphics"
#pragma link "cxImageComboBox"
#pragma link "cxLabel"
#pragma link "cxLookAndFeelPainters"
#pragma link "cxLookAndFeels"
#pragma link "cxMaskEdit"
#pragma link "cxSplitter"
#pragma link "cxTextEdit"
#pragma link "dxSkinBlack"
#pragma link "dxSkinBlue"
#pragma link "dxSkinsCore"
#pragma resource "*.dfm"
//TPlugInChart *PlugInChart = NULL;
//---------------------------------------------------------------------------
__fastcall TPlugInChart::TPlugInChart(TComponent* Owner)
    : TForm(Owner)
{
    LangTrans->Translate(this, ITSDb_GetConnection());
    ITSSkin_Load(this);
}
//---------------------------------------------------------------------------

/*
 * form을 보여줄때 호출되는 event 메서드이다.
 *  arguments
 *      Sender : event handler 객체
 *  return
 *      void
 */
void __fastcall TPlugInChart::FormShow(TObject *Sender)
{
    // form 초기화
    FormInit();
    DbChart->SetFocus();
    DbChart->Title->Visible = false;
    //DbChart->Title->Text->Strings[0] = "";
    DbChart->Title->Caption = "";
    //Caption = m_sCaption;
}
//---------------------------------------------------------------------------

/*
 * form 초기화
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::FormInit()
{
    CbChartKind->ItemIndex = 0;

    //LstLegend->Style = Stdctrls::lbOwnerDrawFixed;
    DbChart->View3D = false;
    //ClearChart();
    //LstLegend->Refresh();
}
//---------------------------------------------------------------------------

/*
 * Form을 닫을때 호출되는 event 메서드
 *  arguments
 *      Sender : event handler 객체
 *      Action : TCloseAction 객체
 *  return
 *      void
 */

void __fastcall TPlugInChart::FormClose(TObject *Sender, TCloseAction &Action)
{
    //상속한 PlugIn 폼에서는 CommClose() 함수를 override 하여 사용하자.
    CommClose();    
    Action = caFree; 
}
//---------------------------------------------------------------------------

/*
 * 닫기버튼 이나 x버튼 클릭시 공통으로 처리하는 로직이들어간다..
 * Form과 DataModule class를 delete시킨다.
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::CommClose()
{
    try
    {
        Clear();
    }
    catch(...)
    {
    }
}
//---------------------------------------------------------------------------

/*
 * 공통으로 처리되지 않는 스킨을 변경한다.
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::LoadLocalSkin()
{
    /*
    *  스킨 변경
    */
	//FrmResource->LoadSkinTitle(this, NULL, NULL, NULL);
	//FrmResource->LoadSkinButton(BtnChkAll, BtnReverse, BtnProperty, NULL, NULL, NULL, NULL, NULL);

#if 0
	switch (SkinType)
	{
	case 1:
		Splitter->Color = (TColor)0x00FDE8D7;
		break;
	case 2:
		Splitter->Color = (TColor)0x003B69F0;
		break;
	case 3:
		Splitter->Color = (TColor)0x00BAA181;
		break;
	case 4:
		Splitter->Color = (TColor)0x00F8C6A4;
		break;
	case 5:
		Splitter->Color = (TColor)0x00A3D8C9;
		break;
	case 6:
		Splitter->Color = (TColor)0x004A189C;
		break;
	default:
		Splitter->Color = (TColor)0x003B69F0;//0x00F5F5F5;
		break;
	}
#endif
}
//---------------------------------------------------------------------------

/*
 * Legend check all button click event
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::BtnChkAllClick(TObject *Sender)
{
    // Check all
    LstLegend->Items->BeginUpdate();
    for (int ii = 0; ii < LstLegend->Count; ii++)
    {
        LstLegend->Checked[ii] = true;
    }
    LstLegend->Items->EndUpdate();

    BtnApplyClick(NULL);
}
//---------------------------------------------------------------------------

/*
 * Legend Reverse button click event
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::BtnReverseClick(TObject *Sender)
{
    // Reverse check
    LstLegend->Items->BeginUpdate();
    for (int ii = 0; ii < LstLegend->Count; ii++)
    {
        LstLegend->Checked[ii] = !LstLegend->Checked[ii];
    }
    LstLegend->Items->EndUpdate();

    BtnApplyClick(NULL);
}
//---------------------------------------------------------------------------

/*
 * Legend Property button click event
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::BtnPropertyClick(TObject *Sender)
{
    // Legend property setting
    LstLegendDblClick(NULL);
}
//---------------------------------------------------------------------------

/*
 * Chart property apply
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::BtnApplyClick(TObject *Sender)
{
    // Apply
    int nRes = 0;

    LstLegend->Items->BeginUpdate();
    for (int ii = 0; ii < LstLegend->Count; ii++)
    {
        nRes += SetActive(ii);
    }
    if (nRes)
    {
        DbChart->LeftAxis->Maximum = GetActiveMaxY();
    }
    LstLegend->Items->EndUpdate();
}
//---------------------------------------------------------------------------

/*
 * Chart 3d on/off
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::Chk3DClick(TObject *Sender)
{
    DbChart->Locked = true;
    try
    {
        // DbChart->Aspect->Orthogonal = false;
        DbChart->View3D = Chk3D->Checked;
    }
    __finally
    {
        DbChart->Locked = false;
        DbChart->Update();
    }

    BtnApplyClick(NULL);
}
//---------------------------------------------------------------------------

/*
 * Chart Label value display on/off
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::ChkDispValueClick(TObject *Sender)
{
    try
    {
        DbChart->Locked = true;
        int nSeries = DbChart->SeriesCount();
        for (int ii = 0; ii < nSeries; ii++)
        {
            DbChart->Series[ii]->Marks->Style = smsValue;
            DbChart->Series[ii]->Marks->Visible = !DbChart->Series[ii]->Marks->Visible;
        }
    }
    __finally
    {
        DbChart->Locked = false;
    }
#if 0
    // Label value display on/off
    SeriesItem* pSrsItem;
    TChartSeries *pSeries;

    //DbChart->Series->BeginUpdate();
    for (int ii = 0; ii < LstLegend->Count; ii++)
    {
        pSrsItem = (SeriesItem*)LstLegend->Items->Objects[ii];
        if (pSrsItem == NULL) continue;

        pSeries = (TChartSeries*)pSrsItem->ChartSeries;
        if (pSeries == NULL) continue;

        pSeries->Marks->Style = smsValue;
        pSeries->Marks->Visible = ChkDispValue->Checked;
    }
    //DbChart->Series->EndUpdate();
#endif
}
//---------------------------------------------------------------------------

/*
 * Chart kind select
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::CbChartKindPropertiesEditValueChanged(TObject *Sender)
{
    //ChangeSeries(DbChart, (SeriesType)CbChartKind->ItemIndex, DbChart->SeriesCount());
    SeriesItem   *pSrsItem;
    TChartSeries *pSeries;
    SeriesType   SrsTypeNew;

    SrsTypeNew = (SeriesType)CbChartKind->ItemIndex;

    try
    {
        DbChart->Locked = true;
        LstLegend->Items->BeginUpdate();
        for (int ii = 0; ii < LstLegend->Count; ii++)
        {
            pSrsItem = (SeriesItem*)LstLegend->Items->Objects[ii];
            if (pSrsItem == NULL) continue;

            pSeries = (TChartSeries*)pSrsItem->ChartSeries;
            if (pSeries == NULL) continue;

            ChangeSeriesItem(ii, SrsTypeNew);
        }
    }
    __finally
    {
        LstLegend->Items->EndUpdate();
        DbChart->Locked = false;
    }
}
//---------------------------------------------------------------------------

/*
 * DBChart 의 모양을 변경한다.
 *  arguments
 *      pDBChart           - DBChart 컴포넌트
 *      pSeriesIndex       - 챠트유형 콤보에서 선택한 유형 index
 *  return
 *      void
 */
void __fastcall TPlugInChart::ChangeSeriesItem(int nIdx, SeriesType ToSrsType)
{
    SeriesItem* pSrsItem;
    TChartSeries *pSeries;
    TMetaClass* NewType;

    pSrsItem = (SeriesItem*)LstLegend->Items->Objects[nIdx];
    if (pSrsItem == NULL) return;
    if (pSrsItem->SrsType == ToSrsType) return;

    pSeries = (TChartSeries*)pSrsItem->ChartSeries;
    switch (ToSrsType)
    {
    case ctpLine:            NewType = __classid(TLineSeries);      break;
    case ctpBar:             NewType = __classid(TBarSeries);       break;
    case ctpHorizontal_Bar:  NewType = __classid(THorizBarSeries);  break;
    case ctpArea:            NewType = __classid(TAreaSeries);      break;
    case ctpPoint:           NewType = __classid(TPointSeries);     break;
    case ctpPie:             NewType = __classid(TPieSeries);       break;
    case ctpFast_Line:       NewType = __classid(TFastLineSeries);  break;
    case ctpHorizontal_Line: NewType = __classid(THorizLineSeries); break;
    case ctpHorizontal_Area: NewType = __classid(THorizAreaSeries); break;
    case ctpShape:           NewType = __classid(TChartShape);      break;
    case ctpGantt:           NewType = __classid(TGanttSeries);     break;
    case ctpArrow:           NewType = __classid(TArrowSeries);     break;
    case ctpBubble:          NewType = __classid(TBubbleSeries);    break;
    default : return;
    }
    ChangeSeriesType(pSeries, NewType);
    pSrsItem->ChartSeries = (void*)pSeries;
    pSrsItem->SrsType = ToSrsType;

    if (ToSrsType == ctpLine)
    {
        ((TLineSeries*)pSeries)->Pointer->Style    = psRectangle;
        ((TLineSeries*)pSeries)->Pointer->VertSize = 4;
        ((TLineSeries*)pSeries)->Pointer->Visible  = true;
    }
    else if(ToSrsType == ctpPie)
    {
        ((TPieSeries*)pSeries)->Marks->Style   = smsValue;
        ((TPieSeries*)pSeries)->Circled        = true;
        //((TPieSeries*)pSeries)->Marks->Visible = ChkDispValue->Checked;
    }
    pSeries->Marks->Style = smsValue;
    pSeries->Marks->Visible = ChkDispValue->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TPlugInChart::ChangeSeries(TDBChart *pDBChart, SeriesType nSeriesTp, int nSeriesCount)
{
    TChartSeries *pChartSeries;

    if (pDBChart == NULL) return;

    for (int ii = 0; ii < nSeriesCount; ii++)
    {
        try
        {
            pChartSeries = pDBChart->Series[ii];

            switch(nSeriesTp)
            {
            case ctpLine:            ChangeSeriesType(pChartSeries, __classid(TLineSeries)); break;
            case ctpBar:             ChangeSeriesType(pChartSeries, __classid(TBarSeries)); break;
            case ctpHorizontal_Bar:  ChangeSeriesType(pChartSeries, __classid(THorizBarSeries)); break;
            case ctpArea:            ChangeSeriesType(pChartSeries, __classid(TAreaSeries)); break;
            case ctpPoint:           ChangeSeriesType(pChartSeries, __classid(TPointSeries)); break;
            case ctpPie:             ChangeSeriesType(pChartSeries, __classid(TPieSeries)); break;
            case ctpFast_Line:       ChangeSeriesType(pChartSeries, __classid(TFastLineSeries)); break;
            case ctpHorizontal_Line: ChangeSeriesType(pChartSeries, __classid(THorizLineSeries)); break;
            case ctpHorizontal_Area: ChangeSeriesType(pChartSeries, __classid(THorizAreaSeries)); break;
            case ctpShape:           ChangeSeriesType(pChartSeries, __classid(TChartShape)); break;
            case ctpGantt:           ChangeSeriesType(pChartSeries, __classid(TGanttSeries)); break;
            case ctpArrow:           ChangeSeriesType(pChartSeries, __classid(TArrowSeries)); break;
            case ctpBubble:          ChangeSeriesType(pChartSeries, __classid(TBubbleSeries)); break;
            }
        }
        catch(...)
        {
        }
    }
}
//---------------------------------------------------------------------------

/*
 * 조회 전 챠트를 Clear 한다.
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::ClearChart()
{
    try
    {
        for (int ii = 0; ii < DbChart->SeriesCount(); ii++)
        {
            DbChart->Series[ii]->Clear();
        }
    }
    catch(...)
    {
    }
}
//---------------------------------------------------------------------------

/*
 * Check on/off legend
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::LstLegendClickCheck(TObject *Sender)
{
    // Check on/off legend
    int nIdx = LstLegend->ItemIndex;
    LstLegend->Items->BeginUpdate();
    if (SetActive(nIdx))
    {
        DbChart->LeftAxis->Maximum = GetActiveMaxY();
    }
    LstLegend->Items->EndUpdate();
}
//---------------------------------------------------------------------------

/*
 * double legend list
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::LstLegendDblClick(TObject *Sender)
{
    // double legend list
    SeriesItem   *pSrsItem;
    TChartSeries *pSeries;
    SeriesType    SrsTypeNew;
    int           idx;
    String        sMsgTitle, sMsgString;

    idx = LstLegend->ItemIndex;

    if(idx < 0)
    {
        sMsgString = lblSel->Caption;//"아이템을 선택하세요.";
        MessageDlg(sMsgString.c_str(), mtInformation, TMsgDlgButtons() << mbOK, NULL);
        return;
    }

    pSrsItem = (SeriesItem *)LstLegend->Items->Objects[idx];
    pSeries = (TChartSeries*)pSrsItem->ChartSeries;

    try
    {
        TPlugInSetChart *PlugInSetChart = new TPlugInSetChart(Parent);

        PlugInSetChart->EdtItemNm->Text = pSeries->Title;
        PlugInSetChart->ChkVisible->Checked = pSeries->Active;
        PlugInSetChart->PnlItemColor->Color = pSeries->SeriesColor;
        PlugInSetChart->m_nSrsType = pSrsItem->SrsType;
        if (PlugInSetChart->ShowModal() == mrOk)
        {
            Application->ProcessMessages();
            pSeries->Active = PlugInSetChart->ChkVisible->Checked;
            LstLegend->Checked[idx] = pSeries->Active;
            pSeries->SeriesColor = PlugInSetChart->PnlItemColor->Color;

            SrsTypeNew = (SeriesType)PlugInSetChart->m_nSrsType;
            if (pSrsItem->SrsType != SrsTypeNew)
            {
                ChangeSeriesItem(idx, SrsTypeNew);
                pSeries = (TChartSeries*)pSrsItem->ChartSeries;
            }
            LstLegend->Repaint();
        }
        delete PlugInSetChart;
        PlugInSetChart = NULL;
    }
    catch(...)
    {
    }
#if 0
    pSrsItem = (SeriesItem*)lstItems->Items->Objects[idx];

    FrmSTC_Grph_Prop->lblSrsTitle->Caption = pSeries->Title;
    FrmSTC_Grph_Prop->chxSrsActive->Checked = pSeries->Active;
    FrmSTC_Grph_Prop->lblSrsColor->Color = pSeries->SeriesColor;
    FrmSTC_Grph_Prop->SetSrsTypeBtn(pSrsItem->SrsType);

    if(FrmSTC_Grph_Prop->ShowModal() == mrOk)
    {
        Application->ProcessMessages();
        pSeries->Active = FrmSTC_Grph_Prop->chxSrsActive->Checked;
        lstItems->Checked[idx] = pSeries->Active;
        pSeries->SeriesColor = FrmSTC_Grph_Prop->lblSrsColor->Color;

        SrsTypeNew = FrmSTC_Grph_Prop->FSrsType;
        if(pSrsItem->SrsType != SrsTypeNew)
        {
          ChangeSeriesItem(idx, SrsTypeNew);
          pSeries = (TChartSeries*)pSrsItem->ChartSeries;
        }
        lstItems->Repaint();
    }
    delete FrmSTC_Grph_Prop;
    FrmSTC_Grph_Prop = NULL;
#endif
}
//---------------------------------------------------------------------------

/*
 * Draw legend items
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::LstLegendDrawItem(TWinControl *Control, int Index, TRect &Rect, TOwnerDrawState State)
{
    TCanvas* pCvs = LstLegend->Canvas;
    int Offset = 2, iBarWidth = 12;
    TColor brColor;
    TRect rct;
    SeriesType SrsType;

    brColor = pCvs->Brush->Color;
    pCvs->Pen->Color = brColor;
    pCvs->Rectangle(Rect);

    // Chart Type Rect
    pCvs->Brush->Color = clWhite;
    rct = Rect;
    rct.Top = Rect.Top + 1;
    rct.Right = Rect.Left + iBarWidth;
    rct.Bottom = Rect.Bottom - 1;
    pCvs->Rectangle(rct);

    DrawSeriesType(GetSeriesType(Index), pCvs, rct);

    // Chart Color Rect
    Rect.Left += iBarWidth + Offset;
    pCvs->Pen->Color = TColor(0x00646464);
    pCvs->Brush->Color = GetSeriesColor(Index);
    pCvs->Rectangle(Rect.Left, Rect.Top + 1,
                    Rect.Left + iBarWidth, Rect.Bottom - 1);

    // Chart Label
    pCvs->Brush->Color = brColor;
    Rect.Left += iBarWidth + Offset;
    pCvs->TextOut(Rect.Left, Rect.Top, LstLegend->Items->Strings[Index]);
}
//---------------------------------------------------------------------------

/*
 * Get Chart type
 *
 *  arguments
 *  return
 *      void
 */
SeriesType __fastcall TPlugInChart::GetSeriesType(int nIdx)
{
    SeriesItem* pSrsItem;

    pSrsItem = (SeriesItem*)LstLegend->Items->Objects[nIdx];

    return pSrsItem->SrsType;
}
//---------------------------------------------------------------------------

/*
 * Get Chart serice color
 *
 *  arguments
 *  return
 *      void
 */
TColor __fastcall TPlugInChart::GetSeriesColor(int nIdx)
{
    SeriesItem   *pSrsItem;
    TChartSeries *pSeries;

    pSrsItem = (SeriesItem*)LstLegend->Items->Objects[nIdx];
    pSeries  = (TChartSeries*)pSrsItem->ChartSeries;

    return pSeries->SeriesColor;
}
//---------------------------------------------------------------------------

/*
 * Draw chart type on legend list
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::DrawSeriesType(SeriesType SrsType, TCanvas* pCvs, TRect Rct)
{

  int x, y;

  x = Rct.Left, y = Rct.Bottom;
  pCvs->Pen->Color = clBlack;

  switch(SrsType)
  {
/*
    ctpLine = 0,
    ctpBar,
    ctpHorizontal_Bar,
    ctpArea,
    ctpPoint,
    ctpFastLine,
*/
    case ctpLine : y -= (Rct.Bottom - Rct.Top) / 3;
                   pCvs->MoveTo(x, y);
                   x += (Rct.Right - Rct.Left) / 3;
                   y -= (Rct.Bottom - Rct.Top) / 2;
                   pCvs->LineTo(x, y);
                   x += (Rct.Right - Rct.Left) / 4;
                   y += (Rct.Bottom - Rct.Top) / 2;
                   pCvs->LineTo(x, y);
                   x  = Rct.Right;
                   y -= (Rct.Bottom - Rct.Top) / 2;
                   pCvs->LineTo(x, y);
                   break;
    case ctpBar  : Rct.Top += 8;
                   Rct.Left += 3; Rct.Right = Rct.Left + 1;
                   pCvs->Rectangle(Rct);
                   Rct.Top -= 2;
                   Rct.Left = Rct.Right + 2; Rct.Right = Rct.Left + 1;
                   pCvs->Rectangle(Rct);
                   Rct.Top -= 4;
                   Rct.Left = Rct.Right + 2; Rct.Right = Rct.Left + 1;
                   pCvs->Rectangle(Rct);
                   break;
    case ctpArea : Rct.Top += 1; Rct.Bottom -= 1;
                   pCvs->Ellipse(Rct);
                   pCvs->Pie(Rct.Left, Rct.Top, Rct.Right, Rct.Bottom,
                             Rct.Left, Rct.Top, Rct.Right, Rct.Top + 3);
                   pCvs->Pie(Rct.Left, Rct.Top, Rct.Right, Rct.Bottom,
                             Rct.Left, Rct.Top, Rct.Left + 4, Rct.Bottom);
                   break;
    case ctpPoint: Rct.Top += 8;
                   Rct.Left += 3; Rct.Right = Rct.Left + 2;
                   pCvs->Rectangle(Rct);
                   //Rct.Top -= 5;
                   Rct.Left = Rct.Right + 2; Rct.Right = Rct.Left + 2;
                   pCvs->Rectangle(Rct);
                   break;
    default : break;
  }
}
//---------------------------------------------------------------------------

/*
 * Active show/hide legend
 *
 *  arguments
 *  return
 *      void
 */
bool __fastcall TPlugInChart::SetActive(int nIdx)
{
    SeriesItem* pSrsItem;
    TChartSeries *pSeries;

    pSrsItem = (SeriesItem*)LstLegend->Items->Objects[nIdx];
    if (pSrsItem == NULL) return false;

    pSeries = (TChartSeries*)pSrsItem->ChartSeries;
    if (pSeries == NULL) return false;

    if (pSeries->Active != LstLegend->Checked[nIdx])
    {
        pSeries->Active = LstLegend->Checked[nIdx];
        return true;
    }

    return false;
}
//---------------------------------------------------------------------------

/*
 * Get active chart Y axis value
 *
 *  arguments
 *  return
 *      void
 */
double __fastcall TPlugInChart::GetActiveMaxY(void)
{
    SeriesItem   *pSrsItem;
    TChartSeries *pSeries;
    double dMaxY = 0.0;

    for (int ii = 0; ii < LstLegend->Count; ii++)
    {
        pSrsItem = (SeriesItem*)LstLegend->Items->Objects[ii];
        if (pSrsItem == NULL) continue;

        pSeries = (TChartSeries*)pSrsItem->ChartSeries;
        if (pSeries == NULL) continue;

        if (pSeries->Active == false) continue;
        if(dMaxY < pSeries->YValues->MaxValue)
           dMaxY = pSeries->YValues->MaxValue;
    }

    double calMaxY = dMaxY + (dMaxY / 20.);
    return calMaxY;// > DbChart->LeftAxis->Minimum ? calMaxY : DbChart->LeftAxis->Minimum;
}
//---------------------------------------------------------------------------

/*
 * 차트 정보 설정
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::SetChartInfo(String sTitle, String sAxisX, String sAxisY)
{
    DbChart->Title->Visible = false;
    DbChart->BottomAxis->Title->Visible = false;
    DbChart->LeftAxis->Title->Visible = false;

    if (sTitle != "")
    {
        DbChart->Title->Caption = sTitle;
        DbChart->Title->Visible = true;
    }

    if (sAxisY != "")
    {
        DbChart->BottomAxis->Title->Caption = sAxisX;
        DbChart->BottomAxis->LabelStyle = talText;
        DbChart->BottomAxis->LabelsAngle = 0;
        DbChart->BottomAxis->Title->Visible = true;
    }
    if (sAxisX != "")
    {
        DbChart->LeftAxis->Title->Caption = sAxisY;
        DbChart->LeftAxis->Title->Visible = true;
    }
}
//---------------------------------------------------------------------------

/*
 * 차트 그리기전에 반드시 호출
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::BeginDraw(String sTitle/*=""*/, String sAxisX/*=""*/, String sAxisY/*=""*/)
{
    ClearData();

    SetChartInfo(sTitle, sAxisX, sAxisY);
}
//---------------------------------------------------------------------------

/*
 * 메모리를 해제한다.
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::Clear()
{
    ClearData();
}
//---------------------------------------------------------------------------

/*
 * 메모리를 해제한다.
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::ClearData()
{
    try
    {
        LstLegend->Items->BeginUpdate();
        try
        {
            for (int ii = 0; ii < LstLegend->Count; ii++)
            {
                SeriesItem *pSrsItem = (SeriesItem *)LstLegend->Items->Objects[ii];
                if (pSrsItem == NULL) continue;
                delete pSrsItem;
            }
            LstLegend->Items->Clear();

            ClearChart();
            DbChart->FreeAllSeries();
        }
        catch(...)
        {
        }
    }
    __finally
    {
        LstLegend->Items->EndUpdate();
    }
}
//---------------------------------------------------------------------------

/*
 * 해당되지 않는 컬럼을 클리어한다.
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::DrawChart1(TcxGridDBTableView *TvList, int nAxisY, int nStColIdx, int nTotColIdx/*=-1*/)
{
    int             ii, jj, kk;
    SeriesType      SrsType;
    TColor          clSrsColor;
    TChartSeries    *pSeries;
    TClientDataSet  *pCDS = NULL;


    TCursor cOldCursor= Screen->Cursor;
    try
    {
        Screen->Cursor = crHourGlass;

        LstLegend->Items->BeginUpdate();

        TvList->BeginUpdate();
        pCDS = (TClientDataSet *)TvList->DataController->DataSource->DataSet;
        if (pCDS)
        {
            pCDS->DisableControls();
        }

        int nCols = TvList->ColumnCount;
        int nRows = TvList->ViewData->RecordCount;

        SrsType = GetChartType();

        /*
        *  합계 표출
        */
        kk = 0;
        if (nTotColIdx >= 0)
        {
            clSrsColor = GetDefaultColor(kk++);
            if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
            if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);
            pSeries = AddSeriesItem(lblSoge->Caption/*"소계"*/, SrsType, clSrsColor, true);
            if (pSeries)
            {
                for (jj = nStColIdx; jj < nCols; jj++)
                {
                    if (!TvList->Columns[jj]->Visible)
                    {
                        break;
                    }
                    String sAxisX = TvList->Columns[jj]->Caption;
                    nTotColIdx = TvList->DataController->Summary->FooterSummaryItems->IndexOfItemLink(TvList->Columns[jj]);
                    if (!VarIsNull(TvList->DataController->Summary->FooterSummaryValues[nTotColIdx]))
                    {
                        double dValX = 0;
                        try {
                            dValX = (double)TvList->DataController->Summary->FooterSummaryValues[nTotColIdx];
                        } catch(...) { dValX = 0; }

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
        }

        for (ii = 0; ii < nRows; ii++, kk++)
        {
            try
            {
                TcxCustomGridRow* ARow = TvList->ViewData->Rows[ii];
                clSrsColor = GetDefaultColor(kk);
                if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
                if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);

                String sTitle = "";
                if (!VarIsNull(sTitle = ARow->Values[nAxisY]))
                {
                    sTitle = ARow->Values[nAxisY];
                }

                pSeries = AddSeriesItem(sTitle, SrsType, clSrsColor, true);
                if (pSeries)
                {
                    for (jj = nStColIdx; jj < nCols; jj++)
                    {
                        if (!TvList->Columns[jj]->Visible)
                        {
                            break;
                        }
                        String sAxisX = TvList->Columns[jj]->Caption;
                        double dValX = 0;

                        if (!VarIsNull(ARow->Values[jj]))
                            try { dValX = (double)ARow->Values[jj]; } catch(...) {dValX=0;}

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
            catch(...)
            {
            }
        }

        DbChart->LeftAxis->Minimum = 0;
        DbChart->LeftAxis->Maximum = GetActiveMaxY();    // 그래프 생성

        if (DbChart->LeftAxis->Minimum >= DbChart->LeftAxis->Maximum)
        {
            DbChart->LeftAxis->Maximum = DbChart->LeftAxis->Minimum + 1;    // 그래프 그리기
        }
    }
    __finally
    {
        if (pCDS)
        {
            pCDS->EnableControls();
        }

        TvList->EndUpdate();
        DbChart->Refresh();

        LstLegend->Items->EndUpdate();  //챠트 생성

        Screen->Cursor = cOldCursor;
    }
}
//---------------------------------------------------------------------------

/*
 * 해당되지 않는 컬럼을 클리어한다.
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::DrawChart4(TcxGridDBTableView *TvList, int nAxisY1, int nAxisY2, int nStColIdx, int nTotColIdx/*=-1*/)
{
    int             ii, jj, kk;
    SeriesType      SrsType;
    TColor          clSrsColor;
    TChartSeries    *pSeries;
    TClientDataSet  *pCDS = NULL;


    TCursor cOldCursor= Screen->Cursor;
    try
    {
        Screen->Cursor = crHourGlass;

        LstLegend->Items->BeginUpdate();
        TvList->BeginUpdate();
        pCDS = (TClientDataSet *)TvList->DataController->DataSource->DataSet;
        if (pCDS)
        {
            pCDS->DisableControls();
        }

        int nCols = TvList->ColumnCount;
        int nRows = TvList->ViewData->RecordCount;

        SrsType = GetChartType();

        /*
        *  합계 표출
        */
        kk = 0;
        if (nTotColIdx >= 0)
        {
            clSrsColor = GetDefaultColor(kk++);
            if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
            if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);
            pSeries = AddSeriesItem(lblSoge->Caption/*"소계"*/, SrsType, clSrsColor, true);
            if (pSeries)
            {
                for (jj = nStColIdx; jj < nCols; jj++)
                {
                    if (!TvList->Columns[jj]->Visible)
                    {
                        break;
                    }
                    String sAxisX = TvList->Columns[jj]->Caption;
                    nTotColIdx = TvList->DataController->Summary->FooterSummaryItems->IndexOfItemLink(TvList->Columns[jj]);
                    if (!VarIsNull(TvList->DataController->Summary->FooterSummaryValues[nTotColIdx]))
                    {
                        double dValX = 0;
                        try {
                            dValX = (double)TvList->DataController->Summary->FooterSummaryValues[nTotColIdx];
                        } catch(...) { dValX = 0; }

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
        }

        for (ii = 0; ii < nRows; ii++, kk++)
        {
            try
            {
                TcxCustomGridRow* ARow = TvList->ViewData->Rows[ii];
                clSrsColor = GetDefaultColor(kk);
                if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
                if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);

                String sTitle = "";
                if (!VarIsNull(ARow->Values[nAxisY1]))
                {
                    sTitle = ARow->Values[nAxisY1];
                }

                if (!VarIsNull(ARow->Values[nAxisY2]))
                {
                    sTitle += ":";
                    sTitle += ARow->Values[nAxisY2];
                }

                pSeries = AddSeriesItem(sTitle, SrsType, clSrsColor, true);
                if (pSeries)
                {
                    for (jj = nStColIdx; jj < nCols; jj++)
                    {
                        if (!TvList->Columns[jj]->Visible)
                        {
                            break;
                        }
                        String sAxisX = TvList->Columns[jj]->Caption;
                        double dValX = 0;

                        String sVal = ARow->Values[jj];
                        if (!VarIsNull(ARow->Values[jj]))
                            try { dValX = (double)ARow->Values[jj]; } catch(...) {dValX=0;}

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
            catch(...)
            {
            }
        }
        DbChart->LeftAxis->Minimum = 0;
        DbChart->LeftAxis->Maximum = GetActiveMaxY();
        if (DbChart->LeftAxis->Minimum >= DbChart->LeftAxis->Maximum)
        {
            DbChart->LeftAxis->Maximum = DbChart->LeftAxis->Minimum + 1;
        }
    }
    __finally
    {
        if (pCDS)
        {
            pCDS->EnableControls();
        }
        TvList->EndUpdate();

        DbChart->Refresh();
        LstLegend->Items->EndUpdate();

        Screen->Cursor = cOldCursor;
    }
}
//---------------------------------------------------------------------------

void __fastcall TPlugInChart::DrawChart5(TcxGridDBTableView *TvList, int nAxisY1, int nAxisY2, int nAxisY3, int nStColIdx, int nEdColIdx/*=-1*/,int nTotColIdx/*=-1*/)
{
    int             ii, jj, kk;
    SeriesType      SrsType;
    TColor          clSrsColor;
    TChartSeries    *pSeries;
    TClientDataSet  *pCDS = NULL;


    TCursor cOldCursor= Screen->Cursor;
    try
    {
        Screen->Cursor = crHourGlass;

        LstLegend->Items->BeginUpdate();
        TvList->BeginUpdate();
        pCDS = (TClientDataSet *)TvList->DataController->DataSource->DataSet;
        if (pCDS)
        {
            pCDS->DisableControls();
        }

        int nCols = TvList->ColumnCount;
        int nRows = TvList->ViewData->RecordCount;

        if (nEdColIdx != -1)
        {
            nCols = nCols > nEdColIdx ? nEdColIdx+1 : nCols;
        }
        SrsType = GetChartType();

        /*
        *  합계 표출
        */
        kk = 0;
        if (nTotColIdx >= 0)
        {
            clSrsColor = GetDefaultColor(kk++);
            if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
            if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);
            pSeries = AddSeriesItem(lblSoge->Caption/*"소계"*/, SrsType, clSrsColor, true);
            if (pSeries)
            {
                for (jj = nStColIdx; jj < nCols; jj++)
                {
                    if (!TvList->Columns[jj]->Visible)
                    {
                        break;
                    }
                    String sAxisX = TvList->Columns[jj]->Caption;
                    nTotColIdx = TvList->DataController->Summary->FooterSummaryItems->IndexOfItemLink(TvList->Columns[jj]);
                    if (!VarIsNull(TvList->DataController->Summary->FooterSummaryValues[nTotColIdx]))
                    {
                        double dValX = 0;
                        try {
                            dValX = (double)TvList->DataController->Summary->FooterSummaryValues[nTotColIdx];
                        } catch(...) { dValX = 0;}

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
        }

        for (ii = 0; ii < nRows; ii++, kk++)
        {
            try
            {
                TcxCustomGridRow* ARow = TvList->ViewData->Rows[ii];
                clSrsColor = GetDefaultColor(kk);
                if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
                if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);

                String sTitle = "";
                if (TvList->Columns[nAxisY1]->Visible && !VarIsNull(ARow->Values[nAxisY1]))
                {
                    sTitle = ARow->Values[nAxisY1];
                }

                if (TvList->Columns[nAxisY2]->Visible && !VarIsNull(ARow->Values[nAxisY2]))
                {
                    sTitle += ":";
                    sTitle += ARow->Values[nAxisY2];
                }

                if (TvList->Columns[nAxisY3]->Visible && !VarIsNull(ARow->Values[nAxisY3]))
                {
                    sTitle += ":";
                    sTitle += ARow->Values[nAxisY3];
                }

                pSeries = AddSeriesItem(sTitle, SrsType, clSrsColor, true);
                if (pSeries)
                {
                    for (jj = nStColIdx; jj < nCols; jj++)
                    {
                        if (!TvList->Columns[jj]->Visible)
                        {
                            break;
                        }
                        String sAxisX = TvList->Columns[jj]->Caption;
                        double dValX = 0;

                        if (!VarIsNull(ARow->Values[jj]))
                        {
                            String sVal = VarToStr(ARow->Values[jj]);
                            try {
                                //dValX = (double)ARow->Values[jj];
                                dValX = (double)sVal.ToIntDef(0);
                            } catch(...) {
                                dValX=0;
                            }
                        }

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
            catch(...)
            {
            }
        }
        DbChart->LeftAxis->Minimum = 0;
        DbChart->LeftAxis->Maximum = GetActiveMaxY();
        if (DbChart->LeftAxis->Minimum >= DbChart->LeftAxis->Maximum)
        {
            DbChart->LeftAxis->Maximum = DbChart->LeftAxis->Minimum + 1;
        }
    }
    __finally
    {
        if (pCDS)
        {
            pCDS->EnableControls();
        }
        TvList->EndUpdate();

        DbChart->Refresh();
        LstLegend->Items->EndUpdate();

        Screen->Cursor = cOldCursor;
    }
}
//---------------------------------------------------------------------------

void __fastcall TPlugInChart::DrawChart5_1(TcxGridTableView *TvList, int nAxisY1, int nAxisY2, int nStColIdx, int nEdColIdx/*=-1*/,int nTotColIdx/*=-1*/)
{
    int             ii, jj, kk;
    SeriesType      SrsType;
    TColor          clSrsColor;
    TChartSeries    *pSeries;

    TCursor cOldCursor= Screen->Cursor;
    try
    {
        Screen->Cursor = crHourGlass;

        LstLegend->Items->BeginUpdate();

        TvList->BeginUpdate();

        int nCols = TvList->ColumnCount;
        int nRows = TvList->ViewData->RecordCount;

        if (nEdColIdx != -1)
        {
            nCols = nCols > nEdColIdx ? nEdColIdx+1 : nCols;
        }
        SrsType = GetChartType();

        /*
        *  합계 표출
        */
        kk = 0;
        if (nTotColIdx >= 0)
        {
            clSrsColor = GetDefaultColor(kk++);
            if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
            if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);
            pSeries = AddSeriesItem(lblSoge->Caption/*"소계"*/, SrsType, clSrsColor, true);
            if (pSeries)
            {
                for (jj = nStColIdx; jj < nCols; jj++)
                {
                    if (!TvList->Columns[jj]->Visible)
                    {
                        break;
                    }
                    String sAxisX = TvList->Columns[jj]->Caption;
                    nTotColIdx = TvList->DataController->Summary->FooterSummaryItems->IndexOfItemLink(TvList->Columns[jj]);
                    if (!VarIsNull(TvList->DataController->Summary->FooterSummaryValues[nTotColIdx]))
                    {
                        double dValX = 0;
                        try {
                            dValX = (double)TvList->DataController->Summary->FooterSummaryValues[nTotColIdx];
                        } catch(...) { dValX = 0;}

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
        }

        for (ii = 0; ii < nRows; ii++, kk++)
        {
            try
            {
                TcxCustomGridRow* ARow = TvList->ViewData->Rows[ii];
                clSrsColor = GetDefaultColor(kk);
                if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
                if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);

                String sTitle = "";
                if (TvList->Columns[nAxisY1]->Visible && !VarIsNull(ARow->Values[nAxisY1]))
                {
                    sTitle = ARow->Values[nAxisY1];
                }

                if (TvList->Columns[nAxisY2]->Visible && !VarIsNull(ARow->Values[nAxisY2]))
                {
                    sTitle += ":";
                    sTitle += ARow->Values[nAxisY2];
                }

                pSeries = AddSeriesItem(sTitle, SrsType, clSrsColor, true);
                if (pSeries)
                {
                    for (jj = nStColIdx; jj < nCols; jj++)
                    {
                        if (!TvList->Columns[jj]->Visible)
                        {
                            break;
                        }
                        String sAxisX = TvList->Columns[jj]->Caption;
                        double dValX = 0;

                        if (!VarIsNull(ARow->Values[jj]))
                        {
                            String sVal = VarToStr(ARow->Values[jj]);
                            try {
                                //dValX = (double)ARow->Values[jj];
                                dValX = (double)sVal.ToIntDef(0);
                            } catch(...) {
                                dValX=0;
                            }
                        }

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
            catch(...)
            {
            }
        }
        DbChart->LeftAxis->Minimum = 0;
        DbChart->LeftAxis->Maximum = GetActiveMaxY();
        if (DbChart->LeftAxis->Minimum >= DbChart->LeftAxis->Maximum)
        {
            DbChart->LeftAxis->Maximum = DbChart->LeftAxis->Minimum + 1;
        }
    }
    __finally
    {
        TvList->EndUpdate();

        DbChart->Refresh();
        LstLegend->Items->EndUpdate();

        Screen->Cursor = cOldCursor;
    }
}
//---------------------------------------------------------------------------

void __fastcall TPlugInChart::DrawChart6(TcxGridDBTableView *TvList, int nAxisY1, int nAxisY2, int nAxisY3, int nStColIdx, int nEdColIdx/*=-1*/,int nTotColIdx/*=-1*/)
{
    int             ii, jj, kk;
    SeriesType      SrsType;
    TColor          clSrsColor;
    TChartSeries    *pSeries;
    TClientDataSet  *pCDS = NULL;


    TCursor cOldCursor= Screen->Cursor;
    try
    {
        Screen->Cursor = crHourGlass;

        LstLegend->Items->BeginUpdate();
        TvList->BeginUpdate();
        pCDS = (TClientDataSet *)TvList->DataController->DataSource->DataSet;
        if (pCDS)
        {
            pCDS->DisableControls();
        }

        int nCols = TvList->ColumnCount;
        int nRows = TvList->ViewData->RecordCount;

        if (nEdColIdx != -1)
        {
            nCols = nCols > nEdColIdx ? nEdColIdx+1 : nCols;
        }
        SrsType = GetChartType();

        /*
        *  합계 표출
        */
        kk = 0;
        if (nTotColIdx >= 0)
        {
            clSrsColor = GetDefaultColor(kk++);
            if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
            if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);
            pSeries = AddSeriesItem(lblSoge->Caption/*"소계"*/, SrsType, clSrsColor, true);
            if (pSeries)
            {
                for (jj = nStColIdx; jj < nCols; jj++)
                {
                    if (!TvList->Columns[jj]->Visible)
                    {
                        break;
                    }
                    String sAxisX = TvList->Columns[jj]->Caption;
                    nTotColIdx = TvList->DataController->Summary->FooterSummaryItems->IndexOfItemLink(TvList->Columns[jj]);
                    if (!VarIsNull(TvList->DataController->Summary->FooterSummaryValues[nTotColIdx]))
                    {
                        double dValX = 0;
                        try {
                            dValX = (double)TvList->DataController->Summary->FooterSummaryValues[nTotColIdx];
                        } catch(...) { dValX = 0;}

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
        }

        for (ii = 0; ii < nRows; ii++, kk++)
        {
            try
            {
                TcxCustomGridRow* ARow = TvList->ViewData->Rows[ii];
                clSrsColor = GetDefaultColor(kk);
                if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
                if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);

                String sTitle = "";
                if (TvList->Columns[nAxisY1]->Visible && !VarIsNull(ARow->Values[nAxisY1]))
                {
                    sTitle = ARow->Values[nAxisY1];
                }

                if (TvList->Columns[nAxisY2]->Visible && !VarIsNull(ARow->Values[nAxisY2]))
                {
                    sTitle += ":";
                    sTitle += ARow->Values[nAxisY2];
                }

#if 0
                if (TvList->Columns[nAxisY3]->Visible && !VarIsNull(ARow->Values[nAxisY3]))
                {
                    sTitle += ":";
                    sTitle += ARow->Values[nAxisY3];
                }
#endif

                pSeries = AddSeriesItem(sTitle, SrsType, clSrsColor, true);
                if (pSeries)
                {
                    for (jj = nStColIdx; jj < nCols; jj++)
                    {
                        if (!TvList->Columns[jj]->Visible)
                        {
                            break;
                        }
                        String sAxisX = TvList->Columns[jj]->Caption;
                        double dValX = 0;

                        if (!VarIsNull(ARow->Values[jj]))
                        {
                            String sVal = VarToStr(ARow->Values[jj]);
                            try {
                                //dValX = (double)ARow->Values[jj];
                                dValX = (double)sVal.ToIntDef(0);
                            } catch(...) {
                                dValX=0;
                            }
                        }

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
            catch(...)
            {
            }
        }
        DbChart->LeftAxis->Minimum = 0;
        DbChart->LeftAxis->Maximum = GetActiveMaxY();
        if (DbChart->LeftAxis->Minimum >= DbChart->LeftAxis->Maximum)
        {
            DbChart->LeftAxis->Maximum = DbChart->LeftAxis->Minimum + 1;
        }
    }
    __finally
    {
        if (pCDS)
        {
            pCDS->EnableControls();
        }
        TvList->EndUpdate();

        DbChart->Refresh();
        LstLegend->Items->EndUpdate();

        Screen->Cursor = cOldCursor;
    }
}
//---------------------------------------------------------------------------

/*
 * 해당되지 않는 컬럼을 클리어한다.
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::DrawChart3(TcxGridDBTableView *TvList, int nAxisY1, int nAxisY2, int nStColIdx, int nTotColIdx/*=-1*/)
{
    int             ii, jj, kk;
    SeriesType      SrsType;
    TColor          clSrsColor;
    TChartSeries    *pSeries;
    TClientDataSet  *pCDS = NULL;


    TCursor cOldCursor= Screen->Cursor;
    try
    {
        Screen->Cursor = crHourGlass;

        LstLegend->Items->BeginUpdate();
        TvList->BeginUpdate();
        pCDS = (TClientDataSet *)TvList->DataController->DataSource->DataSet;
        if (pCDS)
        {
            pCDS->DisableControls();
        }

        int nCols = TvList->ColumnCount;
        int nRows = TvList->ViewData->RecordCount;

        SrsType = GetChartType();

        /*
        *  합계 표출
        */
        kk = 0;
        if (nTotColIdx >= 0)
        {
            clSrsColor = GetDefaultColor(kk++);
            if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
            if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);
            pSeries = AddSeriesItem(lblSoge->Caption/*"소계"*/, SrsType, clSrsColor, true);
            if (pSeries)
            {
                for (jj = nStColIdx; jj < nCols; jj++)
                {
                    if (!TvList->Columns[jj]->Visible)
                    {
                        break;
                    }
                    String sAxisX = TvList->Columns[jj]->Caption;
                    nTotColIdx = TvList->DataController->Summary->FooterSummaryItems->IndexOfItemLink(TvList->Columns[jj]);
                    if (!VarIsNull(TvList->DataController->Summary->FooterSummaryValues[nTotColIdx]))
                    {
                        double dValX = 0;
                        try {
                            dValX = (double)TvList->DataController->Summary->FooterSummaryValues[nTotColIdx];
                        } catch(...) { dValX = 0; }
                        
                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
        }

        for (ii = 0; ii < nRows; ii++, kk++)
        {
            try
            {
                TcxCustomGridRow* ARow = TvList->ViewData->Rows[ii];

                String sTitle, sTitle1, sTitle2;
                sTitle = "";
                sTitle1 = "";
                sTitle2 = "";

                if (!VarIsNull(ARow->Values[nAxisY1]))
                    sTitle1 = ARow->Values[nAxisY1];
                if (!VarIsNull(ARow->Values[nAxisY2]))
                    sTitle2 = ARow->Values[nAxisY2];

                if (sTitle2 == FrmLang->lblChartSoge->Caption)//"소계")
                    continue;

                if (sTitle2 == "")
                {
                    sTitle = sTitle1;
                }
                else
                {
                    sTitle = sTitle1 + ":" + sTitle2;
                }

                clSrsColor = GetDefaultColor(kk);
                if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
                if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);

                pSeries = AddSeriesItem(sTitle, SrsType, clSrsColor, true);
                if (pSeries)
                {
                    for (jj = nStColIdx; jj < nCols; jj++)
                    {
                        if (!TvList->Columns[jj]->Visible)
                        {
                            break;
                        }
                        String sAxisX = TvList->Columns[jj]->Caption;
                        double dValX = 0;

                        if (!VarIsNull(ARow->Values[jj]))
                            try { dValX = (double)ARow->Values[jj]; } catch(...) {dValX=0;}

                        pSeries->AddY(dValX, sAxisX);
                    }
                }
            }
            catch(...)
            {
            }
        }
        DbChart->LeftAxis->Minimum = 0;
        DbChart->LeftAxis->Maximum = GetActiveMaxY();
        if (DbChart->LeftAxis->Minimum >= DbChart->LeftAxis->Maximum)
        {
            DbChart->LeftAxis->Maximum = DbChart->LeftAxis->Minimum + 1;
        }
    }
    __finally
    {
        if (pCDS)
        {
            pCDS->EnableControls();
        }
        TvList->EndUpdate();

        DbChart->Refresh();
        LstLegend->Items->EndUpdate();

        Screen->Cursor = cOldCursor;
    }
}
//---------------------------------------------------------------------------

/*
 * 해당되지 않는 컬럼을 클리어한다.
 *  arguments
 *
 *  return
 *      void
 */
void __fastcall TPlugInChart::DrawChart2(TcxGridDBBandedTableView *TvList,
                                         int nAxisY, int nStColIdx,
                                         int nTotColIdx/*=-1*/,
                                         bool bBarSeries/*=true*/,
                                         bool bBandText/*=true*/,
                                         int nEdColIdx/*=-1*/)
{
    int             ii, jj, kk;
    SeriesType      SrsType;
    TColor          clSrsColor;
    TChartSeries    *pSeries;
    TClientDataSet  *pCDS = NULL;

    TcxGridBand             *pBand;
    TcxGridDBBandedColumn   *pCol;

    TCursor cOldCursor= Screen->Cursor;
    try
    {
        Screen->Cursor = crHourGlass;

        LstLegend->Items->BeginUpdate();
        TvList->BeginUpdate();
        pCDS = (TClientDataSet *)TvList->DataController->DataSource->DataSet;
        if (pCDS)
        {
            pCDS->DisableControls();
        }

        int nCols;
        if (nEdColIdx >= 0)
            nCols = nEdColIdx+1;
        else
            nCols = TvList->ColumnCount;

        int nRows = TvList->ViewData->RecordCount;

        SrsType = GetChartType();

        for (ii = nStColIdx; ii < nCols; ii++, kk++)
        {
            pCol = TvList->Columns[ii];
            if (!pCol)
            {
                continue;
            }
            if (!pCol->Visible)
                continue;

            pBand = TvList->Bands->Items[pCol->Position->BandIndex];

            clSrsColor = GetDefaultColor(kk);
            if (clSrsColor == clWhite) clSrsColor = GetDefaultColor(++kk);
            if (clSrsColor == clYellow) clSrsColor = GetDefaultColor(++kk);

            String sTitle;
            if (bBandText)
            {
                sTitle = "[" + pBand->Caption + "]" + pCol->Caption;
            }
            else
            {
                sTitle = pCol->Caption;
            }

            if (ii == nTotColIdx)
                sTitle = pCol->Caption;

            if (ii == nTotColIdx && bBarSeries)
            {
                pSeries = AddSeriesItem(sTitle, ctpBar, clSrsColor, true);
            }
            else
            {
                pSeries = AddSeriesItem(sTitle, SrsType, clSrsColor, true);
            }
            for (jj = 0; jj < nRows; jj++)
            {
                TcxCustomGridRow* ARow = TvList->ViewData->Rows[jj];
                String sX = "";
                if (!VarIsNull(ARow->Values[nAxisY]))
                    try { sX = ARow->Values[nAxisY]; } catch(...) {}

                double nY = 0;
                if (!VarIsNull(ARow->Values[ii]))
                    try { nY = (double)ARow->Values[ii]; } catch(...){nY=0;};
                pSeries->AddY(nY, sX);
            }
        }
        DbChart->LeftAxis->Minimum = 0;
        DbChart->LeftAxis->Maximum = GetActiveMaxY();
        if (DbChart->LeftAxis->Minimum >= DbChart->LeftAxis->Maximum)
        {
            DbChart->LeftAxis->Maximum = DbChart->LeftAxis->Minimum + 1;
        }
    }
    __finally
    {
        if (pCDS)
        {
            pCDS->EnableControls();
        }
        TvList->EndUpdate();

        DbChart->Refresh();
        LstLegend->Items->EndUpdate();

        Screen->Cursor = cOldCursor;
    }
}
//---------------------------------------------------------------------------

/*
 * 차트 그린후 호출(Optional)
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::EndDraw()
{
    BtnChkAllClick(NULL);
}
//---------------------------------------------------------------------------

SeriesType __fastcall TPlugInChart::GetChartType()
{
    return (SeriesType)CbChartKind->ItemIndex;
}
//---------------------------------------------------------------------------

/*
 * 차트에 차트시리즈를 추가한다.
 *
 *  arguments
 *  return
 *      void
 */
TChartSeries* __fastcall TPlugInChart::AddSeriesItem(String     sTitle,
                                                  SeriesType SrsType,
                                                  TColor     clSrsColor,
                                                  bool       bActive/*=true*/
                                                  )
{
    SeriesItem   *pSrsItem;
    TChartSeries *pSeries = NULL;

    try
    {
        pSrsItem = new SeriesItem;

        pSrsItem->SrsType = SrsType;
        pSeries = MakeChartSeries(SrsType);

        pSeries->Title        = sTitle;
        pSrsItem->ChartSeries = (void*)pSeries;
        pSeries->Active       = bActive;
        pSeries->SeriesColor  = clSrsColor;

        LstLegend->Items->AddObject(sTitle, (TObject*)pSrsItem);
        LstLegend->Checked[LstLegend->Count-1] = bActive;

        pSeries->ParentChart = DbChart;
    }
    catch(...)
    {
    }

    return pSeries;
}
//---------------------------------------------------------------------------

/*
 * 차트시리즈를 생성한다.
 *
 *  arguments
 *  return
 *      void
 */
TChartSeries* __fastcall TPlugInChart::MakeChartSeries(SeriesType nSeriesTp)
{
    TChartSeries *pSeries = NULL;

    try
    {
        switch(nSeriesTp)
        {
        case ctpLine:
            {
            TLineSeries *pChart = new TLineSeries(this);
            pChart->Pointer->Style = psRectangle;
            pChart->Pointer->Visible = true;
            pChart->Pointer->VertSize = 4;
            //pChart->Marks->Style = smsValue;
            //pChart->Marks->Visible = false;
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpBar:
            {
            TBarSeries *pChart = new TBarSeries(this);
            pChart->Marks->Visible = true;
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpHorizontal_Bar:
            {
            THorizBarSeries *pChart = new THorizBarSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpArea:
            {
            TAreaSeries *pChart = new TAreaSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpPoint:
            {
            TPointSeries *pChart = new TPointSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpPie:
            {
            TPieSeries *pChart = new TPieSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpFast_Line:
            {
            TFastLineSeries *pChart = new TFastLineSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpHorizontal_Line:
            {
            THorizLineSeries *pChart = new THorizLineSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpHorizontal_Area:
            {
            THorizAreaSeries *pChart = new THorizAreaSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpShape:
            {
            TChartShape *pChart = new TChartShape(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpGantt:
            {
            TGanttSeries *pChart = new TGanttSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpArrow:
            {
            TArrowSeries *pChart = new TArrowSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        case ctpBubble:
            {
            TBubbleSeries *pChart = new TBubbleSeries(this);
            pSeries = (TChartSeries *)pChart;
            }
            break;
        }
        pSeries->Marks->Style = smsValue;
        pSeries->Marks->Visible = ChkDispValue->Checked;
    }
    catch(...)
    {
    }

    return pSeries;
}
//---------------------------------------------------------------------------

/*
 * Bar 차트시리즈를 생성한다.
 *
 *  arguments
 *  return
 *      void
 */
void __fastcall TPlugInChart::ShowBarChart()
{
#if 0
    chart.RemoveAllSeries();

    if (ds.rowcount == 0) return;

    var i = 0, serindex = 0;
    var oldvalue = "", newvalue = "";

    while (i < ds.rowcount)
    {
        newvalue = ds.GetColumn(i,"D1");

        if (oldvalue != newvalue) {
            //시리즈 추가
            chart.addSeries (1);  //scBar
            chart.Series(serindex).Clear();
            chart.Series(serindex).title = newvalue;
            chart.Series(serindex).Name = newvalue;
            chart.Series(serindex).Marks.Style = 0; //smsValue;
            chart.Series(serindex).Marks.Visible = false;
            chart.Series(serindex).color = arrseror[serindex % arrseror.length];
            serindex++;

            oldvalue = newvalue;
        }

        var xname  = ds.GetColumn(i,"D2"); //X축 명칭
        var xvalue = ds.GetColumn(i,"D3"); //X축 값

        chart.Series(serindex-1).Add (toNumber(xvalue), xname, chart.Series(serindex-1).color);

        chart.Series(serindex-1).Marks.Style = 0; //smsValue                //마크에 표시될 내용
        chart.Series(serindex-1).Marks.Frame.Color = TCH_MARK_BORDERCOLOR; //마크 테두리 색상

        i++;
    }
#endif
}
//---------------------------------------------------------------------------

void __fastcall TPlugInChart::DbChartClickSeries(TCustomChart *Sender, TChartSeries *Series, int ValueIndex, TMouseButton Button, TShiftState Shift,
          int X, int Y)
{
#if 0
    try
    {
        double vx, vy;
        AnsiString s;

        Sender->GetCursorValues(vx, vy);
        int nValue = Sender->GetMarkValue(floor(vx+0.50)-1);
        acDragPanel1->Color = Sender->Tag;

        AnsiString sTP = (AnsiString)tvList->Columns[2+ValueIndex]->Caption;
        s = sTP + "\n" + Sender->Title + "\n" +  IntToStr(nValue) + lblEA->Caption;//"건";

        LblDet->Caption = s;

        LblDet->Left = 6;
        LblDet->Top  = 6;
        acDragPanel1->Width = LblDet->Left+LblDet->Width+8;
        acDragPanel1->Height = LblDet->Left+LblDet->Height+8;

        acDragPanel1->Left = X + 5;
        if((Sender->ParentChart->Height - Y) <= acDragPanel1->Height)
            acDragPanel1->Top = Y - acDragPanel1->Height;
        else
            acDragPanel1->Top = Y;
        acDragPanel1->Visible = true;
    }
    catch(...)
    {
    }
#endif

    if (Button != mbLeft)
    {
        return;
    }

    String sMsg;
    //double vx, vy;
    //Series->GetCursorValues(vx, vy);
    //int nValue = Series->GetMarkValue(floor(vx+0.50)-1);
    //ShowMessage(String(ValueIndex));

    sMsg = Series->Title + "\r\n";
//    sMsg+= String(Series->XValues->Value[ValueIndex]) + " " + DbChart->BottomAxis->Title->Caption + "\r\n";
    sMsg+= DbChart->LeftAxis->Title->Caption + ": " + String(Series->YValues->Value[ValueIndex]);

    ShowMessage(sMsg);
}
//---------------------------------------------------------------------------

void __fastcall TPlugInChart::DbChartMouseMove(TObject *Sender, TShiftState Shift, int X, int Y)
{
#if 0
 int idx=Series1->GetCursorValueIndex();
        if(idx>=0)
        {
            double dX,dY;
            Series1->GetCursorValues(dX,dY);
            Chart1->Hint="( "+IntToStr((int)dX)+" , "+IntToStr((int)dY)+ " )";
        }
        else
        {
            Chart1->Hint="";
        }
#endif
}
//---------------------------------------------------------------------------