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

#ifndef tree_treeH                                                                                 
#define tree_treeH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------


#include  "font.h"
#include  "c_define.h"
#include  "ide_popup.h"

//[2012.04.20.금][추가!!!]
#include "str_heap.h"

//[2012.05.19.토][추가!!!]
#include "str_conf.h"

//[2012.05.25.금][추가!!!]
#include "ide_hint.h"


struct  TREEITEM
{
  //[2006.11.16.목][생성!!!]{------------
  //tree 에서 항목 하나의 정보를 갖는다.
  //}------------------------------------

  //종류를 구분한다. (BASE : '.')
  char   kind;
  //{
      //'+' : 펼칠수 있는 옹이.
      //'-' : 이미 펼쳐진 옹이.
      //'.' : 단순 개별 항목.
      //반드시 이 3개중 하나를 갖는다.
  //}

  //[줄기] 의 단계를 가진다.(BASE : 0)
  //0 은 [뿌리] 가 되며, 값이 클수록 level 이 낮은 것이다.
  int    level;

  //[항목] 을 내부적으로 구분하는 이름.(중복될수 없다.)
  char   name[OPT_name_length];

  //[!]{---------------------------------------------------------------------------------
  //[항목] 을 표시하는 문자열.(중복될수 있다.)
  //[2012.04.17.화][수정!!!]-------------------------------------------------------------
  //{DB} 처럼 [문자열] 의 경우는 [동적생성] 으로 관리하는 것으로 수정.
  //[함수선언정보] 가 지정 크기를 넘는 경우가 많아서 전체 문자열을 관리할수 있어야 한다.
  //char   txt[OPT_Tree_Item_Text_length];
  //
  //[2012.04.18.수][참고!!!]-------------------------------------------------------------
  //<txt> 가 동적 삭제되고 재생성 되는 경우는 아래와 같다.
  //1) [Tree] 전체가 지워지는(삭제가 아니라 비워지는) 경우.
  //2) 항목이 삭제되는 경우.
  //3) 새로운 문자열이 할당되는 경우.
  //
  //반드시 <_Item_Txt()> 함수를 사용해서 할당해야 한다.
  //char  *txt;
  //
  //[2012.04.20.금][중요수정!!!]---------------------------------------------------------
  //<STRHEAP> 상의 위치 <index> 값으로 수정.
  //계속 동적 [생성/삭제] 를 반복하지 않고 [문자열 저장소] 를 별도로 관리하기 위한것.
  //<item> 자체가 [동적 생성] 개체이고 이 안의 <txt> 도 [동적 생성] 개체인 경우
  //<item> 을 [삭제] 시 <txt> 도 같이 삭제되거나 불확정되는 문제가 발생.
  //아예 별도 관리하는 것으로 한다.
  //
  //[STRHEAP] 상에서 문자열을 관리하는 [목록 번호(index)] 가 된다.
  //반드시 초기값은 <-1> 로 [목록없음] 으로 초기화.
  int   txt; //(기본값 : -1)
  //}------------------------------------------------------------------------------------

  //[항목-엄지그림] 의 순번을 저장한다.
  int   bmpindex;

  //[2019.02.20.수][추가]{---------------------------------------------
  //이 항목이 등록된 [옹이] 의 마지막 항목인 경우는 <true>.
  //이 항목이 [삭제] 된 경우는 이전 항목을 <true> 로 설정해 줘야 한다.
  bool  lastItem;
  //}------------------------------------------------------------------

  //[추가정보]
  //{
      //[중요!!!]//[2009.01.25.일][추가!!!]{----------------------------------------------------
      //{DATABASE} 상의 record-index 를 관리한다.
      //이는 [항목] 을 선택한 경우 해당 정보가 있는 문서를 열고 정보를 지정해 주기 위한 것이다.
      //다양한 정보를 보여 주어야 하므로 바로 찾을수 있도록 {DATABASE} 와 연동하기 위한 것이다.
      //(BASE : -1)
      //
      //[2019.02.17.일][참고]*******************************************************************
      //<info1/2/3> 는 [전체찾기] 기능에서도 사용한다.
      //<info1> : 찾은 문서에서 해당 [찾은문자열] 시작 위치.
      //<info2> : 찾은 문서에서 해당 [찾은문자열] 끝 위치.
      //
      //[2019.02.26.화][추가]
      //<info3> : 찾은 문서에서 해당 [찾은문자열] 이 위치한 [행:시작위치].
      //}---------------------------------------------------------------------------------------

      //[2011.07.10.일][수정!!!]
      //<dbRecIndex> 에서 일반적인 [부가정보] 로 번호를 매겨 관리하는 것으로 수정한다.
      //이는 [검증식 보기] 기능이 추가되므로 이를 위한 부가정보를 [공용] 으로 사용하기 위한 것이다.
      int  info1; //(기본값 : -1)
      //{
          //[Tree:설계정보]    : 해당 항목의 {DATABASE} 상의 <recindex>.
          //[Tree:검증식 보기] : 추가된 [검증식] 이 존재하는 함수영역정보({DATABASE} 상의 <funcrecindex>).
          //                     실제 [검증식 계산] 에서는 사용되지 않는다.
          //                     사실상 불필요한 정보다.
          //                     실제 [검증식 계산] 에는 [현재 검증중인 함수위치] 가 사용된다.
          //                      <debug.cpp:_debug_FuncRecIndex> 변수 정보를 사용한다. 

      //}

      //[2011.07.10.일][추가!!!]
      //[Tree:검증식 보기] 항목의 추가 정보를 위한것.
      int  info2; //(기본값 : -1)
      //{
          //[Tree:검증식 보기] : 추가된 [검증식] 이 존재하는 문서번호({DATABASE} 상의 <filelistindex>).

