ChildView.cpp


// ChildView.cpp: CChildView 클래스의 구현
//

#include "pch.h"
#include "framework.h"
#include "22010189황재희.h"
#include "ChildView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CChildView

CChildView::CChildView()
{
	shape_mode = 0; // 도형 선택 모드 초기화
	m_isMovingShapes = false;
}

CChildView::~CChildView()
{
	// 동적 할당된 도형들의 메모리 해제
	for (CMyShape* pShape : p_shapes) {
		delete pShape;
	}
	p_shapes.clear();
}


BEGIN_MESSAGE_MAP(CChildView, CWnd)
	ON_WM_PAINT()
	ON_WM_LBUTTONDOWN()
	ON_WM_MOUSEMOVE()
	ON_WM_ERASEBKGND()
	ON_UPDATE_COMMAND_UI(ID_DRAW_RECTANGLE, &CChildView::OnUpdateShapeRect)
	ON_UPDATE_COMMAND_UI(ID_DRAW_CIRCLE, &CChildView::OnUpdateShapeCircle)
	ON_UPDATE_COMMAND_UI(ID_DRAW_CURVE, &CChildView::OnUpdateShapeCurve)
	ON_UPDATE_COMMAND_UI(ID_DRAW_STAR, &CChildView::OnUpdateShapeStar)
	ON_COMMAND(ID_DRAW_RECTANGLE, &CChildView::OnDrawRectangle)
	ON_COMMAND(ID_DRAW_CIRCLE, &CChildView::OnDrawCircle)
	ON_COMMAND(ID_DRAW_CURVE, &CChildView::OnDrawCurve)
	ON_COMMAND(ID_DRAW_STAR, &CChildView::OnDrawStar)
	ON_WM_CONTEXTMENU()
	ON_COMMAND(ID_ACTION_SELECT, &CChildView::OnActionSelect)
	ON_UPDATE_COMMAND_UI(ID_ACTION_SELECT, &CChildView::OnUpdateActionSelect)
	ON_WM_LBUTTONUP()
	ON_WM_KEYDOWN()
	ON_COMMAND(ID_ACTION_GROUP, &CChildView::OnActionGroup)
	ON_COMMAND(ID_ACTION_UNGROUP, &CChildView::OnActionUngroup)
	ON_UPDATE_COMMAND_UI(ID_ACTION_GROUP, &CChildView::OnUpdateActionGroup)
	ON_UPDATE_COMMAND_UI(ID_ACTION_UNGROUP, &CChildView::OnUpdateActionUngroup)
	ON_COMMAND(ID_ALIGN_BRINGFRONT, &CChildView::OnAlignBringfront)
	ON_COMMAND(ID_ALIGN_BRINGBACK, &CChildView::OnAlignBringback)
END_MESSAGE_MAP()



// CChildView 메시지 처리기

BOOL CChildView::PreCreateWindow(CREATESTRUCT& cs) 
{
	if (!CWnd::PreCreateWindow(cs))
		return FALSE;

	cs.dwExStyle |= WS_EX_CLIENTEDGE;
	cs.style &= ~WS_BORDER;
	cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS, 
		::LoadCursor(nullptr, IDC_ARROW), reinterpret_cast<HBRUSH>(COLOR_WINDOW+1), nullptr);

	return TRUE;
}

