모바일 메뉴 테크니컬 가이드

Begin Object Class=MobileMenuButton Name=ExploreButton
   Tag="EXPLORE"
   Left=0.35
   Top=0.35
   Width=140
   Height=24
   bRelativeLeft=true
   bRelativeTop=true
   TopLeeway=20
   Images(0)=Texture2D'CastleUI.menus.T_CastleMenu2'
   Images(1)=Texture2D'CastleUI.menus.T_CastleMenu2'
   ImagesUVs(0)=(bCustomCoords=true,U=306,V=220,UL=310,VL=48)
   ImagesUVs(1)=(bCustomCoords=true,U=306,V=271,UL=310,VL=48)
End Object
MenuObjects(0)=ExploreButton

Begin Object Class=MobileMenuButton Name=ExploreButton
   Tag="EXPLORE"
   Left=0.35
   Top=0.35
   Width=140
   Height=24
   bRelativeLeft=true
   bRelativeTop=true
   TopLeeway=20
   Images(0)=Texture2D'CastleUI.menus.T_CastleMenu2'
   Images(1)=Texture2D'CastleUI.menus.T_CastleMenu2'
   ImagesUVs(0)=(bCustomCoords=true,U=306,V=220,UL=310,VL=48)
   ImagesUVs(1)=(bCustomCoords=true,U=306,V=271,UL=310,VL=48)
End Object
MenuObjects.Add(ExploreButton)

Begin Object Class=[ControlClass] Name=[ControlName]

End Object

class MobileMenuExample extends MobileMenuScene;

defaultproperties
{   
   Left=0
   Top=0
   Width=1.0
   Height=180
   bRelativeWidth=true
   
   Begin Object Class=MobileMenuImage Name=Background
      Tag="Background"
      Left=0
      Top=0
      Width=1.0
      Height=1.0
      bRelativeWidth=true
      bRelativeHeight=true
      Image=Texture2D'CastleUI.menus.T_CastleMenu2'
      ImageDrawStyle=IDS_Stretched
      ImageUVs=(bCustomCoords=true,U=0,V=30,UL=1024,VL=180)
   End Object
   MenuObjects.Add(Background)

   Begin Object Class=MobileMenuButton Name=ExploreButton
      Tag="EXPLORE"
      Left=0.35
      Top=0.35
      Width=140
      Height=24
      bRelativeLeft=true
      bRelativeTop=true
      TopLeeway=20
      Images(0)=Texture2D'CastleUI.menus.T_CastleMenu2'
      Images(1)=Texture2D'CastleUI.menus.T_CastleMenu2'
      ImagesUVs(0)=(bCustomCoords=true,U=306,V=220,UL=310,VL=48)
      ImagesUVs(1)=(bCustomCoords=true,U=306,V=271,UL=310,VL=48)
   End Object
   MenuObjects.Add(ExploreButton)
}

class MobileMenuExample extends MobileMenuScene;

defaultproperties
{   
   Left=0
   Top=0
   Width=1.0
   Height=180
   bRelativeWidth=true
   
   Begin Object Class=MobileMenuImage Name=Background
      Tag="Background"
      Left=0
      Top=0
      Width=1.0
      Height=1.0
      bRelativeWidth=true
      bRelativeHeight=true
      Image=Texture2D'CastleUI.menus.T_CastleMenu2'
      ImageDrawStyle=IDS_Stretched
      ImageUVs=(bCustomCoords=true,U=0,V=30,UL=1024,VL=180)
   End Object
   MenuObjects.Add(Background)

   Begin Object Class=MobileMenuButton Name=ExploreButton
      Tag="EXPLORE"
      Left=0.35
      Top=0.35
      Width=140
      Height=24
      bRelativeLeft=true
      bRelativeTop=true
      TopLeeway=20
      Images(0)=Texture2D'CastleUI.menus.T_CastleMenu2'
      Images(1)=Texture2D'CastleUI.menus.T_CastleMenu2'
      ImagesUVs(0)=(bCustomCoords=true,U=306,V=220,UL=310,VL=48)
      ImagesUVs(1)=(bCustomCoords=true,U=306,V=271,UL=310,VL=48)
   End Object
   MenuObjects.Add(ExploreButton)
}

function OnTouch(MobileMenuObject Sender,float TouchX, float TouchY, bool bCancel)
{
}

if(Sender == none)
{
   return;
}

if(bCancel)
{
   return;
}

if(Sender.Tag ~= "EXPLORE")
{
   InputOwner.CloseMenuScene(self);
}

class MobileMenuExample extends MobileMenuScene;

function OnTouch(MobileMenuObject Sender,float TouchX, float TouchY, bool bCancel)
{
   if(Sender == none)
   {
      return;
   }
   
   if(bCancel)
   {
      return;
   }
   
   if(Sender.Tag ~= "EXPLORE")
   {
      InputOwner.CloseMenuScene(self);
   }
}

defaultproperties
{   
   Left=0
   Top=0
   Width=1.0
   Height=180
   bRelativeWidth=true
   
   Begin Object Class=MobileMenuImage Name=Background
      Tag="Background"
      Left=0
      Top=0
      Width=1.0
      Height=1.0
      bRelativeWidth=true
      bRelativeHeight=true
      Image=Texture2D'CastleUI.menus.T_CastleMenu2'
      ImageDrawStyle=IDS_Stretched
      ImageUVs=(bCustomCoords=true,U=0,V=30,UL=1024,VL=180)
   End Object
   MenuObjects.Add(Background)

   Begin Object Class=MobileMenuButton Name=ExploreButton
      Tag="EXPLORE"
      Left=0.35
      Top=0.35
      Width=140
      Height=24
      bRelativeLeft=true
      bRelativeTop=true
      TopLeeway=20
      Images(0)=Texture2D'CastleUI.menus.T_CastleMenu2'
      Images(1)=Texture2D'CastleUI.menus.T_CastleMenu2'
      ImagesUVs(0)=(bCustomCoords=true,U=306,V=220,UL=310,VL=48)
      ImagesUVs(1)=(bCustomCoords=true,U=306,V=271,UL=310,VL=48)
   End Object
   MenuObjects.Add(ExploreButton)
}

Interface ITouchable;

function OnTouch(EZoneTouchEvent Type, float X, float Y);