          //[참고!!!]{-----------------------------------------------------------------------------
          //[검증식] 에서 [문서번호] 는 반드시 필요한데, [검증식] 에 사용된 <#define 정의 이름> 을
          //처리하기 위하여 반드시 필요하다.
          //}--------------------------------------------------------------------------------------

      //}

      //[2011.07.11.월][추가!!!]
      int  info3; //(기본값 : -1)
      //{
          //[Tree:검증식 보기] : [검증식] 의 해당 문서상 [시작 위치].

      //}

      //[2011.07.11.월][추가!!!]
      int  info4; //(기본값 : -1)
      //{
          //[Tree:검증식 보기] : [검증식] 의 해당 문서상 [끝 위치].

      //}

      //[2011.07.18.월][추가!!!]
      char info5; //(기본값 : 16)
      //{
          //[Tree:검증식 보기:검증식값 항목] : [10/16/2 진수] 표기 방식.
          //                  짓접 숫자로 10, 16, 2 값을 사용한다.

      //}

  //}

};

struct  ITEMXY
{
  //[2006.11.20.월][생성!!!]{----------------------------------------------
  //tree 의 item 하나를 그려주는데 필요한 각각의 중요 좌표정보를 관리한다.
  //}----------------------------------------------------------------------

  //[계산에 필요한 기본정보]
  //{
      //절대 정보로 한번만 설정하면 된다.

      //tree 자체의 기준 원점. (BASE : 0)
      int  tree_x;
      int  tree_y;

      //행의 높이(문자 높이와 같다.)
      int  line_height;
  //}

  //[지정 기본 정보]
  //{
      //그려줄 item 의 정보에 따라 수정된다.

      //그려줄 지정 행.(BASE : 0)
      int  line_number;

      //item 의 줄기 단계.(BASE : 0)
      int  item_level;
  //}

  //[계산 결과 좌표]
  //{
      //item 을 그릴 영역 전체의 기준 원점.
      int  org_x;
      int  org_y;

      //[엄지그림] 의 출력 좌표.
      int  icon_x;
      int  icon_y;

      //[엄지그림] 의 내부 중심점.
      int  icon_middle_x;
      int  icon_middle_y;

      //[엄지그림] 위 점 좌표.
      int  icon_top_x;
      int  icon_top_y;

      //[엄지그림] 오른 점 좌표.
      int  icon_right_x;
      int  icon_right_y;

      //[엄지그림] 아래 점 좌표.
      int  icon_bottom_x;
      int  icon_bottom_y;

      //[그림영역] 세로선 윗점 좌표.
      int  vline_top_x;
      int  vline_top_y;

      //[그림영역] 세로선 아래점 좌표.
      int  vline_bottom_x;
      int  vline_bottom_y;

      //[그림영역] 가로선 오른점 좌표.
      int  hline_right_x;
      int  hline_right_y;

      //문자열 출력 위치 좌표.([항목-엄지그림] 이 없는 경우)
      int  text_x;
      int  text_y;

      //문자열 출력 위치 좌표.([항목-엄지그림] 이 있는 경우)
      int  text2_x;
      int  text2_y;

      //[항목-엄지그림] 의 표시 좌표.
      int  item_icon_x;
      int  item_icon_y;

      //행의 중심 위 높이.
      int  mh;
      //행의 중심 아래 높이.
      int  ml;
  //}

};

struct  TREE
{
  //[2006.11.16.목][생성!!!]{--------------------------------------------------------------
  //tree 한개를 그려줄 정보를 갖는다.
  //이 구조체 정보를 사용하여 한개의 tree 를 완성할수 있다.
  //
  //[2009.09.13.일][중요수정!!!]-----------------------------------------------------------
  //<items> 를 고정배열로 하지 않고 동적생성할수 있도록 수정한다.
  //이는 메모리를 낭비하지 않고, 사용자의 소스에 다라 정보량이 많을수 있으므로
  //이 정보에 따라 재생성하기 위한 것이다.
  //기본 1000 개로 설정하돼 크기를 넘는 경우는 다시 더 큰 크기로 동적 생성할수 있도록한다.
  //}--------------------------------------------------------------------------------------

  //[2009.09.13.일][중요수정!!!]{------------
  //동적 생성을 위한 것으로 포인터로 바꾼다.
  struct TREEITEM  *items;
  //}----------------------------------------

  //[Tree 크기]
  //{
      //[2009.09.13.일][추가!!!]{----------------------------------------------------
      //현재 tree 의 관리할수 있는 <item> 의 최대수를 가진다(실제적인 tree 의 크기).
      //동적 생성되므로 해당 크기정보를 계속 여기에 기록하여 관리해야 한다.
      //}----------------------------------------------------------------------------

      int  size;

  //}

  //현재 등록돼 있는 [항목] 수.
  int               items_count;

  //[level open/close]
  //{
      //------------------------------------------------------------------------
      //각각의 level 의 open/close 를 갖는다.
      //각각의 bit 는 각각의 level 에 대응하므로 총 32 개 줄기를 판별할수 있다.
      //1 : open.
      //0 : close.
      unsigned int     level_open_close_bit;
      //이 정보는 tree 를 그릴때 줄기를 그려주기 위하여 필요하다.
      //즉, 그려줄때만 일시적으로 필요하다.
      //------------------------------------------------------------------------
  //}

  //[선택관련]
  //{
      //--------------------------------------------------------------------------------------------
      //이 tree 에서 선택된 행.(실제적인 원인이 된다.)
      //(BASE : -1)
      int  select_line;

      //select_line 의 결과로 _TreeView() 함수로 그리면서 얻어지는 실제 선택된 [항목] 의 itemindex.
      //이는 결과적인 값이 된다.
      //(BASE : -1)
      int  select_itemindex;
      //--------------------------------------------------------------------------------------------
  //}

  //그린후 마지막 행을 기록한다.
  //이는 아래의 무효 영역을 선택한 경우 선택을 해제하기 위하여 사용된다.
  int  last_line;

