ITS_OP/TEMP/VmsSymbMngr - SYMB_LIB/VMSM400M/FrmVmsSymbMngrF.cpp

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

#include <vcl.h>
#include <IOUtils.hpp>
#include "ITSSkinF.h"
#include "ITSUtilF.h"
#include "AppGlobalF.h"
#include <jpeg.hpp>
#include <GIFimg.hpp>
#pragma hdrstop

#include "FrmVmsSymbMngrF.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "cxButtons"
#pragma link "cxCalendar"
#pragma link "cxContainer"
#pragma link "cxControls"
#pragma link "cxDropDownEdit"
#pragma link "cxEdit"
#pragma link "cxGraphics"
#pragma link "cxGroupBox"
#pragma link "cxLabel"
#pragma link "cxLookAndFeelPainters"
#pragma link "cxLookAndFeels"
#pragma link "cxMaskEdit"
#pragma link "cxPC"
#pragma link "cxPCdxBarPopupMenu"
#pragma link "cxSpinEdit"
#pragma link "cxSplitter"
#pragma link "cxTextEdit"
#pragma link "cxTimeEdit"
#pragma link "dxSkinBlack"
#pragma link "dxSkinBlue"
#pragma link "dxSkinCaramel"
#pragma link "dxSkinCoffee"
#pragma link "dxSkinDarkRoom"
#pragma link "dxSkinDarkSide"
#pragma link "dxSkinFoggy"
#pragma link "dxSkinGlassOceans"
#pragma link "dxSkiniMaginary"
#pragma link "dxSkinLilian"
#pragma link "dxSkinLiquidSky"
#pragma link "dxSkinLondonLiquidSky"
#pragma link "dxSkinMcSkin"
#pragma link "dxSkinMoneyTwins"
#pragma link "dxSkinOffice2007Black"
#pragma link "dxSkinOffice2007Blue"
#pragma link "dxSkinOffice2007Green"
#pragma link "dxSkinOffice2007Pink"
#pragma link "dxSkinOffice2007Silver"
#pragma link "dxSkinOffice2010Black"
#pragma link "dxSkinOffice2010Blue"
#pragma link "dxSkinOffice2010Silver"
#pragma link "dxSkinsCore"
#pragma link "dxSkinscxPCPainter"
#pragma link "dxSkinSeven"
#pragma link "dxSkinSharp"
#pragma link "dxSkinSilver"
#pragma link "dxSkinStardust"
#pragma link "cxRadioGroup"
#pragma link "cxClasses"
#pragma link "cxCustomData"
#pragma link "cxData"
#pragma link "cxDataStorage"
#pragma link "cxDBData"
#pragma link "cxFilter"
#pragma link "cxGrid"
#pragma link "cxGridCustomTableView"
#pragma link "cxGridCustomView"
#pragma link "cxGridDBTableView"
#pragma link "cxGridLevel"
#pragma link "cxGridTableView"
#pragma link "cxStyles"
#pragma link "cxCheckBox"
#pragma link "cxImage"
#pragma link "cxButtonEdit"
#pragma link "cxBlobEdit"
#pragma link "cxHint"
#pragma link "dxCustomHint"
#pragma link "dxScreenTip"
#pragma link "dxSkinsForm"
#pragma link "FFBaseComponent"
#pragma link "FFBasePlay"
#pragma link "FFPlay"
#pragma link "dxGDIPlusClasses"
#pragma link "FFDecode"
#pragma link "cxCalc"
#pragma resource "*.dfm"

#define LICENSE_KEY "FSXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX"

#define SBT_GENERAL     "SBT1"  // 일반
#define SBT_TRAFFIC     "SBT2"  // 소통정보
#define SBT_ATMP        "SBT3"  // 대기환경
#define SBT_WEATHER     "SBT4"  // 기상정보
#define SBT_INCIDENT    "SBT5"  // 돌발
#define SBT_VIDEO       "SBT6"  // 동영상
#define SBT_TRAFBAK     "SBT7"  // 소통정보배경

TFrmVmsSymbMngr *FrmVmsSymbMngr = NULL;
TItsMap<String, TSymbFmt*> g_SymbFmtLists;
//---------------------------------------------------------------------------

__fastcall TFrmVmsSymbMngr::TFrmVmsSymbMngr(TComponent* Owner)
    : TForm(Owner)
{
    //CMM_SetFormPosition(g_AppCfg.bSaveForm);

    ITSSkin_Initialize(Application, g_AppCfg.sLang);
    ITSSkin_Caption(false);
    ITSSkin_Load(this);
    //CMM_LoadForm(g_sFormsDir, this);

    SetColorScheme(g_AppCfg.sSkinName);

    PnlSymbol->Align = alClient;

    FUpdate= false;
    FTitle = Caption;//"VMS 심볼이미지 관리";

    PgSymb->Properties->HideTabs = true;
    ChangeSymbPage(SBT_GENERAL);

    EditMode = false;
    FIsUpdate = false;

    TvList->OptionsView->DataRowHeight  = 0;
    TvList->OptionsView->CellAutoHeight = true;
    TvList->OptionsView->Indicator      = false;

    TvList->OptionsCustomize->ColumnMoving  = false;
    TvList->OptionsCustomize->ColumnSorting = false;

    TvList->Columns[0]->Width = 60;
    TvList->Columns[0]->Options->HorzSizing = false;

    TNotifyEvent evt = CbType->Properties->OnChange;
    CbType->Properties->OnChange = NULL;
    CbType->Properties->Items->Clear();
    CbType->Properties->Items->Add(" [SBT1] 일반");
    CbType->Properties->Items->Add(" [SBT2] 소통정보");
    CbType->Properties->Items->Add(" [SBT3] 대기환경");
    CbType->Properties->Items->Add(" [SBT4] 기상정보");
    CbType->Properties->Items->Add(" [SBT5] 돌발");
    CbType->Properties->Items->Add(" [SBT6] 동영상");
    //CbType->Properties->Items->Add(" [SBT7] 소통정보 배경");
    CbType->ItemIndex = 0;
    CbType->Properties->OnChange = evt;

    //BtnSaveImgFile->Caption = "Save as image file";
    //BtnSaveImgFile->Hint = "Save as image file";

    g_SymbFmtLists.Push("bmp", new TSymbFmt("bmp", "bmp"));
    g_SymbFmtLists.Push("jpg", new TSymbFmt("jpg", "jpg"));
    g_SymbFmtLists.Push("jpge", new TSymbFmt("jpge", "jpg"));
    g_SymbFmtLists.Push("png", new TSymbFmt("png", "png"));
    g_SymbFmtLists.Push("avi", new TSymbFmt("avi", "avi"));
    g_SymbFmtLists.Push("ico", new TSymbFmt("ico", "ico"));
    g_SymbFmtLists.Push("gif", new TSymbFmt("gif", "gif"));

    CURR_SYMB_DATA = new TMemoryStream();
    CURR_SYMB_AVI_DATA = new TMemoryStream();

    FThumbNail = 0;
    FMakeThumbNail = false;

    FFDecoder1->SetLicenseKey(LICENSE_KEY);
    String sAVILibDir = g_sAppDir + "LibAV";
    FFPlayer1->SetLicenseKey(LICENSE_KEY);
    FFPlayer1->DisableFPUExceptions();

    if (!FFPlayer1->LoadAVLib(sAVILibDir))
    {
        if (g_AppCfg.sLang != "kr") Application->MessageBox(L"Stream display library load failed.", L"Stream display fail", MB_OK|MB_ICONERROR|MB_APPLMODAL);
        else                        Application->MessageBox(L"영상표출 라이브러리를 로드하지 못하였습니다.", L"영상표출 오류", MB_OK|MB_ICONERROR|MB_APPLMODAL);
    }
    FPlayStream = false;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::SetColorScheme(String ASkinName)
{
    dxSkinController1->SkinName = ASkinName;
    dxSkinController1->Refresh();
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::CommClose()
{
    try
    {
#if 0
        if (CURR_SYMB_DATA) {
            CURR_SYMB_DATA->Free();
        }
        if (CURR_SYMB_AVI_DATA) {
            CURR_SYMB_AVI_DATA->Free();
        }
#endif

        ITSSkin_Term();
        //CMM_SaveForm(g_sFormsDir, this);
    }
    catch(...)
    {
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::FormShow(TObject *Sender)
{
    Refresh();

    APP_DbLoading();

    FormInit();
    ChangeEditMode(1);
    TmrShow->Enabled = true;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::FormInit()
{
	EdNmbr->Text = "";
    EdName->Text = "";
    EdExpl->Text = "";
    SeSize->Value = 0;
    SeWidth->Value = 0;
    SeHeight->Value = 0;
    //EdImageFileName->Text = "";

#if 0
    ImgGeneral->Picture->Bitmap->FreeImage();
    ImgGeneral->Picture->Bitmap = NULL;

    ImgVideo->Picture->Bitmap->FreeImage();
    ImgVideo->Picture->Bitmap = NULL;

    ImgTemp->Picture->Bitmap->FreeImage();
    ImgTemp->Picture->Bitmap = NULL;
#endif

    FNewDb = false;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::TmrShowTimer(TObject *Sender)
{
    TmrShow->Enabled = false;

    LoadImageSymbol();
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::BtnCloseClick(TObject *Sender)
{
    Close();
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::FormClose(TObject *Sender, TCloseAction &Action)
{
    CommClose();
    FrmVmsSymbMngr = NULL;
    Action = caFree;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::DisplayInfo()
{
    FormInit();

	int nRow = TvList->DataController->FocusedRecordIndex;
	if( nRow <= -1 )
		return;

	TcxGridDataController *pGDC = TvList->DataController;

	nRow = pGDC->FocusedRecordIndex;

    CURR_SYMB_NMBR     = pGDC->Values[nRow][ColSYMB_NMBR->Index];
    CURR_SYMB_TYPE     = pGDC->Values[nRow][ColSYMB_TYPE->Index];
    CURR_SYMB_NM       = pGDC->Values[nRow][ColSYMB_NM->Index];
    CURR_SYMB_EXPL     = pGDC->Values[nRow][ColSYMB_EXPL->Index];
    CURR_SYMB_FILE_NM  = pGDC->Values[nRow][ColSYMB_FILE_NM->Index];
    CURR_SYMB_FILE_EXT = pGDC->Values[nRow][ColSYMB_FILE_EXT->Index];
    CURR_SYMB_SIZE     = pGDC->Values[nRow][ColSYMB_SIZE->Index];
    CURR_SYMB_WDTH     = pGDC->Values[nRow][ColSYMB_WDTH->Index];
    CURR_SYMB_HGHT     = pGDC->Values[nRow][ColSYMB_HGHT->Index];
    CURR_PLAY_TM       = pGDC->Values[nRow][ColPLAY_TM->Index];
    CURR_BASE_YN       = pGDC->Values[nRow][ColBASE_YN->Index];
    CURR_USE_YN        = pGDC->Values[nRow][ColUSE_YN->Index];

    String imageFilePath = pGDC->Values[nRow][ColImagePath->Index];
    String videoFilePath = pGDC->Values[nRow][ColVideoPath->Index];
    if (CURR_SYMB_FILE_EXT.Pos("avi")) {
        CURR_LOCAL_FILE_NM = videoFilePath;
        //CURR_SYMB_AVI_DATA->LoadFromFile(CURR_LOCAL_FILE_NM);
    }
    else {
        CURR_LOCAL_FILE_NM = imageFilePath;
        //CURR_SYMB_DATA->LoadFromFile(CURR_LOCAL_FILE_NM);
    }

    ChangeSymbPage(CURR_SYMB_TYPE);
    if (CURR_SYMB_TYPE == SBT_GENERAL) {
        ImgGeneral->Picture->LoadFromFile(imageFilePath);
        if (ImgGeneral->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)ImgGeneral->Picture->Graphic)->Animate = true;
        }
    }
    else if (CURR_SYMB_TYPE == SBT_TRAFFIC) {
        ImagTraffic->Picture->LoadFromFile(imageFilePath);
    }
    else if (CURR_SYMB_TYPE == SBT_ATMP) {
        ImagAtmp->Picture->LoadFromFile(imageFilePath);
        if (ImagAtmp->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)ImagAtmp->Picture->Graphic)->Animate = true;
        }
    }
    else if (CURR_SYMB_TYPE == SBT_WEATHER) {
        ImagWeather->Picture->LoadFromFile(imageFilePath);
        if (ImagWeather->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)ImagWeather->Picture->Graphic)->Animate = true;
        }
    }
    else if (CURR_SYMB_TYPE == SBT_INCIDENT) {
        ImagIncident->Picture->LoadFromFile(imageFilePath);
        if (ImagIncident->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)ImagIncident->Picture->Graphic)->Animate = true;
        }
    }
    else if (CURR_SYMB_TYPE == SBT_VIDEO) {
        ImgVideo->Picture->LoadFromFile(imageFilePath);
        if (ImgVideo->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)ImgVideo->Picture->Graphic)->Animate = true;
        }
    }
    else if (CURR_SYMB_TYPE == SBT_TRAFBAK) {
        ImagTrafBack->Picture->LoadFromFile(imageFilePath);
    }

    //FSymbImag = GetPreviewSymb(CURR_SYMB_TYPE);
    //if (FSymbImag != NULL) {