void CChildView::OnPaint()
{
	CPaintDC dc(this); // 그리기를 위한 디바이스 컨텍스트입니다.

	// TODO: 여기에 메시지 처리기 코드를 추가합니다.

	CRect clientRect;
	GetClientRect(clientRect);
	int w = clientRect.Width();
	int h = clientRect.Height();

	// 1. 메모리 DC와 비트맵 생성
	CDC memDC;
	memDC.CreateCompatibleDC(&dc); // 화면 DC와 호환되는 메모리 DC 생성
	CBitmap memBMP;
	memBMP.CreateCompatibleBitmap(&dc, w, h);
	/*
	memDC.SelectObject(memBMP);
	memDC.Rectangle(0, 0, w, h);
	*/
	CBitmap* pOldBmp = memDC.SelectObject(&memBMP); // 이전 비트맵 저장
	// 배경을 흰색으로 채우기
	memDC.FillSolidRect(0, 0, w, h, RGB(255, 255, 255));


	// 2. 그려져있던 최종 도형들을 메모리 DC에 그립니다.
	for (CMyShape* pShape : p_shapes) {
		if (pShape != nullptr) {
			pShape->draw(memDC); // <-- 화면 DC(dc) 대신 메모리 DC(memDC)에 그립니다.
		}
	}
	if (shape_mode == 4) {
		// 드래그 중인 선택 영역 표시
		if (m_isDragging) {
			CPen dragPen(PS_DOT, 1, RGB(128, 128, 128)); // 회색 점선으로 그려지게 하기
			memDC.SelectObject(dragPen);
			memDC.SelectStockObject(NULL_BRUSH);
			memDC.Rectangle(selectRect); // Draw the dragging rectangle
		}
		// 선택된 도형들 주위에 빨간색 점선 사각형 표시
		if (selected_Shapes.size() > 0) {
			CPen selectedPen(PS_DOT, 1, RGB(255, 0, 0));	//선택완료되면 빨간색
			memDC.SelectObject(selectedPen);
			memDC.SelectStockObject(NULL_BRUSH);

			for (CMyShape* s : selected_Shapes) {
				CRect box = s->getBoundingRect();
				box.InflateRect(5, 5);  // 바깥으로 여유를 줘서 감싸기
				memDC.Rectangle(box);
			}
		}
	}
	CString countShapes;
	CString selectedShapes;

	shape_cnt = p_shapes.size();
	shape_selected_cnt = selected_Shapes.size();

	countShapes.Format(_T("Number of Shapes: %d"), shape_cnt);
	selectedShapes.Format(_T("Number of Selected: %d"), shape_selected_cnt);

	memDC.TextOutW(10, 10, countShapes);
	memDC.TextOutW(10, 30, selectedShapes);
	// 3. 메모리 DC의 내용을 화면 DC로 고속 복사 (BitBlt)
	dc.BitBlt(0, 0, w, h, &memDC, 0, 0, SRCCOPY);

	// 메모리 해제
	memDC.SelectObject(pOldBmp);

	// 그리기 메시지에 대해서는 CWnd::OnPaint()를 호출하지 마십시오.
}
BOOL CChildView::OnEraseBkgnd(CDC* pDC)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	return TRUE;  // 배경 지우기를 했다고 거짓말
}
// 개별 도형을 클릭했을 때 해당 도형을 찾는 함수
CMyShape* CChildView::FindShapeAtPoint(CPoint point)
{
	// 역순으로 검사 (나중에 그린 도형이 위에 있으므로)
	for (int i = p_shapes.size() - 1; i >= 0; i--) {
		CRect boundingRect = p_shapes[i]->getBoundingRect();
		if (p_shapes[i]->isInPoint(point)) {
			return p_shapes[i];
		}
	}
	return nullptr;
}

void CChildView::OnLButtonDown(UINT nFlags, CPoint point)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	if (shape_mode == 0) {	//사각형 선택
		CMyRect* newRect = new CMyRect(point, point);	//동적할당으로 객체 CMyRect 생성
		p_shapes.push_back(newRect);	//p_shapes(모든 도형의 주소를 저장)에 추가하기
	}
	else if (shape_mode == 1) {	//원
		CMyCircle* newCircle = new CMyCircle(point, point);	//동적할당으로 객체 CMyCircle 생성
		p_shapes.push_back(newCircle);	//p_shapes(모든 도형의 주소를 저장)에 추가하기
	}
	else if (shape_mode == 2) {	//그림그리기
		CMyCurve* newCurve = new CMyCurve();	//동적할당으로 객체 CMyCircle 생성
		newCurve->m_ptList.push_back(point);
		p_shapes.push_back(newCurve);	//p_shapes(모든 도형의 주소를 저장)에 추가하기
	}
	else if (shape_mode == 3) {	//별
		CMyStar* newStar = new CMyStar(point, point);//동적할당으로 객체 CMyStar 생성
		p_shapes.push_back(newStar);//p_shapes(모든 도형의 주소를 저장)에 추가하기

	}
	else if (shape_mode == 4) {
		// 개별 도형 클릭 선택 처리
		CMyShape* clickedShape = FindShapeAtPoint(point);
		if (clickedShape != nullptr) {
			// 도형을 클릭한 경우
			bool isShiftPressed = (nFlags & MK_SHIFT) != 0;

			if (isShiftPressed) {
				// Shift + 클릭: 복수 선택
				auto it = std::find(selected_Shapes.begin(), selected_Shapes.end(), clickedShape);
				if (it == selected_Shapes.end()){
					// 선택되지 않은 도형이면 선택에 추가
					selected_Shapes.push_back(clickedShape);
				}
			}
			else {
				// 일반 클릭: 단일 선택
				selected_Shapes.clear();
				selected_Shapes.push_back(clickedShape);
			}
			// 도형 이동 준비
			m_isMovingShapes = true;
			m_dragStartPoint = point;
			m_dragCurrentPoint = point;

			Invalidate();
		}
		else {
			// 빈 공간을 클릭한 경우: 드래그 선택 시작
			if (!(nFlags & MK_SHIFT)) {
				// Shift가 눌리지 않았으면 기존 선택 해제
				selected_Shapes.clear();
			}

			m_selectDrag1 = point;
			selectRect.SetRect(point.x, point.y, point.x, point.y);  // 초기화
			m_isDragging = true;
		}
	}

	CWnd::OnLButtonDown(nFlags, point);
}