  //스크롤 위치를 저장한다.
  int  scroll_position;

  //[2009.02.01.일]
  //{
      //[항목] 을 [삭제] 하는 경우 아래의 정보를 수정해 주어야 한다.
      //
      //items_count      : [삭제] 된 수 만큼 수정해 주어야 한다.
      //select_line      : 무조건 -1 로 초기화.
      //select_itemindex : 무조건 -1 로 초기화.
      //
      //[선택] 과 관련된 정보는 관리를 하느니 아예 -1 로 초기화 해버리는 것이 좋다.

  //}

  //[STRHEAP 관련]
  //{
      //[2012.04.20.금][추가!!!]{-----------------------------------------
      //[문자열] 은 [STRHEAP] 으로 별도 관리.
      //작은 동적 생성으로 인한 부하를 줄이고 관리를 쉽게 하기위한것.
      //기본 크기는 <d_STRHEAP_Heap_addSize>, <d_STRHEAP_List_addSize> 의
      //[재생성] 시 추가 크기 증가분 정도면 충분하다.
      //
      //반드시 한번만 초기화 해야 한다.
      //}-----------------------------------------------------------------

      struct STRHEAP  _strHeap;

  //}

};


class Ttree_tree_Form : public TForm
{
__published:	// IDE-managed Components

        void __fastcall FormMouseDown(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y);
        void __fastcall FormMouseWheel(TObject *Sender, TShiftState Shift,
          int WheelDelta, TPoint &MousePos, bool &Handled);
        void __fastcall FormMouseMove(TObject *Sender, TShiftState Shift,
          int X, int Y);
        void __fastcall FormDblClick(TObject *Sender);
        void __fastcall FormMouseUp(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y);
    void __fastcall FormMouseLeave(TObject *Sender);

private:	// User declarations
public:		// User declarations

        __fastcall Ttree_tree_Form(TComponent* Owner);

        //[2012.05.25.금][완료!!!]
        __fastcall ~Ttree_tree_Form(void);

        //[서브클래싱]
        //{
            //[2012.05.25.금][완료!!!]
            void __fastcall WndProc(Messages::TMessage &Message);

        //}

        //[VAR]
        //{
            //[환경변수]
            //{
                //[2007.10.02.화][추가!!!]
                struct  IDE_OPTION   *_ide_option;

                //[2018.07.24.화][추가!!!]{------------------------------------------------------
                //[더블클릭] 처리시작때 <true>, 끝날때 <false>.
                //실제는 [더블클릭] 처리부를 실제 처리하는 <_DbgExp_DoubleClick()> 함수의
                //[시작/끝] 을 알려주는 것.
                //
                //[검증식:문자열] 인 경우 [더블클릭] 시 [문자열:전체보기] 를 처리 하기위한것으로
                //실제는 <DbgExpTree_Set_Info()> 함수안에서 [문자열] 을 처리할때 사용된다.
                //
                //[검증식:문자열] 관련 자세한 설명은 [2018.07.24.화] 의 같은 날짜를 검색한다.
                bool  _isDblClick; //(기본값:false).
                //}------------------------------------------------------------------------------

            //}

            //[실제 그리는 영역]
            //{
                //[2012.06.05.화][수정!!!]{-------------------------------------
                //이전에 항상 [화면 전체크기] 와 같은 크기로 사용하던것에서
                //현제 [그림부품] 의 크기만큼 재생성 하여 사용하는 것으로 수정.
                Graphics::TBitmap  *_bmp_;
                //}-------------------------------------------------------------

                Graphics::TBitmap  *_bmp_back_;

            //}

            //[사용글꼴]
            //{
                struct FONTPACK     _font;

            //}

            //사용 폰트를 적용한 한 행의 높이.
            int  _line_height;

            //[tree]
            //{
                //item 을 그릴때 사용하는 좌표정보.
                //고정 기본값은 초기화 한뒤 사용한다.
                struct  ITEMXY  _item_xy;

                //[bmp]
                //{
                    //-----------------------------------------------------------------------------------
                    //tree 를 만들기 위한 여러 작은 그림들.
                    //처리 속도를 빠르게 하기 위하여 그리지 않고 바로 복사할수 있도록 그림을 사용한다.
                    Graphics::TBitmap  *_bmp_tree_p,   //'+'
                                       *_bmp_tree_m,   //'-'
                                       *_bmp_tree_i,   //'.'
                                       *_bmp_tree_3,   //3방향 줄기.
                                       *_bmp_tree_end, //줄기 끝.
                                       //[2011.07.11.월][추가!!!]
                                       *_bmp_tree_x; //[뿌리] 이나 하위항목이 없는 초기상태의 경우.

                    //이그림을 copy 할때는 별도의 gui 함수로 clBlack 부분으로 색이 있는 부분만 copy 하여
                    //배경이 비치도록 해야 한다.
                    //------------------------------------------------------------------------------------

                //}

                //[항목 bmp]
                //{
                    //각 항목을 대표하는 [엄지그림].
                    #define  d_ITEMBMP_max  18
                    Graphics::TBitmap  *_bmp_item[d_ITEMBMP_max];
                    //{
                        #define  d_ITEMBMP_root        0
                        #define  d_ITEMBMP_define      1
                        #define  d_ITEMBMP_function    2
                        #define  d_ITEMBMP_global      3
                        #define  d_ITEMBMP_struct      4
                        #define  d_ITEMBMP_struct_def  5
                        #define  d_ITEMBMP_union       6
                        #define  d_ITEMBMP_union_def   7
                        #define  d_ITEMBMP_item        8
                        #define  d_ITEMBMP_folder      9
                        #define  d_ITEMBMP_file_c      10
                        #define  d_ITEMBMP_file_h      11
                        #define  d_ITEMBMP_file_x      12
                        #define  d_ITEMBMP_api         13