class UDNMobileMenuBase extends MobileMenuScene;


/**
 * (씬 밖에) 범용 터치가 발생하면 델리게이트 발동
 */
delegate bool OnInputTouch(EZoneTouchEvent EventType, float TouchX, float TouchY);

/**
 * 터치 입력 발생시 호출
 */
function bool OnSceneTouch(EZoneTouchEvent EventType, float TouchX, float TouchY)
{
   OnInputTouch(EventType, TouchX, TouchY);
   
   return true;   
}

defaultproperties
{
}

class UDNMobileMenuScene extends MobileMenuScene;

/** 초기 터치 이벤트의 캐시된 위치 */
var Vector StartTouchLocation;

/** 지난 터치 업데이트 이벤트의 현재 위치 */
var Vector CurrentTouchLocation;

/** 현재 터치가 스와이프면 참 */
var bool bSwipe;

/** 터치가 스와이프로 간주되기 위한 최소 이동 거리. 이보다 작으면 탭. */
var float SwipeTolerance;

/** 콤보 박스가 그 목록을 모든 콘트롤 위에 겹쳐 표시하도록 하기 위해 사용 */
var instanced UDNMobileMenuList List;

var UDNMobileMenuBase HelperScene;


function Opened(string Mode)
{
   Super.Opened(Mode);
   
   //새 베이스 씬 열기 - 범용 터치 이벤트를 받을 수 있도록 폭이나 높이가 없음 
   HelperScene = UDNMobileMenuBase(InputOwner.OpenMenuScene(class'UDNMobileMenuBase'));
   
   //우리 핸들러를 베이스 씬의 인풋 델리게이트로 할당
   HelperScene.OnInputTouch = OnSceneTouch;
}

function Closing()
{
   //Cleanup - 씬을 닫기 전에 헬퍼 씬 닫기
   if(HelperScene != none)
   {
      InputOwner.CloseMenuScene(HelperScene);
   }

   Super.Closing();
}

function bool OnSceneTouch(EZoneTouchEvent EventType, float TouchX, float TouchY)
{
   local MobileMenuObject Touchable;
   
   //초기 터치 이벤트
   if(EventType == ZoneEvent_Touch)
   {
      //스와이프 비우기
      bSwipe = false;
      
      //터치 위치 캐시
      StartTouchLocation.X = TouchX;
      StartTouchLocation.Y = TouchY;
   }
   //터치 업데이트 이벤트
   else if(EventType == ZoneEvent_Update)
   {      
      //현재 터치 위치 저장
      CurrentTouchLocation.X = TouchX;
      CurrentTouchLocation.Y = TouchY;
      
      //이 터치가 스와이프인지 확인
      CheckSwipe();
   }

   //우리 목록이 표시되지 않으면 입력을 터치가능 콘트롤로 전달
   if(List == none || List.bIsHidden)
   {
      foreach MenuObjects(Touchable)
      {   
         if(ITouchable(Touchable) != none)
         {
            ITouchable(Touchable).OnTouch(EventType, TouchX, TouchY);
         }
      }   
   }
   //목록이 보이면 터치 입력을 전달
   else if(List != none && !List.bIsHidden)
   {
      ITouchable(List).OnTouch(EventType, TouchX, TouchY);
   }
   
   //입력을 처리했음을 확인하기 위해 참 반환
   return true;
}

function CheckSwipe()
{
   //터치를 스와이프로 간주할 만큼 움직였는지 검사
   if(VSize(StartTouchLocation - CurrentTouchLocation) > SwipeTolerance)
   {
      bSwipe = true;
   }   
}

function RenderScene(Canvas Canvas,float RenderDelta)
{
   //목록이 보이면 그리기
   if(List != none && !List.bIsHidden)
   {
      List.RenderObject(Canvas);
   }
   //목록이 없으면 우리 콘트롤 그리기
   else
   {
      Super.RenderScene(canvas, RenderDelta);
   }
}

defaultproperties
{
   SwipeTolerance = 5.0
}

class UDNMobileMenuObject extends MobileMenuObject
   implements(ITouchable) DependsOn(UDNMobileMenuBase);

   
function OnTouch(EZoneTouchEvent Type, float X, float Y)
{   
   if(bIsActive)
   {
      if(CheckBounds(X, Y))
      {
         if(Type == ZoneEvent_Touch)
         {
            bIsTouched = true;
            bIsHighlighted = true;
         }
         else if(Type == ZoneEvent_Untouch || Type == ZoneEvent_Cancelled)
         {
            bIsTouched = false;
            bIsHighlighted = false;
         }
      }
      else
      {
         bIsTouched = false;
         bIsHighlighted = false;
      }
   }
}

function bool CheckBounds(float X, float Y)
{
   if(X >= Left && X <= Left + Width && Y >= Top && Y <= Top + Height)
   {
      return true;
   }
   
   return false;
}

function bool CheckSwipe()
{
   return UDNMobileMenuScene(OwnerScene).bSwipe;
}

class UDNMobileMenuLabel extends UDNMobileMenuObject;
   

/** 라벨을 이루는 이미지 둘. [0] = 언터치됨, [1] = 터치됨 */
var Texture2D Images[2];

/** 이미지에 대한 UV 좌표. [0] = 언터치됨, [1] = 터치됨 */
var UVCoords ImagesUVs[2];

/** 이미지 덮어쓰기용 색 저장 */
var LinearColor ImageColors[2];

/** 라벨용 현지화가능 캡션 */
var string Caption;

/** 캡션용 색 저장 */
var LinearColor CaptionColors[2];

/** 텍스트를 그리는 데 사용될 폰트 저장 */
var font TextFont;

/** 참이면 라벨의 텍스츠 중앙정렬. 거짓이면 왼쪽정렬. */
var bool bCenterText;

/** 참이면 라벨 텍스트 줄바꾸기 안함 */
var bool bClipText;

/** 텍스트 중앙정렬을 하지 않을 때의 여백 픽셀 수 */
var float TextPadding;

/** 라벨 배경을 그리는 데 사용할 색. 지정된 텍스처가 없으면 사용 */
var LinearColor BackgroundColors[2];

/** 라벨 테두리를 그리는 데 사용할 색. 지정된 텍스처가 없으면 사용 */
var LinearColor BorderColors[2];