void CChildView::OnMouseMove(UINT nFlags, CPoint point)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	if (nFlags & MK_LBUTTON) {
		if (shape_mode == 0 && !p_shapes.empty()) {
			p_shapes.back()->m_p2 = point;
			Invalidate();
		}
		else if (shape_mode == 1 && !p_shapes.empty()) {
			p_shapes.back()->m_p2 = point;
			Invalidate();
		}
		else if (shape_mode == 2 && !p_shapes.empty()) {
			p_shapes.back()->m_ptList.push_back(point);
			Invalidate();
		}
		else if (shape_mode == 3 && !p_shapes.empty()) {
			p_shapes.back()->m_p2 = point;
			Invalidate();
		}
		else if (shape_mode == 4) {
			if (m_isMovingShapes && !selected_Shapes.empty()) {
				// 선택된 도형들 이동
				int dx = point.x - m_dragCurrentPoint.x;
				int dy = point.y - m_dragCurrentPoint.y;

				for (CMyShape* shape : selected_Shapes) {
					shape->moveBy(dx, dy);  // 도형을 dx, dy만큼 이동
				}

				m_dragCurrentPoint = point;
				Invalidate();
			}
			else if (m_isDragging) {
				// 드래그 선택 중
				m_selectDrag2 = point;
				selectRect.SetRect(min(m_selectDrag1.x, m_selectDrag2.x), min(m_selectDrag1.y, m_selectDrag2.y),
					max(m_selectDrag1.x, m_selectDrag2.x), max(m_selectDrag1.y, m_selectDrag2.y));
				Invalidate();
			}
		}
	}
	CWnd::OnMouseMove(nFlags, point);
}

void CChildView::OnUpdateShapeRect(CCmdUI* pCmdUI)
{
	// TODO: 여기에 명령 업데이트 UI 처리기 코드를 추가합니다.
	pCmdUI->SetCheck(shape_mode == 0);
}

void CChildView::OnUpdateShapeCircle(CCmdUI* pCmdUI)
{
	// TODO: 여기에 명령 업데이트 UI 처리기 코드를 추가합니다.
	pCmdUI->SetCheck(shape_mode == 1);
}


void CChildView::OnUpdateShapeCurve(CCmdUI* pCmdUI)
{
	// TODO: 여기에 명령 업데이트 UI 처리기 코드를 추가합니다.
	pCmdUI->SetCheck(shape_mode == 2);
}


void CChildView::OnUpdateShapeStar(CCmdUI* pCmdUI)
{
	// TODO: 여기에 명령 업데이트 UI 처리기 코드를 추가합니다.
	pCmdUI->SetCheck(shape_mode == 3);
}


void CChildView::OnDrawRectangle()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	shape_mode = 0;
}


void CChildView::OnDrawCircle()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	shape_mode = 1;
}


void CChildView::OnDrawCurve()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	shape_mode = 2;
}


void CChildView::OnDrawStar()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	shape_mode = 3;
}


void CChildView::OnContextMenu(CWnd* pWnd, CPoint point)
{
	// TODO: 여기에 메시지 처리기 코드를 추가합니다.
	CMenu menu;
	menu.LoadMenu(IDR_MAINFRAME);

	CMenu* pMenu = menu.GetSubMenu(4);

	pMenu->TrackPopupMenu(TPM_LEFTALIGN, point.x, point.y, AfxGetMainWnd());
}


void CChildView::OnActionSelect()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	shape_mode = 4;
}


void CChildView::OnUpdateActionSelect(CCmdUI* pCmdUI)
{
	// TODO: 여기에 명령 업데이트 UI 처리기 코드를 추가합니다.
	pCmdUI->SetCheck(shape_mode == 4);
}


