1292 lines
36 KiB
C++
1292 lines
36 KiB
C++
/*=========================================================================
|
|
* DEVDevic.cpp : Implementation of device.
|
|
* This is a part of the CPA project.
|
|
*
|
|
* Version 1.0
|
|
* Creation date 26/06/96
|
|
* Revision date
|
|
*
|
|
*
|
|
* (c) Ubi Studios 1996
|
|
*=======================================================================*/
|
|
|
|
#include "stdafx.h"
|
|
#include "acp_base.h"
|
|
#include "geo.h"
|
|
#include "gli.h"
|
|
#include "col.h"
|
|
#define HieFriend
|
|
#include "spo.h"
|
|
#include "main.h"
|
|
#include "lst.hpp"
|
|
#include "IncTUT.h"
|
|
|
|
#include "itf/CPARes.h"
|
|
#include "itf/DEVDevic.hpp"
|
|
#include "itf/DEVVp3D.hpp"
|
|
//#include "itf/DEVVp2D.hpp"
|
|
#include "itf/DEVMulti.hpp"
|
|
#include "itf/DEVMul3D.hpp"
|
|
#include "itf/CPAProj.hpp"
|
|
#include "itf/cpamworl.hpp"
|
|
#include "itf/StdDLLId.h"
|
|
#include "itf/camdllb.hpp"
|
|
#include "itf/CPAConst.hpp"
|
|
#include "acp_driver.h"
|
|
|
|
#ifdef USE_DIRECTX
|
|
extern "C"
|
|
{
|
|
#include "gliglou\multidrv\inc\dllinter.h"
|
|
}
|
|
#endif
|
|
/*
|
|
#define M_GetParent ((DEV_MultiDevice*)GetWindowParent())
|
|
#define M_GetParentFrame() ((FRMBaseMenu *) (GetParent()->GetParent()->GetParent()))
|
|
#define M_GetParentDialogBar() (&(M_GetParentFrame()->m_oGeneralDialogBar))
|
|
*/
|
|
// type of Device.
|
|
#define DEV_NORMAL 0
|
|
#define DEV_BACKGROUND 1
|
|
|
|
BEGIN_MESSAGE_MAP(DEV_Device, CWnd)
|
|
//{{AFX_MSG_MAP(DEV_Device)
|
|
ON_WM_DESTROY()
|
|
ON_WM_SIZE()
|
|
ON_WM_MOUSEACTIVATE()
|
|
ON_WM_CREATE()
|
|
ON_WM_WINDOWPOSCHANGING()
|
|
ON_WM_WINDOWPOSCHANGED()
|
|
ON_WM_PAINT()
|
|
ON_WM_SYSCOMMAND()
|
|
ON_WM_NCACTIVATE()
|
|
|
|
ON_WM_NCHITTEST()
|
|
ON_WM_SIZING()
|
|
ON_WM_NCLBUTTONDBLCLK()
|
|
ON_WM_NCCALCSIZE()
|
|
ON_WM_NCHITTEST()
|
|
ON_WM_NCPAINT()
|
|
ON_WM_NCRBUTTONDOWN()
|
|
ON_WM_NCLBUTTONDOWN()
|
|
ON_WM_NCLBUTTONUP()
|
|
ON_WM_NCMOUSEMOVE()
|
|
ON_COMMAND(CPA_ID_DEVICEMENU_VIEWINGAME, OnCxtMenu1)
|
|
ON_COMMAND(CPA_IDB_DEVICE_TILE_VERT, OnCxtMenu2)
|
|
ON_COMMAND(CPA_IDB_DEVICE_TILE_HORZ, OnCxtMenu3)
|
|
ON_COMMAND(CPA_IDB_DEVICE_CASCADE, OnCxtMenu4)
|
|
ON_COMMAND(CPA_IDB_DEVICE_MAXIMIZE, OnCxtMenu5)
|
|
ON_COMMAND(CPA_IDB_DEVICE_RESTORE, OnCxtMenu6)
|
|
ON_COMMAND(CPA_IDM_DEVICE_CLOSE, OnCxtMenu7)
|
|
ON_COMMAND(CPA_IDM_DEVICE_CLOSEALL, OnCxtMenu8)
|
|
ON_COMMAND(CPA_IDM_DEVICE_NEWDEVICE, OnCxtMenu9)
|
|
ON_COMMAND(CPA_ID_DEVICEMENU_SPLITVERTICAL, OnCxtMenu10)
|
|
ON_COMMAND(CPA_ID_DEVICEMENU_SPLITHORIZONTAL, OnCxtMenu11)
|
|
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
DEV_Device::DEV_Device()
|
|
{
|
|
|
|
m_bIsMaximize = 0;
|
|
mbGameRefresh = TRUE;
|
|
m_oSizingRect.SetRectEmpty();
|
|
m_dfProp = 0;
|
|
|
|
}
|
|
|
|
DEV_Device::~DEV_Device()
|
|
{
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
FRMBaseMenu *DEV_Device::GetParentFrame()
|
|
{
|
|
return GetParentMultiDevice()->GetParentFrame();
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
|
|
CPA_DialogBar * DEV_Device::GetParentDialogBar()
|
|
{
|
|
return &GetParentFrame()->m_oGeneralDialogBar;
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
// return the number of Device
|
|
int DEV_Device::GetNumber()
|
|
{
|
|
|
|
return mNumber;
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
// Return the Camera if this is a device 3D else return NULL.
|
|
GLI_tdxHandleToCamera DEV_Device::GetCamera()
|
|
{
|
|
if (mViewType == C_DEVICE3D)
|
|
return ((DEV_ViewPort3D *)mpViewPort)->GetEngineCamera();
|
|
else return NULL;
|
|
}
|
|
|
|
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
// stocks the number of Device
|
|
void DEV_Device::SetNumber(int number)
|
|
{
|
|
mNumber = number;
|
|
}
|
|
|
|
void DEV_Device::CreateDevice(void *device,int x, int y,int w, int h, UINT ViewType)
|
|
{
|
|
CPA_CameraDLLBase *p_oCamDLL = NULL;
|
|
CPA_Object *p_oCamera = NULL;
|
|
m_p_oWndParent = (CWnd*) device;
|
|
|
|
mType = DEV_NORMAL;
|
|
mViewType = ViewType;
|
|
|
|
Create(NULL, NULL,
|
|
WS_THICKFRAME | WS_OVERLAPPED | WS_CLIPSIBLINGS | WS_VISIBLE | WS_CHILD | WS_CAPTION | WS_MAXIMIZEBOX,
|
|
CRect(x,y,x+w,y+h), m_p_oWndParent, 1);
|
|
|
|
// positioning the Device in top plan
|
|
SetWindowPos(&wndTop,0,0,0,0,SWP_NOSIZE | SWP_NOMOVE );
|
|
|
|
// if the dialogbar exists, ok. else, it camera creation will be done in the framebase
|
|
/* if (GetParentDialogBar() != NULL)
|
|
{
|
|
// create the default camera for the device
|
|
p_oCamDLL = (CPA_CameraDLLBase*) M_GetMainApp()->m_p_oMainWorld->GetObjectDLLWithName(C_szDLLCameraName);
|
|
ASSERT(p_oCamDLL != NULL);
|
|
|
|
p_oCamera = p_oCamDLL->CreateDefaultCamera();
|
|
ASSERT(p_oCamera != NULL);
|
|
|
|
((DEV_ViewPort3D*)GetViewPort())->ChangeCamera(p_oCamera);
|
|
}
|
|
*/
|
|
// stake has day of the list of the existing Devices
|
|
GetParentMultiDevice()->SetActivDevice(GetNumber(),TRUE);
|
|
// stake has days of active Device
|
|
//GetParentMultiDevice()->SetFocusDevice(GetNumber());
|
|
|
|
mbFullScreen = FALSE;
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
BOOL DEV_Device::IsMaximize()
|
|
{
|
|
return (m_bIsMaximize || (mType == DEV_BACKGROUND));
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
// creation of a background Device
|
|
// first Device created
|
|
void DEV_Device::CreateDeviceBackground(void * device, UINT ViewType)
|
|
{
|
|
CRect stRect;
|
|
m_p_oWndParent = (CWnd*)device;
|
|
|
|
|
|
mType = DEV_BACKGROUND; // definition of type
|
|
mViewType = ViewType;
|
|
|
|
GetParentMultiDevice()->GetClientRect(&stRect);
|
|
//GetParentFrame()->GetClientRect(&stRect);
|
|
//GetClientRect(&stRect);
|
|
Create(NULL, (LPCTSTR) "",
|
|
WS_OVERLAPPED | WS_CLIPSIBLINGS | WS_VISIBLE | WS_CHILD | WS_MAXIMIZE,
|
|
stRect, m_p_oWndParent, 1);
|
|
|
|
// positioning of Device in rear plan
|
|
SetWindowPos(&wndTop, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
|
|
// SetWindowPos(&wndTop, 250, 250, 0, 0, SWP_NOSIZE);//chbani
|
|
|
|
|
|
|
|
|
|
/* if (M_GetMainWnd())
|
|
{
|
|
if (M_GetMainDevice()->GetDevice(0) != this)
|
|
{
|
|
CPA_CameraDLLBase *p_oCamDLL = NULL;
|
|
CPA_Object *p_oCamera = NULL;
|
|
|
|
// we are not in the game device
|
|
// so, create a camera for this device
|
|
p_oCamDLL = (CPA_CameraDLLBase*) M_GetMainApp()->m_p_oMainWorld->GetObjectDLLWithName(C_szDLLCameraName);
|
|
ASSERT(p_oCamDLL != NULL);
|
|
|
|
p_oCamera = p_oCamDLL->CreateDefaultCamera();
|
|
ASSERT(p_oCamera != NULL);
|
|
|
|
((DEV_ViewPort3D*)GetViewPort())->ChangeCamera(p_oCamera);
|
|
}
|
|
}
|
|
|
|
*/ GetParentMultiDevice()->SetActivDevice(GetNumber(),TRUE); // stake has day of the list of the existing Device
|
|
//GetParentMultiDevice()->SetFocusDevice(GetNumber()); // stake has days of active Device
|
|
|
|
|
|
mbFullScreen = FALSE;
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::OnDestroy()
|
|
{
|
|
WaitForSingleObject(M_GetMainApp()->m_hDrawSem, INFINITE);
|
|
CWnd::OnDestroy();
|
|
|
|
// Destroy the DisplayViewport.
|
|
// fn_bDeleteViewport3D(mDisplayDevice3D, mViewPort.GetDisplayViewport3D());
|
|
|
|
GLD_bReleaseViewportAndDevice(m_hDisplayDevice,mpViewPort->m_hDisplayViewport);
|
|
|
|
mpViewPort->SendMessage(WM_DESTROY);
|
|
delete(mpViewPort);
|
|
|
|
|
|
GetParentMultiDevice()->SetActivDevice(GetNumber(),FALSE);
|
|
CWnd *topWnd=this;
|
|
Freeze();
|
|
while(1)
|
|
{
|
|
if((mType != DEV_BACKGROUND) && ((topWnd=topWnd->GetNextWindow()) != NULL))
|
|
{
|
|
if (GetParentMultiDevice()->IsDevice((DEV_Device *)topWnd))
|
|
{
|
|
GetParentMultiDevice()->SetFocusDevice( ((DEV_Device*)topWnd)->GetNumber() );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GetParentMultiDevice()->SetFocusDevice( -1 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
ReleaseSemaphore(M_GetMainApp()->m_hDrawSem, 1, NULL);
|
|
|
|
|
|
// Destroy bitmap
|
|
m_oBmClose.DeleteObject();
|
|
m_oBmGameRefresh1.DeleteObject();
|
|
m_oBmGameRefresh2.DeleteObject();
|
|
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
|
|
void DEV_Device::OnSizing(UINT nSide, LPRECT lpRect)
|
|
{
|
|
char cFlags;
|
|
char cKey = M_GetMainApp()->mp_oDevKeyboard->mfn_cActionToKey(KA_PropSizing, &cFlags);
|
|
int iLW, iLH, iNW, iNH, iDW, iDH;
|
|
|
|
if(GetAsyncKeyState(cKey) >= 0)
|
|
{
|
|
m_dfProp = ((double) (lpRect->right - lpRect->left + 1)) / ((double) (lpRect->bottom - lpRect->top + 1));
|
|
m_oSizingRect.SetRect(lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
|
|
}
|
|
else
|
|
{
|
|
iLW = m_oSizingRect.right - m_oSizingRect.left + 1;
|
|
iLH = m_oSizingRect.bottom - m_oSizingRect.top + 1;
|
|
iNW = lpRect->right - lpRect->left + 1;
|
|
iNH = lpRect->bottom - lpRect->top + 1;
|
|
|
|
iDW = iNW - iLW;
|
|
iDH = iNH - iLH;
|
|
|
|
if((abs(iDW) >= abs(iDH)) || (nSide == WMSZ_BOTTOMRIGHT))
|
|
{
|
|
iNH = (int) ((double) iNW / m_dfProp);
|
|
lpRect->bottom = lpRect->top + iNH;
|
|
}
|
|
else
|
|
{
|
|
iNW = (int) ((double) iNH * m_dfProp);
|
|
lpRect->right = lpRect->left + iNW;
|
|
}
|
|
|
|
m_oSizingRect.SetRect(lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
|
|
}
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::OnSize(UINT type, int cx, int cy)
|
|
{
|
|
RECT r;
|
|
|
|
|
|
if(mNumber)
|
|
WaitForSingleObject(M_GetMainApp()->m_hDrawSem, INFINITE);
|
|
|
|
if (!IsFreezed())
|
|
{
|
|
CWnd::OnSize(type, cx, cy);
|
|
|
|
GetWindowRect(&m_oSizingRect);
|
|
m_dfProp = ((double) (m_oSizingRect.right - m_oSizingRect.left + 1)) / ((double) (m_oSizingRect.bottom - m_oSizingRect.top + 1));
|
|
|
|
if(!M_bEditorsActive())
|
|
{
|
|
if(M_GetMainWnd())
|
|
M_GetMainWnd()->GetWindowRect(&M_GetMainWnd()->m_oMainPos);
|
|
}
|
|
|
|
if (!IsFullScreen())
|
|
{
|
|
|
|
if (!GLD_bAdjustDeviceToWindow(m_hDisplayDevice))
|
|
{
|
|
ASSERT(0);
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
{
|
|
//save the new pos for when we come back from fullscreen
|
|
if(M_GetMainWnd())
|
|
{
|
|
M_GetMainWnd()->GetWindowRect(m_stRectWhileFullscreen);
|
|
g_oBaseFrame.ScreenToClient(&m_stRectWhileFullscreen);
|
|
}
|
|
}
|
|
|
|
|
|
// Adjust the camera to the new size of the viewport (device)
|
|
if((mViewType == C_DEVICE3D) && (((DEV_ViewPort3D *) mpViewPort)->GetEngineCamera()))
|
|
GLI_xAdjustCameraToViewport
|
|
(
|
|
m_hDisplayDevice, mpViewPort->m_hDisplayViewport,
|
|
((DEV_ViewPort3D *) mpViewPort)->GetEngineCamera()
|
|
);
|
|
|
|
GAMITF_fn_vResizeGameViewport();
|
|
|
|
|
|
GetParentMultiDevice()->mbForceDrawing = TRUE;
|
|
|
|
|
|
CWnd::GetClientRect(&r);
|
|
mpViewPort->SetWindowPos(&wndTopMost,r.left,r.top,r.right,r.bottom, SWP_NOZORDER | SWP_SHOWWINDOW);
|
|
}
|
|
|
|
if(mNumber)
|
|
ReleaseSemaphore(M_GetMainApp()->m_hDrawSem, 1, NULL);
|
|
|
|
}
|
|
|
|
//================================================================================
|
|
// When device gains the focus, it must say it to the contact (and so to one or
|
|
// more editor) to update viewport modes.
|
|
//================================================================================
|
|
BOOL DEV_Device::OnNcActivate(BOOL)
|
|
{
|
|
OnNcPaint();
|
|
return FALSE;
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
int DEV_Device::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message)
|
|
{
|
|
if(!M_bEditorsActive())
|
|
return MA_NOACTIVATEANDEAT;
|
|
|
|
int iRes = CWnd::OnMouseActivate(pDesktopWnd, nHitTest, message);
|
|
GetParentMultiDevice()->SetFocusDevice(GetNumber());
|
|
return iRes;
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
|
|
void DEV_Device::OnNcLButtonDblClk(UINT nHitTest, CPoint point)
|
|
{
|
|
if((nHitTest == HTCAPTION) && (mType != DEV_BACKGROUND))
|
|
{
|
|
if(m_bIsMaximize)
|
|
SendMessage(WM_SYSCOMMAND, SC_RESTORE, 0);
|
|
else
|
|
{
|
|
if(GetParentFrame()->mbWantTile)
|
|
SendMessage(WM_SYSCOMMAND, SC_MAXIMIZE, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::OnNcMouseMove(UINT nHitTest, CPoint point)
|
|
{
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
int DEV_Device::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
GLD_tdstDeviceAttributes stDeviceAttr;
|
|
if (CWnd::OnCreate(lpCreateStruct) == -1)
|
|
return -1;
|
|
|
|
// Create the DisplayDevice.
|
|
stDeviceAttr.bFullScreen = FALSE;
|
|
stDeviceAttr.dwFullScreenModeX = MAIN_fn_ulGetDeviceWidth();
|
|
stDeviceAttr.dwFullScreenModeY = MAIN_fn_ulGetDeviceHeight();
|
|
stDeviceAttr.dwFullScreenModeBpp = 16;
|
|
stDeviceAttr.hFullScreenModeWnd = M_GetMainWnd()->GetSafeHwnd();
|
|
stDeviceAttr.hNormalModeWnd = CWnd::GetSafeHwnd();
|
|
stDeviceAttr.uiTypeDriver = C_DRIVER_HARD | C_DRIVER_RGB; // marc : moteur D3D
|
|
if (!GLD_bCreateDevice(&stDeviceAttr, &m_hDisplayDevice))
|
|
{
|
|
ASSERT(0);
|
|
// M_GetMainApp()->fn_vDynaFatalError(GLD_szGetLastErrorString());
|
|
}
|
|
|
|
// Create the Viewport.
|
|
/*if (mViewType == C_DEVICE3D)
|
|
{*/
|
|
mpViewPort = new(DEV_ViewPort3D);
|
|
((DEV_ViewPort3D *)mpViewPort)->CreateViewPort(this, m_hDisplayDevice);
|
|
/*}
|
|
else
|
|
{
|
|
mpViewPort = new(DEV_ViewPort2D);
|
|
((DEV_ViewPort2D *)mpViewPort)->CreateViewPort(this, m_hDisplayDevice);
|
|
}*/
|
|
Unfreeze();
|
|
SetBackgroundColor(0, 0, 0);
|
|
// Load bitmap for closing frame
|
|
|
|
m_oBmClose.LoadBitmap(CPA_IDB_DEVICE_CLOSE);
|
|
m_oBmGameRefresh1.LoadBitmap(CPA_IDB_DEVICE_GAMEREFRESH1);
|
|
m_oBmGameRefresh2.LoadBitmap(CPA_IDB_DEVICE_GAMEREFRESH2);
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)
|
|
{
|
|
CWnd::OnWindowPosChanging(lpwndpos);
|
|
|
|
if(mType == DEV_BACKGROUND)
|
|
{
|
|
lpwndpos->flags |= SWP_NOZORDER | SWP_NOMOVE;
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos)
|
|
{
|
|
RECT r;
|
|
|
|
CWnd::OnWindowPosChanged(lpwndpos);
|
|
|
|
|
|
GetParentMultiDevice()->mbForceDrawing = TRUE;
|
|
|
|
|
|
GetClientRect(&r);
|
|
if(IsWindow(mpViewPort->m_hWnd))
|
|
mpViewPort->SetWindowPos(&wndTopMost,r.left,r.top,r.right-r.left,r.bottom-r.top,0);
|
|
|
|
//CWnd::UpdateWindow();
|
|
|
|
}
|
|
|
|
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::SetBackgroundColor(COLORREF Color)
|
|
{
|
|
mRed = GetRValue(Color);
|
|
mGreen = GetGValue(Color);
|
|
mBlue = GetBValue(Color);
|
|
GLD_bSetBackgroundColorForDevice(m_hDisplayDevice, Color);
|
|
CWnd::SendMessage(WM_PAINT);
|
|
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::SetBackgroundColor(char Red, char Green, char Blue)
|
|
{
|
|
mRed = Red;
|
|
mGreen = Green;
|
|
mBlue = Blue;
|
|
SetBackgroundColor(RGB(Red, Green, Blue));
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::GetBackgroundColor(char *Red, char *Green, char *Blue)
|
|
{
|
|
*Red = mRed;
|
|
*Green = mGreen;
|
|
*Blue = mBlue;
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::OnPaint()
|
|
{
|
|
#ifdef USE_DIRECTX
|
|
static COLORREF clrBand=0x00de967b;
|
|
static COLORREF clrBgr=0x00deebef;
|
|
static dwBand = 7;
|
|
DWORD dwRealWidth;
|
|
DWORD dwRealHeight;
|
|
|
|
CClientDC *p_DC;
|
|
CRect stRect;
|
|
|
|
p_DC = new CClientDC(this);
|
|
GetClientRect(&stRect);
|
|
|
|
if (GLI_xIsGliInit())
|
|
{
|
|
|
|
GLI_fn_vRecomputeViewportToMaximizeDisplay(0);
|
|
|
|
dwRealWidth = (DWORD)( (float)stRect.right / GLI_gst_DllInfo.f_WidthRatio);
|
|
dwRealHeight = (DWORD)( (float)stRect.bottom / GLI_gst_DllInfo.f_HeightRatio);
|
|
|
|
p_DC->FillSolidRect(dwRealWidth, 0, stRect.right - dwRealWidth , stRect.bottom ,clrBgr);
|
|
p_DC->FillSolidRect(dwRealWidth, 0, dwBand , dwRealHeight+dwBand ,clrBand);
|
|
|
|
|
|
p_DC->FillSolidRect(0, dwRealHeight , stRect.right , stRect.bottom - dwRealHeight ,clrBgr);
|
|
p_DC->FillSolidRect(0 , dwRealHeight , dwRealWidth+dwBand , dwBand ,clrBand);
|
|
|
|
}
|
|
else
|
|
{
|
|
p_DC->FillSolidRect(&stRect,0x00);
|
|
}
|
|
|
|
if ( !M_bFullScreenEditor())
|
|
GetParentMultiDevice()->DrawObject();
|
|
|
|
#else
|
|
|
|
GetParentMultiDevice()->DrawObject();
|
|
if (M_bFullScreenEditor())
|
|
{
|
|
CClientDC *p_DC;
|
|
CRect stRect;
|
|
|
|
p_DC = new CClientDC(this);
|
|
GetClientRect(&stRect);
|
|
p_DC->FillSolidRect(&stRect,0x00);
|
|
}
|
|
#endif
|
|
|
|
CWnd::OnPaint();
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
void DEV_Device::OnSysCommand(UINT nID, LPARAM lParam)
|
|
{
|
|
RECT parentRect;
|
|
CSize sf(GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME));
|
|
|
|
switch(nID)
|
|
{
|
|
|
|
case SC_RESTORE:
|
|
MoveWindow(&m_oRestoreRect);
|
|
m_bIsMaximize = FALSE;
|
|
break;
|
|
|
|
case SC_MAXIMIZE:
|
|
GetParent()->GetClientRect(&parentRect);
|
|
|
|
RECT myRect;
|
|
if(m_bIsMaximize == FALSE)
|
|
{
|
|
GetWindowRect(&myRect);
|
|
GetParent()->ScreenToClient(&myRect);
|
|
m_oRestoreRect.CopyRect(&myRect);
|
|
m_bIsMaximize = TRUE;
|
|
}
|
|
|
|
if(mType == DEV_BACKGROUND)
|
|
{
|
|
sf.cx = 0; sf.cy = 0;
|
|
}
|
|
MoveWindow(-sf.cx, 0, parentRect.right + 2*sf.cx, parentRect.bottom + sf.cy);
|
|
break;
|
|
default:
|
|
CWnd::OnSysCommand(nID, lParam);
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
|
|
//
|
|
// DrawObject 3D
|
|
//
|
|
void DEV_Device::DrawObject(GLI_tdxHandleToLight hLight, HIE_tdxHandleToSuperObject hObject)
|
|
{
|
|
if (!IsFreezed())
|
|
{
|
|
WaitForSingleObject(M_GetMainApp()->m_hDrawSem, INFINITE);
|
|
if (!IsFreezed())
|
|
{
|
|
((DEV_ViewPort3D *)mpViewPort)->DrawObject(hLight, hObject);
|
|
if (!GLD_bFlipDevice(m_hDisplayDevice))
|
|
{
|
|
ASSERT(0);
|
|
// M_GetMainApp()->fn_vDynaFatalError(GLD_szGetLastErrorString());
|
|
}
|
|
}
|
|
ReleaseSemaphore(M_GetMainApp()->m_hDrawSem, 1, NULL);
|
|
}
|
|
}
|
|
|
|
void DEV_Device::DrawEditorObject(GLI_tdxHandleToLight hLight, CPA_SuperObject *pRoot)
|
|
{
|
|
if (!IsFreezed())
|
|
{
|
|
WaitForSingleObject(M_GetMainApp()->m_hDrawSem, INFINITE);
|
|
if (!IsFreezed())
|
|
{
|
|
((DEV_ViewPort3D *)mpViewPort)->DrawEditorObject(hLight, pRoot);
|
|
if (!GLD_bFlipDevice(m_hDisplayDevice))
|
|
{
|
|
ASSERT(0);
|
|
// M_GetMainApp()->fn_vDynaFatalError(GLD_szGetLastErrorString());
|
|
}
|
|
}
|
|
ReleaseSemaphore(M_GetMainApp()->m_hDrawSem, 1, NULL);
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
COLORREF fn_ComputeColor(char cCaption, char cHasFocus)
|
|
{
|
|
COLORREF cActive, cNActive;
|
|
|
|
if(cCaption)
|
|
{
|
|
cActive = ::GetSysColor(COLOR_ACTIVECAPTION);
|
|
cNActive = ::GetSysColor(COLOR_INACTIVECAPTION);
|
|
}
|
|
else
|
|
{
|
|
cActive = COLORREF(RGB(150, 0, 0));
|
|
cNActive = ::GetSysColor(COLOR_INACTIVECAPTION);
|
|
}
|
|
|
|
if(cHasFocus)
|
|
return cActive;
|
|
return cNActive;
|
|
}
|
|
|
|
void DEV_Device::DrawDeviceTitle(void)
|
|
{
|
|
CWindowDC dc(this);
|
|
CPen oPen;
|
|
CBrush oBrush, oBrush1;
|
|
CPen *p_oldPen;
|
|
RECT myRect, nRect;
|
|
COLORREF Color;
|
|
CSize sizeFrame(GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME));
|
|
|
|
if(mType == DEV_BACKGROUND)
|
|
{
|
|
sizeFrame.cx = 0;
|
|
sizeFrame.cy = 0;
|
|
}
|
|
|
|
GetClientRect(&myRect);
|
|
myRect.right += sizeFrame.cx;
|
|
|
|
// Move area
|
|
// Compute color
|
|
if(GetParentMultiDevice())
|
|
Color = fn_ComputeColor(1, GetParentMultiDevice()->GetParent()->GetFocus() == mpViewPort);
|
|
else
|
|
Color = fn_ComputeColor(1, 0);
|
|
|
|
oBrush.CreateSolidBrush(Color);
|
|
nRect.left = sizeFrame.cx;
|
|
nRect.right = myRect.right;
|
|
if(mType == DEV_BACKGROUND)
|
|
nRect.top = 0;
|
|
else
|
|
nRect.top = 1;
|
|
nRect.bottom = DEV_YCaption - 2;
|
|
dc.FillRect(&nRect, &oBrush);
|
|
|
|
// A black line under caption
|
|
oPen.CreatePen(PS_SOLID, 1, COLORREF(RGB(0, 0, 0)));
|
|
p_oldPen = dc.SelectObject(&oPen);
|
|
dc.MoveTo(sizeFrame.cx, DEV_YCaption - 2);
|
|
dc.LineTo(myRect.right, DEV_YCaption - 2);
|
|
dc.SelectObject(p_oldPen);
|
|
oPen.DeleteObject();
|
|
|
|
// A frame line under caption
|
|
if(GetParentMultiDevice()->GetNumFocusDevice() == mNumber)
|
|
Color = ::GetSysColor(COLOR_ACTIVEBORDER);
|
|
else
|
|
Color = ::GetSysColor(COLOR_INACTIVEBORDER);
|
|
oPen.CreatePen(PS_SOLID, 1, Color);
|
|
p_oldPen = dc.SelectObject(&oPen);
|
|
dc.MoveTo(sizeFrame.cx, DEV_YCaption - 1);
|
|
dc.LineTo(myRect.right, DEV_YCaption - 1);
|
|
dc.SelectObject(p_oldPen);
|
|
|
|
// To close frame
|
|
if((mType != DEV_BACKGROUND) && (GetParentFrame()->mbWantClose))
|
|
{
|
|
CDC dcBitmap;
|
|
HBITMAP hBitmapOld;
|
|
if (!dcBitmap.CreateCompatibleDC(&dc))
|
|
return;
|
|
hBitmapOld = (HBITMAP) dcBitmap.SelectObject(&m_oBmClose);
|
|
dc.BitBlt(myRect.right - 32, myRect.top, 24, DEV_YCaption, &dcBitmap, 0, 0, SRCCOPY);
|
|
dcBitmap.SelectObject(hBitmapOld);
|
|
}
|
|
|
|
// Game refresh
|
|
if
|
|
(
|
|
(GetParentFrame() == M_GetMainWnd())
|
|
&&
|
|
(
|
|
(mType != DEV_BACKGROUND)
|
|
|| (GetParent() != GetParentFrame()->m_oSplitter.GetPane(0, 0))
|
|
)
|
|
)
|
|
{
|
|
CDC dcBitmap;
|
|
HBITMAP hBitmapOld;
|
|
if (!dcBitmap.CreateCompatibleDC(&dc))
|
|
return;
|
|
if(!mbGameRefresh)
|
|
hBitmapOld = (HBITMAP) dcBitmap.SelectObject(&m_oBmGameRefresh1);
|
|
else
|
|
hBitmapOld = (HBITMAP) dcBitmap.SelectObject(&m_oBmGameRefresh2);
|
|
dc.BitBlt(myRect.left + sizeFrame.cx + 8, myRect.top, 24, DEV_YCaption, &dcBitmap, 0, 0, SRCCOPY);
|
|
dcBitmap.SelectObject(hBitmapOld);
|
|
}
|
|
}
|
|
|
|
void DEV_Device::OnNcPaint(void)
|
|
{
|
|
CWnd::OnNcPaint();
|
|
DrawDeviceTitle();
|
|
}
|
|
|
|
void DEV_Device::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpncsp)
|
|
{
|
|
CSize sizeFrame(GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME));
|
|
|
|
if(mType == DEV_BACKGROUND)
|
|
lpncsp->rgrc[0].top += DEV_YCaption;
|
|
else
|
|
{
|
|
lpncsp->rgrc[0].left += sizeFrame.cx;
|
|
lpncsp->rgrc[0].right -= sizeFrame.cx;
|
|
lpncsp->rgrc[0].bottom -= sizeFrame.cy;
|
|
lpncsp->rgrc[0].top += DEV_YCaption;
|
|
}
|
|
}
|
|
|
|
UINT DEV_Device::OnNcHitTest(CPoint point)
|
|
{
|
|
RECT myRect;
|
|
|
|
GetWindowRect(&myRect);
|
|
if(point.y < (myRect.top + DEV_YCaption))
|
|
{
|
|
CSize sizeFrame(GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME));
|
|
|
|
// To close a windowed device
|
|
if
|
|
(
|
|
((point.x >= (myRect.right - 32 - sizeFrame.cx)) && (point.x <= (myRect.right - 8 - sizeFrame.cx)))
|
|
&& (mType != DEV_BACKGROUND)
|
|
&& (GetParentFrame()->mbWantClose)
|
|
)
|
|
return HTSYSMENU;
|
|
|
|
// Refresh or not by game
|
|
if
|
|
(
|
|
(point.x >= myRect.left + 8 + sizeFrame.cx)
|
|
&& (point.x <= myRect.left + 32 + sizeFrame.cx)
|
|
&& (GetParentFrame() == M_GetMainWnd())
|
|
&&
|
|
(
|
|
(mType != DEV_BACKGROUND)
|
|
|| (GetParent() != GetParentFrame()->m_oSplitter.GetPane(0, 0))
|
|
)
|
|
)
|
|
{
|
|
return HTMENU;
|
|
}
|
|
|
|
return HTCAPTION;
|
|
}
|
|
|
|
UINT uiHit = CWnd::OnNcHitTest(point);
|
|
switch(uiHit)
|
|
{
|
|
case HTBOTTOMLEFT:
|
|
return HTBOTTOM;
|
|
case HTTOPLEFT:
|
|
return HTLEFT;
|
|
case HTTOPRIGHT:
|
|
return HTRIGHT;
|
|
case HTTOP:
|
|
return HTNOWHERE;
|
|
}
|
|
return uiHit;
|
|
}
|
|
|
|
void DEV_Device::OnNcRButtonDown(UINT HitTest, CPoint point)
|
|
{
|
|
//ANNECY CB
|
|
return;
|
|
//END
|
|
CMenu oMenu;
|
|
CMenu *pMenu;
|
|
BOOL bActiv = FALSE;
|
|
|
|
if(!M_bEditorsActive())
|
|
return;
|
|
|
|
// Is there an additional active device ?
|
|
for(int i = 1; i < MAX_DEVICE; i++)
|
|
{
|
|
if(GetParentMultiDevice()->IsActivDevice(i))
|
|
{
|
|
bActiv = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
oMenu.LoadMenu(CPA_IDM_DEVICEMENU);
|
|
pMenu = oMenu.GetSubMenu(0);
|
|
|
|
if
|
|
(
|
|
(mType == DEV_BACKGROUND)
|
|
&& (GetParentFrame() == M_GetMainWnd())
|
|
&& (GetParentFrame()->m_oSplitter.GetPane(0, 0) == GetParent())
|
|
)
|
|
{
|
|
pMenu->CheckMenuItem(CPA_ID_DEVICEMENU_VIEWINGAME, MF_BYCOMMAND|MF_CHECKED);
|
|
pMenu->EnableMenuItem(CPA_ID_DEVICEMENU_VIEWINGAME, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
}
|
|
else
|
|
pMenu->CheckMenuItem(CPA_ID_DEVICEMENU_VIEWINGAME, MF_BYCOMMAND|mbGameRefresh ? MF_CHECKED : MF_UNCHECKED);
|
|
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_MAXIMIZE, MF_BYCOMMAND|mType == DEV_BACKGROUND ? MF_DISABLED|MF_GRAYED : MF_ENABLED);
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_RESTORE, MF_BYCOMMAND|mType == DEV_BACKGROUND ? MF_DISABLED|MF_GRAYED : MF_ENABLED);
|
|
pMenu->EnableMenuItem(CPA_IDM_DEVICE_CLOSE, MF_BYCOMMAND|mType == DEV_BACKGROUND ? MF_DISABLED|MF_GRAYED : MF_ENABLED);
|
|
|
|
if(bActiv == FALSE)
|
|
{
|
|
pMenu->EnableMenuItem(CPA_IDM_DEVICE_CLOSEALL, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_TILE_VERT, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_TILE_HORZ, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_CASCADE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_IDM_DEVICE_CLOSEALL, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
}
|
|
if(GetParentFrame()->mbWantNew == FALSE)
|
|
pMenu->EnableMenuItem(CPA_IDM_DEVICE_NEWDEVICE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
|
|
if(GetParentFrame()->mbWantTile == FALSE)
|
|
{
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_TILE_VERT, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_TILE_HORZ, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_CASCADE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_MAXIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_IDB_DEVICE_RESTORE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
}
|
|
if(GetParentFrame()->mbWantClose == FALSE)
|
|
{
|
|
pMenu->EnableMenuItem(CPA_IDM_DEVICE_CLOSE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_IDM_DEVICE_CLOSEALL, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
}
|
|
|
|
if
|
|
(
|
|
(!(GetParent()->GetParent()->IsKindOf(RUNTIME_CLASS(FRMSplitter))))
|
|
|| (mType != DEV_BACKGROUND)
|
|
|| (GetParentFrame()->mbWantSplit == FALSE)
|
|
)
|
|
{
|
|
pMenu->EnableMenuItem(CPA_ID_DEVICEMENU_SPLITVERTICAL, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
pMenu->EnableMenuItem(CPA_ID_DEVICEMENU_SPLITHORIZONTAL, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
}
|
|
else
|
|
{
|
|
if(GetParentSplitter()->GetRowCount() == 2)
|
|
pMenu->EnableMenuItem(CPA_ID_DEVICEMENU_SPLITHORIZONTAL, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
if(GetParentSplitter()->GetColumnCount() == 2)
|
|
pMenu->EnableMenuItem(CPA_ID_DEVICEMENU_SPLITVERTICAL, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
}
|
|
|
|
// register the popup menu for the tutorial module
|
|
TUT_M_vGetTutDll ();
|
|
TUT_M_vRegisterMenu (this -> m_hWnd , pMenu -> m_hMenu , point . x , point . y);
|
|
|
|
pMenu->TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON, point.x, point.y, this);
|
|
oMenu.DestroyMenu();
|
|
}
|
|
|
|
void DEV_Device::OnNcLButtonDown(UINT HitTest, CPoint point)
|
|
{
|
|
if((HitTest == HTSYSMENU) && (mType != DEV_BACKGROUND))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
// Refresh or not by game
|
|
if(HitTest == HTMENU)
|
|
{
|
|
mbGameRefresh = mbGameRefresh ? FALSE : TRUE;
|
|
DrawDeviceTitle();
|
|
return;
|
|
}
|
|
|
|
if(!IsMaximize())
|
|
{
|
|
SetWindowPos(&wndTop, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
|
|
RedrawWindow();
|
|
CWnd::OnNcLButtonDown(HitTest, point);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DEV_Device::OnNcLButtonUp(UINT HitTest, CPoint point)
|
|
{
|
|
if((HitTest == HTSYSMENU) && (mType != DEV_BACKGROUND))
|
|
{
|
|
if(GetParentFrame()->mbWantClose)
|
|
{
|
|
FRMBaseMenu *pParent = GetParentFrame();
|
|
SendMessage(WM_CLOSE, 0, 0);
|
|
pParent->mfn_vUpdateDeviceToolBar();
|
|
}
|
|
}
|
|
else
|
|
CWnd::OnNcLButtonUp(HitTest, point);
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
BOOL DEV_Device::SwapFullScreen(BOOL Show /*=TRUE*/)
|
|
{
|
|
|
|
// M_GetListOfAllDLL()->DeviceIsSwapping(GetParentMultiDevice(),this);
|
|
|
|
if (!IsFullScreen())
|
|
{
|
|
//save the new pos for when we come back from fullscreen
|
|
GetParentFrame()->GetWindowRect(m_stRectWhileFullscreen);
|
|
g_oBaseFrame.ScreenToClient(&m_stRectWhileFullscreen);
|
|
}
|
|
|
|
|
|
// if (M_bEditorsActive() && M_GetMainApp()->m_bViewerOpened == TRUE)
|
|
// return;
|
|
if (!M_bEditorsActive())
|
|
|
|
{
|
|
if(!mbFullScreen)
|
|
{
|
|
M_GetMainWnd()->ShowWindow(FALSE);
|
|
|
|
M_GetMainWnd()->fn_vShowGeneralInterface(FALSE);
|
|
|
|
}
|
|
}
|
|
|
|
SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
|
|
|
|
WaitForSingleObject(M_GetMainApp()->m_hDrawSem, INFINITE);
|
|
M_GetMainApp()->m_bFlagTaken = TRUE;
|
|
//--------------------------------------------------------
|
|
// Freeze all devices
|
|
GetParentMultiDevice()->FreezeAll();
|
|
|
|
|
|
if(!mbFullScreen)
|
|
{
|
|
FRMSplitter *pSplit = &(M_GetMainWnd()->m_oSplitter);
|
|
DEV_MultiDevice *pSingle = (DEV_MultiDevice *) pSplit->GetPane(0, 0);
|
|
if(pSplit->GetColumnCount() == 2)
|
|
{
|
|
pSingle = (DEV_MultiDevice *) pSplit->GetPane(0, 1);
|
|
pSingle->FreezeAll();
|
|
pSingle->EnableWindow(FALSE);
|
|
}
|
|
if(pSplit->GetRowCount() == 2)
|
|
{
|
|
pSingle = (DEV_MultiDevice *) pSplit->GetPane(1, 0);
|
|
pSingle->FreezeAll();
|
|
pSingle->EnableWindow(FALSE);
|
|
|
|
if(pSplit->GetColumnCount() == 2)
|
|
{
|
|
pSingle = (DEV_MultiDevice *) pSplit->GetPane(1, 1);
|
|
pSingle->FreezeAll();
|
|
pSingle->EnableWindow(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (!GLD_bSetFullScreenModeForDevice(m_hDisplayDevice, MAIN_fn_ulGetDeviceWidth(),MAIN_fn_ulGetDeviceHeight(), 16, M_GetMainWnd()->GetSafeHwnd()))
|
|
{
|
|
ASSERT(0);
|
|
}
|
|
|
|
if (!GLD_bSwapDeviceMode(m_hDisplayDevice, TRUE))
|
|
{
|
|
ASSERT(0);
|
|
}
|
|
|
|
if(((DEV_ViewPort3D *) mpViewPort)->GetEngineCamera())
|
|
GLI_xAdjustCameraToViewport(m_hDisplayDevice, mpViewPort->m_hDisplayViewport, ((DEV_ViewPort3D *) mpViewPort)->GetEngineCamera());
|
|
|
|
GAMITF_fn_vResizeGameViewport();
|
|
|
|
if (!mbFullScreen)
|
|
{
|
|
mbFullScreen = TRUE;
|
|
GetParentMultiDevice()->FreezeAllButOne(0);
|
|
}
|
|
else
|
|
{
|
|
mbFullScreen = FALSE;
|
|
GetParentMultiDevice()->UnfreezeAll();
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
M_GetMainApp()->m_bFlagTaken = FALSE;
|
|
ReleaseSemaphore(M_GetMainApp()->m_hDrawSem, 1, NULL);
|
|
|
|
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
|
|
|
|
if(!mbFullScreen && Show)
|
|
{
|
|
/* if (!M_bEditorsActive())
|
|
M_GetMainWnd()->fn_vShowGeneralInterface(FALSE);
|
|
else*/
|
|
M_GetMainWnd()->fn_vShowGeneralInterface(TRUE);
|
|
}
|
|
// GetParentFrame()->ShowWindow(TRUE);
|
|
|
|
#ifdef NDEBUG
|
|
if (mbFullScreen == TRUE)
|
|
{
|
|
RECT stRect,stRect2;
|
|
|
|
M_GetMainWnd()->GetWindowRect(&stRect2);
|
|
stRect.left = stRect2.left + 10;
|
|
stRect.top = stRect2.top + 10;
|
|
stRect.right = stRect2.left + 10;
|
|
stRect.bottom = stRect2.top + 10;
|
|
|
|
// we are in fullscreen
|
|
// confine cursor in the window
|
|
ClipCursor(&stRect);
|
|
// hide cursor
|
|
while (ShowCursor(FALSE) >= 0);
|
|
}
|
|
else
|
|
{
|
|
// we are in fullscreen
|
|
// confine cursor in the window
|
|
ClipCursor(NULL);
|
|
// show cursor
|
|
while (ShowCursor(TRUE) < 0);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// Unfreeze panes ?
|
|
if(!mbFullScreen)
|
|
{
|
|
FRMSplitter *pSplit = &M_GetMainWnd()->m_oSplitter;
|
|
DEV_MultiDevice *pSingle = (DEV_MultiDevice *) pSplit->GetPane(0, 0);
|
|
if(pSplit->GetColumnCount() == 2)
|
|
{
|
|
pSingle = (DEV_MultiDevice *) pSplit->GetPane(0, 1);
|
|
pSingle->UnfreezeAll();
|
|
pSingle->EnableWindow(TRUE);
|
|
}
|
|
if(pSplit->GetRowCount() == 2)
|
|
{
|
|
pSingle = (DEV_MultiDevice *) pSplit->GetPane(1, 0);
|
|
pSingle->UnfreezeAll();
|
|
pSingle->EnableWindow(TRUE);
|
|
|
|
if(pSplit->GetColumnCount() == 2)
|
|
{
|
|
pSingle = (DEV_MultiDevice *) pSplit->GetPane(1, 1);
|
|
pSingle->UnfreezeAll();
|
|
pSingle->EnableWindow(TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
M_GetMainApp()->m_bFullScreenInEditor = IsFullScreen();
|
|
|
|
if (!IsFullScreen() || M_bEditorsActive())
|
|
{
|
|
// RECT r;
|
|
// M_GetMainWnd()->GetWindowRect(&r);
|
|
// r.left--;
|
|
// M_GetMainWnd()->SetWindowPos(&wndTopMost,r.left,r.top,r.right,r.bottom, SWP_NOZORDER | SWP_SHOWWINDOW);
|
|
// r.left++;
|
|
GetParentFrame()->SetParent(&g_oBaseFrame);
|
|
if(!M_bEditorsActive())
|
|
{
|
|
CSize ss(GetSystemMetrics(SM_CXMAXIMIZED), GetSystemMetrics(SM_CYMAXIMIZED));
|
|
CRect cs;
|
|
cs.left = (ss.cx - 700) / 2;
|
|
cs.top = (ss.cy - 550) / 2;
|
|
cs.right = cs.left + 700;
|
|
cs.bottom = cs.top + 550;
|
|
GetParentFrame()->MoveWindow(cs);
|
|
}
|
|
else
|
|
{
|
|
GetParentFrame()->MoveWindow(m_stRectWhileFullscreen.left,
|
|
m_stRectWhileFullscreen.top,
|
|
m_stRectWhileFullscreen.right - m_stRectWhileFullscreen.left+1,
|
|
m_stRectWhileFullscreen.bottom - m_stRectWhileFullscreen.top+1,
|
|
FALSE
|
|
);
|
|
}
|
|
// M_GetMainDevice()->DrawObject();
|
|
if(M_bEditorsActive())
|
|
M_GetMainWnd()->fn_vShowGeneralInterface(TRUE);
|
|
else
|
|
M_GetMainWnd()->fn_vShowGeneralInterface(FALSE);
|
|
}
|
|
if(M_bEditorsActive())
|
|
{
|
|
g_oFrameGest.mfn_vAWindowHasMoved(GetParentFrame(), FRM_C_MoveLeft);
|
|
g_oFrameGest.mfn_vRefreshWindows(TRUE);
|
|
}
|
|
else
|
|
{
|
|
if(!IsFullScreen() && !IsWindowVisible())
|
|
M_GetMainWnd()->ShowWindow(TRUE);
|
|
else if (IsFullScreen() && IsWindowVisible())
|
|
M_GetMainWnd()->ShowWindow(FALSE);
|
|
}
|
|
g_oBaseFrame.SetFocus();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
|
|
|
|
void DEV_Device::SetMainWindowForRender(BOOL Show)
|
|
{
|
|
#ifdef USE_DIRECTX
|
|
GLI_fn_vSetMainWindowForRender(m_hWnd);
|
|
#endif
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
//================================================================================
|
|
|
|
|
|
void DEV_Device::OnCxtMenu1(void) // Game refresh
|
|
{
|
|
mbGameRefresh = mbGameRefresh ? FALSE : TRUE;
|
|
DrawDeviceTitle();
|
|
}
|
|
void DEV_Device::OnCxtMenu2(void) // Tile vert
|
|
{
|
|
GetParentMultiDevice()->OnDeviceTileVert();
|
|
}
|
|
void DEV_Device::OnCxtMenu3(void) // Tile horiz
|
|
{
|
|
GetParentMultiDevice()->OnDeviceTileHorz();
|
|
}
|
|
void DEV_Device::OnCxtMenu4(void) // Cascade
|
|
{
|
|
GetParentMultiDevice()->OnDeviceCascade();
|
|
}
|
|
void DEV_Device::OnCxtMenu5(void) // Maximize
|
|
{
|
|
GetParentMultiDevice()->OnMaximizeDevice();
|
|
}
|
|
void DEV_Device::OnCxtMenu6(void) // Restore
|
|
{
|
|
GetParentMultiDevice()->OnRestoreDevice();
|
|
}
|
|
void DEV_Device::OnCxtMenu7(void) // Close
|
|
{
|
|
GetParentMultiDevice()->OnCloseDevice();
|
|
}
|
|
void DEV_Device::OnCxtMenu8(void) // Close all
|
|
{
|
|
GetParentMultiDevice()->OnCloseAllDevice();
|
|
}
|
|
void DEV_Device::OnCxtMenu9(void) // New
|
|
{
|
|
GetParentMultiDevice()->OnOpenDevice();
|
|
}
|
|
void DEV_Device::OnCxtMenu10(void) // Split vertical
|
|
{
|
|
GetParentSplitter()->MakeSplit(2);
|
|
}
|
|
void DEV_Device::OnCxtMenu11(void) // Split horizontal
|
|
{
|
|
GetParentSplitter()->MakeSplit(1);
|
|
}
|
|
|