Descent3/legacy/editor/SelManager.cpp

/*
* Descent 3 
* Copyright (C) 2024 Parallax Software
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <algorithm>

#ifdef NEWEDITOR
	#include "../neweditor/stdafx.h"
	#include "../neweditor/globals.h"	
#endif

#include "SelManager.h"
#include "stdafx.h"

#include "macros.h"

#ifndef NEWEDITOR
	#include "ddio.h"
#endif

editorSelectorManager SelManager;


editorSelectorManager::editorSelectorManager()
{
	m_l = m_t = m_r = m_b = -1;
	m_OwnerWnd = NULL;
	m_DragX = m_DragY = -1;
	m_DragState = 0;
	m_EndFunc = NULL;
}


//	sets the owner window of selection
//	starts a selection at x,y
void editorSelectorManager::StartSelection(CWnd *wnd, void (*func)(editorSelectorManager *), int x, int y)
{
	ASSERT(wnd != NULL);

	if (m_DragState != 1) {
		POINT pt;
		RECT rect;
		SIZE size = {2,2};

		if (m_DragState == 2)  {
			CClientDC dc(m_OwnerWnd);
			int r_l, r_b, r_t, r_r;
			RECT client_rect;

			m_OwnerWnd->GetClientRect(&client_rect);
			r_l = m_l; r_t = m_t; r_r = m_r; r_b = m_b;
                        if (r_r < r_l) std::swap(r_l, r_r);
                        if (r_b < r_t) std::swap(r_t, r_b);
			if (r_l < client_rect.left) r_l = client_rect.left;
			if (r_t < client_rect.top) r_t = client_rect.top;
			if (r_r > client_rect.right) r_r = client_rect.right;
			if (r_b > client_rect.bottom) r_b = client_rect.bottom;
			SetRect(&rect, r_l, r_t, r_r, r_b);
			dc.DrawDragRect(&rect, size, NULL, size, NULL, NULL);
		}

		CClientDC dc(wnd);
		m_OwnerWnd = wnd;

		m_DragState = 1;
		m_EndFunc = func;

		m_l = x; m_t = y;
		m_r = x; m_b = y;
		SetRect(&rect, m_l, m_t, m_r, m_b);
		dc.DrawDragRect(&rect, size, NULL, size, NULL, NULL);

		GetCursorPos(&pt);
		m_DragX = pt.x;
		m_DragY = pt.y;
	}
}


//	returns the selected rectangle.
void editorSelectorManager::GetSelectedRect(int *l, int *t, int *r, int *b)
{
	RECT client_rect;

//	make sure selected rectangle is clipped to the owner window and normalized.
	m_OwnerWnd->GetClientRect(&client_rect);

        if (m_r < m_l) std::swap(m_l, m_r);
        if (m_b < m_t) std::swap(m_t, m_b);
	if (m_l < client_rect.left) m_l = client_rect.left;
	if (m_t < client_rect.top) m_t = client_rect.top;
	if (m_r > client_rect.right) m_r = client_rect.right;
	if (m_b > client_rect.bottom) m_b = client_rect.bottom;

	*l = m_l;
	*t = m_t;
	*r = m_r;
	*b = m_b;
}


//	defers control to the selector manager
void editorSelectorManager::Defer()
{
	int mx, my, mdx, mdy;
#ifndef NEWEDITOR
	int mouse_state;
#endif
	POINT pt;

	if (m_DragState != 1) return;
	
//	get mouse deltas and button state
#ifdef NEWEDITOR
	mx = mouse.x;
	my = mouse.y;
	mdx = mouse.x-mouse.oldx;
	mdy = mouse.y-mouse.oldy;
#else
	mouse_state = ddio_MouseGetState(&mx, &my, &mdx, &mdy);
#endif
	GetCursorPos(&pt);
	mx = pt.x; my = pt.y;

	mdx = mx - m_DragX;
	mdy = my - m_DragY;

#ifdef NEWEDITOR
	if (mouse.left && m_DragState == 1) {
#else
	if ((mouse_state & MOUSE_LB) && m_DragState == 1) {
#endif
	// if dragging mouse, then draw drag rectangle.  if dragging outside owner window
	//	then still do sizing of window within bounds of owner (why we use deltas for mouse)
		CClientDC dc(m_OwnerWnd);
		RECT old_draw_rect, draw_rect, client_rect;
		SIZE size = {2,2};
		int r_l, r_b, r_t, r_r;

		m_OwnerWnd->GetClientRect(&client_rect);

	//	get current selected rect, normalize rectangle if left,top is invalid for drawing.
		r_l = m_l; r_t = m_t; r_r = m_r; r_b = m_b;
                if (r_r < r_l) std::swap(r_l, r_r);
                if (r_b < r_t) std::swap(r_t, r_b);
		if (r_l < client_rect.left) r_l = client_rect.left;
		if (r_t < client_rect.top) r_t = client_rect.top;
		if (r_r > client_rect.right) r_r = client_rect.right;
		if (r_b > client_rect.bottom) r_b = client_rect.bottom;
		SetRect(&old_draw_rect, r_l, r_t, r_r, r_b);

		m_r = m_r + mdx;
		m_b = m_b + mdy;

		r_l = m_l; r_t = m_t; r_r = m_r; r_b = m_b;
                if (r_r < r_l) std::swap(r_l, r_r);
                if (r_b < r_t) std::swap(r_t, r_b);
		if (r_l < client_rect.left) r_l = client_rect.left;
		if (r_t < client_rect.top) r_t = client_rect.top;
		if (r_r > client_rect.right) r_r = client_rect.right;
		if (r_b > client_rect.bottom) r_b = client_rect.bottom;
		SetRect(&draw_rect, r_l, r_t, r_r, r_b);

		dc.DrawDragRect(&draw_rect, size, &old_draw_rect, size, NULL, NULL);
	}
#ifdef NEWEDITOR
	else if (mouse.left && m_DragState == 1) {
#else
	else if (!(mouse_state & MOUSE_LB) && m_DragState == 1) {
#endif
	// if mouse up then call our ending function
		m_DragState = 2;
		if (m_EndFunc) (*m_EndFunc)(this);
	}

	m_DragX = mx;
	m_DragY = my;
}


void editorSelectorManager::EndSelection()
{
	RECT rect;
	SIZE size = {2,2};

	CClientDC dc(m_OwnerWnd);
	int r_l, r_b, r_t, r_r;
	RECT client_rect;

// clip drawing rectangle to owner window.
	m_OwnerWnd->GetClientRect(&client_rect);
	r_l = m_l; r_t = m_t; r_r = m_r; r_b = m_b;
        if (r_r < r_l) std::swap(r_l, r_r);
        if (r_b < r_t) std::swap(r_t, r_b);
	if (r_l < client_rect.left) r_l = client_rect.left;
	if (r_t < client_rect.top) r_t = client_rect.top;
	if (r_r > client_rect.right) r_r = client_rect.right;
	if (r_b > client_rect.bottom) r_b = client_rect.bottom;
	SetRect(&rect, r_l, r_t, r_r, r_b);
	dc.DrawDragRect(&rect, size, NULL, size, NULL, NULL);
	m_l = -1; m_t = -1; m_r = -1; m_b = -1;
	m_DragState = 0;
}