/** 네 테두리 폭. (순서: 위, 오른쪽, 아래, 왼쪽) */
var float BorderWidth[4];

/** 참이면 라벨 이미지를 그리는 데 DrawTileStretched() 사용. 거짓이면 DrawTile() 사용. */
var bool bStretchBackground;


/**
 * 라벨 초기화 - 이미지 좌표 구성
 */
function InitMenuObject(MobilePlayerInput PlayerInput, MobileMenuScene Scene, int ScreenWidth, int ScreenHeight)
{
   local int i;
   
   Super.InitMenuObject(PlayerInput, Scene, ScreenWidth, ScreenHeight);

   //커스텀 좌표 없음, 이미지 전체 크기로 설정
   for (i=0;i<2;i++)
   {
      if (!ImagesUVs[i].bCustomCoords && Images[i] != none)
      {
         ImagesUVs[i].U = 0.0f;
         ImagesUVs[i].V = 0.0f;
         ImagesUVs[i].UL = Images[i].SizeX;
         ImagesUVs[i].VL = Images[i].SizeY;
      }
   }
}


/**
 * 위젯 렌더링
 */
function RenderObject(canvas Canvas)
{
   local int Idx;
   local LinearColor DrawColor;

   //라벨이 터치 또는 반전되고 있는지에 따라 이미지/컬러 인덱스 구하기
   Idx = (bIsTouched || bIsHighlighted) ? 1 : 0;
   
   //이미지 세트가 있다면 그리기
   if(Images[Idx] != none)
   {   
      //배경 이미지 그리기용으로 캔버스 구성
      Canvas.SetPos(OwnerScene.Left + Left - Canvas.OrgX, OwnerScene.Top + Top - Canvas.OrgY);
      Drawcolor = ImageColors[Idx];
      Drawcolor.A *= Opacity * OwnerScene.Opacity;
      
      //배경 이미지를 늘여 그리기
      if(bStretchBackground)
      {
         Canvas.DrawTileStretched(Images[Idx], Width, Height,ImagesUVs[Idx].U, ImagesUVs[Idx].V, ImagesUVs[Idx].UL, ImagesUVs[Idx].VL, DrawColor, true, true);
      }
      //배경 이미지를 스케일 조절하여 그리기
      else
      {
         Canvas.DrawTile(Images[Idx], Width, Height,ImagesUVs[Idx].U, ImagesUVs[Idx].V, ImagesUVs[Idx].UL, ImagesUVs[Idx].VL, DrawColor, true);
      }
   }
   //설정된 이미지가 없어, 단순한 사각 배경 그리기
   else
   {
      //배경 사각형 그리기용 캔버스 구성
      Canvas.SetPos(OwnerScene.Left + Left - Canvas.OrgX, OwnerScene.Top + Top - Canvas.OrgY);
      Canvas.DrawColor.R = byte(BackgroundColors[Idx].R * 255.0);
      Canvas.DrawColor.G = byte(BackgroundColors[Idx].G * 255.0);
      Canvas.DrawColor.B = byte(BackgroundColors[Idx].B * 255.0);
      Canvas.DrawColor.A = byte(BackgroundColors[Idx].A * 255.0);
      Canvas.DrawRect(Width, Height);
      
      //테두리 그리기
      DrawBorder(Canvas);
   }

   //캡션 텍스트 그리기
   RenderCaption(Canvas);
}

/**
 * 라벨의 테두리 그리기
 *
 * @param Canvas - 드리기에 사용되는 캔버스 오브젝트
 */
function DrawBorder(Canvas Canvas)
{
   local int Idx;
   
   Idx = (bIsTouched || bIsHighlighted) ? 1 : 0;
   
   //위쪽 테두리 그리기
   if(BorderWidth[0] > 0)
   {
      Canvas.SetPos(Left - Canvas.OrgX, Top - Canvas.OrgY);
      Canvas.DrawColor.R = byte(BorderColors[Idx].R * 255.0);
      Canvas.DrawColor.G = byte(BorderColors[Idx].G * 255.0);
      Canvas.DrawColor.B = byte(BorderColors[Idx].B * 255.0);
      Canvas.DrawColor.A = byte(BorderColors[Idx].A * 255.0);
      Canvas.DrawRect(Width, BorderWidth[0]);
   }
   
   //오른쪽 테두리 그리기
   if(BorderWidth[1] > 0)
   {
      Canvas.SetPos(Left + Width - 1 - Canvas.OrgX, Top + Height - 1 - Canvas.OrgY);
      Canvas.DrawColor.R = byte(BorderColors[Idx].R * 255.0);
      Canvas.DrawColor.G = byte(BorderColors[Idx].G * 255.0);
      Canvas.DrawColor.B = byte(BorderColors[Idx].B * 255.0);
      Canvas.DrawColor.A = byte(BorderColors[Idx].A * 255.0);
      Canvas.DrawRect(BorderWidth[1], Height);
   }
   
   //아래쪽 테두리 그리기
   if(BorderWidth[2] > 0)
   {
      Canvas.SetPos(Left - Canvas.OrgX, Top + Height - 1 - Canvas.OrgY);
      Canvas.DrawColor.R = byte(BorderColors[Idx].R * 255.0);
      Canvas.DrawColor.G = byte(BorderColors[Idx].G * 255.0);
      Canvas.DrawColor.B = byte(BorderColors[Idx].B * 255.0);
      Canvas.DrawColor.A = byte(BorderColors[Idx].A * 255.0);
      Canvas.DrawRect(Width, BorderWidth[2]);
   }
   
   //왼쪽 테두리 그리기
   if(BorderWidth[3] > 0)
   {
      Canvas.SetPos(Left - Canvas.OrgX, Top - Canvas.OrgY);
      Canvas.DrawColor.R = byte(BorderColors[Idx].R * 255.0);
      Canvas.DrawColor.G = byte(BorderColors[Idx].G * 255.0);
      Canvas.DrawColor.B = byte(BorderColors[Idx].B * 255.0);
      Canvas.DrawColor.A = byte(BorderColors[Idx].A * 255.0);
      Canvas.DrawRect(BorderWidth[3], Height);
   }
}

/**
 * 라벨의 텍스트 그리기
 *
 * @param Canvas - 그리기에 사용되는 캔버스 오브젝트
 */
