/*
* 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/>.

--- HISTORICAL COMMENTS FOLLOW ---

 * $Logfile: /DescentIII/Main/editor/DoorwayDialog.cpp $
 * $Revision: 1.1.1.1 $
 * $Date: 2003-08-26 03:57:37 $
 * $Author: kevinb $
 *
 * Doorway keypad
 *
 * $Log: not supported by cvs2svn $
 * 
 * 23    5/05/99 2:02a Matt
 * Added doorway flag to tell the Guide-Bot to ignore the locked state of
 * the door.
 * 
 * 22    4/03/99 7:55p Matt
 * Use new keypad update system instead of timer to update.
 * 
 * 21    3/05/99 1:51p Kevin
 * Fixed small crash bug
 * 
 * 20    3/01/99 10:37a Matt
 * Update doorway tab when the door object is renamed
 * 
 * 19    2/06/99 10:03p Matt
 * Added keys system
 * 
 * 18    2/04/99 2:05p Matt
 * Added blastable doors
 * 
 * 17    1/29/99 12:48p Matt
 * Rewrote the doorway system
 * 
 * 16    9/22/98 12:02p Matt
 * Fixed compile warnings
 * 
 * 15    9/08/98 12:06p Jason
 * added automatic reinitting of doors when rooms get deleted
 * 
 * 14    9/02/98 4:32p Matt
 * Added some error checking when placing a door.
 * 
 * 13    6/15/98 4:00p Jason
 * replaced monochromatic polymodel lighting with rgb lighting
 * 
 * 12    4/20/98 2:52p Jason
 * added doorway reinit function
 * 
 * 11    4/07/98 11:05a Kevin
 * For Samir, added m_Active to the if statement in the timer interrupt
 * 
 * 10    4/02/98 3:54p Jason
 * first pass in getting polymodel paging to work
 * 
 * 9     12/19/97 11:25a Samir
 * g3_StartFrame and g3_EndFrame replaced by EditorStartFrame and
 * EditorEndFrame
 * 
 * 8     10/03/97 12:24p Jason
 * added new keys for doorways
 * 
 * 7     9/29/97 12:09p Jason
 * added functionality to doorway system
 * 
 * 6     9/23/97 12:29p Jason
 * fixed m_Active bug
 * 
 * 5     9/17/97 1:01p Matt
 * Ripped out segment code
 * 
 * 4     9/11/97 5:46p Jason
 * first pass at getting doors to work with room engine
 * 
 * 3     7/24/97 6:11p Matt
 * Created symbolic constant for default zoom, and used it every place
 * that specifies zoom
 * 
 * 20    6/03/97 4:55p Mark
 * 
 *	20	6/03/97	4:51p	Jeff
 *	Added Context Sensitive Help
 *
 * 19    4/02/97 5:15p Samir
 * Added a Opened checkbox to mark a door as open or closed initially
 * 
 * 18    4/01/97 11:00p Matt
 * Changed editor to keep a viewer object (type camera) seperate from the
 * player object.  This camera, and not the player, is now moved by
 * slewing, the C key, etc.  When going into the game, the viewer position
 * & orientation are copied to the player.  When going back to the editor,
 * the player position is copied to the viewer, and the player object is
 * reset to its start location.
 * 
 * 17    3/31/97 5:57p Matt
 * Revamped mine update flags
 * 
 * 16    3/26/97 5:43p Samir
 * Fixed refresh of doorway selector when changing state of door page.
 * 
 * 15    3/25/97 6:31p Samir
 * Now you can select from different 3d doors hopefully.
 * 
 * 14    3/24/97 6:47p Samir
 * Fixed some place,remove  doorway probs with 3d doors.  Made some state
 * vars static for multiple instances of dialog.
 * 
 * 13    3/20/97 12:10p Samir
 * Fixed prob when going into fullscreen with doorway keypad visible.
 * 
 * 12    3/19/97 7:02p Samir
 * If adding door segment fails, don't register it as a door! And
 * deactivated moving doorways from one seg to another for now.
 * 
 * 11    3/18/97 11:35a Samir
 * Fixed user interface problems.
 *
 * $NoKeywords: $
 */

// DoorwayDialog.cpp : implementation file
//

#include "stdafx.h"
#include "editor.h"
#include "DoorwayDialog.h"

#include "door.h"
#include "HView.h"
#include "HRoom.h"
#include "polymodel.h"
#include "edoors.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

int Current_door_room=-1;

/////////////////////////////////////////////////////////////////////////////
// CDoorwayDialog dialog


