//***************************************************************************** //* _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 (); }