function RenderCaption(canvas Canvas)
{
   local float X,Y,UL,VL;
   local FontRenderInfo FRI;
   local int Idx;
   
   Idx = (bIsTouched || bIsHighlighted) ? 1 : 0;

   //텍스트가 설정되어 있어야만 그리기
   if (Caption != "")
   {
      Canvas.Font = TextFont;
      Canvas.TextSize(Caption,UL,VL);

      //필요하면 텍스트 중앙정렬, 아니면 왼쪽정렬
      if(bCenterText)
      {
         X = Left + (Width / 2) - (UL/2);
         Y = Top + (Height /2) - (VL/2);
      }
      else
      {
         X = Left + 5;
         Y = Top + (Height /2) - (VL/2);
      }

      //캡션 그리기용 캔버스 구성
      Canvas.SetPos(OwnerScene.Left + X - Canvas.OrgX, OwnerScene.Top + Y - Canvas.OrgY);
      Canvas.DrawColor.R = byte(CaptionColors[Idx].R * 255.0);
      Canvas.DrawColor.G = byte(CaptionColors[Idx].G * 255.0);
      Canvas.DrawColor.B = byte(CaptionColors[Idx].B * 255.0);
      Canvas.DrawColor.A = byte(CaptionColors[Idx].A * 255.0);

      //텍스트 그리기 - 필요하면 잘라내기
      FRI.bClipText = bClipText;
      Canvas.DrawText(Caption, false, 1.0, 1.0, FRI);
   }
}

defaultproperties
{
   ImageColors(0)=(r=1.0,g=1.0,b=1.0,a=1.0)
   ImageColors(1)=(r=0.5,g=0.5,b=0.5,a=1.0)
   CaptionColors(0)=(r=0.0,g=0.0,b=0.0,a=1.0)
   CaptionColors(1)=(r=1.0,g=1.0,b=1.0,a=1.0)
   
   bIsActive=false
   bCenterText=false
   bStretchBackground=true
   
   BorderWidth(0)=0
   BorderWidth(1)=0
   BorderWidth(2)=0
   BorderWidth(3)=0
}

class UDNMobileMenuButton extends UDNMobileMenuLabel;
   

/** 
 * 버튼이 탭을 받으면 호출되는 델리게이트
 */
delegate OnClick(UDNMobileMenuObject Sender, float X, float Y);

/**
 * ITouchable 인터페이스의 OnTouch() 멤버 구현.
 * 부모가 터치 이벤트를 받을 때 호출.
 *
 * @param Type - 터치 이벤트 유형
 * @param X - 터치 이벤트 가로 위치
 * @param Y - 터치 이벤트 세로 위치
 */
function OnTouch(EZoneTouchEvent Type, float X, float Y)
{
   Super.OnTouch(Type, X, Y);
   
   //버튼 경계 내에서 끝나는 터치, 리스너에게 탭을 알리고자 OnClick 델리게이트 발동
   if(Type == ZoneEvent_Untouch && CheckBounds(X, Y))
   {
      OnClick(self, X, Y);
   }
}

defaultproperties
{
   bIsActive=true
   bCenterText=true
}

class UDNMobileMenuList extends UDNMobileMenuObject;
   
/** 목록의 제목으로 표시할 텍스트 */
var string Title;   

/** 제목 텍스트 색 */
var Color CaptionColor;

/** 참이면 캡션 텍스트 중앙정렬. 거짓이면 왼쪽정렬. */
var bool bCenterText;
   
/** 목록 배경에 채울 색 */
var Color BackgroundColor;

/** 목록 테두리 색 */
var Color BorderColor;

/** 목록 항목의 배경색. [0] 은 비선택, [1] 은 선택 항목. */
var LinearColor ItemBackgroundColors[2];

/** 목록 항목의 테두리 색. [0] 은 비선택, [1] 은 선택 항목. */
var LinearColor ItemBorderColors[2];

/** 목록 항목 텍스트 색. [0] 은 비선택, [1] 은 선택 항목. */
var LinearColor ItemCaptionColors[2];

/** 목록 항목 텍스트 폰트. */
var Font ItemFont;

/** 목록을 닫는 데 사용할 취소 버튼으로의 참조. */
var instanced UDNMobileMenuButton Cancel;

/** 참이면 목록은 취소가능. (즉 취소 버튼이 표시됨) */
var bool bHasCancel;

/** 메뉴에 속하는 항목 목록 */
var instanced array<UDNMobileMenuButton> Items;

/** 현재 선택된 항목 인덱스 */
var int SelectedIndex;

/** 목록 내 각 항목 셀의 높이 */
var float ItemHeight;

/** 제목 바 높이 */
var float TitleBarHeight;

/** 제목 바 색 */
var Color TitleBarColor;

/** 목록이 제어되는 중이면, 즉 사용자가 현재 목록을 스크롤중이거나 하면 참. */
var bool bActive;

/** 목록에 대한 지난 터치 이벤트의 캐시된 위치 저장 */
var vector LastTouchLocation;

/** 목록이 활성 상태일 때 스크롤시킬 양. (터치 업데이트간의 델타. 목록과 사용자의 손가락 동기화 유지.) */
var float ScrollAmount;

/** 목록이 비활성 상태일 때 스크롤시킬 양. (스와이프를 통해 목록에 저장되는 속도가 얼마인지.) */
var float ScrollInertia;

/** 지난 렌더링 업데이트의 캐시된 시간 저장 */
var float LastRenderTime;

/** ScrollInertial(스크롤 관성) 제어에 사용되는 터치 이동에 대한 곱수 */
var float SwipeFactor;

/** 목록이 경계 너머로 스크롤되었을 때 되잡아끌 속도에 대한 곱수 */
var float SnapFactor;

/** 목록의 경계 너머 스크롤 가능한 거리 */
var float ScrollLimit;


/****************************************
* 초기화 및 렌더링 함수
****************************************/

/**
 * 목록 초기화
 */