CDoorwayDialog::CDoorwayDialog(CWnd* pParent /*=NULL*/)
	: CKeypadDialog(CDoorwayDialog::IDD, pParent)
{
	//{{AFX_DATA_INIT(CDoorwayDialog)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT

//	m_SelectionType = DOORWAY_DOOR;
}


void CDoorwayDialog::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDoorwayDialog)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CDoorwayDialog, CDialog)
	//{{AFX_MSG_MAP(CDoorwayDialog)
	ON_WM_VSCROLL()
	ON_WM_HSCROLL()
	ON_WM_SIZE()
	ON_WM_PAINT()
	ON_BN_CLICKED(IDC_DOORWAY_PLACEDOOR, OnDoorwayPlaceDoorway)
	ON_BN_CLICKED(IDC_NEXT_DOOR, OnNextDoor)
	ON_BN_CLICKED(IDC_PREV_DOOR, OnPrevDoor)
	ON_BN_CLICKED(IDC_DOORWAY_LOCKED, OnDoorwayLocked)
	ON_BN_CLICKED(IDC_KEY1_CHECK, OnKey1Check)
	ON_BN_CLICKED(IDC_KEY2_CHECK, OnKey2Check)
	ON_BN_CLICKED(IDC_KEY3_CHECK, OnKey3Check)
	ON_BN_CLICKED(IDC_KEY4_CHECK, OnKey4Check)
	ON_BN_CLICKED(IDC_KEY5_CHECK, OnKey5Check)
	ON_BN_CLICKED(IDC_KEY6_CHECK, OnKey6Check)
	ON_BN_CLICKED(IDC_KEY7_CHECK, OnKey7Check)
	ON_BN_CLICKED(IDC_KEY8_CHECK, OnKey8Check)
	ON_BN_CLICKED(IDC_DOORWAY_ATTACHDOOR, OnDoorwayAttachDoor)
	ON_BN_CLICKED(IDC_DOORWAY_AUTO, OnDoorwayAuto)
	ON_EN_KILLFOCUS(IDC_DOORWAY_POS_EDIT, OnKillfocusDoorwayPosEdit)
	ON_EN_KILLFOCUS(IDC_DOORWAY_HITPOINT_EDIT, OnKillfocusDoorwayHitpointEdit)
	ON_BN_CLICKED(IDC_DOORWAY_KEY_ALL, OnDoorwayKeyAll)
	ON_BN_CLICKED(IDC_DOORWAY_KEY_ONLY_ONE, OnDoorwayKeyOnlyOne)
	ON_BN_CLICKED(IDC_DOORWAY_GB_IGNORE_LOCKED, OnDoorwayGBIgnoreLocked)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDoorwayDialog message handlers

void CDoorwayDialog::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	// TODO: Add your message handler code here and/or call default
	
	CKeypadDialog::OnVScroll(nSBCode, nPos, pScrollBar);
}


void CDoorwayDialog::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	// TODO: Add your message handler code here and/or call default
	
	CKeypadDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}


void CDoorwayDialog::OnSize(UINT nType, int cx, int cy) 
{
	CKeypadDialog::OnSize(nType, cx, cy);

	
}


void CDoorwayDialog::OnPaint() 
{
	CPaintDC dc(this); // device context for painting

	UpdateDialog();	
}


BOOL CDoorwayDialog::OnInitDialog() 
{
	CDialog::OnInitDialog();
	UpdateDialog();
	return TRUE;
}


void CDoorwayDialog::OnOK()
{
	CWnd *focus = CWnd::GetFocus();
	if (focus) focus->GetNextWindow()->SetFocus();
}

void CDoorwayDialog::EnableCurrentItems(bool state)
{
	((CButton *) GetDlgItem(IDC_DOORWAY_ID))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_LOCKED))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_GB_IGNORE_LOCKED))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_AUTO))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_CURRENT_BOX))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_POS_TEXT))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_POS_EDIT))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_HITPOINT_TEXT))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_HITPOINT_EDIT))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_KEYS_TEXT))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_KEY_ALL))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_DOORWAY_KEY_ONLY_ONE))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_KEY1_CHECK))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_KEY2_CHECK))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_KEY3_CHECK))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_KEY4_CHECK))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_KEY5_CHECK))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_KEY6_CHECK))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_KEY7_CHECK))->EnableWindow(state);
	((CButton *) GetDlgItem(IDC_KEY8_CHECK))->EnableWindow(state);
}


