khi/XRLib
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

버그 수정 중. 이동 후 남겨지는 경우가 있음

Browse Source
This commit is contained in:
logonkhi
2025-10-31 19:55:14 +09:00
parent 09a620ff71
commit 02ed8a01a0
10 changed files with 1079 additions and 1345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

534
Assets/Scripts/UVC/UI/List/Tree/TreeListItem.cs
View File

@@ -1,9 +1,7 @@
#nullable enable
using Cysharp.Threading.Tasks;
using DG.Tweening;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.UI;
@@ -13,130 +11,63 @@ namespace UVC.UI.List.Tree
/// 트리 리스트의 개별 아이템을 표시하고 관리하는 UI 클래스입니다.
///
/// 역할:
/// 1. 아이템의 이름을 화면에 표시
/// 2. 자식 아이템 펼침/접힘 기능 관리
/// 3. 아이템 선택/선택 해제 표시
/// 4. 사용자 입력(클릭, 키) 처리
/// 5. 데이터 변경 감지 및 UI 업데이트
/// - 아이템 이름 표시
/// - 자식 아이템 펼침/접힘 관리
/// - 선택 상태 UI 표시 및 입력 처리
/// - 데이터 변경 감지 후 UI 동기화
/// - 드래그 & 드롭 핸들러 연결
///
/// 구조:
/// 📦 TreeListItem (이 클래스)
/// ├─ 📝 valueText: 아이템 이름 표시 (TextMeshPro)
/// ├─ 🔘 childExpand: 펼침/접힘 버튼
/// ├─ 📦 childContainer: 자식 아이템들을 담는 컨테이너
/// ├─ 🎨 selectedBg: 선택됨 표시 배경
/// └─ 🔘 itemButton: 클릭 감지 버튼
///
/// MonoBehaviour란?
/// Unity의 모든 GameObject가 가져야 할 기본 클래스입니다.
/// Update, OnDestroy 같은 Unity의 생명주기 메서드를 사용할 수 있습니다.
/// 구성:
/// "TreeListItem"
/// ├─ "valueText": 이름 텍스트
/// ├─ "childExpand": 펼침/접힘 버튼
/// ├─ "childContainer": 자식 컨테이너
/// ├─ "childRoot": 자식 배치 부모
/// ├─ "selectedBg": 선택 배경
/// └─ "itemButton": 아이템 클릭 버튼
/// </summary>
public class TreeListItem : MonoBehaviour
{
#region UI 컴포넌트 참조 (UI Component References)
/// <summary>
/// 이 아이템을 관리하는 부모 TreeList입니다.
///
/// 용도:
/// - 선택 상태 변경 시 TreeList에 알림
/// - 새 자식 아이템 생성 시 프리팹 가져오기
/// - 키보드 입력(Ctrl, Shift) 상태 전달
///
/// [SerializeField]란?
/// Inspector에서 이 값을 직접 할당할 수 있게 해줍니다.
/// (private이지만 Unity가 특별히 접근 가능)
/// 이 아이템을 관리하는 상위 컨트롤입니다. (선택/평탄화/프리팹 액세스 등에 사용)
/// </summary>
[SerializeField]
protected TreeList treeList;
/// <summary>
/// 이 아이템의 이름을 표시하는 텍스트 UI입니다.
///
/// TMPro.TextMeshProUGUI란?
/// TextMeshPro는 Unity의 고급 텍스트 시스템입니다.
/// 일반 Text보다 더 예쁘고 빠릅니다.
///
/// 사용:
/// valueText.text = "새로운 이름"; // 화면에 표시되는 텍스트 변경
/// 아이템 이름 텍스트(UI).
/// </summary>
[SerializeField]
protected TMPro.TextMeshProUGUI valueText;
/// <summary>
/// 트리의 자식을 펼침/접힘하는 화살표 버튼입니다.
///
/// 특징:
/// - 자식이 없으면 숨겨집니다
/// - 자식이 펼쳐지면 ▼ 모양
/// - 자식이 접혀있으면 ▶ 모양
/// - 클릭 시 ToggleChild() 메서드 호출
///
/// 회전 애니메이션:
/// DORotate()를 사용해 부드럽게 회전합니다.
/// 자식 펼침/접힘 버튼. onClick에서 ToggleChild를 호출합니다.
/// </summary>
[SerializeField]
protected Button childExpand;
/// <summary>
/// 모든 자식 아이템들을 담는 컨테이너 GameObject입니다.
///
/// 역할:
/// - 자식 아이템들을 묶음으로 보관
/// - 펼침/접힘 시 이 컨테이너 전체를 표시/숨김
/// - SetActive(true/false)로 온/오프 제어
///
/// GameObject란?
/// Unity의 모든 객체(씬의 모든 것)의 기본 단위입니다.
/// 게임 오브젝트는 여러 컴포넌트를 가질 수 있습니다.
/// 자식 아이템들을 포함하는 컨테이너 GameObject.
/// </summary>
[SerializeField]
protected GameObject childContainer;
/// <summary>
/// 자식 아이템들이 실제로 배치되는 부모 Transform입니다.
///
/// RectTransform란?
/// UI 요소의 위치, 크기, 회전을 관리하는 컴포넌트입니다.
/// Canvas 아래의 모든 UI 요소가 RectTransform을 가집니다.
///
/// 용도:
/// - childRoot.childCount: 현재 몇 개의 자식이 있는지 확인
/// - new TreeListItem을 Instantiate할 때 부모로 지정
///
/// 구조 예:
/// childRoot (이것)
/// ├─ 자식1 (TreeListItem)
/// ├─ 자식2 (TreeListItem)
/// └─ 자식3 (TreeListItem)
/// 자식 TreeListItem이 배치될 부모 RectTransform.
/// </summary>
[SerializeField]
protected RectTransform childRoot;
/// <summary>
/// 아이템이 선택되었을 때 배경으로 표시되는 이미지입니다.
///
/// 예: 파일 탐색기에서 파일을 선택했을 때 파일 이름 뒤의 파란 배경
///
/// 동작:
/// - IsSelected가 true면 selectedBg.gameObject.SetActive(true)
/// - IsSelected가 false면 selectedBg.gameObject.SetActive(false)
/// - 모든 레벨의 선택된 아이템의 selectedBg 왼쪽이 정렬됨
/// 선택 상태를 표시하는 배경 이미지.
/// </summary>
[SerializeField]
protected Image selectedBg;
/// <summary>
/// 아이템 전체를 클릭 가능하게 하는 버튼 컴포넌트입니다.
///
/// Button이란?
/// 사용자가 클릭하면 onClick 이벤트를 발생시킵니다.
/// 이 경우 OnItemClicked() 메서드가 호출됩니다.
///
/// onClick.AddListener는?
/// 버튼이 클릭되면 리스너 함수를 호출하라는 뜻입니다.
/// 예: itemButton.onClick.AddListener(OnItemClicked);
/// → itemButton을 클릭하면 OnItemClicked() 실행
/// 아이템 전체 클릭 버튼. onClick에서 OnItemClicked를 호출합니다.
/// </summary>
[SerializeField]
protected Button itemButton;
@@ -146,62 +77,17 @@ namespace UVC.UI.List.Tree
#region 데이터 필드 (Data Fields)
/// <summary>
/// 이 UI 아이템이 표시하는 데이터 객체입니다.
///
/// 구조:
/// TreeListItem (UI - 화면에 보이는 것)
/// ↓
/// TreeListItemData (데이터 - 실제 정보)
///
/// 관계:
/// - TreeListItemData에 이름, 자식 목록, 선택 상태 등이 저장됨
/// - TreeListItem은 이 데이터를 화면에 표시하고 상호작용 처리
///
/// 예:
/// data.Name = "폴더"
/// → valueText.text = "폴더"로 화면에 표시
///
/// data.IsSelected = true
/// → selectedBg가 활성화되어 선택 표시
///
/// ? 연산자 (nullable):
/// data는 null일 수 있습니다.
/// 따라서 사용 전에 null 체크를 해야 합니다.
/// if (data == null) return;
/// 이 UI가 표시하는 데이터(Nullable). UI는 이 데이터의 변경 이벤트에 반응합니다.
/// </summary>
protected TreeListItemData? data;
/// <summary>
/// data 속성을 읽기 전용으로 공개합니다.
///
/// 문법:
/// public TreeListItemData? Data => data;
/// = getter 전용 프로퍼티
/// = 외부에서 이 값을 읽을 수 있지만 변경할 수 없음
///
/// 사용 예:
/// if (treeItem.Data != null)
/// {
/// Debug.Log(treeItem.Data.Name); // 읽기만 가능
/// }
/// 표시 데이터의 읽기 전용 접근자.
/// </summary>
public TreeListItemData? Data => data;
/// <summary>
/// 펼침/접힘 애니메이션이 진행 중인지를 나타내는 플래그입니다.
///
/// 용도: 애니메이션이 끝나기 전에 다시 클릭하는 것을 방지합니다.
///
/// 시나리오:
/// 1. 사용자가 화살표 버튼 클릭
/// 2. isAnimating = true (애니메이션 시작)
/// 3. 0.3초 동안 화살표가 회전
/// 4. 애니메이션 완료 → isAnimating = false
///
/// 중간에 다시 클릭해도:
/// if (isAnimating) return; ← 여기서 무시됨
///
/// 이렇게 하는 이유: 애니메이션이 겹치면 버그가 발생할 수 있음
/// 펼침/접힘 애니메이션 진행 여부(중복 입력 방지).
/// </summary>
protected bool isAnimating = false;
@@ -210,27 +96,20 @@ namespace UVC.UI.List.Tree
#region 초기화 (Initialization)
/// <summary>
/// 이 TreeListItem을 초기화합니다.
/// TreeListItem을 초기화합니다.
///
/// 호출 시점:
/// - 새로운 TreeListItem이 생성될 때
/// - Instantiate 직후 에 Init()이 호출됨
///
/// 초기화 과정:
/// 1. UI 요소 설정 (이름 표시, 이벤트 연결)
/// 2. 자식이 있으면 자식 UI 생성
/// 3. 데이터 변경 이벤트 구독
/// 4. 버튼 클릭 이벤트 구독
/// 5. 선택 상태 UI 업데이트
/// 6. 선택된 배경 위치 정렬
/// 절차:
/// 1) 데이터/컨트롤 연결 및 이름 표시
/// 2) 자식 UI 생성
/// 3) 데이터/선택 변경 이벤트 구독
/// 4) 버튼(onClick) 이벤트 연결
/// 5) 선택 UI 반영 및 선택 배경 정렬
/// 6) 드래그 핸들러 연결
///
/// 매개변수:
/// - data: 표시할 데이터
/// - treeList: 부모 TreeList (선택 관리, 클릭 처리 등)
///
/// 사용 예:
/// var item = Instantiate(prefab);
/// item.Init(treeData, treeList);
/// - data: 표시할 데이터
/// - control: 상위 TreeList
/// - dragDropManager: 드래그 & 드롭 매니저
/// </summary>
public void Init(TreeListItemData data, TreeList control, TreeListDragDropManager dragDropManager)
{
@@ -248,13 +127,13 @@ namespace UVC.UI.List.Tree
if (data.Children.Count > 0)
{
{
// 각 자식 데이터에 대해 UI 생성
foreach (var childData in data.Children)
{
CreateItem(childData); // 재귀적으로 트리 구조 생성
}
}
// 화살표 방향 설정 (초기에는 펼쳐짐)
SetExpand();
@@ -299,20 +178,12 @@ namespace UVC.UI.List.Tree
#region 데이터 변경 처리 (Data Change Handlers)
/// <summary>
/// 데이터가 변경되었을 때 호출되는 메서드입니다.
/// 데이터 변경에 반응하여 UI를 갱신합니다.
///
/// 호출되는 경우:
/// 1. data.Name이 변경됨
/// 2. data.Children이 추가/제거됨
/// 3. data.IsExpanded가 변경됨
///
/// 역할:
/// - 화면에 표시된 내용과 데이터를 동기화
/// - 필요한 UI 컴포넌트 업데이트
///
/// 데이터 바인딩이란?
/// 데이터가 변경되면 UI가 자동으로 업데이트되는 패턴입니다.
/// 이렇게 하면 데이터와 UI를 동기화 유지하기 쉽습니다.
/// 매개변수:
/// - changedType: 변경 종류(이름/확장/자식 추가 등)
/// - changedData: 변경 대상 데이터(자식 추가 등일 때 유효)
/// - index: 삽입/이동 시 기준 인덱스(해당되는 경우)
/// </summary>
private void OnDataChanged(ChangedType changedType, TreeListItemData changedData, int index)
{
@@ -328,7 +199,7 @@ namespace UVC.UI.List.Tree
if (changedType == ChangedType.Name)
{
{
// 이름이 변경된 경우
if (valueText.text != data.Name)
{
@@ -356,34 +227,16 @@ namespace UVC.UI.List.Tree
}
else if (changedType == ChangedType.AddChild)
{
TreeListItem? item = treeList.AllItemFlattened.FirstOrDefault(x => x.Data == changedData);
if (item != null)
{
item.transform.SetParent(childRoot);
item.SetExpand();
}
else
{
CreateItem(changedData);
}
CreateItem(changedData);
UniTask.DelayFrame(1).ContinueWith(() =>
{
if (item != null) item.transform.SetAsLastSibling();
treeList.UpdateFlattenedItemDataList();
});
}
else if (changedType == ChangedType.AddAtChild)
{
TreeListItem? item = treeList.AllItemFlattened.FirstOrDefault(x => x.Data == changedData);
if (item != null)
{
item.transform.SetParent(childRoot);
item.SetExpand();
}
else
{
item = CreateItem(changedData);
}
TreeListItem item = CreateItem(changedData);
UniTask.DelayFrame(1).ContinueWith(() =>
{
@@ -391,28 +244,68 @@ namespace UVC.UI.List.Tree
treeList.UpdateFlattenedItemDataList();
});
}
else if (changedType == ChangedType.RemoveChild)
{
var childItem = childRoot.GetChild(index).GetComponent<TreeListItem>();
if (childItem != null)
else if (changedType == ChangedType.AddCloneChild)
{
//데이터 복사
TreeListItemData clone = changedData.Clone();
//changedData 부모에게 알림 - UI 갱신 용
if (changedData.Parent != null)
{
childItem.Delete(false);
UniTask.DelayFrame(1).ContinueWith(() =>
{
treeList.UpdateFlattenedItemDataList();
});
changedData.Parent.RemoveChild(changedData);
}
else
{
treeList.RemoveItem(changedData);
}
// TreeListItem 제거
TreeListItem? item = treeList.AllItemFlattened.FirstOrDefault(x => x.Data == changedData);
if (item != null) item.Delete(true);
data.AddChild(clone);
}
else if (changedType == ChangedType.AddCloneAtChild)
{
//데이터 복사
TreeListItemData clone = changedData.Clone();
//changedData 부모에게 알림
if (changedData.Parent != null)
{
changedData.Parent.RemoveChild(changedData);
}
else
{
treeList.RemoveItem(changedData);
}
// TreeListItem 제거
TreeListItem? item = treeList.AllItemFlattened.FirstOrDefault(x => x.Data == changedData);
if (item != null) item.Delete(true);
data.AddChildAt(clone, index);
}
else if (changedType == ChangedType.SwapChild)
{
UniTask.DelayFrame(1).ContinueWith(() =>
{
TreeListItem? item = treeList.AllItemFlattened.FirstOrDefault(x => x.Data == changedData);
if (item != null) item.transform.SetSiblingIndex(index);
treeList.UpdateFlattenedItemDataList();
});
}
else if (changedType == ChangedType.RemoveChild)
{
//따로 할것 없음 - 펼침 버튼 갱신 용
Debug.Log($"RemoveChild 처리 완료 {changedData.Name}, {index}");
}
// 5️. 펼침 버튼 표시 여부 결정
childExpand.gameObject.SetActive(data.Children.Count > 0);
// 확장 상태 변경 않함
//if (data.Children.Count > 0 && !childContainer.activeSelf)
//{
// childContainer.SetActive(true);
// SetExpand();
//}
UniTask.DelayFrame(1).ContinueWith(() =>
{
// 5️. 펼침 버튼 표시 여부 결정
childExpand.gameObject.SetActive(data.Children.Count > 0);
});
}
#endregion
@@ -420,17 +313,11 @@ namespace UVC.UI.List.Tree
#region 선택 상태 관리 (Selection Management)
/// <summary>
/// 아이템의 선택 상태가 변경되었을 때 호출됩니다.
///
/// 호출 시기:
/// - data.IsSelected = true/false 일 때
///
/// 동작:
/// - UpdateSelectionUI() 호출해서 화면 업데이트
/// 선택 상태 변경에 반응하여 UI를 갱신합니다.
///
/// 매개변수:
/// - changedData: 변경된 데이터 (이 경우 항상 this.data와 같음)
/// - isSelected: 새로운 선택 상태 (true = 선택됨, false = 해제됨)
/// - changedData: 변경된 데이터(자기 자신)
/// - isSelected: 선택 여부
/// </summary>
private void OnSelectionChanged(TreeListItemData changedData, bool isSelected)
{
@@ -439,18 +326,7 @@ namespace UVC.UI.List.Tree
}
/// <summary>
/// 선택 상태에 따라 UI를 업데이트합니다.
///
/// 동작:
/// - data.IsSelected = true → selectedBg 표시 (배경 보이기)
/// - data.IsSelected = false → selectedBg 숨김 (배경 숨기기)
///
/// 예시:
/// data.IsSelected = true
/// ↓
/// selectedBg.gameObject.SetActive(true)
/// ↓
/// 화면에 파란 배경이 나타남
/// 선택 상태에 따라 배경 표시/숨김을 갱신합니다.
/// </summary>
private void UpdateSelectionUI()
{
@@ -464,25 +340,7 @@ namespace UVC.UI.List.Tree
#region 위치 정렬 (Position Alignment)
/// <summary>
/// 모든 선택 배경(selectedBg)의 왼쪽 위치를 정렬합니다.
///
/// 목표:
/// 📌 폴더1
/// 📌├─ 파일1
/// 📌├─ 파일2
/// 📌└─ 폴더2
/// 📌├─ 파일3
///
/// 모든 선택 배경의 왼쪽이 📌 위치에서 시작하도록 합니다.
///
/// 이렇게 하는 이유:
/// - 깔끔한 UI 표현
/// - 다중 레벨 트리에서 시각적 일관성 유지
///
/// 좌표 변환:
/// - 월드 좌표(World Coordinate): 게임 전체에서의 절대 위치
/// - 로컬 좌표(Local Coordinate): 부모 기준 상대 위치
/// - TransformPoint: 로컬 좌표를 월드 좌표로 변환
/// 모든 레벨에서 선택 배경의 왼쪽 정렬을 루트와 맞춥니다.
/// </summary>
private void AlignSelectedBgToRoot()
{
@@ -523,25 +381,10 @@ namespace UVC.UI.List.Tree
#region 계층 구조 탐색 (Hierarchy Navigation)
/// <summary>
/// 최상위 부모(루트)의 TreeListItem을 찾습니다.
/// 현재 아이템의 루트 TreeListItem을 반환합니다.
///
/// 트리 구조:
/// TreeListItem1 (루트)
/// ├─ TreeListItem2 (부모)
/// │ └─ TreeListItem3 (자식 ← 이 메서드를 호출하면)
/// └─ TreeListItem4
///
/// 반환값: TreeListItem1
///
/// 동작:
/// 1. 현재 객체의 부모 확인
/// 2. 부모가 TreeListItem을 가지는지 확인
/// 3. 가지면 그 부모의 GetRootTreeListItem() 재귀 호출
/// 4. 루트에 도달할 때까지 반복
///
/// 재귀(Recursion)란?
/// 함수가 자기 자신을 호출하는 것입니다.
/// 계층 구조를 탐색하는 데 효과적입니다.
/// 반환:
/// - 루트 TreeListItem, 없으면 null
/// </summary>
private TreeListItem? GetRootTreeListItem()
{
@@ -580,35 +423,18 @@ namespace UVC.UI.List.Tree
#region 입력 처리 (Input Handling)
/// <summary>
/// 아이템을 클릭했을 때 호출됩니다.
/// 아이템 클릭 시 호출됩니다.
///
/// 호출 시점:
/// - itemButton.onClick 이벤트 발생 시
/// = 사용자가 이 아이템을 마우스로 클릭했을 때
///
/// 처리 순서:
/// 1. 데이터의 OnClickAction 실행 (있으면)
/// 2. Ctrl, Shift 키 상태 감지
/// 3. TreeList에 클릭 정보 전달 (다중 선택 로직)
///
/// 키 입력:
/// - Ctrl 클릭: 현재 선택을 유지하면서 이 아이템 토글 (다중 선택)
/// - Shift 클릭: 마지막 선택부터 이 아이템까지 범위 선택
/// - 일반 클릭: 이 아이템만 선택
///
/// 파일 탐색기와 동일한 동작:
/// Windows 탐색기를 생각하면 쉽습니다.
/// - 클릭: 한 파일만 선택
/// - Ctrl+클릭: 여러 파일 선택 (기존 선택 유지)
/// - Shift+클릭: 범위 선택
/// 동작:
/// - 등록된 OnClickAction 실행(있으면)
/// - Ctrl/Shift 상태를 읽어 TreeList에 전달
/// (일반/토글/범위 선택)
/// </summary>
private void OnItemClicked()
{
if (data == null) return;
// 1️. 데이터에 등록된 클릭 액션 실행 (있으면)
// ?. 연산자: null이면 실행 안 함
// 예: 펼침/접힘 버튼 클릭 시 자동으로 호출되는 액션
data.OnClickAction?.Invoke(data);
// 2️. Ctrl 키 상태 감지
@@ -629,20 +455,8 @@ namespace UVC.UI.List.Tree
#region 펼침/접힘 (Expand/Collapse)
/// <summary>
/// 자식 아이템의 펼침/접힘을 토글합니다. (펼쳐있으면 접고, 접혀있으면 펼침)
///
/// 호출 시점:
/// - childExpand 버튼을 클릭했을 때
///
/// 동작:
/// 1. 애니메이션이 진행 중이면 무시 (중복 클릭 방지)
/// 2. data.IsExpanded 토글 (true ↔ false)
/// 3. childContainer 활성화/비활성화
/// 4. 0.3초에 걸쳐 화살표 회전 애니메이션 실행
///
/// UI 피드백:
/// 애니메이션이 있으면 사용자가 반응을 확인할 수 있습니다.
/// 즉시 완료되는 것보다 더 자연스럽고 좋은 경험입니다.
/// 자식의 펼침/접힘을 토글합니다.
/// (중복 입력은 애니메이션 종료까지 무시)
/// </summary>
public void ToggleChild()
{
@@ -659,26 +473,9 @@ namespace UVC.UI.List.Tree
}
/// <summary>
/// 펼침/접힘 화살표의 회전 애니메이션을 실행합니다.
///
/// 파라미터:
/// - duration: 애니메이션 지속 시간 (초)
/// 기본값 0.0 = 즉시 완료 (애니메이션 없음)
/// 0.3 = 0.3초에 걸쳐 회전
///
/// 동작:
/// - 펼쳐짐 (IsExpanded=true): 화살표를 0도로 회전 (▼ 모양)
/// - 접혀짐 (IsExpanded=false): 화살표를 90도로 회전 (▶ 모양)
/// - 애니메이션 완료 후 isAnimating 플래그 리셋
///
/// DORotate란? (Tweening 라이브러리)
/// 부드럽게 회전하는 애니메이션을 쉽게 만들어줍니다.
/// duration 시간에 걸쳐 지정된 각도까지 회전합니다.
///
/// OnComplete란?
/// 애니메이션이 완료되면 호출되는 콜백입니다.
/// 람다 식(=>)으로 익명 함수를 정의합니다.
/// 펼침/접힘 화살표 회전과 컨테이너 표시를 갱신합니다.
/// </summary>
/// <param name="duration">회전 애니메이션 시간(초). 0이면 즉시 적용.</param>
internal void SetExpand(float duration = 0.0f)
{
@@ -695,6 +492,7 @@ namespace UVC.UI.List.Tree
// 4️. 애니메이션이 완료되면 플래그 리셋
// 이제 다시 ToggleChild() 호출 가능
isAnimating = false;
LayoutRebuilder.ForceRebuildLayoutImmediate(transform as RectTransform);
});
}
@@ -703,24 +501,9 @@ namespace UVC.UI.List.Tree
#region 자식 관리 (Child Management)
/// <summary>
/// 새로운 자식 아이템을 추가합니다.
///
/// 호출 시점:
/// - 프로그램이 런타임에 새 자식을 추가할 때
/// - 예: 폴더에 파일을 추가했을 때
///
/// 동작:
/// 1. 새 자식 UI 생성 (CreateItem)
/// 2. 자식 컨테이너 활성화
/// 3. 펼침 애니메이션 (자동으로 펼침)
///
/// 매개변수:
/// - data: 추가할 자식 데이터
///
/// 사용 예:
/// treeItem.AddChild(newChildData);
/// // → 새 자식이 자동으로 UI에 추가되고 펼쳐짐
/// 새로운 자식 아이템을 추가하고 UI를 갱신합니다.
/// </summary>
/// <param name="data">추가할 자식 데이터</param>
public void AddChild(TreeListItemData data)
{
// 1️. 새 자식 UI 생성
@@ -735,32 +518,10 @@ namespace UVC.UI.List.Tree
}
/// <summary>
/// 자식 데이터를 받아 UI TreeListItem으로 생성합니다.
///
/// 호출 시점:
/// - Init()에서 기존 자식들을 UI로 생성할 때
/// - OnDataChanged()에서 추가된 자식을 UI로 생성할 때
/// - AddChild()에서 새 자식을 추가할 때
///
/// 동작:
/// 1. treeList.ItemPrefab를 childRoot 아래에 인스턴스화
/// 2. 생성된 item의 Init() 메서드 호출
/// 3. 생성된 item 반환
///
/// Instantiate란?
/// 프리팹(템플릿)을 복제해서 새로운 객체를 만드는 함수입니다.
/// Instantiate(프리팹, 부모, 복제)
///
/// 매개변수:
/// - data: 생성할 아이템의 데이터
///
/// 반환값:
/// - 생성된 TreeListItem 컴포넌트
///
/// 재귀 구조:
/// CreateItem은 계속 자식을 생성하므로
/// 깊이 있는 트리 구조를 만들 수 있습니다.
/// 자식 데이터를 받아 UI TreeListItem을 생성합니다.
/// </summary>
/// <param name="data">생성할 아이템 데이터</param>
/// <returns>생성된 TreeListItem</returns>
protected TreeListItem CreateItem(TreeListItemData data)
{
// 1️. 프리팹을 복제해서 새로운 TreeListItem 생성
@@ -784,27 +545,9 @@ namespace UVC.UI.List.Tree
#region 제거 (Deletion)
/// <summary>
/// 이 TreeListItem과 관련된 모든 리소스를 정리하고 삭제합니다.
///
/// 호출 시점:
/// - 트리에서 아이템을 제거하고 싶을 때
/// - 프로그램이 명시적으로 아이템을 삭제할 때
///
/// 정리 작업:
/// 1. 데이터 변경 이벤트 구독 해제
/// 2. 버튼 클릭 이벤트 구독 해제
/// 3. GameObject 삭제
///
/// 왜 구독을 해제하나?
/// - 이벤트를 구독하는 것은 메모리 연결을 만듭니다.
/// - 해제하지 않으면 메모리 누수가 발생할 수 있습니다.
/// - 따라서 삭제 전에 반드시 해제해야 합니다.
///
/// 메모리 누수란?
/// 불필요한 메모리가 해제되지 않고 계속 사용되는 문제입니다.
/// 게임이 계속 실행되면서 메모리 사용량이 증가해서
/// 결국 게임이 느려지거나 충돌할 수 있습니다.
/// 이벤트 구독 해제, 애니메이션 중지 후 GameObject를 삭제합니다.
/// </summary>
/// <param name="deleteData">데이터도 삭제할지 여부</param>
public void Delete(bool deleteData = false)
{
// 1️. 데이터 변경 이벤트 구독 해제
@@ -813,8 +556,7 @@ namespace UVC.UI.List.Tree
// -= 연산자: 이벤트에서 리스너 제거
data.OnDataChanged -= OnDataChanged;
data.OnSelectionChanged -= OnSelectionChanged;
data.Parent = null;
if(deleteData) data.Dispose();
data.Dispose();
data = null;
}
@@ -835,22 +577,7 @@ namespace UVC.UI.List.Tree
}
/// <summary>
/// GameObject가 파괴될 때 자동으로 호출되는 Unity 메서드입니다.
///
/// 호출 시점:
/// - Destroy(gameObject) 호출 후 실제 삭제되기 직전
/// - 게임이 종료될 때
/// - 씬이 언로드될 때
///
/// 용도:
/// - 정리 작업 (Clean-up)
/// - 리소스 해제
/// - 이벤트 구독 해제
///
/// Delete()와의 차이:
/// - Delete(): 명시적으로 호출하는 메서드
/// - OnDestroy(): Unity에서 자동으로 호출하는 메서드
/// - 둘 다 같은 정리 작업을 합니다 (중복 방지)
/// Unity 파괴 시점에 정리합니다. (중복 정리 방지)
/// </summary>
private void OnDestroy()
{
@@ -859,7 +586,6 @@ namespace UVC.UI.List.Tree
{
data.OnDataChanged -= OnDataChanged;
data.OnSelectionChanged -= OnSelectionChanged;
data.Parent = null;
data.Dispose();
data = null;
}