                        //[2011.07.11.월][추가!!!]
                        //[검증식 보기창] 을 위한 것.
                        #define  d_ITEMBMP_dbgExp      14 //검증식.
                        #define  d_ITEMBMP_dbgValue    15 //검증식 값.

                        //[2012.03.14.수][추가!!!]
                        //[가상기계] 항목을 추가.
                        #define  d_ITEMBMP_gvms        16 //GVMS.
                        #define  d_ITEMBMP_gvmx        17 //GVMX.

                    //}

                //}

                //[tree]
                //{
                    //[2006.11.19.일][추가!!!]{---------
                    //tree 를 그려줄 3가지 정보 구조체.
                    //}---------------------------------

                    //[2019.02.16.토][수정]
                    //[전체찾기결과] 를 위하여 1 개 추가.
                    //[2022.06.15.수][수정]
                    //[API 검색] 기능을 위하여 6 -> 7 로 수정.
                    //단, [API 검색] 용은 임시 보기 용이므로 [탭] 을 가지지 않는다. 
                    #define  d_TREE_max    7

                    struct TREE  _tree[d_TREE_max];
                    //{
                        //[2019.02.16.토][수정]
                        //[전체찾기:결과] 지원을 위한 [찾기] 가 추가됐으므로 순서를 수정한다.
                        #define  d_TREE_project   0
                        #define  d_TREE_info      1
                        #define  d_TREE_api       2

                        //[2019.02.16.토][추가]{------------
                        //전체 찾기 결과를 표시하기 위한것.
                        #define  d_TREE_find      3
                        //}---------------------------------

                        #define  d_TREE_system    4 //3->4

                        //[2011.07.11.월][추가!!!]
                        //[검증식 보기창] 의 경우.
                        #define  d_TREE_dbgExp    5 //4->5

                        //[2022.06.15.수][추가]{****************************************
                        //[API 검색] 기능을 위한것.
                        //단, [API 검색] 용은 임시 보기 용이므로 [탭] 을 가지지 않는다.
                        #define  d_TREE_apiSrch   6
                        //}*************************************************************

                    //}

                    //표시할 tree 의 순번을 기록한다.([탭] 으로 선택 표시하는 경우)
                    int  _tree_select_index;

                //}

            //}

            //[2007.03.31.토][추가!!!]
            //{
                //배경 bmp 경로는 전역 변수로 관리 하는 것이 좋다.(수시로 바뀌는 것이 아니므로...)
                AnsiString  _bmp_path;

            //}

        //}

        //[내부 사용 개체]
        //{
            //[빠른목록]
            //{
                //[2009.02.02.월][추가!!!]
                Tide_popup_Form  *_popupMenu;

                //[함수]
                //{
                    //[2011.07.13.수][완료!!!]
                    void __fastcall _PopupMemu_Set(//[빠른목록] 을 설정할 대상을 설정한다.
                                                   int  pTreeIndex);

                    //[2009.05.31.일][완료!!!]
                    void __fastcall _EVENT_PopupMenu_Prj(void);

                    //[2009.05.31.일][완료!!!]
                    void __fastcall _EVENT_PopupMenu_Info(void);

                    //[2009.05.31.일][완료!!!]
                    void __fastcall _EVENT_PopupMenu_Api(void);

                    //[2022.06.24.금][완료]
                    void __fastcall _EVENT_PopupMenu_ApiSrch(void);

                    //[2019.02.26.화][완료]
                    void __fastcall _EVENT_PopupMenu_Find(void);

                    //[2009.05.31.일][완료!!!]
                    void __fastcall _EVENT_PopupMenu_System(void);

                    //[2011.07.20.수][완료!!!]
                    void __fastcall _EVENT_PopupMenu_DbgExpView(void);

                    //[특수 함수]
                    //{
                        //[2011.07.18.월][완료!!!]
                        void __fastcall _EVENT_Item_P(void);

                        //[2011.07.20.수][완료!!!]
                        //<_TreeView(..., true)> 인 경우 [검증식 계산] 처리를 수행.
                        //현재 이 부분은 한곳 뿐이다.
                        void __fastcall _EVENT_Item_M(void);

                        //[2011.07.21.목][완료!!!]
                        void __fastcall _EVENT_Item_M_Ready(void);

                        //[2011.07.21.목][완료!!!]
                        void __fastcall _DbgExp_DoubleClick(void);

                        //[2012.04.26.목][완료!!!]
                        //현재 불필요함.
                        //void __fastcall _DbgExp_FormMouseDown(void);

                    //}

                //}

            //}

            //[귀뜸말]
            //{
                //[2012.05.25.금][추가!!!]{----------------------------------------
                //[Tree] 의 경우는 각각 [귀뜸말] 을 가지는 것이 더 효과적이다.
                //이는 [Tree] 계통인 [실시간 선언 정보판] 과 여러 기능이 혼선이
                //오기 때문에 아예 각각 독립적인 [귀뜸말] 을 사용하는 것으로 한다.
                //}----------------------------------------------------------------

                //[VAR]
                //{
                    Tide_hint_Form  *_hint;

                //}

            //}

            //[이전 선택 항목]
            //{
                //[2012.06.05.화][추가!!!]{----------------------------------------------
                //<FormMouseMove()> 에서 [항목] 의 귀뜸말 이 [중복] 출력 되지 않도록
                //이전 선택 항목 위치를 기록.
                //<FormMouseMove()> 의 첫 부분에서 <_Get_ItemIndex_withLINE()> 으로 항상
                //현재 [화면지정자위치] 값이 얻어 지므로 이 값을 사용.
                //}----------------------------------------------------------------------

                int  _bfItemSelIndex; //(기본값 : -1)

            //}

        //}

        //[FUNCTION]
        //{
            //[2012.06.05.화][완료!!!]
            void __fastcall _Resize(void);

            void __fastcall _Draw(void);


