MQL5 リファレンス標準的な定数、列挙と構造体チャート定数チャート操作の例

차트 작업 예제

이 절에는 차트 속성으로 작업하는 예가 나와 있습니다. 각 속성에 대해 하나 또는 두 개의 완전한 함수가 표시됩니다. 이러한 기능을 통해 속성 값을 설정/수신할 수 있습니다. 이러한 함수는 커스텀 mql5 애플리케이션에서 "있는 그대로" 사용할 수 있습니다.

아래 스크린샷은 차트 속성의 변경사항이 어떻게 모양을 변화시키는지를 보여주는 그래픽 패널을 보여줍니다. Next 버튼을 클릭하면 적절한 속성의 새 값을 설정하고 차트 창에서 변경 사항을 볼 수 있습니다.

chart_properties_panel

패널의 소스 코드는 아래에 있습니다.

차트 특성 및 샘플 함수 관련 작업

CHART_IS_OBJECT 는 객체가 실제 차트인지 그래픽 객체인지 정의합니다.

//+------------------------------------------------------------------+
//| 객체가 차트인지 확인합니다. 만약 그것이 그래픽 객체라면,       |
//| 결과는 참입니다. 그것이 실제 차트라면, 결과 변수는   |
//| 거짓의 값을 가집니다.                                          |
//+------------------------------------------------------------------+
bool ChartIsObject(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 차트 속성 가져오기
   if(!ChartGetInteger(chart_ID,CHART_IS_OBJECT,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      //--- false 반환
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }

CHART_BRING_TO_TOP는 차트를 다른 차트 위에 표시합니다.

//+----------------------------------------------------------------------+
//| 터미널에 명령을 보내 다른 모든 차트보다 차트를 표시합니다  |
//+----------------------------------------------------------------------+
bool ChartBringToTop(const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 차트를 다른 차트 위에 표시하다
   if(!ChartSetInteger(chart_ID,CHART_BRING_TO_TOP,0,true))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_MOUSE_SCROLL는 마우스 왼쪽 버튼을 사용하여 차트를 스크롤하는 속성입니다.

//+--------------------------------------------------------------------------+
//| 마우스 왼쪽 버튼을 사용하여 차트 스크롤이 활성화되어 있는지 확인합니다          |
//+--------------------------------------------------------------------------+
bool ChartMouseScrollGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+--------------------------------------------------------------------+
//| 마우스 왼쪽 버튼을 사용하여 차트 스크롤을 활성화/비활성화합니다        |
//+--------------------------------------------------------------------+
bool ChartMouseScrollSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_EVENT_MOUSE_MOVE 는 mql5 어플리케이션(CHARTEVENT_MOUSE_MOVE)으로 이동 이벤트 및 마우스 클릭과 관련된 메시지를 보내는 속성입니다.

//+------------------------------------------------------------------+
//| 이동 이벤트 및 마우스 클릭과 관련된 메시지 확인       |
//| 차트의 모든 MQL5 어플리케이션에 전송됩니다                   |
//+------------------------------------------------------------------+
bool ChartEventMouseMoveGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------------------+
//| 이동 이벤트와 관련된 메시지 전송 모드를 활성화/비활성화합니다     |
//| 차트에서 MQL5 애플리케이션을 마우스 클릭                               |
//+------------------------------------------------------------------------------+
bool ChartEventMouseMoveSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_EVENT_OBJECT_CREATE는 그래픽 객체 생성 이벤트와 관련된 메시지를 mql5 응용 프로그램(CHARTEVENT_OBJECT_CREATE)에 보내는 속성입니다.

//+---------------------------------------------------------------------+
//| 그래픽 이벤트와 관련된 메시지 확인                |
//| 개체 생성은 차트의 모든 MQL5 응용 프로그램에 전송됩니다      |
//+---------------------------------------------------------------------+
bool ChartEventObjectCreateGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+--------------------------------------------------------------------------+
//| 차트에 있는 모든 mql5 응용 프로그램에 그래픽 개체 생성 이벤트와  |
//| 관련된 메시지를 보내는 모드를 활성화/비활성화합니다            |
//+--------------------------------------------------------------------------+
bool ChartEventObjectCreateSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_EVENT_OBJECT_DELETE는 그래픽 객체 삭제 이벤트와 관련된 메시지를 mql5 응용 프로그램(CHARTEVENT_OBJECT_DELETE)에 보내는 속성입니다.

//+---------------------------------------------------------------------+
//| 그래픽 객체 삭제 이벤트와 관련된 메시지가 차트의         |
//| 모든 mql5 응용 프로그램에 전송되는지 확인합니다             |
//+---------------------------------------------------------------------+
bool ChartEventObjectDeleteGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+--------------------------------------------------------------------------+
//| 차트에 있는 모든 mql5 응용 프로그램에 그래픽 개체 생성 이벤트와  |
//| 차트에 있는 모든 mql5 응용 프로그램에 대한 그래픽 개체 삭제            |
//+--------------------------------------------------------------------------+
bool ChartEventObjectDeleteSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_MODE – 차트 유형 (캔들스틱, 막대 또는 선).

//+------------------------------------------------------------------+
//| 차트 표시 유형(촛대, 막대 또는 선)을 가져옵니다             |
//+------------------------------------------------------------------+
ENUM_CHART_MODE ChartModeGet(const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=WRONG_VALUE;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_MODE,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((ENUM_CHART_MODE)result);
  }
//+------------------------------------------------------------------+
//| 차트 표시 유형 설정(캔들스틱, 막대 또는 선)             |
//+------------------------------------------------------------------+
bool ChartModeSet(const long value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_MODE,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_FOREGROUND는 가격 차트를 맨 앞에 표시하는 속성입니다.

//+------------------------------------------------------------------+
//| 가격 차트가 전면에 표시되는지 확인합니다           |
//+------------------------------------------------------------------+
bool ChartForegroundGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 전면에 가격 차트를 표시하거나 표시하지 않습니다   |
//+------------------------------------------------------------------+
bool ChartForegroundSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHIFT – 오른쪽 경계에서 가격 차트의 이동 모드.

//+-------------------------------------------------------------------+
//| 오른쪽 테두리에서 가격 차트를 이동할 수 있는지 확인합니다 |
//+-------------------------------------------------------------------+
bool ChartShiftGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+---------------------------------------------------------------------------------+
//| 오른쪽 테두리에서 전환하여 가격 차트를 표시하거나 표시하지 않습니다 |
//+---------------------------------------------------------------------------------+
bool ChartShiftSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_AUTOSCROLL – 차트의 오른쪽 테두리로 자동 이동 모드.

//+------------------------------------------------------------------+
//| 새 틱 도착 시 차트의 오른쪽 자동 스크롤이            |
//| 활성화되어 있는지 확인합니다                                  |
//+------------------------------------------------------------------+
bool ChartAutoscrollGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 새 틱 도착 시 차트의 오른쪽 자동 스크롤을     |
//| 활설화/비활성화합니다                                             |
//+------------------------------------------------------------------+
bool ChartAutoscrollSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SCALE – 차트 스케일 속성.

//+------------------------------------------------------------------+
//| 차트 스케일 가져오기 (0에서 5까지)                                   |
//+------------------------------------------------------------------+
int ChartScaleGet(const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=-1;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SCALE,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((int)result);
  }
//+------------------------------------------------------------------+
//| 차트 스케일 설정 (0에서 5까지)                                   |
//+------------------------------------------------------------------+
bool ChartScaleSet(const long value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SCALE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SCALEFIX – 고정 차트 스케일 모드.

//+------------------------------------------------------------------+
//| 고정 축척 모드가 활성화되어 있는지 확인합니다                        |
//+------------------------------------------------------------------+
bool ChartScaleFixGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 고정 스케일 모드를 활성화/비활성화합니다                            |
//+------------------------------------------------------------------+
bool ChartScaleFixSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SCALEFIX_11 – 1:1 차트 스케일 모드.

//+------------------------------------------------------------------+
//| 1:1 배율이 사용 가능한지 확인합니다                             |
//+------------------------------------------------------------------+
bool ChartScaleFix11Get(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| "1:1" 스케일 모드를 활성화/비활성화                            |
//+------------------------------------------------------------------+
bool ChartScaleFix11Set(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SCALE_PT_PER_BAR – 막대당 포인트 단위로 차트 축척을 지정하는 모드.

//+------------------------------------------------------------------+
//| "막대당 포인트 수" 차트 축척 모드가 활성화되어 있는지 확인합니다     |
//+------------------------------------------------------------------+
bool ChartScalePerBarGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| "막대당 포인트" 차트 스케일링 모드를 활성화/비활성화합니다.         |
//+------------------------------------------------------------------+
bool ChartScalePerBarSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_OHLC – 왼쪽 상단 모서리에 OHLC 값을 표시하는 속성.

//+----------------------------------------------------------------------------------+
//| 차트의 왼쪽 상단 모서리에 OHLC 값 표시가 활성화되어 있는지 확인합니다 |
//+----------------------------------------------------------------------------------+
bool ChartShowOHLCGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------------------+
//| 차트의 왼쪽 상단 모서리에 OHLC 값을 표시하거나 표시하지 않습니다 |
//+------------------------------------------------------------------------------+
bool ChartShowOHLCSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_BID_LINE – 차트에 입찰 값을 수평선으로 표시하는 속성.

//+------------------------------------------------------------------+
//| 차트에 입찰선 표시가 활성화되어 있는지 확인합니다             |
//+------------------------------------------------------------------+
bool ChartShowBidLineGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 차트에 입찰 선 표시를 활성화/비활성화합니다                 |
//+------------------------------------------------------------------+
bool ChartShowBidLineSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_ASK_LINE – 차트에서 요청가를 수평선으로 표시하는 속성.

//+------------------------------------------------------------------+
//| 차트에 요청선 표시가 활성화되어 있는지 확인합니다             |
//+------------------------------------------------------------------+
bool ChartShowAskLineGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 관리도에 요청선 표시를 활성화/비활성화합니다                 |
//+------------------------------------------------------------------+
bool ChartShowAskLineSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_LAST_LINE – 차트에 종가를 수평선으로 표시하는 속성.

//+-----------------------------------------------------------------------------+
//| 마지막으로 수행된 거래 가격에 대한 라인 표시가 활성화되어 있는지 확인합니다 |
//+-----------------------------------------------------------------------------+
bool ChartShowLastLineGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+-------------------------------------------------------------------------+
//| 마지막으로 수행된 거래 가격에 대한 라인 표시를 활성화/비활성화합니다 |
//+-------------------------------------------------------------------------+
bool ChartShowLastLineSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_PERIOD_SEP – 인접 기간 간의 수직 구분 표시 특성.

//+---------------------------------------------------------------------------------+
//| 인접 기간 간의 수직 구분 기호 표시가 활성화되어 있는지 확인합니다 |
//+---------------------------------------------------------------------------------+
bool ChartShowPeriodSeparatorGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+-----------------------------------------------------------------------------+
//| 인접 기간 간의 수직 구분 기호 표시 활성화/비활성화 |
//+-----------------------------------------------------------------------------+
bool ChartShowPeriodSepapatorSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_GRID – 차트 그리드 표시 속성.

//+------------------------------------------------------------------+
//| 차트 그리드가 표시되는지 확인합니다                            |
//+------------------------------------------------------------------+
bool ChartShowGridGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 차트에 그리드 표시를 활성화/비활성화합니다                     |
//+------------------------------------------------------------------+
bool ChartShowGridSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_VOLUMES – 도표에 볼륨을 표시하는 속성.

//+------------------------------------------------------------------+
//| 볼륨이 차트에 표시되는지 확인합니다                       |
//| 플래그는 모드를 표시하는 볼륨을 나타냅니다                      |
//+------------------------------------------------------------------+
ENUM_CHART_VOLUME_MODE ChartShowVolumesGet(const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=WRONG_VALUE;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_VOLUMES,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((ENUM_CHART_VOLUME_MODE)result);
  }
//+------------------------------------------------------------------+
//| 차트에 볼륨을 표시하는 모드를 설정합니다                         |
//+------------------------------------------------------------------+
bool ChartShowVolumesSet(const long value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_VOLUMES,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_OBJECT_DESCR – 그래픽 객체 팝업 설명의 속성.

//+-------------------------------------------------------------------+
//| 마우스를 그래픽 개체 위에 놓을 때 그래픽 개체의  |
//| 팝업 설명이 표시되는지 확인합니다                                     |
//+-------------------------------------------------------------------+
bool ChartShowObjectDescriptionGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+-------------------------------------------------------------------------+
//| 그래픽 객체의 팝업 설명 표시 활성화/비활성화 |
//| 마우스가 그것들을 호버할 때                                           |
//+-------------------------------------------------------------------------+
bool ChartShowObjectDescriptionSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_VISIBLE_BARS는 차트에서 표시할 수 있는 막대 수를 정의합니다.

//+----------------------------------------------------------------------+
//| 차트 창에 표시되는(표시되는) 막대 수를 가져옵니다 |
//+----------------------------------------------------------------------+
int ChartVisibleBars(const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=-1;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_VISIBLE_BARS,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((int)result);
  }

CHART_WINDOWS_TOTAL는 지표 하위 창을 포함하여 차트 창의 총 수를 정의합니다.

//+-----------------------------------------------------------------------+
//| 지표 하위 창을 포함한 전체 차트 창 수를 가져옵니다 |
//+-----------------------------------------------------------------------+
int ChartWindowsTotal(const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=-1;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_WINDOWS_TOTAL,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((int)result);
  }

CHART_WINDOW_IS_VISIBLE는 하위 창의 가시성을 정의합니다.

//+------------------------------------------------------------------+
//| 현재 차트 창 또는 하위 창이 표시되는지 확인합니다       |
//+------------------------------------------------------------------+
bool ChartWindowsIsVisible(bool &result,const long chart_ID=0,const int sub_window=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_IS_VISIBLE,sub_window,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }

CHART_WINDOW_HANDLE은 차트 핸들을 반환합니다.

//+------------------------------------------------------------------+
//| 차트 핸들 가져오기                                            |
//+------------------------------------------------------------------+
int ChartWindowsHandle(const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=-1;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_HANDLE,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((int)result);
  }

CHART_WINDOW_YDISTANCE는 지표 하위 창의 위쪽 프레임과 차트의 기본 창의 위쪽 프레임 사이의 거리를 픽셀 단위로 정의합니다.

//+------------------------------------------------------------------+
//| 차트의 기본 창의 위쪽 경계와 하위 창의          |
//| 위쪽 경계 사이의 거리(픽셀)를 가져옵니다            |
//+------------------------------------------------------------------+
int ChartWindowsYDistance(const long chart_ID=0,const int sub_window=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=-1;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_YDISTANCE,sub_window,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((int)result);
  }

CHART_FIRST_VISIBLE_BAR는 차트에 표시되는 첫 번째 막대의 수를 반환합니다(막대 인덱싱은 시계열에 해당).

//+------------------------------------------------------------------------------+
//| 차트에 표시되는 첫 번째 막대의 인덱스를 가져옵니다.                            |
//| 인덱싱은 시계열에서처럼 수행되며, 최신 막대의 인덱스가 가장 작습니다. |
//+------------------------------------------------------------------------------+
int ChartFirstVisibleBar(const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=-1;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_FIRST_VISIBLE_BAR,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((int)result);
  }

CHART_WIDTH_IN_BARS는 차트 너비를 막대 단위로 반환합니다.

//+------------------------------------------------------------------+
//| 차트의 너비(막대 단위)를 가져옵니다                                |
//+------------------------------------------------------------------+
int ChartWidthInBars(const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=-1;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_BARS,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((int)result);
  }

CHART_WIDTH_IN_PIXELS 차트 너비(픽셀)를 반환합니다.

//+------------------------------------------------------------------+
//| 차트 너비(픽셀) 가져오기                              |
//+------------------------------------------------------------------+
int ChartWidthInPixels(const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=-1;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_PIXELS,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((int)result);
  }

CHART_HEIGHT_IN_PIXELS – 차트 높이 속성(픽셀).

//+------------------------------------------------------------------+
//| 차트의 높이(픽셀)를 가져오기                             |
//+------------------------------------------------------------------+
int ChartHeightInPixelsGet(const long chart_ID=0,const int sub_window=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long result=-1;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((int)result);
  }
//+------------------------------------------------------------------+
//| 차트의 높이를 설정합니다(픽셀 단위)                             |
//+------------------------------------------------------------------+
bool ChartHeightInPixelsSet(const int value,const long chart_ID=0,const int sub_window=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_BACKGROUND - 차트 배경색.

//+------------------------------------------------------------------+
//| 차트 배경색 가져오기                               |
//+------------------------------------------------------------------+
color ChartBackColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 차트 배경색 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BACKGROUND,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 차트 배경색 설정                               |
//+------------------------------------------------------------------+
bool ChartBackColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 차트 배경색을 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BACKGROUND,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_FOREGROUND – 축, 스케일, OHLC 선의 색상.

//+------------------------------------------------------------------+
//| 축, 스케일, OHLC 선의 색상 가져오기                      |
//+------------------------------------------------------------------+
color ChartForeColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 축, 스케일, OHLC 선의 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_FOREGROUND,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 축, 스케일, OHLC 선 색상 설정                      |
//+------------------------------------------------------------------+
bool ChartForeColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 축, 스케일 및 OHLC 선 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_FOREGROUND,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_GRID – chart grid color.

//+------------------------------------------------------------------+
//| 차트 그리드 색상 가져오기                                     |
//+------------------------------------------------------------------+
color ChartGridColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 차트 그리드 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_GRID,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 차트 그리드 색상 설정                                     |
//+------------------------------------------------------------------+
bool ChartGridColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 차트 그리드 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_GRID,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_VOLUME - 볼륨 및 포지션 오프닝 레벨의 색상.

//+------------------------------------------------------------------+
//| 볼륨 및 마켓 엔트리 레벨의 색상 가져오기                |
//+------------------------------------------------------------------+
color ChartVolumeColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 볼륨 및 마켓 엔트리 레벨 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_VOLUME,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 볼륨 및 시장 엔트리 레벨의 색상 설정                |
//+------------------------------------------------------------------+
bool ChartVolumeColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 볼륨 및 시장 엔트리 레벨 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_VOLUME,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_CHART_UP – 위쪽 막대의 색깔, 막대 모양의 그림자와 막대기 몸통 테두리.

//+-----------------------------------------------------------------------------+
//| 막대 모양의 위쪽, 그림자 및 막대 모양의 막대 모양 막대 모양 가져오기 |
//+-----------------------------------------------------------------------------+
color ChartUpColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 막대의 빛깔과 그 그림자와 촛대의 테두리를 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_UP,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 촛대 본체의 위쪽 막대, 그림자 및 테두리의 색상을 설정 |
//+------------------------------------------------------------------+
bool ChartUpColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 쇠막대기의 색상과 그 그림자와 바디의 테두리 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_UP,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_CHART_DOWN – 다운 막대, 그 음영, 약세 캔들스틱 테두리의 색상.

//+-------------------------------------------------------------------------------+
//| 다운 막대, 그 음영, 약세 캔들스틱 테두리의 색상 가져오기 |
//+-------------------------------------------------------------------------------+
color ChartDownColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 다운 막대, 그 음영, 약세 캔들스틱 테두리 색상 수려
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_DOWN,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+-------------------------------------------------------------------------------+
//| 약세 캔들스틱의 다운 막대, 그림자 및 테두리의 색상을 설정합니다 |
//+-------------------------------------------------------------------------------+
bool ChartDownColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 약세 촛대 몸통의 아래쪽 막대의 색깔과 그림자와 테두리 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_DOWN,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_CHART_LINE – 차트 선 및 도지 촛대의 색상.

//+------------------------------------------------------------------+
//| 차트 선과 도지 촛대의 색상 가져오기               |
//+------------------------------------------------------------------+
color ChartLineColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 차트 선과 도지 촛대의 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_LINE,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 차트 선과 도지 촛대의 색상 설정               |
//+------------------------------------------------------------------+
bool ChartLineColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 차트 선과 도지 촛대의 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_LINE,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_CANDLE_BULL – 상승 촛대의 바디 색깔.

//+------------------------------------------------------------------+
//| 상승 촛대 바디 색상을 가져오기                     |
//+------------------------------------------------------------------+
color ChartBullColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 상승 캔들스틱 바디 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 상승세 캔들스틱 바디 색상 설정                     |
//+------------------------------------------------------------------+
bool ChartBullColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 상승세 캔들스틱 바디 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_CANDLE_BEAR – 상승세 캔들스틱 바디 색상.

//+------------------------------------------------------------------+
//| 상승세 캔들스틱 바디 색상 가져오기                     |
//+------------------------------------------------------------------+
color ChartBearColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 상승세 캔들스틱 바디 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 상승세 캔들스틱 바디 색상 설정                     |
//+------------------------------------------------------------------+
bool ChartBearColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 상승세 캔들스틱 바디 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_BID – 요청가 선 색상.

//+------------------------------------------------------------------+
//| 요청 선 색상 가져오기                                       |
//+------------------------------------------------------------------+
color ChartBidColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 요청가 라인 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BID,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 입찰 선 색상 설정                                       |
//+------------------------------------------------------------------+
bool ChartBidColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 입찰가 선 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BID,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_ASK – 요청가 선 색상.

//+------------------------------------------------------------------+
//| 요청 선 색상 가져오기                                       |
//+------------------------------------------------------------------+
color ChartAskColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 요청가 라인 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_ASK,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 요청 선 색상 설정                                       |
//+------------------------------------------------------------------+
bool ChartAskColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 요청가 라인 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_ASK,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_LAST – 최근 수행한 거래 가격 선 (종가) 색상.

//+------------------------------------------------------------------+
//| 최근 수행 거래 가격 선 색상 가져오기           |
//+------------------------------------------------------------------+
color ChartLastColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 최근 수행 거래 가격선(종가) 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_LAST,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 최근 수행 거래 가격선 색상 설정           |
//+------------------------------------------------------------------+
bool ChartLastColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 최근 수행 거래가 라인(종가) 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_LAST,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_COLOR_STOP_LEVEL – 스탑 오더 레벨 색상(스탑 로스 및 이익 실현).

//+------------------------------------------------------------------+
//| 스탑 로스 및 이익 실현 색상 가져오기               |
//+------------------------------------------------------------------+
color ChartStopLevelColorGet(const long chart_ID=0)
  {
//--- 변수를 준비하여 색을 입힘
   long result=clrNONE;
//--- 오류 값 리셋
   ResetLastError();
//--- 스탑 오더 수준 (스탑 로스 및 이익 실현) 색상 수령
   if(!ChartGetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return((color)result);
  }
//+------------------------------------------------------------------+
//| 스탑 로스 및 이익 실현 수준 색상 설정               |
//+------------------------------------------------------------------+
bool ChartStopLevelColorSet(const color clr,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 스탑 오더 수준 (스탑 로스 및 이익 실현) 색상 설정
   if(!ChartSetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,clr))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_TRADE_LEVELS – 차트에 거래 수준을 표시하는 속성(오픈 포지션 수준, 스탑 로스, 이익 실현 및 보류 중 주문)

//+------------------------------------------------------------------+
//| 거래 수준이 차트에 표시되는지 확인합니다                  |
//+------------------------------------------------------------------+
bool ChartShowTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 거래 수준 표시 활성화/비활성화                    |
//+------------------------------------------------------------------+
bool ChartShowTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_DRAG_TRADE_LEVELS – 마우스를 사용하여 차트에서 거래 수준을 드래그하는 기능을 활성화하는 속성.

//+----------------------------------------------------------------------+
//| 마우스를 사용하여 차트에서 거래 수준을 드래그할 수 있는지 확인 |
//+----------------------------------------------------------------------+
bool ChartDragTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 마우스를 사용하여 차트에서 거래 수준 드래그 활성화/비활성화 |
//+------------------------------------------------------------------+
bool ChartDragTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_DATE_SCALE – 차트에 시간 스케일을 표시하는 속성.

//+------------------------------------------------------------------+
//| 시간 스케일이 차트에 표시되는지 확인합니다                   |
//+------------------------------------------------------------------+
bool ChartShowDateScaleGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 차트에 시간 스케일 표시 활성화/비활성화           |
//+------------------------------------------------------------------+
bool ChartShowDateScaleSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_PRICE_SCALE – 차트에 가격 스케일을 표시하는 속성.

//+------------------------------------------------------------------+
//| 가격 스케일이 차트에 표시되는지 확인                  |
//+------------------------------------------------------------------+
bool ChartShowPriceScaleGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 차트에 가격 척도 표시 활성화/비활성화          |
//+------------------------------------------------------------------+
bool ChartShowPriceScaleSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHOW_ONE_CLICK – 차트에 "원클릭 트레이딩" 패널 표시 속성.

//+------------------------------------------------------------------+
//| 차트에 "원클릭 트레이딩" 패널이 표시되는지 확인    |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelGet(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 가져오기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 차트 속성 값을 메모리에 저장합니다
   result=value;
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 원클릭 트레이딩 패널 표시 활성화/비활성화     |
//| 차트에서                                                         |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelSet(const bool value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_SHIFT_SIZE – 오른쪽 테두리에서 0 막대의 이동 크기(백분율 값).

//+-----------------------------------------------------------------+
//| 차트의 오른쪽 테두리에서 0 막대의 이동 크기를 백분율 값 |
//| (10% ~ 50%)으로 가져옵니다          |
//+-----------------------------------------------------------------+
double ChartShiftSizeGet(const long chart_ID=0)
  {
//--- 결과를 얻기 위해 변수를 준비
   double result=EMPTY_VALUE;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetDouble(chart_ID,CHART_SHIFT_SIZE,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return(result);
  }
//+-----------------------------------------------------------------------------+
//| 차트의 오른쪽 테두리에서 0 막대의 이동 크기를             |
//| 백분율 값(10% ~ 50%)으로 가져옵니다.                     |
//| Shift 모드를 활성화하려면 CHART_SHIFT 속성 값을 true로 설정해야 합니다. |
//+-----------------------------------------------------------------------------+
bool ChartShiftSizeSet(const double value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetDouble(chart_ID,CHART_SHIFT_SIZE,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_FIXED_POSITION – 차트 고정 위치를 왼쪽 테두리부터 백분율 값으로 표시.

//+----------------------------------------------------------------------------------------+
//| 왼쪽 테두리(백분율 값)에서 차트의 고정 위치 위치를 가져옵니다 |
//+----------------------------------------------------------------------------------------+
double ChartFixedPositionGet(const long chart_ID=0)
  {
//--- 결과를 얻기 위해 변수를 준비
   double result=EMPTY_VALUE;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetDouble(chart_ID,CHART_FIXED_POSITION,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return(result);
  }
//+-----------------------------------------------------------------------------------------+
//| 왼쪽 테두리(백분율 값)에서 차트의 고정 위치 위치를 가져옵니다. |
//| 차트의 고정 위치 위치를 보려면 CHART_AUTOSCROLL 속성 값을  |
//| false로 설정해야 합니다.                                                                 |
//+-----------------------------------------------------------------------------------------+
bool ChartFixedPositionSet(const double value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetDouble(chart_ID,CHART_FIXED_POSITION,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_FIXED_MAX – 차트의 고정 최대값 속성.

//+------------------------------------------------------------------+
//| 차트의 고정 최대값 값을 가져옵니다                          |
//+------------------------------------------------------------------+
double ChartFixedMaxGet(const long chart_ID=0)
  {
//--- 결과를 얻기 위해 변수를 준비
   double result=EMPTY_VALUE;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MAX,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return(result);
  }
//+------------------------------------------------------------------+
//| 차트의 고정 최대값을 설정합니다.                         |
//| 속성 값을 변경하려면 CHART_SCALEFIX 속성 값을     |
//| 임시로 true로 설정해야 합니다.                       |
//+------------------------------------------------------------------+
bool ChartFixedMaxSet(const double value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MAX,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_FIXED_MIN – 차트의 고정 최소값 속성.

//+------------------------------------------------------------------+
//| 차트의 고정 최소값 속성                          |
//+------------------------------------------------------------------+
double ChartFixedMinGet(const long chart_ID=0)
  {
//--- 결과를 얻기 위해 변수를 준비
   double result=EMPTY_VALUE;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MIN,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return(result);
  }
//+------------------------------------------------------------------+
//| 차트의 고정 최소값을 설정합니다.                         |
//| 속성 값을 변경하려면 CHART_SCALEFIX 속성 값을     |
//| 임시로 true로 설정해야 합니다.                       |
//+------------------------------------------------------------------+
bool ChartFixedMinSet(const double value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MIN,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_POINTS_PER_BAR – 막대당 포인트 단위의 척도 값.

//+------------------------------------------------------------------+
//| 막대당 점 단위의 차트 축척 값을 가져옵니다                  |
//+------------------------------------------------------------------+
double ChartPointsPerBarGet(const long chart_ID=0)
  {
//--- 결과를 얻기 위해 변수를 준비
   double result=EMPTY_VALUE;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetDouble(chart_ID,CHART_POINTS_PER_BAR,0,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return(result);
  }
//+----------------------------------------------------------------------+
//| 막대당 포인트 단위로 차트 스케일 값을 설정합니다.                     |
//| 이 속성의 값 변경 결과를 보려면     |
//| CHART_SCALE_PT_PER_BAR 속성 값을 true로 미리 설정해야 합니다. |
//+----------------------------------------------------------------------+
bool ChartPointsPerBarSet(const double value,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetDouble(chart_ID,CHART_POINTS_PER_BAR,value))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_PRICE_MIN는 차트 최소값을 반환합니다.

//+----------------------------------------------------------------------+
//| 기본 창 또는 하위 창에서 차트 최소값을 가져옵니다 |
//+----------------------------------------------------------------------+
double ChartPriceMin(const long chart_ID=0,const int sub_window=0)
  {
//--- 결과를 얻기 위해 변수를 준비
   double result=EMPTY_VALUE;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MIN,sub_window,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return(result);
  }

CHART_PRICE_MAX는 차트 최대값을 반환합니다.

//+----------------------------------------------------------------------+
//| 기본 창 또는 하위 창에서 차트 최대값을 가져옵니다 |
//+----------------------------------------------------------------------+
double ChartPriceMax(const long chart_ID=0,const int sub_window=0)
  {
//--- 결과를 얻기 위해 변수를 준비
   double result=EMPTY_VALUE;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MAX,sub_window,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
    }
//--- 차트 속성 값을 반환합니다
   return(result);
  }

CHART_COMMENT – 차트 내 주석.

//+------------------------------------------------------------------+
//| 차트의 왼쪽 상단 모서리에 주석을 가져옵니다                   |
//+------------------------------------------------------------------+
bool ChartCommentGet(string &result,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 받기
   if(!ChartGetString(chart_ID,CHART_COMMENT,result))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 차트의 왼쪽 상단 모서리에 주석을 가져옵니다                   |
//+------------------------------------------------------------------+
bool ChartCommentSet(const string str,const long chart_ID=0)
  {
//--- 오류 값 리셋
   ResetLastError();
//--- 속성값 설정
   if(!ChartSetString(chart_ID,CHART_COMMENT,str))
     {
      //--- 전문가 저널에 오류 메시지를 표시합니다
      Print(__FUNCTION__+", 에러 코드 = ",GetLastError());
      return(false);
    }
//--- 성공적 실행
   return(true);
  }

CHART_IS_MAXIMIZED - 차트창이 최대화됩니다.

//+------------------------------------------------------------------+
//| 현재 차트 창을 최대화할지 여부를 정의합니다                 |
//+------------------------------------------------------------------+
bool ChartWindowsIsMaximized(bool &result,const long chart_ID=0)
  {
//--- 속성 값을 받기 위해 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 수령
   if(!ChartGetInteger(chart_ID,CHART_IS_MAXIMIZED))
     {
      //--- Experts 로그에 오류 메시지 표시
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- 변수 내 차트 속성값 저장
   result=value;
//--- 실행 성공
   return(true);
  }

CHART_IS_MINIMIZED – 차트창이 최소화됩니다.

//+------------------------------------------------------------------+
//| 현재 차트 창을 최소화할지 여부를 정의합니다                 |
//+------------------------------------------------------------------+
bool ChartWindowsIsMinimized(bool &result,const long chart_ID=0)
  {
//--- 속성 값 수령을 위한 변수 준비
   long value;
//--- 오류 값 리셋
   ResetLastError();
//--- 속성 값 수령
   if(!ChartGetInteger(chart_ID,CHART_IS_MINIMIZED))
     {
      //--- Experts 로그에 오류 메시지 표시
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- 변수 내 차트 속성 값 저장
   result=value;
//--- 실행 성공
   return(true);
  }

차트 속성 패널

//--- 제어 요소 라이브러리를 연결
#include <ChartObjects\ChartObjectsTxtControls.mqh>
//--- 미리 정의된 상수
#define X_PROPERTY_NAME_1    10  // 첫 번째 열에 있는 특성 이름의 x 좌표
#define X_PROPERTY_VALUE_1   225 // 첫 번째 열에 있는 특성 값의 x 좌표
#define X_PROPERTY_NAME_2    345 // 두 번째 및 세 번째 열에 있는 특성 이름의 x 좌표
#define X_PROPERTY_VALUE_2   550 // 두 번째 및 세 번째 열에 있는 특성 값의 x 좌표
#define X_BUTTON_1           285 // 첫 번째 열에 있는 버튼의 x 좌표
#define X_BUTTON_2           700 // 두 번째 열에 있는 버튼의 x 좌표
#define Y_PROPERTY_1         30  // 첫 번째 및 두 번째 열의 시작의 y 좌표
#define Y_PROPERTY_2         286 // 세 번째 열의 시작의 y 좌표
#define Y_DISTANCE           16  // 선 사이의 y축 간격
#define LAST_PROPERTY_NUMBER 111 // 마지막 그래픽 특성 수
//--- 입력 매개 변수
input color InpFirstColor=clrDodgerBlue; // 홀수 선 색상
input color InpSecondColor=clrGoldenrod; // 짝수 선 색상
//--- 변수 및 배열
CChartObjectLabel  ExtLabelsName[];  // 특성 이름 표시 레이블
CChartObjectLabel  ExtLabelsValue[]; // 특성 값 표시 레이블
CChartObjectButton ExtButtons[];     // 버튼
int                ExtNumbers[];     // 속성 지수
string             ExtNames[];       // 속성명
uchar              ExtDataTypes[];   // 속성 데이터 유형 (integer, double, string)
uint               ExtGroupTypes[];  // 그룹 중 하나에 속성을 속성에 데이터를 저장하는 배열
uchar              ExtDrawTypes[];   // 속성 표시 유형에 데이터를 저장하는 배열
double             ExtMaxValue[];    // 패널 작업 시 가능한 최대 속성 값
double             ExtMinValue[];    // 패널 작업 시 가능한 최소 속성 값
double             ExtStep[];        // 속성 변경 단계
int                ExtCount;         // 모든 속성의 총 수
color              ExtColors[2];     // 라인 표시용 색상 배열
string             ExtComments[2];   // 주석 배열 (CHART_COMMENT 속성용)
//+------------------------------------------------------------------+
//| 커스텀 지표 초기화 함수                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- 차트에 주석 표시
   Comment("SomeComment");
//--- 나중에 전환할 수 있도록 배열에 색상 저장
   ExtColors[0]=InpFirstColor;
   ExtColors[1]=InpSecondColor;
//--- 나중에 주석을 전환할 수 있도록 배열에 주석 저장
   ExtComments[0]="FirstComment";
   ExtComments[1]="SecondComment";
//--- 차트 속성 관리를 위한 제어판 준비 및 표시
   if(!PrepareControls())
      return(INIT_FAILED);
//--- 성공적 실행
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| expert 함수 초기화해제                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- 차트 내 주석 삭제
   Comment("");
  }
//+------------------------------------------------------------------+
//| 차트 이벤트 핸들러                                         |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- 차트 객체 클릭 이벤트 확인
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
      //--- 개체명을 구분 기호로 나눔
      string obj_name[];
      StringSplit(sparam,'_',obj_name);
      //--- 객체가 버튼인지 체크
      if(obj_name[0]=="Button")
        {
         //--- 버튼 인덱스 수령
         int index=(int)StringToInteger(obj_name[1]);
         //--- 버튼 누름해제
         ExtButtons[index].State(false);
         //--- 속성의 유형에 따라 새 값을 설정
         if(ExtDataTypes[index]=='I')
            ChangeIntegerProperty(index);
         if(ExtDataTypes[index]=='D')
            ChangeDoubleProperty(index);
         if(ExtDataTypes[index]=='S')
            ChangeStringProperty(index);
        }
    }
//--- 속성 값 다시 그리기
   RedrawProperties();
   ChartRedraw();
  }
//+------------------------------------------------------------------+
//| 차트 정수 속성 변경                             |
//+------------------------------------------------------------------+
void ChangeIntegerProperty(const int index)
  {
//--- 현재 속성 값 수령
   long value=ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index]);
//--- 다음 속성 값 정의
   switch(ExtDrawTypes[index])
     {
      case 'C':
         value=GetNextColor((color)value);
         break;
      default:
         value=(long)GetNextValue((double)value,index);
         break;
    }
//--- 새 속성 값 설정
   ChartSetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index],0,value);
  }
//+------------------------------------------------------------------+
//| 차트 double 속성 변경                               |
//+------------------------------------------------------------------+
void ChangeDoubleProperty(const int index)
  {
//--- 현재 속성 값 수령
   double value=ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index]);
//--- 다음 속성 값 정의
   value=GetNextValue(value,index);
//--- 새 속성 값 설정
   ChartSetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index],value);
  }
//+------------------------------------------------------------------+
//| 차트 문자열 속성 변경                               |
//+------------------------------------------------------------------+
void ChangeStringProperty(const int index)
  {
//--- ExtComments 배열 내에서 전환하기 위한 정적 변수
   static uint comment_index=1;
//--- 다른 주석을 수신하기 위한 색인 변경
   comment_index=1-comment_index;
//--- 새 속성 값 설정
   ChartSetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[index],ExtComments[comment_index]);
  }
//+------------------------------------------------------------------+
//| 다음 특성 값을 가져옵니다                                     |
//+------------------------------------------------------------------+
double GetNextValue(const double value,const int index)
  {
   if(value+ExtStep[index]<=ExtMaxValue[index])
      return(value+ExtStep[index]);
   else
      return(ExtMinValue[index]);
  }
//+------------------------------------------------------------------+
//| 색상 유형 속성에 대한 다음 색상을 가져옵니다                      |
//+------------------------------------------------------------------+
color GetNextColor(const color clr)
  {
//--- 다음 색상 값 반환
   switch(clr)
     {
      case clrWhite: return(clrRed);
      case clrRed:   return(clrGreen);
      case clrGreen: return(clrBlue);
      case clrBlue:  return(clrBlack);
      default:       return(clrWhite);
    }
  }
//+------------------------------------------------------------------+
//| 속성 값 다시 그리기                                         |
//+------------------------------------------------------------------+
void RedrawProperties(void)
  {
//--- 속성 값 텍스트
   string text;
   long   value;
//--- 속성 수 루프
   for(int i=0;i<ExtCount;i++)
     {
      text="";
      switch(ExtDataTypes[i])
        {
         case 'I':
            //--- 현재 속성 값 수령
            if(!ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[i],0,value))
            break;
            //--- 정수 속성 텍스트
            switch(ExtDrawTypes[i])
              {
               //--- 색상 속성
               case 'C':
                  text=(string)((color)value);
                  break;
                  //--- boolean 속성
               case 'B':
                  text=(string)((bool)value);
                  break;
                  //--- ENUM_CHART_MODE 열거 속성
               case 'M':
                  text=EnumToString((ENUM_CHART_MODE)value);
                  break;
                  //--- ENUM_CHART_VOLUME_MODE 열거 속성
               case 'V':
                  text=EnumToString((ENUM_CHART_VOLUME_MODE)value);
                  break;
                  //--- int 타입 수
               default:
                  text=IntegerToString(value);
                  break;
              }
            break;
         case 'D':
            //--- double 속성 텍스트
            text=DoubleToString(ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[i]),4);
            break;
         case 'S':
            //--- 문자열 속성 텍스트
            text=ChartGetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[i]);
            break;
        }
      //--- 속성 값 표시
      ExtLabelsValue[i].Description(text);
    }
  }
//+------------------------------------------------------------------+
//| 차트 속성 관리용 패널 생성                      |
//+------------------------------------------------------------------+
bool PrepareControls(void)
  {
//--- 예약된 배열에 대해 메모리 할당
   MemoryAllocation(LAST_PROPERTY_NUMBER+1);
//--- 변수
   int i=0;     // 루프 변수
   int col_1=0; // 첫 칼럼에의 속성 수
   int col_2=0; // 둘� 칼럼의 속성 수
   int col_3=0; // 셋째 칼럼의 속성 수
//--- 속성의 현재 수 - 0
   ExtCount=0;
//--- 루프에 있는 속성 찾기
   while(i<=LAST_PROPERTY_NUMBER)
     {
      //--- 속성의 현재 수 저장
      ExtNumbers[ExtCount]=i;
      //--- 루프 변수 값 증가
      i++;
      //--- 속성에 그러한 수가 있는지 확인
      if(CheckNumber(ExtNumbers[ExtCount],ExtNames[ExtCount],ExtDataTypes[ExtCount],ExtGroupTypes[ExtCount],ExtDrawTypes[ExtCount]))
        {
         //--- 속성용 제어 요소 생성
         switch(ExtGroupTypes[ExtCount])
           {
            case 1:
               //--- 속성용 레이블 및 버튼 생성
               if(!ShowProperty(ExtCount,0,X_PROPERTY_NAME_1,X_PROPERTY_VALUE_1,X_BUTTON_1,Y_PROPERTY_1+col_1*Y_DISTANCE,true))
               return(false);
               //--- 첫 번째 열의 요소 수가 증가했습니다
               col_1++;
               break;
            case 2:
               //--- 속성용 레이블 및 버튼 생성
               if(!ShowProperty(ExtCount,1,X_PROPERTY_NAME_2,X_PROPERTY_VALUE_2,X_BUTTON_2,Y_PROPERTY_1+col_2*Y_DISTANCE,true))
               return(false);
               //--- 두 번째 열의 요소 수가 증가했습니다
               col_2++;
               break;
            case 3:
               //--- 속성에 대한 레이블만 작성합니다
               if(!ShowProperty(ExtCount,2,X_PROPERTY_NAME_2,X_PROPERTY_VALUE_2,0,Y_PROPERTY_2+col_3*Y_DISTANCE,false))
               return(false);
               //--- 세 번째 열의 요소 수가 증가했습니다
               col_3++;
               break;
          }
         //--- 최대 및 최소 특성 값 및 단계 정의
         GetMaxMinStep(ExtNumbers[ExtCount],ExtMaxValue[ExtCount],ExtMinValue[ExtCount],ExtStep[ExtCount]);
         //--- 속성 수 증가
         ExtCount++;
        }
    }
//--- 배열에서 사용하지 않는 메모리 사용 가능
   MemoryAllocation(ExtCount);
//--- 속성 값 다시 그리기
   RedrawProperties();
   ChartRedraw();
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 배열용 메모리 할당                                      |
//+------------------------------------------------------------------+
void MemoryAllocation(const int size)
  {
   ArrayResize(ExtLabelsName,size);
   ArrayResize(ExtLabelsValue,size);
   ArrayResize(ExtButtons,size);
   ArrayResize(ExtNumbers,size);
   ArrayResize(ExtNames,size);
   ArrayResize(ExtDataTypes,size);
   ArrayResize(ExtGroupTypes,size);
   ArrayResize(ExtDrawTypes,size);
   ArrayResize(ExtMaxValue,size);
   ArrayResize(ExtMinValue,size);
   ArrayResize(ExtStep,size);
  }
//+------------------------------------------------------------------+
//| 속성 인덱스가 다음 중 하나에 속하는지 확인합니다               |
//| ENUM_CHART_PROPERTIES 열거값                               |
//+------------------------------------------------------------------+
bool CheckNumber(const int ind,string &name,uchar &data_type,uint &group_type,uchar &draw_type)
  {
//--- 속성이 정수 유형인지 확인합니다
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_INTEGER)ind);
   if(_LastError==0)
     {
      data_type='I';                      // ENUM_CHART_PROPERTY_INTEGER 열거값 속성
      GetTypes(ind,group_type,draw_type); // 특성 표시 매개 변수 정의
      return(true);
    }
//--- 속성이 double 타입인지 확인
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_DOUBLE)ind);
   if(_LastError==0)
     {
      data_type='D';                      // ENUM_CHART_PROPERTY_DOUBLE 열거값 속성
      GetTypes(ind,group_type,draw_type); // 특성 표시 매개 변수 정의
      return(true);
    }
//--- 속성이 문자열 유형인지 확인
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_STRING)ind);
   if(_LastError==0)
     {
      data_type='S';                      // ENUM_CHART_PROPERTY_STRING 열거값 속성
      GetTypes(ind,group_type,draw_type); // 특성 표시 매개 변수 정의
      return(true);
    }
//--- 속성이 어떤 열거형에도 속하지 않습니다
   return(false);
  }
//+------------------------------------------------------------------+
//| 속성을 저장할 그룹을 정의합니다            |
//| 그것으 표시 유형과 마찬가지로                                      |
//+------------------------------------------------------------------+
void GetTypes(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- 속성이 세 번째 그룹에 속하는지 확인합니다
//--- 세 번째 그룹 속성이 CHART_BRING_TO_TOP 에서 시작하는 두 번째 열에 표시됩니다
   if(CheckThirdGroup(property_number,group_type,draw_type))
      return;
//--- 속성이 두 번째 그룹에 속하는지 확인합니다
//--- 두 번째 그룹 속성이 두 번째 열의 시작 부분에 표시됩니다
   if(CheckSecondGroup(property_number,group_type,draw_type))
      return;
//--- 여기서 잘 보면 속성이 첫 번째 그룹(첫 번째 열)에 속합니다
   CheckFirstGroup(property_number,group_type,draw_type);
  }
//+----------------------------------------------------------------------+
//| 속성이 세 번째 그룹에 속하는지 확인하고                    |
//| 긍정 응답인 경우 해당 표시 유형을 정의합니다                |
//+----------------------------------------------------------------------+
bool CheckThirdGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- 속성이 세 번째 그룹에 속하는지 확인합니다
   switch(property_number)
     {
      //--- boolean 속성
      case CHART_IS_OBJECT:
      case CHART_WINDOW_IS_VISIBLE:
         draw_type='B';
         break;
         //--- integer 속성
      case CHART_VISIBLE_BARS:
      case CHART_WINDOWS_TOTAL:
      case CHART_WINDOW_HANDLE:
      case CHART_WINDOW_YDISTANCE:
      case CHART_FIRST_VISIBLE_BAR:
      case CHART_WIDTH_IN_BARS:
      case CHART_WIDTH_IN_PIXELS:
         draw_type='I';
         break;
         //--- double 속성
      case CHART_PRICE_MIN:
      case CHART_PRICE_MAX:
         draw_type='D';
         break;
         //--- 사실 이 속성은 차트를 다른 모든 차트 위에 표시하는 명령입니다
         //--- 창이 항상 열려 있으므로 이 패널을 적용할 필요가 없습니다
         //--- 우리가 사용하기 전에 다른 것들 위에
      case CHART_BRING_TO_TOP:
         draw_type=' ';
         break;
         //--- 속성이 세 번째 그룹에 속하지 않습니다
      default:
         return(false);
    }
//--- 속성이 세 번째 그룹에 속하지 않습니다
   group_type=3;
   return(true);
  }