function InitMenuObject(MobilePlayerInput PlayerInput, MobileMenuScene Scene, int ScreenWidth, int ScreenHeight)
{   
   Super.InitMenuObject(PlayerInput, Scene, ScreenWidth, ScreenHeight);
   
   //텍스트를 목록의 경계에 맞춰 잘라내기가 쉽지 않기에, 목록을 강제로 디바이스 화면의 크기에 맞춤
   Left = 0;
   Top = 0;
   Width = ScreenWidth;
   Height = ScreenHeight;
   
   //취소 버튼 초기화 (메뉴 시스템은 콘트롤 내의 콘트롤에 대한 처리가 내장되어있지 않음)
   Cancel.InitMenuObject(PlayerInput, Scene, ScreenWidth, ScreenHeight);
   
   //취소 버튼 위치를 제목 바 오른쪽에 세로 중앙정렬
   Cancel.Top = Top + ((TitleBarHeight - Cancel.Height) / 2);
   Cancel.Left = Left + Width - Cancel.Width - 1;
   
   //버튼에서 클릭 이벤트 잡기
   Cancel.OnClick = HandleCancel;
}

/**
 * 목록 그리기
 */
function RenderObject(canvas Canvas)
{
   local int i;
   local float DeltaTime;
   local float ScrollDelta;
   
   Canvas.SetPos(Left, Top);
   
   //목록 배경 그리기
   Canvas.DrawColor = BackgroundColor;
   Canvas.DrawRect(Width, Height);
   
   //목록 수동 스크롤에 사용할 렌더 델타 계산
   if(LastRenderTime != 0)
   {
      DeltaTime = InputOwner.Outer.WorldInfo.RealTimeSeconds - LastRenderTime;
   }
   lastRenderTime = InputOwner.Outer.WorldInfo.RealTimeSeconds;   
   
   if(Items.Length > 0)
   {
      //이 렌더 패스에 대한 스크롤 델타 계산 및 목록 경계 밖이면 목록 잡아채기
      if(Items[0].Top > Top + TitleBarHeight)
      {
         ScrollInertia = Top + TitleBarHeight - Items[0].Top;
         ScrollDelta = ScrollInertia * DeltaTime * SnapFactor;
      }
      else if(Items[Items.Length - 1].Top + ItemHeight < Top + Height)
      {
         ScrollInertia = (Top + Height) - (Items[Items.Length - 1].Top + ItemHeight);
         ScrollDelta = ScrollInertia * DeltaTime * SnapFactor;
      }
      else
      {      
         ScrollDelta = ScrollInertia * DeltaTime;
      }
      
      //각 목록 항목 렌더링
      for(i=0; i < Items.Length; i++)
      {
         //오리엔테이션이 변경된 경우 여기서 항목 크기 강제
         Items[i].Left = left;
         Items[i].Top += bActive ? ScrollAmount : ScrollDelta;
         Items[i].Width = Width;
         Items[i].Height = ItemHeight;
         
         //일부라도 보이는 항목만 렌더링
         if(Items[i].Top + ItemHeight > Top && Items[i].Top < Top + Height)
         {
            Items[i].RenderObject(Canvas);
         }
      }
   }
   
   if(bActive)
   {
      //능동이면 활성 스크롤 0화
      ScrollAmount = 0;
   }
   else
   {
      //수동이면 스크롤 관성 감소
      ScrollInertia -= ScrollDelta;
   }
   
   //제목 바 그리기 - 목록 항목이 제목 바에 클리핑되게 목록 항목 이후에 그리기
   Canvas.SetPos(Left, Top);   
   Canvas.DrawColor = TitleBarColor;
   Canvas.DrawRect(Width, TitleBarHeight);
   
   //제목 그리기
   RenderTitle(Canvas);
   
   //목록 테두리 그리기
   Canvas.SetPos(Left, Top + TitleBarHeight);   
   Canvas.DrawColor = BorderColor;
   Canvas.DrawBox(Width, Height - TitleBarHeight);
   
   //원하는 경우 취소 버튼 그리기
   if(bHasCancel)
   {
      Cancel.RenderObject(Canvas);
   }
}

/**
 * 목록의 제목 텍스트 그리기
 */
function RenderTitle(canvas Canvas)
{
   local float X,Y,UL,VL;
   local FontRenderInfo FRI;

   //제목이 없어도 걱정 뚝
   if (Title != "")
   {
      //폰트 설정 (씬 폰트를 빌려쓰겠지만, 커스텀 폰트 추가 가능)
      Canvas.Font = OwnerScene.SceneCaptionFont;
      Canvas.TextSize(Title,UL,VL);

      //위치 계산 - 중앙정렬 또는 왼쪽정렬
      if(bCenterText)
      {
         X = Left + (Width / 2) - (UL/2);
         Y = Top + (Height /2) - (VL/2);
      }
      else
      {
         X = Left + (TitleBarHeight /2) - (VL/2);
         Y = Top + (TitleBarHeight /2) - (VL/2);
      }

      //제목 텍스트를 클리핑하여 그리기 (들어맞지 않으면 ... 식으로 줄이는 기능 추가 가능.)
      Canvas.SetPos(OwnerScene.Left + X - Canvas.OrgX, OwnerScene.Top + Y - Canvas.OrgY);
      Canvas.DrawColor = CaptionColor;
      FRI.bClipText = true;
      Canvas.DrawText(Title, false, 1.0, 1.0, FRI);
   }
}

/****************************************
* 항목 관리 함수
****************************************/

/**
 * 목록에 새 항목 추가
 *
 * @param item - 추가시킬 새 항목 값
 */
function AddItem(string item)
{
   local UDNMobileMenuButton NewItem;
   local Vector2D ViewportSize;
   
   //새 항목 (버튼) 생성
   NewItem = new(Outer) class'UDNMobileMenuButton';
   
   if(NewItem != none)
   {
      //새 항목 초기화
      LocalPlayer(InputOwner.Outer.Player).ViewportClient.GetViewportSize(ViewportSize);
      NewItem.InitMenuObject(InputOwner, OwnerScene, ViewportSize.X, ViewportSize.Y);
      
      //새 항목 속성 설정
      NewItem.Caption = item;
      NewItem.CaptionColors[0] = ItemCaptionColors[0];
      NewItem.CaptionColors[1] = ItemCaptionColors[1];
      NewItem.TextFont = ItemFont;
      NewItem.Left = Left;
      NewItem.BackgroundColors[0] = ItemBackgroundColors[0];
      NewItem.BackgroundColors[1] = ItemBackgroundColors[1];
      NewItem.BorderColors[0] = ItemBorderColors[0];
      NewItem.BorderColors[1] = ItemBorderColors[1];
      NewItem.Top = Top + TitleBarHeight + (Items.Length * ItemHeight);
      NewItem.OnClick = OnSelect;
      NewItem.bCenterText = false;
      NewItem.BorderWidth[2] = 1;
      
      //선택 항목이 되려는 경우, 반전시킴
      if(Items.Length == SelectedIndex)
      {
         NewItem.bIsHighlighted = true;
      }
      
      //항목을 목록에 추가
      Items.AddItem(NewItem);
   }
}