            //[2012.06.05.화][완료!!!]
            void __fastcall _Width(int   pWidth,
                                   //[다시 그리기] 하는 경우는 <true>.
                                   bool  pRePaint);

            //[2012.06.05.화][완료!!!]
            void __fastcall _Height(int   pHeight,
                                    //[다시 그리기] 하는 경우는 <true>.
                                    bool  pRePaint);


            //[2012.06.05.화][완료!!!]
            //[2019.02.17.일][완료]
            void __fastcall _V_Scroll(int   pPosition,
                                      //[2019.02.17.일][추가]
                                      //[다시그리기] 하지 않는 경우 <false>.
                                      bool  pShape);

            //[TREE 관련]
            //{
                void __fastcall _TreeView(int   pTREEindex,
                                          bool  pCONTROL);

                //[2022.06.23.목][완료]
                void __fastcall _Tree(struct TREE  *pTREE,
                                      bool          pCONTROL);

                //[2012.04.20.금][완료!!!]
                void __fastcall _Item_Init(struct TREEITEM  *pTREEitem);

                //[2012.04.22.일][완료!!!]
                //<txt> 에 이미 [등록] 된 [문자열] 이 있는 경우 기존것을 [삭제] 하고 재등록한다.
                void __fastcall _Item_Txt(struct TREE      *pTree,
                                          struct TREEITEM  *pTreeItem,
                                          char             *pTxt);

                //[2012.04.20.금][완료!!!]
                char * __fastcall _Item_Txt_StrPtr(//[Tree] 번호.
                                                   int  pTreeIndex,
                                                   //[항목] 번호.
                                                   int  pItemIndex);

                //[2012.04.20.금][완료!!!]
                char * __fastcall _Item_Txt_StrPtr2(//[Tree] 번호.
                                                    int  pTreeIndex,
                                                    //[txt:목록번호].
                                                    int  pTxt);

                //[2012.04.21.토][완료!!!]
                char * __fastcall _Item_Txt_StrPtr3(//[Tree] 번호.
                                                    struct TREE  *pTree,
                                                    //[항목] 번호.
                                                    int           pItemIndex);





                //[2009.10.06.화][완료!!!]
                //[2012.04.17.화][주석처리!!!]
                //void __fastcall _Item_Text(struct TREEITEM  *pTreeItem,
                //                           char             *pText);

                //[2012.04.20.금][완료!!!]
                //[STRHEAP] 까지 삭제된다.
                void __fastcall _Tree_Delete(struct TREE  *pTree);

                //[2012.04.20.금][완료!!!]
                //[STRHEAP] 까지 생성된다.
                //내부적으로 기존 생성된 것을 [삭제] 하지 않고 [생성] 만 한다.
                void __fastcall _Tree_Create(struct TREE  *pTree,
                                             //생성할 크기(관리할 항목 총수).
                                             int           pSize);

                //[2012.04.20.금][완료!!!]
                //[STRHEAP] 는 그대로 유지.
                void __fastcall _Tree_ReSize(struct TREE  *pTree);

                //[2019.02.21.목][완료]
                void __fastcall _Tree_ReSizeX(struct TREE  *pTree,
                                              int           pAddSizeX);

                //[2012.04.20.금][완료!!!]
                //실제 외부에서 [Tree] 초기화시 이 함수만 사용한다.
                //내부적으로 [삭제]=>[기본크기 생성] 까지 자동 처리.
                void __fastcall _Tree_Init(struct TREE  *pTREE,
                                           //[2009.09.13.일][추가!!!]
                                           //초기화시 저장소 크기를 지정할수 있게 한다.
                                           int           pSize);


                //[2009.09.13.일][완료!!!]
                void __fastcall _Tree_Add_Item(struct TREE      *pTREE,
                                               struct TREEITEM  *pITEM);

                //[2011.05.16.월][완료!!!]
                //지정 <name> [옹이] 에 해당 항목을 등록한다.
                bool __fastcall _Tree_Add_NodeItem(struct TREE      *pTREE,
                                                   char             *pNODEname,
                                                   struct TREEITEM  *pITEM,
                                                   //[2011.05.07.토][추가!!!]
                                                   //추가한 항목의 [절대위치] 를 반환한다.
                                                   int              *rItemIndex);

                /*
                //[2022.06.19.일][완료]
                bool __fastcall _Tree_Add_NodeItem_CheckName(struct TREE      *pTree_,
                                                             char             *pNodeName_,
                                                             struct TREEITEM  *pItem_,
                                                             //추가한 항목의 [절대위치] 를 반환.
                                                             int              *rItemIndex_);
                */

                //<name> 에 해당하는 [항목] 의 [절대위치] 를 찾는다.
                void __fastcall _Tree_Get_ItemIndex_withNAME(struct TREE  *pTREE,
                                                             char         *pITEMname,
                                                             int          *rITEMindex);

                //[2012.04.21.토][완료!!!]
                //<text> 에 해당하는 [항목] 의 [절대위치] 를 찾는다.
                void __fastcall _Tree_Get_ItemIndex_withText(struct TREE  *pTree,
                                                             char         *pItemText,
                                                             int          *rItemIndex);

                void __fastcall _Tree_Get_NodeInfo(struct TREE  *pTREE,
                                                   //지정 [옹이] 의 [이름].
                                                   char         *pNODEname,
                                                   //지정 [옹이] 의 tree 상에서의 item-index.
                                                   int          *rNODEindex,
                                                   //지정 [옹이] 의 순수한 직계 [가지] 의 마지막 item-index.
                                                   int          *rNODEendITEMindex,
                                                   //지정 [옹이] 의 가장 마지막 [가지] 의 item-index.
                                                   int          *rNODElastITEMindex);

                void __fastcall _Tree_Make_InsertPosition(struct TREE  *pTREE,
                                                          //끼워넣을 위치(이 공간을 비워야 한다).
                                                          int           pINSERTindex);