//	---------------------------------------------------------------------------
//	Update doorway key functions functions
//	---------------------------------------------------------------------------

char last_name[OBJ_NAME_LEN +1];

void CDoorwayDialog::UpdateDialog()
{
	if (!m_Active) return;

	if (Num_doors<=0)
		return;
	if (Doors[D3EditState.current_door].used==0)
		D3EditState.current_door=GetNextDoor (D3EditState.current_door);

	int door_handle=D3EditState.current_door;
	
	CEdit *ebox=(CEdit *) GetDlgItem (IDC_DOORWAYSELEDIT);
	ebox->SetWindowText (Doors[door_handle].name);
	DrawDoorwayDoorPic();

	((CButton *) GetDlgItem(IDC_DOORWAY_ATTACHDOOR))->EnableWindow(Placed_door != -1);

	ebox=(CEdit *) GetDlgItem (IDC_DOORWAY_ID);

	if (Cur_object_index==-1 || Objects[Cur_object_index].type!=OBJ_DOOR)
	{
		ebox->SetWindowText ("No doorway selected");
		Current_door_room = -1;
		EnableCurrentItems(0);
	}
	else
	{
		char str[250];
		object *objp = &Objects[Cur_object_index];

		EnableCurrentItems(1);

		Current_door_room = objp->roomnum;

		ASSERT(Rooms[Current_door_room].flags & RF_DOOR);

		strcpy(last_name,Objects[Cur_object_index].name?Objects[Cur_object_index].name:"<no name>");
		sprintf (str,"Door:  %s        ",last_name);
		ebox->SetWindowText (str);

		doorway *dw = Rooms[Current_door_room].doorway_data;

		sprintf(str,"%.2f",dw->position);
		ebox=(CEdit *) GetDlgItem(IDC_DOORWAY_POS_EDIT);
  		ebox->SetWindowText(str);

		//Update key check boxes
		CButton *bbox = (CButton *)GetDlgItem(IDC_DOORWAY_LOCKED);
  		bbox->SetCheck(dw->flags & DF_LOCKED);

		bbox = (CButton *)GetDlgItem(IDC_DOORWAY_AUTO);
  		bbox->SetCheck(dw->flags & DF_AUTO);

		bbox = (CButton *)GetDlgItem(IDC_DOORWAY_GB_IGNORE_LOCKED);
  		bbox->SetCheck(dw->flags & DF_GB_IGNORE_LOCKED);

		bbox = (CButton *)GetDlgItem(IDC_KEY1_CHECK);
  		bbox->SetCheck(dw->keys_needed & KEY_FLAG(1));

		bbox = (CButton *)GetDlgItem(IDC_KEY2_CHECK);
  		bbox->SetCheck(dw->keys_needed & KEY_FLAG(2));

		bbox = (CButton *)GetDlgItem(IDC_KEY3_CHECK);
  		bbox->SetCheck(dw->keys_needed & KEY_FLAG(3));

		bbox = (CButton *)GetDlgItem(IDC_KEY4_CHECK);
  		bbox->SetCheck(dw->keys_needed & KEY_FLAG(4));

		bbox = (CButton *)GetDlgItem(IDC_KEY5_CHECK);
  		bbox->SetCheck(dw->keys_needed & KEY_FLAG(5));

		bbox = (CButton *)GetDlgItem(IDC_KEY6_CHECK);
  		bbox->SetCheck(dw->keys_needed & KEY_FLAG(6));

		bbox = (CButton *)GetDlgItem(IDC_KEY7_CHECK);
  		bbox->SetCheck(dw->keys_needed & KEY_FLAG(7));

		bbox = (CButton *)GetDlgItem(IDC_KEY8_CHECK);
  		bbox->SetCheck(dw->keys_needed & KEY_FLAG(8));

		//Update key radio buttons
		bbox = (CButton *)GetDlgItem(IDC_DOORWAY_KEY_ALL);
  		bbox->SetCheck(! (dw->flags & DF_KEY_ONLY_ONE));
		bbox = (CButton *)GetDlgItem(IDC_DOORWAY_KEY_ONLY_ONE);
  		bbox->SetCheck(dw->flags & DF_KEY_ONLY_ONE);

		//Update hitpoints editing
		door *door = &Doors[dw->doornum];
		bool blastable = ((door->flags & DF_BLASTABLE) != 0);
		((CButton *) GetDlgItem(IDC_DOORWAY_HITPOINT_TEXT))->EnableWindow(blastable);
		sprintf(str,"%d",(int) objp->shields);
		ebox=(CEdit *) GetDlgItem(IDC_DOORWAY_HITPOINT_EDIT);
 		ebox->SetWindowText(str);
		ebox->EnableWindow(blastable);
	}
}