//+----------------------------------------------------------------------+
//| 속성이 두 번째 그룹에 속하는지 확인하고                   |
//| 긍정 응답인 경우 해당 표시 유형을 정의합니다                |
//+----------------------------------------------------------------------+
bool CheckSecondGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- 속성이 두 번째 그룹에 속하는지 확인합니다
   switch(property_number)
     {
      //--- ENUM_CHART_MODE 유형 속성
      case CHART_MODE:
         draw_type='M';
         break;
         //--- ENUM_CHART_VOLUME_MODE 유형 속성
      case CHART_SHOW_VOLUMES:
         draw_type='V';
         break;
         //--- string 속성
      case CHART_COMMENT:
         draw_type='S';
         break;
         //--- 색 속성
      case CHART_COLOR_BACKGROUND:
      case CHART_COLOR_FOREGROUND:
      case CHART_COLOR_GRID:
      case CHART_COLOR_VOLUME:
      case CHART_COLOR_CHART_UP:
      case CHART_COLOR_CHART_DOWN:
      case CHART_COLOR_CHART_LINE:
      case CHART_COLOR_CANDLE_BULL:
      case CHART_COLOR_CANDLE_BEAR:
      case CHART_COLOR_BID:
      case CHART_COLOR_ASK:
      case CHART_COLOR_LAST:
      case CHART_COLOR_STOP_LEVEL:
         draw_type='C';
         break;
         //--- 속성이 두 번째 그룹에 속하지 않습니다
      default:
         return(false);
    }