                void __fastcall _Tree_Get_XY(struct ITEMXY  *prITEMxy);

                //[2012.06.01.금][완료!!!][중요수정!!!]
                void __fastcall _Tree_Get_Node_LastItemIndex(struct TREE  *pTREE,
                                                             //지정 [옹이] 의 index.
                                                             int           pNODEindex,
                                                             //지정 [옹이] 의 순수한 직계 [가지] 의 마지막 item-index.
                                                             int          *rNODEendITEMindex,
                                                             //지정 [옹이] 의 가장 마지막 가지의 item-index.
                                                             int          *rNODElastITEMindex);

                //[2012.06.01.금][완료!!!][중요수정!!!]
                void __fastcall _Tree_Get_Node_LastItemIndex2(struct TREE  *pTree,
                                                              //지정 [옹이] 의 name.
                                                              char         *pNodeName,
                                                              //이 [옹이] 의 <itemindex> 를 반환한다.
                                                              int          *rNodeItemIndex,
                                                              //지정 [옹이] 의 순수한 [직계 가지] 의 마지막 item-index.
                                                              int          *rNodeJikgyeLastItemIndex,
                                                              //지정 [옹이] 의 가장 마지막 가지의 item-index.
                                                              int          *rNodeLastItemIndex);


                //[2012.05.08.화][완료!!!]
                void __fastcall _Tree_Get_ThisItemNode_LastItemIndex(struct TREE  *pTREE,
                                                                     //지정 itemindex.
                                                                     int           pITEMindex,
                                                                     //[2009.02.02.월][추가!!!]
                                                                     int          *rNodeIndex,
                                                                     //지정 [옹이] 의 순수한 직계 [가지] 의 마지막 item-index.
                                                                     int          *rNODEendITEMindex,
                                                                     //이 itemindex 를 포함하는 [옹이] 의 마지막 itemindex.
                                                                     int          *rNODElastITEMindex);

                void __fastcall _Tree_Bmp_Create_Load(Graphics::TBitmap **pBITMAP,
                                                      AnsiString          pBMPname);

                //[2006.12.08.금][완료!!!]
                void __fastcall _Get_ItemIndex_withLINE(struct TREE    *pTREE,
                                                        int             pLINEnumber,
                                                        int            *rITEMindex,
                                                        int            *rTEXTx,
                                                        int            *rTEXTy);

                //[2012.04.23.월][완료!!!]
                void __fastcall _Get_LineNumber_withItemIndex(struct TREE  *pTree,
                                                              int           pItemIndex,
                                                              int          *rLineNumber);

                //[2006.12.11.월][완료!!!]
                int __fastcall _Get_ViewLineCount(struct TREE  *pTREE);

                //[2009.01.27.화][완료!!!]
                //해당 [옹이] 에 소속된 [직계가지] 의 개수를 반환한다.
                void __fastcall _Tree_Get_Node_ItemCount(struct TREE  *pTree,
                                                         //지정 [옹이] 의 [이름].
                                                         char         *pNodeName,
                                                         //이 [옹이] 의 item-index.
                                                         int          *rNodeItemindex,
                                                         //지정 [옹이] 의 직계 가지 수.
                                                         int          *rItemCount);

                //[2011.05.08.일][완료!!!]
                void __fastcall _Tree_Get_Node_ItemCount2(struct TREE  *pTree,
                                                          //지정 [옹이] 의 [절대위치].
                                                          int           pNodeIndex,
                                                          //지정 [옹이] 의 직계 가지 수.
                                                          int          *rItemCount);

                //[2012.04.21.토][완료!!!]
                //지정 [옹이] 의 [직계 가지] 만을 대상으로, <text> 항목이 일치 하는 항목의 item-index 를 찾아서 반환한다.
                //즉, [가지] 안의 또 다른 하위 [가지] 는 대상으로 하지 않는다.
                void __fastcall _Tree_Get_Node_ItemIndex_withText(struct TREE  *pTree,
                                                                  //지정 [옹이] 의 [이름].
                                                                  char         *pNodeName,
                                                                  //검사할 <text> 항목.
                                                                  char         *pItemText,
                                                                  //[대/소] 문자 구분 여부(true:구분).
                                                                  bool          pCase,
                                                                  //이 [옹이] 의 item-index.
                                                                  int          *rNodeItemindex,
                                                                  //<text> 를 가진 itemindex.
                                                                  int          *rItemindex);

                //[찾기 관련]
                //{
                    //[2019.02.21.목][완료]
                    int __fastcall _Tree_Search_Item_with_Name(struct TREE  *pTree,
                                                               //이 <level> 만 대상으로 처리.
                                                               int           pLevel,
                                                               //[대/소] 문자 구분 여부(true:구분).
                                                               bool          pCase,
                                                               char         *pName);

                    //[2019.02.21.목][완료]                                           
                    int __fastcall _Tree_Search_Item_with_Txt(struct TREE  *pTree,
                                                              //이 <level> 만 대상으로 처리.
                                                              int           pLevel,
                                                              //[대/소] 문자 구분 여부(true:구분).
                                                              bool          pCase,
                                                              char         *pTxt);
                    //[2019.02.20.수][완료]
                    int __fastcall _Tree_Search_Before_Item(struct TREE  *pTree,
                                                            int           pItemIndex);


                //}

                //[2012.04.21.토][완료!!!]
                //[2019.02.20.수][완료]
                //먼저 각 [항목] 을 [비우기] 하고 [삭제] 된다.
                bool __fastcall _Tree_Delete_Item(struct TREE  *pTree,
                                                  //삭제할 itemIndex.
                                                  int           pDeleteItemIndex);

                //[2012.04.21.토][완료!!!]
                bool __fastcall _Tree_Delete_AllSubItem(struct TREE  *pTree,
                                                        //삭제할 하위 항목의 [옹이] itemIndex.
                                                        int    pDeleteNodeIndex);