//	update doorway picture

void CDoorwayDialog::DrawDoorwayDoorPic()
{
	int door_handle=D3EditState.current_door;
	vector zero_vector;
	vector view_vector={0,0,-20};
	matrix id_matrix;
	float norm_angles[30];
	int w, h, bm_handle, x, y;
	RECT rect;
	CWnd *wnd = GetDlgItem(IDC_DOORPIC);

	Desktop_surf->attach_to_window((unsigned)wnd->m_hWnd);

	wnd->GetWindowRect(&rect);
	ScreenToClient(&rect);

	w=rect.right-rect.left;
	h=rect.bottom-rect.top;

	m_DoorSurf.create(w, h, BPP_16);

	Desktop_surf->clear(0,0,w,h);
	
	bm_handle=GetDoorImage (door_handle);

	poly_model *pm=GetPolymodelPointer (bm_handle);

	vm_MakeZero (&zero_vector);
	vm_MakeIdentity (&id_matrix);

	for (int i=0;i<30;i++)
		norm_angles[i]=0;

	grViewport *vport=new grViewport (&m_DoorSurf);
	StartEditorFrame (vport,&view_vector,&id_matrix,D3_DEFAULT_ZOOM);
	DrawPolygonModel (&zero_vector,&id_matrix,bm_handle,norm_angles,0,1.0,1.0,1.0);
	EndEditorFrame();

	x = rect.left + ((rect.right-rect.left)/2) - m_DoorSurf.width()/2; 
	y = rect.top + ((rect.bottom-rect.top)/2) - m_DoorSurf.height()/2;
	Desktop_surf->blt(0, 0, &m_DoorSurf);

	delete vport;
	m_DoorSurf.free();
	Desktop_surf->attach_to_window((unsigned)NULL);	
}



//	---------------------------------------------------------------------------
//	Doorway editing functions
//	---------------------------------------------------------------------------

void CDoorwayDialog::OnDoorwayPlaceDoorway() 
{
	if (Num_doors<=0)
		return;

	if (D3EditState.current_door == -1) {
		OutrageMessageBox("You must have a current door for this operation");
		return;
	}

	if (Curroomp->faces[Curface].portal_num != -1) {
		OutrageMessageBox("There's already a connection at the current room:face.");
		return;
	}

	PlaceDoor(Curroomp,Curface,D3EditState.current_door);

	UpdateDialog();

	World_changed = 1;
}

/*BOOL CDoorwayDialog::OnHelpInfo(HELPINFO* pHelpInfo) 
{
	// TODO: Add your message handler code here and/or call default
	WinHelp(HID_DOORWAYTAB,HELP_CONTEXT);
	return TRUE;
	//return CDialog::OnHelpInfo(pHelpInfo);
}*/

void CDoorwayDialog::OnNextDoor() 
{
	if (Num_doors<=0)
		return;

	D3EditState.current_door=GetNextDoor (D3EditState.current_door);
	UpdateDialog();
}

void CDoorwayDialog::OnPrevDoor() 
{
	if (Num_doors<=0)
		return;

	D3EditState.current_door=GetPrevDoor (D3EditState.current_door);
	UpdateDialog();

	
}

void CDoorwayDialog::OnDoorwayLocked() 
{
	if (Current_door_room == -1)
		return;

	doorway *dp = Rooms[Current_door_room].doorway_data;

	ASSERT(dp != NULL);

	int c=IsDlgButtonChecked(IDC_DOORWAY_LOCKED);

	if (c)
		dp->flags|=DF_LOCKED;
	else
		dp->flags&=~DF_LOCKED;
}

void CDoorwayDialog::UpdateKeypad(int mask)
{
	if (mask & (KUF_CUROBJ_CHANGED+KUF_CUROBJ_NAME_CHANGED))
		UpdateDialog();
}

void CDoorwayDialog::OnKeyCheck(int id,int keynum)
{
	if (Current_door_room == -1)
		return;

	doorway *dp = Rooms[Current_door_room].doorway_data;

	ASSERT(dp != NULL);

	if (IsDlgButtonChecked(id))
		dp->keys_needed |= KEY_FLAG(keynum);
	else
		dp->keys_needed &= ~KEY_FLAG(keynum);
}

