446 lines
15 KiB
C#
446 lines
15 KiB
C#
#nullable enable
|
|
using Gpm.Ui;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace UVC.UI.List.Tree
|
|
{
|
|
/// <summary>
|
|
/// 트리 리스트 아이템의 데이터 모델.
|
|
///
|
|
/// 목적:
|
|
/// - 이름/옵션/선택/펼침 상태 및 계층(부모-자식) 보유
|
|
/// - 상태 변경 시 UI에 알릴 이벤트 제공(데이터 변경/선택 변경)
|
|
/// - 자식 추가/삽입/복제/재배치/초기화 등 계층 편집 기능
|
|
///
|
|
/// 이벤트 설계:
|
|
/// - OnDataChanged(ChangedType type, TreeListItemData changed, int index):
|
|
/// 데이터/구조 변경 통지. changed는 변동 주체(보통 this 또는 대상 자식),
|
|
/// index는 삽입/이동 시 사용(해당 없으면 -1).
|
|
/// - OnSelectionChanged(TreeListItemData data, bool isSelected):
|
|
/// 선택 상태 변경 통지(선택 UI/로직 처리용).
|
|
///
|
|
/// 동등성/해시:
|
|
/// - 이름(Name) 기반 비교/해시 코드. 이름이 같으면 같은 개체로 간주(대소문자 구분).
|
|
/// - 해시/Equals가 이름에 의존하므로 Name 변경 시 컬렉션 키로 사용 중이면 주의.
|
|
///
|
|
/// 주의사항:
|
|
/// - ClearChildren은 각 자식에 Dispose를 호출하여 이벤트/내부 상태를 정리한 뒤
|
|
/// 리스트를 비웁니다(연결만 끊는 수준을 넘어 자식도 정리됨).
|
|
/// - AddClone계열은 전달된 원본 child를 Dispose한 뒤 복제본을 추가합니다(파괴적).
|
|
/// </summary>
|
|
public class TreeListItemData : IDisposable
|
|
{
|
|
#region 이벤트 (Events)
|
|
|
|
/// <summary>
|
|
/// 데이터/구조 변경 통지 이벤트.
|
|
/// 시그니처: (ChangedType type, TreeListItemData changed, int index)
|
|
/// - type: 변경 종류
|
|
/// - changed: 변경 대상(보통 this 또는 특정 자식)
|
|
/// - index: 위치 관련 변경 시 사용(해당 없으면 -1)
|
|
/// </summary>
|
|
public Action<ChangedType, TreeListItemData, int>? OnDataChanged;
|
|
|
|
/// <summary>
|
|
/// 선택 상태 변경 통지 이벤트.
|
|
/// 시그니처: (TreeListItemData data, bool isSelected)
|
|
/// </summary>
|
|
public Action<TreeListItemData, bool>? OnSelectionChanged;
|
|
|
|
/// <summary>
|
|
/// 아이템 클릭 시 실행할 사용자 정의 동작.
|
|
/// (예: 속성 패널 열기, 포커스 이동 등. 확장/축소와는 별개)
|
|
/// </summary>
|
|
public Action<TreeListItemData>? OnClickAction;
|
|
|
|
#endregion
|
|
|
|
#region 내부 필드 (Private Fields)
|
|
|
|
/// <summary>고유 식별자(Id).</summary>
|
|
private readonly Guid _id = Guid.NewGuid();
|
|
|
|
/// <summary>아이템 이름.</summary>
|
|
private string _name = string.Empty;
|
|
|
|
/// <summary>추가 옵션 문자열.</summary>
|
|
private string _option = string.Empty;
|
|
|
|
/// <summary>자식 펼침 여부.</summary>
|
|
private bool _isExpanded = false;
|
|
|
|
/// <summary>선택 여부.</summary>
|
|
private bool _isSelected = false;
|
|
|
|
/// <summary>부모</summary>
|
|
private TreeListItemData? _parent;
|
|
|
|
/// <summary>자식 리스트.</summary>
|
|
private List<TreeListItemData> _children = new List<TreeListItemData>();
|
|
|
|
#endregion
|
|
|
|
#region 공개 프로퍼티 (Public Properties)
|
|
|
|
/// <summary>
|
|
/// 아이템 이름.
|
|
/// 변경 시 OnDataChanged(Name) 발생.
|
|
/// </summary>
|
|
public string Name
|
|
{
|
|
get => _name;
|
|
set
|
|
{
|
|
if (_name != value)
|
|
{
|
|
_name = value;
|
|
NotifyDataChanged(ChangedType.Name); // UI에 변경을 알림
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 옵션 문자열.
|
|
/// 변경 시 OnDataChanged(Option) 발생.
|
|
/// </summary>
|
|
public string Option
|
|
{
|
|
get => _option;
|
|
set
|
|
{
|
|
if (_option != value)
|
|
{
|
|
_option = value;
|
|
NotifyDataChanged(ChangedType.Option);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 펼침 상태(같은 어셈블리 내 전용).
|
|
/// 변경 시 OnDataChanged(Expanded) 발생.
|
|
/// </summary>
|
|
internal bool IsExpanded
|
|
{
|
|
get => _isExpanded;
|
|
set
|
|
{
|
|
if (_isExpanded != value)
|
|
{
|
|
_isExpanded = value;
|
|
NotifyDataChanged(ChangedType.Expanded); // 트리 구조 UI 갱신
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 선택 상태.
|
|
/// 변경 시 OnSelectionChanged 발생.
|
|
/// </summary>
|
|
public bool IsSelected
|
|
{
|
|
get => _isSelected;
|
|
set
|
|
{
|
|
if (_isSelected != value)
|
|
{
|
|
_isSelected = value;
|
|
// OnSelectionChanged 이벤트 발생
|
|
// 예: "폴더가 선택되었습니다" 같은 처리를 수행
|
|
OnSelectionChanged?.Invoke(this, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>부모 데이터(내부 전용).</summary>
|
|
internal TreeListItemData? Parent
|
|
{
|
|
get => _parent;
|
|
set => _parent = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 자식 컬렉션(내부 전용).
|
|
/// set 시 null을 빈 리스트로 대체하고 OnDataChanged(ResetChildren) 발생.
|
|
/// </summary>
|
|
internal List<TreeListItemData> Children
|
|
{
|
|
get => _children;
|
|
set
|
|
{
|
|
_children = value ?? new List<TreeListItemData>();
|
|
NotifyDataChanged(ChangedType.ResetChildren);
|
|
}
|
|
}
|
|
|
|
/// <summary>고유 식별자(Id).</summary>
|
|
public Guid Id => _id;
|
|
|
|
#endregion
|
|
|
|
#region 생성자 (Constructors)
|
|
|
|
/// <summary>
|
|
/// 기본 생성자.
|
|
/// 초기값: Name="", Option="", IsExpanded=false, IsSelected=false, Children=[]
|
|
/// </summary>
|
|
public TreeListItemData()
|
|
{
|
|
_name = string.Empty;
|
|
_option = string.Empty;
|
|
_isExpanded = false;
|
|
_isSelected = false;
|
|
_children = new List<TreeListItemData>();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 이름과 초기 자식으로 생성합니다.
|
|
/// </summary>
|
|
/// <param name="generalName">아이템 이름(필수).</param>
|
|
/// <param name="childrenItemData">초기 자식 목록(null 허용).</param>
|
|
public TreeListItemData(string generalName, List<TreeListItemData>? childrenItemData = null)
|
|
{
|
|
_name = generalName;
|
|
_option = string.Empty;
|
|
_isExpanded = false;
|
|
_children = childrenItemData ?? new List<TreeListItemData>();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 자식 관리 메서드 (Child Management Methods)
|
|
|
|
/// <summary>
|
|
/// 자식을 끝에 추가합니다.
|
|
/// </summary>
|
|
/// <param name="child">추가할 자식.</param>
|
|
public void AddChild(TreeListItemData child)
|
|
{
|
|
child.Parent = this;
|
|
_children.Add(child);
|
|
NotifyDataChanged(ChangedType.AddChild, child); // UI에 트리 구조 변경 알림
|
|
}
|
|
|
|
/// <summary>
|
|
/// 자식을 지정 인덱스에 삽입합니다.
|
|
/// </summary>
|
|
/// <param name="child">삽입할 자식.</param>
|
|
/// <param name="index">삽입 인덱스(0 기반).</param>
|
|
public void AddChildAt(TreeListItemData child, int index)
|
|
{
|
|
child._parent = this;
|
|
_children.Insert(index, child);
|
|
NotifyDataChanged(ChangedType.AddAtChild, child, index); // UI에 트리 구조 변경 알림
|
|
}
|
|
|
|
/// <summary>
|
|
/// 전달된 자식을 복제하여 추가합니다.
|
|
/// 주의: 원본 child는 Dispose됩니다(파괴적).
|
|
/// </summary>
|
|
/// <param name="child">복제 및 대체할 원본 자식.</param>
|
|
public void AddCloneChild(TreeListItemData child)
|
|
{
|
|
NotifyDataChanged(ChangedType.AddCloneChild, child); // UI에 트리 구조 변경 알림
|
|
}
|
|
|
|
/// <summary>
|
|
/// 전달된 자식을 복제하여 지정 인덱스에 삽입합니다.
|
|
/// 주의: 원본 child는 Dispose됩니다(파괴적).
|
|
/// </summary>
|
|
/// <param name="child">복제 및 대체할 원본 자식.</param>
|
|
/// <param name="index">삽입 인덱스(0 기반).</param>
|
|
public void AddCloneAtChild(TreeListItemData child, int index)
|
|
{
|
|
NotifyDataChanged(ChangedType.AddCloneAtChild, child, index); // UI에 트리 구조 변경 알림
|
|
}
|
|
|
|
/// <summary>
|
|
/// 지정 자식을 지정 인덱스 위치에 삽입합니다.
|
|
/// 주의: 기존 위치에서 제거하지 않으므로 "이동"이 아닌 "삽입" 동작입니다.
|
|
/// (호출 측에서 기존 위치 정리는 별도로 해야 합니다)
|
|
/// </summary>
|
|
/// <param name="child">삽입할 기존 자식 참조.</param>
|
|
/// <param name="index">삽입 인덱스(0 기반).</param>
|
|
public void SwapChild(TreeListItemData child, int index)
|
|
{
|
|
_children.Insert(index, child);
|
|
NotifyDataChanged(ChangedType.SwapChild, child, index); // UI에 트리 구조 변경 알림
|
|
}
|
|
|
|
public void RemoveChild(TreeListItemData child)
|
|
{
|
|
if (_children.Remove(child))
|
|
{
|
|
child._parent = null;
|
|
NotifyDataChanged(ChangedType.RemoveChild, child); // UI에 트리 구조 변경 알림
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 모든 자식을 제거하고 정리합니다.
|
|
/// 각 자식에 대해 Parent=null 및 Dispose()를 호출한 뒤 리스트를 비웁니다.
|
|
/// </summary>
|
|
public void ClearChildren()
|
|
{
|
|
foreach (var child in _children)
|
|
{
|
|
child._parent = null;
|
|
child.Dispose();
|
|
}
|
|
_children.Clear();
|
|
NotifyDataChanged(ChangedType.ResetChildren); // UI에 트리 구조 변경 알림
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 내부 메서드 (Internal Methods)
|
|
|
|
/// <summary>
|
|
/// 변경을 구독자에게 알립니다.
|
|
/// </summary>
|
|
/// <param name="changedType">변경 종류.</param>
|
|
/// <param name="target">변경 대상(null이면 this).</param>
|
|
/// <param name="index">위치 관련 인덱스(없으면 -1).</param>
|
|
internal void NotifyDataChanged(ChangedType changedType, TreeListItemData? target = null, int index = -1)
|
|
{
|
|
// OnDataChanged가 등록되어 있으면 실행
|
|
// ?. 연산자: null이면 실행하지 않음 (null reference exception 방지)
|
|
OnDataChanged?.Invoke(changedType, (target == null ? this : target), index);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 비교 연산자 (Comparison Operators)
|
|
|
|
/// <summary>
|
|
/// 이름(대소문자 구분, Ordinal) 기반 동등 비교.
|
|
/// </summary>
|
|
public static bool operator ==(TreeListItemData? left, TreeListItemData? right)
|
|
{
|
|
// 같은 객체인지 확인 (메모리 주소 비교)
|
|
if (ReferenceEquals(left, right))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// 하나 이상이 null이면 false (ReferenceEquals에서 둘 다 null인 경우는 true 반환)
|
|
if (left is null || right is null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// 고유 식별자(Id)로 비교
|
|
return left.Id == right.Id;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 이름 기반 비동등 비교.
|
|
/// </summary>
|
|
public static bool operator !=(TreeListItemData? left, TreeListItemData? right)
|
|
{
|
|
return !(left == right);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 객체 메서드 (Object Methods)
|
|
|
|
/// <summary>
|
|
/// 이름 기반 해시 코드 반환.
|
|
/// </summary>
|
|
public override int GetHashCode()
|
|
{
|
|
return Id.GetHashCode();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 이름 기반 동등성 비교(== 사용).
|
|
/// </summary>
|
|
/// <param name="obj">비교 대상.</param>
|
|
public override bool Equals(object? obj)
|
|
{
|
|
// obj가 TreeListItemData 타입인지 확인
|
|
if (obj is TreeListItemData other)
|
|
{
|
|
// TreeListItemData면 == 연산자로 비교
|
|
return this == other;
|
|
}
|
|
|
|
// 다른 타입이면 false
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 이벤트/참조/자식 컬렉션을 정리합니다.
|
|
/// - Parent=null, 이벤트 핸들러 해제, Children.Clear()
|
|
/// - 하위 항목을 재귀적으로 Dispose하지는 않습니다
|
|
/// (재귀 정리는 ClearChildren에서 수행).
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
if (_parent != null && _parent.Children.Contains(this)) _parent.Children.Remove(this);
|
|
_parent = null;
|
|
if (OnDataChanged != null) OnDataChanged = null;
|
|
if (OnSelectionChanged != null) OnSelectionChanged = null;
|
|
if (OnClickAction != null) OnClickAction = null;
|
|
if (Children != null)
|
|
{
|
|
Children.Clear();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 깊은 복제본을 생성합니다(자식까지 재귀 복제).
|
|
/// </summary>
|
|
/// <returns>복제된 새 인스턴스.</returns>
|
|
public TreeListItemData CloneWithChild()
|
|
{
|
|
TreeListItemData clone = new TreeListItemData();
|
|
clone.Name = this.Name;
|
|
clone.Option = this.Option;
|
|
clone.IsExpanded = this.IsExpanded;
|
|
clone.IsSelected = this.IsSelected;
|
|
foreach (var child in this.Children)
|
|
{
|
|
clone.AddChild(child.CloneWithChild());
|
|
}
|
|
return clone;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 현재 인스턴스의 복사본인 <see cref="TreeListItemData"/>의 새 인스턴스를 생성합니다.
|
|
/// </summary>
|
|
/// <returns>현재 인스턴스와 동일한 속성 값을 가진 새 <see cref="TreeListItemData"/> 객체를 생성합니다.</returns>
|
|
public TreeListItemData Clone()
|
|
{
|
|
TreeListItemData clone = new TreeListItemData();
|
|
clone.Name = this.Name;
|
|
clone.Option = this.Option;
|
|
clone.IsExpanded = this.IsExpanded;
|
|
clone.IsSelected = this.IsSelected;
|
|
return clone;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// 데이터 변경 종류 열거형.
|
|
/// </summary>
|
|
public enum ChangedType
|
|
{
|
|
Name,
|
|
Option,
|
|
Expanded,
|
|
ResetChildren,
|
|
AddChild,
|
|
RemoveChild,
|
|
AddAtChild,
|
|
AddCloneChild,
|
|
AddCloneAtChild,
|
|
SwapChild,
|
|
}
|
|
} |