/**
 * 목록에서 값 제거
 * 
 * @param Idx - 제거할 항목의 인덱스
 */
function RemoveItem(int Idx)
{
   local int i;
   
   //목록에서 항목 제거
   Items.Remove(Idx, 1);
   
   //다음 항목을 위로 이동
   for(i=Idx; i < Items.Length; i++)
   {
      Items[i].Top -= ItemHeight;
   }
   
   //선택된 항목을 제거한 경우, 첫 항목으로 선택 재설정
   if(SelectedIndex == Idx)
   {
      SelectedIndex = 0;
      if(Items.Length > 0)
      {
         Items[0].bIsHighlighted = true;
      }
   }
}

/**
 * 목록의 값 구하기
 *
 * 선택된 항목의 캡션 반환
 */
function string GetValue()
{
   //선택된 인덱스에 액세스할 항목을 가져야 함
   if(Items.Length > 0)
   {
      //선택된 항목의 캡션 (값) 반환
      return Items[SelectedIndex].Caption;
   }
   else
   {
      //항목 없음 - 빈 문자열 반환
      return "";
   }
}

/****************************************
* 인풋 함수
****************************************/
   
/**
 * 목록 내 항목이 선택되면 델리게이트 발동
 */
delegate OnChange(int Idx, string Item, float X, float Y);

/**
 * 목록이 취소되면 델리게이트 발동
 */
delegate OnCancel();

/**
 * ITouchable 인터페이스 구현
 */
function OnTouch(EZoneTouchEvent Type, float X, float Y)
{
   local UDNMobileMenuButton Label;
   local float ActualY;
   
   Super.OnTouch(Type, X, Y);
   
   //초기 터치 이벤트
   if(Type == ZoneEvent_Touch)
   {
      //목록 밖 또는 제목 바에 터치된 경우 무시
      if(CheckBounds(X, Y) && Y > Top + TitleBarHeight)
      {
         //목록 활성으로 설정 - 사용자가 제어중
         bActive = true;
         
         //터치 위치 캐시
         LastTouchLocation.X = X;
         LastTouchLocation.Y = y;
         
         //스크롤 값 리셋
         ScrollAmount = 0;
         ScrollInertia = 0;
      }
   }
   //터치 진행중
   else if(Type == ZoneEvent_Update || Type == ZoneEvent_Stationary)
   {
      //목록이 활성이 아니면 무시 - 터치가 목록 밖에서 시작된 듯
      if(bActive)
      {
         /************************************************************
         *   다음과 같은 경우에만 스크롤 업데이트:
         *
         *    * 스크롤이 필요할 만큼 항목이 있음
         *    * 목록이 이미 경계 밖으로 스크롤되지 않음
         *    
         ************************************************************/
         if(   (Items.Length * ItemHeight > Height) && 
            ((Items[0].Top - (Top + TitleBarHeight) < ScrollLimit) || (Y < LastTouchLocation.Y)) && 
            (((Top + Height) - (Items[Items.Length - 1].Top + ItemHeight) < ScrollLimit) || (Y > LastTouchLocation.Y)))
         {
            //사용된 관성을 구하고자 실제 관성에 디바이스 스케일링과 커스텀 스와이프 인수로 곱해줌
            ActualY = (Y - LastTouchLocation.Y) * class'MobileMenuScene'.static.GetGlobalScaleY() * SwipeFactor;
            
            //이동이 무시가능한 수준이면 스크롤 관성 리셋. 아니면 새로운 델타만큼 증가.
            if(Abs(ActualY) < UDNMobileMenuScene(OwnerScene).SwipeTolerance)
            {
               ScrollInertia = 0;
            }
            else
            {
               ScrollInertia += ActualY;
            }
            
            //활성 스크롤 및 증분용 이동 델타 계산
            ActualY = (Y - LastTouchLocation.Y);
            ScrollAmount += ActualY;
         }
         
         //캐시된 터치 위치 업데이트
         LastTouchLocation.X = X;
         LastTouchLocation.Y = y;
      }
   }
   //사용자가 손가락을 들어 터치 종료
   else if(Type == ZoneEvent_Untouch)
   {
      //스와이프가 아니며 목록 내임
      if(!CheckSwipe() && CheckBounds(X, Y))
      {   
         //제목 바 안이 아님 - 항목 위의 탭인 듯
         if(Y > Top + TitleBarHeight)
         {
            //모든 항목 위에 탭 전달
            foreach Items(Label)
            {
               Label.OnTouch(Type, X, Y);
            }
         }
         //제목 바에 탭
         else
         {
            //목록이 취소 가능하면 취소 버튼에 탭 처리 위임
            if(bHasCancel)
            {
               Cancel.OnTouch(Type, X, Y);
            }
         }
      }
      
      //수동으로 가기 전에 스크롤 관성 마지막 업데이트
      if(bActive)
      {
         ActualY = (Y - LastTouchLocation.Y) * class'MobileMenuScene'.static.GetGlobalScaleY() * SwipeFactor;
         ScrollInertia += ActualY;
         
         //목록 수동으로 설정
         bActive = false;
      }
   } 
   //터치가 미완 상태로 종료
   else if(Type == ZoneEvent_Cancelled)
   {      
      //수동으로 설정
      bActive = false;
      
      //모든 스크롤 값 0화
      ScrollAmount = 0;
      ScrollInertia = 0;
   }
}

/**
 * 목록 내 새 항목 선택.
 * 목록 내 각 항목의 OnClick() 으로 할당.
 */
