bool CBasicWindow::SetOpacity(int Opacity,bool fClearLayered)
{
if (Opacity<0 || Opacity>255 || m_hwnd==NULL)
return false;
// 子ウィンドウをレイヤードウィンドウにできるのは Windows 8 以降
if ((GetWindowStyle() & WS_CHILD)!=0 && !Util::OS::IsWindows8OrLater())
return false;
DWORD ExStyle=GetWindowExStyle();
if (Opacity<255) {
if ((ExStyle & WS_EX_LAYERED)==0)
SetWindowExStyle(ExStyle | WS_EX_LAYERED);
if (!::SetLayeredWindowAttributes(m_hwnd,0,(BYTE)Opacity,LWA_ALPHA))
return false;
} else {
if ((ExStyle & WS_EX_LAYERED)!=0) {
if (fClearLayered) {
SetWindowExStyle(ExStyle ^ WS_EX_LAYERED);
Redraw(NULL,RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
} else {
::SetLayeredWindowAttributes(m_hwnd,0,255,LWA_ALPHA);
}
}
}
return true;
}
static void setup_anim_mem_dc (HWND hwnd, ANIMATIONINFO* anim_info)
{
gal_pixel bk_pixel;
HDC hdc;
if (!anim_info->anim)
return;
if (anim_info->mem_dc)
DeleteCompatibleDC (anim_info->mem_dc);
hdc = GetClientDC (hwnd);
#ifdef _USE_NEWGAL
anim_info->mem_dc = CreateCompatibleDCEx (hdc,
anim_info->anim->width, anim_info->anim->height);
#else
anim_info->mem_dc = CreateCompatibleDC (hdc);
#endif
if (GetWindowExStyle (hwnd) & WS_EX_TRANSPARENT)
bk_pixel = GetWindowBkColor (GetParent (hwnd));
else
bk_pixel = GetWindowBkColor (hwnd);
SetBkColor (anim_info->mem_dc, bk_pixel);
SetBrushColor (anim_info->mem_dc, bk_pixel);
FillBox (anim_info->mem_dc, 0, 0,
GetGDCapability (hdc, GDCAP_MAXX)+1,
GetGDCapability (hdc, GDCAP_MAXY)+1);
ReleaseDC (hdc);
}
void
GFXDevice::setWindow(Point2I *size)
{
if(!size)
{
size = ¤tSize;
}
RECT rect;
if ( !restoreWin )
GetWindowRect( clientWind, &windowRect);
SetRect(&rect,0,0,size->x, size->y);
AdjustWindowRectEx(&rect,
GetWindowStyle(clientWind),
GetMenu(clientWind) != NULL,
GetWindowExStyle(clientWind));
SetWindowPos(clientWind, HWND_TOPMOST,
rect.left, // X
rect.top, // Y
(rect.right - rect.left), // Width
(rect.bottom - rect.top), // Height
0 );
restoreWin = true;
}
void CWindow::SetClientSize (int ClientWidth, int ClientHeight)
{
#ifdef WIN32
RECT rc;
SetRect (&rc, 0, 0, ClientWidth, ClientHeight);
AdjustWindowRectEx (&rc, GetWindowStyle(m_hWnd), (int)GetMenu (m_hWnd), GetWindowExStyle (m_hWnd));
SetWindowPos (m_hWnd, HWND_NOTOPMOST, 0, 0, rc.right - rc.left, rc.bottom - rc.top, SWP_NOMOVE);
#endif
}
GameWindow::GameWindow(const string name_t,const string title_t,int width,int height):name(name_t),title(title_t),WIDTH(width),HEIGHT(height)
{
//1.创建窗口类
WNDCLASSEX wndClass = {};
wndClass.cbSize = sizeof(WNDCLASSEX);
wndClass.style = CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = WndProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hInstance = GetModuleHandle(NULL);
wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = name.c_str();
//2.注册窗口类
assert(RegisterClassEx(&wndClass));
//3.创建窗口
hwnd = CreateWindow(name.c_str(),title.c_str(),WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,WIDTH,HEIGHT,NULL,NULL,wndClass.hInstance,NULL);
//4.调整大小，移动，显示，更新
RECT window_rect = {0,0,WIDTH,HEIGHT};
AdjustWindowRectEx(&window_rect, GetWindowStyle(hwnd), GetMenu(hwnd) != NULL, GetWindowExStyle(hwnd));
MoveWindow(hwnd,300,150,window_rect.right-window_rect.left, window_rect.bottom-window_rect.top,false);
ShowWindow(hwnd,SW_NORMAL);
UpdateWindow(hwnd);
//5.隐藏鼠标，设为屏幕中心
ShowCursor(false);
center.x = WIDTH/2;
center.y = HEIGHT/2;
ClientToScreen(hwnd,¢er);
SetCursorPos(center.x,center.y);
//6.限定鼠标在窗口内
RECT rect;
GetClientRect(hwnd,&rect);
POINT left_top;
left_top.x = rect.left;
left_top.y = rect.top;
POINT right_bottom;
right_bottom.x = rect.right;
right_bottom.y = rect.bottom;
ClientToScreen(hwnd,&left_top);
ClientToScreen(hwnd,&right_bottom);
rect.left = left_top.x;
rect.top = left_top.y;
rect.right = right_bottom.x;
rect.bottom = right_bottom.y;
ClipCursor(&rect);
}
void CToolbarBottom::InitWindow()
{
RECT rc = { 0 };
if( !::GetClientRect(m_hWnd, &rc) )
return;
rc.top = rc.bottom - DEFAULT_TOOLBAR_HEIGHT;
rc.bottom = rc.top + DEFAULT_TOOLBAR_HEIGHT;
if( !::AdjustWindowRectEx(&rc, GetWindowStyle(m_hWnd), false, GetWindowExStyle(m_hWnd)) ) return;
::SetWindowPos(m_hWnd, HWND_BOTTOM,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
m_containerBottomButtons = static_cast<CHorizontalLayoutUI* >(m_PaintManager.FindControl(_T("container_buttons_bottom_ui")));
m_btnParticipant = static_cast<CButtonUI* >(m_PaintManager.FindControl(_T("btn_participant")));
if(m_btnParticipant)
{
m_btnParticipant->SetText(L"Show Participant");
}
m_btnThumbnailVideo = static_cast<CButtonUI* >(m_PaintManager.FindControl(_T("btn_thumbnailvideo")));
if(m_btnThumbnailVideo)
m_btnThumbnailVideo->SetText(L"Show Gallery");
m_btnAudio = static_cast<CButtonUI* >(m_PaintManager.FindControl(_T("btn_audio")));
if(m_btnAudio)
m_btnAudio->SetText(L"Mute Audio");
m_btnVideo = static_cast<CButtonUI* >(m_PaintManager.FindControl(_T("btn_video")));
if(m_btnVideo)
m_btnVideo->SetText(L"Stop video");
//m_btnInvite = static_cast<CButtonUI* >(m_PaintManager.FindControl(_T("btn_invite")));
m_btnShare = static_cast<CButtonUI* >(m_PaintManager.FindControl(_T("btn_share")));
if(m_btnShare)
m_btnShare->SetText(L"Share");
m_btnChat = static_cast<CButtonUI* >(m_PaintManager.FindControl(_T("btn_chat")));
if(m_btnChat)
m_btnChat->SetText(L"Show Chat");
m_btnLeave = static_cast<CButtonUI* >(m_PaintManager.FindControl(_T("btn_leavemeeting")));
if(m_btnLeave)
{
if(m_pToolbarMgr && m_pToolbarMgr->IsHost())
m_btnLeave->SetText(L"End Meeting");
else
m_btnLeave->SetText(L"Leave Meeting");
}
m_ToolbarBottomWorkFlow.SetUIEvent(this);
}
void CWidget::GetPosition(Position *pPosition) const
{
if (m_hwnd!=nullptr) {
RECT rc;
if ((GetWindowStyle(m_hwnd)&WS_CHILD)!=0) {
::GetWindowRect(m_hwnd,&rc);
::MapWindowPoints(nullptr,::GetParent(m_hwnd),reinterpret_cast<POINT*>(&rc),2);
pPosition->Left=rc.left;
pPosition->Top=rc.top;
pPosition->Width=rc.right-rc.left;
pPosition->Height=rc.bottom-rc.top;
pPosition->fMaximized=false;
} else {
WINDOWPLACEMENT wp;
wp.length=sizeof(WINDOWPLACEMENT);
::GetWindowPlacement(m_hwnd,&wp);
if (wp.showCmd==SW_SHOWNORMAL) {
::GetWindowRect(m_hwnd,&rc);
pPosition->fMaximized=false;
} else {
if ((GetWindowExStyle(m_hwnd)&WS_EX_TOOLWINDOW)==0) {
HMONITOR hMonitor=::MonitorFromWindow(m_hwnd,MONITOR_DEFAULTTONEAREST);
MONITORINFO mi;
mi.cbSize=sizeof(MONITORINFO);
::GetMonitorInfo(hMonitor,&mi);
::OffsetRect(&wp.rcNormalPosition,
mi.rcWork.left-mi.rcMonitor.left,
mi.rcWork.top-mi.rcMonitor.top);
}
rc=wp.rcNormalPosition;
pPosition->fMaximized=wp.showCmd==SW_SHOWMAXIMIZED;
}
pPosition->Left=rc.left;
pPosition->Top=rc.top;
pPosition->Width=rc.right-rc.left;
pPosition->Height=rc.bottom-rc.top;
}
} else {
*pPosition=m_WindowPosition;
}
}
int AdjustWindow(HWND hwnd)
{
RECT window_rect;
GetWindowRect(hwnd, &window_rect);
AdjustWindowRectEx(&window_rect,
GetWindowStyle(hwnd),
GetMenu(hwnd)!=NULL,
GetWindowExStyle(hwnd));
SetWindowPos(hwnd,
HWND_TOP,
(GetSystemMetrics(SM_CXSCREEN) - (window_rect.right - window_rect.left))/2,
(GetSystemMetrics(SM_CYSCREEN) - (window_rect.bottom - window_rect.top))/2,
window_rect.right - window_rect.left,
window_rect.bottom - window_rect.top,
SWP_SHOWWINDOW);
return 0;
}
bool CBasicWindow::SetPosition(int Left,int Top,int Width,int Height)
{
if (Width<0 || Height<0)
return false;
if (m_hwnd!=NULL) {
if ((GetWindowStyle() & WS_CHILD)!=0
|| (!::IsZoomed(m_hwnd) && !::IsIconic(m_hwnd))) {
::MoveWindow(m_hwnd,Left,Top,Width,Height,TRUE);
} else {
WINDOWPLACEMENT wp;
wp.length=sizeof(WINDOWPLACEMENT);
::GetWindowPlacement(m_hwnd,&wp);
wp.rcNormalPosition.left=Left;
wp.rcNormalPosition.top=Top;
wp.rcNormalPosition.right=Left+Width;
wp.rcNormalPosition.bottom=Top+Height;
if ((GetWindowExStyle() & WS_EX_TOOLWINDOW)==0) {
HMONITOR hMonitor=::MonitorFromRect(&wp.rcNormalPosition,MONITOR_DEFAULTTONEAREST);
MONITORINFO mi;
mi.cbSize=sizeof(MONITORINFO);
::GetMonitorInfo(hMonitor,&mi);
::OffsetRect(&wp.rcNormalPosition,
mi.rcMonitor.left-mi.rcWork.left,
mi.rcMonitor.top-mi.rcWork.top);
}
::SetWindowPlacement(m_hwnd,&wp);
}
} else {
m_WindowPosition.Left=Left;
m_WindowPosition.Top=Top;
m_WindowPosition.Width=Width;
m_WindowPosition.Height=Height;
}
return true;
}
//-----------------------------------------------------------------------------
// Name: InitGraphics()
// Desc:
//-----------------------------------------------------------------------------
HRESULT InitGraphics()
{
DDCAPS ddcaps;
HRESULT hr;
DDSURFACEDESC ddsd;
DDSCAPS ddscaps;
// Create a window
g_hwndMain = CreateWindowEx( WS_EX_APPWINDOW, TEXT("DuelClass"),
TEXT("Duel"), WS_POPUP | WS_SYSMENU, 0, 0,
GetSystemMetrics(SM_CXSCREEN),
GetSystemMetrics(SM_CYSCREEN),
NULL, NULL, g_hInst, NULL );
if( NULL == g_hwndMain )
return E_FAIL;
UpdateWindow( g_hwndMain );
SetFocus( g_hwndMain );
// DDraw stuff begins here
if( FAILED( hr = DirectDrawCreate( NULL, &g_pDD, NULL ) ) )
{
ShowError(IDS_DDRAW_ERROR_DDC);
return E_FAIL;
}
// Set access mode based on fullscreen/window
if( g_bFullscreen )
{
hr = g_pDD->SetCooperativeLevel( g_hwndMain,
DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );
}
else
{
hr = g_pDD->SetCooperativeLevel( g_hwndMain,
DDSCL_NORMAL);
}
if( FAILED(hr) )
{
ShowError(IDS_DDRAW_ERROR_SCL);
return E_FAIL;
}
if( g_bFullscreen )
{
// Set the mode to 640 by 480 by 8
if( FAILED( g_pDD->SetDisplayMode( 640, 480, 8 ) ) )
{
ShowError(IDS_DDRAW_ERROR_SDM);
return E_FAIL;
}
}
else
{
RECT rcWork;
RECT rc;
DWORD dwStyle;
// If we are still a WS_POPUP window we should convert to a
// normal app window so we look like a windows app.
dwStyle = GetWindowStyle(g_hwndMain);
dwStyle &= ~WS_POPUP;
dwStyle |= WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX;
SetWindowLong( g_hwndMain, GWL_STYLE, dwStyle );
// Aet window size
SetRect( &rc, 0, 0, MAX_DEFWIN_X, MAX_DEFWIN_Y );
AdjustWindowRectEx( &rc, GetWindowStyle(g_hwndMain),
GetMenu(g_hwndMain) != NULL,
GetWindowExStyle(g_hwndMain) );
SetWindowPos( g_hwndMain, NULL, 0, 0, rc.right-rc.left,
rc.bottom-rc.top,
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
SetWindowPos( g_hwndMain, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
// Make sure our window does not hang outside of the work area
SystemParametersInfo( SPI_GETWORKAREA, 0, &rcWork, 0 );
GetWindowRect( g_hwndMain, &rc );
if( rc.left < rcWork.left ) rc.left = rcWork.left;
if( rc.top < rcWork.top ) rc.top = rcWork.top;
SetWindowPos( g_hwndMain, NULL, rc.left, rc.top, 0, 0,
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
}
// Check the color key hardware capabilities
ddcaps.dwSize = sizeof( ddcaps );
memset( &ddsd, 0, sizeof( ddsd ) );
ddsd.dwSize = sizeof( ddsd );
if( g_bFullscreen )
{
// Create surfaces
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
DDSCAPS_FLIP |
DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount = 1;
if( FAILED( hr = g_pDD->CreateSurface( &ddsd, &g_pddsFrontBuffer,
NULL ) ) )
{
ShowError(IDS_DDRAW_ERROR_CREATESURFACE);
return E_FAIL;
}
// Get a pointer to the back buffer
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
if( FAILED( hr = g_pddsFrontBuffer->GetAttachedSurface( &ddscaps,
&g_pddsBackBuffer ) ) )
{
ShowError(IDS_DDRAW_ERROR_GAS);
return E_FAIL;
}
}
else
{
LPDIRECTDRAWCLIPPER pcClipper;
// Window case, create the primary surface
// and create a backbuffer in offscreen memory
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
if( FAILED( g_pDD->CreateSurface( &ddsd, &g_pddsFrontBuffer, NULL ) ) )
{
ShowError(IDS_DDRAW_ERROR_CREATESURFACE);
return E_FAIL;
}
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddsd.dwWidth = MAX_DEFWIN_X;
ddsd.dwHeight = MAX_DEFWIN_Y;
if( FAILED( hr = g_pDD->CreateSurface( &ddsd, &g_pddsBackBuffer, NULL ) ) )
{
ShowError(IDS_DDRAW_ERROR_CREATESURFACE);
return E_FAIL;
}
if( FAILED( hr = g_pDD->CreateClipper( 0, &pcClipper, NULL) ) )
{
ShowError(IDS_DDRAW_ERROR_CC);
return E_FAIL;
}
if( FAILED( hr = pcClipper->SetHWnd( 0, g_hwndMain) ) )
{
pcClipper->Release();
ShowError(IDS_DDRAW_ERROR_SH);
return E_FAIL;
}
if( FAILED( hr = g_pddsFrontBuffer->SetClipper( pcClipper) ) )
{
pcClipper->Release();
ShowError(IDS_DDRAW_ERROR_SC);
return E_FAIL;
}
// Done with clipper
pcClipper->Release();
}
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddsd.dwWidth = 320;
ddsd.dwHeight = 128;
for( DWORD i=0; i<4; i++ )
{
if( FAILED( hr = g_pDD->CreateSurface( &ddsd, &g_pddsShip[i], NULL ) ) )
{
ShowError(IDS_DDRAW_ERROR_CREATESURFACE);
return E_FAIL;
}
}
ddsd.dwHeight = 16;
if( FAILED( hr = g_pDD->CreateSurface( &ddsd, &g_pddsNumbers, NULL ) ) )
{
ShowError(IDS_DDRAW_ERROR_CREATESURFACE);
return E_FAIL;
}
if( FAILED( RestoreSurfaces() ) )
{
ShowError(IDS_DDRAW_ERROR_RS);
return E_FAIL;
}
g_dwKeys = 0;
ShowWindow( g_hwndMain, SW_SHOW);
return S_OK;
}
static void W32_WindowLayoutSetSize(HWND hWnd, RECT *pRect, int dwWidth, int dwHeight, bool bFullScrn, bool bResizable) // Must be in called at D3Dx window creation
{
DWORD dwStyle = GetWindowStyle(hWnd);
DWORD dwExStyle = GetWindowExStyle( hWnd);
RECT rc;
// If we are still a WS_POPUP window we should convert to a normal app
// window so we look like a windows app.
if (!bFullScrn)
{
#if _WIN32_WCE
dwExStyle|= bResizable ? WS_EX_WINDOWEDGE : 0; // Window Extended Style
dwStyle|= WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // Windows Style
#else
dwExStyle|=WS_EX_APPWINDOW | (bResizable ? WS_EX_WINDOWEDGE : 0); // Window Extended Style
dwStyle|= WS_OVERLAPPED| WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX; // Windows Style
if (bResizable)
dwStyle|= WS_THICKFRAME | WS_MAXIMIZEBOX;
#endif
}
else
{
dwStyle|= WS_POPUP;
}
SetWindowLong(hWnd, GWL_STYLE, dwStyle);
SetWindowLong(hWnd, GWL_EXSTYLE, dwExStyle);
if (!bFullScrn)
{
RECT rcWork;
// Center Window
SetRect( &rc, 0, 0, dwWidth, dwHeight );
SystemParametersInfo( SPI_GETWORKAREA, 0, &rcWork, 0 );
int cx = (rcWork.right - rcWork.left - (rc.right - rc.left)) >>1;
int cy = (rcWork.bottom - rcWork.top - (rc.bottom - rc.top)) >>1;
rc.left+=cx;
rc.right+=cx;
rc.top+=cy;
rc.bottom+=cy;
// Make sure our window does not hang outside of the work area
if( rc.left < rcWork.left ) rc.left = rcWork.left;
if( rc.top < rcWork.top ) rc.top = rcWork.top;
AdjustWindowRectEx( &rc,
GetWindowStyle(hWnd),
#if _WIN32_WCE
0,
#else
GetMenu(hWnd) != NULL,
#endif
GetWindowExStyle(hWnd) );
SetWindowPos( hWnd, NULL,
rc.left, rc.top,
rc.right - rc.left,
rc.bottom - rc.top,
SWP_NOZORDER | SWP_NOACTIVATE );
}
//-----------------------------------------------------------------------------
// Name: CreateWindowedDisplay()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CDisplay::CreateWindowedDisplay( HWND hWnd, DWORD dwWidth, DWORD dwHeight )
{
HRESULT hr;
// Cleanup anything from a previous call
DestroyObjects();
// DDraw stuff begins here
if( FAILED( hr = DirectDrawCreateEx( NULL, (VOID**)&m_pDD,
IID_IDirectDraw7, NULL ) ) )
return E_FAIL;
// Set cooperative level
hr = m_pDD->SetCooperativeLevel( hWnd, DDSCL_NORMAL );
if( FAILED(hr) )
return E_FAIL;
RECT rcWork;
RECT rc;
DWORD dwStyle;
// If we are still a WS_POPUP window we should convert to a normal app
// window so we look like a windows app.
dwStyle = GetWindowStyle( hWnd );
dwStyle &= ~WS_POPUP;
dwStyle |= WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX;
SetWindowLong( hWnd, GWL_STYLE, dwStyle );
// Aet window size
SetRect( &rc, 0, 0, dwWidth, dwHeight );
AdjustWindowRectEx( &rc, GetWindowStyle(hWnd), GetMenu(hWnd) != NULL,
GetWindowExStyle(hWnd) );
SetWindowPos( hWnd, NULL, 0, 0, rc.right-rc.left, rc.bottom-rc.top,
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
SetWindowPos( hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
// Make sure our window does not hang outside of the work area
SystemParametersInfo( SPI_GETWORKAREA, 0, &rcWork, 0 );
GetWindowRect( hWnd, &rc );
if( rc.left < rcWork.left ) rc.left = rcWork.left;
if( rc.top < rcWork.top ) rc.top = rcWork.top;
SetWindowPos( hWnd, NULL, rc.left, rc.top, 0, 0,
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
LPDIRECTDRAWCLIPPER pcClipper;
// Create the primary surface
DDSURFACEDESC2 ddsd;
ZeroMemory( &ddsd, sizeof( ddsd ) );
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
if( FAILED( m_pDD->CreateSurface( &ddsd, &m_pddsFrontBuffer, NULL ) ) )
return E_FAIL;
// Create the backbuffer surface
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
ddsd.dwWidth = dwWidth;
ddsd.dwHeight = dwHeight;
if( FAILED( hr = m_pDD->CreateSurface( &ddsd, &m_pddsBackBuffer, NULL ) ) )
return E_FAIL;
if( FAILED( hr = m_pDD->CreateClipper( 0, &pcClipper, NULL ) ) )
return E_FAIL;
if( FAILED( hr = pcClipper->SetHWnd( 0, hWnd ) ) )
{
pcClipper->Release();
return E_FAIL;
}
if( FAILED( hr = m_pddsFrontBuffer->SetClipper( pcClipper ) ) )
{
pcClipper->Release();
return E_FAIL;
}
// Done with clipper
pcClipper->Release();
m_hWnd = hWnd;
m_bWindowed = TRUE;
UpdateBounds();
return S_OK;
}
int WINAPI WinMain( HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{
WNDCLASSEX winclass; // this will hold the class we create
HWND hwnd; // generic window handle
MSG msg; // generic message
HDC hdc; // graphics device context
// first fill in the window class stucture
winclass.cbSize = sizeof(WNDCLASSEX);
winclass.style = CS_DBLCLKS | CS_OWNDC |
CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc = WindowProc;
winclass.cbClsExtra = 0;
winclass.cbWndExtra = 0;
winclass.hInstance = hinstance;
winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName = NULL;
winclass.lpszClassName = WINDOW_CLASS_NAME;
winclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
// save hinstance in global
main_instance = hinstance;
// register the window class
if (!RegisterClassEx(&winclass))
return(0);
// create the window
if (!(hwnd = CreateWindowEx(NULL, // extended style
WINDOW_CLASS_NAME, // class
"DirectInput Keyboard Demo", // title
(WINDOWED_APP ? (WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION) : (WS_POPUP | WS_VISIBLE)),
0,0, // initial x,y
SCREEN_WIDTH,SCREEN_HEIGHT, // initial width, height
NULL, // handle to parent
NULL, // handle to menu
hinstance,// instance of this application
NULL))) // extra creation parms
return(0);
// save main window handle
main_window_handle = hwnd;
// resize the window so that client is really width x height
if (WINDOWED_APP)
{
// now resize the window, so the client area is the actual size requested
// since there may be borders and controls if this is going to be a windowed app
// if the app is not windowed then it won't matter
RECT window_rect = { 0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1 };
// make the call to adjust window_rect
AdjustWindowRectEx(&window_rect,
GetWindowStyle(main_window_handle),
GetMenu(main_window_handle) != NULL,
GetWindowExStyle(main_window_handle));
// save the global client offsets, they are needed in DDraw_Flip()
window_client_x0 = -window_rect.left;
window_client_y0 = -window_rect.top;
// now resize the window with a call to MoveWindow()
MoveWindow(main_window_handle,
0, // x position
0, // y position
window_rect.right - window_rect.left, // width
window_rect.bottom - window_rect.top, // height
FALSE);
// show the window, so there's no garbage on first render
ShowWindow(main_window_handle, SW_SHOW);
} // end if windowed
// initialize game here
Game_Init();
// enter main event loop
while(TRUE)
{
// test if there is a message in queue, if so get it
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
// test if this is a quit
if (msg.message == WM_QUIT)
break;
// translate any accelerator keys
TranslateMessage(&msg);
// send the message to the window proc
DispatchMessage(&msg);
} // end if
// main game processing goes here
Game_Main();
} // end while
// closedown game here
Game_Shutdown();
// return to Windows like this
return(msg.wParam);
} // end WinMain
int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPTSTR lpCmdLine,
_In_ int nCmdShow)
{
timeBeginPeriod(1);
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// TODO: 여기에 코드를 입력합니다.
MSG msg;
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_TCPFIGHTER));
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wcex.lpszMenuName = MAKEINTRESOURCE(IDC_TCPFIGHTER);
wcex.lpszClassName = L"TCPFighter";
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
RegisterClassEx(&wcex);
hInst = hInstance; // 인스턴스 핸들을 전역 변수에 저장합니다.
g_hWnd = CreateWindow(L"TCPFighter", L"TCPFighter", WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, 640, 480, NULL, NULL, hInstance, NULL);
if (!g_hWnd)
{
return FALSE;
}
ShowWindow(g_hWnd, nCmdShow);
UpdateWindow(g_hWnd);
////////////////////////////////////////////////////////////////////////////////
// 게임, 네트워크 초기화
////////////////////////////////////////////////////////////////////////////////
InitialGame();
InitialNetwork(&client_sock, &g_hWnd);
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// 윈도우 사이즈 맞추기
///////////////////////////////////////////////////////////////////////////////////////////////////////////
SetFocus(g_hWnd);
RECT WindowRect;
WindowRect.top = 0;
WindowRect.left = 0;
WindowRect.right = 640;
WindowRect.bottom = 480;
AdjustWindowRectEx(&WindowRect, GetWindowStyle(g_hWnd), GetMenu(g_hWnd) != NULL, GetWindowExStyle(g_hWnd));
int iX = (GetSystemMetrics(SM_CXSCREEN) - 640) / 2;
int iY = (GetSystemMetrics(SM_CYSCREEN) - 480) / 2;
MoveWindow(g_hWnd, iX, iY, WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top, TRUE);
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// 기본 메시지 루프입니다.
while (1)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
Update_Game();
}
}
return (int) msg.wParam;
}
// fill task bar with buttons for enumerated top level windows
BOOL CALLBACK TaskBar::EnumWndProc(HWND hwnd, LPARAM lparam)
{
TaskBar* pThis = (TaskBar*)lparam;
DWORD style = GetWindowStyle(hwnd);
DWORD ex_style = GetWindowExStyle(hwnd);
if ((style&WS_VISIBLE) && !(ex_style&WS_EX_TOOLWINDOW) &&
!GetParent(hwnd) && !GetWindow(hwnd,GW_OWNER)) {
TCHAR title[BUFFER_LEN];
if (!GetWindowText(hwnd, title, BUFFER_LEN))
title[0] = '\0';
TaskBarMap::iterator found = pThis->_map.find(hwnd);
int last_id = 0;
if (found != pThis->_map.end()) {
last_id = found->second._id;
if (!last_id)
found->second._id = pThis->_next_id++;
} else {
HBITMAP hbmp;
HICON hIcon = get_window_icon_small(hwnd);
BOOL delete_icon = FALSE;
if (!hIcon) {
hIcon = LoadIcon(0, IDI_APPLICATION);
delete_icon = TRUE;
}
if (hIcon) {
hbmp = create_bitmap_from_icon(hIcon, GetSysColorBrush(COLOR_BTNFACE), WindowCanvas(pThis->_htoolbar));
if (delete_icon)
DestroyIcon(hIcon); // some icons can be freed, some not - so ignore any error return of DestroyIcon()
} else
hbmp = 0;
TBADDBITMAP ab = {0, (UINT_PTR)hbmp};
int bmp_idx = SendMessage(pThis->_htoolbar, TB_ADDBITMAP, 1, (LPARAM)&ab);
TaskBarEntry entry;
entry._id = pThis->_next_id++;
entry._hbmp = hbmp;
entry._bmp_idx = bmp_idx;
entry._title = title;
pThis->_map[hwnd] = entry;
found = pThis->_map.find(hwnd);
}
TBBUTTON btn = {-2/*I_IMAGENONE*/, 0, TBSTATE_ENABLED/*|TBSTATE_ELLIPSES*/, BTNS_BUTTON, {0, 0}, 0, 0};
TaskBarEntry& entry = found->second;
++entry._used;
btn.idCommand = entry._id;
HWND foreground = GetForegroundWindow();
HWND foreground_owner = GetWindow(foreground, GW_OWNER);
if (hwnd==foreground || hwnd==foreground_owner) {
btn.fsState |= TBSTATE_PRESSED|TBSTATE_CHECKED;
pThis->_last_foreground_wnd = hwnd;
}
if (!last_id) {
// create new toolbar buttons for new windows
if (title[0])
btn.iString = (INT_PTR)title;
btn.iBitmap = entry._bmp_idx;
entry._btn_idx = SendMessage(pThis->_htoolbar, TB_BUTTONCOUNT, 0, 0);
SendMessage(pThis->_htoolbar, TB_INSERTBUTTON, entry._btn_idx, (LPARAM)&btn);
pThis->ResizeButtons();
} else {
// refresh attributes of existing buttons
if (btn.fsState != entry._fsState)
SendMessage(pThis->_htoolbar, TB_SETSTATE, entry._id, MAKELONG(btn.fsState,0));
if (entry._title != title) {
TBBUTTONINFO info;
info.cbSize = sizeof(TBBUTTONINFO);
info.dwMask = TBIF_TEXT;
info.pszText = title;
SendMessage(pThis->_htoolbar, TB_SETBUTTONINFO, entry._id, (LPARAM)&info);
entry._title = title;
}
}
entry._fsState = btn.fsState;
#ifdef __REACTOS__ // now handled by activating the ARW_HIDE flag with SystemParametersInfo(SPI_SETMINIMIZEDMETRICS)
// move minimized windows out of sight
if (IsIconic(hwnd)) {
RECT rect;
GetWindowRect(hwnd, &rect);
if (rect.bottom > 0)
SetWindowPos(hwnd, 0, -32000, -32000, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
}
#endif
}
return TRUE;
}
static HRESULT CreateFullScreenDisplay(HWND hWnd, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
{
RECT rc;
DWORD dwStyle;
// Set app window's style to WS_POPUP so that it can fit for full screen mode.
dwStyle = GetWindowLong(hWnd, GWL_STYLE);
dwStyle &= ~(WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
dwStyle |= WS_POPUP;
SetWindowLong(hWnd, GWL_STYLE, dwStyle);
// Adapt window size
SetRect(&rc, 0, 0, dwWidth, dwHeight);
AdjustWindowRectEx(&rc, GetWindowStyle(hWnd), GetMenu(hWnd) != NULL, GetWindowExStyle(hWnd));
// Set cooperative level
if (FAILED(lpdd->SetCooperativeLevel(hWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT)))
{
return E_FAIL;
}
// Set the display mode
if (FAILED(lpdd->SetDisplayMode(dwWidth, dwHeight, dwBPP, 0, 0)))
{
return E_FAIL;
}
// Create primary surface (with backbuffer attached)
DDSURFACEDESC2 ddsd;
DDRAW_INIT_STRUCT(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT | DDSD_CKSRCBLT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP |
DDSCAPS_COMPLEX | DDSCAPS_3DDEVICE;
ddsd.dwBackBufferCount = 1;
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsMain, NULL)))
{
return E_FAIL;
}
// Get a pointer to the back buffer
DDSCAPS2 ddscaps;
ZeroMemory(&ddscaps, sizeof(ddscaps));
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
if (FAILED(lpddsMain->GetAttachedSurface(&ddscaps, &lpddsBack)))
{
return E_FAIL;
}
//lpddsBack->AddRef();
// Set surface color key
DDCOLORKEY ddCK;
ddCK.dwColorSpaceLowValue = 0;
ddCK.dwColorSpaceHighValue = 0;
if (lpddsBack->SetColorKey(DDCKEY_SRCBLT, &ddCK))
{
return E_FAIL;
}
// Update window flag
SetClassLong(hWnd, GCL_HICONSM, NULL);
SendMessage(hWnd, WM_SETICON, ICON_SMALL, NULL);
UpdateWindow(hWnd);
return S_OK;
}
static HRESULT CreateWindowedDisplay(HWND hWnd, DWORD dwWidth, DWORD dwHeight)
{
// Set cooperative level
if (FAILED(lpdd->SetCooperativeLevel(hWnd, DDSCL_NORMAL)))
{
return E_FAIL;
}
RECT rcWork;
RECT rc;
DWORD dwStyle;
// If we are still a WS_POPUP window
// We should convert to a normal app window so we look like a windows app.
dwStyle = GetWindowLong(hWnd, GWL_STYLE);
dwStyle &= ~WS_POPUP;
dwStyle |= WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
SetWindowLong(hWnd, GWL_STYLE, dwStyle);
// Adapt window size
SetRect(&rc, 0, 0, dwWidth, dwHeight);
AdjustWindowRectEx(&rc, GetWindowStyle(hWnd), GetMenu(hWnd) != NULL, GetWindowExStyle(hWnd));
SetWindowPos(hWnd, NULL, 0, 0, rc.right - rc.left, rc.bottom - rc.top, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
// Make sure our window does not hang outside of the work area
SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWork, 0);
GetWindowRect(hWnd, &rc);
if (rc.left < rcWork.left) rc.left = rcWork.left;
if (rc.top < rcWork.top) rc.top = rcWork.top;
SetWindowPos(hWnd, NULL, rc.left, rc.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
// Create the primary surface
DDSURFACEDESC2 ddsd;
DDRAW_INIT_STRUCT(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsMain, NULL)))
{
return E_FAIL;
}
// Create the backbuffer surface
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CKSRCBLT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
ddsd.dwWidth = dwWidth;
ddsd.dwHeight = dwHeight;
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsBack, NULL)))
{
return E_FAIL;
}
// Set surface color key
DDCOLORKEY ddCK;
ddCK.dwColorSpaceLowValue = 0;
ddCK.dwColorSpaceHighValue = 0;
if (lpddsBack->SetColorKey(DDCKEY_SRCBLT, &ddCK))
{
return E_FAIL;
}
// Create clipper for the primary surface
LPDIRECTDRAWCLIPPER lpClipper;
if (FAILED(lpdd->CreateClipper(0, &lpClipper, NULL)))
{
return E_FAIL;
}
if (FAILED(lpClipper->SetHWnd(0, hWnd)))
{
lpClipper->Release();
return E_FAIL;
}
if (FAILED(lpddsMain->SetClipper(lpClipper)))
{
lpClipper->Release();
return E_FAIL;
}
lpClipper->Release();
lpClipper = NULL;
// Update window flag
SetClassLong(hWnd, GCL_HICONSM, (LONG)LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICONSM)));
SendMessage(hWnd, WM_SETICON, ICON_SMALL, (LONG)LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICONSM)));
UpdateWindow(hWnd);
return S_OK;
}
bool CBasicWindow::CalcPositionFromClientRect(RECT *pRect) const
{
if (m_hwnd==NULL)
return false;
return ::AdjustWindowRectEx(pRect,GetWindowStyle(),FALSE,GetWindowExStyle())!=FALSE;
}
//
// - returns true if DirectDraw was initialized properly
//
int InitDirectDrawe (HWND appWin, int width, int height, int bpp, int fullScr)
{
DDSURFACEDESC ddsd; // DirectDraw surface description for allocating
DDSCAPS ddscaps;
HRESULT ddrval;
DWORD dwStyle;
RECT rect;
// enumerate directdraw devices
//if (FAILED(DirectDrawEnumerate (myEnumDDDevicesCallback, NULL)))
// I_Error("Error with DirectDrawEnumerate");
if (!DDr2)
CreateDirectDrawInstance();
// remember what screen mode we are in
bAppFullScreen = fullScr;
ScreenHeight = height;
ScreenWidth = width;
if (bAppFullScreen)
{
// Change window attributes
dwStyle = WS_POPUP | WS_VISIBLE;
SetWindowLong (appWin, GWL_STYLE, dwStyle);
SetWindowPos(appWin, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE |
SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
// Get exclusive mode
ddrval = IDirectDraw2_SetCooperativeLevel(DDr2, appWin, DDSCL_EXCLUSIVE |
DDSCL_FULLSCREEN |
DDSCL_ALLOWREBOOT);
if (ddrval != DD_OK)
I_Error("SetCooperativeLevel FAILED: %s\n", DXErrorToString(ddrval));
// Switch from windows desktop to fullscreen
#ifdef NT4COMPAT
ddrval = IDirectDraw2_SetDisplayMode(DDr2, width, height, bpp, 0, 0);
#else
ddrval = IDirectDraw2_SetDisplayMode(DDr2, width, height, bpp, 0, DDSDM_STANDARDVGAMODE);
#endif
if (ddrval != DD_OK)
I_Error("SetDisplayMode FAILED: %s\n", DXErrorToString(ddrval));
// This is not really needed, except in certain cases. One case
// is while using MFC. When the desktop is initally at 16bpp, a mode
// switch to 8bpp somehow causes the MFC window to not fully initialize
// and a CreateSurface will fail with DDERR_NOEXCLUSIVEMODE. This will
// ensure that the window is initialized properly after a mode switch.
ShowWindow(appWin, SW_SHOW);
// Create the primary surface with 1 back buffer. Always zero the
// DDSURFACEDESC structure and set the dwSize member!
ZeroMemory(&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
// for fullscreen we use page flipping, for windowed mode, we blit the hidden surface to
// the visible surface, in both cases we have a visible (or 'real') surface, and a hidden
// (or 'virtual', or 'backbuffer') surface.
ddsd.dwBackBufferCount = 2;
ddrval = IDirectDraw2_CreateSurface(DDr2,&ddsd, &ScreenReal, NULL);
if (ddrval != DD_OK)
I_Error("CreateSurface Primary Screen FAILED");
// Get a pointer to the back buffer
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
ddrval = IDirectDrawSurface_GetAttachedSurface(ScreenReal,&ddscaps, &ScreenVirtual);
if (ddrval != DD_OK)
I_Error("GetAttachedSurface FAILED");
}
else
{
rect.top = 0;
rect.left = 0;
rect.bottom = height;
rect.right = width;
// Change window attributes
dwStyle = GetWindowStyle(appWin);
dwStyle &= ~WS_POPUP;
dwStyle |= WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION;
SetWindowLong(appWin, GWL_STYLE, dwStyle);
// Resize the window so that the client area is the requested width/height
AdjustWindowRectEx(&rect, GetWindowStyle(appWin), GetMenu(appWin) != NULL,
GetWindowExStyle(appWin));
// Just in case the window was moved off the visible area of the
// screen.
SetWindowPos(appWin, NULL, 0, 0, rect.right-rect.left,
rect.bottom-rect.top, SWP_NOMOVE | SWP_NOZORDER |
SWP_NOACTIVATE);
SetWindowPos(appWin, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
// Exclusive mode is normal since it's in windowed mode and needs
// to cooperate with GDI
ddrval = IDirectDraw2_SetCooperativeLevel(DDr2,appWin, DDSCL_NORMAL);
if (ddrval != DD_OK)
I_Error("SetCooperativeLevel FAILED");
// Always zero the DDSURFACEDESC structure and set the dwSize member!
ZeroMemory(&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
// Create the primary surface
ddrval = IDirectDraw2_CreateSurface(DDr2,&ddsd, &ScreenReal, NULL);
if (ddrval != DD_OK)
I_Error("CreateSurface Primary Screen FAILED");
// Create a back buffer for offscreen rendering, this will be used to
// blt to the primary
ScreenVirtual = CreateNewSurface(width, height, DDSCAPS_OFFSCREENPLAIN |
DDSCAPS_SYSTEMMEMORY);
if (ScreenVirtual == NULL)
I_Error("CreateSurface Secondary Screen FAILED");
/// \todo get the desktop bit depth, and build a lookup table
/// for quick conversions of 8bit color indexes 0-255 to desktop colors
/// eg: 256 entries of equivalent of palette colors 0-255 in 15,16,24,32 bit format
/// when blit virtual to real, convert pixels through lookup table..
// Use a clipper object for clipping when in windowed mode
// (make sure our drawing doesn't affect other windows)
ddrval = IDirectDraw2_CreateClipper (DDr2, 0, &windclip, 0);
if (ddrval != DD_OK)
I_Error("CreateClipper FAILED");
// Associate the clipper with the window.
ddrval = IDirectDrawClipper_SetHWnd (windclip,0, appWin);
if (ddrval != DD_OK)
I_Error("Clipper -> SetHWnd FAILED");
// Attach the clipper to the surface.
ddrval = IDirectDrawSurface_SetClipper (ScreenReal,windclip);
if (ddrval != DD_OK)
I_Error("PrimaryScreen -> SetClipperClipper FAILED");
}
return TRUE;
}
void CWindowWnd::ResizeClient(int cx /*= -1*/, int cy /*= -1*/)
{
ASSERT(::IsWindow(m_hWnd));
RECT rc = { 0 };
if( !::GetClientRect(m_hWnd, &rc) ) return;
if( cx != -1 ) rc.right = cx;
if( cy != -1 ) rc.bottom = cy;
if( !::AdjustWindowRectEx(&rc, GetWindowStyle(m_hWnd), (!(GetWindowStyle(m_hWnd) & WS_CHILD) && (::GetMenu(m_hWnd) != NULL)), GetWindowExStyle(m_hWnd)) ) return;
::SetWindowPos(m_hWnd, NULL, 0, 0, rc.right - rc.left, rc.bottom - rc.top, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
}
//
// 函数: InitInstance(HINSTANCE, int)
//
// 目的: 保存实例句柄并创建主窗口
//
// 注释:
//
// 在此函数中，我们在全局变量中保存实例句柄并
// 创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HWND hWnd;
MSG msg; // generic message
hInst = hInstance; // 将实例句柄存储在全局变量中
hWnd = CreateWindow(szWindowClass, szTitle, (WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION),//WS_OVERLAPPEDWINDOW | WS_VISIBLE,
0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
main_window_handle = hWnd;
// now resize the window, so the client area is the actual size requested
// since there may be borders and controls if this is going to be a windowed app
// if the app is not windowed then it won't matter
RECT window_rect = { 0, 0, WINDOW_WIDTH - 1, WINDOW_HEIGHT - 1 };
// make the call to adjust window_rect
AdjustWindowRectEx(&window_rect,
GetWindowStyle(main_window_handle),
GetMenu(main_window_handle) != NULL,
GetWindowExStyle(main_window_handle));
// save the global client offsets, they are needed in DDraw_Flip()
//window_client_x0 = -window_rect.left;
//window_client_y0 = -window_rect.top;
// now resize the window with a call to MoveWindow()
MoveWindow(main_window_handle,
0, // x position
0, // y position
window_rect.right - window_rect.left, // width
window_rect.bottom - window_rect.top, // height
FALSE);
// show the window, so there's no garbage on first render
ShowWindow(hWnd, nCmdShow);
Game_Init();
while (1)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
// test if this is a quit
if (msg.message == WM_QUIT)
break;
// translate any accelerator keys
TranslateMessage(&msg);
// send the message to the window proc
DispatchMessage(&msg);
} // end if
// main game processing goes here
Game_Main();
} // end while
//UpdateWindow(hWnd);
Game_Shutdown();
return msg.wParam;
}
/* create a new page */
static BOOL
create_page (HWND hwnd, DWORD style, PPROPSHEETDATA propsheet, PROPPAGE *page,
PDLGTEMPLATE dlgtpl, WNDPROC proc)
{
int i, len, w, h;
PCTRLDATA ctrl;
HWND hCtrl;
RECT rcPage;
DWORD ex_style;
if ((dlgtpl->controlnr > 0) && !dlgtpl->controls)
return FALSE;
if (GetWindowExStyle (hwnd) & WS_EX_TRANSPARENT)
ex_style = WS_EX_TRANSPARENT | WS_EX_USEPARENTRDR;
else
ex_style = WS_EX_USEPARENTRDR;
GetClientRect (hwnd, &rcPage);
w = RECTW(rcPage) - OFFSET_VALUE*2;
h = RECTH(rcPage) -RECTH(propsheet->head_rc) - OFFSET_VALUE*2;
/* create content page */
if ((style & 0xf0L) == PSS_BOTTOM) {
page->hwnd = CreateWindowEx (CTRL_STATIC, "", SS_LEFT, ex_style,
IDC_STATIC,
OFFSET_VALUE, OFFSET_VALUE,
w, h,
hwnd, dlgtpl->dwAddData);
} else {
page->hwnd = CreateWindowEx (CTRL_STATIC, "", SS_LEFT, ex_style,
IDC_STATIC,
OFFSET_VALUE, OFFSET_VALUE + propsheet->head_rc.bottom,
w, h,
hwnd, dlgtpl->dwAddData);
}
if (page->hwnd == HWND_INVALID)
return FALSE;
len = strlen (dlgtpl->caption);
page->title = FixStrAlloc (len);
if (page->title)
strcpy (page->title, dlgtpl->caption);
page->proc = proc;
page->icon = dlgtpl->hIcon;
for (i = 0; i < dlgtpl->controlnr; i++) {
ctrl = dlgtpl->controls + i;
hCtrl = CreateWindowEx (ctrl->class_name, ctrl->caption,
ctrl->dwStyle | WS_CHILD, ctrl->dwExStyle,
ctrl->id, ctrl->x, ctrl->y, ctrl->w, ctrl->h,
page->hwnd, ctrl->dwAddData);
if (hCtrl == HWND_INVALID) {
DestroyWindow (page->hwnd);
if (page->title) {
FreeFixStr (page->title);
}
return FALSE;
}
}
SetWindowCallbackProc (page->hwnd, page->proc);
SendMessage (page->hwnd, MSG_INITPAGE, 0, dlgtpl->dwAddData);
return TRUE;
}
void CSDKMeetingChatUIMgr::InitWindow()
{
m_chat_controller_workflow.SetEvent(this);
RECT rc = { 0 };
if( !::GetClientRect(m_hWnd, &rc) ) return;
rc.right = rc.left + 380;
rc.bottom = rc.top + 500;
if( !::AdjustWindowRectEx(&rc, GetWindowStyle(m_hWnd), (!(GetWindowStyle(m_hWnd) & WS_CHILD) && (::GetMenu(m_hWnd) != NULL)), GetWindowExStyle(m_hWnd)) ) return;
int ScreenX = GetSystemMetrics(SM_CXSCREEN);
int ScreenY = GetSystemMetrics(SM_CYSCREEN);
::SetWindowPos(m_hWnd, NULL, (ScreenX - (rc.right - rc.left)) / 2,
(ScreenY - (rc.bottom - rc.top)) / 2, rc.right - rc.left, rc.bottom - rc.top, SWP_NOZORDER | SWP_SHOWWINDOW);
m_pUserListCombox = static_cast<CComboUI* >(m_PaintManager.FindControl(L"chat_to_who"));
m_input_content = static_cast<CRichEditUI* >(m_PaintManager.FindControl(L"chat_input_content_edit"));
m_show_chat_info = static_cast<CRichEditUI* >(m_PaintManager.FindControl(L"chat_show_content_edit"));
}
void CBasicWindow::GetPosition(int *pLeft,int *pTop,int *pWidth,int *pHeight) const
{
if (m_hwnd!=NULL) {
RECT rc;
if ((GetWindowStyle() & WS_CHILD)!=0) {
::GetWindowRect(m_hwnd,&rc);
::MapWindowPoints(NULL,::GetParent(m_hwnd),reinterpret_cast<POINT*>(&rc),2);
if (pLeft)
*pLeft=rc.left;
if (pTop)
*pTop=rc.top;
if (pWidth)
*pWidth=rc.right-rc.left;
if (pHeight)
*pHeight=rc.bottom-rc.top;
} else {
WINDOWPLACEMENT wp;
wp.length=sizeof(WINDOWPLACEMENT);
::GetWindowPlacement(m_hwnd,&wp);
if (wp.showCmd==SW_SHOWNORMAL) {
// 通常表示時はGetWindowRectの方が座標変換の問題がないので確実
::GetWindowRect(m_hwnd,&rc);
} else {
/*
WS_EX_TOOLWINDOWスタイルが付いていない場合は、
rcNormalPositionはワークスペース座標になる(仕様が意味不明...)
*/
if ((GetWindowExStyle() & WS_EX_TOOLWINDOW)==0) {
/*
ワークスペース座標をスクリーン座標に変換
しかし、マルチモニタの時はどのモニタのワークスペース座標が
基準になっているのか不明...
*/
HMONITOR hMonitor=::MonitorFromWindow(m_hwnd,MONITOR_DEFAULTTONEAREST);
MONITORINFO mi;
mi.cbSize=sizeof(MONITORINFO);
::GetMonitorInfo(hMonitor,&mi);
::OffsetRect(&wp.rcNormalPosition,
mi.rcWork.left-mi.rcMonitor.left,
mi.rcWork.top-mi.rcMonitor.top);
}
rc=wp.rcNormalPosition;
}
if (pLeft)
*pLeft=rc.left;
if (pTop)
*pTop=rc.top;
if (pWidth)
*pWidth=rc.right-rc.left;
if (pHeight)
*pHeight=rc.bottom-rc.top;
}
} else {
if (pLeft)
*pLeft=m_WindowPosition.Left;
if (pTop)
*pTop=m_WindowPosition.Top;
if (pWidth)
*pWidth=m_WindowPosition.Width;
if (pHeight)
*pHeight=m_WindowPosition.Height;
}
}
void CSDKLoginUIMgr::InitWindow()
{
m_LoginWithEmailUIGroup.InitWindow(m_PaintManager, this);
m_LoginWithSSOUIGroup.InitWindow(m_PaintManager, this);
m_WithoutLoginStartJoinMeetingUIGroup.InitWindow(m_PaintManager,this);
m_RestAPIUserUIGroup.InitWindow(m_PaintManager,this);
RECT rc = { 0 };
if( !::GetClientRect(m_hWnd, &rc) ) return;
rc.right = rc.left + 524;
rc.bottom = rc.top + 376;
if( !::AdjustWindowRectEx(&rc, GetWindowStyle(m_hWnd), (!(GetWindowStyle(m_hWnd) & WS_CHILD) && (::GetMenu(m_hWnd) != NULL)), GetWindowExStyle(m_hWnd)) ) return;
int ScreenX = GetSystemMetrics(SM_CXSCREEN);
int ScreenY = GetSystemMetrics(SM_CYSCREEN);
::SetWindowPos(m_hWnd, NULL, (ScreenX - (rc.right - rc.left)) / 2,
(ScreenY - (rc.bottom - rc.top)) / 2, rc.right - rc.left, rc.bottom - rc.top, SWP_NOZORDER | SWP_SHOWWINDOW);
m_waitingPage = static_cast<CVerticalLayoutUI* >(m_PaintManager.FindControl(_T("waiting")));
m_waitingLabelUI = static_cast<CLabelUI* >(m_PaintManager.FindControl(_T("waiting_label")));
m_gifWaiting = static_cast<CGifAnimUI*>(m_PaintManager.FindControl(_T("gif_waiting")));
m_btnLoginWithEmail = static_cast<COptionUI*>(m_PaintManager.FindControl(_T("tabbtn_login_with_email")));
m_btnRestAPI = static_cast<COptionUI*>(m_PaintManager.FindControl(_T("tabbtn_login_with_RestAPI")));
m_btnLoginWithSSO = static_cast<COptionUI*>(m_PaintManager.FindControl(_T("tabbtn_login_with_SSO")));
m_btnJoinMeetingOnly = static_cast<COptionUI*>(m_PaintManager.FindControl(_T("tabbtn_JoinMeetingOnly")));
m_panel_login_content = static_cast<CVerticalLayoutUI* >(m_PaintManager.FindControl(L"panel_Login_Content"));
m_email_login_page = static_cast<CVerticalLayoutUI* >(m_PaintManager.FindControl(L"panel_Login_With_Email"));
m_sso_login_page = static_cast<CVerticalLayoutUI* >(m_PaintManager.FindControl(L"panel_Login_With_SSO"));
m_restApi_login_page = static_cast<CVerticalLayoutUI* >(m_PaintManager.FindControl(L"panel_RestAPI_Without_Login"));
m_only_join_page = static_cast<CVerticalLayoutUI* >(m_PaintManager.FindControl(L"panel_Join_Meeting_Only"));
m_currentPage = m_email_login_page;
SwitchToWaitingPage(L"", false);
m_LoginCBHandler.SetUIEvent(this);
}
int WINAPI WinMain( HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{
// this is the winmain function
WNDCLASS winclass; // this will hold the class we create
HWND hwnd; // generic window handle
MSG msg; // generic message
HDC hdc; // generic dc
PAINTSTRUCT ps; // generic paintstruct
// first fill in the window class stucture
winclass.style = CS_DBLCLKS | CS_OWNDC |
CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc = WindowProc;
winclass.cbClsExtra = 0;
winclass.cbWndExtra = 0;
winclass.hInstance = hinstance;
winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName = NULL;
winclass.lpszClassName = WINDOW_CLASS_NAME;
// register the window class
if (!RegisterClass(&winclass))
return(0);
// create the window, note the test to see if WINDOWED_APP is
// true to select the appropriate window flags
if (!(hwnd = CreateWindow(WINDOW_CLASS_NAME, // class
WINDOW_TITLE, // title
(WINDOWED_APP ? (WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION) : (WS_POPUP | WS_VISIBLE)),
0,0, // x,y
WINDOW_WIDTH, // width
WINDOW_HEIGHT, // height
NULL, // handle to parent
NULL, // handle to menu
hinstance,// instance
NULL))) // creation parms
return(0);
// save the window handle and instance in a global
main_window_handle = hwnd;
main_instance = hinstance;
// resize the window so that client is really width x height
if (WINDOWED_APP)
{
// now resize the window, so the client area is the actual size requested
// since there may be borders and controls if this is going to be a windowed app
// if the app is not windowed then it won't matter
RECT window_rect = {0,0,WINDOW_WIDTH-1,WINDOW_HEIGHT-1};
// make the call to adjust window_rect
AdjustWindowRectEx(&window_rect,
GetWindowStyle(main_window_handle),
GetMenu(main_window_handle) != NULL,
GetWindowExStyle(main_window_handle));
// save the global client offsets, they are needed in DDraw_Flip()
window_client_x0 = -window_rect.left;
window_client_y0 = -window_rect.top;
// now resize the window with a call to MoveWindow()
MoveWindow(main_window_handle,
0, // x position
0, // y position
window_rect.right - window_rect.left, // width
window_rect.bottom - window_rect.top, // height
FALSE);
// show the window, so there's no garbage on first render
ShowWindow(main_window_handle, SW_SHOW);
} // end if windowed
// perform all game console specific initialization
Game_Init();
// disable CTRL-ALT_DEL, ALT_TAB, comment this line out
// if it causes your system to crash
SystemParametersInfo(SPI_SCREENSAVERRUNNING, TRUE, NULL, 0);
// enter main event loop
while(1)
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
// test if this is a quit
if (msg.message == WM_QUIT)
break;
// translate any accelerator keys
TranslateMessage(&msg);
// send the message to the window proc
DispatchMessage(&msg);
} // end if
// main game processing goes here
Game_Main();
} // end while
// shutdown game and release all resources
Game_Shutdown();
// enable CTRL-ALT_DEL, ALT_TAB, comment this line out
// if it causes your system to crash
SystemParametersInfo(SPI_SCREENSAVERRUNNING, FALSE, NULL, 0);
// return to Windows like this
return(msg.wParam);
} // end WinMain
(GetSystemMetrics(SM_CXSCREEN) - 640)/2, (GetSystemMetrics(SM_CYSCREEN) - 480)/2, RECT window_rect; GetWindowRect(hwnd,&window_rect); AdjustWindowRectEx(&window_rect, GetWindowStyle(hwnd), GetMenu(hwnd)!=NULL, GetWindowExStyle(hwnd)); SetWindowPos(hwnd, HWND_TOP, (GetSystemMetrics(SM_CXSCREEN) - (window_rect.right - window_rect.left))/2, (GetSystemMetrics(SM_CYSCREEN) - (window_rect.bottom - window_rect.top))/2, window_rect.right - window_rect.left, window_rect.bottom - window_rect.top, SWP_SHOWWINDOW);