void CChildView::OnLButtonUp(UINT nFlags, CPoint point)
{
	// TODO: 여기에 메시지 처리기 코드를 추가 및/또는 기본값을 호출합니다.
	if (shape_mode == 4) {
		if (m_isMovingShapes) {
			// 도형 이동 완료
			m_isMovingShapes = false;
			Invalidate();
		}
		else if (m_isDragging) {
			// 드래그 선택 완료
			m_selectDrag2 = point;
			selectRect.SetRect(min(m_selectDrag1.x, m_selectDrag2.x), min(m_selectDrag1.y, m_selectDrag2.y),
				max(m_selectDrag1.x, m_selectDrag2.x), max(m_selectDrag1.y, m_selectDrag2.y));

			if (!(nFlags & MK_SHIFT)) {
				selected_Shapes.clear();
			}

			for (CMyShape* shape : p_shapes) {
				if (shape->isInRect(selectRect)) {
					auto it = std::find(selected_Shapes.begin(), selected_Shapes.end(), shape);
					if (it == selected_Shapes.end()) {
						selected_Shapes.push_back(shape);
					}
				}
			}

			m_isDragging = false;
			Invalidate();
		}
	}

	CWnd::OnLButtonUp(nFlags, point);
}


void CChildView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	// Delete 키가 눌렸을 때
	if (nChar == VK_DELETE) {
		if (shape_mode == 4 && !selected_Shapes.empty()) {
			// 선택된 도형들을 p_shapes에서 찾아서 삭제
			for (CMyShape* selectedShape : selected_Shapes) {
				// p_shapes에서 해당 도형 찾기
				auto it = std::find(p_shapes.begin(), p_shapes.end(), selectedShape);
				if (it != p_shapes.end()) {
					// 그룹인 경우 특별 처리
					CMyGroup* group = dynamic_cast<CMyGroup*>(selectedShape);
					if (group != nullptr) {
						// 그룹 내 모든 도형들도 함께 삭제
						std::vector<CMyShape*> allShapes;
						group->getAllShapes(allShapes);
						for (CMyShape* shape : allShapes) {
							delete shape;
						}
					}

					delete* it;  // 메모리 해제
					p_shapes.erase(it);  // 벡터에서 제거
				}
			}

			// 선택 목록 비우기
			selected_Shapes.clear();

			// 화면 갱신
			Invalidate();
		}
	}


	CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
}
// 그룹 관련 함수들의 구현
bool CChildView::CanGroup() const
{
	// 2개 이상의 도형이 선택되었고, 모두 개별 도형이거나 그룹인 경우 그룹 생성 가능
	return selected_Shapes.size() >= 2;
}

bool CChildView::CanUngroup() const
{
	// 선택된 도형 중 하나라도 그룹이면 언그룹 가능
	for (CMyShape* shape : selected_Shapes) {
		if (dynamic_cast<CMyGroup*>(shape) != nullptr) {
			return true;
		}
	}
	return false;
}

void CChildView::GroupSelectedShapes()
{
	if (!CanGroup()) return;

	// 새 그룹 생성
	CMyGroup* newGroup = new CMyGroup();

	// 선택된 도형들을 그룹에 추가
	for (CMyShape* shape : selected_Shapes) {
		newGroup->addShape(shape);

		// p_shapes에서 해당 도형 제거 (그룹에 포함되므로)
		auto it = std::find(p_shapes.begin(), p_shapes.end(), shape);
		if (it != p_shapes.end()) {
			p_shapes.erase(it);
		}
	}

	// 새 그룹을 p_shapes에 추가
	p_shapes.push_back(newGroup);

	// 선택을 새 그룹으로 변경
	selected_Shapes.clear();
	selected_Shapes.push_back(newGroup);

	Invalidate(); // 화면 갱신
}
void CChildView::UngroupSelectedShapes()
{
	if (!CanUngroup()) return;

	std::vector<CMyShape*> newSelection;

	// 선택된 도형들을 검사하여 그룹인 경우 해제
	for (CMyShape* shape : selected_Shapes) {
		CMyGroup* group = dynamic_cast<CMyGroup*>(shape);
		if (group != nullptr) {
			// 그룹인 경우: 그룹 내 도형들을 p_shapes에 다시 추가
			const std::vector<CMyShape*>& groupShapes = group->getShapes();
			for (CMyShape* groupShape : groupShapes) {
				p_shapes.push_back(groupShape);
				newSelection.push_back(groupShape);
			}

			// p_shapes에서 그룹 제거
			auto it = std::find(p_shapes.begin(), p_shapes.end(), group);
			if (it != p_shapes.end()) {
				p_shapes.erase(it);
			}

			// 그룹의 도형들을 비우고 그룹 삭제
			group->clearShapes();
			delete group;
		}
		else {
			// 그룹이 아닌 경우: 그대로 유지
			newSelection.push_back(shape);
		}
	}

	// 선택을 언그룹된 도형들로 변경
	selected_Shapes = newSelection;

	Invalidate(); // 화면 갱신
}