function OnSelect(UDNMobileMenuObject Sender, float X, float Y)
{
   local UDNMobileMenuButton Label;
   local int i;
   
   i = 0;
   
   if(UDNMobileMenuButton(Sender) != none)
   {
      //보낸이가 일치하는 항목을 찾고자 항목 반복처리
      foreach Items(Label)
      {
         //일치하는 항목 찾음
         if(Label == UDNMobileMenuButton(Sender))
         {
            //새 선택 인덱스 설정
            SelectedIndex = i;
            
            //선택된 항목 반전
            Sender.bIsHighlighted = true;
            
            //리스닝중인 것에 알리고자 OnChange 델리게이트 호출
            OnChange(i, Label.Caption, X, Y);
            
            //모든 작업이 끝났으니 반복처리 빠져나가기
            break;
         }
         
         i++;
      }
   }
   
   //수동으로 설정
   bActive = false;
   
   //모든 스크롤 값 0화
   ScrollAmount = 0;
   ScrollInertia = 0;
}

/**
 * 목록 취소하기.
 * 취소 버튼의 OnClick() 으로 할당.
 */
function HandleCancel(UDNMobileMenuObject Sender, float X, float Y)
{
   //리스닝중인 것에 알리고자 OnCancel 델리게이트 호출
   OnCancel();
   
   //수동으로 설정
   bActive = false;
   
   //모든 스크롤 값 0화
   ScrollAmount = 0;
   ScrollInertia = 0;
}

defaultproperties
{
   CaptionColor=(R=255,G=255,B=255,A=255)
   BackgroundColor=(R=64,G=64,B=64,A=255)
   BorderColor=(R=64,G=64,B=64,A=255)
   ItemBackgroundColors(0)=(R=0.5,G=0.5,B=0.5,A=1.0)
   ItemBackgroundColors(1)=(R=0.75,G=0.75,B=0.75,A=1.0)
   ItemBorderColors(0)=(R=0.25,G=0.25,B=0.25,A=1.0)
   ItemBorderColors(1)=(R=1.0,G=1.0,B=1.0,A=1.0)
   ItemCaptionColors(0)=(R=1.0,G=1.0,B=1.0,A=1.0)
   ItemCaptionColors(1)=(R=1.0,G=1.0,B=1.0,A=1.0)
   ItemFont=Font'EngineFonts.SmallFont'
   
   ItemHeight=48
   SwipeFactor=5
   SnapFactor=5
   ScrollLimit=20
   
   TitleBarHeight=32
   TitleBarColor=(R=96,G=96,B=96,A=255)
   
   Begin Object class=UDNMobileMenuButton name=CancelButton
      Tag="Cancel"
      Width=64
      Height=32
      Caption="Cancel"
      TextFont=Font'EngineFonts.SmallFont'
      CaptionColors(0)=(r=1.0,g=1.0,b=1.0,a=1.0)
      CaptionColors(1)=(r=0.0,g=0.0,b=0.0,a=1.0)
      Images(0)=Texture2D'UDNExampleUI.Menus.T_MenuUI'
      Images(1)=Texture2D'UDNExampleUI.Menus.T_MenuUI'
      ImagesUVs(0)=(bCustomCoords=true,U=0,V=896,UL=256,VL=128)
      ImagesUVs(1)=(bCustomCoords=true,U=0,V=896,UL=256,VL=128)
   End Object
   Cancel=CancelButton
}

class UDNMobileMenuComboBox extends UDNMobileMenuObject;


/** 콤보박스를 시각적으로 표현해 내는 버튼 */
var instanced UDNMobileMenuButton Label;

/** 콤보박스용 새 값 선택에 사용되는 목록 */
var instanced UDNMobileMenulist list;

/** 콤보박스 제목 - 목록 제목 설정시에도 사용 */
var string Title;

/** 참이면 제목 표시. 거짓이면 현재 값 표시. */
var bool bShowTitle;

/** 목록을 채우는 데 사용되는 값 목록. */
var array<string> Items;

/** 콤보 박스를 이 값 인덱스로 초기화. */
var int InitialSelectedIndex;

/** 새 값 선택을 위해 목록이 열려 있으면 참. */
var bool bIsOpen;


/****************************************
* 초기화 및 렌더링 함수
****************************************/

/**
 * 콤보박스 초기화
 */
function InitMenuObject(MobilePlayerInput PlayerInput, MobileMenuScene Scene, int ScreenWidth, int ScreenHeight)
{
   local string item;
   
   Super.InitMenuObject(PlayerInput, Scene, ScreenWidth, ScreenHeight);
   
   //라벨 및 목록 초기화
   Label.InitMenuObject(PlayerInput, Scene, ScreenWidth, ScreenHeight);
   List.InitMenuObject(PlayerInput, Scene, ScreenWidth, ScreenHeight);
   
   //라벨의 위치와 크기 설정
   Label.Left = Left;
   Label.Width = Width;
   Label.Top = Top;
   Label.height = height;
   
   //라벨 캡션 초기화
   Label.Caption = Items[InitialSelectedIndex];
   
   //델리게이트 구성
   Label.OnClick = OnClick;
   List.OnChange = OnSelect;
   List.OnCancel = OnCancel;   
   
   //목록 초기화
   List.bHasCancel = true;
   List.SelectedIndex = InitialSelectedIndex;
   List.Title = Title;
   
   //항목 값을 목록에 항목으로 추가
   foreach Items(item)
   {
      List.AddItem(item);
   }
}

/**
 * 콤보박스 그리기
 */
function RenderObject(canvas Canvas)
{      
   //열려있는 경우 아무것도 렌더링 안함 - 오너 씬에 속하는 목록이 렌더링 처리
   if(!bIsOpen)
   {
      //라벨 텍스트 업데이트
      if(bShowTitle)
      {
         Label.Caption = Title;
      }
      else
      {
         Label.Caption = GetValue();
      }
      
      //라벨 그리기
      Label.RenderObject(Canvas);
   }
}

/****************************************
* 목록 관리 함수
****************************************/

/**
 * 콤보박스의 옵션에 항목 추가
 *
 * @param item - 추가시킬 항목 값
 */
function AddItem(string Item)
{
   //값을 내부 목록 밖에 추가
   Items.Additem(Item);
   
   //값을 실제 목록 내 새 항목으로 추가
   List.Additem(Item);
}

/**
 * 값을 콤보박스 옵션에서 제거
 *
 * @param Idx - 제거할 항목 인덱스
 */
function RemoveItem(int Idx)
{
   //내부 목록에서 항목 제거
   Items.Remove(Idx, 1);
   
   //실제 목록에서 값 제거
   List.RemoveItem(Idx);
}