#if 0
        FSymbImag->Picture->Assign(NULL);
        FSymbImag->Picture->LoadFromFile(imageFilePath);
        if (FSymbImag->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)FSymbImag->Picture->Graphic)->Animate = true;
        }
#endif
#if 0
        Image1->Picture->LoadFromFile(imageFilePath);
        if (Image1->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)Image1->Picture->Graphic)->Animate = true;
        }

        ImgGeneral->Picture->LoadFromFile(imageFilePath);
        if (ImgGeneral->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)ImgGeneral->Picture->Graphic)->Animate = true;
        }
#endif
    //}

    EdNmbr->Text  = String(CURR_SYMB_NMBR);
    EdExpl->Text  = CURR_SYMB_EXPL;
    EdVmsCd->Text = CURR_SYMB_TYPE;
    EdName->Text  = CURR_SYMB_NM;
    EdImageFileName->Text = CURR_SYMB_FILE_NM;
    SeSize->Value = CURR_SYMB_SIZE;
    SeWidth->Value = CURR_SYMB_WDTH;
    SeHeight->Value = CURR_SYMB_HGHT;

    ChangeEditMode(3);
    BtnPlay->Enabled = true;
    BtnStop->Enabled = false;
    BtnPause->Enabled = false;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::BtnEditClick(TObject *Sender)
{
    if (BtnEdit->Caption == "편집")//"편집")
    {
        ChangeEditMode(0);
        FNewDb = false;
    }
    else
    {
        String sId = EdNmbr->Text;
        ChangeEditMode(1);

        if (CMM_FindGridData(TvList->DataController, sId, ColSYMB_NMBR->Index) >= 0)
        {
            CMM_SetGridRow(CxList, TvList, sId, ColSYMB_NMBR->Index);
            DisplayInfo();
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::ChangeEditMode(int AEdit)
{
    FImageUpdate = false;
    bool bEnabled = false;
    switch(AEdit)
    {
    case 0: //편집버튼클릭
        {
            BtnEdit->Enabled = true;
            BtnInsert->Enabled = false;
            BtnDelete->Enabled = false;
            BtnSave->Enabled = true;

            BtnEdit->Caption = "취소";//"취소";
            BtnEdit->Hint    = "데이터 편집 취소";//데이터 편집 취소";
            EditMode = true;
            //EdImageFileName->Enabled = FIsUpdate;
        }
        break;
    case 1: //편집[취소]버튼클릭
        {
            FormInit(); //화면을 모두 지운다.
            BtnEdit->Enabled = false;
            BtnInsert->Enabled = true;
            BtnDelete->Enabled = false;
            BtnSave->Enabled = false;

            BtnEdit->Caption = "편집";//"편집";
            BtnEdit->Hint    = "데이터 편집";//데이터 편집";
            //bEnabled = true;
            EditMode = false;
            //EdImageFileName->Enabled = false;
        }
        break;
    case 2: //추가
        {
            BtnEdit->Enabled = true;
            BtnInsert->Enabled = false;
            BtnDelete->Enabled = false;
            BtnSave->Enabled = true;

            BtnEdit->Caption = "취소";//"취소";
            BtnEdit->Hint    = "데이터 편집 취소";//데이터 편집 취소";
            EditMode = true;
            //EdImageFileName->Enabled = true;
        }
        break;
    case 3: //수정모드
        {
            BtnEdit->Enabled = true;
            BtnInsert->Enabled = true;
            BtnDelete->Enabled = true;
            BtnSave->Enabled = false;

            BtnEdit->Caption = "편집";//"편집";
            BtnEdit->Hint    = "데이터 편집";//데이터 편집";
            bEnabled = true;
            EditMode = false;
            //EdImageFileName->Enabled = FIsUpdate;
        }
        break;
    }

    BtnSaveImgFile->Enabled = false;
    if (FSymbImag != NULL && FSymbImag->Picture->Bitmap != NULL)
    {
        if (FSymbImag->Picture->Bitmap->Height != 0)
        {
            BtnSaveImgFile->Enabled = true;
        }
    }
    if (AEdit == 0 || AEdit == 2)
    {
        GrpList->Enabled = false;
        PnlCmd->Enabled = true;
    }
    else
    {
        GrpList->Enabled = true;
        PnlCmd->Enabled = false;
    }

    //PnlEdit->Enabled = EditMode;
}
//---------------------------------------------------------------------------

bool __fastcall TFrmVmsSymbMngr::UpdateVmsImage(String ANmbr, String AExpl, String ATypeCd)
{
    String sQry;
    TADOQuery *pADO = NULL;

    sQry = "UPDATE TB_VMS_SYMB_LIB                                    \r\n"
           "   SET RGST_DT   = TO_CHAR(SYSDATE, 'YYYYMMDDHH24MISS'),  \r\n"
           "       SYMB_EXPL = :p02,                                  \r\n"
           "       IMAG_DATA = :p03,                                  \r\n"
           "       SYMB_TYPE = :p04,                                  \r\n"
           "       UPDT_DT   = TO_CHAR(SYSDATE, 'YYYYMMDDHH24MISS')   \r\n"
           " WHERE SYMB_LIB_NMBR = :p01                               \r\n";

	TMemoryStream *dataStream = new TMemoryStream();
   	//ImgGeneral->Picture->Bitmap->SaveToStream(dataStream);
   	ImgTemp->Picture->Bitmap->SaveToStream(dataStream);

    try
    {
        try
        {
            pADO = new TADOQuery(NULL);
			pADO->Close();
            pADO->Connection = ITSDb_GetConnection();

            ITSDb_SQLText(pADO, sQry);
            ITSDb_SQLBind(pADO, "p01", ANmbr);
            ITSDb_SQLBind(pADO, "p02", AExpl);
    		pADO->Parameters->ParamByName("p03")->LoadFromStream(dataStream, ftBlob);
            ITSDb_SQLBind(pADO, "p04", ATypeCd);
			pADO->ExecSQL();

            if (FImageUpdate)
            {
    sQry = "UPDATE TB_VMS_FORM_OBJECT    \r\n"
           "   SET VMS_DSPL_FIGR = :p03  \r\n"
           " WHERE SYMB_LIB_NMBR = :p01  \r\n";

                ITSDb_SQLText(pADO, sQry);
                ITSDb_SQLBind(pADO, "p01", ANmbr);
                pADO->Parameters->ParamByName("p03")->LoadFromStream(dataStream, ftBlob);
                pADO->ExecSQL();

    //통신서버가 항상 폼정보를 내려보내도록 업데이트시각을 업데이트한다.
    sQry = "UPDATE TB_VMS_FORM                                      \r\n"
           "   SET UPDT_DT = TO_CHAR(SYSDATE, 'YYYYMMDDHH24MISS')   \r\n"
           " WHERE VMS_FORM_ID IN (SELECT VMS_FORM_ID               \r\n"
           "                         FROM TB_VMS_FORM_OBJECT        \r\n"
           "                        WHERE SYMB_LIB_NMBR = :p01      \r\n"
           "                        GROUP BY VMS_FORM_ID)           \r\n";

                ITSDb_SQLText(pADO, sQry);
                ITSDb_SQLBind(pADO, "p01", ANmbr);
                pADO->ExecSQL();

                //폼이미지를 새로생성
                FrmLang->UpdateVmsFormImage(ANmbr, FOldWidth, FOldHeight, FNewWidth, FNewHeight);
            }

            return true;
        }
        catch(EDatabaseError &E)
        {
            DBERRORMSG("VMS Symbol Update", String(E.ClassName()), E.Message, sQry);
            throw Exception(String(E.ClassName()) + E.Message);
        }
        catch(Exception &e)
        {
            DBERRORMSG("VMS Symbol Update", String(e.ClassName()), e.Message, sQry);
            throw Exception(String(e.ClassName()) + e.Message);
        }
    }
    __finally
    {
        if (pADO)
        {
            pADO->Close();
            delete pADO;
        }
        if (dataStream) delete dataStream;
        dataStream = NULL;
    }
    return true;
}
//---------------------------------------------------------------------------

bool __fastcall TFrmVmsSymbMngr::UpdateVmsSymbLib(int SYMB_NMBR, String SYMB_NM, String SYMB_EXPL)
{
    String sQry;
    TADOQuery *pADO = NULL;

    sQry = "UPDATE TB_VMS_SYMB_LIB   \r\n"
           "   SET SYMB_NM   = :p02, \r\n"
           "       SYMB_EXPL = :p03  \r\n"
           " WHERE SYMB_NMBR = :p01  \r\n";

    try
    {
        try
        {
            pADO = new TADOQuery(NULL);
			pADO->Close();
            pADO->Connection = ITSDb_GetConnection();

            ITSDb_SQLText(pADO, sQry);

            pADO->Parameters->ParamByName("p01")->Value = SYMB_NMBR;
            pADO->Parameters->ParamByName("p02")->Value = SYMB_NM;
            pADO->Parameters->ParamByName("p03")->Value = SYMB_EXPL;

			pADO->ExecSQL();
        }
        catch(EDatabaseError &E)
        {
            DBERRORMSG("TFrmVmsSymbMngr::UpdateVmsSymbLib", String(E.ClassName()), E.Message, sQry);
            return false;
        }
        catch(Exception &e)
        {
            DBERRORMSG("TFrmVmsSymbMngr::UpdateVmsSymbLib", String(e.ClassName()), e.Message, sQry);
            return false;
        }
    }
    __finally
    {
        if (pADO)
        {
            pADO->Close();
            delete pADO;
        }

    }
    return true;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::BtnSaveClick(TObject *Sender)
{
	if (EdNmbr->Text.IsEmpty())
	{
        Application->MessageBox(L"VMS 이미지정보 저장\r\n이미지 번호를 입력하세요.",//FrmLang->lblImage1->Caption.c_str(),//L"VMS 이미지정보 저장\r\n이미지 번호를 입력하세요.",
                                FTitle.c_str(), MB_OK|MB_ICONERROR|MB_APPLMODAL);
		return;
	}
	if (EdName->Text.Trim().IsEmpty())
	{
        Application->MessageBox(L"VMS 이미지정보 저장\r\n이미지 설명을 입력하세요.",//FrmLang->lblImage2->Caption.c_str(),//L"VMS 이미지정보 저장\r\n이미지 설명을 입력하세요.",
                                FTitle.c_str(), MB_OK|MB_ICONERROR|MB_APPLMODAL);
		return;
	}

    bool bResult = false;
    String sNmbr = EdNmbr->Text;

    CURR_SYMB_NMBR = sNmbr.ToInt();
    CURR_SYMB_NM   = EdName->Text.Trim();
    CURR_SYMB_EXPL = EdExpl->Text.Trim();
    CURR_SYMB_SIZE = SeSize->Value;
    CURR_SYMB_WDTH = SeWidth->Value;
    CURR_SYMB_HGHT = SeHeight->Value;

    if (!FNewDb)
    {
        bResult = UpdateVmsSymbLib(CURR_SYMB_NMBR, CURR_SYMB_NM, CURR_SYMB_EXPL);
    }
    else
    {
        CURR_BASE_YN = "Y";
        CURR_USE_YN = "Y";
        bResult = InsertVmsSymbLib(CURR_SYMB_NMBR,
                                   CURR_SYMB_TYPE,
                                   CURR_SYMB_NM,
                                   CURR_SYMB_EXPL,
                                   CURR_SYMB_DATA,
                                   CURR_SYMB_AVI_DATA,
                                   CURR_SYMB_FILE_NM,
                                   CURR_SYMB_FILE_EXT,
                                   CURR_SYMB_SIZE,
                                   CURR_SYMB_WDTH,
                                   CURR_SYMB_HGHT,
                                   CURR_PLAY_TM,
                                   CURR_BASE_YN,
                                   CURR_USE_YN);
    }

    if (bResult)
    {
        Application->MessageBox(lblText1->Caption.c_str(),//L"VMS 이미지정보 저장\r\nVMS 이미지정보를 저장 하였습니다.",
                                FTitle.c_str(), MB_OK|MB_ICONINFORMATION|MB_APPLMODAL);

        FUpdate = true;

        LoadImageSymbol();
        CMM_SetGridRow(CxList, TvList, sNmbr, ColSYMB_NMBR->Index);
        //DisplayInfo();
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::BtnInsertClick(TObject *Sender)
{
    PopupAdd->Popup(BtnInsert->ClientOrigin.x, BtnInsert->ClientOrigin.y + BtnInsert->Height);
#if 0
    FormInit();
    //신규아이디를 얻어와서 화면을 초기화한다.

    int nNmbr;

    if (!FrmLang->GetNextVmsImgeId(nNmbr, 6000, 6999))
    {
        Application->MessageBox(L"새로운 VMS 이미지정보를 생성하지 못하였습니다.\r\n프로그램 종료후에 다시 시도해 보세요.",//FrmLang->lblImage4->Caption.c_str(),//L"새로운 VMS 이미지정보를 생성하지 못하였습니다.\r\n프로그램 종료후에 다시 시도해 보세요.",
                                FTitle.c_str(), MB_OK|MB_ICONERROR|MB_APPLMODAL);
        return;
    }

    EdNmbr->Text = String(nNmbr);

    ChangeEditMode(2);
    FNewDb = true;
    //EdImageFileNameClick((TObject *)EdImageFileName);
#endif
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::BtnDeleteClick(TObject *Sender)
{
    int nIdx = TvList->DataController->FocusedRecordIndex;
    if (nIdx < 0) return;

    String sId = EdNmbr->Text;
    if (sId.IsEmpty())
    {
        Application->MessageBox(L"삭제할 VMS 이미지를 목록에서 선택하세요.\r\n목록에서 더블클릭하여 선택합니다.",//FrmLang->lblImage6->Caption.c_str(),//L"삭제할 VMS 이미지를 목록에서 선택하세요.\r\n목록에서 더블클릭하여 선택합니다.",
                                FTitle.c_str(), MB_OK|MB_ICONERROR|MB_APPLMODAL);
        return;
    }

#if 0
    if (FrmLang->CheckImageUseCount(sId) > 0)
    {
        Application->MessageBox(L"삭제할 이미지가 VMS 폼에서 사용되고 있습니다.\r\n먼저 해당 폼에서 삭제해주시기 바랍니다.",//FrmLang->lblImage5->Caption.c_str(),//L"삭제할 이미지가 VMS 폼에서 사용되고 있습니다.\r\n먼저 해당 폼에서 삭제해주시기 바랍니다.",
                                FTitle.c_str(), MB_OK|MB_ICONERROR|MB_APPLMODAL);
        return;
    }
#endif

    String sMsg;
    sMsg = FrmLang->lblImage7->Caption + ": " + sId;//"VMS이미지번호: " + sId;
    sMsg+= "\r\n" + FrmLang->lblImage8->Caption;//"선택하신 VMS 이미지 정보를 삭제하시겠습니까?";

    if (Application->MessageBox(sMsg.c_str(), FTitle.c_str(), MB_YESNO|MB_ICONQUESTION|MB_APPLMODAL) != IDYES) return;

    if (DeleteVmsSymbLib(sId.ToInt(), false))
    {
        FUpdate = true;

        Application->MessageBox(FrmLang->lblImage9->Caption.c_str(),//L"VMS 이미지정보삭제\r\nVMS 이미지정보를 삭제 하였습니다.",
                                FTitle.c_str(), MB_OK|MB_ICONINFORMATION|MB_APPLMODAL);

        FormInit();
        ChangeEditMode(1);

        LoadImageSymbol();
	}
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::BtnSaveImgFileClick(TObject *Sender)
{
    SaveDialog->Title      = FTitle;
    SaveDialog->InitialDir = ExtractFilePath(Application->ExeName);
    SaveDialog->Filter     = "Bitmap image Files (*.bmp)|*.bmp";
    SaveDialog->FileName   = EdNmbr->Text + ".bmp";

    if (SaveDialog->Execute())
    {
        try {
            String sFileName = SaveDialog->FileName;

            int iRet = sFileName.Pos(".bmp");
            if (iRet == 0)
            {
                sFileName = SaveDialog->FileName + ".bmp";
            }

            //ImgGeneral->Picture->SaveToFile(sFileName);
            ImgTemp->Picture->SaveToFile(sFileName);
        }
        catch (Exception &exception)
        {
            Application->ShowException(&exception);
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::EdImageFileNameClick(TObject *Sender)
{
#if 0
    if (OpenBmp->InitialDir == "") {
        OpenBmp->InitialDir = g_sAppDir;
    }

    OpenBmp->Title = FTitle;
    OpenBmp->FileName = "";
    OpenBmp->Execute();
#endif
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::OpenBmpCanClose(TObject *Sender, bool &CanClose)
{
    CURR_LOCAL_FILE_NM = OpenBmp->FileName;
    String sFilePath  = ExtractFilePath(CURR_LOCAL_FILE_NM);
    CURR_SYMB_FILE_NM = ExtractFileName(CURR_LOCAL_FILE_NM);
    String sFileExt   = ExtractFileExt(CURR_LOCAL_FILE_NM);

    OpenBmp->InitialDir = sFilePath;

    CURR_SYMB_FILE_EXT = "";
    sFileExt = StringReplace(sFileExt, ".", "", TReplaceFlags() << rfReplaceAll);
    sFileExt = sFileExt.LowerCase();

    TSymbFmt *symbFmt = g_SymbFmtLists.Find(sFileExt);
    if (symbFmt == NULL) {
        Application->MessageBox(L"이미지 심벌로 지원하지 않는 형식입니다.\r\n지원형식(bmp, jpg, png, avi, ico)", L"이미지 심벌 추가 실패", MB_OK|MB_ICONERROR|MB_APPLMODAL);
        BtnInsertClick((TObject*)BtnInsert);
        return;
    }
    CURR_SYMB_FILE_EXT = symbFmt->fmtType;

    if (CURR_SYMB_TYPE == SBT_TRAFFIC || CURR_SYMB_TYPE == SBT_TRAFBAK) {
        if (CURR_SYMB_FILE_EXT != "bmp") {
            Application->MessageBox(L"이미지 심벌 유형에 허용되지 않는 이미지 형식입니다.[bmp 형식 지원]", L"이미지 심벌 추가 실패", MB_OK|MB_ICONERROR|MB_APPLMODAL);
            BtnInsertClick((TObject*)BtnInsert);
            return;
        }
    }

    FImageUpdate = false;

#if 0
    if (CURR_SYMB_DATA->Size > 0) {
        CURR_SYMB_DATA->Clear();
    }
    if (CURR_SYMB_AVI_DATA->Size > 0) {
        CURR_SYMB_AVI_DATA->Clear();
    }
#endif
    //CURR_SYMB_DATA->Free();
    //delete CURR_SYMB_DATA;
    CURR_SYMB_DATA = new TMemoryStream();

    //CURR_SYMB_AVI_DATA->Free();
    //delete CURR_SYMB_AVI_DATA;
    CURR_SYMB_AVI_DATA = new TMemoryStream();

    if (CURR_SYMB_DATA) {
        CURR_SYMB_DATA->Clear();
        CURR_SYMB_DATA->Size = 0;
        CURR_SYMB_DATA->Position = 0;
    }
    CURR_SYMB_AVI_DATA->Clear();
    CURR_SYMB_AVI_DATA->Position = 0;

    if (CURR_SYMB_FILE_EXT == "avi") {
        CURR_SYMB_AVI_DATA->LoadFromFile(CURR_LOCAL_FILE_NM);
        CURR_SYMB_SIZE = CURR_SYMB_AVI_DATA->Size;
    }
    else {
        CURR_SYMB_DATA->LoadFromFile(CURR_LOCAL_FILE_NM);
        CURR_SYMB_SIZE = CURR_SYMB_DATA->Size;
    }

    FSymbImag = GetPreviewSymb(CURR_SYMB_TYPE);
    if (FSymbImag == NULL) {
        Application->MessageBox(L"알수없는 이미지 심벌 형식 입니다.\r\n이미지 심벌 형식을 확인하십시요.", L"이미지 심벌 추가 실패", MB_OK|MB_ICONERROR|MB_APPLMODAL);
        BtnInsertClick((TObject*)BtnInsert);
        return;
    }

    try {
        if (CURR_SYMB_FILE_EXT == "avi") {
            ChangeSymbPage(SBT_VIDEO);

            ////////////////////////////////////////////////
            if (!FFDecoder1->LoadFile(CURR_LOCAL_FILE_NM))
            {
                Application->MessageBox(L"동영상 파일을 읽어 오는데 실패하였습니다.", L"VMS 이미지 선택", MB_OK|MB_ICONERROR|MB_APPLMODAL);
                return;
            }

            if (FFDecoder1->Decode()) {
                FFDecoder1->CopyToBitmap(ImgTemp->Picture->Bitmap);

                FSymbImag->Picture->Bitmap->Width  = FSymbImag->Width;
                FSymbImag->Picture->Bitmap->Height = FSymbImag->Height;
                APP_ImageClear(FSymbImag->Canvas, 0, 0, FSymbImag->Width, FSymbImag->Height, clBlack);
                SetStretchBltMode(FSymbImag->Canvas->Handle, MAXSTRETCHBLTMODE);//HALFTONE);//MAXSTRETCHBLTMODE)//STRETCH_HALFTONE;
                ImgVideo->Canvas->CopyRect(Classes::Rect(0, 0, FSymbImag->Width, FSymbImag->Height),
                                           ImgTemp->Picture->Bitmap->Canvas,
                                           Classes::Rect(0, 0, ImgTemp->Picture->Bitmap->Width, ImgTemp->Picture->Bitmap->Height));
                CURR_SYMB_WDTH = ImgTemp->Picture->Bitmap->Width;
                CURR_SYMB_HGHT = ImgTemp->Picture->Bitmap->Height;

                ImgVideo->Picture->Bitmap->SaveToStream(CURR_SYMB_DATA);
            }

            FFDecoder1->CloseFile();

            BtnPlay->Enabled = true;
            BtnStop->Enabled = false;
            BtnPause->Enabled = false;
        }
        else {
#if 0
            if (CURR_SYMB_FILE_EXT == "png") {
                TdxPNGImage *img = new TdxPNGImage;
                img->LoadFromStream(CURR_SYMB_DATA);
                //FSymbImag->Picture->Bitmap->Assign(img);
                //FSymbImag->Picture->Bitmap->PixelFormat = pf24bit;
                //FSymbImag->Picture->Bitmap->SaveToFile(AOutFileName);
                SAFE_DELETE(img);
            }
            else
            if (CURR_SYMB_FILE_EXT == "jpg")
            {
                TJPEGImage *img = new TJPEGImage();
                img->LoadFromStream(CURR_SYMB_DATA);
                //FSymbImag->Picture->Bitmap->Assign(img);
                //FSymbImag->Picture->Bitmap->PixelFormat = pf24bit;
                //FSymbImag->Picture->Bitmap->SaveToFile(AOutFileName);
                SAFE_DELETE(img);
            }
#endif
            FSymbImag->Picture->LoadFromFile(CURR_LOCAL_FILE_NM);

            CURR_SYMB_WDTH = FSymbImag->Picture->Width;
            CURR_SYMB_HGHT = FSymbImag->Picture->Height;
        }

        SeSize->Value = CURR_SYMB_SIZE;
        SeWidth->Value = CURR_SYMB_WDTH;
        SeHeight->Value = CURR_SYMB_HGHT;

#if 0
        if (CURR_SYMB_FILE_EXT == "ico") {
            TImage *imgIcon = new TImage(NULL);
            TIcon *icon = new TIcon();
            icon->LoadFromFile(CURR_LOCAL_FILE_NM);
            icon->AssignTo(imgIcon);
            //imgIcon->Assign(icon);
            FSymbImag->Picture->Assign(imgIcon);
            SAFE_DELETE(icon);
            SAFE_DELETE(imgIcon);
        }
#endif

#if 0
        if (CURR_SYMB_FILE_EXT == "gif") {
            TGIFImage *gif = new TGIFImage();
            //gif->LoadFromStream(CURR_SYMB_DATA);
            gif->LoadFromFile(CURR_LOCAL_FILE_NM);
            FSymbImag->Picture->Assign(NULL);
            FSymbImag->Picture->Assign(gif);
            SAFE_DELETE(gif);
            if (FSymbImag->Picture->Graphic->ClassName() == "TGIFImage") {
                ((TGIFImage *)FSymbImag->Picture->Graphic)->Animate = true;
            }
        }
#endif
        if (FSymbImag->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)FSymbImag->Picture->Graphic)->Animate = true;
        }

        if (CURR_SYMB_TYPE == SBT_TRAFFIC) {
            ImageClear(ImagTraffic1);
            ImageClear(ImagTraffic2);
            ImageClear(ImagTraffic3);

            ImagTraffic1->Picture->Bitmap->Assign(FSymbImag->Picture->Bitmap);
            ImagTraffic2->Picture->Bitmap->Assign(FSymbImag->Picture->Bitmap);
            ImagTraffic3->Picture->Bitmap->Assign(FSymbImag->Picture->Bitmap);
        }
        if (CURR_SYMB_TYPE == SBT_ATMP) {
            ImageClear(ImagAtmp1);
            ImageClear(ImagAtmp2);
            ImageClear(ImagAtmp3);
            ImageClear(ImagAtmp4);
            ImagAtmp1->Picture->Bitmap->Assign(FSymbImag->Picture->Bitmap);
        }
        if (CURR_SYMB_TYPE == SBT_WEATHER) {
            ImageClear(ImagWeather1);
            ImageClear(ImagWeather2);
            ImageClear(ImagWeather3);
            ImageClear(ImagWeather4);
            ImagWeather1->Picture->Bitmap->Assign(FSymbImag->Picture->Bitmap);
        }
        if (CURR_SYMB_TYPE == SBT_INCIDENT) {
            ImageClear(ImagIncident1);
            ImageClear(ImagIncident2);
            ImageClear(ImagIncident3);
            ImageClear(ImagIncident4);
            ImagIncident1->Picture->Bitmap->Assign(FSymbImag->Picture->Bitmap);
        }

        FImageUpdate = true;
    }
    catch(Exception &e) {
        String errMsg = "이미지 심벌 처리 중에 오류가 발생했습니다.\r\n" + e.Message;
        Application->MessageBox(errMsg.c_str(), L"이미지 심벌 추가 실패", MB_OK|MB_ICONERROR|MB_APPLMODAL);
    }

    if (FImageUpdate == false) {
        BtnInsertClick((TObject*)BtnInsert);
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::ClearListMemory()
{
#if 0
    try {
        TvList->BeginUpdate();

        int nRowCnt = TvList->ViewData->RecordCount;
        for (int ii = 0; ii < nRowCnt; ii++) {
            TcxCustomGridRow* ARow = TvList->ViewData->Rows[ii];
            TMemoryStream *pImgStream = (TMemoryStream *)(int)ARow->Values[Column99->Index];
            SAFE_DELETE(pImgStream);
        }
    }
    __finally {
        TvList->EndUpdate();
    }
#endif
    CMM_ClearGridTableView(TvList);
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::LoadImageSymbol()
{
    FormInit();

    ClearListMemory();

    String sQry;
    TADOQuery *pADO = NULL;

    sQry = "SELECT *                                \r\n"
           "  FROM TB_VMS_SYMB_LIB                  \r\n"
           " WHERE 1=1                              \r\n"
           //"   AND SYMB_NMBR BETWEEN 6000 AND 6999  \r\n"
           "   AND USE_YN = 'Y'                     \r\n"
           " ORDER BY SYMB_NMBR                     \r\n";

    int nRowHeight = 0;
    try
    {
        int nRow;
        TcxDataController *pGDC = TvList->DataController;
        TvList->BeginUpdate();
        try
        {
            pADO = new TADOQuery(NULL);
			pADO->Close();
            pADO->Connection = ITSDb_GetConnection();

            ITSDb_SQLText(pADO, sQry);
            ITSDb_SQLOpen(pADO);

            String tempFileExt;
            String imageFilePath;
            String videoFilePath;
            String saveDirPath = TPath::GetTempPath() + "VMS\\";
            ForceDirectories(saveDirPath.c_str());
            for( ; !pADO->Eof; pADO->Next())
            {
                nRow = pGDC->AppendRecord();

                String SYMB_NMBR = pADO->FieldByName("SYMB_NMBR")->AsString;
                String SYMB_TYPE = pADO->FieldByName("SYMB_TYPE")->AsString;
                String SYMB_FILE_EXT = pADO->FieldByName("SYMB_FILE_EXT")->AsString;

                pGDC->Values[nRow][ColSYMB_NMBR->Index]     = SYMB_NMBR;
                pGDC->Values[nRow][ColSYMB_TYPE->Index]     = SYMB_TYPE;
                pGDC->Values[nRow][ColSYMB_NM->Index]       = pADO->FieldByName("SYMB_NM")->AsString;
                pGDC->Values[nRow][ColSYMB_EXPL->Index]     = pADO->FieldByName("SYMB_EXPL")->AsString;
                pGDC->Values[nRow][ColSYMB_DATA->Index]     = pADO->FieldByName("SYMB_DATA")->AsVariant;
                pGDC->Values[nRow][ColSYMB_FILE_NM->Index]  = pADO->FieldByName("SYMB_FILE_NM")->AsString;
                pGDC->Values[nRow][ColSYMB_FILE_EXT->Index] = SYMB_FILE_EXT;
                pGDC->Values[nRow][ColSYMB_SIZE->Index]     = pADO->FieldByName("SYMB_SIZE")->AsInteger;
                pGDC->Values[nRow][ColSYMB_WDTH->Index]     = pADO->FieldByName("SYMB_WDTH")->AsInteger;
                pGDC->Values[nRow][ColSYMB_HGHT->Index]     = pADO->FieldByName("SYMB_HGHT")->AsInteger;
                pGDC->Values[nRow][ColPLAY_TM->Index]       = pADO->FieldByName("PLAY_TM")->AsInteger;
                pGDC->Values[nRow][ColBASE_YN->Index]       = pADO->FieldByName("BASE_YN")->AsString;
                pGDC->Values[nRow][ColUSE_YN->Index]        = pADO->FieldByName("USE_YN")->AsString;

                pGDC->Values[nRow][ColSYMB_TYPE_DESC->Index] = GetSymbTypeDesc(SYMB_TYPE);

                TMemoryStream *pImgStream = new TMemoryStream();
                pImgStream->LoadFromStream(pADO->CreateBlobStream(pADO->FieldByName("SYMB_DATA"), bmRead));
                //pGDC->Values[nRow][Column99->Index] = (int)pImgStream;
                videoFilePath = "";
                tempFileExt = SYMB_FILE_EXT;
                if (SYMB_FILE_EXT.Pos("avi")) {
                    tempFileExt = "bmp";
                    TMemoryStream *pAviStream = new TMemoryStream();
                    pAviStream->LoadFromStream(pADO->CreateBlobStream(pADO->FieldByName("SYMB_AVI_DATA"), bmRead));
                    videoFilePath = saveDirPath + SYMB_NMBR + "." + SYMB_FILE_EXT;
                    pAviStream->SaveToFile(videoFilePath);
                    SAFE_DELETE(pAviStream);
                }
                imageFilePath = saveDirPath + SYMB_NMBR + "." + tempFileExt;
                pImgStream->SaveToFile(imageFilePath);
                SAFE_DELETE(pImgStream);

                pGDC->Values[nRow][ColImagePath->Index] = imageFilePath;
                pGDC->Values[nRow][ColVideoPath->Index] = videoFilePath;
            }
        }
        catch(EDatabaseError &E)
        {
            DBERRORMSG("VMS Symbol Query", String(E.ClassName()), E.Message, sQry);
            throw Exception(String(E.ClassName()) + E.Message);
        }
        catch(Exception &e)
        {
            DBERRORMSG("VMS Symbol Query", String(e.ClassName()), e.Message, sQry);
            throw Exception(String(e.ClassName()) + e.Message);
        }
    }
    __finally
    {
        if (pADO)
        {
            pADO->Close();
            delete pADO;
        }
        //TvList->OptionsView->DataRowHeight = nRowHeight;
        TvList->EndUpdate();
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::TvListCellDblClick(TcxCustomGridTableView *Sender, TcxGridTableDataCellViewInfo *ACellViewInfo,
          TMouseButton AButton, TShiftState AShift,
          bool &AHandled)
{
	if (!ACellViewInfo) return;

    DisplayInfo();
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::ColSYMB_DATACustomDrawCell(TcxCustomGridTableView *Sender,
          TcxCanvas *ACanvas, TcxGridTableDataCellViewInfo *AViewInfo,
          bool &ADone)
{
#if 0
    int nRow = AViewInfo->GridRecord->RecordIndex;
    if (nRow < 0) return;

    try
    {
        Graphics::TBitmap *pBmp = (Graphics::TBitmap*)FListSymb->Items[nRow];

        TRect rc;
        TRect rcOrg = AViewInfo->Bounds;
        int nH = ( (rcOrg.Bottom - rcOrg.Top) - pBmp->Height ) / 2;

        rc.Top    = rcOrg.Top    + nH+1;
        rc.Bottom = rcOrg.Bottom - nH+1;
        rc.Left   = rcOrg.Left + 1;
        rc.Right  = rc.Left + pBmp->Width;

        ACanvas->Canvas->StretchDraw(rc, pBmp);
        ADone = true;
    }
    catch(Exception &e)
    {
    }
#endif
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::TvListFocusedRecordChanged(TcxCustomGridTableView *Sender,
          TcxCustomGridRecord *APrevFocusedRecord, TcxCustomGridRecord *AFocusedRecord,
          bool ANewItemRecordFocusingChanged)
{
    if (!AFocusedRecord) return;
    DisplayInfo();
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::CbTypePropertiesChange(TObject *Sender)
{
    if (CbType->Text.Pos(SBT_GENERAL)) {
        //if (LblDesc->Visible) LblDesc->Visible = false;
    }
    else {
        //if (LblDesc->Visible == false) LblDesc->Visible = true;
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::PnlMenuDblClick(TObject *Sender)
{
    FIsUpdate = true;
}
//---------------------------------------------------------------------------

bool __fastcall TFrmVmsSymbMngr::DeleteVmsSymbLib(int SYMB_NMBR, bool ADelete)
{
    String sQry;
    TADOQuery *pADO = NULL;

    if (ADelete) {
    sQry = "DELETE TB_VMS_SYMB_LIB   \r\n"
           " WHERE SYMB_NMBR = :p01  \r\n";
    }
    else {
    sQry = "UPDATE TB_VMS_SYMB_LIB   \r\n"
           "   SET USE_YN = 'N'      \r\n"
           " WHERE SYMB_NMBR = :p01  \r\n";
    }

    try
    {
        try
        {
            pADO = new TADOQuery(NULL);
			pADO->Close();
            pADO->Connection = ITSDb_GetConnection();

            ITSDb_SQLText(pADO, sQry);

            pADO->Parameters->ParamByName("p01")->Value = SYMB_NMBR;

			pADO->ExecSQL();
        }
        catch(EDatabaseError &E)
        {
            DBERRORMSG("TFrmVmsSymbMngr::DeleteVmsSymbLib", String(E.ClassName()), E.Message, sQry);
            return false;
        }
        catch(Exception &e)
        {
            DBERRORMSG("TFrmVmsSymbMngr::DeleteVmsSymbLib", String(e.ClassName()), e.Message, sQry);
            return false;
        }
    }
    __finally
    {
        if (pADO)
        {
            pADO->Close();
            delete pADO;
        }

    }
    return true;
}
//---------------------------------------------------------------------------
bool __fastcall TFrmVmsSymbMngr::InsertVmsSymbLib(int    SYMB_NMBR,
                                                  String SYMB_TYPE,
                                                  String SYMB_NM,
                                                  String SYMB_EXPL,
                                                  TMemoryStream *SYMB_DATA,
                                                  TMemoryStream *SYMB_AVI_DATA,
                                                  String SYMB_FILE_NM,
                                                  String SYMB_FILE_EXT,
                                                  int    SYMB_SIZE,
                                                  int    SYMB_WDTH,
                                                  int    SYMB_HGHT,
                                                  int    PLAY_TM,
                                                  String BASE_YN,
                                                  String USE_YN) {
    String sQry;
    TADOQuery *pADO = NULL;

    sQry = "INSERT INTO TB_VMS_SYMB_LIB (      \r\n"
           "            SYMB_NMBR,             \r\n"
           "            SYMB_TYPE,             \r\n"
           "            SYMB_NM,               \r\n"
           "            SYMB_EXPL,             \r\n"
           "            SYMB_DATA,             \r\n"
           "            SYMB_AVI_DATA,         \r\n"
           "            SYMB_FILE_NM,          \r\n"
           "            SYMB_FILE_EXT,         \r\n"
           "            SYMB_SIZE,             \r\n"
           "            SYMB_WDTH,             \r\n"
           "            SYMB_HGHT,             \r\n"
           "            PLAY_TM,               \r\n"
           "            BASE_YN,               \r\n"
           "            USE_YN )               \r\n"
           "   VALUES (                        \r\n"
           "           :p01,                   \r\n"
           "           :p02,                   \r\n"
           "           :p03,                   \r\n"
           "           :p04,                   \r\n"
           "           :p05,                   \r\n"
           "           :p06,                   \r\n"
           "           :p07,                   \r\n"
           "           :p08,                   \r\n"
           "           :p09,                   \r\n"
           "           :p10,                   \r\n"
           "           :p11,                   \r\n"
           "           :p12,                   \r\n"
           "           :p13,                   \r\n"
           "           :p14 )                  \r\n";


    try
    {
        try
        {
            pADO = new TADOQuery(NULL);
			pADO->Close();
            pADO->Connection = ITSDb_GetConnection();

            ITSDb_SQLText(pADO, sQry);

            pADO->Parameters->ParamByName("p01")->Value = SYMB_NMBR;
            pADO->Parameters->ParamByName("p02")->Value = SYMB_TYPE;
            pADO->Parameters->ParamByName("p03")->Value = SYMB_NM;
            pADO->Parameters->ParamByName("p04")->Value = SYMB_EXPL;
            pADO->Parameters->ParamByName("p05")->LoadFromStream(SYMB_DATA, ftBlob);
            if (SYMB_AVI_DATA->Size > 0) {
                pADO->Parameters->ParamByName("p06")->LoadFromStream(SYMB_AVI_DATA, ftBlob);
            }
            else {
                pADO->Parameters->ParamByName("p06")->Value = "";
            }
            pADO->Parameters->ParamByName("p07")->Value = SYMB_FILE_NM;
            pADO->Parameters->ParamByName("p08")->Value = SYMB_FILE_EXT;
            pADO->Parameters->ParamByName("p09")->Value = SYMB_SIZE;
            pADO->Parameters->ParamByName("p10")->Value = SYMB_WDTH;
            pADO->Parameters->ParamByName("p11")->Value = SYMB_HGHT;
            pADO->Parameters->ParamByName("p12")->Value = PLAY_TM;
            pADO->Parameters->ParamByName("p13")->Value = BASE_YN;
            pADO->Parameters->ParamByName("p14")->Value = USE_YN;

			pADO->ExecSQL();
        }
        catch(EDatabaseError &E)
        {
            DBERRORMSG("TFrmVmsSymbMngr::InsertVmsSymbLib", String(E.ClassName()), E.Message, sQry);
            return false;
        }
        catch(Exception &e)
        {
            DBERRORMSG("TFrmVmsSymbMngr::InsertVmsSymbLib", String(e.ClassName()), e.Message, sQry);
            return false;
        }
    }
    __finally
    {
        if (pADO)
        {
            pADO->Close();
            delete pADO;
        }
        SAFE_DELETE(SYMB_DATA);

    }
    return true;
}
//---------------------------------------------------------------------------
bool __fastcall TFrmVmsSymbMngr::GetNextVmsSymbNmbr(int &ANmbr, int AFromId, int AToId)
{
    String sQry;
    TADOQuery *pADO = NULL;

    sQry = "SELECT NVL(MAX(SYMB_NMBR), :p01)+1 AS NEWID FROM TB_VMS_SYMB_LIB WHERE SYMB_NMBR BETWEEN :p02 AND :p03 \r\n";

    try
    {
        try
        {
            pADO = new TADOQuery(NULL);
			pADO->Close();
            pADO->Connection = ITSDb_GetConnection();

            ITSDb_SQLText(pADO, sQry);
            ITSDb_SQLBind(pADO, "p01", AFromId-1);
            ITSDb_SQLBind(pADO, "p02", AFromId);
            ITSDb_SQLBind(pADO, "p03", AToId);
            ITSDb_SQLOpen(pADO);

			pADO->Open();
            ANmbr = pADO->FieldByName("NEWID")->AsInteger;
        }
        catch(EDatabaseError &E)
        {
            DBERRORMSG("GetNextVmsImgeId", String(E.ClassName()), E.Message, sQry);
            return false;
        }
        catch(Exception &e)
        {
            DBERRORMSG("GetNextVmsImgeId", String(e.ClassName()), e.Message, sQry);
            return false;
        }
    }
    __finally
    {
        if (pADO)
        {
            pADO->Close();
            delete pADO;
        }
    }
    return true;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::MnuAddVmsSymbClick(TObject *Sender)
{
    int START_NMBR, END_NMBR;

    TMenuItem *pMenu = (TMenuItem*)Sender;
    switch(pMenu->Tag) {
    case 1: CURR_SYMB_TYPE = SBT_GENERAL;  START_NMBR = 1000; END_NMBR = 1999; break;  // 일반
    case 2: CURR_SYMB_TYPE = SBT_TRAFFIC;  START_NMBR = 2000; END_NMBR = 2999; break;  // 소통정보
    case 3: CURR_SYMB_TYPE = SBT_ATMP;     START_NMBR = 3000; END_NMBR = 3999; break;  // 대기환경
    case 4: CURR_SYMB_TYPE = SBT_WEATHER;  START_NMBR = 4000; END_NMBR = 4999; break;  // 기상정보
    case 5: CURR_SYMB_TYPE = SBT_INCIDENT; START_NMBR = 5000; END_NMBR = 5999; break;  // 돌발
    case 6: CURR_SYMB_TYPE = SBT_VIDEO;    START_NMBR = 6000; END_NMBR = 6999; break;  // 동영상
    case 7: CURR_SYMB_TYPE = SBT_TRAFBAK;  START_NMBR = 7000; END_NMBR = 7999; break;  // 소통정보배경
    default: return;
    }

    String symbDefExt = "";
    String symbFilter = "";
    switch(pMenu->Tag) {
    case 1: symbDefExt = "bmp"; symbFilter = "심벌 (*.gif;*.png;*.jpg;*.jpeg;*.bmp;*.ico)|*.gif;*.png;*.jpg;*.jpeg;*.bmp;*.ico"; break;  // 일반
    case 2: symbDefExt = "bmp"; symbFilter = "소통정보 (*.bmp)|*.bmp"; break;  // 소통정보
    case 3: symbDefExt = "bmp"; symbFilter = "대기환경 (*.gif;*.png;*.jpg;*.jpeg;*.bmp)|*.gif;*.png;*.jpg;*.jpeg;*.bmp"; break;  // 대기환경
    case 4: symbDefExt = "bmp"; symbFilter = "기상정보 (*.gif;*.png;*.jpg;*.jpeg;*.bmp;*.avi)|*.gif;*.png;*.jpg;*.jpeg;*.bmp;*.avi"; break;  // 기상정보
    case 5: symbDefExt = "bmp"; symbFilter = "돌발 (*.gif;*.png;*.jpg;*.jpeg;*.bmp)|*.gif;*.png;*.jpg;*.jpeg;*.bmp"; break;  // 돌발
    case 6: symbDefExt = "avi"; symbFilter = "동영상 (*.avi)|*.avi"; break;  // 동영상
    case 7: symbDefExt = "bmp"; symbFilter = "소통정보배경 (*.bmp)|*.bmp"; break;  // 소통정보배경
    default: return;
    }
    OpenBmp->DefaultExt = symbDefExt;
    OpenBmp->Filter = symbFilter;

    FormInit();

    if (!GetNextVmsSymbNmbr(CURR_SYMB_NMBR, START_NMBR, END_NMBR)) {
        Application->MessageBox(L"새로운 이미지 심벌 번호 생성에 실패하였습니다.",
                                FTitle.c_str(), MB_OK|MB_ICONERROR|MB_APPLMODAL);
        return;
    }

    EdNmbr->Text = String(CURR_SYMB_NMBR);

    ChangeEditMode(2);
    FNewDb = true;

    ChangeSymbPage(CURR_SYMB_TYPE);

    if (OpenBmp->InitialDir == "") {
        OpenBmp->InitialDir = g_sAppDir;
    }

    OpenBmp->Title = FTitle;
    OpenBmp->FileName = "";
    if (!OpenBmp->Execute()) {
        ChangeEditMode(1);
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::ChangeSymbPage(String ASymbType)
{
    int itemIdx = -1;
    for (int ii = 0; ii < CbType->Properties->Items->Count; ii++) {
        String itemText = CbType->Properties->Items->Strings[ii];
        if (itemText.Pos(ASymbType)) {
            itemIdx = ii;
            break;
        }
    }
    CbType->ItemIndex = itemIdx;

    if (ASymbType == SBT_TRAFFIC
     || ASymbType == SBT_ATMP
     || ASymbType == SBT_WEATHER
     || ASymbType == SBT_INCIDENT) {
        EdExpl->Properties->ReadOnly = true;
    }
    else EdExpl->Properties->ReadOnly = false;

    TcxTabSheet *pNewActive = NULL;
    String grpSymbCaption = "▶ 일반 심볼 이미지";
    if (ASymbType == SBT_GENERAL) {
        pNewActive = TsSbt1;
        grpSymbCaption = "▶ 일반 심볼 이미지";
    }
    else if (ASymbType == SBT_TRAFFIC) {
        pNewActive = TsSbt2;
        grpSymbCaption = "▶ 소통정보 심볼 이미지";
    }
    else if (ASymbType == SBT_ATMP)
    {
        pNewActive = TsSbt3;
        grpSymbCaption = "▶ 대기환경 심볼 이미지";
    }
    else if (ASymbType == SBT_WEATHER) {
        pNewActive = TsSbt4;
        grpSymbCaption = "▶ 기상정보 심볼 이미지";
    }
    else if (ASymbType == SBT_INCIDENT) {
        pNewActive = TsSbt5;
        grpSymbCaption = "▶ 돌발 심볼 이미지";
    }
    else if (ASymbType == SBT_VIDEO) {
        pNewActive = TsSbt6;
        grpSymbCaption = "▶ 동영상 심볼 이미지";
    }
    else if (ASymbType == SBT_TRAFBAK) {
        pNewActive = TsSbt7;
        grpSymbCaption = "▶ 소통정보 배경 심볼 이미지";
    }
    else return;

    TcxTabSheet *pCurActive = PgSymb->Properties->ActivePage;
    if (pNewActive != pCurActive) {
        PgSymb->Properties->ActivePage = pNewActive;
        GrpSymbBox->Caption = grpSymbCaption;
    }
}
//---------------------------------------------------------------------------

String __fastcall TFrmVmsSymbMngr::GetSymbTypeDesc(String ASymbType)
{
    if (ASymbType == SBT_GENERAL) {
        return "일반";
    }
    else if (ASymbType == SBT_TRAFFIC) {
        return "소통정보";
    }
    else if (ASymbType == SBT_ATMP)
    {
        return "대기환경";
    }
    else if (ASymbType == SBT_WEATHER) {
        return "기상정보";
    }
    else if (ASymbType == SBT_INCIDENT) {
        return "돌발";
    }
    else if (ASymbType == SBT_VIDEO) {
        return "동영상";
    }
    else if (ASymbType == SBT_TRAFBAK) {
        return "소통정보 배경";
    }
    return "?-" + ASymbType;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::FFPlayer1FileOpen(TObject *Sender, const __int64 ADuration, int AFrameWidth, int AFrameHeight,
          int &AScreenWidth, int &AScreenHeight)
{
#if 0
    FPlayTime = (ADuration + 5000) / 1000000;
    FPlayTime++;
    FThumbNail = 0;
    FMakeThumbNail = true;
#endif

    FDuration = ADuration;
    lblDuration->Caption = DurationToStr(ADuration);
    lblCurrentPTS->Caption = "N/A";

    // setup track bar
    TrackBar->Frequency = 5;
    TrackBar->TickStyle = tsAuto;
    TrackBar->Max = TrackBar->Width;
    TrackBar->SelStart = 0;
    TrackBar->SelEnd = 0;
    TrackBar->SliderVisible = ADuration > 0;

    FTrackChanging = true;
    try
    {
        TrackBar->Position = 0;
    }
    __finally
    {
        FTrackChanging = false;
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::FFPlayer1OpenFailed(TObject *Sender)
{
    String sLastErrMsg = FFPlayer1->LastErrMsg;
    PnlPlayer->Caption = sLastErrMsg;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::FFPlayer1Position(TObject *Sender, const __int64 APTS)
{
    lblCurrentPTS->Caption = DurationToStr(APTS);
    if ((APTS >= 0) && (FDuration > 0))
    {
        TrackBar->SelEnd = TrackBar->Max * APTS / FDuration;
        if (FTrackChanging == false && (IsMouseDown() == false ||  TrackBar->Focused() == false))
        {
            FTrackChanging = true;
            try
            {
                TrackBar->Position = TrackBar->Max * APTS / FDuration;
            }
            __finally
            {
                FTrackChanging = false;
            }
        }
        if (FMakeThumbNail)
        {
            FThumbNail++;
            if (FThumbNail > 2)
            {
                //섬네일이미지 생성
                FMakeThumbNail = false;
            }
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::FFPlayer1State(TObject *Sender, TPlayState APlayState)
{
    switch(APlayState)
    {
    case Ffbasecomponent::psPlay:
    case Ffbasecomponent::psResume:
        break;
    case Ffbasecomponent::psPause:
    case Ffbasecomponent::psStep:
        break;
    case Ffbasecomponent::psStop:
        if (FFPlayer1->ScreenHandle != NULL)
        {
            PostMessage(FFPlayer1->ScreenHandle, CM_INVALIDATE, 0, 0);
            UpdateWindow(FFPlayer1->ScreenHandle);
        }
        break;
    case Ffbasecomponent::psEnd:
        {
            FFPlayer1->Stop(true);
            //FFPlayer1->Seek((__int64)0, TSeekFlags()<<sfBackward);
        }
        break;
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::TrackBarChange(TObject *Sender)
{
    if (!FTrackChanging && !IsMouseDown())
    {
        FFPlayer1->Seek(FDuration * TrackBar->Position / TrackBar->Max);
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::BtnPlayClick(TObject *Sender)
{
    BtnPlay->Enabled = false;
Application->ProcessMessages();
    try {
        if (FFPlayer1->ScreenHandle != NULL)
        {
            FFPlayer1->Stop(true);
            PostMessage(FFPlayer1->ScreenHandle, CM_INVALIDATE, 0, 0);
            UpdateWindow(FFPlayer1->ScreenHandle);
        }

        FFPlayer1->AspectRatio = ChkFitScreen->Checked ? -1 : 0;
        FFPlayer1->TryOpen(CURR_LOCAL_FILE_NM, PnlPlayer->Handle);

Application->ProcessMessages();
    }
    catch(Exception &e)
    {
    }
    BtnStop->Enabled = true;
    BtnPause->Enabled = true;

    FPlayStream = true;
    ImgVideo->Visible = false;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::BtnStopClick(TObject *Sender)
{
    BtnStop->Enabled = false;
    BtnPause->Enabled = false;
    if (FFPlayer1->ScreenHandle != NULL) {
        FFPlayer1->Stop(true);
    }
    BtnPlay->Enabled = true;
    FPlayStream = false;
    ImgVideo->Visible = true;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::BtnPauseClick(TObject *Sender)
{
    try
    {
        if (FFPlayer1->ScreenHandle != NULL)
        {
            FFPlayer1->TogglePause();
        }
Application->ProcessMessages();
    }
    catch(Exception &e)
    {
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::ChkFitScreenClick(TObject *Sender)
{
    FFPlayer1->AspectRatio = ChkFitScreen->Checked ? -1 : 0;
}
//---------------------------------------------------------------------------

TImage* __fastcall TFrmVmsSymbMngr::GetPreviewSymb(String ASymbType)
{
    TImage *imagSymb = NULL;
    if (ASymbType == SBT_GENERAL) {
        imagSymb = ImgGeneral;
    }
    else if (ASymbType == SBT_TRAFFIC) {
        imagSymb = ImagTraffic;
    }
    else if (ASymbType == SBT_ATMP) {
        imagSymb = ImagAtmp;
    }
    else if (ASymbType == SBT_WEATHER) {
        imagSymb = ImagWeather;
    }
    else if (ASymbType == SBT_INCIDENT) {
        imagSymb = ImagIncident;
    }
    else if (ASymbType == SBT_VIDEO) {
        imagSymb = ImgVideo;
    }
    else if (ASymbType == SBT_TRAFBAK) {
        imagSymb = ImagTrafBack;
    }
    return imagSymb;
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::ImagTrafficMouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y)
{
    if (!FNewDb) return;

    ImageClear(ImagTraffic1);
    ImageClear(ImagTraffic2);
    ImageClear(ImagTraffic3);

    ImagTraffic1->Picture->Bitmap->Assign(ImagTraffic->Picture->Bitmap);
    ImagTraffic2->Picture->Bitmap->Assign(ImagTraffic->Picture->Bitmap);
    ImagTraffic3->Picture->Bitmap->Assign(ImagTraffic->Picture->Bitmap);

    TColor FOldColor = ImagTraffic->Picture->Bitmap->Canvas->Pixels[X][Y];

    ImagTraffic1->Picture->Bitmap->Canvas->Brush->Color = clLime;
    ImagTraffic1->Picture->Bitmap->Canvas->FloodFill(X, Y, FOldColor, fsSurface);

    ImagTraffic2->Picture->Bitmap->Canvas->Brush->Color = clYellow;
    ImagTraffic2->Picture->Bitmap->Canvas->FloodFill(X, Y, FOldColor, fsSurface);

    ImagTraffic3->Picture->Bitmap->Canvas->Brush->Color = clRed;
    ImagTraffic3->Picture->Bitmap->Canvas->FloodFill(X, Y, FOldColor, fsSurface);
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::ImageClear(TImage *AImage)
{
    AImage->Picture->Bitmap->FreeImage();
    AImage->Picture->Bitmap->ReleaseHandle();
    AImage->Picture->Assign(NULL);
    AImage->Repaint();
    AImage->Invalidate();
}
//---------------------------------------------------------------------------

void __fastcall TFrmVmsSymbMngr::OpenSubImagCanClose(TObject *Sender, bool &CanClose)
{
    if (FSelImag == NULL) {
        return;
    }

    // 이미지별로 형식이 다를수 있으니까 멤버변수를 배열로 선언해서 처리하자......

    String localFileName = OpenSubImag->FileName;
    String sFilePath = ExtractFilePath(CURR_LOCAL_FILE_NM);
    String sFileName = ExtractFileName(CURR_LOCAL_FILE_NM);
    String sFileExt  = ExtractFileExt(CURR_LOCAL_FILE_NM);

    OpenSubImag->InitialDir = OpenBmp->InitialDir;

    CURR_SYMB_FILE_EXT = "";
    sFileExt = StringReplace(sFileExt, ".", "", TReplaceFlags() << rfReplaceAll);
    sFileExt = sFileExt.LowerCase();

    TSymbFmt *symbFmt = g_SymbFmtLists.Find(sFileExt);
    if (symbFmt == NULL) {
        Application->MessageBox(L"이미지 심벌로 지원하지 않는 형식입니다.\r\n지원형식(bmp, jpg, png, avi, ico)", L"이미지 심벌 추가 실패", MB_OK|MB_ICONERROR|MB_APPLMODAL);
        BtnInsertClick((TObject*)BtnInsert);
        return;
    }
    CURR_SYMB_FILE_EXT = symbFmt->fmtType;

    if (CURR_SYMB_TYPE == SBT_TRAFFIC || CURR_SYMB_TYPE == SBT_TRAFBAK) {
        if (CURR_SYMB_FILE_EXT != "bmp") {
            Application->MessageBox(L"이미지 심벌 유형에 허용되지 않는 이미지 형식입니다.[bmp 형식 지원]", L"이미지 심벌 추가 실패", MB_OK|MB_ICONERROR|MB_APPLMODAL);
            BtnInsertClick((TObject*)BtnInsert);
            return;
        }
    }

    FImageUpdate = false;
    CURR_SYMB_DATA->LoadFromFile(CURR_LOCAL_FILE_NM);

    TImage *imagSymb = FSelImag;
    if (imagSymb == NULL) {
        Application->MessageBox(L"알수없는 이미지 심벌 형식 입니다.\r\n이미지 심벌 형식을 확인하십시요.", L"이미지 심벌 추가 실패", MB_OK|MB_ICONERROR|MB_APPLMODAL);
        BtnInsertClick((TObject*)BtnInsert);
        return;
    }

    try {
        if (CURR_SYMB_FILE_EXT == "avi") {

            ////////////////////////////////////////////////
            if (!FFDecoder1->LoadFile(CURR_LOCAL_FILE_NM))
            {
                Application->MessageBox(L"동영상 파일을 읽어 오는데 실패하였습니다.", L"VMS 이미지 선택", MB_OK|MB_ICONERROR|MB_APPLMODAL);
                return;
            }

            if (FFDecoder1->Decode()) {
                FFDecoder1->CopyToBitmap(ImgTemp->Picture->Bitmap);

                imagSymb->Picture->Bitmap->Width  = imagSymb->Width;
                imagSymb->Picture->Bitmap->Height = imagSymb->Height;
                APP_ImageClear(imagSymb->Canvas, 0, 0, imagSymb->Width, imagSymb->Height, clBlack);
                SetStretchBltMode(imagSymb->Canvas->Handle, MAXSTRETCHBLTMODE);//HALFTONE);//MAXSTRETCHBLTMODE)//STRETCH_HALFTONE;
                ImgVideo->Canvas->CopyRect(Classes::Rect(0, 0, imagSymb->Width, imagSymb->Height),
                                           ImgTemp->Picture->Bitmap->Canvas,
                                           Classes::Rect(0, 0, ImgTemp->Picture->Bitmap->Width, ImgTemp->Picture->Bitmap->Height));
                CURR_SYMB_WDTH = ImgTemp->Picture->Bitmap->Width;
                CURR_SYMB_HGHT = ImgTemp->Picture->Bitmap->Height;
            }

            FFDecoder1->CloseFile();

            BtnPlay->Enabled = true;
            BtnStop->Enabled = false;
            BtnPause->Enabled = false;
        }
        else {
            imagSymb->Picture->LoadFromFile(CURR_LOCAL_FILE_NM);
            CURR_SYMB_WDTH  = imagSymb->Picture->Width;
            CURR_SYMB_HGHT = imagSymb->Picture->Height;
        }

        CURR_SYMB_SIZE = CURR_SYMB_DATA->Size;
        SeSize->Value = CURR_SYMB_SIZE;
        SeWidth->Value = CURR_SYMB_WDTH;
        SeHeight->Value = CURR_SYMB_HGHT;

        if (imagSymb->Picture->Graphic->ClassName() == "TGIFImage") {
            ((TGIFImage *)imagSymb->Picture->Graphic)->Animate = true;
        }
    }
    catch(Exception &e) {
        String errMsg = "이미지 심벌 처리 중에 오류가 발생했습니다.\r\n" + e.Message;
        Application->MessageBox(errMsg.c_str(), L"이미지 심벌 추가 실패", MB_OK|MB_ICONERROR|MB_APPLMODAL);
    }
}
//---------------------------------------------------------------------------


void __fastcall TFrmVmsSymbMngr::BtnSubImageSelectClick(TObject *Sender)
{
    TcxButton *pBtn = (TcxButton*)Sender;

    FSelImag = NULL;
    switch(pBtn->Tag) {
    case 10: FSelImag = ImagAtmp1; break;
    case 11: FSelImag = ImagAtmp2; break;
    case 12: FSelImag = ImagAtmp3; break;
    case 13: FSelImag = ImagAtmp4; break;

    case 20: FSelImag = ImagWeather1; break;
    case 21: FSelImag = ImagWeather2; break;
    case 22: FSelImag = ImagWeather3; break;
    case 23: FSelImag = ImagWeather4; break;

    case 30: FSelImag = ImagIncident1; break;
    case 31: FSelImag = ImagIncident2; break;
    case 32: FSelImag = ImagIncident3; break;
    case 33: FSelImag = ImagIncident4; break;

    default: return;
    }

    OpenSubImag->DefaultExt = OpenBmp->DefaultExt;
    OpenSubImag->Filter = OpenBmp->Filter;

    OpenSubImag->InitialDir = OpenBmp->InitialDir;
    OpenSubImag->Title = FTitle;
    OpenSubImag->FileName = "";
    OpenSubImag->Execute();
}
//---------------------------------------------------------------------------