void CDoorwayDialog::OnKey1Check() 
{
	OnKeyCheck(IDC_KEY1_CHECK,1);
}

void CDoorwayDialog::OnKey2Check() 
{
	OnKeyCheck(IDC_KEY2_CHECK,2);
}

void CDoorwayDialog::OnKey3Check() 
{
	OnKeyCheck(IDC_KEY3_CHECK,3);
}

void CDoorwayDialog::OnKey4Check() 
{
	OnKeyCheck(IDC_KEY4_CHECK,4);
}

void CDoorwayDialog::OnKey5Check() 
{
	OnKeyCheck(IDC_KEY5_CHECK,5);
}

void CDoorwayDialog::OnKey6Check() 
{
	OnKeyCheck(IDC_KEY6_CHECK,6);
}

void CDoorwayDialog::OnKey7Check() 
{
	OnKeyCheck(IDC_KEY7_CHECK,7);
}

void CDoorwayDialog::OnKey8Check() 
{
	OnKeyCheck(IDC_KEY8_CHECK,8);
}


void CDoorwayDialog::OnDoorwayAttachDoor() 
{
	ASSERT(Placed_door != -1);

	AttachRoom();

	UpdateDialog();
}

void CDoorwayDialog::OnDoorwayAuto() 
{
	if (Current_door_room == -1)
		return;

	doorway *dp = Rooms[Current_door_room].doorway_data;

	ASSERT(dp != NULL);

	int c=IsDlgButtonChecked(IDC_DOORWAY_AUTO);

	if (c)
		dp->flags |= DF_AUTO;
	else
		dp->flags &= ~DF_AUTO;
}

void CDoorwayDialog::OnKillfocusDoorwayPosEdit() 
{
	if (Current_door_room == -1)
		return;

	doorway *dp = Rooms[Current_door_room].doorway_data;

	ASSERT(dp != NULL);

	char str[100];

	CEdit *ebox=(CEdit *) GetDlgItem(IDC_DOORWAY_POS_EDIT);
	ebox->GetWindowText(str,sizeof(str));

	dp->position = dp->dest_pos = atof(str);

	if (dp->position < 0.0)
		dp->position = 0.0;
	if (dp->position > 1.0)
		dp->position = 1.0;

	dp->dest_pos = dp->position;

	DoorwayUpdateAnimation(&Rooms[Current_door_room]);

	World_changed = 1;
}

void CDoorwayDialog::OnKillfocusDoorwayHitpointEdit() 
{
	if (Current_door_room == -1)
		return;

	doorway *dp = Rooms[Current_door_room].doorway_data;

	ASSERT(dp != NULL);

	char str[100];

	CEdit *ebox=(CEdit *) GetDlgItem(IDC_DOORWAY_HITPOINT_EDIT);
	ebox->GetWindowText(str,sizeof(str));

	ASSERT(Objects[Cur_object_index].type == OBJ_DOOR);

	Objects[Cur_object_index].shields = atof(str);

	World_changed = 1;
}

void CDoorwayDialog::OnDoorwayKeyAll() 
{
	if (Current_door_room == -1)
		return;

	doorway *dp = Rooms[Current_door_room].doorway_data;

	ASSERT(dp != NULL);

	if (IsDlgButtonChecked(IDC_DOORWAY_KEY_ALL))
		dp->flags &= ~DF_KEY_ONLY_ONE;
	else
		dp->flags |= DF_KEY_ONLY_ONE;

	World_changed = 1;
	
	UpdateDialog();
}

void CDoorwayDialog::OnDoorwayKeyOnlyOne() 
{
	if (Current_door_room == -1)
		return;

	doorway *dp = Rooms[Current_door_room].doorway_data;

	ASSERT(dp != NULL);

	if (IsDlgButtonChecked(IDC_DOORWAY_KEY_ONLY_ONE))
		dp->flags |= DF_KEY_ONLY_ONE;
	else
		dp->flags &= ~DF_KEY_ONLY_ONE;

	World_changed = 1;
	
	UpdateDialog();
}

void CDoorwayDialog::OnDoorwayGBIgnoreLocked() 
{
	if (Current_door_room == -1)
		return;

	doorway *dp = Rooms[Current_door_room].doorway_data;

	ASSERT(dp != NULL);

	int c=IsDlgButtonChecked(IDC_DOORWAY_GB_IGNORE_LOCKED);

	if (c)
		dp->flags |= DF_GB_IGNORE_LOCKED;
	else
		dp->flags &= ~DF_GB_IGNORE_LOCKED;
}