/**
 * 목록이 열렸/닫혔는지 토글
 */
function ToggleList()
{
   //열림? 값 토글
   bIsOpen = !bIsOpen;
   
   //오너 씬의 목록 업데이트
   if(bIsOpen)
   {   
      //우리 목록을 활성 목록으로 설정하고 보이는지 확인
      UDNMobileMenuScene(OwnerScene).List = List;
      List.bIsHidden = false;
   }
   else
   {
      //씬의 목록 참조를 비우고 목록을 보이지 않게 만듦
      UDNMobileMenuScene(OwnerScene).List = none;
      List.bIsHidden = true;
   }
}

/**
 * 콤보박스의 값 (그 목록을 통해) 반환
 */
function string GetValue()
{
   //목록이 값을 구하도록 위임
   return List.GetValue();
}

/****************************************
* 인풋 함수
****************************************/

/**
 * 항목이 선택되면 델리게이트 발동
 */
delegate OnChange(int Idx, string Item, float X, float Y);

/**
 * ITouchable 인터페이스의 OnTouch() 함수 구현
 */
function OnTouch(EZoneTouchEvent Type, float X, float Y)
{
   Super.OnTouch(Type, X, Y);
   
   //목록이 열렸으면 입력을 목록에 전달
   if(bIsOpen)
   {
      List.OnTouch(Type, X, Y);
   }
   //목록이 닫힘
   else
   {   
      //탭을 받으면 목록 열림 토글
      if(!CheckSwipe())
      {
         Label.OnTouch(Type, X, Y);
      }
   }
}

function OnClick(UDNMobileMenuObject Sender, float X, float Y)
{
   ToggleList();
}

/**
 * 항목이 선택되면 호출
 * 목록의 OnChange() 로 할당
 */
function OnSelect(int Idx, string item, float X, float Y)
{
   //목록 닫기
   ToggleList();
   
   //리스닝중인 것에 우리 OnChange 델리게이트 발동
   OnChange(Idx, Item, X, Y);
   
   //오너 씬에게 탭을 받았다고 알려줌
   OwnerScene.OnTouch(self, X, Y, false);
}

/**
 * 선택 취소, 목록 닫기
 */
function OnCancel()
{
   //선택이 취소되어, 목록을 닫음
   ToggleList();
}

defaultproperties
{   
   Begin Object class=UDNMobileMenuButton name=Label0
      Tag="Combo_LabelItem"
      bCenterText=false
      TextFont=Font'EngineFonts.SmallFont'
      CaptionColors(0)=(R=0.125,G=0.125,B=0.125,A=1.0)
      CaptionColors(1)=(R=0.125,G=0.125,B=0.125,A=1.0)
      Images(0)=Texture2D'UDNExampleUI.Menus.T_MenuUI'
      Images(1)=Texture2D'UDNExampleUI.Menus.T_MenuUI'
      ImagesUVs(0)=(bCustomCoords=true,U=0,V=768,UL=1024,VL=128)
      ImagesUVs(1)=(bCustomCoords=true,U=0,V=768,UL=1024,VL=128)
   End Object
   Label=Label0
   
   Begin Object class=UDNMobileMenuList name=List0
      Tag="Combo_ItemsList"
   End Object
   List=List0
}

class UDNMobileMenuExample extends UDNMobileMenuScene;

/**
 * 콘트롤에서 기본 탭 처리
 */
event OnTouch(MobileMenuObject Sender,float TouchX, float TouchY, bool bCancel)
{
   //콤보박스 1 변경됨, 라벨을 그 값으로 설정
   if(Sender.Tag == "Combo1")
   {
      UDNMobileMenuLabel(FindMenuObject("Title")).Caption = UDNMobileMenuComboBox(FindMenuObject("Combo1")).GetValue();
   }
   //콤보박스 2 변경됨, 라벨을 그 값으로 설정
   else if(Sender.Tag == "Combo2")
   {
      UDNMobileMenuLabel(FindMenuObject("Title")).Caption = UDNMobileMenuComboBox(FindMenuObject("Combo2")).GetValue();
   }
}

defaultproperties
{
   //콤보박스 생성
   Begin Object class=UDNMobileMenuComboBox name=Combo0
      Tag="Combo1"
      Title="Setting One"
      Height=32
      Width=256
      Top=20
      Left=20
      Items(0)="Item 0"
      Items(1)="Item 1"
      Items(2)="Item 2"
      Items(3)="Item 3"
      Items(4)="Item 4"
      Items(5)="Item 5"
      InitialSelectedIndex=3
      bShowTitle=true
   End Object
   MenuObjects.Add(Combo0)
   
   //콤보박스 생성
   Begin Object class=UDNMobileMenuComboBox name=Combo1
      Tag="Combo2"
      Title="Setting Two"
      Height=32
      Width=256
      Top=60
      Left=20
      Items(0)="Object 0"
      Items(1)="Object 1"
      Items(2)="Object 2"
      Items(3)="Object 3"
      Items(4)="Object 4"
      Items(5)="Object 5"
      Items(6)="Object 6"
      Items(7)="Object 7"
      Items(8)="Object 8"
      Items(9)="Object 9"
      Items(10)="Object 10"
      Items(11)="Object 11"
      Items(12)="Object 12"
      Items(13)="Object 13"
      Items(14)="Object 14"
      Items(15)="Object 15"
      InitialSelectedIndex=9
   End Object
   MenuObjects.Add(Combo1)
   
   //라벨 생성
   Begin Object class=UDNMobileMenuLabel name=Label0
      Tag="Title"
      Height=32
      Width=160
      Left=296
      Top=20
      TextFont=Font'EngineFonts.SmallFont'
      CaptionColors(0)=(R=1.0,G=1.0,B=1.0,A=1.0)
      CaptionColors(1)=(R=1.0,G=1.0,B=1.0,A=1.0)
      Images(0)=Texture2D'UDNExampleUI.Menus.T_MenuUI'
      Images(1)=Texture2D'UDNExampleUI.Menus.T_MenuUI'
      ImagesUVs(0)=(bCustomCoords=true,U=576,V=384,UL=192,VL=192)
      ImagesUVs(1)=(bCustomCoords=true,U=576,V=384,UL=192,VL=192)
   End Object
   MenuObjects.Add(Label0)
}