guus
/
reman3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
reman3/Rayman_X/cpa/tempgrp/OZO/Src/_zWEdit.cpp

2454 lines
106 KiB
C++
Raw Blame History

//*****************************************************************************
//* _zWEdit.cpp *
//*****************************************************************************
//* *
//* This file contains all the functions for the edit windows *
//* *
//*****************************************************************************
//* Author : Alexis Vaisse *
//*****************************************************************************
// "standard" include
#include "stdafx.h"
#include "ACP_Base.h"
#define HieFriend
#include "IncGAM.h"
#include "ITF.h"
// personal include
#include "_zRes.h" // File created by Microsoft Developer Studio
#include "_zWEdit.hpp"
#include "_zObject.hpp"
#include "_zModif.hpp"
#include "_zWList1.hpp"
#include "_zWList2.hpp"
#include "_zInterf.hpp"
#include "OAC.h" // Actor dll include
#include "IncTUT.h" // Tutorial dll include
class EdActors_EditorActorInstance;
class EdActors_EditorActorModel;
class CPA_Family;
static float s_fOldLenght = 0;
static float s_fOldWidth = 0;
static float s_fOldHeight = 0;
//*****************************************************************************
// class CDisplayControlWindow
//
// Window that controls the display of the zones
//*****************************************************************************
IMPLEMENT_DYNCREATE (CDisplayControlWindow , CFormView)
//-----------------------------------------------------------------------------
// class CDisplayControlWindow : constructor
//-----------------------------------------------------------------------------
CDisplayControlWindow::CDisplayControlWindow(CWnd* pParent /*=NULL*/)
: CFormView(CDisplayControlWindow::IDD)
{
//{{AFX_DATA_INIT(CDisplayControlWindow)
m_Radio_Button_All_Actors = -1;
m_Radio_Button_Current_Actor = -1;
//}}AFX_DATA_INIT
m_Radio_Button_All_Actors = 2; // "Selected" button
m_Radio_Button_Current_Actor = 2; // "Selected" button
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow : general functions
//-----------------------------------------------------------------------------
void CDisplayControlWindow::DoDataExchange(CDataExchange* pDX)
{
CFormView::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CDisplayControlWindow)
DDX_Radio(pDX, IDC_Radio_Button_All_Actors_On, m_Radio_Button_All_Actors);
DDX_Radio(pDX, IDC_Radio_Button_Current_Actor_On, m_Radio_Button_Current_Actor);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CDisplayControlWindow, CFormView)
//{{AFX_MSG_MAP(CDisplayControlWindow)
ON_BN_CLICKED(IDC_Radio_Button_All_Actors_On, On_Radio_Buttons_All_Actors)
ON_BN_CLICKED(IDC_Radio_Button_All_Actors_Off, On_Radio_Buttons_All_Actors)
ON_BN_CLICKED(IDC_Radio_Button_All_Actors_Selected, On_Radio_Buttons_All_Actors)
ON_BN_CLICKED(IDC_Radio_Button_Current_Actor_On, On_Radio_Buttons_Current_Actor)
ON_BN_CLICKED(IDC_Radio_Button_Current_Actor_Off, On_Radio_Buttons_Current_Actor)
ON_BN_CLICKED(IDC_Radio_Button_Current_Actor_Selected, On_Radio_Buttons_Current_Actor)
//}}AFX_MSG_MAP
ON_NOTIFY_EX(TTN_NEEDTEXT, 0, SetToolTipText)
END_MESSAGE_MAP()
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - Create
// init the window
//-----------------------------------------------------------------------------
BOOL CDisplayControlWindow::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)
{
// Call the standard create. Return TRUE if Ok
if (CFormView::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext))
{
// To call DoDataExchange
UpdateData (FALSE);
// Init tooltip control
m_ToolTipCtrl . Create (this , WS_VISIBLE | TTS_ALWAYSTIP);
m_ToolTipCtrl . AddTool (GetDlgItem (IDC_Radio_Button_All_Actors_On ));
m_ToolTipCtrl . AddTool (GetDlgItem (IDC_Radio_Button_All_Actors_Off ));
m_ToolTipCtrl . AddTool (GetDlgItem (IDC_Radio_Button_All_Actors_Selected ));
m_ToolTipCtrl . AddTool (GetDlgItem (IDC_Radio_Button_Current_Actor_On ));
m_ToolTipCtrl . AddTool (GetDlgItem (IDC_Radio_Button_Current_Actor_Off ));
m_ToolTipCtrl . AddTool (GetDlgItem (IDC_Radio_Button_Current_Actor_Selected));
m_ToolTipCtrl . Activate (TRUE);
EnableToolTips ();
// Register the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vRegisterControlID (IDC_Radio_Button_All_Actors_On , "TUT_AllActorsOn" , TUT_e_Button);
TUT_M_vRegisterControlID (IDC_Radio_Button_All_Actors_Off , "TUT_AllActorsOff" , TUT_e_Button);
TUT_M_vRegisterControlID (IDC_Radio_Button_All_Actors_Selected , "TUT_AllActorsSelected" , TUT_e_Button);
TUT_M_vRegisterControlID (IDC_Radio_Button_Current_Actor_On , "TUT_CurrentActorOn" , TUT_e_Button);
TUT_M_vRegisterControlID (IDC_Radio_Button_Current_Actor_Off , "TUT_CurrentActorOff" , TUT_e_Button);
TUT_M_vRegisterControlID (IDC_Radio_Button_Current_Actor_Selected , "TUT_CurrentActorSelected" , TUT_e_Button);
return TRUE;
}
else return FALSE;
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - SetToolTipText
// Set the text that will be shown in a tool tip
//-----------------------------------------------------------------------------
BOOL CDisplayControlWindow::SetToolTipText (UINT uiControlId , NMHDR * pNMHDR , LRESULT * pResult)
{
LPTOOLTIPTEXT lpToolTipText = (LPTOOLTIPTEXT) pNMHDR;
uiControlId = ::GetDlgCtrlID ((HWND) pNMHDR -> idFrom);
switch (uiControlId)
{
case IDC_Radio_Button_All_Actors_On : lpToolTipText -> lpszText = "Show zones of other actors"; break;
case IDC_Radio_Button_All_Actors_Off : lpToolTipText -> lpszText = "Hide zones of other actors"; break;
case IDC_Radio_Button_All_Actors_Selected : lpToolTipText -> lpszText = "Show zones of selected actors"; break;
case IDC_Radio_Button_Current_Actor_On : lpToolTipText -> lpszText = "Select current actor"; break;
case IDC_Radio_Button_Current_Actor_Off : lpToolTipText -> lpszText = "Unselect current actor"; break;
case IDC_Radio_Button_Current_Actor_Selected : lpToolTipText -> lpszText = "Show selected zones of actor"; break;
default : lpToolTipText -> lpszText = ""; break;
}
return TRUE;
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - PreTranslateMessage
// We intercept the WM_NOTIFY message
//-----------------------------------------------------------------------------
BOOL CDisplayControlWindow::PreTranslateMessage (MSG * pMsg)
{
switch (pMsg -> message)
{
case WM_LBUTTONDOWN :
case WM_MOUSEMOVE :
case WM_LBUTTONUP :
case WM_RBUTTONDOWN :
case WM_MBUTTONDOWN :
case WM_RBUTTONUP :
case WM_MBUTTONUP : m_ToolTipCtrl . RelayEvent (pMsg);
break;
}
return CFormView::PreTranslateMessage(pMsg);
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - On_Radio_Buttons_All_Actors
// Called when one clicks on one of the 3 buttons for 'All actors'
//-----------------------------------------------------------------------------
void CDisplayControlWindow::On_Radio_Buttons_All_Actors ()
{
UpdateData (TRUE); // Update the variables from screen
m_pZDxInterface -> IWillRefreshDisplay (C_lOnButtonAllActors);
// If we were editing the bouding volume, we leave the edition
if (m_pZDxInterface -> GetList1Window () -> IsEditingBoundingVolume ())
m_pZDxInterface -> GetList1Window () -> LeaveEditionOfBoundingVolume ();
// ANNECY AV CLEAN_MEC {
/*
else
if (m_pZDxInterface -> GetList1Window () -> IsEditingTestPoint ())
m_pZDxInterface -> GetList1Window () -> LeaveEditionOfTestPoint ();
*/
// END ANNECY AV }
switch (m_Radio_Button_All_Actors)
{
case 0 : // "On" button
m_pZDxInterface -> ShowAllZDxOfAllActors (C_ucShowAllZDx , FALSE);
break;
case 1 : // "Off" button
m_pZDxInterface -> ShowAllZDxOfAllActors (C_ucHideAllZDx , FALSE);
break;
case 2 : // "Selected" button
m_pZDxInterface -> ShowAllZDxOfAllActors (C_ucShowAllZDx , TRUE);
break;
default: ASSERT (0);
}
CPA_SuperObject * pSelectedActorSuperObject = m_pZDxInterface -> GetList1Window () -> GetSelectedActorSuperObject ();
if (pSelectedActorSuperObject) m_pZDxInterface -> ShowZDxOfActor (pSelectedActorSuperObject , C_ucShowAllZDx);
m_pZDxInterface -> RefreshDisplay (C_lOnButtonAllActors);
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - On_Radio_Buttons_Current_Actor
// Called when one clicks on one of the 3 buttons for 'Current actor'
//-----------------------------------------------------------------------------
void CDisplayControlWindow::On_Radio_Buttons_Current_Actor ()
{
UpdateData (TRUE); // Update the variables from screen
// Get the current actor
CPA_Actor * pSelectedActor = (CPA_Actor *) m_pZDxInterface -> GetList1Window () -> GetSelectedActor ();
if (! pSelectedActor) return;
switch (m_Radio_Button_Current_Actor)
{
case 0 : // "On" button
pSelectedActor -> SetDisplayZone (TRUE);
break;
case 1 : // "Off" button
pSelectedActor -> SetDisplayZone (FALSE);
break;
case 2 : // "Selected" button
pSelectedActor -> SetDisplayZone ((BOOL) 2);
break;
default : ASSERT (0);
}
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - GetDisplayForAllActors
// Get the state of the "All actors" radio button
//-----------------------------------------------------------------------------
tdeDisplayType CDisplayControlWindow::GetDisplayForAllActors ()
{
UpdateData (TRUE);
switch (m_Radio_Button_All_Actors)
{
case -1 : return eNoZone;
case 0 : return eOn;
case 1 : return eOff;
case 2 : return eSelected;
default : ASSERT (0);
return eNoZone;
}
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - GetDisplayForCurrentActor
// Get the state of the "Current actor" radio button
//-----------------------------------------------------------------------------
tdeDisplayType CDisplayControlWindow::GetDisplayForCurrentActor ()
{
UpdateData (TRUE);
switch (m_Radio_Button_Current_Actor)
{
case -1 : return eNoZone;
case 0 : return eOn;
case 1 : return eOff;
case 2 : return eSelected;
default : ASSERT (0);
return eNoZone;
}
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - SetDisplayForAllActors
// Set the state of the "All actors" radio button
//-----------------------------------------------------------------------------
void CDisplayControlWindow::SetDisplayForAllActors (tdeDisplayType _eDisplayType)
{
switch (_eDisplayType)
{
case eNoZone : m_Radio_Button_All_Actors = -1; break;
case eOn : m_Radio_Button_All_Actors = 0; break;
case eOff : m_Radio_Button_All_Actors = 1; break;
case eSelected : m_Radio_Button_All_Actors = 2; break;
default : ASSERT (0); break;
}
UpdateData (FALSE); // Update the screen
On_Radio_Buttons_All_Actors ();
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - SetDisplayForCurrentActor
// Set the state of the "Current actor" radio button
//-----------------------------------------------------------------------------
void CDisplayControlWindow::SetDisplayForCurrentActor (tdeDisplayType _eDisplayType)
{
switch (_eDisplayType)
{
case eNoZone : m_Radio_Button_Current_Actor = -1; break;
case eOn : m_Radio_Button_Current_Actor = 0; break;
case eOff : m_Radio_Button_Current_Actor = 1; break;
case eSelected : m_Radio_Button_Current_Actor = 2; break;
default : ASSERT (0); break;
}
UpdateData (FALSE); // Update the screen
On_Radio_Buttons_Current_Actor (); // Update the flag of the actor
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - SetNameOfCurrentActor
// Set the name of the current actor (it is showed in the window)
//-----------------------------------------------------------------------------
void CDisplayControlWindow::SetNameOfCurrentActor (CString csActorName)
{
CString csText = "Current actor";
if (! csActorName . IsEmpty ()) csText += ": " + csActorName;
GetDlgItem (IDC_Frame_Current_Actor) -> SetWindowText ((char *) (LPCTSTR) csText);
}
//-----------------------------------------------------------------------------
// class CDisplayControlWindow - DisplayAllActors
// Display all actors with the correct zones
//-----------------------------------------------------------------------------
void CDisplayControlWindow::DisplayAllActors ()
{
On_Radio_Buttons_All_Actors ();
}
//*****************************************************************************
// class CZDxInfoWindow
//
// Window that shows informations about a ZDx object
//*****************************************************************************
IMPLEMENT_DYNCREATE (CZDxInfoWindow , CFormView)
//-----------------------------------------------------------------------------
// class CZDxInfoWindow : constructor
//-----------------------------------------------------------------------------
CZDxInfoWindow::CZDxInfoWindow(CWnd* pParent /*=NULL*/)
: CFormView(CZDxInfoWindow::IDD)
{
//{{AFX_DATA_INIT(CZDxInfoWindow)
m_Edition_Zone_Name = _T("");
//}}AFX_DATA_INIT
// Init the variables
m_pCZDxShapeInfoWindow = NULL;
m_pZDxModif = NULL;
m_pZDxObject = NULL;
m_bIsApplying = FALSE;
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow : general functions
//-----------------------------------------------------------------------------
void CZDxInfoWindow::DoDataExchange(CDataExchange* pDX)
{
CFormView::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CZDxInfoWindow)
DDX_Text(pDX, IDC_Edition_Zone_Name, m_Edition_Zone_Name);
DDX_Text(pDX, IDC_Edition_Zone_Type, m_Edition_Zone_Type);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CZDxInfoWindow, CFormView)
//{{AFX_MSG_MAP(CZDxInfoWindow)
ON_EN_CHANGE(IDC_Edition_Zone_Name, On_Change_Edition_Zone_Name)
ON_BN_CLICKED(IDC_Apply_Button, On_Apply_Button)
ON_BN_CLICKED(IDC_Cancel_Button, On_Cancel_Button)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - Create
// init the window
//-----------------------------------------------------------------------------
BOOL CZDxInfoWindow::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)
{
// Call the standard create. Return TRUE if Ok
if (CFormView::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext))
{
// To call DoDataExchange
UpdateData (FALSE);
// Register the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vRegisterControlID (IDC_Edition_Zone_Name , "TUT_ZoneName" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Apply_Button , "TUT_Apply" , TUT_e_Button);
TUT_M_vRegisterControlID (IDC_Cancel_Button , "TUT_Cancel" , TUT_e_Button);
return TRUE;
}
else return FALSE;
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - SetZDxObjectToEdit
// set the ZDx object to edit :
// we fill the different fields in the window with the data of a ZDx object
//-----------------------------------------------------------------------------
void CZDxInfoWindow::SetZDxObjectToEdit (CPA_SuperObject * _pZDxSuperObject)
{
// if there is already a ZDx object edited, we clic on the apply button to save the changes
if (m_pZDxObject) Apply ();
m_pZDxSuperObject = _pZDxSuperObject;
m_pZDxObject = (ZDx_Object *) (_pZDxSuperObject ? _pZDxSuperObject -> GetObject () : NULL);
// Refresh the data
RefreshData (FALSE);
// If there is a ZDx object to edit, we must have a ZDx modif
if (m_pZDxObject) RefreshModif ();
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - RefreshData
// this function is called when the data need to be refreshed
//-----------------------------------------------------------------------------
void CZDxInfoWindow::RefreshData (BOOL _bRedrawNeeded)
{
// Init variables
SetZDxHasBeenChanged (FALSE);
if (m_pZDxObject) // If there is a ZDx object to edit
{
// Set the field for the name of the ZDx object
// ANNECY AV CLEAN_MEC {
GetDlgItem (IDC_Edition_Zone_Name) -> EnableWindow (TRUE /* m_pZDxObject -> GetZDxType () != eTestPoint */); // One cannot modify the name of a test point
// END ANNECY AV }
m_Edition_Zone_Name = m_pZDxObject->GetZDxName ();
// Set the field for the type of the ZDx object
switch (m_pZDxObject -> GetZDxType ())
{
case eZdd : m_Edition_Zone_Type = C_szZddName; break;
case eZde : m_Edition_Zone_Type = C_szZdeName; break;
case eZdm : m_Edition_Zone_Type = C_szZdmName; break;
case eZdr : m_Edition_Zone_Type = C_szZdrName; break;
case eBoundingVolume : m_Edition_Zone_Type = C_szBoundingVolumeName; break;
// ANNECY AV CLEAN_MEC {
// case eTestPoint : m_Edition_Zone_Type = C_szTestPointName; break;
// END ANNECY AV }
default : ASSERT (0); break;
}
// ANNECY AV CLEAN_MEC {
// if (m_pZDxObject -> GetZDxType () != eTestPoint)
// END ANNECY AV }
{
m_Edition_Zone_Type += " - ";
switch (m_pZDxObject -> GetZDxGeometricType ())
{
case eSphere : m_Edition_Zone_Type += C_szZDxSphereName; break;
case eBox : m_Edition_Zone_Type += C_szZDxBoxName; break;
case ePoint : m_Edition_Zone_Type += C_szZDxPointName; break;
case eCone : m_Edition_Zone_Type += C_szZDxConeName; break;
default: ASSERT (0); break;
}
}
UpdateData (FALSE);
// If a shape info window is already open
if (m_pCZDxShapeInfoWindow)
{
// If the new edited object has the same type
if (m_eTypeShapeInfoWindow == m_pZDxObject -> GetZDxGeometricType ())
{
// We set the shape to edit (this refreshes the data of the shape info window)
m_pCZDxShapeInfoWindow -> SetZDxShapeToEdit (m_pZDxObject -> GetZDxShape ());
}
// Else we close the shape info window and we open a new one
else
{
CloseShapeInfoWindow ();
OpenShapeInfoWindow ();
}
}
// If the shape info window is not open, we open it
else
{
OpenShapeInfoWindow ();
}
if (_bRedrawNeeded) m_pZDxObject -> RedrawZDxObject ();
}
else // if there is no ZDx object to edit
{
m_Edition_Zone_Name = "";
GetDlgItem (IDC_Edition_Zone_Name) -> EnableWindow (FALSE);
m_Edition_Zone_Type = "";
if (m_pCZDxShapeInfoWindow) CloseShapeInfoWindow ();
}
// At the beginning, buttons are disabled
// They will be enabled when a modification is done
GetDlgItem (IDC_Apply_Button) -> EnableWindow (FALSE);
GetDlgItem (IDC_Cancel_Button) -> EnableWindow (FALSE);
UpdateData (FALSE); // Update the screen
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - RefreshModif
// create a modif for the selected ZDx object
//-----------------------------------------------------------------------------
void CZDxInfoWindow::RefreshModif ()
{
// We don't create a modif if there is no ZDx object
if (! m_pZDxObject) return;
if (m_pZDxModif) m_pZDxModif -> SetZDxObject (m_pZDxObject);
else m_pZDxModif = new ZDx_Modif (m_pZDxObject , "Modification ZDx");
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - SetZDxHasBeenChanged
// Indicate if the ZDx object has been changed or not
//-----------------------------------------------------------------------------
void CZDxInfoWindow::SetZDxHasBeenChanged (BOOL b)
{
m_ZDxHasBeenChanged = b;
// buttons are enabled only if there is a modification
GetDlgItem (IDC_Apply_Button) -> EnableWindow (b);
GetDlgItem (IDC_Cancel_Button) -> EnableWindow (b);
UpdateData (FALSE); // Update the screen
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - On_Change_Edition_Zone_Name
// this function is called when the user changes the name of the ZDx Object :
//-----------------------------------------------------------------------------
void CZDxInfoWindow::On_Change_Edition_Zone_Name ()
{
UpdateData (TRUE);
if( m_pZDxObject == NULL ) return;
CList2Window * pList2Window = ((ZDx_Interface *) m_pZDxObject -> GetEditor ()) -> GetList2Window ();
// If the name has changed, we call SetZDxName
if (m_Edition_Zone_Name != m_pZDxObject -> GetZDxName ())
{
if (m_Edition_Zone_Name != "") // The name is not empty
{
if (! m_pZDxObject -> SetZDxName ((char *) (LPCTSTR (m_Edition_Zone_Name))))
{
MessageBox ("This name already exists or contains invalid characters (space...). Please enter another name." , "Warning" , MB_OK + MB_APPLMODAL + MB_ICONSTOP);
::SetFocus (GetDlgItem (IDC_Edition_Zone_Name) -> m_hWnd);
return;
}
else
{
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
// Refresh the list of ZDx
if (m_pZDxObject -> GetZDxType () == eBoundingVolume)
pList2Window -> CreateBoundingVolume (pList2Window -> GetActorSuperObject () , m_pZDxObject , FALSE);
else pList2Window -> ReCreateListOfZDx (FALSE , FALSE);
}
}
else // The name is empty : we put " " as name, and we do not show any message
{
m_pZDxObject -> SetZDxName (" ");
// Refresh the list of ZDx
if (m_pZDxObject -> GetZDxType () == eBoundingVolume)
pList2Window -> CreateBoundingVolume (pList2Window -> GetActorSuperObject () , m_pZDxObject , FALSE);
else pList2Window -> ReCreateListOfZDx (FALSE , FALSE);
SetZDxHasBeenChanged (TRUE);
}
}
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - OpenShapeInfoWindow
// open a window with the properties of the ZDx object (radius for the sphere...)
//-----------------------------------------------------------------------------
void CZDxInfoWindow::OpenShapeInfoWindow ()
{
CPA_SuperObject * pFatherSuperObject = m_pZDxSuperObject -> GetSuperObjectFather ();
ZDx_Interface * pZDxInterface = (ZDx_Interface *) m_pZDxObject -> GetEditor ();
// We want the resources to be searched into the DLL and not into the program
HINSTANCE hOldInst = AfxGetResourceHandle ();
AfxSetResourceHandle (((CPA_DLLBase *) m_pZDxObject -> GetEditor ()) -> GetDLLIdentity () -> hModule);
switch (m_pZDxObject -> GetZDxGeometricType ())
{
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
case eSphere: // create a window to display the sphere attributes and give it a pointer to the ZDx object
m_pCZDxShapeInfoWindow = new CZDxSphereInfoWindow (this , (ZDx_Shape *) m_pZDxObject -> GetZDxShape () , pFatherSuperObject , pZDxInterface);
break;
case eBox: // create a window to display the box attributes and give it a pointer to the ZDx object
m_pCZDxShapeInfoWindow = new CZDxBoxInfoWindow (this , (ZDx_Shape *) m_pZDxObject -> GetZDxShape () , pFatherSuperObject , pZDxInterface);
break;
case ePoint: // create a window to display the point attributes and give it a pointer to the ZDx object
m_pCZDxShapeInfoWindow = new CZDxPointInfoWindow (this , (ZDx_Point *) m_pZDxObject -> GetZDxShape ());
break;
case eCone: // create a window to display the cone attributes and give it a pointer to the ZDx object
m_pCZDxShapeInfoWindow = new CZDxConeInfoWindow (this , (ZDx_Shape *) m_pZDxObject -> GetZDxShape ());
break;
//ENDROMTEAM WorldEditor (Cristi Petrescu)
default: ASSERT (0);
return;
}
AfxSetResourceHandle (hOldInst);
// Set the type of the shape info window
m_eTypeShapeInfoWindow = m_pZDxObject -> GetZDxGeometricType ();
// Move the shape info window to the right place
RECT Dimension; // Get the width and height of the Shape info window
m_pCZDxShapeInfoWindow -> GetWindowRect( & Dimension);
RECT AbsolutePosition; // Get the absolute position of the static
GetDlgItem (IDC_Pos_Shape_Info_Window) -> GetWindowRect (& AbsolutePosition);
RECT WindowPosition; // Get the absolute position of the window
GetWindowRect (& WindowPosition);
RECT RelativePosition; // Then we can calculate the relative position of the static within the window
RelativePosition.left = AbsolutePosition.left - WindowPosition.left;
RelativePosition.top = AbsolutePosition.top - WindowPosition.top;
// We move the Shape info window
m_pCZDxShapeInfoWindow -> MoveWindow( RelativePosition.left , RelativePosition.top ,
Dimension.right-Dimension.left , Dimension.bottom-Dimension.top);
m_pCZDxShapeInfoWindow -> ShowWindow (SW_SHOW);
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - CloseShapeInfoWindow
// close the Shape info window
//-----------------------------------------------------------------------------
void CZDxInfoWindow::CloseShapeInfoWindow ()
{
m_pCZDxShapeInfoWindow->DestroyWindow ();
delete m_pCZDxShapeInfoWindow;
m_pCZDxShapeInfoWindow = NULL;
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - On_Apply_Button
// clic on the Apply button
//-----------------------------------------------------------------------------
void CZDxInfoWindow::On_Apply_Button ()
{
if (m_bIsApplying || m_pZDxObject == NULL) return;
m_bIsApplying = TRUE;
if (m_ZDxHasBeenChanged)
{
m_pZDxModif -> Undo (FALSE); // we must undo the modifications (without refreshing the window)
m_pZDxObject->GetEditor()->GetInterface()->GetMultiDevice()->GetEditManager()->AskFor (m_pZDxModif);
// because the edit manager redoes them
if (! m_pZDxObject) // The Do function of the modification refreshes the display,
{ // so m_pZDxObject can now be NULL
m_bIsApplying = FALSE;
m_pZDxModif = NULL;
return;
}
m_pZDxModif = new ZDx_Modif (m_pZDxObject , "Modification ZDx"); // we create a new ZDx modif
m_ZDxHasBeenChanged = FALSE;
GetDlgItem (IDC_Apply_Button) -> EnableWindow (FALSE);
GetDlgItem (IDC_Cancel_Button) -> EnableWindow (FALSE);
UpdateData (FALSE); // Update the screen
}
m_bIsApplying = FALSE;
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - Apply
// this simulates a clic on the Apply button
//-----------------------------------------------------------------------------
void CZDxInfoWindow::Apply ()
{
On_Apply_Button ();
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - On_Cancel_Button
// clic on the cancel button : we cancel the changes the user did
//-----------------------------------------------------------------------------
void CZDxInfoWindow::On_Cancel_Button ()
{
if (m_pZDxObject == NULL) return;
if (m_ZDxHasBeenChanged)
{
m_pZDxModif -> Undo (); // we undo the modifications
m_pZDxModif -> SetZDxObject (m_pZDxObject); // and we start again
GetDlgItem (IDC_Apply_Button) -> EnableWindow (FALSE);
GetDlgItem (IDC_Cancel_Button) -> EnableWindow (FALSE);
UpdateData (FALSE); // Update the screen
}
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - Cancel
// this simulates a clic on the Cancel button
//-----------------------------------------------------------------------------
void CZDxInfoWindow::Cancel ()
{
On_Cancel_Button ();
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - GetFirstControlOfWindow
// Get the first control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxInfoWindow::GetFirstControlOfWindow ()
{
return GetDlgItem (IDC_Edition_Zone_Name);
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - GetLastControlOfWindow
// Get the last control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxInfoWindow::GetLastControlOfWindow ()
{
if (m_ZDxHasBeenChanged) return GetDlgItem (IDC_Cancel_Button);
else return GetDlgItem (IDC_Edition_Zone_Name);
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - OnTabKeyPressed
// Called when the Tab key is pressed ; return TRUE if the message is used
//-----------------------------------------------------------------------------
BOOL CZDxInfoWindow::OnTabKeyPressed ()
{
if (GetFocus () == GetLastControlOfWindow ())
{
m_pCZDxShapeInfoWindow -> GetFirstControlOfWindow () -> SetFocus ();
return TRUE;
}
if (GetFocus () == m_pCZDxShapeInfoWindow -> GetLastControlOfWindow ())
{
GetFirstControlOfWindow () -> SetFocus ();
return TRUE;
}
// Give the focus to the next control
GetFocus () -> GetParent () -> GetNextDlgTabItem (GetFocus () , FALSE) -> SetFocus ();
return TRUE;
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - OnShiftTabKeyPressed
// Called when the Tab key is pressed ; return TRUE if the message is used
//-----------------------------------------------------------------------------
BOOL CZDxInfoWindow::OnShiftTabKeyPressed ()
{
if (GetFocus () == GetFirstControlOfWindow ())
{
m_pCZDxShapeInfoWindow -> GetLastControlOfWindow () -> SetFocus ();
return TRUE;
}
if (GetFocus () == m_pCZDxShapeInfoWindow -> GetFirstControlOfWindow ())
{
GetLastControlOfWindow () -> SetFocus ();
return TRUE;
}
// Give the focus to the previous control
GetFocus () -> GetParent () -> GetNextDlgTabItem (GetFocus () , TRUE) -> SetFocus ();
return TRUE;
}
//-----------------------------------------------------------------------------
// class CZDxInfoWindow - PreTranslateMessage
// used to test the Tab key
//-----------------------------------------------------------------------------
BOOL CZDxInfoWindow::PreTranslateMessage (MSG * pMsg)
{
if (pMsg -> message == WM_KEYDOWN)
{
switch (pMsg -> wParam)
{
case VK_TAB:
if ((::GetKeyState (VK_CONTROL) & 0x8000) == 0x0000) // The Control key must not be pressed
{
if (::GetKeyState (VK_SHIFT) & 0x8000)
{
if (OnShiftTabKeyPressed ()) return TRUE;
}
else
{
if (OnTabKeyPressed ()) return TRUE;
}
}
break;
case VK_RETURN: Apply ();
return TRUE;
case VK_ESCAPE: Cancel ();
return TRUE;
}
}
return CFormView::PreTranslateMessage (pMsg);
}
//*****************************************************************************
// class CZDxShapeInfoWindow
//
// Abstract class
//*****************************************************************************
//-----------------------------------------------------------------------------
// class CZDxShapeInfoWindow - OnOK
// clic on the Apply button of the parent window
//-----------------------------------------------------------------------------
void CZDxShapeInfoWindow::OnOK ()
{
((CZDxInfoWindow *) GetParent ()) -> Apply ();
}
//-----------------------------------------------------------------------------
// class CZDxShapeInfoWindow - OnCancel
// clic on the Cancel button of the parent window
//-----------------------------------------------------------------------------
void CZDxShapeInfoWindow::OnCancel ()
{
((CZDxInfoWindow *) GetParent ()) -> Cancel ();
}
//-----------------------------------------------------------------------------
// class CZDxShapeInfoWindow - SetZDxHasBeenChanged
// indicate to the parent window that the ZDx object has been changed
//-----------------------------------------------------------------------------
void CZDxShapeInfoWindow::SetZDxHasBeenChanged (BOOL b)
{
((CZDxInfoWindow *) GetParent ()) -> SetZDxHasBeenChanged (b);
}
//-----------------------------------------------------------------------------
// class CZDxShapeInfoWindow - PreTranslateMessage
// used to test the Tab key
//-----------------------------------------------------------------------------
BOOL CZDxShapeInfoWindow::PreTranslateMessage (MSG * pMsg)
{
if (pMsg -> message == WM_KEYDOWN && pMsg -> wParam == VK_TAB)
{
if (GetParent () -> PreTranslateMessage (pMsg)) return TRUE;
}
return CDialog::PreTranslateMessage (pMsg);
}
//*****************************************************************************
// class CZDxSphereInfoWindow
//
// Window that shows informations about a ZDx sphere object
//*****************************************************************************
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow
// general functions
//-----------------------------------------------------------------------------
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
CZDxSphereInfoWindow::CZDxSphereInfoWindow (CWnd * _pParent , ZDx_Shape * _pObject , CPA_SuperObject * _pFatherSuperObject ,
ZDx_Interface * _pZDxInterface)
//ENDROMTEAM WorldEditor (Cristi Petrescu)
{
// Call the CDialog constructor
CDialog::CDialog (CZDxSphereInfoWindow::IDD, _pParent);
//{{AFX_DATA_INIT(CZDxSphereInfoWindow)
m_Edition_Zone_Center_X = _T("");
m_Edition_Zone_Center_Y = _T("");
m_Edition_Zone_Center_Z = _T("");
m_Edition_Zone_Radius = _T("");
//}}AFX_DATA_INIT
// Store the pointer to the ZDx sphere object
m_pZDxSphere = _pObject;
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pSphere3D = (Sphere3D *) _pObject -> GetGeometric3dObject ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (_pFatherSuperObject)
{
m_FatherRadius = _pZDxInterface -> ComputeInitialSizeOfSphere (_pFatherSuperObject , & m_FatherCenter);
}
else
{
m_FatherRadius = (float) 1.0;
MTH3D_M_vNullVector (& m_FatherCenter);
}
// Create the window
Create (IDD_ZDD_Sphere_Info_Window , _pParent);
}
void CZDxSphereInfoWindow::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CZDxSphereInfoWindow)
DDX_Text(pDX, IDC_Edition_Zone_Center_X, m_Edition_Zone_Center_X);
DDX_Text(pDX, IDC_Edition_Zone_Center_Y, m_Edition_Zone_Center_Y);
DDX_Text(pDX, IDC_Edition_Zone_Center_Z, m_Edition_Zone_Center_Z);
DDX_Text(pDX, IDC_Edition_Zone_Radius, m_Edition_Zone_Radius);
DDX_Control(pDX, IDC_Slider_Radius , m_Slider_Radius);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CZDxSphereInfoWindow, CDialog)
//{{AFX_MSG_MAP(CZDxSphereInfoWindow)
ON_EN_CHANGE(IDC_Edition_Zone_Center_X, On_Change_Edition_Zone_Center_X)
ON_EN_CHANGE(IDC_Edition_Zone_Center_Y, On_Change_Edition_Zone_Center_Y)
ON_EN_CHANGE(IDC_Edition_Zone_Center_Z, On_Change_Edition_Zone_Center_Z)
ON_EN_CHANGE(IDC_Edition_Zone_Radius, On_Change_Edition_Zone_Radius)
ON_WM_HSCROLL()
ON_BN_CLICKED(IDC_Button_Init, On_Button_Init)
ON_WM_DESTROY()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - OnInitDialog
// initialisation of the window
//-----------------------------------------------------------------------------
BOOL CZDxSphereInfoWindow::OnInitDialog()
{
CDialog::OnInitDialog();
RefreshData (); // Init the variables
// Register the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vRegisterControlID (IDC_Edition_Zone_Center_X , "TUT_SphereX" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Center_Y , "TUT_SphereY" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Center_Z , "TUT_SphereZ" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Radius , "TUT_Radius" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Slider_Radius , "TUT_RadiusSlider" , TUT_e_Slider);
TUT_M_vRegisterControlID (IDC_Button_Init , "TUT_SphereInit" , TUT_e_Button);
return TRUE;
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - SetZDxObjectToEdit
// set the ZDx object to edit :
// we fill the different fields in the window with the data of a ZDx object
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::SetZDxShapeToEdit (ZDx_Shape * _pZDxShape)
{
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pZDxSphere = _pZDxShape;
m_pSphere3D = (Sphere3D *) _pZDxShape -> GetGeometric3dObject ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData ();
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - On_Change_Edition_Zone_Center_X
// this function is called when the user changes the X coordinate of the center
// we update the variable
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::On_Change_Edition_Zone_Center_X ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pSphere3D -> SetCenterX ((float) atof (m_Edition_Zone_Center_X));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxSphere -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - On_Change_Edition_Zone_Center_Y
// this function is called when the user changes the Y coordinate of the center
// we update the variable
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::On_Change_Edition_Zone_Center_Y ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pSphere3D -> SetCenterY ((float) atof (m_Edition_Zone_Center_Y));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxSphere -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - On_Change_Edition_Zone_Center_Z
// this function is called when the user changes the Z coordinate of the center
// we update the variable
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::On_Change_Edition_Zone_Center_Z ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pSphere3D -> SetCenterZ ((float) atof (m_Edition_Zone_Center_Z));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxSphere -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - On_Change_Edition_Zone_Radius
// this function is called when the user changes the radius of the sphere
// we update the variable
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::On_Change_Edition_Zone_Radius ()
{
UpdateData (TRUE); // Update variables from screen
float Radius = (float) atof (m_Edition_Zone_Radius);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
if (! m_pSphere3D -> SetRadius (& Radius))
//ENDROMTEAM WorldEditor (Cristi Petrescu)
{ // Not a correct value : the correct value is stored in Radius. We show it
m_Edition_Zone_Radius . Format ("%.4g" , Radius);
UpdateData (FALSE);
}
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxSphere -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - RefreshSlider
// Refresh the position of the slider
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::RefreshSlider ()
{
m_Slider_Radius . SetOwner (this);
m_Slider_Radius . SetRange (0 , 150 , TRUE);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_Slider_Radius . SetPos ((long) (m_pSphere3D -> GetRadius () / m_FatherRadius * 100));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Slider_Radius . SetTicFreq (50);
UpdateData (FALSE);
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - RefreshRadiusFromSlider
// Refresh the radius of the sphere when the position of the slider has changed
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::RefreshRadiusFromSlider ()
{
UpdateData (TRUE);
MTH_tdxReal NewRadius = (float) (m_FatherRadius * m_Slider_Radius . GetPos () / 100.0);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pSphere3D -> SetRadius (& NewRadius);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Edition_Zone_Radius . Format ("%.4g" , NewRadius);
UpdateData (FALSE);
m_pZDxSphere -> RedrawZDxObject ();
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - RefreshData
// this function is called when the data need to be refreshed
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::RefreshData ()
{
// Init the variables on the screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
MTH3D_tdstVector Center = m_pSphere3D -> GetCenter ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Edition_Zone_Center_X . Format ("%.4g" , Center . xX);
m_Edition_Zone_Center_Y . Format ("%.4g" , Center . xY);
m_Edition_Zone_Center_Z . Format ("%.4g" , Center . xZ);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_Edition_Zone_Radius . Format ("%.4g" , m_pSphere3D -> GetRadius ());
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshSlider ();
UpdateData (FALSE); // Update the screen
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - GetFirstControlOfWindow
// Get the first control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxSphereInfoWindow::GetFirstControlOfWindow ()
{
return GetDlgItem (IDC_Edition_Zone_Center_X);
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - GetLastControlOfWindow
// Get the last control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxSphereInfoWindow::GetLastControlOfWindow ()
{
return GetDlgItem (IDC_Edition_Zone_Radius);
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - OnHScroll
// Call when the slider is changed
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::OnHScroll(UINT nSBCode , UINT nPos , CScrollBar * pScrollBar)
{
if (pScrollBar == (void *) & m_Slider_Radius) RefreshRadiusFromSlider ();
else CDialog::OnHScroll (nSBCode , nPos , pScrollBar);
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - On_Button_Init
// Call when the user clics on the Init button : we reinit the position and the size of the sphere
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::On_Button_Init ()
{
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pSphere3D -> SetRadius (& m_FatherRadius);
m_pSphere3D -> SetCenter (& m_FatherCenter);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData ();
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxSphere -> RedrawZDxObject ();
((CZDxInfoWindow *) GetParent ()) -> Apply ();
}
//-----------------------------------------------------------------------------
// class CZDxSphereInfoWindow - OnDestroy
// Call when the window is destroy
//-----------------------------------------------------------------------------
void CZDxSphereInfoWindow::OnDestroy ()
{
// Unregister the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Center_X);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Center_Y);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Center_Z);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Radius );
TUT_M_vUnregisterControlID (IDC_Slider_Radius );
TUT_M_vUnregisterControlID (IDC_Button_Init );
CZDxShapeInfoWindow::OnDestroy ();
}
//*****************************************************************************
// class CZDxBoxInfoWindow
//
// Window that shows informations about a ZDx box object
//*****************************************************************************
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow
// general functions
//-----------------------------------------------------------------------------
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
CZDxBoxInfoWindow::CZDxBoxInfoWindow (CWnd * _pParent , ZDx_Shape * _pObject , CPA_SuperObject * _pFatherSuperObject ,
ZDx_Interface * _pZDxInterface)
//ENDROMTEAM WorldEditor (Cristi Petrescu)
{
// Call the CDialog constructor
CDialog::CDialog (CZDxBoxInfoWindow::IDD, _pParent);
//{{AFX_DATA_INIT(CZDxBoxInfoWindow)
m_Radio_Button = -1;
m_Check_Box_Cube = FALSE;
m_Edition_Zone_Center_X = _T("");
m_Edition_Zone_Center_Y = _T("");
m_Edition_Zone_Center_Z = _T("");
m_Edition_Zone_Height = _T("");
m_Edition_Zone_Length = _T("");
m_Edition_Zone_Width = _T("");
m_Edition_Zone_X_Maxi = _T("");
m_Edition_Zone_X_Mini = _T("");
m_Edition_Zone_Y_Maxi = _T("");
m_Edition_Zone_Y_Mini = _T("");
m_Edition_Zone_Z_Maxi = _T("");
m_Edition_Zone_Z_Mini = _T("");
//}}AFX_DATA_INIT
// Store the pointer to the ZDx box object
m_pZDxBox = _pObject;
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D = (Box3D *) _pObject -> GetGeometric3dObject ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
// Compute size of the father
if (_pFatherSuperObject)
{
_pZDxInterface -> ComputeInitialSizeOfBox (_pFatherSuperObject , & m_FatherMinPoint , & m_FatherMaxPoint);
MTH3D_tdstVector Difference;
MTH3D_M_vSubVector (& Difference , & m_FatherMaxPoint , & m_FatherMinPoint);
m_FatherAverageSize = (MTH3D_M_xGetXofVector (& Difference) + MTH3D_M_xGetYofVector (& Difference) +
MTH3D_M_xGetZofVector (& Difference)) / 3.0;
}
else m_FatherAverageSize = 1.0;
// Create the window
Create (IDD_ZDD_Box_Info_Window , _pParent);
}
void CZDxBoxInfoWindow::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CZDxBoxInfoWindow)
DDX_Radio(pDX, IDC_Radio_Button_Center, m_Radio_Button);
DDX_Check(pDX, IDC_Check_Box_Cube, m_Check_Box_Cube);
DDX_Text(pDX, IDC_Edition_Zone_Center_X, m_Edition_Zone_Center_X);
DDX_Text(pDX, IDC_Edition_Zone_Center_Y, m_Edition_Zone_Center_Y);
DDX_Text(pDX, IDC_Edition_Zone_Center_Z, m_Edition_Zone_Center_Z);
DDX_Text(pDX, IDC_Edition_Zone_Height, m_Edition_Zone_Height);
DDX_Text(pDX, IDC_Edition_Zone_Length, m_Edition_Zone_Length);
DDX_Text(pDX, IDC_Edition_Zone_Width, m_Edition_Zone_Width);
DDX_Text(pDX, IDC_Edition_Zone_X_Maxi, m_Edition_Zone_X_Maxi);
DDX_Text(pDX, IDC_Edition_Zone_X_Mini, m_Edition_Zone_X_Mini);
DDX_Text(pDX, IDC_Edition_Zone_Y_Maxi, m_Edition_Zone_Y_Maxi);
DDX_Text(pDX, IDC_Edition_Zone_Y_Mini, m_Edition_Zone_Y_Mini);
DDX_Text(pDX, IDC_Edition_Zone_Z_Maxi, m_Edition_Zone_Z_Maxi);
DDX_Text(pDX, IDC_Edition_Zone_Z_Mini, m_Edition_Zone_Z_Mini);
DDX_Control(pDX, IDC_Slider_Size, m_Slider_Size);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CZDxBoxInfoWindow, CDialog)
//{{AFX_MSG_MAP(CZDxBoxInfoWindow)
ON_BN_CLICKED(IDC_Radio_Button_Center, On_Radio_Button_Center)
ON_BN_CLICKED(IDC_Radio_Button_Extrema, On_Radio_Button_Extrema)
ON_EN_CHANGE(IDC_Edition_Zone_X_Mini, On_Change_Edition_Zone_X_Mini)
ON_EN_CHANGE(IDC_Edition_Zone_Y_Mini, On_Change_Edition_Zone_Y_Mini)
ON_EN_CHANGE(IDC_Edition_Zone_Z_Mini, On_Change_Edition_Zone_Z_Mini)
ON_EN_CHANGE(IDC_Edition_Zone_X_Maxi, On_Change_Edition_Zone_X_Maxi)
ON_EN_CHANGE(IDC_Edition_Zone_Y_Maxi, On_Change_Edition_Zone_Y_Maxi)
ON_EN_CHANGE(IDC_Edition_Zone_Z_Maxi, On_Change_Edition_Zone_Z_Maxi)
ON_EN_CHANGE(IDC_Edition_Zone_Center_X, On_Change_Edition_Zone_Center_X)
ON_EN_CHANGE(IDC_Edition_Zone_Center_Y, On_Change_Edition_Zone_Center_Y)
ON_EN_CHANGE(IDC_Edition_Zone_Center_Z, On_Change_Edition_Zone_Center_Z)
ON_EN_CHANGE(IDC_Edition_Zone_Length, On_Change_Edition_Zone_Length)
ON_EN_CHANGE(IDC_Edition_Zone_Width, On_Change_Edition_Zone_Width)
ON_EN_CHANGE(IDC_Edition_Zone_Height, On_Change_Edition_Zone_Height)
ON_BN_CLICKED(IDC_Check_Box_Cube, On_Check_Box_Cube)
ON_WM_HSCROLL()
ON_BN_CLICKED(IDC_Button_Init, On_Button_Init)
ON_WM_DESTROY()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - OnInitDialog
// initialisation of the window
//-----------------------------------------------------------------------------
BOOL CZDxBoxInfoWindow::OnInitDialog()
{
CDialog::OnInitDialog();
m_Radio_Button = 0; // we show the Center screen
RefreshData (); // Init the other variables
// Register the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vRegisterControlID (IDC_Radio_Button_Center , "TUT_BoxCenter" , TUT_e_Button);
TUT_M_vRegisterControlID (IDC_Radio_Button_Extrema , "TUT_BoxExtrema" , TUT_e_Button);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Center_X , "TUT_BoxCenterX" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Center_Y , "TUT_BoxCenterY" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Center_Z , "TUT_BoxCenterZ" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Length , "TUT_BoxLength" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Width , "TUT_BoxWidth" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Height , "TUT_BoxHeight" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_X_Mini , "TUT_XMin" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Y_Mini , "TUT_YMin" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Z_Mini , "TUT_ZMin" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_X_Maxi , "TUT_XMax" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Y_Maxi , "TUT_YMax" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Z_Maxi , "TUT_ZMax" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Check_Box_Cube , "TUT_Cube" , TUT_e_Button);
TUT_M_vRegisterControlID (IDC_Slider_Size , "TUT_SizeSlider" , TUT_e_Slider);
TUT_M_vRegisterControlID (IDC_Button_Init , "TUT_BoxInit" , TUT_e_Button);
return TRUE;
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - SetZDxObjectToEdit
// set the ZDx object to edit :
// we fill the different fields in the window with the data of a ZDx object
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::SetZDxShapeToEdit (ZDx_Shape * _pZDxShape)
{
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pZDxBox = _pZDxShape;
m_pBox3D = (Box3D *) _pZDxShape -> GetGeometric3dObject ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Radio_Button_Center
// clic on the radio button Center : we show the fields for the center
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Radio_Button_Center ()
{
m_Radio_Button = 0;
// Fill the variables for the screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
MTH3D_tdstVector Center = m_pBox3D->GetCenter ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Edition_Zone_Center_X . Format ("%.4g" , Center . xX);
m_Edition_Zone_Center_Y . Format ("%.4g" , Center . xY);
m_Edition_Zone_Center_Z . Format ("%.4g" , Center . xZ);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_Edition_Zone_Length . Format ("%.4g" , m_pBox3D->GetLength ());
m_Edition_Zone_Width . Format ("%.4g" , m_pBox3D->GetWidth ());
m_Edition_Zone_Height . Format ("%.4g" , m_pBox3D->GetHeight ());
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
// Hide the items for the extrema screen
GetDlgItem (IDC_Frame_Mini) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_X_Mini) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Y_Mini) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Z_Mini) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_X_Mini) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Y_Mini) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Z_Mini) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Frame_Maxi) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_X_Maxi) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Y_Maxi) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Z_Maxi) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_X_Maxi) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Y_Maxi) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Z_Maxi) -> ShowWindow (SW_HIDE);
// Show the items for the Center screen
GetDlgItem (IDC_Frame_Center) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Center_X) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Center_Y) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Center_Z) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Length) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Width) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Height) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Center_X) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Center_Y) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Center_Z) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Length) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Width) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Height) -> ShowWindow (SW_SHOW);
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Radio_Button_Extrema
// clic on the radio button Center : we show the fields for the extrema
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Radio_Button_Extrema ()
{
m_Radio_Button = 1;
// Fill the variables for the screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
MTH3D_tdstVector MinPoint = m_pBox3D->GetMinPoint ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Edition_Zone_X_Mini . Format ("%.4g" , MinPoint . xX);
m_Edition_Zone_Y_Mini . Format ("%.4g" , MinPoint . xY);
m_Edition_Zone_Z_Mini . Format ("%.4g" , MinPoint . xZ);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
MTH3D_tdstVector MaxPoint = m_pBox3D->GetMaxPoint ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Edition_Zone_X_Maxi . Format ("%.4g" , MaxPoint . xX);
m_Edition_Zone_Y_Maxi . Format ("%.4g" , MaxPoint . xY);
m_Edition_Zone_Z_Maxi . Format ("%.4g" , MaxPoint . xZ);
UpdateData (FALSE); // Update the screen
// Hide the items for the Center screen
GetDlgItem (IDC_Frame_Center) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Center_X) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Center_Y) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Center_Z) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Length) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Width) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Static_Text_Height) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Center_X) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Center_Y) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Center_Z) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Length) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Width) -> ShowWindow (SW_HIDE);
GetDlgItem (IDC_Edition_Zone_Height) -> ShowWindow (SW_HIDE);
// Show the items for the extrema screen
GetDlgItem (IDC_Frame_Mini) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_X_Mini) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Y_Mini) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Z_Mini) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_X_Mini) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Y_Mini) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Z_Mini) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Frame_Maxi) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_X_Maxi) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Y_Maxi) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Static_Text_Z_Maxi) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_X_Maxi) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Y_Maxi) -> ShowWindow (SW_SHOW);
GetDlgItem (IDC_Edition_Zone_Z_Maxi) -> ShowWindow (SW_SHOW);
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Center_X
// this function is called when the user changes the X coordinate of the center :
// we update the variable
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Center_X ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetCenterX ((float) atof (m_Edition_Zone_Center_X));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Center_Y
// this function is called when the user changes the X coordinate of the center :
// we update the variable
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Center_Y ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetCenterY ((float) atof (m_Edition_Zone_Center_Y));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Center_Z
// this function is called when the user changes the Z coordinate of the center :
// we update the variable
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Center_Z ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetCenterZ ((float) atof (m_Edition_Zone_Center_Z));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Length
// this function is called when the user changes the length of the box : we update the variables
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Length ()
{
UpdateData (TRUE); // Update variables from screen
float Length = (float) atof (m_Edition_Zone_Length);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
BOOL CorrectValue = m_pBox3D -> SetLength (& Length);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (m_ZDxIsACube) // If it is a cube, we must change width and height
{
m_Edition_Zone_Width = m_Edition_Zone_Height = m_Edition_Zone_Length;
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
CorrectValue &= m_pBox3D -> SetWidth (& Length);
CorrectValue &= m_pBox3D -> SetHeight (& Length);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
}
// If one of the given value is not correct (negative), we refresh the display
if (! CorrectValue) RefreshData (TRUE);
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Width
// this function is called when the user changes the width of the box : we update the variables
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Width ()
{
UpdateData (TRUE); // Update variables from screen
float Width = (float) atof (m_Edition_Zone_Width);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
BOOL CorrectValue = m_pBox3D -> SetWidth (& Width);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (m_ZDxIsACube) // If it is a cube, we must change length and height
{
m_Edition_Zone_Length = m_Edition_Zone_Height = m_Edition_Zone_Width;
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
CorrectValue &= m_pBox3D -> SetLength (& Width);
CorrectValue &= m_pBox3D -> SetHeight (& Width);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
}
// If one of the given value is not correct (negative), we refresh the display
if (! CorrectValue) RefreshData (TRUE);
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Height
// this function is called when the user changes the height of the box : we update the variables
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Height ()
{
UpdateData (TRUE); // Update variables from screen
float Height = (float) atof (m_Edition_Zone_Height);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
BOOL CorrectValue = m_pBox3D -> SetHeight (& Height);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (m_ZDxIsACube) // If it is a cube, we must change length and width
{
m_Edition_Zone_Length = m_Edition_Zone_Width = m_Edition_Zone_Height;
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
CorrectValue &= m_pBox3D -> SetLength (& Height);
CorrectValue &= m_pBox3D -> SetWidth (& Height);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
}
// If one of the given value is not correct (negative), we refresh the display
if (! CorrectValue) RefreshData (TRUE);
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_X_Mini
// this function is called when the user changes the X coordinate of the min point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_X_Mini()
{
UpdateData (TRUE); // Update variables from screen
float X_Mini = (float) atof (m_Edition_Zone_X_Mini);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
BOOL CorrectValue = m_pBox3D -> SetMinPointX (& X_Mini);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (m_ZDxIsACube) // If it is a cube, we must change Y_Mini and Z_Mini too
{
float Y_Mini = (float) (atof (m_Edition_Zone_Y_Maxi) - atof (m_Edition_Zone_X_Maxi) + X_Mini);
float Z_Mini = (float) (atof (m_Edition_Zone_Z_Maxi) - atof (m_Edition_Zone_X_Maxi) + X_Mini);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetMinPointY (& Y_Mini);
m_pBox3D -> SetMinPointZ (& Z_Mini);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData (TRUE);
UpdateData (FALSE); // Update the screen
}
else if (! CorrectValue) RefreshData (TRUE);
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Y_Mini
// this function is called when the user changes the Y coordinate of the min point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Y_Mini()
{
UpdateData (TRUE); // Update variables from screen
float Y_Mini = (float) atof (m_Edition_Zone_Y_Mini);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
BOOL CorrectValue = m_pBox3D -> SetMinPointY (& Y_Mini);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (m_ZDxIsACube) // If it is a cube, we must change X_Mini and Z_Mini too
{
float X_Mini = (float) (atof (m_Edition_Zone_X_Maxi) - atof (m_Edition_Zone_Y_Maxi) + Y_Mini);
float Z_Mini = (float) (atof (m_Edition_Zone_Z_Maxi) - atof (m_Edition_Zone_Y_Maxi) + Y_Mini);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetMinPointX (& X_Mini);
m_pBox3D -> SetMinPointZ (& Z_Mini);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData (TRUE);
UpdateData (FALSE); // Update the screen
}
else if (! CorrectValue) RefreshData (TRUE);
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Z_Mini
// this function is called when the user changes the Z coordinate of the min point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Z_Mini()
{
UpdateData (TRUE); // Update variables from screen
float Z_Mini = (float) atof (m_Edition_Zone_Z_Mini);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
BOOL CorrectValue = m_pBox3D -> SetMinPointZ (& Z_Mini);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (m_ZDxIsACube) // If it is a cube, we must change X_Mini and Y_Mini too
{
float X_Mini = (float) (atof (m_Edition_Zone_X_Maxi) - atof (m_Edition_Zone_Z_Maxi) + Z_Mini);
float Y_Mini = (float) (atof (m_Edition_Zone_Y_Maxi) - atof (m_Edition_Zone_Z_Maxi) + Z_Mini);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetMinPointX (& X_Mini);
m_pBox3D -> SetMinPointY (& Y_Mini);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData (TRUE);
UpdateData (FALSE); // Update the screen
}
else if (! CorrectValue) RefreshData (TRUE);
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_X_Maxi
// this function is called when the user changes the X coordinate of the max point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_X_Maxi()
{
UpdateData (TRUE); // Update variables from screen
float X_Maxi = (float) atof (m_Edition_Zone_X_Maxi);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
BOOL CorrectValue = m_pBox3D -> SetMaxPointX (& X_Maxi);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (m_ZDxIsACube) // If it is a cube, we must change Y_Maxi and Z_Maxi too
{
float Y_Maxi = (float) (atof (m_Edition_Zone_Y_Mini) + X_Maxi - atof (m_Edition_Zone_X_Mini));
float Z_Maxi = (float) (atof (m_Edition_Zone_Z_Mini) + X_Maxi - atof (m_Edition_Zone_X_Mini));
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetMaxPointY (& Y_Maxi);
m_pBox3D -> SetMaxPointZ (& Z_Maxi);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData (TRUE);
UpdateData (FALSE); // Update the screen
}
else if (! CorrectValue) RefreshData (TRUE);
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Y_Maxi
// this function is called when the user changes the Y coordinate of the max point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Y_Maxi()
{
UpdateData (TRUE); // Update variables from screen
float Y_Maxi = (float) atof (m_Edition_Zone_Y_Maxi);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
BOOL CorrectValue = m_pBox3D -> SetMaxPointY (& Y_Maxi);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (m_ZDxIsACube) // If it is a cube, we must change X_Maxi and Z_Maxi too
{
float X_Maxi = (float) (atof (m_Edition_Zone_X_Mini) + Y_Maxi - atof (m_Edition_Zone_Y_Mini));
float Z_Maxi = (float) (atof (m_Edition_Zone_Z_Mini) + Y_Maxi - atof (m_Edition_Zone_Y_Mini));
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetMaxPointX (& X_Maxi);
m_pBox3D -> SetMaxPointZ (& Z_Maxi);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData (TRUE);
UpdateData (FALSE); // Update the screen
}
else if (! CorrectValue) RefreshData (TRUE);
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Change_Edition_Zone_Z_Maxi
// this function is called when the user changes the Z coordinate of the max point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Change_Edition_Zone_Z_Maxi()
{
UpdateData (TRUE); // Update variables from screen
float Z_Maxi = (float) atof (m_Edition_Zone_Z_Maxi);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
BOOL CorrectValue = m_pBox3D -> SetMaxPointZ (& Z_Maxi);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
if (m_ZDxIsACube) // If it is a cube, we must change X_Maxi and Y_Maxi too
{
float X_Maxi = (float) (atof (m_Edition_Zone_X_Mini) + Z_Maxi - atof (m_Edition_Zone_Z_Mini));
float Y_Maxi = (float) (atof (m_Edition_Zone_Y_Mini) + Z_Maxi - atof (m_Edition_Zone_Z_Mini));
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetMaxPointX (& X_Maxi);
m_pBox3D -> SetMaxPointY (& Y_Maxi);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData (TRUE);
UpdateData (FALSE); // Update the screen
}
else if (! CorrectValue) RefreshData (TRUE);
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Check_Box_Cube
// this function is called when the user clic on the check box Cube
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Check_Box_Cube()
{
UpdateData (TRUE); // Update variables from screen
m_ZDxIsACube = m_Check_Box_Cube;
if (m_ZDxIsACube) // if the check box Cube is selected, then length, width and height must be equal
{
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
//Box3D * p = m_pBox3D; // pointer to the ZDx box object
GLI_tdxValue L = (m_pBox3D->GetLength () + m_pBox3D->GetWidth () + m_pBox3D->GetHeight ()) / 3;
m_pBox3D->SetLength (& L);
m_pBox3D->SetWidth (& L);
m_pBox3D->SetHeight (& L);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
// update the screen
if (m_Radio_Button == 0) On_Radio_Button_Center ();
else On_Radio_Button_Extrema ();
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
RefreshSlider ();
m_pZDxBox -> RedrawZDxObject ();
}
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - RefreshSlider
// Refresh the position of the slider
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::RefreshSlider ()
{
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
double BoxAverageSize = (m_pBox3D -> GetLength () + m_pBox3D -> GetWidth () + m_pBox3D -> GetHeight ()) / 3.0;
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Slider_Size . SetOwner (this);
m_Slider_Size . SetRange (0 , 150 , TRUE);
m_Slider_Size . SetPos ((long) (BoxAverageSize / m_FatherAverageSize * 100));
m_Slider_Size . SetTicFreq (50);
UpdateData (FALSE);
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - RefreshSizeFromSlider
// Refresh the size of the box when the position of the slider has changed
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::RefreshSizeFromSlider ()
{
float OldBoxAverageSize, NewBoxAverageSize;
float NewLength, NewWidth, NewHeight;
float Coef;
UpdateData (TRUE);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
OldBoxAverageSize = (float) ((m_pBox3D -> GetLength () + m_pBox3D -> GetWidth () + m_pBox3D -> GetHeight ()) / 3.0);
NewBoxAverageSize = (float) (m_FatherAverageSize * m_Slider_Size . GetPos () / 100.0);
if (!OldBoxAverageSize)
{
MTH3D_tdstVector Difference;
MTH3D_M_vSubVector (& Difference , & m_FatherMaxPoint , & m_FatherMinPoint);
NewLength = NewBoxAverageSize * MTH3D_M_xGetXofVector (& Difference);
NewWidth = NewBoxAverageSize * MTH3D_M_xGetYofVector (& Difference);
NewHeight = NewBoxAverageSize * MTH3D_M_xGetZofVector (& Difference);
}
else
{
Coef = NewBoxAverageSize / OldBoxAverageSize;
NewLength = m_pBox3D -> GetLength () * Coef;
NewWidth = m_pBox3D -> GetWidth () * Coef;
NewHeight = m_pBox3D -> GetHeight () * Coef;
}
m_pBox3D -> SetLength (& NewLength);
m_pBox3D -> SetWidth (& NewWidth);
m_pBox3D -> SetHeight (& NewHeight);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData (TRUE);
m_pZDxBox -> RedrawZDxObject ();
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - RefreshData
// this function is called when the data need to be refreshed (because of a Undo, for instance)
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::RefreshData (BOOL _bKeepCube)
{
// Init the variables
if (! _bKeepCube) m_Check_Box_Cube = m_ZDxIsACube = FALSE;
// Init the variables on the screen
if (m_Radio_Button == 0) On_Radio_Button_Center ();
else On_Radio_Button_Extrema ();
RefreshSlider ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - RefreshData
// this function is called when the data need to be refreshed (because of a Undo, for instance)
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::RefreshData ()
{
RefreshData (FALSE);
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - GetFirstControlOfWindow
// Get the first control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxBoxInfoWindow::GetFirstControlOfWindow ()
{
return m_Radio_Button == 0 ? GetDlgItem (IDC_Radio_Button_Center)
: GetDlgItem (IDC_Edition_Zone_X_Mini);
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - GetLastControlOfWindow
// Get the last control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxBoxInfoWindow::GetLastControlOfWindow ()
{
return GetDlgItem (IDC_Check_Box_Cube);
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - OnHScroll
// Call when the slider is changed
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::OnHScroll(UINT nSBCode , UINT nPos , CScrollBar * pScrollBar)
{
if (pScrollBar == (void *) & m_Slider_Size) RefreshSizeFromSlider ();
else CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - On_Button_Init
// Call when the user clics on the Init button : we reinit the position and the size of the box
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::On_Button_Init ()
{
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pBox3D -> SetMinPoint (& m_FatherMinPoint);
m_pBox3D -> SetMaxPoint (& m_FatherMaxPoint);
m_pBox3D -> SetMinPoint (& m_FatherMinPoint);
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData ();
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxBox -> RedrawZDxObject ();
((CZDxInfoWindow *) GetParent ()) -> Apply ();
}
//-----------------------------------------------------------------------------
// class CZDxBoxInfoWindow - OnDestroy
// Call when the window is destroyed
//-----------------------------------------------------------------------------
void CZDxBoxInfoWindow::OnDestroy ()
{
// Unregister the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vUnregisterControlID (IDC_Radio_Button_Center );
TUT_M_vUnregisterControlID (IDC_Radio_Button_Extrema );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Center_X);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Center_Y);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Center_Z);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Length );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Width );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Height );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_X_Mini );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Y_Mini );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Z_Mini );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_X_Maxi );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Y_Maxi );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Z_Maxi );
TUT_M_vUnregisterControlID (IDC_Check_Box_Cube );
TUT_M_vUnregisterControlID (IDC_Slider_Size );
TUT_M_vUnregisterControlID (IDC_Button_Init );
CZDxShapeInfoWindow::OnDestroy ();
}
//*****************************************************************************
// class CZDxPointInfoWindow
//
// Window that shows informations about a ZDx Point object
//*****************************************************************************
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow
// general functions
//-----------------------------------------------------------------------------
CZDxPointInfoWindow::CZDxPointInfoWindow(CWnd* _pParent , ZDx_Point * _pObject)
{
// Call the CDialog constructor
CDialog::CDialog(CZDxPointInfoWindow::IDD, _pParent);
//{{AFX_DATA_INIT(CZDxPointInfoWindow)
m_Edition_Zone_X = _T("");
m_Edition_Zone_Y = _T("");
m_Edition_Zone_Z = _T("");
//}}AFX_DATA_INIT
// Store the pointer to the ZDx box object
m_pZDxPoint = _pObject;
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pPoint3D = (Point3D *) _pObject -> GetGeometric3dObject ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
// Create the window
Create (IDD_ZDD_Point_Info_Window , _pParent);
}
void CZDxPointInfoWindow::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CZDxPointInfoWindow)
DDX_Text(pDX, IDC_Edition_Zone_X, m_Edition_Zone_X);
DDX_Text(pDX, IDC_Edition_Zone_Y, m_Edition_Zone_Y);
DDX_Text(pDX, IDC_Edition_Zone_Z, m_Edition_Zone_Z);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CZDxPointInfoWindow, CDialog)
//{{AFX_MSG_MAP(CZDxPointInfoWindow)
ON_EN_CHANGE(IDC_Edition_Zone_X, On_Change_Edition_Zone_X)
ON_EN_CHANGE(IDC_Edition_Zone_Y, On_Change_Edition_Zone_Y)
ON_EN_CHANGE(IDC_Edition_Zone_Z, On_Change_Edition_Zone_Z)
ON_WM_DESTROY()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow - OnInitDialog
// initialisation of the window
//-----------------------------------------------------------------------------
BOOL CZDxPointInfoWindow::OnInitDialog()
{
CDialog::OnInitDialog();
RefreshData (); // Init the variables
// Register the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vRegisterControlID (IDC_Edition_Zone_X , "TUT_PointX" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Y , "TUT_PointY" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Z , "TUT_PointZ" , TUT_e_TextEdit);
return TRUE;
}
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow - SetZDxObjectToEdit
// set the ZDx object to edit :
// we fill the different fields in the window with the data of a ZDx object
//-----------------------------------------------------------------------------
void CZDxPointInfoWindow::SetZDxShapeToEdit (ZDx_Shape * _pZDxShape)
{
m_pZDxPoint = (ZDx_Point *) _pZDxShape;
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pPoint3D = (Point3D *) _pZDxShape -> GetGeometric3dObject ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData ();
}
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow - On_Change_Edition_Zone_X
// this function is called when the user changes the X coordinate of the point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxPointInfoWindow::On_Change_Edition_Zone_X ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pPoint3D -> SetPointX ((float) atof (m_Edition_Zone_X));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxPoint -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow - On_Change_Edition_Zone_Y
// this function is called when the user changes the Y coordinate of the point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxPointInfoWindow::On_Change_Edition_Zone_Y ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pPoint3D -> SetPointY ((float) atof (m_Edition_Zone_Y));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxPoint -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow - On_Change_Edition_Zone_Z
// this function is called when the user changes the Z coordinate of the point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxPointInfoWindow::On_Change_Edition_Zone_Z ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pPoint3D -> SetPointZ ((float) atof (m_Edition_Zone_Z));
//ENDROMTEAM WorldEditor (Cristi Petrescu)
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxPoint -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow - RefreshData
// this function is called when the data need to be refreshed (because of a Undo, for instance)
//-----------------------------------------------------------------------------
void CZDxPointInfoWindow::RefreshData ()
{
// Init the variables on the screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
MTH3D_tdstVector Point = m_pPoint3D -> GetPoint ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Edition_Zone_X . Format ("%.4g" , Point . xX);
m_Edition_Zone_Y . Format ("%.4g" , Point . xY);
m_Edition_Zone_Z . Format ("%.4g" , Point . xZ);
UpdateData (FALSE); // Update the screen
}
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow - GetFirstControlOfWindow
// Get the first control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxPointInfoWindow::GetFirstControlOfWindow ()
{
return GetDlgItem (IDC_Edition_Zone_X);
}
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow - GetLastControlOfWindow
// Get the last control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxPointInfoWindow::GetLastControlOfWindow ()
{
return GetDlgItem (IDC_Edition_Zone_Z);
}
//-----------------------------------------------------------------------------
// class CZDxPointInfoWindow - OnDestroy
// Call when the window is destroyed
//-----------------------------------------------------------------------------
void CZDxPointInfoWindow::OnDestroy ()
{
// Unregister the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vUnregisterControlID (IDC_Edition_Zone_X);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Y);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Z);
CZDxShapeInfoWindow::OnDestroy ();
}
//*****************************************************************************
// class CZDxConeInfoWindow
//
// Window that shows informations about a ZDx Cone object
//*****************************************************************************
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow
// general functions
//-----------------------------------------------------------------------------
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
CZDxConeInfoWindow::CZDxConeInfoWindow(CWnd* _pParent , ZDx_Shape * _pObject)
//ENDROMTEAM WorldEditor (Cristi Petrescu)
{
// Call the CDialog constructor
CDialog::CDialog(CZDxConeInfoWindow::IDD, _pParent);
//{{AFX_DATA_INIT(CZDxConeInfoWindow)
m_Edition_Zone_Angle = _T("");
m_Edition_Zone_Radius = _T("");
m_Edition_Zone_X_Base = _T("");
m_Edition_Zone_X_Top = _T("");
m_Edition_Zone_Y_Base = _T("");
m_Edition_Zone_Y_Top = _T("");
m_Edition_Zone_Z_Base = _T("");
m_Edition_Zone_Z_Top = _T("");
//}}AFX_DATA_INIT
// Store the pointer to the ZDx box object
m_pZDxCone = _pObject;
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pCone3D = (Cone3D *) _pObject -> GetGeometric3dObject ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
// Create the window
Create (IDD_ZDD_Cone_Info_Window , _pParent);
}
void CZDxConeInfoWindow::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CZDxConeInfoWindow)
DDX_Text(pDX, IDC_Edition_Zone_Angle, m_Edition_Zone_Angle);
DDX_Text(pDX, IDC_Edition_Zone_Radius, m_Edition_Zone_Radius);
DDX_Text(pDX, IDC_Edition_Zone_X_Base, m_Edition_Zone_X_Base);
DDX_Text(pDX, IDC_Edition_Zone_X_Top, m_Edition_Zone_X_Top);
DDX_Text(pDX, IDC_Edition_Zone_Y_Base, m_Edition_Zone_Y_Base);
DDX_Text(pDX, IDC_Edition_Zone_Y_Top, m_Edition_Zone_Y_Top);
DDX_Text(pDX, IDC_Edition_Zone_Z_Base, m_Edition_Zone_Z_Base);
DDX_Text(pDX, IDC_Edition_Zone_Z_Top, m_Edition_Zone_Z_Top);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CZDxConeInfoWindow, CDialog)
//{{AFX_MSG_MAP(CZDxConeInfoWindow)
ON_EN_CHANGE(IDC_Edition_Zone_Angle, On_Change_Edition_Zone_Angle)
ON_EN_CHANGE(IDC_Edition_Zone_Radius, On_Change_Edition_Zone_Radius)
ON_EN_CHANGE(IDC_Edition_Zone_X_Base, On_Change_Edition_Zone_X_Base)
ON_EN_CHANGE(IDC_Edition_Zone_X_Top, On_Change_Edition_Zone_X_Top)
ON_EN_CHANGE(IDC_Edition_Zone_Y_Base, On_Change_Edition_Zone_Y_Base)
ON_EN_CHANGE(IDC_Edition_Zone_Y_Top, On_Change_Edition_Zone_Y_Top)
ON_EN_CHANGE(IDC_Edition_Zone_Z_Base, On_Change_Edition_Zone_Z_Base)
ON_EN_CHANGE(IDC_Edition_Zone_Z_Top, On_Change_Edition_Zone_Z_Top)
ON_WM_DESTROY()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - OnInitDialog
// initialisation of the window
//-----------------------------------------------------------------------------
BOOL CZDxConeInfoWindow::OnInitDialog()
{
CDialog::OnInitDialog();
RefreshData (); // Init the variables
// Register the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vRegisterControlID (IDC_Edition_Zone_X_Top , "TUT_TopX" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Y_Top , "TUT_TopY" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Z_Top , "TUT_TopZ" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_X_Base , "TUT_BaseX" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Y_Base , "TUT_BaseY" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Z_Base , "TUT_BaseZ" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Radius , "TUT_ConeRadius" , TUT_e_TextEdit);
TUT_M_vRegisterControlID (IDC_Edition_Zone_Angle , "TUT_ConeAngle" , TUT_e_TextEdit);
return TRUE;
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - SetZDxObjectToEdit
// set the ZDx object to edit :
// we fill the different fields in the window with the data of a ZDx object
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::SetZDxShapeToEdit (ZDx_Shape * _pZDxShape)
{
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pZDxCone = _pZDxShape;
m_pCone3D = (Cone3D *) _pZDxShape -> GetGeometric3dObject ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
RefreshData ();
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - On_Change_Edition_Zone_X_Base
// this function is called when the user changes the X coordinate of the base point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::On_Change_Edition_Zone_X_Base ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pCone3D -> SetBasePointX ((float) atof (m_Edition_Zone_X_Base));
m_Edition_Zone_Angle . Format ("%.4g" , m_pCone3D -> GetAngle ()); // The angle changes too
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxCone -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - On_Change_Edition_Zone_Y_Base
// this function is called when the user changes the Y coordinate of the base point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::On_Change_Edition_Zone_Y_Base ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pCone3D -> SetBasePointY ((float) atof (m_Edition_Zone_Y_Base));
m_Edition_Zone_Angle . Format ("%.4g" , m_pCone3D -> GetAngle ()); // The angle changes too
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxCone -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - On_Change_Edition_Zone_Z_Base
// this function is called when the user changes the Z coordinate of the base point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::On_Change_Edition_Zone_Z_Base ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pCone3D -> SetBasePointZ ((float) atof (m_Edition_Zone_Z_Base));
m_Edition_Zone_Angle . Format ("%.4g" , m_pCone3D -> GetAngle ()); // The angle changes too
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxCone -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - On_Change_Edition_Zone_X_Top
// this function is called when the user changes the X coordinate of the top point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::On_Change_Edition_Zone_X_Top ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pCone3D -> SetTopPointX ((float) atof (m_Edition_Zone_X_Top));
m_Edition_Zone_Angle . Format ("%.4g" , m_pCone3D -> GetAngle ()); // The angle changes too
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxCone -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - On_Change_Edition_Zone_Y_Top
// this function is called when the user changes the Y coordinate of the top point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::On_Change_Edition_Zone_Y_Top ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pCone3D -> SetTopPointY ((float) atof (m_Edition_Zone_Y_Top));
m_Edition_Zone_Angle . Format ("%.4g" , m_pCone3D -> GetAngle ()); // The angle changes too
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxCone -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - On_Change_Edition_Zone_Z_Top
// this function is called when the user changes the Z coordinate of the top point
// we update the variable
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::On_Change_Edition_Zone_Z_Top ()
{
UpdateData (TRUE); // Update variables from screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pCone3D -> SetTopPointZ ((float) atof (m_Edition_Zone_Z_Top));
m_Edition_Zone_Angle . Format ("%.4g" , m_pCone3D -> GetAngle ()); // The angle changes too
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxCone -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - On_Change_Edition_Zone_Radius
// this function is called when the user changes the radius of the cone
// we update the variable
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::On_Change_Edition_Zone_Radius ()
{
UpdateData (TRUE); // Update variables from screen
float Radius = (float) atof (m_Edition_Zone_Radius);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pCone3D -> SetRadius (& Radius);
m_Edition_Zone_Angle . Format ("%.4g" , m_pCone3D -> GetAngle ()); // When one changes the radius, the angle changes too
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxCone -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - On_Change_Edition_Zone_Angle
// this function is called when the user changes the angle of the cone
// we update the variable
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::On_Change_Edition_Zone_Angle ()
{
UpdateData (TRUE); // Update variables from screen
float Angle = (float) atof (m_Edition_Zone_Angle);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_pCone3D -> SetAngle (& Angle);
m_Edition_Zone_Radius . Format ("%.4g" , m_pCone3D -> GetRadius ()); // When one changes the angle, the radius changes too
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
SetZDxHasBeenChanged (TRUE); // Indicate that the ZDx changes
m_pZDxCone -> RedrawZDxObject ();
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - RefreshData
// this function is called when the data need to be refreshed (because of a Undo, for instance)
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::RefreshData ()
{
// Init the variables on the screen
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
MTH3D_tdstVector BasePoint = m_pCone3D -> GetBasePoint ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Edition_Zone_X_Base . Format ("%.4g" , BasePoint . xX);
m_Edition_Zone_Y_Base . Format ("%.4g" , BasePoint . xY);
m_Edition_Zone_Z_Base . Format ("%.4g" , BasePoint . xZ);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
MTH3D_tdstVector TopPoint = m_pCone3D -> GetTopPoint ();
//ENDROMTEAM WorldEditor (Cristi Petrescu)
m_Edition_Zone_X_Top . Format ("%.4g" , TopPoint . xX);
m_Edition_Zone_Y_Top . Format ("%.4g" , TopPoint . xY);
m_Edition_Zone_Z_Top . Format ("%.4g" , TopPoint . xZ);
//ROMTEAM WorldEditor (Cristi Petrescu 12/97)
m_Edition_Zone_Radius . Format ("%.4g" , m_pCone3D -> GetRadius ());
m_Edition_Zone_Angle . Format ("%.4g" , m_pCone3D -> GetAngle ());
//ENDROMTEAM WorldEditor (Cristi Petrescu)
UpdateData (FALSE); // Update the screen
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - GetFirstControlOfWindow
// Get the first control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxConeInfoWindow::GetFirstControlOfWindow ()
{
return GetDlgItem (IDC_Edition_Zone_X_Top);
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - GetLastControlOfWindow
// Get the last control of the window
//-----------------------------------------------------------------------------
CWnd * CZDxConeInfoWindow::GetLastControlOfWindow ()
{
return GetDlgItem (IDC_Edition_Zone_Angle);
}
//-----------------------------------------------------------------------------
// class CZDxConeInfoWindow - OnDestroy
// Call when the window is destroyed
//-----------------------------------------------------------------------------
void CZDxConeInfoWindow::OnDestroy ()
{
// Unregister the controls for the tutorial
TUT_M_vGetTutDll ();
TUT_M_vUnregisterControlID (IDC_Edition_Zone_X_Top );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Y_Top );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Z_Top );
TUT_M_vUnregisterControlID (IDC_Edition_Zone_X_Base);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Y_Base);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Z_Base);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Radius);
TUT_M_vUnregisterControlID (IDC_Edition_Zone_Angle );
CZDxShapeInfoWindow::OnDestroy ();
}
Reference in New Issue View Git Blame Copy Permalink