CView::CView(const CRect& WindowRect, std::string sTitle, bool bResizable, bool bFullScreen) :
CWindow(WindowRect, 0),
m_bResizable(bResizable),
m_bFullScreen(bFullScreen),
m_pMenu(0),
m_pFloatingWindow(0),
m_pScreenSurface(0)
{
if (m_pInstance)
{
throw(Wg_Ex_App("Cannot have more than one view at a time!"));
}
m_pInstance = this;
CMessageServer::Instance().RegisterMessageClient(this, CMessage::APP_PAINT);
CMessageServer::Instance().RegisterMessageClient(this, CMessage::APP_DESTROY_FRAME, CMessageServer::PRIORITY_FIRST);
CMessageServer::Instance().RegisterMessageClient(this, CMessage::CTRL_RESIZE);
CMessageServer::Instance().RegisterMessageClient(this, CMessage::MOUSE_BUTTONDOWN, CMessageServer::PRIORITY_FIRST);
CMessageServer::Instance().RegisterMessageClient(this, CMessage::MOUSE_BUTTONUP, CMessageServer::PRIORITY_FIRST);
SetWindowRect(WindowRect);
SetWindowText(sTitle);
CApplication::Instance()->GetApplicationLog().AddLogEntry("Created new CView : " + sTitle, APP_LOG_INFO);
Draw();
}
bool console::SetSize(COORD Size) const
{
if (!sWindowMode)
return SetConsoleScreenBufferSize(GetOutputHandle(), Size) != FALSE;
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(GetOutputHandle(), &csbi);
csbi.srWindow.Left = 0;
csbi.srWindow.Right = Size.X - 1;
csbi.srWindow.Bottom = csbi.dwSize.Y - 1;
csbi.srWindow.Top = csbi.srWindow.Bottom - (Size.Y - 1);
COORD WindowCoord = { static_cast<SHORT>(csbi.srWindow.Right - csbi.srWindow.Left + 1), static_cast<SHORT>(csbi.srWindow.Bottom - csbi.srWindow.Top + 1) };
if (WindowCoord.X > csbi.dwSize.X || WindowCoord.Y > csbi.dwSize.Y)
{
WindowCoord.X = std::max(WindowCoord.X, csbi.dwSize.X);
WindowCoord.Y = std::max(WindowCoord.Y, csbi.dwSize.Y);
SetConsoleScreenBufferSize(GetOutputHandle(), WindowCoord);
if (WindowCoord.X > csbi.dwSize.X)
{
// windows sometimes uses existing colors to init right region of screen buffer
FarColor Color;
GetTextAttributes(Color);
ClearExtraRegions(Color, CR_RIGHT);
}
}
return SetWindowRect(csbi.srWindow);
}
void CView::SwitchMode(const CRect& WindowRect, bool bResizable, bool bFullScreen)
{
m_bResizable = bResizable;
m_bFullScreen = bFullScreen;
SetWindowRect(WindowRect);
}
void RunPostChangeStatus()
{
int NewHeight = StatusHeight();
if (OldHeight != NewHeight)
{
RECT winrect;
GetWindowRect(hFrameWnd,&winrect);
winrect.bottom += NewHeight-OldHeight;
MoveOK=timeGetTime();
SetWindowRect(hFrameWnd,&winrect);
}
}
//-----------------------------------------------------------------
//! \brief Display menu at screen position
//! \return Pointer to selected Item Desc
//-----------------------------------------------------------------
void NMenuCtrl::TrackPopupMenu(NPoint _ptScreen, NMenuCtrl* _pParentMenu/*=null*/)
{
TRACE("NMenuCtrl::TrackPopupMenu\n");
m_dwReturnCmdID = 0;
//Calc Menu rect
NRect rc;
CalcMenuSize(rc);
//Move Menu
//if (m_pParentWnd)
// m_pParentWnd->ClientToScreen(_ptScreen);
// Clipping
NRect rcApp = GetGUISubSystem()->GetMainWnd()->GetWindowRect();
if(_ptScreen.x + rc.Width() > rcApp.right)
_ptScreen.x -= _ptScreen.x + rc.Width() - rcApp.right;
if(_ptScreen.y + rc.Height() > rcApp.bottom)
_ptScreen.y -= _ptScreen.y + rc.Height() - rcApp.bottom;
if (m_pParentWnd)
m_pParentWnd->ScreenToClient(_ptScreen);
rc.Move(_ptScreen);
SetWindowRect(rc);
//TRACE("TrackPopupMenu %d,%d-%d,%d\n", rc.left, rc.top, rc.right, rc.bottom);
//TRACE("Count %d\n", m_carrayItems.Count());
//TRACE("_pParentMenu %d\n", _pParentMenu);
if (_pParentMenu==null) SetFocus();
//Display menu window
ShowMenu(true, _pParentMenu);
//Graphic update
//Update();
}
virtual bool SetSize(COORD Size) const override
{
bool Result=false;
if(Global->Opt->WindowMode)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(GetOutputHandle(), &csbi);
csbi.srWindow.Left=0;
csbi.srWindow.Right=Size.X-1;
csbi.srWindow.Bottom=csbi.dwSize.Y-1;
csbi.srWindow.Top=csbi.srWindow.Bottom-(Size.Y-1);
COORD WindowCoord={static_cast<SHORT>(csbi.srWindow.Right-csbi.srWindow.Left+1), static_cast<SHORT>(csbi.srWindow.Bottom-csbi.srWindow.Top+1)};
if(WindowCoord.X>csbi.dwSize.X || WindowCoord.Y>csbi.dwSize.Y)
{
WindowCoord.X=std::max(WindowCoord.X,csbi.dwSize.X);
WindowCoord.Y=std::max(WindowCoord.Y,csbi.dwSize.Y);
SetConsoleScreenBufferSize(GetOutputHandle(), WindowCoord);
if(WindowCoord.X>csbi.dwSize.X)
{
// windows sometimes uses existing colors to init right region of screen buffer
FarColor Color;
Console().GetTextAttributes(Color);
Console().ClearExtraRegions(Color, CR_RIGHT);
}
}
if(SetWindowRect(csbi.srWindow))
{
csbi.dwSize.X = Size.X;
Result=SetConsoleScreenBufferSize(GetOutputHandle(), csbi.dwSize)!=FALSE;
}
}
else
{
Result=SetConsoleScreenBufferSize(GetOutputHandle(), Size)!=FALSE;
}
return Result;
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance
, LPSTR lpszCmdParam, int nCmdShow)
{
#if defined (DEBUG) | defined (_DEBUG)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
//아이콘 로드
HICON hIcon = reinterpret_cast<HICON>(::LoadImage(hInstance, MAKEINTRESOURCE(IDI_ICON2),
IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR));
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, WndProc, 0L, 0L,
GetModuleHandle(NULL),
hIcon,
NULL,
NULL,
NULL,
GENERIC::gAppName.c_str(),
hIcon };
RegisterClassEx(&wc);
DWORD style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
HWND hWnd = CreateWindow(GENERIC::gAppName.c_str(), GENERIC::gAppName.c_str(),
style, CW_USEDEFAULT, 0, GENERIC::windowWidth, GENERIC::windowHeight,
GetDesktopWindow(), NULL, wc.hInstance, NULL);
Console::Get()->Initialize("Debug Console", hInstance, hPrevInstance, lpszCmdParam, nCmdShow);
DEBUG_CONSOLE("Hello!\n");
gAppPuased = false;
InitializeObjects(hWnd);
SetWindowRect(hWnd);
ShowWindow(hWnd, SW_SHOWDEFAULT);
UpdateWindow(hWnd);
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
GameTimer::Get()->UpdateTickCount();
if (!gAppPuased)
{
float tick = GameTimer::Get()->DeltaTime();
General::Get()->Update(tick);
//RenderDevice::Get()->UpdateScene(tick);
RenderDevice::Get()->Render11();
CalculateFrameStats(hWnd);
}
else
{
Sleep(1);
}
}
RenderDevice::Get()->Release();
UnregisterClass(GENERIC::gAppName.c_str(), wc.hInstance);
return 0;
}
void MemMgr_OnSize (void)
{
WINDOWSIZES Sizes;
MemMgr_GetWindowSizes (&Sizes);
SetWindowRect (GetDlgItem (l.hManager, IDC_BOX_ALLOC), &Sizes.rBoxAlloc);
SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_CPP), &Sizes.rLabelCpp);
SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_OTHER), &Sizes.rLabelOther);
SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_TARED), &Sizes.rLabelTared);
SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_TOTAL), &Sizes.rLabelTotal);
SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_COUNT), &Sizes.rLabelCount);
SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_SIZE), &Sizes.rLabelSize);
SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_AVERAGE), &Sizes.rLabelAverage);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_CPP_COUNT), &Sizes.rValueCppCount);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_OTHER_COUNT), &Sizes.rValueOtherCount);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TARED_COUNT), &Sizes.rValueTaredCount);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TOTAL_COUNT), &Sizes.rValueTotalCount);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_CPP_SIZE), &Sizes.rValueCppSize);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_OTHER_SIZE), &Sizes.rValueOtherSize);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TARED_SIZE), &Sizes.rValueTaredSize);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TOTAL_SIZE), &Sizes.rValueTotalSize);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_CPP_AVERAGE), &Sizes.rValueCppAverage);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_OTHER_AVERAGE), &Sizes.rValueOtherAverage);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TARED_AVERAGE), &Sizes.rValueTaredAverage);
SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TOTAL_AVERAGE), &Sizes.rValueTotalAverage);
SetWindowRect (GetDlgItem (l.hManager, IDC_BOX_DETAILS), &Sizes.rBoxDetails);
SetWindowRect (GetDlgItem (l.hManager, IDC_LIST), &Sizes.rList);
SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL), &Sizes.rLabel);
SetWindowRect (GetDlgItem (l.hManager, IDC_HIDE), &Sizes.rHide);
SetWindowRect (GetDlgItem (l.hManager, IDC_TARE), &Sizes.rTare);
SetWindowRect (GetDlgItem (l.hManager, IDC_RESET), &Sizes.rReset);
SetWindowRect (GetDlgItem (l.hManager, IDCANCEL), &Sizes.rClose);
}
void CToolTip::ShowTip(const CPoint& DrawPoint)
{
SetWindowRect(m_pParentWindow->ViewToClient(m_BoundingRect + DrawPoint));
SetVisible(true);
Draw();
}
void wxMessageDialog::AdjustButtonLabels()
{
// changing the button labels is the easy part but we also need to ensure
// that the buttons are big enough for the label strings and increase their
// size (and maybe the size of the message box itself) if they are not
// TODO-RTL: check whether this works correctly in RTL
// we want to use this font in GetTextExtent() calls below but we don't
// want to send WM_SETFONT to the message box, who knows how is it going to
// react to it (right now it doesn't seem to do anything but what if this
// changes)
wxWindowBase::SetFont(GetMessageFont());
// first iteration: find the widest button and update the buttons labels
int wBtnOld = 0, // current buttons width
wBtnNew = 0; // required new buttons width
RECT rcBtn; // stores the button height and y positions
unsigned numButtons = 0; // total number of buttons in the message box
unsigned n;
for ( n = 0; n < WXSIZEOF(ms_buttons); n++ )
{
const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id);
if ( !hwndBtn )
continue; // it's ok, not all buttons are always present
numButtons++;
const wxString label = (this->*ms_buttons[n].getter)();
const wxSize sizeLabel = wxWindowBase::GetTextExtent(label);
// check if the button is big enough for this label
const RECT rc = wxGetWindowRect(hwndBtn);
if ( !wBtnOld )
{
// initialize wBtnOld using the first button width, all the other
// ones should have the same one
wBtnOld = rc.right - rc.left;
rcBtn = rc; // remember for use below when we reposition the buttons
}
else
{
wxASSERT_MSG( wBtnOld == rc.right - rc.left,
"all buttons are supposed to be of same width" );
}
const int widthNeeded = wxMSWButton::GetFittingSize(this, sizeLabel).x;
if ( widthNeeded > wBtnNew )
wBtnNew = widthNeeded;
::SetWindowText(hwndBtn, label.wx_str());
}
if ( wBtnNew <= wBtnOld )
{
// all buttons fit, nothing else to do
return;
}
// resize the message box to be wider if needed
const int wBoxOld = wxGetClientRect(GetHwnd()).right;
const int CHAR_WIDTH = GetCharWidth();
const int MARGIN_OUTER = 2*CHAR_WIDTH; // margin between box and buttons
const int MARGIN_INNER = CHAR_WIDTH; // margin between buttons
RECT rcBox = wxGetWindowRect(GetHwnd());
const int wAllButtons = numButtons*(wBtnNew + MARGIN_INNER) - MARGIN_INNER;
int wBoxNew = 2*MARGIN_OUTER + wAllButtons;
if ( wBoxNew > wBoxOld )
{
const int dw = wBoxNew - wBoxOld;
rcBox.left -= dw/2;
rcBox.right += dw - dw/2;
SetWindowRect(GetHwnd(), rcBox);
// surprisingly, we don't need to resize the static text control, it
// seems to adjust itself to the new size, at least under Windows 2003
// (TODO: test if this happens on older Windows versions)
}
else // the current width is big enough
{
wBoxNew = wBoxOld;
}
// finally position all buttons
// notice that we have to take into account the difference between window
// and client width
rcBtn.left = (rcBox.left + rcBox.right - wxGetClientRect(GetHwnd()).right +
wBoxNew - wAllButtons) / 2;
rcBtn.right = rcBtn.left + wBtnNew;
for ( n = 0; n < WXSIZEOF(ms_buttons); n++ )
{
const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id);
if ( !hwndBtn )
continue;
MoveWindowToScreenRect(hwndBtn, rcBtn);
rcBtn.left += wBtnNew + MARGIN_INNER;
rcBtn.right += wBtnNew + MARGIN_INNER;
}
}
void wxMessageDialog::ReplaceStaticWithEdit()
{
// check if the message box fits the display
int nDisplay = wxDisplay::GetFromWindow(this);
if ( nDisplay == wxNOT_FOUND )
nDisplay = 0;
const wxRect rectDisplay = wxDisplay(nDisplay).GetClientArea();
if ( rectDisplay.Contains(GetRect()) )
{
// nothing to do
return;
}
// find the static control to replace: normally there are two of them, the
// icon and the text itself so search for all of them and ignore the icon
// ones
HWND hwndStatic = ::FindWindowEx(GetHwnd(), NULL, wxT("STATIC"), NULL);
if ( ::GetWindowLong(hwndStatic, GWL_STYLE) & SS_ICON )
hwndStatic = ::FindWindowEx(GetHwnd(), hwndStatic, wxT("STATIC"), NULL);
if ( !hwndStatic )
{
wxLogDebug("Failed to find the static text control in message box.");
return;
}
// set the right font for GetCharHeight() call below
wxWindowBase::SetFont(GetMessageFont());
// put the new edit control at the same place
RECT rc = wxGetWindowRect(hwndStatic);
ScreenRectToClient(GetHwnd(), rc);
// but make it less tall so that the message box fits on the screen: we try
// to make the message box take no more than 7/8 of the screen to leave
// some space above and below it
const int hText = (7*rectDisplay.height)/8 -
(
2*::GetSystemMetrics(SM_CYFIXEDFRAME) +
::GetSystemMetrics(SM_CYCAPTION) +
5*GetCharHeight() // buttons + margins
);
const int dh = (rc.bottom - rc.top) - hText; // vertical space we save
rc.bottom -= dh;
// and it also must be wider as it needs a vertical scrollbar (in order
// to preserve the word wrap, otherwise the number of lines would change
// and we want the control to look as similar as possible to the original)
//
// NB: you would have thought that 2*SM_CXEDGE would be enough but it
// isn't, somehow, and the text control breaks lines differently from
// the static one so fudge by adding some extra space
const int dw = ::GetSystemMetrics(SM_CXVSCROLL) +
4*::GetSystemMetrics(SM_CXEDGE);
rc.right += dw;
// chop of the trailing new line(s) from the message box text, they are
// ignored by the static control but result in extra lines and hence extra
// scrollbar position in the edit one
wxString text(wxGetWindowText(hwndStatic));
for ( wxString::reverse_iterator i = text.rbegin(); i != text.rend(); ++i )
{
if ( *i != '\n' )
{
// found last non-newline char, remove everything after it and stop
text.erase(i.base() + 1, text.end());
break;
}
}
// do create the new control
HWND hwndEdit = ::CreateWindow
(
wxT("EDIT"),
wxTextBuffer::Translate(text).wx_str(),
WS_CHILD | WS_VSCROLL | WS_VISIBLE |
ES_MULTILINE | ES_READONLY | ES_AUTOVSCROLL,
rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top,
GetHwnd(),
NULL,
wxGetInstance(),
NULL
);
if ( !hwndEdit )
{
wxLogDebug("Creation of replacement edit control failed in message box");
return;
}
// copy the font from the original control
LRESULT hfont = ::SendMessage(hwndStatic, WM_GETFONT, 0, 0);
::SendMessage(hwndEdit, WM_SETFONT, hfont, 0);
// and get rid of it
::DestroyWindow(hwndStatic);
// shrink and centre the message box vertically and widen it box to account
// for the extra scrollbar
RECT rcBox = wxGetWindowRect(GetHwnd());
const int hMsgBox = rcBox.bottom - rcBox.top - dh;
rcBox.top = (rectDisplay.height - hMsgBox)/2;
rcBox.bottom = rcBox.top + hMsgBox + (rectDisplay.height - hMsgBox)%2;
rcBox.left -= dw/2;
rcBox.right += dw - dw/2;
SetWindowRect(GetHwnd(), rcBox);
// and adjust all the buttons positions
for ( unsigned n = 0; n < WXSIZEOF(ms_buttons); n++ )
{
const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id);
if ( !hwndBtn )
continue; // it's ok, not all buttons are always present
RECT rc = wxGetWindowRect(hwndBtn);
rc.top -= dh;
rc.bottom -= dh;
rc.left += dw/2;
rc.right += dw/2;
MoveWindowToScreenRect(hwndBtn, rc);
}
}