//--- 속성이 두 번째 그룹에 속합니다
   group_type=2;
   return(true);
  }
//+-----------------------------------------------------------------------+
//| 속성이 두 번째 및 세 번째 속성 그룹에 속하지 않는 것으로      |
//| 이미 알려진 경우에만 호출됩니다                               |
//+-----------------------------------------------------------------------+
void CheckFirstGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- 속성이 첫 번째 그룹에 속합니다
   group_type=1;
//--- 속성 표시 유형 정의
   switch(property_number)
     {
      //--- integer 속성
      case CHART_SCALE:
      case CHART_HEIGHT_IN_PIXELS:
         draw_type='I';
         return;
         //--- double 속성
      case CHART_SHIFT_SIZE:
      case CHART_FIXED_POSITION:
      case CHART_FIXED_MAX:
      case CHART_FIXED_MIN:
      case CHART_POINTS_PER_BAR:
         draw_type='D';
         return;
         //--- 부울 속성만 남아 있습니다
      default:
         draw_type='B';
         return;
    }
  }
//+------------------------------------------------------------------+
//| 속성용 레이블 및 버튼 생성                            |
//+------------------------------------------------------------------+
bool ShowProperty(const int ind,const int type,const int x1,const int x2,
                  const int xb,const int y,const bool btn)
  {
//--- ExtColors 색상 배열 내에서 전환하기 위한 정적 배열
   static uint color_index[3]={1,1,1};
//--- 다른 색상 수신에 대한 인덱스 변경
   color_index[type]=1-color_index[type];
//--- 속성에 대한 표시 레이블 및 버튼(btn=true인 경우)
   if(!LabelCreate(ExtLabelsName[ind],"name_"+(string)ind,ExtNames[ind],ExtColors[color_index[type]],x1,y))
      return(false);
   if(!LabelCreate(ExtLabelsValue[ind],"value_"+(string)ind,"",ExtColors[color_index[type]],x2,y))
      return(false);
   if(btn && !ButtonCreate(ExtButtons[ind],(string)ind,xb,y+1))
      return(false);
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 레이블 생성                                                    |
//+------------------------------------------------------------------+
bool LabelCreate(CChartObjectLabel &lbl,const string name,const string text,
                 const color clr,const int x,const int y)
  {
   if(!lbl.Create(0,"Label_"+name,0,x,y)) return(false);
   if(!lbl.Description(text))             return(false);
   if(!lbl.FontSize(10))                  return(false);
   if(!lbl.Color(clr))                    return(false);
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 버튼 생성                                                   |
//+------------------------------------------------------------------+
bool ButtonCreate(CChartObjectButton &btn,const string name,
                  const int x,const int y)
  {
   if(!btn.Create(0,"Button_"+name,0,x,y,50,15)) return(false);
   if(!btn.Description("Next"))                  return(false);
   if(!btn.FontSize(10))                         return(false);
   if(!btn.Color(clrBlack))                      return(false);
   if(!btn.BackColor(clrWhite))                  return(false);
   if(!btn.BorderColor(clrBlack))                return(false);
//--- 성공적 실행
   return(true);
  }
//+------------------------------------------------------------------+
//| 최대 및 최소 속성 값과 단계를 정의합니다              |
//+------------------------------------------------------------------+
void GetMaxMinStep(const int property_number,double &max,double &min,double &step)
  {
   double value;
//--- 속성 유형에 따라 값 설정
   switch(property_number)
     {
      case CHART_SCALE:
         max=5;
         min=0;
         step=1;
         break;
      case CHART_MODE:
      case CHART_SHOW_VOLUMES:
         max=2;
         min=0;
         step=1;
         break;
      case CHART_SHIFT_SIZE:
         max=50;
         min=10;
         step=2.5;
         break;
      case CHART_FIXED_POSITION:
         max=90;
         min=0;
         step=15;
         break;
      case CHART_POINTS_PER_BAR:
         max=19;
         min=1;
         step=3;
         break;
      case CHART_FIXED_MAX:
         value=ChartGetDouble(0,CHART_FIXED_MAX);
         max=value*1.25;
         min=value;
         step=value/32;
         break;
      case CHART_FIXED_MIN:
         value=ChartGetDouble(0,CHART_FIXED_MIN);
         max=value;
         min=value*0.75;
         step=value/32;
         break;
      case CHART_HEIGHT_IN_PIXELS:
         max=700;
         min=520;
         step=30;
         break;
         //--- 디폴트 값
      default:
         max=1;
         min=0;
         step=1;
    }
  }

チャート表示

オブジェクト定数