                //[2009.02.02.월][완료!!!]
                //지정 [항목] 을 포함하고 있는 [직계 옹이] 의 index 를 찾아서 반환한다.
                void __fastcall _Tree_Get_NodeIndex_of_ThisItem(struct TREE  *pTree,
                                                                //지정 itemIndex.
                                                                int           pItemIndex,
                                                                //직계 [옹이] 의 itemIndex.
                                                                int          *rNodeIndex);

                //[2012.04.25.수][완료!!!]
                void __fastcall _Tree_ExpandAll(//처리 대상.
                                                int   pTreeIndex,
                                                //[2011.07.20.수][추가!!!]
                                                //[다시그리기] 를 할지를 결정한다.
                                                //true : 다시 그려 반영한다.
                                                bool  pRePaint);

                //[2012.04.24.화][완료!!!]
                void __fastcall _Tree_CloseAll(//처리 대상.
                                               int  pTreeIndex);

                //[2012.04.25.수][완료!!!]
                void __fastcall _Tree_ThisItemExpandAll(//처리 대상.
                                                        int   pTreeIndex,
                                                        int   pItemIndex,
                                                        //[2011.07.20.수][추가!!!]
                                                        //[다시그리기] 를 할지를 결정한다.
                                                        //true : 다시 그려 반영한다.
                                                        bool  pRePaint);

                //[2012.04.25.수][완료!!!]
                void __fastcall _Tree_ThisItemCloseAll(//처리 대상.
                                                       int  pTreeIndex,
                                                       int  pItemIndex);

                //[2012.04.25.수][완료!!!]
                void __fastcall _Tree_ThisLevelExpandAll(//처리 대상.
                                                         int   pTreeIndex,
                                                         int   pLevel,
                                                         //[2011.07.20.수][추가!!!]
                                                         //[다시그리기] 를 할지를 결정한다.
                                                         //true : 다시 그려 반영한다.
                                                         bool  pRePaint);

                //[2012.04.25.수][완료!!!]
                void __fastcall _Tree_ThisLevelCloseAll(//처리 대상.
                                                        int  pTreeIndex,
                                                        int  pLevel);

                //[2012.04.25.수][완료!!!]
                bool __fastcall _Tree_SelItem_ViewPos(//가운데 위치시킨다면 <true>.
                                                      bool pMiddle,
                                                      //[2012.04.25.수][추가!!!]
                                                      //실제 [줄이동] 하지 않고 가상적으로 확인만한다.
                                                      bool  pSimul);

                //[2022.07.11.월][완료]                                      
                void __fastcall _Tree_ApiName_ClipBoard_Copy(int  pTreeIndex,
                                                             int  pItemIndex);

            //}

            //[2006.11.29.수][완료!!!]
            void __fastcall _Scroll_Set(void);

            //[키 제어]
            //{
                //[2012.04.23.월][완료!!!]
                void __fastcall _Key_Up(void);

                //[2012.04.23.월][완료!!!]
                void __fastcall _Key_Down(void);

                //[2012.04.23.월][완료!!!]
                void __fastcall _Key_Enter(void);

                //[2012.04.26.목][완료!!!]
                void __fastcall _Key_Right(void);

                //[2012.04.25.수][완료!!!]
                void __fastcall _Key_Left(void);

                //[2012.04.26.목][완료!!!]
                void __fastcall _Key_Right_Shift(void);

                //[2012.05.25.금][완료!!!]
                void __fastcall _Key_Left_Shift(void);

                //[2012.04.26.목][완료!!!]
                void __fastcall _Key_Right_Ctrl(void);

                //[2012.04.23.월][완료!!!]
                void __fastcall _Key_Left_Ctrl(void);

                //[2012.04.26.목][완료!!!]
                void __fastcall _Key_Right_Shift_Ctrl(void);

                //[2012.04.23.월][완료!!!]
                void __fastcall _Key_Left_Shift_Ctrl(void);


                //[2012.04.24.화][완료!!!]
                void __fastcall _Key_Up_Ctrl(void);

                //[2012.04.24.화][완료!!!]
                void __fastcall _Key_Down_Ctrl(void);

                //[2012.04.24.화][완료!!!]
                void __fastcall _Key_PageUp(void);

                //[2012.04.24.화][완료!!!]
                void __fastcall _Key_PageDown(void);

                //[2012.04.24.화][완료!!!]
                void __fastcall _Key_Home(void);

                //[2012.04.26.목][완료!!!]
                void __fastcall _Key_End(void);

                //[2012.04.24.화][완료!!!]
                void __fastcall _Key_Home_Ctrl(void);

                //[2012.04.24.화][완료!!!]
                void __fastcall _Key_End_Ctrl(void);

                //[2022.06.22.수][완료]
                void __fastcall _Key_Ctrl_F(void);

                //[2022.07.05.화][완료]
                void __fastcall _Key_Ctrl_C(void);

            //}

            //[API 정보 순간보기 관련 동작 함수]
            //{
                //[!]{-----------------------------------------------------------------------------
                //[항목선택] 동작 관련 함수.
                //외부에서 사용하는 일반 [동작함수] 가 아니라, 내부적으로만 사용되는 유사동작함수.
                //
                //[참고]***************************************************************************
                //[마법사] 와 같은 [잔상보기] 는 [가선택] 의 경우만 처리한다.
                //
                //[선택]     : [가선택] 과 겹치므로 의미가 없다.
                //[키로이동] : PC  의 종류에 따라서 Tree 탐색 속도에 지장이 있을수 있다.
                //}--------------------------------------------------------------------------------