void CChildView::OnActionGroup()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	GroupSelectedShapes();
}


void CChildView::OnActionUngroup()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	UngroupSelectedShapes();
}


void CChildView::OnUpdateActionGroup(CCmdUI* pCmdUI)
{
	// TODO: 여기에 명령 업데이트 UI 처리기 코드를 추가합니다.
	pCmdUI->Enable(CanGroup());
}


void CChildView::OnUpdateActionUngroup(CCmdUI* pCmdUI)
{
	// TODO: 여기에 명령 업데이트 UI 처리기 코드를 추가합니다.
	// 언그룹이 가능한 경우에만 메뉴/버튼 활성화
	pCmdUI->Enable(CanUngroup());
}

// 순서 변경 관련 함수들의 구현 (기존 코드 끝부분에 추가)

bool CChildView::CanBringToFront() const
{
	// 선택된 도형이 있고, 선택 모드일 때 가능
	return (shape_mode == 4 && !selected_Shapes.empty());
}

bool CChildView::CanSendToBack() const
{
	// 선택된 도형이 있고, 선택 모드일 때 가능
	return (shape_mode == 4 && !selected_Shapes.empty());
}

void CChildView::BringSelectedShapesToFront()
{
	if (!CanBringToFront()) return;

	// 선택된 도형들을 p_shapes에서 제거하고 맨 뒤에 추가
	// 단, 선택 순서의 역순으로 추가하여 나중에 선택한 도형이 더 앞에 오도록 함

	std::vector<CMyShape*> shapesToMove;

	// 1. 선택된 도형들을 찾아서 별도 벡터에 저장
	for (CMyShape* selectedShape : selected_Shapes) {
		auto it = std::find(p_shapes.begin(), p_shapes.end(), selectedShape);
		if (it != p_shapes.end()) {
			shapesToMove.push_back(selectedShape);
		}
	}

	// 2. p_shapes에서 선택된 도형들 제거
	for (CMyShape* shape : shapesToMove) {
		auto it = std::find(p_shapes.begin(), p_shapes.end(), shape);
		if (it != p_shapes.end()) {
			p_shapes.erase(it);
		}
	}

	// 3. 선택된 도형들을 맨 뒤에 역순으로 추가
	// 이렇게 하면 나중에 선택한 도형이 더 앞에(위에) 보이게 됩니다
	for (int i = shapesToMove.size() - 1; i >= 0; i--) {
		p_shapes.push_back(shapesToMove[i]);
	}

	// 화면 갱신
	Invalidate();
}

void CChildView::SendSelectedShapesToBack()
{
	if (!CanSendToBack()) return;

	// 선택된 도형들을 p_shapes에서 제거하고 맨 앞에 추가
	// (맨 앞에 있는 도형이 먼저 그려져서 맨 아래에 보임)

	std::vector<CMyShape*> shapesToMove;

	// 1. 선택된 도형들을 찾아서 별도 벡터에 저장
	for (CMyShape* selectedShape : selected_Shapes) {
		auto it = std::find(p_shapes.begin(), p_shapes.end(), selectedShape);
		if (it != p_shapes.end()) {
			shapesToMove.push_back(selectedShape);
		}
	}

	// 2. p_shapes에서 선택된 도형들 제거
	for (CMyShape* shape : shapesToMove) {
		auto it = std::find(p_shapes.begin(), p_shapes.end(), shape);
		if (it != p_shapes.end()) {
			p_shapes.erase(it);
		}
	}

	// 3. 선택된 도형들을 맨 앞에 추가 (먼저 그려져서 아래에 보임)
	// 역순으로 추가하여 선택 순서를 유지
	for (int i = shapesToMove.size() - 1; i >= 0; i--) {
		p_shapes.insert(p_shapes.begin(), shapesToMove[i]);
	}

	// 화면 갱신
	Invalidate();
}
void CChildView::OnAlignBringfront()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	BringSelectedShapesToFront();
}


void CChildView::OnAlignBringback()
{
	// TODO: 여기에 명령 처리기 코드를 추가합니다.
	SendSelectedShapesToBack();
}