                //[VAR]
                //{
                    //[2022.07.03.일][추가]{************************************************************
                    //[Tree:API 검색] 의 [한줄편집기] 에서 입력 중이고 [Tree:API 검색] 에
                    //[화면지정자] 가 존재하는 경우, 자동 정렬시 <FormMouseMove()> 에서 [항목변경] 으로
                    //인식하고 계속 [순간보기] 가 동작되어 [촛점] 이 계속 [한줄편집기] 에 맟추어 져서
                    //입력시 [입력지정자] 의 위치가 변동되는 문제가 발생된다.
                    //이는 [Tree:API 검색] 안에 [화면지정자] 가 위치하기만 해도 계속 <FormMouseMove()>
                    //이벤트가 발생해서 생기는 문제로, [화면지정자] 의 이동이 없는 경우는 [순간보기] 는
                    //아예 처리하지 않는 것으로 한다.
                    //이를 검사하기 위하여 관련 변수를 추가한다.
                    //}*********************************************************************************

                    int  mouseX, mouseY; //(기본값:0)

                //}



                //[2022.06.30.목][완료]
                void __fastcall _Tree_ApiInfo_View(int  pTreeIndex,
                                                   int  pSelItemIndex);

                //[2022.06.30.목][완료]
                void __fastcall _Tree_ApiInfo_Hide(int   pTreeIndex,
                                                   //[2022.06.28.화][추가]
                                                   //[깜박임방지] 를 하는 경우는 <true>.
                                                   //이 경우는 내부적으로 [편집기 요소] 의 다시 그리기가 되지 않음에 주의.
                                                   //별도 다시 그리기 처리시는 <ide_editor:_Shape()> 를 사용 가능.
                                                   bool  pNoBlink);

                //[현재편집중인 문서 Push/Pop 관련]
                //{
                    //[VAR]
                    //{
                        //[2022.10.27.목][추가]{-------------------------------------------------------------
                        //<_Tree_ApiInfo_View()> 에서 [순간보기] 문서를 열기 전에 이 <_textinfoIndex> 에
                        //[현재편집중인문서] 인 <editor_edit:_textinfo_index> 를 기록한다.
                        //
                        //이는 <_Tree_ApiInfo_Hide()> 에서 [순간보기] 문서를 닫으면서, 다시 편집중이었던
                        //문서를 열어주기 위한것.
                        //
                        //이 기능은 [순간보기] 후에 항상 열려있는 문서중 가장 마지막 문서가 열려, 편집중이던
                        //문서를 다시 열어 주어야 하는 불편함을 개선한 것이다.
                        //}----------------------------------------------------------------------------------

                        int  _textinfoIndex; //(기본값 : -1)

                    //}

                    //[2022.10.27.목][완료]
                    void __fastcall _Tree_ApiInfo_Editor_Push(void);

                    //[2022.10.27.목][완료]
                    void __fastcall _Tree_ApiInfo_Editor_Pop(void);

                //}

            //}

        //}

        //[배경 설정]
        //{
            //[2009.04.20.월][완료!!!]
            void __fastcall _BACKBMP_Brightness(int  pBrightness);

            //[2009.04.20.월][완료!!!]
            void __fastcall _BACKBMP_ChangeJpeg(AnsiString  pJpegFilePath);

        //}

        //[형식 적용 문자열]
        //{
            //[2012.05.19.토][추가!!!]{----------------------------------
            //<item.txt> 를 [형식 적용 문자열] 로 출력하기 위한 정보.
            //지정 [단어] 에 따라 개별적인 [속성] 이 적용되어 출력된다.
            //
            //[예약어], [구조체/공용체 형이름], [연산자 '*'] 만 처리.
            //"*" 는 [연산자] 에 들어있지만 [포인터] 차원을 [선언] 에서
            //사용하기 때문에 [형] 으로 보고 같이 처리해야 [선언정보] 가
            //제대로 구별된다.
            //나머지 [연산자/기호] 등은 처리할 필요 없다.
            //}----------------------------------------------------------

            //[VAR]
            //{
                struct STRCONF_STRHEAP_ITEM  _confStr_SetList_Hint[3];
                //[2012.05.21.월][추가!!!]
                //선언한 개수 관리.
                //<_ConfStr_Info_Set()> 함수에서 자동 설정.
                int                          _confStr_SetList_Hint_Count;

                //[2012.05.21.월][추가!!!]{----------------------------------
                //기본 적용 항목.
                struct STRCONF_STRHEAP_ITEM  _confStr_SetList_ItemDft[3];
                int                          _confStr_SetList_ItemDft_Count;
                //선택 항목(반전).
                struct STRCONF_STRHEAP_ITEM  _confStr_SetList_ItemSel[3];
                int                          _confStr_SetList_ItemSel_Count;
                //}----------------------------------------------------------

                //[기본 설정]
                //{
                    struct STRCONFITEM  _confStr_StdConf;

                    //[2012.05.21.월][추가!!!]
                    //[항목 선택] 시는 [반전출력] 하므로 별도의 [기본설정] 을 사용.
                    struct STRCONFITEM  _confStr_StdConf_ItemSel;

                //}

                //[지정 설정]
                //{
                    //[2019.02.26.화][추가]{--------------------------------
                    //[전체찾기:Tree] 의 [찾은항목] 을 처리하는데 사용된다.
                    //}-----------------------------------------------------

                    struct STRCONFITEM  _confStr_SetConf;

                    //[항목 선택] 시는 [반전출력] 하므로 별도의 [기본설정] 을 사용.
                    struct STRCONFITEM  _confStr_SetConf_ItemSel;

                //}

            //}

            //[2012.05.19.토][완료!!!]
            //[2019.02.26.화][완료]
            void __fastcall _ConfStr_Info_Set(void);

        //}

        //[동작 함수]
        //{
            //[2022.06.13.월][추가]
            //<키:ESC> 가 눌린 경우 동작.
            void __fastcall (__closure * _EVENT_KeyDown_Esc)(void);

        //}


};

//---------------------------------------------------------------------------
extern PACKAGE Ttree_tree_Form *tree_tree_Form;
//---------------------------------------------------------------------------

#endif
