void Game_Genie_Window_CreateChildWindows(HWND hWnd)
{
// Description labels.
HWND lblInfoTitle, lblInfo;
// Strings
const char* strInfoTitle = "Information about Game Genie / Patch codes";
const char* strInfo =
"Both Game Genie codes and Patch codes are supported.\n"
"Check the box next to the code to activate it.\n"
"Syntax for Game Genie codes: XXXX-YYYY\n"
"Syntax for Patch codes: AAAAAA-DDDD (address-data)";
// Info Title
lblInfoTitle = CreateWindow(WC_STATIC, strInfoTitle,
WS_CHILD | WS_VISIBLE | SS_LEFT,
8, 8, 256, 16, hWnd, NULL, ghInstance, NULL);
SetWindowFont(lblInfoTitle, fntTitle, TRUE);
// Info
lblInfo = CreateWindow(WC_STATIC, strInfo,
WS_CHILD | WS_VISIBLE | SS_LEFT,
8, 24, wndWidth-16, 68, hWnd, NULL, ghInstance, NULL);
SetWindowFont(lblInfo, fntMain, TRUE);
// Code and Name boxes, plus "Add Code" button.
HWND lblCode, btnAddCode;
HWND lblName;
// Code label
lblCode = CreateWindow(WC_STATIC, "Code",
WS_CHILD | WS_VISIBLE | SS_LEFT,
8, 24+68+8, 32, 16, hWnd, NULL, ghInstance, NULL);
SetWindowFont(lblCode, fntMain, TRUE);
// Code entry
gg_txtCode = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, NULL,
WS_CHILD | WS_VISIBLE | WS_TABSTOP | SS_LEFT | ES_AUTOHSCROLL,
8+32+8, 24+68+8, wndWidth - (8+32+8+64+8+8+16), 20,
hWnd, NULL, ghInstance, NULL);
SetWindowFont(gg_txtCode, fntMain, TRUE);
gg_txtCode_oldProc = (WNDPROC)SetWindowLongPtr(gg_txtCode, GWL_WNDPROC, (LONG_PTR)Game_Genie_TextBox_WndProc);
// Name label
lblName = CreateWindow(WC_STATIC, "Name",
WS_CHILD | WS_VISIBLE | SS_LEFT,
8, 24+68+8+24, 32, 16,
hWnd, NULL, ghInstance, NULL);
SetWindowFont(lblName, fntMain, TRUE);
// Name entry
gg_txtName = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, NULL,
WS_CHILD | WS_VISIBLE | WS_TABSTOP | SS_LEFT | ES_AUTOHSCROLL,
8+32+8, 24+68+8+24, wndWidth - (8+32+8+64+8+8+16), 20,
hWnd, NULL, ghInstance, NULL);
SetWindowFont(gg_txtName, fntMain, TRUE);
gg_txtName_oldProc = (WNDPROC)SetWindowLongPtr(gg_txtName, GWL_WNDPROC, (LONG_PTR)Game_Genie_TextBox_WndProc);
// Add Code
btnAddCode = CreateWindow(WC_BUTTON, "&Add Code",
WS_CHILD | WS_VISIBLE | WS_TABSTOP,
wndWidth - (64+8+16), 24+68+8, 63+16, 20,
hWnd, IDC_BTN_ADD, ghInstance, NULL);
SetWindowFont(btnAddCode, fntMain, TRUE);
// ListView
gg_lstvCodes = CreateWindowEx(WS_EX_CLIENTEDGE, WC_LISTVIEW, "",
WS_CHILD | WS_VISIBLE | WS_TABSTOP | LVS_REPORT,
8, 24+68+8+24+24, wndWidth - (8+8), 128,
hWnd, NULL, ghInstance, NULL);
SetWindowFont(gg_lstvCodes, fntMain, TRUE);
SendMessage(gg_lstvCodes, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT);
// Create the ListView columns.
LV_COLUMN lvCol;
memset(&lvCol, 0, sizeof(lvCol));
lvCol.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
// Code
lvCol.pszText = "Code";
lvCol.cx = 128;
SendMessage(gg_lstvCodes, LVM_INSERTCOLUMN, 0, (LPARAM)&lvCol);
// Name
lvCol.pszText = "Name";
lvCol.cx = 256;
SendMessage(gg_lstvCodes, LVM_INSERTCOLUMN, 1, (LPARAM)&lvCol);
// Buttons
const int btnTop = 24+68+8+24+24+128+8;
HWND btnOK, btnApply, btnCancel, btnDeactivateAll, btnDelete;
btnOK = CreateWindow(WC_BUTTON, "&OK", WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON,
8, btnTop, 75, 23,
hWnd, (HMENU)IDC_BTN_OK, ghInstance, NULL);
SetWindowFont(btnOK, fntMain, TRUE);
btnApply = CreateWindow(WC_BUTTON, "&Apply", WS_CHILD | WS_VISIBLE | WS_TABSTOP,
8+75+8, btnTop, 75, 23,
hWnd, (HMENU)IDC_BTN_APPLY, ghInstance, NULL);
SetWindowFont(btnApply, fntMain, TRUE);
btnCancel = CreateWindow(WC_BUTTON, "&Cancel", WS_CHILD | WS_VISIBLE | WS_TABSTOP,
8+75+8+75+8, btnTop, 75, 23,
hWnd, (HMENU)IDC_BTN_CANCEL, ghInstance, NULL);
SetWindowFont(btnCancel, fntMain, TRUE);
btnDelete = CreateWindow(WC_BUTTON, "&Delete", WS_CHILD | WS_VISIBLE | WS_TABSTOP,
8+75+8+75+8+75+8, btnTop, 75, 23,
hWnd, (HMENU)IDC_BTN_DELETE, ghInstance, NULL);
SetWindowFont(btnDelete, fntMain, TRUE);
btnDeactivateAll = CreateWindow(WC_BUTTON, "Deac&tivate All", WS_CHILD | WS_VISIBLE | WS_TABSTOP,
8+75+8+75+8+75+8+75+8, btnTop, 75+16, 23,
hWnd, (HMENU)IDC_BTN_DEACTIVATEALL, ghInstance, NULL);
SetWindowFont(btnDeactivateAll, fntMain, TRUE);
// Set focus to the Code textbox.
SetFocus(gg_txtCode);
}
DWORD WINAPI _WinMain(LPVOID lpParam)
{
HWND hwnd;
MSG messages;
WNDCLASSEX wincl;
/*
wincl.hInstance = hInstance;
wincl.lpszClassName = szClassName;
wincl.lpfnWndProc = WindowProcedure;
wincl.style = CS_DBLCLKS;
wincl.cbSize = sizeof (WNDCLASSEX);
wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
MessageBox(NULL,"AA","AA",MB_OK);
*/
wincl.cbSize = sizeof(wincl); // size of structure
wincl.style = CS_HREDRAW |
CS_VREDRAW; // redraw if size changes
wincl.lpfnWndProc = WndProc; // points to window procedure
wincl.cbClsExtra = 0; // no extra class memory
wincl.cbWndExtra = 0; // no extra window memory
wincl.hInstance = _hinst; // handle to instance
wincl.hIcon = LoadIcon(NULL,
IDI_APPLICATION); // predefined app. icon
wincl.hCursor = LoadCursor(NULL,
IDC_ARROW); // predefined arrow
wincl.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
// wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND; // white background brush
wincl.lpszMenuName = "MainMenu"; // name of menu resource
wincl.lpszClassName = "MainWClass"; // name of window class
wincl.hIconSm = NULL;
char buf[100];
//sprintf(buf,"%d",_hinst);
// MessageBox(NULL,buf,"11",MB_OK);
if (!RegisterClassEx (&wincl))
return 0;
hwnd = CreateWindowEx (
0,
szClassName, /* Classname */
"MainWClass", /* Title Text */
WS_OVERLAPPEDWINDOW, /* default window */
// CW_USEDEFAULT, /* Windows decides the position */
// CW_USEDEFAULT, /* where the window ends up on the screen */
0,
0,
640, /* The programs width */
400, /* and height in pixels */
HWND_DESKTOP, /* The window is a child-window to desktop */
NULL, /* No menu */
_hinst, /* Program Instance handler */
NULL /* No Window Creation data */
);
if(!hwnd)
{
long lError;
lError = ::GetLastError();
sprintf(buf,"%d, %d",hwnd,lError);
MessageBox(NULL,buf,"22",MB_OK);
return 0;
}
_hwnd=hwnd;
/* Make the window visible on the screen */
ShowWindow (hwnd, SW_SHOWNORMAL);
UpdateWindow(hwnd);
/* Run the message loop. It will run until GetMessage() returns 0 */
while (GetMessage (&messages, NULL, 0, 0))
{
/* Translate virtual-key messages into character messages */
TranslateMessage(&messages);
/* Send message to WindowProcedure */
DispatchMessage(&messages);
}
/* The program return-value is 0 - The value that PostQuitMessage() gave */
return messages.wParam;
}
boolean wf_post_connect(freerdp* instance)
{
rdpGdi* gdi;
wfInfo* wfi;
rdpCache* cache;
wfContext* context;
int width, height;
wchar_t win_title[64];
rdpSettings* settings;
settings = instance->settings;
context = (wfContext*) instance->context;
cache = instance->context->cache;
wfi = context->wfi;
wfi->dstBpp = 32;
width = settings->width;
height = settings->height;
if (wfi->sw_gdi)
{
gdi_init(instance, CLRCONV_ALPHA | CLRBUF_32BPP, NULL);
gdi = instance->context->gdi;
wfi->hdc = gdi->primary->hdc;
wfi->primary = wf_image_new(wfi, width, height, wfi->dstBpp, gdi->primary_buffer);
}
else
{
wf_gdi_register_update_callbacks(instance->update);
wfi->srcBpp = instance->settings->color_depth;
wfi->primary = wf_image_new(wfi, width, height, wfi->dstBpp, NULL);
wfi->hdc = gdi_GetDC();
wfi->hdc->bitsPerPixel = wfi->dstBpp;
wfi->hdc->bytesPerPixel = wfi->dstBpp / 8;
wfi->hdc->alpha = wfi->clrconv->alpha;
wfi->hdc->invert = wfi->clrconv->invert;
wfi->hdc->hwnd = (HGDI_WND) malloc(sizeof(GDI_WND));
wfi->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0);
wfi->hdc->hwnd->invalid->null = 1;
wfi->hdc->hwnd->count = 32;
wfi->hdc->hwnd->cinvalid = (HGDI_RGN) malloc(sizeof(GDI_RGN) * wfi->hdc->hwnd->count);
wfi->hdc->hwnd->ninvalid = 0;
}
if (strlen(wfi->window_title) > 0)
_snwprintf(win_title, sizeof(win_title), L"%S", wfi->window_title);
else if (settings->port == 3389)
_snwprintf(win_title, sizeof(win_title) / sizeof(win_title[0]), L"%S - FreeRDP", settings->hostname);
else
_snwprintf(win_title, sizeof(win_title) / sizeof(win_title[0]), L"%S:%d - FreeRDP", settings->hostname, settings->port);
if (wfi->hwnd == 0)
{
wfi->hwnd = CreateWindowEx((DWORD) NULL, g_wnd_class_name, win_title,
0, 0, 0, 0, 0, NULL, NULL, g_hInstance, NULL);
SetWindowLongPtr(wfi->hwnd, GWLP_USERDATA, (LONG_PTR) wfi);
}
if (wfi->fullscreen)
{
SetWindowLongPtr(wfi->hwnd, GWL_STYLE, WS_POPUP);
SetWindowPos(wfi->hwnd, HWND_TOP, 0, 0, width, height, SWP_FRAMECHANGED);
}
else
{
POINT diff;
RECT rc_client, rc_wnd;
SetWindowLongPtr(wfi->hwnd, GWL_STYLE, WS_CAPTION | WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX);
/* Now resize to get full canvas size and room for caption and borders */
SetWindowPos(wfi->hwnd, HWND_TOP, 10, 10, width, height, SWP_FRAMECHANGED);
GetClientRect(wfi->hwnd, &rc_client);
GetWindowRect(wfi->hwnd, &rc_wnd);
diff.x = (rc_wnd.right - rc_wnd.left) - rc_client.right;
diff.y = (rc_wnd.bottom - rc_wnd.top) - rc_client.bottom;
SetWindowPos(wfi->hwnd, HWND_TOP, -1, -1, width + diff.x, height + diff.y, SWP_NOMOVE | SWP_FRAMECHANGED);
}
BitBlt(wfi->primary->hdc, 0, 0, width, height, NULL, 0, 0, BLACKNESS);
wfi->drawing = wfi->primary;
ShowWindow(wfi->hwnd, SW_SHOWNORMAL);
UpdateWindow(wfi->hwnd);
if (wfi->sw_gdi)
{
instance->update->BeginPaint = wf_sw_begin_paint;
instance->update->EndPaint = wf_sw_end_paint;
}
else
{
instance->update->BeginPaint = wf_hw_begin_paint;
instance->update->EndPaint = wf_hw_end_paint;
}
pointer_cache_register_callbacks(instance->update);
if (wfi->sw_gdi != True)
{
brush_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
offscreen_cache_register_callbacks(instance->update);
}
wf_register_graphics(instance->context->graphics);
freerdp_channels_post_connect(instance->context->channels, instance);
return True;
}
/* This Code Creates Our OpenGL Window. Parameters Are:
* lpszTitle - Title to Appear at the Top of the Window
* hWndParent - Parent HWND where the screne will be drawn
* nZBuffer - Number of Bits to Use for Z-Buffer (16/32)
*/
bool CGL::Create(char* lpszTitle, HWND hWndParent, int nZBuffer=16) : m_bFullScreen(false)
{
GLuint PixelFormat; // Holds The Results After Searching For A Match
WNDCLASS wc; // Windows Class Structure
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT rectWindow; // Grabs Rectangle Upper Left / Lower Right Values
int nWidth,
nHeight;
// Get window size
GetClientRect(hWndParent, &rectWindow);
nWidth = rectWindow.right-rectWindow.left;
nHeight = rectWindow.bottom-rectWindow.top;
m_hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = m_hInstance; // Set The Instance
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For GL
wc.lpszMenuName = NULL; // We Don't Want A Menu
wc.lpszClassName = "OpenGL"; // Set The Class Name
if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{
MessageBox(m_hWnd,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return false; // Return false
}
dwExStyle = WS_EX_APPWINDOW; // Window Extended Style
//dwStyle = WS_OVERLAPPEDWINDOW; // Windows Style
dwStyle = WS_DISABLED | WS_VISIBLE | WS_CHILD; // Windows Style
AdjustWindowRectEx(&rectWindow, dwStyle, false, dwExStyle); // Adjust Window To true Requested Size
// Create The Window
if (!(m_hWnd=CreateWindowEx(dwExStyle, // Extended Style For The Window
"OpenGL", // Class Name
lpszTitle, // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
NULL, // No Parent Window
NULL, // No Menu
m_hInstance, // Instance
NULL))) // Dont Pass Anything To WM_CREATE
{
KillGLWindow(); // Reset The Display
MessageBox(m_hWnd,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return false; // Return false
}
static PIXELFORMATDESCRIPTOR pfd = // pfd Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
nBits, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
nZBuffer, // 16/32Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
if (!(m_hDC=GetDC(m_hWnd))) // Did We Get A Device Context?
{
KillGLWindow(); // Reset The Display
MessageBox(m_hWnd,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return false; // Return false
}
if (!(PixelFormat=ChoosePixelFormat(m_hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(m_hWnd,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return false; // Return false
}
if(!SetPixelFormat(m_hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(m_hWnd,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return false; // Return false
}
if (!(hRC=wglCreateContext(m_hDC))) // Are We Able To Get A Rendering Context?
{
KillGLWindow(); // Reset The Display
MessageBox(m_hWnd,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return false; // Return false
}
if(!wglMakeCurrent(m_hDC,hRC)) // Try To Activate The Rendering Context
{
KillGLWindow(); // Reset The Display
MessageBox(m_hWnd,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return false; // Return false
}
ShowWindow(m_hWnd, SW_SHOW); // Show The Window
SetForegroundWindow(m_hWnd); // Slightly Higher Priority
SetFocus(m_hWnd); // Sets Keyboard Focus To The Window
Resize(nWidth, nHeight); // Set Up Our Perspective GL Screen
if (!Init()) // Initialize Our Newly Created GL Window
{
KillGLWindow(); // Reset The Display
MessageBox(m_hWnd,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return false; // Return false
}
return true; // Success
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
RECT rect;
COLORREF colorText = RGB(0, 0, 255); // задаём цвет текста
switch (message)
{
case WM_COMMAND:
case BN_CLICKED:
if (LOWORD(wParam) == ID_BUTTON1)
{
GetClientRect(hWnd, &rect);
edit1 = CreateWindowEx(
WS_EX_CLIENTEDGE,
L"edit",
L"Нажмите правую клавишу мыши",
WS_CHILD | WS_VISIBLE | EM_FMTLINES,
rect.right / 4, /*координаты по X*/
rect.bottom / 4, /*координаты по Y*/
rect.right / 2, /*Ширина окошка*/
rect.bottom / 2,
hWnd,
(HMENU)ID_EDIT1,
hinst,
NULL);
}
break;
case WM_RBUTTONDOWN:
ShowWindow(edit1, SW_HIDE);
break;
case WM_CREATE:
GetClientRect(hWnd, &rect);
button1 = CreateWindowEx(
WS_EX_CLIENTEDGE,
L"button",
L"Показать",
WS_CHILD | WS_VISIBLE,
rect.right / 2 - ARRAYSIZE(L"Показать") * 4 - 10, /*координаты по X*/
rect.bottom - 30, /*координаты по Y*/
ARRAYSIZE(L"Показать") * 10, /*Ширина окошка*/
25,
hWnd,
(HMENU)ID_BUTTON1,
hinst,
NULL);
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps); // инициализируем контекст устройства
GetClientRect(hWnd, &rect); // получаем ширину и высоту области для рисования
SetTextColor(hdc, colorText); // устанавливаем цвет контекстного устройства
DrawText(hdc, L"В в е д и т е т е к с т", -1, &rect, DT_SINGLELINE | DT_CENTER); // рисуем текст
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
break;
}
return 0;
}
INT_PTR SettingsVideo::ProcMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
HWND hwndTemp;
switch(message)
{
case WM_INITDIALOG:
{
LocalizeWindow(hwnd);
//--------------------------------------------
HWND hwndToolTip = CreateWindowEx(NULL, TOOLTIPS_CLASS, NULL, WS_POPUP|TTS_NOPREFIX|TTS_ALWAYSTIP,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hwnd, NULL, hinstMain, NULL);
TOOLINFO ti;
zero(&ti, sizeof(ti));
ti.cbSize = sizeof(ti);
ti.uFlags = TTF_SUBCLASS|TTF_IDISHWND;
ti.hwnd = hwnd;
SendMessage(hwndToolTip, TTM_SETMAXTIPWIDTH, 0, 500);
SendMessage(hwndToolTip, TTM_SETDELAYTIME, TTDT_AUTOPOP, 8000);
//--------------------------------------------
hwndTemp = GetDlgItem(hwnd, IDC_MONITOR);
App->monitors.Clear();
EnumDisplayMonitors(NULL, NULL, (MONITORENUMPROC)MonitorInfoEnumProc, (LPARAM)&App->monitors);
for(UINT i=0; i<App->monitors.Num(); i++)
SendMessage(hwndTemp, CB_ADDSTRING, 0, (LPARAM)IntString(i+1).Array());
int monitorID = LoadSettingComboInt(hwndTemp, TEXT("Video"), TEXT("Monitor"), 0, App->monitors.Num()-1);
if(monitorID > (int)App->monitors.Num())
monitorID = 0;
//--------------------------------------------
SendMessage(GetDlgItem(hwnd, IDC_USECUSTOM), BM_SETCHECK, BST_CHECKED, 0);
EnableWindow(GetDlgItem(hwnd, IDC_MONITOR), FALSE);
//--------------------------------------------
int cx, cy;
if(!AppConfig->HasKey(TEXT("Video"), TEXT("BaseWidth")) || !AppConfig->HasKey(TEXT("Video"), TEXT("BaseHeight")))
{
cx = App->monitors[monitorID].rect.right - App->monitors[monitorID].rect.left;
cy = App->monitors[monitorID].rect.bottom - App->monitors[monitorID].rect.top;
AppConfig->SetInt(TEXT("Video"), TEXT("BaseWidth"), cx);
AppConfig->SetInt(TEXT("Video"), TEXT("BaseHeight"), cy);
}
else
{
cx = AppConfig->GetInt(TEXT("Video"), TEXT("BaseWidth"));
cy = AppConfig->GetInt(TEXT("Video"), TEXT("BaseHeight"));
if(cx < 128) cx = 128;
else if(cx > 4096) cx = 4096;
if(cy < 128) cy = 128;
else if(cy > 4096) cy = 4096;
}
hwndTemp = GetDlgItem(hwnd, IDC_SIZEX);
editProc = (FARPROC)GetWindowLongPtr(hwndTemp, GWLP_WNDPROC);
SetWindowLongPtr(hwndTemp, GWLP_WNDPROC, (LONG_PTR)ResolutionEditSubclassProc);
SetWindowText(hwndTemp, IntString(cx).Array());
hwndTemp = GetDlgItem(hwnd, IDC_SIZEY);
SetWindowLongPtr(hwndTemp, GWLP_WNDPROC, (LONG_PTR)ResolutionEditSubclassProc);
SetWindowText(hwndTemp, IntString(cy).Array());
//--------------------------------------------
hwndTemp = GetDlgItem(hwnd, IDC_DISABLEAERO);
if(OSGetVersion() == 8)
EnableWindow(hwndTemp, FALSE);
BOOL bDisableAero = AppConfig->GetInt(TEXT("Video"), TEXT("DisableAero"), 0);
SendMessage(hwndTemp, BM_SETCHECK, bDisableAero ? BST_CHECKED : 0, 0);
ti.lpszText = (LPWSTR)Str("Settings.Video.DisableAeroTooltip");
ti.uId = (UINT_PTR)hwndTemp;
SendMessage(hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&ti);
//--------------------------------------------
BOOL bUnlockFPS = AppConfig->GetInt(TEXT("Video"), TEXT("UnlockFPS"));
int topFPS = bUnlockFPS ? 120 : 60;
hwndTemp = GetDlgItem(hwnd, IDC_FPS);
SendMessage(hwndTemp, UDM_SETRANGE32, 10, topFPS);
int fps = AppConfig->GetInt(TEXT("Video"), TEXT("FPS"), 30);
if(!AppConfig->HasKey(TEXT("Video"), TEXT("FPS")))
{
AppConfig->SetInt(TEXT("Video"), TEXT("FPS"), 30);
fps = 30;
}
else if(fps < 10)
{
AppConfig->SetInt(TEXT("Video"), TEXT("FPS"), 10);
fps = 10;
}
else if(fps > topFPS)
{
AppConfig->SetInt(TEXT("Video"), TEXT("FPS"), topFPS);
fps = topFPS;
}
SendMessage(hwndTemp, UDM_SETPOS32, 0, fps);
//--------------------------------------------
hwndTemp = GetDlgItem(hwnd, IDC_DOWNSCALE);
RefreshDownscales(hwndTemp, cx, cy);
ti.lpszText = (LPWSTR)Str("Settings.Video.DownscaleTooltip");
ti.uId = (UINT_PTR)hwndTemp;
SendMessage(hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&ti);
//--------------------------------------------
ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_HIDE);
SetChangedSettings(false);
return TRUE;
}
case WM_COMMAND:
{
bool bDataChanged = false;
switch(LOWORD(wParam))
{
case IDC_MONITOR:
{
if(HIWORD(wParam) != CBN_SELCHANGE)
break;
int sel = (int)SendMessage(GetDlgItem(hwnd, IDC_MONITOR), CB_GETCURSEL, 0, 0);
if(sel != CB_ERR)
{
if(sel >= (int)App->monitors.Num())
sel = 0;
MonitorInfo &monitor = App->monitors[sel];
int cx, cy;
cx = monitor.rect.right - monitor.rect.left;
cy = monitor.rect.bottom - monitor.rect.top;
SetWindowText(GetDlgItem(hwnd, IDC_SIZEX), IntString(cx).Array());
SetWindowText(GetDlgItem(hwnd, IDC_SIZEY), IntString(cy).Array());
}
break;
}
case IDC_USECUSTOM:
SendMessage(GetDlgItem(hwnd, IDC_SIZEX), EM_SETREADONLY, FALSE, 0);
SendMessage(GetDlgItem(hwnd, IDC_SIZEY), EM_SETREADONLY, FALSE, 0);
EnableWindow(GetDlgItem(hwnd, IDC_MONITOR), FALSE);
break;
case IDC_USEMONITOR:
{
SendMessage(GetDlgItem(hwnd, IDC_SIZEX), EM_SETREADONLY, TRUE, 0);
SendMessage(GetDlgItem(hwnd, IDC_SIZEY), EM_SETREADONLY, TRUE, 0);
EnableWindow(GetDlgItem(hwnd, IDC_MONITOR), TRUE);
int sel = (int)SendMessage(GetDlgItem(hwnd, IDC_MONITOR), CB_GETCURSEL, 0, 0);
if(sel != CB_ERR)
{
if(sel >= (int)App->monitors.Num())
sel = 0;
MonitorInfo &monitor = App->monitors[sel];
int cx, cy;
cx = monitor.rect.right - monitor.rect.left;
cy = monitor.rect.bottom - monitor.rect.top;
SetWindowText(GetDlgItem(hwnd, IDC_SIZEX), IntString(cx).Array());
SetWindowText(GetDlgItem(hwnd, IDC_SIZEY), IntString(cy).Array());
}
break;
}
case IDC_SIZEX:
case IDC_SIZEY:
{
if(HIWORD(wParam) != EN_CHANGE)
break;
String strInt = GetEditText((HWND)lParam);
int iVal = strInt.ToInt();
int cx = GetEditText(GetDlgItem(hwnd, IDC_SIZEX)).ToInt();
int cy = GetEditText(GetDlgItem(hwnd, IDC_SIZEY)).ToInt();
if(cx < 128) cx = 128;
else if(cx > 4096) cx = 4096;
if(cy < 128) cy = 128;
else if(cy > 4096) cy = 4096;
RefreshDownscales(GetDlgItem(hwnd, IDC_DOWNSCALE), cx, cy);
bDataChanged = true;
break;
}
case IDC_DISABLEAERO:
if(HIWORD(wParam) == BN_CLICKED)
bDataChanged = true;
break;
case IDC_FPS_EDIT:
if(HIWORD(wParam) == EN_CHANGE)
bDataChanged = true;
break;
case IDC_DOWNSCALE:
if(HIWORD(wParam) == CBN_SELCHANGE)
bDataChanged = true;
break;
}
if(bDataChanged)
{
ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_SHOW);
SetChangedSettings(true);
}
break;
}
}
return FALSE;
}
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
char const * class_name = "Pong";
char const * window_title = "Adolf Hitler Pong";
WNDCLASSEX window_class;
window_class.cbSize = sizeof(window_class);
window_class.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;
window_class.lpfnWndProc = &window_procedure;
window_class.cbClsExtra = 0;
window_class.cbWndExtra = 0;
window_class.hInstance = hInstance;
window_class.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_HITLER));
window_class.hCursor = LoadCursor(0, IDC_ARROW);
window_class.hbrBackground = reinterpret_cast<HBRUSH>(GetStockObject(WHITE_BRUSH));
window_class.lpszMenuName = 0;
window_class.lpszClassName = class_name;
window_class.hIconSm = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_HITLER));
RegisterClassEx(&window_class);
HWND window_handle = CreateWindowEx(0, class_name, window_title, WS_POPUP | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, window_width, window_height, 0, 0, hInstance, 0);
//SetTimer(window_handle, 0, 1000 / fps, 0);
std::string arguments(lpCmdLine);
if(!arguments.empty())
{
if(arguments[0] == '"' && arguments.length() >= 2)
{
arguments.erase(arguments.begin());
arguments.erase(arguments.end() - 1);
}
bool success = game.load_demo(arguments);
if(!success)
{
MessageBox(window_handle, "Unable to load demo file", "Demo playback error", MB_OK | MB_ICONERROR);
SendMessage(window_handle, WM_DESTROY, 0, 0);
return 0;
}
}
else
game.start_game();
nil::ini ini;
if(ini.load("pong.ini"))
{
game.set_demo_level_limit(ini.number<unsigned>("demo_level_limit", 3));
SetThreadPriority(GetCurrentThread(), ini.number<int>("thread_priority", 0));
}
LARGE_INTEGER frequency_struct;
QueryPerformanceFrequency(&frequency_struct);
unsigned long long divisor = frequency_struct.QuadPart / fps;
unsigned long long last_state = 0ull;
while(run)
{
MSG message;
while(PeekMessage(&message, window_handle, 0, 0, PM_REMOVE))
{
TranslateMessage(&message);
DispatchMessage(&message);
}
LARGE_INTEGER counter;
QueryPerformanceCounter(&counter);
unsigned long long current_state = counter.QuadPart / divisor;
if(last_state < current_state)
{
game.invalidate(window_handle);
game.process_frame(window_handle);
last_state = current_state;
}
//Sleep(20);
}
return 0;
}
BOOL CreateWindowGL (GL_Window* window) // This Code Creates Our OpenGL Window
{
DWORD windowStyle = WS_OVERLAPPEDWINDOW; // Define Our Window Style
DWORD windowExtendedStyle = WS_EX_APPWINDOW; // Define The Window's Extended Style
PIXELFORMATDESCRIPTOR pfd = // pfd Tells Windows How We Want Things To Be
{
sizeof (PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
window->init.bitsPerPixel, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
RECT windowRect = {0, 0, window->init.width, window->init.height}; // Define Our Window Coordinates
GLuint PixelFormat; // Will Hold The Selected Pixel Format
if (window->init.isFullScreen == TRUE) // Fullscreen Requested, Try Changing Video Modes
{
if (ChangeScreenResolution (window->init.width, window->init.height, window->init.bitsPerPixel) == FALSE)
{
// Fullscreen Mode Failed. Run In Windowed Mode Instead
MessageBox (HWND_DESKTOP, "Mode Switch Failed.\nRunning In Windowed Mode.", "Error", MB_OK | MB_ICONEXCLAMATION);
window->init.isFullScreen = FALSE; // Set isFullscreen To False (Windowed Mode)
}
else // Otherwise (If Fullscreen Mode Was Successful)
{
ShowCursor (FALSE); // Turn Off The Cursor
windowStyle = WS_POPUP; // Set The WindowStyle To WS_POPUP (Popup Window)
windowExtendedStyle |= WS_EX_TOPMOST; // Set The Extended Window Style To WS_EX_TOPMOST
} // (Top Window Covering Everything Else)
}
else // If Fullscreen Was Not Selected
{
// Adjust Window, Account For Window Borders
AdjustWindowRectEx (&windowRect, windowStyle, 0, windowExtendedStyle);
}
// Create The OpenGL Window
window->hWnd = CreateWindowEx (windowExtendedStyle, // Extended Style
window->init.application->className, // Class Name
window->init.title, // Window Title
windowStyle, // Window Style
0, 0, // Window X,Y Position
windowRect.right - windowRect.left, // Window Width
windowRect.bottom - windowRect.top, // Window Height
HWND_DESKTOP, // Desktop Is Window's Parent
0, // No Menu
window->init.application->hInstance, // Pass The Window Instance
window);
if (window->hWnd == 0) // Was Window Creation A Success?
{
return FALSE; // If Not Return False
}
window->hDC = GetDC (window->hWnd); // Grab A Device Context For This Window
if (window->hDC == 0) // Did We Get A Device Context?
{
// Failed
DestroyWindow (window->hWnd); // Destroy The Window
window->hWnd = 0; // Zero The Window Handle
return FALSE; // Return False
}
PixelFormat = ChoosePixelFormat (window->hDC, &pfd); // Find A Compatible Pixel Format
if (PixelFormat == 0) // Did We Find A Compatible Format?
{
// Failed
ReleaseDC (window->hWnd, window->hDC); // Release Our Device Context
window->hDC = 0; // Zero The Device Context
DestroyWindow (window->hWnd); // Destroy The Window
window->hWnd = 0; // Zero The Window Handle
return FALSE; // Return False
}
if (SetPixelFormat (window->hDC, PixelFormat, &pfd) == FALSE) // Try To Set The Pixel Format
{
// Failed
ReleaseDC (window->hWnd, window->hDC); // Release Our Device Context
window->hDC = 0; // Zero The Device Context
DestroyWindow (window->hWnd); // Destroy The Window
window->hWnd = 0; // Zero The Window Handle
return FALSE; // Return False
}
window->hRC = wglCreateContext (window->hDC); // Try To Get A Rendering Context
if (window->hRC == 0) // Did We Get A Rendering Context?
{
// Failed
ReleaseDC (window->hWnd, window->hDC); // Release Our Device Context
window->hDC = 0; // Zero The Device Context
DestroyWindow (window->hWnd); // Destroy The Window
window->hWnd = 0; // Zero The Window Handle
return FALSE; // Return False
}
// Make The Rendering Context Our Current Rendering Context
if (wglMakeCurrent (window->hDC, window->hRC) == FALSE)
{
// Failed
wglDeleteContext (window->hRC); // Delete The Rendering Context
window->hRC = 0; // Zero The Rendering Context
ReleaseDC (window->hWnd, window->hDC); // Release Our Device Context
window->hDC = 0; // Zero The Device Context
DestroyWindow (window->hWnd); // Destroy The Window
window->hWnd = 0; // Zero The Window Handle
return FALSE; // Return False
}
ShowWindow (window->hWnd, SW_NORMAL); // Make The Window Visible
window->isVisible = TRUE; // Set isVisible To True
//ReshapeGL (window->init.width, window->init.height); // Reshape Our GL Window
ZeroMemory (window->keys, sizeof (Keys)); // Clear All Keys
window->lastTickCount = GetTickCount (); // Get Tick Count
return TRUE; // Window Creating Was A Success
// Initialization Will Be Done In WM_CREATE
}
void SystemClass::InitializeWindows(int& screenWidth, int& screenHeight)
{
WNDCLASSEX wc;
DEVMODE dmScreenSettings;
int posX, posY;
// Get an external pointer to this object.
ApplicationHandle = this;
// Get the instance of this application.
m_hinstance = GetModuleHandle(NULL);
// Give the application a name.
m_applicationName = L"Engine";
// Setup the windows class with default settings.
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = m_hinstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hIconSm = wc.hIcon;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = m_applicationName;
wc.cbSize = sizeof(WNDCLASSEX);
// Register the window class.
RegisterClassEx(&wc);
// Determine the resolution of the clients desktop screen.
screenWidth = GetSystemMetrics(SM_CXSCREEN);
screenHeight = GetSystemMetrics(SM_CYSCREEN);
// Setup the screen settings depending on whether it is running in full screen or in windowed mode.
if(FULL_SCREEN)
{
// If full screen set the screen to maximum size of the users desktop and 32bit.
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = (unsigned long)screenWidth;
dmScreenSettings.dmPelsHeight = (unsigned long)screenHeight;
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
// Change the display settings to full screen.
ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
// Set the position of the window to the top left corner.
posX = posY = 0;
}
else
{
// If windowed then set it to 800x600 resolution.
screenWidth = 800;
screenHeight = 600;
// Place the window in the middle of the screen.
posX = (GetSystemMetrics(SM_CXSCREEN) - screenWidth) / 2;
posY = (GetSystemMetrics(SM_CYSCREEN) - screenHeight) / 2;
}
// Create the window with the screen settings and get the handle to it.
m_hwnd = CreateWindowEx(WS_EX_APPWINDOW, m_applicationName, m_applicationName,
WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_POPUP,
posX, posY, screenWidth, screenHeight, NULL, NULL, m_hinstance, NULL);
// Bring the window up on the screen and set it as main focus.
ShowWindow(m_hwnd, SW_SHOW);
SetForegroundWindow(m_hwnd);
SetFocus(m_hwnd);
// Hide the mouse cursor.
ShowCursor(false);
return;
}
//************************************
// Method: CreateWindow
// FullName: QuackWin::CreateWindow
// Access: public
// Returns: bool
// Qualifier:
// Parameter: int width
// Parameter: int height
// Parameter: int colorBits
//************************************
bool QuackWin::B_CreateWindow(int width, int height, int colorBits) {
if (!classRegistered) {
WNDCLASS wc;
memset(&wc, 0, sizeof(wc));
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC)wndproc;
wc.cbClsExtra = 0;
wc.cbWndExtra = sizeof(void*)+sizeof(int);
wc.hInstance = GetModuleHandle(NULL);
//wc.hIcon = LoadIcon(hinstOpenGL, MAKEINTRESOURCE(IDI_ICON1));
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = 0;
wc.lpszClassName = WINDOW_CLASS_NAME;
if (!RegisterClass(&wc)) {
// TODO: Add safe error here
// unable to register class
}
classRegistered = true;
}
// create HWND
if (!hWnd) {
hWnd = CreateWindowEx(
WS_EX_APPWINDOW | WS_EX_WINDOWEDGE,
WINDOW_CLASS_NAME,
"Quack",
WS_VISIBLE | WS_OVERLAPPEDWINDOW,
0,
0,
width,
height,
NULL,
NULL,
hinstOpenGL,
this
);
if (!hWnd) {
// error creating the window
}
ShowWindow(hWnd, SW_SHOW);
UpdateWindow(hWnd);
}
if (!(hDC = GetDC(hWnd))) {
ShowWindow(hWnd, SW_HIDE);
DestroyWindow(hWnd);
hWnd = NULL;
return false;
}
// Create OpenGL Context
if (!MakeContext()) {
ShowWindow(hWnd, SW_HIDE);
DestroyWindow(hWnd);
hWnd = NULL;
return false;
}
SetForegroundWindow(hWnd);
SetFocus(hWnd);
return true;
}
bool InitGLCapture()
{
static HWND hwndOpenGLSetupWindow = NULL;
bool bSuccess = false;
if(!hwndOpenGLSetupWindow)
{
WNDCLASSEX windowClass;
ZeroMemory(&windowClass, sizeof(windowClass));
windowClass.cbSize = sizeof(windowClass);
windowClass.style = CS_OWNDC;
windowClass.lpfnWndProc = DefWindowProc;
windowClass.lpszClassName = TEXT("OBSOGLHookClass");
windowClass.hInstance = hinstMain;
if(RegisterClassEx(&windowClass))
{
hwndOpenGLSetupWindow = CreateWindowEx (0,
TEXT("OBSOGLHookClass"),
TEXT("OBS OpenGL Context Window"),
WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
0, 0,
1, 1,
NULL,
NULL,
hinstMain,
NULL
);
}
}
HMODULE hGL = GetModuleHandle(TEXT("opengl32.dll"));
if(hGL && hwndOpenGLSetupWindow)
{
pglReadBuffer = (GLREADBUFFERPROC) GetProcAddress(hGL, "glReadBuffer");
pglReadPixels = (GLREADPIXELSPROC) GetProcAddress(hGL, "glReadPixels");
pglGetError = (GLGETERRORPROC) GetProcAddress(hGL, "glGetError");
pwglSwapLayerBuffers= (WGLSWAPLAYERBUFFERSPROC) GetProcAddress(hGL, "wglSwapLayerBuffers");
pwglSwapBuffers= (WGLSWAPBUFFERSPROC) GetProcAddress(hGL, "wglSwapBuffers");
pwglDeleteContext = (WGLDELETECONTEXTPROC) GetProcAddress(hGL, "wglDeleteContext");
pwglGetProcAddress = (WGLGETPROCADDRESSPROC) GetProcAddress(hGL, "wglGetProcAddress");
pwglMakeCurrent = (WGLMAKECURRENTPROC) GetProcAddress(hGL, "wglMakeCurrent");
pwglCreateContext = (WGLCREATECONTEXTPROC) GetProcAddress(hGL, "wglCreateContext");
if( !pglReadBuffer || !pglReadPixels || !pglGetError || !pwglSwapLayerBuffers || !pwglSwapBuffers ||
!pwglDeleteContext || !pwglGetProcAddress || !pwglMakeCurrent || !pwglCreateContext)
{
return false;
}
HDC hDC = GetDC(hwndOpenGLSetupWindow);
if(hDC)
{
PIXELFORMATDESCRIPTOR pfd;
ZeroMemory(&pfd, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_GENERIC_ACCELERATED;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 32;
pfd.cAccumBits = 32;
pfd.iLayerType = PFD_MAIN_PLANE;
SetPixelFormat(hDC, ChoosePixelFormat(hDC, &pfd), &pfd);
HGLRC hGlrc = jimglCreateContext(hDC);
if(hGlrc)
{
jimglMakeCurrent(hDC, hGlrc);
pglBufferData = (GLBUFFERDATAARBPROC) jimglGetProcAddress("glBufferData");
pglDeleteBuffers = (GLDELETEBUFFERSARBPROC) jimglGetProcAddress("glDeleteBuffers");
pglGenBuffers = (GLGENBUFFERSARBPROC) jimglGetProcAddress("glGenBuffers");
pglMapBuffer = (GLMAPBUFFERPROC) jimglGetProcAddress("glMapBuffer");
pglUnmapBuffer = (GLUNMAPBUFFERPROC) jimglGetProcAddress("glUnmapBuffer");
pglBindBuffer = (GLBINDBUFFERPROC) jimglGetProcAddress("glBindBuffer");
UINT lastErr = GetLastError();
if(pglBufferData && pglDeleteBuffers && pglGenBuffers && pglMapBuffer && pglUnmapBuffer && pglBindBuffer)
{
glHookSwapBuffers.Hook((FARPROC)SwapBuffers, (FARPROC)SwapBuffersHook);
glHookSwapLayerBuffers.Hook((FARPROC)jimglSwapLayerBuffers, (FARPROC)wglSwapLayerBuffersHook);
glHookwglSwapBuffers.Hook((FARPROC)jimglSwapBuffers, (FARPROC)wglSwapBuffersHook);
glHookDeleteContext.Hook((FARPROC)jimglDeleteContext, (FARPROC)wglDeleteContextHook);
bSuccess = true;
}
jimglMakeCurrent(NULL, NULL);
jimglDeleteContext(hGlrc);
ReleaseDC(hwndOpenGLSetupWindow, hDC);
if(bSuccess)
{
glHookSwapBuffers.Rehook();
glHookSwapLayerBuffers.Rehook();
glHookwglSwapBuffers.Rehook();
glHookDeleteContext.Rehook();
DestroyWindow(hwndOpenGLSetupWindow);
hwndOpenGLSetupWindow = NULL;
UnregisterClass(TEXT("OBSOGLHookClass"), hinstMain);
}
}
if(hwndOpenGLSetupWindow)
ReleaseDC(hwndOpenGLSetupWindow, hDC);
}
}
return bSuccess;
}
void khm_create_standard_toolbar(HWND rebar) {
HWND hwtb;
SIZE sz;
HBITMAP hbm_blank;
HIMAGELIST hiList;
REBARBANDINFO rbi;
khui_menu_def * def;
khui_action * act;
khui_action_ref * aref;
int idx_blank;
def = khui_find_menu(KHUI_TOOLBAR_STANDARD);
if (!def) {
#ifdef DEBUG
assert(FALSE);
#endif
return;
}
hwtb = CreateWindowEx(0 ,
TOOLBARCLASSNAME,
(LPWSTR) NULL,
WS_CHILD |
TBSTYLE_FLAT |
TBSTYLE_AUTOSIZE |
TBSTYLE_TOOLTIPS |
CCS_NORESIZE |
CCS_NOPARENTALIGN |
CCS_ADJUSTABLE |
CCS_NODIVIDER,
0, 0, 0, 0, rebar,
(HMENU) NULL, khm_hInstance,
NULL);
if(!hwtb) {
#ifdef DEBUG
assert(FALSE);
#endif
return;
}
#if (_WIN32_IE >= 0x0501)
SendMessage(hwtb, TB_SETEXTENDEDSTYLE, 0,
TBSTYLE_EX_MIXEDBUTTONS | TBSTYLE_EX_DRAWDDARROWS);
#endif
hiList = ImageList_Create(
KHUI_TOOLBAR_IMAGE_WIDTH,
KHUI_TOOLBAR_IMAGE_HEIGHT,
ILC_MASK,
(int) khui_action_list_length(def->items),
3);
hbm_blank = LoadImage(khm_hInstance,
MAKEINTRESOURCE(IDB_TB_BLANK),
IMAGE_BITMAP,
KHUI_TOOLBAR_IMAGE_WIDTH,
KHUI_TOOLBAR_IMAGE_HEIGHT, 0);
idx_blank = ImageList_AddMasked(hiList, hbm_blank, RGB(0,0,0));
khui_hwnd_standard_toolbar = hwtb;
khui_tb_blank = idx_blank;
def = khui_find_menu(KHUI_TOOLBAR_STANDARD);
aref = def->items;
SendMessage(hwtb,
TB_BUTTONSTRUCTSIZE,
sizeof(TBBUTTON),
0);
SendMessage(hwtb,
TB_SETBITMAPSIZE,
0,
MAKELONG(KHUI_TOOLBAR_IMAGE_WIDTH,KHUI_TOOLBAR_IMAGE_HEIGHT));
SendMessage(hwtb,
TB_SETIMAGELIST,
0,
(LPARAM) hiList);
SendMessage(hwtb,
TB_SETBUTTONSIZE,
0,
MAKELONG(KHUI_TOOLBAR_IMAGE_WIDTH,KHUI_TOOLBAR_IMAGE_HEIGHT));
while(aref && aref->action != KHUI_MENU_END) {
if(aref->action == KHUI_MENU_SEP) {
khui_add_action_to_toolbar(hwtb,
NULL,
KHUI_TOOLBAR_ADD_SEP,
hiList);
} else {
act = khui_find_action(aref->action);
khui_add_action_to_toolbar(hwtb,
act,
KHUI_TOOLBAR_ADD_BITMAP |
((aref->flags & KHUI_ACTIONREF_SUBMENU)?
KHUI_TOOLBAR_ADD_DROPDOWN: 0),
hiList);
}
aref ++;
}
SendMessage(hwtb,
TB_AUTOSIZE,
0,0);
SendMessage(hwtb,
TB_GETMAXSIZE,
0,
(LPARAM) &sz);
sz.cy += 5;
ZeroMemory(&rbi, sizeof(rbi));
rbi.cbSize = sizeof(rbi);
rbi.fMask =
RBBIM_ID |
RBBIM_CHILD |
RBBIM_CHILDSIZE |
RBBIM_IDEALSIZE |
RBBIM_SIZE |
RBBIM_STYLE;
rbi.fStyle =
RBBS_USECHEVRON |
RBBS_BREAK;
rbi.hwndChild = hwtb;
rbi.wID = KHUI_TOOLBAR_STANDARD;
rbi.cx = sz.cx;
rbi.cxMinChild = sz.cx;
rbi.cyMinChild = sz.cy;
rbi.cyChild = rbi.cyMinChild;
rbi.cyMaxChild = rbi.cyMinChild;
rbi.cyIntegral = rbi.cyMinChild;
rbi.cxIdeal = rbi.cx;
SendMessage(rebar,
RB_INSERTBAND,
0,
(LPARAM) &rbi);
}
bool WINDOW::InitExtended()
{
//Put up dialog box and find out which number of samples to use
DialogBox(hInstance, MAKEINTRESOURCE(IDD_RESOLUTION), HWND_DESKTOP, SelectModeProc);
//Create a rect structure for the size/position of the window
RECT windowRect;
windowRect.left=0;
windowRect.right=(long)width;
windowRect.top=0;
windowRect.bottom=(long)height;
//Window class structure
WNDCLASS wc;
//Fill in window class struct
wc.style= CS_HREDRAW | CS_VREDRAW | CS_OWNDC; //Style - redraw on move, own DC
wc.lpfnWndProc= (WNDPROC) WndProc; //Wndproc handles messages
wc.cbClsExtra= 0;
wc.cbWndExtra= 0;
wc.hInstance= hInstance; //Handle to instance
wc.hIcon= LoadIcon(NULL, IDI_WINLOGO); //Load windows logo icon
wc.hCursor= LoadCursor(NULL, IDC_ARROW); //Load standard cursor
wc.hbrBackground= NULL; //No background required
wc.lpszMenuName= NULL; //No Menu
wc.lpszClassName= "OpenGL"; //class name
//Register window class
if(!RegisterClass(&wc))
{
LOG::Instance()->OutputError("Unable to register window class");
return false;
}
else
LOG::Instance()->OutputSuccess("Window Class Registered");
//Switch to fullscreen if required
if(fullscreen)
{
DEVMODE screenSettings; //device mode
memset(&screenSettings, 0, sizeof(screenSettings));
screenSettings.dmSize=sizeof(screenSettings);
//Set size & color bits
screenSettings.dmPelsWidth=width;
screenSettings.dmPelsHeight=height;
screenSettings.dmBitsPerPel=redBits+greenBits+blueBits+alphaBits;
screenSettings.dmFields= DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
//Try to change to full screen
if(ChangeDisplaySettings(&screenSettings, CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
//If failed, ask whether to run in window
char * errorText="The Requested Full Screen Mode Is Not Supported By\n Your Video Card. Use Windowed Mode Instead?";
if(MessageBox(NULL, errorText, title, MB_YESNO | MB_ICONEXCLAMATION)==IDYES)
fullscreen=false;
else
{
LOG::Instance()->OutputError("Requested full screen mode not supported, quitting...");
return false;
}
}
}
//Set window style & extended style
DWORD style, exStyle;
if(fullscreen)
{
exStyle=WS_EX_APPWINDOW;
style=WS_POPUP | WS_VISIBLE; //no border
//Hide cursor
ShowCursor(false);
}
else
{
exStyle=WS_EX_CLIENTEDGE;
style=WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_VISIBLE;
}
//Adjust the window size so that client area is the size requested
AdjustWindowRectEx(&windowRect, style, false, exStyle);
//Create Window
if(!(hWnd=CreateWindowEx( exStyle, //window style
"OpenGL", //class name
title,
WS_CLIPSIBLINGS | WS_CLIPCHILDREN | style, //style
0, 0, //position
windowRect.right-windowRect.left, //width
windowRect.bottom-windowRect.top, //height
NULL, NULL,
hInstance,
NULL)))
{
Shutdown();
LOG::Instance()->OutputError("Unable to create window");
return false;
}
//Get DC
if(!(hDC=GetDC(hWnd)))
{
//if failed,
Shutdown();
LOG::Instance()->OutputError("Cannot get the Device Context");
return false;
}
else
LOG::Instance()->OutputSuccess("DC Created");
//Set a list of attributes for our pixel format
int attributes[26];
attributes[0] = WGL_RED_BITS_ARB; //bits
attributes[1] = redBits;
attributes[2] = WGL_GREEN_BITS_ARB;
attributes[3] = greenBits;
attributes[4] = WGL_BLUE_BITS_ARB;
attributes[5] = blueBits;
attributes[6] = WGL_ALPHA_BITS_ARB;
attributes[7] = alphaBits;
attributes[8] = WGL_DEPTH_BITS_ARB;
attributes[9] = depthBits;
attributes[10] = WGL_STENCIL_BITS_ARB;
attributes[11] = stencilBits;
attributes[12] = WGL_DRAW_TO_WINDOW_ARB; //required to be true
attributes[13] = true;
attributes[14] = WGL_SUPPORT_OPENGL_ARB;
attributes[15] = true;
attributes[16] = WGL_DOUBLE_BUFFER_ARB;
attributes[17] = true;
attributes[18] = WGL_ACCELERATION_ARB; //required to be FULL_ACCELERATION_ARB
attributes[19] = WGL_FULL_ACCELERATION_ARB;
//Set antialias attributes
if(numSamples>0)
{
attributes[20] = WGL_SAMPLE_BUFFERS_ARB; //Multisample
attributes[21] = true;
attributes[22] = WGL_SAMPLES_ARB;
attributes[23] = numSamples;
}
else
{
attributes[20] = 0;
attributes[21] = 0;
attributes[22] = 0;
attributes[23] = 0;
}
//End the list with (0, 0)
attributes[24]=0;
attributes[25]=0;
//Find the best pixelformat matching out requirements
unsigned int numFormats;
int pixelFormat;
float fAttribs[]={0.0f, 0.0f};
if(!wglChoosePixelFormatARB(hDC, attributes, fAttribs, 1, &pixelFormat, &numFormats))
{
LOG::Instance()->OutputError("Unable to find a suitable pixel format");
return false;
}
//Set pixel format
if(!SetPixelFormat(hDC, pixelFormat, NULL))
{
//if failed,
Shutdown();
LOG::Instance()->OutputError("Cannot set the pixel format");
return false;
}
else
LOG::Instance()->OutputSuccess("Pixel format set");
//Create context
if(!(hRC=wglCreateContext(hDC)))
{
//if failed,
Shutdown();
LOG::Instance()->OutputError("Unable to Create context");
return false;
}
else
LOG::Instance()->OutputSuccess("Context Created");
//Make current
if(!MakeCurrent())
{
Shutdown();
return false;
}
else
LOG::Instance()->OutputSuccess("GL rendering context made current");
//Show window
ShowWindow(hWnd, SW_SHOW);
SetForegroundWindow(hWnd);
SetFocus(hWnd);
//Set Swap interval
wglSwapIntervalEXT(vSync ? 1 : 0);
//Update class variables
glGetIntegerv(GL_RED_BITS, &redBits);
glGetIntegerv(GL_GREEN_BITS, &greenBits);
glGetIntegerv(GL_BLUE_BITS, &blueBits);
glGetIntegerv(GL_ALPHA_BITS, &alphaBits);
glGetIntegerv(GL_DEPTH_BITS, &depthBits);
glGetIntegerv(GL_STENCIL_BITS, &stencilBits);
//Output these parameters
LOG::Instance()->OutputNewLine();
LOG::Instance()->OutputSuccess("Window Created!");
LOG::Instance()->OutputNewLine();
LOG::Instance()->OutputSuccess("Window Size: (%d, %d)", width, height);
LOG::Instance()->OutputSuccess("Color Buffer Bits (R, G, B, A): (%d, %d, %d, %d)",
redBits, greenBits, blueBits, alphaBits);
LOG::Instance()->OutputSuccess("Depth Buffer Bits: %d", depthBits);
LOG::Instance()->OutputSuccess("Stencil Buffer Bits: %d", stencilBits);
LOG::Instance()->OutputNewLine();
return true;
}
/****************************************************************************
* *
* Function: CreateHypCtrl *
* *
* Purpose : Create Hyperlink control. *
* *
* History : Date Reason *
* 00/00/00 Created *
* *
****************************************************************************/
HWND CreateHypCtrl(HWND hWndParent, HYPCTRL* pHc, int x, int y, int width, int height)
{
HYPCTRL* pHcWnd;
HWND hWndHyperlink;
RECT rect;
LOGFONT lf;
HFONT hFontParent, hFontNormal, hFontHover;
// some error checking
if (hInst == NULL) return (HWND) NULL;
if (hWndParent == NULL) return (HWND) NULL;
if (pHc->cbFn == NULL) {
// if the hyperlink opens a normal link, require the szLink member
if (pHc->szLink == NULL) return (HWND) NULL;
} else {
// if the hyperlink calls a callback function, require the szText member
if (pHc->szText == NULL) return (HWND) NULL;
}
hWndHyperlink = CreateWindow(lpszClassname,
NULL,
WS_CHILD,
x, y, width, height,
hWndParent,
NULL,
hInst,
NULL);
if (!hWndHyperlink) return (HWND) NULL;
// alloc some space to hold all hyperlink stuff
if ((pHcWnd = GlobalAllocPtr(GPTR, sizeof(HYPCTRL))) == NULL) {
DestroyWindow(hWndHyperlink);
return (HWND) NULL;
}
CopyMemory(pHcWnd, pHc, sizeof(HYPCTRL));
// copy the text entries from HYPCTRL
if (pHcWnd->cbFn == NULL) {
if (pHcWnd->szLink != NULL) {
if ((pHcWnd->szLink = (LPTSTR) GlobalAllocPtr(GPTR, STRBYTESIZE(pHc->szLink))) == NULL) {
if (pHcWnd) GlobalFreePtr(pHcWnd);
DestroyWindow(hWndHyperlink);
return (HWND) NULL;
}
CopyMemory(pHcWnd->szLink, pHc->szLink, STRBYTESIZE(pHc->szLink));
}
}
if (pHcWnd->szText != NULL) {
if ((pHcWnd->szText = GlobalAllocPtr(GPTR, STRBYTESIZE(pHc->szText))) == NULL) {
if (pHcWnd->szLink) GlobalFreePtr(pHcWnd->szLink);
if (pHcWnd) GlobalFreePtr(pHcWnd);
DestroyWindow(hWndHyperlink);
return (HWND) NULL;
}
CopyMemory(pHcWnd->szText, pHc->szText, STRBYTESIZE(pHc->szText));
} else {
// no callback function and no szText given so we use szLink as text
if(pHcWnd->cbFn == NULL) pHcWnd->szText = pHcWnd->szLink;
}
if (pHcWnd->szTooltip != NULL) {
if ((pHcWnd->szTooltip = GlobalAllocPtr(GPTR, STRBYTESIZE(pHc->szTooltip))) == NULL) {
if (pHcWnd->szLink) GlobalFreePtr(pHcWnd->szLink);
if (pHcWnd->szText) GlobalFreePtr(pHcWnd->szText);
if (pHcWnd) GlobalFreePtr(pHcWnd);
DestroyWindow(hWndHyperlink);
return (HWND) NULL;
}
CopyMemory(pHcWnd->szTooltip, pHc->szTooltip, STRBYTESIZE(pHc->szTooltip));
}
// save a pointer to the structure in the window extra space
SetWindowLong(hWndHyperlink, WND_HYPSTRUCT, (LONG) (pHcWnd));
SetWindowWord(hWndHyperlink, WND_ISHOVER, (WORD) FALSE);
// create the fonts for the control
hFontParent = (HFONT) SendMessage(GetParent(hWndHyperlink), WM_GETFONT, 0, 0);
if (hFontParent != NULL) {
GetObject(hFontParent, sizeof(LOGFONT), &lf);
switch (pHcWnd->ulStyle) {
case ulHover:
hFontNormal = CreateFontIndirect(&lf);
lf.lfUnderline = (BYTE) TRUE;
hFontHover = CreateFontIndirect(&lf);
break;
case ulAlways:
lf.lfUnderline = (BYTE) TRUE;
hFontNormal = CreateFontIndirect(&lf);
hFontHover = CreateFontIndirect(&lf);
break;
case ulNone:
hFontNormal = CreateFontIndirect(&lf);
hFontHover = CreateFontIndirect(&lf);
break;
}
// save the fonts in the window extra space
SetWindowLong(hWndHyperlink, WND_FONTN, (LONG) hFontNormal);
SetWindowLong(hWndHyperlink, WND_FONTH, (LONG) hFontHover);
} else {
// use the system font
SetWindowLong(hWndHyperlink, WND_FONTN, (LONG) NULL);
SetWindowLong(hWndHyperlink, WND_FONTH, (LONG) NULL);
}
GetClientRect(hWndHyperlink, &rect);
// adjust window size to fit the text
if (pHcWnd->bAutoSize) {
PAINTSTRUCT ps;
HDC hdc;
SIZE size;
hdc = BeginPaint(hWndHyperlink, &ps);
SelectObject(hdc, (HFONT) GetWindowLong(hWndHyperlink, WND_FONTN));
GetTextExtentPoint32(hdc, pHcWnd->szText, GetStringLength(pHcWnd->szText), &size);
rect.right = size.cx - rect.left;
rect.bottom = size.cy - rect.top;
EndPaint(hWndHyperlink, &ps);
SetWindowPos(hWndHyperlink,
0,
0, 0, size.cx, size.cy,
SWP_NOMOVE | SWP_NOZORDER);
}
// save window size in the window extra space
SetWindowLong(hWndHyperlink, WND_LEFT, (LONG) (rect.left));
SetWindowLong(hWndHyperlink, WND_TOP, (LONG) (rect.top));
SetWindowLong(hWndHyperlink, WND_RIGHT, (LONG) (rect.right));
SetWindowLong(hWndHyperlink, WND_BOTTOM, (LONG) (rect.bottom));
// create tooltip if requested
if (pHcWnd->szTooltip != NULL) {
HWND hWndTT;
TOOLINFO ti;
hWndTT = CreateWindowEx(WS_EX_TOPMOST,
TOOLTIPS_CLASS,
NULL,
WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
hWndHyperlink,
NULL,
hInst,
NULL);
if (!hWndTT) return FALSE;
SetWindowPos(hWndTT,
HWND_TOPMOST,
0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
ti.cbSize = sizeof(TOOLINFO);
ti.uFlags = TTF_SUBCLASS;
ti.hwnd = hWndHyperlink;
ti.hinst = hInst;
ti.uId = 0;
ti.lpszText = pHcWnd->szTooltip; // get text for tooltip
ti.rect.left = (LONG) GetWindowLong(hWndHyperlink, WND_LEFT);
ti.rect.top = (LONG) GetWindowLong(hWndHyperlink, WND_TOP);
ti.rect.right = (LONG) GetWindowLong(hWndHyperlink, WND_RIGHT);
ti.rect.bottom = (LONG) GetWindowLong(hWndHyperlink, WND_BOTTOM);
// add tooltip
SendMessage(hWndTT, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);
}
// show the window
ShowWindow(hWndHyperlink, SW_NORMAL);
UpdateWindow(hWndHyperlink);
return hWndHyperlink;
}
qboolean VID_CreateWindow( int width, int height, qboolean fullscreen )
{
#ifdef __WXWINDOWS__
glw_state.hWnd = *(HWND*) ri.Vid_GetWindowPtr();
#else
WNDCLASS wc;
RECT r;
cvar_t *vid_xpos, *vid_ypos;
int stylebits;
int x, y, w, h;
int exstyle;
/* Register the frame class */
wc.style = 0;
wc.lpfnWndProc = (WNDPROC)glw_state.wndproc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = glw_state.hInstance;
wc.hIcon = 0;
wc.hCursor = LoadCursor (NULL,IDC_ARROW);
wc.hbrBackground = (void *)COLOR_GRAYTEXT;
wc.lpszMenuName = 0;
wc.lpszClassName = WINDOW_CLASS_NAME;
if (!RegisterClass (&wc) )
ri.Sys_Error (ERR_FATAL, "Couldn't register window class");
if (fullscreen)
{
exstyle = WS_EX_TOPMOST;
stylebits = WS_POPUP|WS_VISIBLE;
}
else
{
exstyle = 0;
stylebits = WINDOW_STYLE;
}
r.left = 0;
r.top = 0;
r.right = width;
r.bottom = height;
AdjustWindowRect (&r, stylebits, FALSE);
w = r.right - r.left;
h = r.bottom - r.top;
if (fullscreen)
{
x = 0;
y = 0;
}
else
{
vid_xpos = ri.Cvar_Get ("vid_xpos", "0", 0);
vid_ypos = ri.Cvar_Get ("vid_ypos", "0", 0);
x = vid_xpos->value;
y = vid_ypos->value;
}
glw_state.hWnd = CreateWindowEx (
exstyle,
WINDOW_CLASS_NAME,
"Quake 2",
stylebits,
x, y, w, h,
NULL,
NULL,
glw_state.hInstance,
NULL);
#endif // ndef __WXWINDOWS__
if (!glw_state.hWnd)
ri.Sys_Error (ERR_FATAL, "Couldn't create window");
ShowWindow( glw_state.hWnd, SW_SHOW );
UpdateWindow( glw_state.hWnd );
// init all the gl stuff for the window
if (!GLimp_InitGL ())
{
ri.Con_Printf( PRINT_ALL, "VID_CreateWindow() - GLimp_InitGL failed\n");
return false;
}
SetForegroundWindow( glw_state.hWnd );
SetFocus( glw_state.hWnd );
// let the sound and input subsystems know about the new window
ri.Vid_NewWindow (width, height);
return true;
}
BOOL CreateAppWindow(const char* title, int width, int height, int bits, bool fullscreenflag)
{
windowWidth = width;
windowHeight = height;
windowName = title;
GLuint PixelFormat; // Holds The Results After Searching For A Match
WNDCLASS wc; // Windows Class Structure
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
WindowRect.left=(long)0; // Set Left Value To 0
WindowRect.right=(long)width; // Set Right Value To Requested Width
WindowRect.top=(long)0; // Set Top Value To 0
WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height
gFullscreen=fullscreenflag; // Set The Global Fullscreen Flag
HICON hIcon = (HICON)LoadImage(0,IDI_WINLOGO,IMAGE_ICON,0,0,LR_SHARED);
hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = hInstance; // Set The Instance
wc.hIcon = 0;
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For GL
wc.lpszMenuName = NULL; // We Don't Want A Menu
wc.lpszClassName = "OpenGL"; // Set The Class Name
if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{
MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (gFullscreen) // Attempt Fullscreen Mode?
{
DEVMODE dmScreenSettings; // Device Mode
memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared
dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure
dmScreenSettings.dmPelsWidth = width; // Selected Screen Width
dmScreenSettings.dmPelsHeight = height; // Selected Screen Height
dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
// If The Mode Fails, Offer Two Options. Quit Or Use Windowed Mode.
if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
{
gFullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE
}
else
{
// Pop Up A Message Box Letting User Know The Program Is Closing.
MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
return FALSE; // Return FALSE
}
}
}
if (gFullscreen) // Are We Still In Fullscreen Mode?
{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP; // Windows Style
ShowCursor(FALSE); // Hide Mouse Pointer
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
}
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
// Create The Window
if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
"OpenGL", // Class Name
title, // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
NULL, // No Parent Window
NULL, // No Menu
hInstance, // Instance
NULL))) // Dont Pass Anything To WM_CREATE
{
CloseWindow(); // Reset The Display
MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
bits, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
{
CloseWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
{
CloseWindow(); // Reset The Display
MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
{
CloseWindow(); // Reset The Display
MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
{
CloseWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
{
CloseWindow(); // Reset The Display
MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
ShowWindow(hWnd,SW_SHOW); // Show The Window
SetForegroundWindow(hWnd); // Slightly Higher Priority
SetFocus(hWnd); // Sets Keyboard Focus To The Window
ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen
if (!InitGL()) // Initialize Our Newly Created GL Window
{
CloseWindow(); // Reset The Display
MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
return TRUE; // Success
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
int iResult;
// Initialize Winsock first
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
MessageBoxA(NULL, "Unable to initialize Winsock!", "Error!", MB_ICONERROR | MB_OK);
return 1;
}
HWND hwnd;
MSG Msg;
hDefaultFont = GetStockObject(DEFAULT_GUI_FONT);
gHBRBackground = CreateSolidBrush(RGB(0, 0xCC, 0));
wc.lpfnWndProc = WndProc;
wc.hInstance = hInstance;
if (!RegisterClassEx(&wc))
{
MessageBoxA(NULL, "Window Registration Failed!", "Error!", MB_ICONEXCLAMATION | MB_OK);
return 0;
}
hwnd = CreateWindowEx(0, wc.lpszClassName, L"cREST", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
MASTER_WIDTH, MASTER_HEIGHT, NULL, NULL, hInstance, NULL);
if (hwnd == NULL)
{
MessageBoxA(NULL, "Window Creation Failed!", "Error!", MB_ICONEXCLAMATION | MB_OK);
return 0;
}
ShowWindow(hwnd, nCmdShow);
UpdateWindow(hwnd);
while (GetMessage(&Msg, NULL, 0, 0) > 0)
{
//Checks for thread communications
//TODO: move these out of the main msg loop
if (Msg.message == SET_RESPONSE_TEXT) {
if (Msg.lParam == THREAD_STATUS_CONNECTING) {
SendMessage(vControls[AREA_RESPONSE], WM_SETTEXT, NULL, (LPARAM)L"Connecting to server...");
} else if (Msg.lParam == THREAD_STATUS_WAITING) {
SendMessage(vControls[AREA_RESPONSE], WM_SETTEXT, NULL, (LPARAM)L"Waiting for server response...");
} else if (Msg.lParam == THREAD_STATUS_RECEIVING_RESPONSE) {
SendMessage(vControls[AREA_RESPONSE], WM_SETTEXT, NULL, (LPARAM)L"Receiving server response...");
} else if (Msg.lParam == THREAD_STATUS_DONE && gThreadBool) {
SendMessage(vControls[AREA_RESPONSE], WM_SETTEXT, NULL, (LPARAM)gThreadResponse.c_str());
gThreadBool = false;
gCanSend = true;
};
}
//Send the request whenever ENTER is pressed, regardless of keyboard focus
if (Msg.message == WM_KEYUP && Msg.wParam == VK_RETURN) {
SendMessage(hwnd, WM_COMMAND, (WPARAM)IDC_SEND_BUTTON, NULL); //Emulate clicking the SEND button
}
//Shut the beeper up when pressing ENTER
if (Msg.message == WM_KEYDOWN && Msg.wParam == VK_RETURN) {
continue;
}
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
return Msg.wParam;
}
bool InitializeWindow(HINSTANCE hInstance, const RenderParams& renderParams, HWND* hwndOut)
{
WNDCLASSEX wc;
DEVMODE dmScreenSettings;
int posX, posY;
OutputDebugString("Initializing Window...\n");
// Setup the windows class with default settings.
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = &WindowProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(nullptr, IDI_WINLOGO);
wc.hIconSm = wc.hIcon;
wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wc.lpszMenuName = nullptr;
wc.lpszClassName = WINDOW_CLASS_NAME;
wc.cbSize = sizeof(WNDCLASSEX);
OutputDebugString("Registering Window Class...\n");
// Register the window class.
RegisterClassEx(&wc);
int windowWidth = renderParams.Extent.Width;
int windowHeight = renderParams.Extent.Height;
// Setup the screen settings depending on whether it is running in full screen or in windowed mode.
if (!renderParams.Windowed)
{
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = (unsigned long)GetSystemMetrics(SM_CXSCREEN);
dmScreenSettings.dmPelsHeight = (unsigned long)GetSystemMetrics(SM_CXSCREEN);
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
// Change the display settings to full screen.
ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
// Set the position of the window to the top left corner.
posX = 0;
posY = 0;
}
else
{
// Place the window in the middle of the screen.
posX = (GetSystemMetrics(SM_CXSCREEN) - windowWidth) / 2;
posY = (GetSystemMetrics(SM_CYSCREEN) - windowHeight) / 2;
RECT r = { 0, 0, windowWidth, windowHeight };
AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);
windowWidth = r.right - r.left;
windowHeight = r.bottom - r.top;
}
DWORD windowStyle = 0;
if (!renderParams.Windowed)
windowStyle = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_POPUP;
else
windowStyle = WS_OVERLAPPEDWINDOW;
OutputDebugString("Creating Window...\n");
// Create the window with the screen settings and get the handle to it.
*hwndOut = CreateWindowEx(WS_EX_APPWINDOW, WINDOW_CLASS_NAME, APPLICATION_NAME,
windowStyle,
posX, posY, windowWidth, windowHeight, nullptr, nullptr, hInstance, nullptr);
ShowWindow(*hwndOut, SW_HIDE);
if (hwndOut == nullptr)
return false;
return true;
}
LRESULT CALLBACK IORegView_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CIORegView* wnd = (CIORegView*)GetWindowLongPtr(hWnd, DWLP_USER);
if ((wnd == NULL) && (uMsg != WM_CREATE))
return DefWindowProc(hWnd, uMsg, wParam, lParam);
switch (uMsg)
{
case WM_CREATE:
{
RECT rc;
SIZE fontsize;
// Retrieve the CIORegView instance passed upon window creation
// and match it to the window
wnd = (CIORegView*)((CREATESTRUCT*)lParam)->lpCreateParams;
SetWindowLongPtr(hWnd, DWLP_USER, (LONG)wnd);
// Create the fixed-pitch font
wnd->hFont = CreateFont(16, 0, 0, 0, FW_MEDIUM, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, GetFontQuality(), FIXED_PITCH, "Courier New");
// Create the vertical scrollbar
// The sizing and positioning of the scrollbar is done in WM_SIZE messages
wnd->vsbWidth = GetSystemMetrics(SM_CXVSCROLL);
wnd->hScrollbar = CreateWindow("Scrollbar", "",
WS_CHILD | WS_VISIBLE | WS_DISABLED | SBS_VERT,
0, 0, 0, 0, hWnd, NULL, hAppInst, NULL);
// Create the rebar that will hold all the controls
wnd->hRebar = CreateWindowEx(WS_EX_TOOLWINDOW, REBARCLASSNAME, NULL,
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CCS_NODIVIDER | RBS_VARHEIGHT | RBS_BANDBORDERS,
0, 0, 0, 0, hWnd, NULL, hAppInst, NULL);
// Create the CPU combobox and fill it
wnd->hCPUCombo = CreateWindow("ComboBox", "",
WS_CHILD | WS_VISIBLE | WS_VSCROLL | CBS_DROPDOWNLIST,
0, 0, 0, 50, wnd->hRebar, (HMENU)IDC_CPU, hAppInst, NULL);
SendMessage(wnd->hCPUCombo, WM_SETFONT, (WPARAM)wnd->hFont, TRUE);
SendMessage(wnd->hCPUCombo, CB_ADDSTRING, 0, (LPARAM)"ARM9");
SendMessage(wnd->hCPUCombo, CB_ADDSTRING, 0, (LPARAM)"ARM7");
SendMessage(wnd->hCPUCombo, CB_SETCURSEL, 0, 0);
// Create the reg combobox and fill it
wnd->hRegCombo = CreateWindow("ComboBox", "",
WS_CHILD | WS_VISIBLE | WS_VSCROLL | CBS_DROPDOWNLIST,
0, 0, 0, 400, wnd->hRebar, (HMENU)IDC_IOREG, hAppInst, NULL);
SendMessage(wnd->hRegCombo, WM_SETFONT, (WPARAM)wnd->hFont, TRUE);
SendMessage(wnd->hRegCombo, CB_SETDROPPEDWIDTH, 300, 0);
wnd->ChangeCPU(ARMCPU_ARM9);
SendMessage(wnd->hRegCombo, CB_SETCURSEL, 0, 0);
// Add all those nice controls to the rebar
REBARBANDINFO rbBand = { 80 };
rbBand.fMask = RBBIM_STYLE | RBBIM_TEXT | RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_SIZE;
rbBand.fStyle = RBBS_CHILDEDGE | RBBS_NOGRIPPER;
GetWindowRect(wnd->hCPUCombo, &rc);
rbBand.lpText = "CPU: ";
rbBand.hwndChild = wnd->hCPUCombo;
rbBand.cxMinChild = 0;
rbBand.cyMinChild = rc.bottom - rc.top;
rbBand.cx = 100;
SendMessage(wnd->hRebar, RB_INSERTBAND, (WPARAM)-1, (LPARAM)&rbBand);
GetWindowRect(wnd->hRegCombo, &rc);
rbBand.lpText = "Registers: ";
rbBand.hwndChild = wnd->hRegCombo;
rbBand.cxMinChild = 0;
rbBand.cyMinChild = rc.bottom - rc.top;
rbBand.cx = 0;
SendMessage(wnd->hRebar, RB_INSERTBAND, (WPARAM)-1, (LPARAM)&rbBand);
GetWindowRect(wnd->hRebar, &rc);
wnd->rebarHeight = rc.bottom - rc.top;
GetFontSize(hWnd, wnd->hFont, &fontsize);
wnd->lineheight = kYMargin + fontsize.cy + kYMargin + 1;
}
return 0;
case WM_CLOSE:
CloseToolWindow(wnd);
return 0;
case WM_SIZE:
{
RECT rc;
// Resize and reposition the controls
SetWindowPos(wnd->hRebar, NULL, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, SWP_NOZORDER | SWP_NOMOVE);
GetClientRect(hWnd, &rc);
SetWindowPos(wnd->hScrollbar, NULL, rc.right-wnd->vsbWidth, wnd->rebarHeight, wnd->vsbWidth, rc.bottom-wnd->rebarHeight, SWP_NOZORDER);
// Keep the first rebar band width to a reasonable value
SendMessage(wnd->hRebar, RB_SETBANDWIDTH, 0, 100);
GetClientRect(hWnd, &rc);
wnd->maxlines = (rc.bottom - wnd->rebarHeight) / wnd->lineheight;
wnd->UpdateScrollbar();
wnd->Refresh();
}
return 0;
case WM_PAINT:
IORegView_Paint(wnd, hWnd, wParam, lParam);
return 0;
case WM_VSCROLL:
{
int pos = SendMessage(wnd->hScrollbar, SBM_GETPOS, 0, 0);
int minpos, maxpos;
SendMessage(wnd->hScrollbar, SBM_GETRANGE, (WPARAM)&minpos, (LPARAM)&maxpos);
switch(LOWORD(wParam))
{
case SB_LINEUP:
pos = max(minpos, pos - 1);
break;
case SB_LINEDOWN:
pos = min(maxpos, pos + 1);
break;
case SB_PAGEUP:
pos = max(minpos, pos - wnd->lineheight);
break;
case SB_PAGEDOWN:
pos = min(maxpos, pos + wnd->lineheight);
break;
case SB_THUMBTRACK:
case SB_THUMBPOSITION:
{
SCROLLINFO si;
ZeroMemory(&si, sizeof(si));
si.cbSize = sizeof(si);
si.fMask = SIF_TRACKPOS;
SendMessage(wnd->hScrollbar, SBM_GETSCROLLINFO, 0, (LPARAM)&si);
pos = si.nTrackPos;
}
break;
}
SendMessage(wnd->hScrollbar, SBM_SETPOS, pos, TRUE);
wnd->yoff = -pos;
wnd->Refresh();
}
return 0;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_CPU:
switch (HIWORD(wParam))
{
case CBN_SELCHANGE:
case CBN_CLOSEUP:
{
int cpu = SendMessage(wnd->hCPUCombo, CB_GETCURSEL, 0, 0);
if (cpu != wnd->CPU)
{
wnd->ChangeCPU(cpu);
wnd->Refresh();
}
}
break;
}
break;
case IDC_IOREG:
switch (HIWORD(wParam))
{
case CBN_SELCHANGE:
case CBN_CLOSEUP:
{
int reg = SendMessage(wnd->hRegCombo, CB_GETCURSEL, 0, 0);
if (reg != wnd->Reg)
{
wnd->ChangeReg(reg);
wnd->Refresh();
}
}
break;
}
break;
}
return 0;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
/*****************************************************************************
* Win32VoutCreateWindow: create a window for the video.
*****************************************************************************
* Before creating a direct draw surface, we need to create a window in which
* the video will be displayed. This window will also allow us to capture the
* events.
*****************************************************************************/
static int Win32VoutCreateWindow( event_thread_t *p_event )
{
vout_display_t *vd = p_event->vd;
HINSTANCE hInstance;
HMENU hMenu;
RECT rect_window;
WNDCLASS wc; /* window class components */
TCHAR vlc_path[MAX_PATH+1];
int i_style, i_stylex;
msg_Dbg( vd, "Win32VoutCreateWindow" );
/* Get this module's instance */
hInstance = GetModuleHandle(NULL);
#ifdef MODULE_NAME_IS_direct3d
if( !p_event->use_desktop )
{
#endif
/* If an external window was specified, we'll draw in it. */
p_event->parent_window = vout_display_NewWindow(vd, &p_event->wnd_cfg );
if( p_event->parent_window )
p_event->hparent = (HWND) p_event->parent_window->handle.hwnd; // sunqueen modify
else
p_event->hparent = NULL;
#ifdef MODULE_NAME_IS_direct3d
}
else
{
p_event->parent_window = NULL;
p_event->hparent = GetDesktopHandle(vd);
}
#endif
p_event->cursor_arrow = LoadCursor(NULL, IDC_ARROW);
p_event->cursor_empty = EmptyCursor(hInstance);
/* Get the Icon from the main app */
p_event->vlc_icon = NULL;
if( GetModuleFileName( NULL, vlc_path, MAX_PATH ) )
{
p_event->vlc_icon = ExtractIcon( hInstance, vlc_path, 0 );
}
/* Fill in the window class structure */
wc.style = CS_OWNDC|CS_DBLCLKS; /* style: dbl click */
wc.lpfnWndProc = (WNDPROC)WinVoutEventProc; /* event handler */
wc.cbClsExtra = 0; /* no extra class data */
wc.cbWndExtra = 0; /* no extra window data */
wc.hInstance = hInstance; /* instance */
wc.hIcon = p_event->vlc_icon; /* load the vlc big icon */
wc.hCursor = p_event->is_cursor_hidden ? p_event->cursor_empty :
p_event->cursor_arrow;
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); /* background color */ // sunqueen modify
wc.lpszMenuName = NULL; /* no menu */
wc.lpszClassName = p_event->class_main; /* use a special class */
/* Register the window class */
if( !RegisterClass(&wc) )
{
if( p_event->vlc_icon )
DestroyIcon( p_event->vlc_icon );
msg_Err( vd, "Win32VoutCreateWindow RegisterClass FAILED (err=%lu)", GetLastError() );
return VLC_EGENERIC;
}
/* Register the video sub-window class */
wc.lpszClassName = p_event->class_video;
wc.hIcon = 0;
wc.hbrBackground = NULL; /* no background color */
if( !RegisterClass(&wc) )
{
msg_Err( vd, "Win32VoutCreateWindow RegisterClass FAILED (err=%lu)", GetLastError() );
return VLC_EGENERIC;
}
/* When you create a window you give the dimensions you wish it to
* have. Unfortunatly these dimensions will include the borders and
* titlebar. We use the following function to find out the size of
* the window corresponding to the useable surface we want */
rect_window.left = 10;
rect_window.top = 10;
rect_window.right = rect_window.left + p_event->wnd_cfg.width;
rect_window.bottom = rect_window.top + p_event->wnd_cfg.height;
if( var_GetBool( vd, "video-deco" ) )
{
/* Open with window decoration */
AdjustWindowRect( &rect_window, WS_OVERLAPPEDWINDOW|WS_SIZEBOX, 0 );
i_style = WS_OVERLAPPEDWINDOW|WS_SIZEBOX|WS_VISIBLE|WS_CLIPCHILDREN;
i_stylex = 0;
}
else
{
/* No window decoration */
AdjustWindowRect( &rect_window, WS_POPUP, 0 );
i_style = WS_POPUP|WS_VISIBLE|WS_CLIPCHILDREN;
i_stylex = 0; // WS_EX_TOOLWINDOW; Is TOOLWINDOW really needed ?
// It messes up the fullscreen window.
}
if( p_event->hparent )
{
i_style = WS_VISIBLE|WS_CLIPCHILDREN|WS_CHILD;
i_stylex = 0;
/* allow user to regain control over input events if requested */
bool b_mouse_support = var_InheritBool( vd, "mouse-events" );
bool b_key_support = var_InheritBool( vd, "keyboard-events" );
if( !b_mouse_support && !b_key_support )
i_style |= WS_DISABLED;
}
p_event->i_window_style = i_style;
/* Create the window */
p_event->hwnd =
CreateWindowEx( WS_EX_NOPARENTNOTIFY | i_stylex,
p_event->class_main, /* name of window class */
_T(VOUT_TITLE) _T(" (VLC Video Output)"), /* window title */
i_style, /* window style */
(!p_event->wnd_cfg.x) ? (UINT)CW_USEDEFAULT :
(UINT)p_event->wnd_cfg.x, /* default X coordinate */
(!p_event->wnd_cfg.y) ? (UINT)CW_USEDEFAULT :
(UINT)p_event->wnd_cfg.y, /* default Y coordinate */
rect_window.right - rect_window.left, /* window width */
rect_window.bottom - rect_window.top, /* window height */
p_event->hparent, /* parent window */
NULL, /* no menu in this window */
hInstance, /* handle of this program instance */
(LPVOID)p_event ); /* send vd to WM_CREATE */
if( !p_event->hwnd )
{
msg_Warn( vd, "Win32VoutCreateWindow create window FAILED (err=%lu)", GetLastError() );
return VLC_EGENERIC;
}
InitGestures( p_event->hwnd, &p_event->p_gesture );
if( p_event->hparent )
{
LONG i_style;
/* We don't want the window owner to overwrite our client area */
i_style = GetWindowLong( p_event->hparent, GWL_STYLE );
if( !(i_style & WS_CLIPCHILDREN) )
/* Hmmm, apparently this is a blocking call... */
SetWindowLong( p_event->hparent, GWL_STYLE,
i_style | WS_CLIPCHILDREN );
/* Create our fullscreen window */
p_event->hfswnd =
CreateWindowEx( WS_EX_APPWINDOW, p_event->class_main,
_T(VOUT_TITLE) _T(" (VLC Fullscreen Video Output)"),
WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN|WS_SIZEBOX,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
NULL, NULL, hInstance, NULL );
}
else
{
p_event->hfswnd = NULL;
}
/* Append a "Always On Top" entry in the system menu */
hMenu = GetSystemMenu( p_event->hwnd, FALSE );
AppendMenu( hMenu, MF_SEPARATOR, 0, _T("") );
AppendMenu( hMenu, MF_STRING | MF_UNCHECKED,
IDM_TOGGLE_ON_TOP, _T("Always on &Top") );
/* Create video sub-window. This sub window will always exactly match
* the size of the video, which allows us to use crazy overlay colorkeys
* without having them shown outside of the video area. */
/* FIXME vd->source.i_width/i_height seems wrong */
p_event->hvideownd =
CreateWindow( p_event->class_video, _T(""), /* window class */
WS_CHILD, /* window style, not visible initially */
0, 0,
vd->source.i_width, /* default width */
vd->source.i_height, /* default height */
p_event->hwnd, /* parent window */
NULL, hInstance,
(LPVOID)p_event ); /* send vd to WM_CREATE */
if( !p_event->hvideownd )
msg_Warn( vd, "can't create video sub-window" );
else
msg_Dbg( vd, "created video sub-window" );
/* Now display the window */
ShowWindow( p_event->hwnd, SW_SHOW );
return VLC_SUCCESS;
}
HWND CreateButton(TCHAR *Titel, int x0, int y0, int w, int h, int ID, HWND hW, HINSTANCE hInst)
{
return CreateWindowEx(WS_EX_PALETTEWINDOW, L"BUTTON", Titel,
WS_VISIBLE | WS_CHILD,
x0, y0, w, h, hW, (HMENU)ID, hInst, NULL);
}
INT WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR szCmdLine, int iCmdShow)
{
WNDCLASSEX winClass ;
winClass.lpszClassName = "MaterialOnly";
winClass.cbSize = sizeof(WNDCLASSEX);
winClass.style = CS_HREDRAW | CS_VREDRAW;
winClass.lpfnWndProc = MsgProc;
winClass.hInstance = hInstance;
winClass.hIcon = NULL ;
winClass.hIconSm = NULL ;
winClass.hCursor = LoadCursor(NULL, IDC_ARROW) ;
winClass.hbrBackground = NULL ;
winClass.lpszMenuName = NULL ;
winClass.cbClsExtra = 0;
winClass.cbWndExtra = 0;
RegisterClassEx (&winClass) ;
HWND hWnd = CreateWindowEx(NULL,
winClass.lpszClassName, // window class name
"MaterialOnly", // window caption
WS_OVERLAPPEDWINDOW, // window style
32, // initial x position
32, // initial y position
600, // initial window width
600, // initial window height
NULL, // parent window handle
NULL, // window menu handle
hInstance, // program instance handle
NULL) ; // creation parameters
// Create window failed
if(hWnd == NULL)
{
MessageBoxA(hWnd, "Create Window failed!", "Error", 0) ;
return -1 ;
}
// Initialize Direct3D
if( SUCCEEDED(InitD3D(hWnd)))
{
// Show the window
ShowWindow( hWnd, SW_SHOWDEFAULT );
UpdateWindow( hWnd );
MSG msg ;
ZeroMemory( &msg, sizeof(msg) );
PeekMessage( &msg, NULL, 0U, 0U, PM_NOREMOVE );
// Get last time
static DWORD lastTime = timeGetTime();
while (msg.message != WM_QUIT)
{
if(PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) != 0)
{
TranslateMessage (&msg) ;
DispatchMessage (&msg) ;
}
else // Render the game if there is no message to process
{
// Get current time
DWORD currTime = timeGetTime();
// Calculate time elapsed
float timeDelta = (currTime - lastTime) * 0.001f;
// Render
Render(timeDelta) ;
// Update last time to current time for next loop
lastTime = currTime;
}
}
}
UnregisterClass(winClass.lpszClassName, hInstance) ;
return 0;
}
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
hinstance_app = hinstance;
// register the window class
if (!RegisterClassEx(&winclass))
return(0);
// create the window
if (!(hwnd = CreateWindowEx(NULL, // extended style
WINDOW_CLASS_NAME, // class
"DirectDraw 8-Bit Blitting Demo", // title
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;
// 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
void ChangeInfoData::BeginListEdit(int iItem, RECT *rc, int iSetting, WORD wVKey)
{
int j,n;
POINT pt;
int itemHeight;
char str[MAX_PATH];
if (dataListEdit)
dataListEdit->EndListEdit(0);
pt.x=pt.y=0;
ClientToScreen(hwndList,&pt);
OffsetRect(rc,pt.x,pt.y);
InflateRect(rc,-2,-2);
rc->left-=2;
iEditItem = iItem;
ListView_RedrawItems(hwndList, iEditItem, iEditItem);
UpdateWindow(hwndList);
dataListEdit = this;
hwndListEdit = CreateWindowEx(WS_EX_TOOLWINDOW|WS_EX_TOPMOST, _T("LISTBOX"), _T(""), WS_POPUP|WS_BORDER|WS_VSCROLL, rc->left, rc->bottom, rc->right - rc->left, 150, NULL, NULL, hInst, NULL);
SendMessage(hwndListEdit, WM_SETFONT, (WPARAM)hListFont, 0);
itemHeight = SendMessage(hwndListEdit, LB_GETITEMHEIGHT, 0, 0);
FieldNamesItem *list = (FieldNamesItem*)setting[iSetting].pList;
if (list == countryField)
{ // some country codes were changed leaving old details uknown, convert it for the user
if (settingData[iSetting].value == 420) settingData[iSetting].value = 42; // conversion of obsolete codes (OMG!)
else if (settingData[iSetting].value == 421) settingData[iSetting].value = 4201;
else if (settingData[iSetting].value == 102) settingData[iSetting].value = 1201;
}
n = ListBoxAddStringUtf(hwndListEdit, "Unspecified");
for (j=0; ; j++)
if (!list[j].text)
{
SendMessage(hwndListEdit, LB_SETITEMDATA, n, j);
if ((settingData[iSetting].value == 0 && list[j].code == 0)
|| (setting[iSetting].dbType != DBVT_ASCIIZ && settingData[iSetting].value == list[j].code))
SendMessage(hwndListEdit, LB_SETCURSEL, n, 0);
break;
}
for (j=0; list[j].text; j++)
{
n = ListBoxAddStringUtf(hwndListEdit, list[j].text);
SendMessage(hwndListEdit, LB_SETITEMDATA, n, j);
if ((setting[iSetting].dbType == DBVT_ASCIIZ && (!strcmpnull((char*)settingData[iSetting].value, list[j].text))
|| (setting[iSetting].dbType == DBVT_ASCIIZ && (!strcmpnull((char*)settingData[iSetting].value, ICQTranslateUtfStatic(list[j].text, str, MAX_PATH))))
|| ((char*)settingData[iSetting].value == NULL && list[j].code == 0))
|| (setting[iSetting].dbType != DBVT_ASCIIZ && settingData[iSetting].value == list[j].code))
SendMessage(hwndListEdit, LB_SETCURSEL, n, 0);
}
SendMessage(hwndListEdit, LB_SETTOPINDEX, SendMessage(hwndListEdit, LB_GETCURSEL, 0, 0) - 3, 0);
int listCount = SendMessage(hwndListEdit, LB_GETCOUNT, 0, 0);
if (itemHeight * listCount < 150)
SetWindowPos(hwndListEdit, 0, 0, 0, rc->right - rc->left, itemHeight * listCount + GetSystemMetrics(SM_CYBORDER) * 2, SWP_NOZORDER|SWP_NOMOVE);
OldListEditProc = (WNDPROC)SetWindowLongPtr(hwndListEdit, GWLP_WNDPROC, (LONG_PTR)ListEditSubclassProc);
if (MyAnimateWindow = (BOOL (WINAPI*)(HWND,DWORD,DWORD))GetProcAddress(GetModuleHandleA("user32"), "AnimateWindow"))
{
BOOL enabled;
SystemParametersInfo(SPI_GETCOMBOBOXANIMATION, 0, &enabled, FALSE);
if (enabled) MyAnimateWindow(hwndListEdit, 200, AW_SLIDE|AW_ACTIVATE|AW_VER_POSITIVE);
}
ShowWindow(hwndListEdit, SW_SHOW);
SetFocus(hwndListEdit);
if (wVKey)
PostMessage(hwndListEdit, WM_KEYDOWN, wVKey, 0);
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam) {
PAINTSTRUCT Ps;
switch(msg) {
case WM_CREATE: {
/**
* Create AddFood Button
*/
HFONT hFont = CreateFont(30,0,0,0,FW_DONTCARE,FALSE,TRUE,FALSE,DEFAULT_CHARSET,OUT_OUTLINE_PRECIS,
CLIP_DEFAULT_PRECIS,NULL, VARIABLE_PITCH,TEXT("Impact"));
HWND hButtonAddFood = CreateWindowEx(NULL,
"BUTTON",
"ADD FOOD",
WS_TABSTOP|WS_VISIBLE|
WS_CHILD|BS_DEFPUSHBUTTON|BS_TOP,
10,
150,
100,
25,
hWnd,
(HMENU)BUTTON_ADD_FOOD,
GetModuleHandle(NULL),
NULL);
/**
* Create button ShowFoodNumber
*/
HWND hShowFoodNumber = CreateWindowEx(NULL,
"BUTTON",
"Funny",
WS_TABSTOP|WS_VISIBLE|
WS_CHILD|BS_DEFPUSHBUTTON|BS_TOP,
10,
180,
300,
40,
hWnd,
(HMENU)BUTTON_DISPLAY_FOOD_NR,
GetModuleHandle(NULL),
NULL);
SendMessage (hShowFoodNumber, WM_SETFONT, WPARAM (hFont), TRUE);
/**
* Draw Food List (In a input box)
*/
hFoodList = CreateWindowEx(WS_EX_CLIENTEDGE,
"EDIT",
"",
WS_CHILD|WS_VISIBLE|WS_VSCROLL|ES_READONLY|
ES_MULTILINE,
10,
40,
300,
100,
hWnd,
(HMENU)INPUT_TEXT_SHOW_FOOD,
GetModuleHandle(NULL),
NULL);
/**
* Draw main Input food field
*/
hInputFood = CreateWindowEx(
(DWORD)NULL,
TEXT("edit"),
"",
WS_VISIBLE | WS_CHILD | WS_BORDER,
120,
150,
190,
25,
hWnd,
(HMENU)INPUT_TEXT_ADD_FOOD,
GetModuleHandle(NULL),
NULL);
}
break;
case WM_PAINT: {
HDC hdc = BeginPaint(hWnd, &Ps);
RECT rect;
/**
* Draw Text
*/
// Second Text
char foodNrMessage[256] = "Number : ";
char nr[50];
strcat(foodNrMessage, itoa(foodNumber, nr, 10));
SetBkMode(hdc, TRANSPARENT);
SetRect(&updateRect, 210, 10, 300, 30);
DrawText( hdc, foodNrMessage, -1, &updateRect, DT_SINGLELINE | DT_NOCLIP ) ;
// First Text
HFONT hFont = CreateFont(25,0,0,0,FW_DONTCARE,FALSE,TRUE,FALSE,DEFAULT_CHARSET,OUT_OUTLINE_PRECIS,
CLIP_DEFAULT_PRECIS,NULL, VARIABLE_PITCH,TEXT("Impact"));
SetRect(&rect, 10, 10, 50, 50);
SelectObject(hdc, hFont);
SetBkMode(hdc, OPAQUE);
SetBkColor(hdc, RGB(0,255,255));
SetTextColor(hdc, RGB(255,0,0));
DrawText(hdc, TEXT(firstText), -1,&rect, DT_NOCLIP);
EndPaint(hWnd, &Ps);
}
break;
case WM_CTLCOLOREDIT: {
HDC hdc = (HDC)wParam;
HWND hwnd = (HWND)lParam;
HBRUSH color;
if (GetDlgCtrlID(hwnd) == INPUT_TEXT_ADD_FOOD) {
color = CreateSolidBrush(RGB(225, 225, 225));
SetTextColor(hdc, RGB(0, 0, 255));
SetBkMode(hdc, TRANSPARENT);
SetBkColor(hdc,(LONG)color);
}
return (LONG) color;
}
break;
case WM_COMMAND: {
switch(LOWORD(wParam)) {
case BUTTON_ADD_FOOD: {
char buffer[256];
SendMessage(hInputFood,
WM_GETTEXT,
sizeof(buffer)/sizeof(buffer[0]),
reinterpret_cast<LPARAM>(buffer));
if(strlen(buffer) > 0){
char newInput[255] = "";
char stat[30];
strcat(newInput, itoa((foodNumber+1), stat, 10) );
strcat(newInput, " ) ");
strcat(newInput, buffer);
strcat(newInput, "\r\n");
SendMessage(hFoodList, EM_REPLACESEL, FALSE, (LPARAM)newInput);
SendMessage(hInputFood, WM_SETTEXT, NULL, (LPARAM)"");
foodNumber++;
InvalidateRect(hWnd, &updateRect, TRUE);
}
}
break;
case BUTTON_DISPLAY_FOOD_NR: {
char buffer[255] = "";
switch(foodNumber){
case 0:http://pastebin.com/62fGU90U
case 1:
case 2:
case 3:
strcat(buffer, "You are not hungry at all");
break;
case 4:
case 5:
case 6:
strcat(buffer, "I see you are hungry now");
break;
default:
strcat(buffer, "You are starvin... go get something to eat");
break;
}
MessageBox(NULL,
buffer,
"Funny",
MB_ICONINFORMATION);
}
break;
}
}
break;
case WM_SIZE: {
INT nWidth = LOWORD(lParam);
HWND hFunnyButton = GetDlgItem(hWnd, BUTTON_DISPLAY_FOOD_NR);
MoveWindow(hFunnyButton, 10, 180, nWidth - 17, 40, TRUE);
HWND hShowFoodInput = GetDlgItem(hWnd, INPUT_TEXT_SHOW_FOOD);
HWND hAddFood = GetDlgItem(hWnd, INPUT_TEXT_ADD_FOOD);
MoveWindow(hShowFoodInput, 10, 40, nWidth - 18, 100, TRUE);
MoveWindow(hAddFood, 120, 150, nWidth - 128, 25, TRUE);
}
break;
case WM_GETMINMAXINFO: {
MINMAXINFO * mmiStruct;
mmiStruct = (MINMAXINFO*)lParam;
POINT ptPoint;
ptPoint.x = 335; //Minimum width of the window.
ptPoint.y = 260; //Minimum height of the window.
mmiStruct->ptMinTrackSize = ptPoint;
ptPoint.x = GetSystemMetrics(SM_CXMAXIMIZED); //Maximum width of the window.
ptPoint.y = GetSystemMetrics(SM_CYMAXIMIZED); //Maximum height of the window.
mmiStruct->ptMaxTrackSize = ptPoint;
}
break;
case WM_DESTROY: {
PostQuitMessage(0);
return 0;
}
break;
}
return DefWindowProc(hWnd,msg,wParam,lParam);
}
static qboolean GLW_CreateWindow( const char *drivername, int width, int height, int colorbits, qboolean cdsFullscreen ) {
RECT r;
cvar_t *vid_xpos, *vid_ypos;
int stylebits;
int x, y, w, h;
int exstyle;
//
// register the window class if necessary
//
if ( !s_classRegistered ) {
WNDCLASS wc;
memset( &wc, 0, sizeof( wc ) );
wc.style = 0;
wc.lpfnWndProc = (WNDPROC) glw_state.wndproc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = g_wv.hInstance;
wc.hIcon = LoadIcon( g_wv.hInstance, MAKEINTRESOURCE( IDI_ICON1 ) );
wc.hCursor = LoadCursor( NULL,IDC_ARROW );
wc.hbrBackground = (void *)COLOR_GRAYTEXT;
wc.lpszMenuName = 0;
wc.lpszClassName = WINDOW_CLASS_NAME;
if ( !RegisterClass( &wc ) ) {
ri.Error( ERR_VID_FATAL, "GLW_CreateWindow: could not register window class" );
}
s_classRegistered = qtrue;
ri.Printf( PRINT_ALL, "...registered window class\n" );
}
//
// create the HWND if one does not already exist
//
if ( !g_wv.hWnd ) {
//
// compute width and height
//
r.left = 0;
r.top = 0;
r.right = width;
r.bottom = height;
if ( cdsFullscreen || !Q_stricmp( _3DFX_DRIVER_NAME, drivername ) ) {
exstyle = WS_EX_TOPMOST;
stylebits = WS_POPUP | WS_VISIBLE | WS_SYSMENU;
} else
{
exstyle = 0;
stylebits = WINDOW_STYLE | WS_SYSMENU;
AdjustWindowRect( &r, stylebits, FALSE );
}
w = r.right - r.left;
h = r.bottom - r.top;
if ( cdsFullscreen || !Q_stricmp( _3DFX_DRIVER_NAME, drivername ) ) {
x = 0;
y = 0;
} else
{
vid_xpos = ri.Cvar_Get( "vid_xpos", "", 0 );
vid_ypos = ri.Cvar_Get( "vid_ypos", "", 0 );
x = vid_xpos->integer;
y = vid_ypos->integer;
// adjust window coordinates if necessary
// so that the window is completely on screen
if ( x < 0 ) {
x = 0;
}
if ( y < 0 ) {
y = 0;
}
if ( w < glw_state.desktopWidth &&
h < glw_state.desktopHeight ) {
if ( x + w > glw_state.desktopWidth ) {
x = ( glw_state.desktopWidth - w );
}
if ( y + h > glw_state.desktopHeight ) {
y = ( glw_state.desktopHeight - h );
}
}
}
g_wv.hWnd = CreateWindowEx(
exstyle,
WINDOW_CLASS_NAME,
//"Wolfenstein",
"Enemy Territory - Omni-bot",
stylebits,
x, y, w, h,
NULL,
NULL,
g_wv.hInstance,
NULL );
if ( !g_wv.hWnd ) {
ri.Error( ERR_VID_FATAL, "GLW_CreateWindow() - Couldn't create window" );
}
ShowWindow( g_wv.hWnd, SW_SHOW );
UpdateWindow( g_wv.hWnd );
ri.Printf( PRINT_ALL, "...created window@%d,%d (%dx%d)\n", x, y, w, h );
} else
{
ri.Printf( PRINT_ALL, "...window already present, CreateWindowEx skipped\n" );
}
if ( !GLW_InitDriver( drivername, colorbits ) ) {
ShowWindow( g_wv.hWnd, SW_HIDE );
DestroyWindow( g_wv.hWnd );
g_wv.hWnd = NULL;
return qfalse;
}
SetForegroundWindow( g_wv.hWnd );
SetFocus( g_wv.hWnd );
return qtrue;
}
//------------------------------------------------------------------------
int WINAPI WinMain(
HINSTANCE instance,
HINSTANCE previnst,
LPSTR cmdline,
int cmdshow)
{
MSG msg;
DWORD win_style;
int win_width;
int win_height;
// Setup window stuff
g_win_instance = instance;
strcpy(g_win_class_name, "DreamGL_cls");
memset(&g_win_class, 0, sizeof(g_win_class));
g_win_class.cbSize = sizeof(WNDCLASSEX);
g_win_class.lpfnWndProc = MainWindowProc;
g_win_class.style = CS_HREDRAW | CS_VREDRAW;//CS_CLASSDC;
g_win_class.cbClsExtra = 0;
g_win_class.cbWndExtra = 0;
g_win_class.hInstance = g_win_instance;
g_win_class.hIcon = LoadIcon(g_win_instance, MAKEINTRESOURCE(IDI_APPLICATION));
g_win_class.hIconSm = g_win_class.hIcon;
g_win_class.hCursor = LoadCursor(NULL, IDC_ARROW);
g_win_class.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
g_win_class.lpszClassName = g_win_class_name;
g_win_class.lpszMenuName = NULL;
g_win_atom = RegisterClassEx(&g_win_class);
if(INVALID_ATOM == g_win_atom)
{
MessageBox(0, "Invalid ATOM returned by RegisterClassEx()!", "ERROR!", MB_OK);
return(0);
}
win_style = WS_OVERLAPPEDWINDOW;
if(g_full_screen) win_style = WS_POPUP;
// In windowed mode, account for window border and caption bar.
win_width = g_screen_width;
win_height = g_screen_height;
if(!g_full_screen)
{
win_width += (GetSystemMetrics(SM_CXFRAME)*2);
win_height += (GetSystemMetrics(SM_CYFRAME)*2)+GetSystemMetrics(SM_CYCAPTION);
}
g_win_h = CreateWindowEx(
WS_EX_APPWINDOW,
MAKEINTATOM(g_win_atom),
"DreamGL Demo",
win_style,
0, 0, win_width, win_height,
NULL, NULL, g_win_instance, NULL);
if(!IsWindow(g_win_h))
{
MessageBox(0, "Invalid HWND returned by CreateWindowEx()!", "ERROR!", MB_OK);
return(0);
}
ShowWindow(g_win_h, cmdshow);
UpdateWindow(g_win_h);
if(!init())
{
MessageBox(0, "Failed to initialize OpenGL!", "ERROR!", MB_OK);
return(0);
}
demo_init();
while(TRUE)
{
if(PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
if(WM_QUIT == msg.message)
{
break;
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else
{
demo_tick();
}
}
demo_end();
end();
UnregisterClass(MAKEINTATOM(g_win_atom), instance);
return(msg.wParam);
}
/* ********************************************************************************************************************
* * * * *
* * IDC_STATIC_SCALE * * *
* * * * IDC_STATIC_POPULANTS_GROUP_BOX *
* * IDC_STATIC_SLOPE_SCALE * * (popGrpBoxProp) *
* bathyBitmapProp * * * *
* * * ************************************
* * (scaleProp) * | *
* * * B | *
* * * | *
* * * | *
*********************************************************** | C *
* | | *
* | | *
* A | | *
* | | *
*********************************************************************************************************************/
DLGLAYOUT SelectDialogLayout(HWND hDlg, WNDPROP PrevDlgProp, const BATHYMAPINF *pBathyMapInf, const HEIGHTWIDTH *pReqPixels, DLGLAYOUTOPTIONS *pLayoutOptions)
{
//SEEDDLGSETUP sedg = GetSeedDlgSetup();
static int scaleWidths = GetWinProps(GetDlgItem(hDlg,IDC_STATIC_SCALE)).width;
static int minY = GetWinProps(GetDlgItem(hDlg,IDC_STATIC_SCALE)).y;
int c, i;
int dx, dy;
const int CONTRLSPACEPIXELS = 7;
//WNDPROP winProp;
DLGLAYOUT dlgLayout;
WNDPROP winProp;
WNDPROP dlg = GetWinProps(hDlg);
WNDPROP pop = GetWinProps(GetDlgItem(hDlg,IDC_STATIC_POPULANTS_GROUP_BOX));
HEIGHTWIDTH bathyPixAvial[NUMCONFIGURATIONS] = {0}; // Pixels available for the bathymetry map
HEIGHTWIDTH bathyDimResult[NUMCONFIGURATIONS] = {0}; // Resulting dimensions of the bathymap
HEIGHTWIDTH cntrlsPixAvail[NUMCONFIGURATIONS] = {0}; // Pixels available for the controls
MAPGRPCONFIG m;
ANIMATGRPCONFIG a;
BUTTONGRPCONFIG b;
// Get the current bathymetry bitmap properties. Needed for its X Y values.
if(g_hwndBathy == NULL)
{
_ASSERT(g_hwndDepthScale == NULL && g_hwndSlopeScale == NULL);
// Bathymetry Map
dlgLayout.bathy.x = DLGBOXLEFTSIDEMARGIN;
dlgLayout.bathy.y = DLBBOXTOPMARGIN;
dlgLayout.bathy.width = 0;
dlgLayout.bathy.height = 0;
// Widths for the scaling bitmaps is needed now.
winProp = GetWinProps(GetDlgItem(hDlg,IDC_STATIC_SCALE));
while((winProp.width % 16) != 0)
winProp.width++;
// Depth Scale
dlgLayout.depth.x = 0;
dlgLayout.depth.y = DLBBOXTOPMARGIN;
dlgLayout.depth.width = winProp.width;
dlgLayout.depth.height = winProp.height;
dlgLayout.slope.x = 0;
dlgLayout.slope.y = DLBBOXTOPMARGIN;
dlgLayout.slope.width = winProp.width;
dlgLayout.slope.height = winProp.height;
}
else
{
// _ASSERT(g_hwndDepthScale != NULL && g_hwndSlopeScale != NULL);
dlgLayout.bathy = GetWinProps(g_hwndBathy);
// Get the current depth and slope scale and window properties. Needed for their
// dimensions.
dlgLayout.depth = GetWinProps(g_hwndDepthScale);
dlgLayout.slope = GetWinProps(g_hwndSlopeScale);
}
// The first three layouts have a horizontal layout
for(c=0; c<3; c++)
{
if(dlg.width < pReqPixels[c].width + pop.width)
continue;
// Calculate the pixels avalable for the bathymetry map
bathyPixAvial[c].width = dlg.width - (pop.width +
dlgLayout.depth.width +
dlgLayout.slope.width +
3*CONTRLSPACEPIXELS +
DLGBOXLEFTSIDEMARGIN +
DLGBOXRIGHTSIDEMARGIN);
bathyPixAvial[c].height = dlg.height - (pReqPixels[c].height +
DLBBOXTOPMARGIN);
cntrlsPixAvail[c].width = dlg.width - (pop.width +
CONTRLSPACEPIXELS +
DLGBOXLEFTSIDEMARGIN +
DLGBOXRIGHTSIDEMARGIN);
cntrlsPixAvail[c].height = dlg.height - (pop.width +
CONTRLSPACEPIXELS +
DLBBOXTOPMARGIN);
}
// vertical layout
// Calculate the pixels avalable for the bathymetry map
bathyPixAvial[3].width =
dlg.width - (
DLGBOXRIGHTSIDEMARGIN + // margin on the dialog box's right side
pop.width + // populants group box width
CONTRLSPACEPIXELS + // pixels between the populants group box and this layout's setup
pReqPixels[3].width + // pixels required by the controls of this layout
CONTRLSPACEPIXELS + // pixels between the this layout's setup and the depth bitmap slider
dlgLayout.depth.width + // depth bitmap slider width
CONTRLSPACEPIXELS + // pixels between the two sliders
dlgLayout.slope.width + // slope bitmap slider width
CONTRLSPACEPIXELS + // pixels between the slope slider and the bathymetry bitmap
DLGBOXLEFTSIDEMARGIN); // margin on the left side of the dialog box.
bathyPixAvial[3].height =
dlg.height - (
DLBBOXTOPMARGIN + // top of the dialog box margin
7 + // space for the mouse move.
//pReqPixels[3].height + // height of this layout
DLBBOXTOPMARGIN);// bottom margin of the dialog box?
cntrlsPixAvail[3].width =
dlg.width - (
DLGBOXLEFTSIDEMARGIN + // left margin
pop.width + // populants group box width
CONTRLSPACEPIXELS + // space between the populants group box and depth slider
dlgLayout.depth.width + // depth slider width
CONTRLSPACEPIXELS + // space between depth slider and slope slider
dlgLayout.slope.width + // slope slider width
CONTRLSPACEPIXELS);// space between slope slider and bathymetry map.
cntrlsPixAvail[3].height =
dlg.height - (
DLBBOXTOPMARGIN + // top margin
0); // ? bottom margin???
//----------------------------------------------------------------------------------//
// Handle the dialog set up based on if the map runs horizontally (width being larger
// than height or square) or vertically.
//-------------------------------------//
// Horizontal and square maps have all of the controls underneath (in the dialog box
// design) remain their. Vertical maps can have those controls repositioned when
// possible to give the bitmap as much space as possible.
if(pBathyMapInf->widthMeters >= pBathyMapInf->heightMeters /* Horizontal orientation or square*/)
{
// Cares about height available when determining width. Grab the first the meets the
// requirements starting with the widest (want the map as wide as possible)
for(c=0; c<3; c++)
{
if(bathyPixAvial[c].width == 0)
continue;
bathyDimResult[c].width = bathyPixAvial[c].width-2; // -2 to be sure to save room for the border.
while(bathyDimResult[c].width%16 != 0)
bathyDimResult[c].width--;
bathyDimResult[c].height =
(int)((double)bathyDimResult[c].width * pBathyMapInf->heightMeters/pBathyMapInf->widthMeters);
while(bathyDimResult[c].height > bathyPixAvial[c].height-2 || bathyDimResult[c].width%16 != 0)
{
while(--bathyDimResult[c].width%16 != 0)
;
bathyDimResult[c].height =
(int)((double)(bathyDimResult[c].width * pBathyMapInf->heightMeters/pBathyMapInf->widthMeters));
}
}
// Now determine which configuration allows for the maximum width
c = 0;
for(i=1; i<3; i++)
{
if(cntrlsPixAvail[c].width <= bathyDimResult[i].width)
c = i;
}
_ASSERT(c >= 0 && c <=2);
}
else /* vertical orientation (height is greater than width)*/
{
c = 3;
bathyDimResult[c].height = bathyPixAvial[c].height-2;
bathyDimResult[c].width = (int)(bathyDimResult[c].height * pBathyMapInf->widthMeters/pBathyMapInf->heightMeters);
while(bathyDimResult[c].width > bathyPixAvial[c].width || bathyDimResult[c].width%16 != 0)
{
while(--bathyDimResult[c].width%16 != 0)
;
_ASSERT(bathyDimResult[c].width%16 == 0);
bathyDimResult[c].height = (int)(bathyDimResult[c].width * pBathyMapInf->heightMeters/pBathyMapInf->widthMeters);
}
}
_ASSERT(c >= 0 && c <=3);
// Get the configuration
//layoutConfig = GetDlgLayoutConfig(
//----------------------------------------------------------------------------------//
// Set up the bathymetry map size on the dialog box.
//-------------------------------------------------//
dlgLayout.bathy.width = bathyDimResult[c].width;
dlgLayout.bathy.height = bathyDimResult[c].height;
_ASSERT(bathyDimResult[c].width%16 == 0);
//----------------------------------------------------------------------------------//
// Set the slope and depth scale locations and size on the dialog box.
//--------------------------------------------------------------------//
// The X locations are a function of the space the bathymetry bitmap take up plus
// space inbetween
dlgLayout.depth.x = dlgLayout.bathy.x + dlgLayout.bathy.width + CONTRLSPACEPIXELS;
dlgLayout.depth.y = dlgLayout.bathy.y;
dlgLayout.depth.height = dlgLayout.bathy.height;
#if 0
if(g_hwndDepthScale == NULL)
{
// Depth scale
g_hwndDepthScale = CreateWindowEx(
0, // dwExStyle: The extended window style of the window being created.
SCALEBITMAPWINDOWCLASSNAME, // lpClassName: Pointer to a null-terminated string or a class atom
"ScaleBitmap", // lpWindowName: Pointer to a null-terminated string that specifies the window name
WS_CLIPCHILDREN | WS_BORDER | WS_VISIBLE | WS_CHILD, //dwStyle: Specifies the style of the window
dlgLayout.depth.x, // x: Initial horizontal position of the window
dlgLayout.depth.y, // y: Initial vertical position of the window
dlgLayout.depth.width + 2, // The width of the window in device units. +2 for the border box.
dlgLayout.depth.height + 2, // The height of the window in device units. +2 for the border box.
g_hDlgSeed, // hWndParent: Handle to the parent or owner window of the window being created.
(HMENU) NULL, //hMenu: Handle to a menu, or specifies a child-window identifier, depending on the window style.
NULL,//hInstance: Handle to the instance of the module to be associated with the window.
(LPVOID)(pSeedInf)); // lpParam: Pointer to a value to be passed to the window through the CREATESTRUCT
// structure (lpCreateParams member) pointed to by the lParam param of
// the WM_CREATE message
}
else
{
SetWindowPos(g_hwndDepthScale, HWND_TOP, dlgLayout.depth.x, dlgLayout.depth.y+2, dlgLayout.depth.width+2, dlgLayout.depth.height, SWP_SHOWWINDOW);
}
#endif
dlgLayout.slope.x = dlgLayout.depth.x + dlgLayout.depth.width + CONTRLSPACEPIXELS;
dlgLayout.slope.y = dlgLayout.bathy.y;
dlgLayout.slope.height = dlgLayout.bathy.height;
#if 0
if(g_hwndSlopeScale == NULL)
{
g_hwndSlopeScale = CreateWindowEx(
0, // dwExStyle: The extended window style of the window being created.
SCALEBITMAPWINDOWCLASSNAME, // lpClassName: Pointer to a null-terminated string or a class atom
"ScaleSlopeBitmap", // lpWindowName: Pointer to a null-terminated string that specifies the window name
WS_CLIPCHILDREN | WS_BORDER | WS_VISIBLE | WS_CHILD, //dwStyle: Specifies the style of the window
dlgLayout.slope.x, // x: Initial horizontal position of the window
dlgLayout.slope.y, //layout.depth.y, // y: Initial vertical position of the window
dlgLayout.slope.width + 2, // The width of the window in device units. +2 for the border box.
dlgLayout.slope.height + 2, // The height of the window in device units. +2 for the border box.
g_hDlgSeed, // hWndParent: Handle to the parent or owner window of the window being created.
(HMENU) NULL, //hMenu: Handle to a menu, or specifies a child-window identifier, depending on the window style.
NULL,//hInstance: Handle to the instance of the module to be associated with the window.
(LPVOID)(pSeedInf)); // lpParam: Pointer to a value to be passed to the window through the CREATESTRUCT
// structure (lpCreateParams member) pointed to by the lParam param of
// the WM_CREATE message
}
else
{
SetWindowPos(g_hwndSlopeScale, HWND_TOP, dlgLayout.slope.x, dlgLayout.slope.y+2, dlgLayout.slope.width+2, dlgLayout.slope.height, SWP_SHOWWINDOW);
}
#endif
#if 0
if(g_hwndBathy == NULL)
{
// Bathymetry bitmap
g_hwndBathy = CreateWindowEx(
0,
BATHYBITMAPWINDOWCLASSNAME,"BathyBitmap",
WS_CLIPCHILDREN | WS_BORDER | WS_VISIBLE | WS_CHILD,
DLGBOXLEFTSIDEMARGIN, //layout.bathy.x,
DLBBOXTOPMARGIN, //layout.bathy.y,
dlgLayout.bathy.width+2, //layout.bathy.width+2, // The width of the window in device units. +2 for the border box.
dlgLayout.bathy.height+2, // The height of the window in device units. +2 for the border box.
g_hDlgSeed, // parent window.
(HMENU) NULL,
NULL,
(LPVOID)(pSeedInf));
}
else
{
SetWindowPos(g_hwndBathy, HWND_TOP, NULL, NULL, dlgLayout.bathy.width+2, dlgLayout.bathy.height+2,
SWP_NOMOVE|SWP_SHOWWINDOW);
}
#endif
//----------------------------------------------------------------------------------//
// Get the change in the dialog box width and height.
//--------------------------------------------------//
// The change in width (dx) here tells how far to move the populants group box
// controls to the left (negative) or right (positive)
dx = dlg.width - PrevDlgProp.width;
dy = dlg.height - PrevDlgProp.height;
//----------------------------------------------------------------------------------//
// Move the Populants Group Box controls.
//---------------------------------------//
MoveDlgControl(IDC_STATIC_POPULANTS_GROUP_BOX, hDlg, dx, 0);
// Things under the IDC_STATIC_POPULANTS_GROUP_BOX control.
MoveDlgControl(IDC_LOAD_SCENARIO, hDlg, dx, 0);
MoveDlgControl(IDC_TRACKTOGGLE_BUTTON, hDlg, dx, 0);
MoveDlgControl(IDC_VISUAL_INC_BUTTON, hDlg, dx, 0);
MoveDlgControl(IDC_VISUAL_RESET_BUTTON, hDlg, dx, 0);
MoveDlgControl(IDC_VISUAL_STOP_BUTTON, hDlg, dx, 0);
MoveDlgControl(IDC_VISUAL_PLAY_BUTTON, hDlg, dx, 0);
MoveDlgControl(IDC_VISUAL_DEC_BUTTON, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_SPE_ACSRC, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_ENVDLG_FIRSANIMATACSTSRCE, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_ENVDLG_SPEC_ADD, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_ENVDLG_SPEC_REMOVE, hDlg, dx, 0);
MoveDlgControl(IDC_LIST_SPECIES, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_INDIVIDUAL, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_ENVDLG_INDIVIDUAL_DELETE, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_PODS, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_ENVDLG_POD_DELETE, hDlg, dx, 0);
MoveDlgControl(IDC_LIST_INDIVIDUAL, hDlg, dx, 0);
MoveDlgControl(IDC_LIST_PODS, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_POP_LOCATION, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_ENVDLG_PODMEMBER_DELETE, hDlg, dx, 0);
MoveDlgControl(IDC_LIST_SEL_POP, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_SEEDOPTNS_GRPBOX, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_SEED_INDIVIDUAL, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_ADD_POD, hDlg, dx, 0);
MoveDlgControl(IDC_EDIT_ENVBITMAP_INIT_PODSIZE, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_ENVBITMAP_INITPODSIZE, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_LEADANIMATSETTING_GRPBOX, hDlg, dx, 0);
MoveDlgControl(IDC_EDIT_ENVBITMAP_FOCAL_DIST, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_ENVBITMAP_FOCAL_DIST, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_PODLEADTYPE_ANIMAT, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_PODLEADTYPE_CENTROID, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_ADJUSTPODSIZE_GRPBOX, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_DEBUG_ADDPODMEMBER, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_SEEDING_METHOD, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_MOUSE_CLICKING, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_N_ANIMATS_AROUND_CLICK, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_BOUNDING_BOX, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_N_ANIMATS_OVERMAP, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_POLYGON, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_ANIMATS_BY_DENSITY, hDlg, dx, 0);
MoveDlgControl(IDC_EDIT_DENSITY, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_DENSITY, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_DENSITYCALC, hDlg, dx, 0);
MoveDlgControl(IDC_RADIO_LOAD_SHAPE_FILE, hDlg, dx, 0);
MoveDlgControl(IDC_EDIT_NUM_ANIMATS, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_NUMANIMATS, hDlg, dx, 0);
MoveDlgControl(IDC_EDIT_AVE_DIST, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_AVEDIST, hDlg, dx, 0);
MoveDlgControl(IDC_EDIT_STD_DIST, hDlg, dx, 0);
MoveDlgControl(IDC_STATIC_STDEVDIST, hDlg, dx, 0);
MoveDlgControl(IDC_VISUAL_RUN_BUTTON, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_DENSITYDISTRIBUTE, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_PODSIZEINC, hDlg, dx, 0);
MoveDlgControl(IDC_BUTTON_PODSIZEDEC, hDlg, dx, 0);
//----------------------------------------------------------------------------------//
// Move the Done Button
//---------------------//
MoveDlgControl(IDOK, hDlg, dx, dy);
//----------------------------------------------------------------------------------//
// Configure and move the Map Information group box controls
//-----------------------------------------------------------//
dy = dlgLayout.bathy.y + dlgLayout.bathy.height + CONTRLSPACEPIXELS;
dx = DLGBOXLEFTSIDEMARGIN;
SetDlgControlLocation(pLayoutOptions->config[c].mouseMoveLabel, GetDlgItem(hDlg, IDC_STATIC_MOUSE_POSITION), dx, dy);
if(c == 3)
{
dy = dlgLayout.bathy.y;
dx = dlgLayout.slope.x + dlgLayout.slope.width + CONTRLSPACEPIXELS;
}
m = pLayoutOptions->config[c].map;
SetDlgControlLocation(m.grpBox, GetDlgItem(hDlg, IDC_STATIC_MAPGROUPBOX), dx, dy);
SetDlgControlLocation(m.heightLabel, GetDlgItem(hDlg, IDC_STATIC_MAPHEIGHT), dx, dy);
SetDlgControlLocation(m.widthLabel, GetDlgItem(hDlg, IDC_STATIC_MAPWIDTH), dx, dy);
SetDlgControlLocation(m.totSurfAreaLabel, GetDlgItem(hDlg, IDC_STATIC_MAPSURFAREA), dx, dy);
SetDlgControlLocation(m.totWaterAreaLabel, GetDlgItem(hDlg, IDC_STATIC_MAPSURFAREA_WATER), dx, dy);
SetDlgControlLocation(m.totLandAreaLabel, GetDlgItem(hDlg, IDC_STATIC_MAPSURFAREA_LAND), dx, dy);
SetDlgControlLocation(m.latResLabel, GetDlgItem(hDlg, IDC_STATIC_RESOLUTION_LAT), dx, dy);
SetDlgControlLocation(m.lonResLabel, GetDlgItem(hDlg, IDC_STATIC_RESOLUTION_LON), dx, dy);
a = pLayoutOptions->config[c].animat;
SetDlgControlLocation(a.grpBox, GetDlgItem(hDlg, IDC_STATIC_ANIMATDENSITYGROUPBOX), dx, dy);
SetDlgControlLocation(a.densityLabel, GetDlgItem(hDlg, IDC_STATIC_ANIMATDENSITY), dx, dy);
SetDlgControlLocation(a.popSizeLabel, GetDlgItem(hDlg, IDC_STATIC_ANIMATPOPSIZE), dx, dy);
b = pLayoutOptions->config[c].buttonGroup;
SetDlgControlLocation(b.grpBox, GetDlgItem(hDlg, IDC_STATIC_DISPLAYOPTSGROUPBOX), dx, dy);
SetDlgControlLocation(b.samplePtsButton, GetDlgItem(hDlg, IDC_BUTTON_TOGGLE_DATPTS), dx, dy);
//SetDlgControlLocation(b.bathySlopeButton, GetDlgItem(hDlg, IDC_BUTTON_TOGGLE_EXTRAS), dx, dy);
SetDlgControlLocation(b.slopeRegionsButton, GetDlgItem(hDlg, IDC_BUTTON_TOGGLE_SLOPEREGIONS), dx, dy);
return dlgLayout;
}
BOOL CreateGLWindow(char* title, int width, int height, int bits, BOOL fullscreenflag)
{
GLuint PixelFormat; // Holds The Results After Searching For A Match
WNDCLASS wc; // Windows Class Structure
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
WindowRect.left=(long)0; // Set Left Value To 0
WindowRect.right=(long)width; // Set Right Value To Requested Width
WindowRect.top=(long)0; // Set Top Value To 0
WindowRect.bottom=(long)height; // Set Bottom Value To Requested Height
fullscreen=fullscreenflag; // Set The Global Fullscreen Flag
hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = hInstance; // Set The Instance
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For GL
wc.lpszMenuName = NULL; // We Don't Want A Menu
wc.lpszClassName = "OpenGL"; // Set The Class Name
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &DMsaved); // save the current display state (NEW)
if (fullscreen) // Attempt Fullscreen Mode?
{
DEVMODE dmScreenSettings; // Device Mode
memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared
dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure
dmScreenSettings.dmPelsWidth = width; // Selected Screen Width
dmScreenSettings.dmPelsHeight = height; // Selected Screen Height
dmScreenSettings.dmBitsPerPel = bits; // Selected Bits Per Pixel
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
// If The Mode Fails, Offer Two Options. Quit Or Use Windowed Mode.
if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
{
fullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE
}
else
{
// Pop Up A Message Box Letting User Know The Program Is Closing.
MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
return FALSE; // Return FALSE
}
}
}
if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{
MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (fullscreen) // Are We Still In Fullscreen Mode?
{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP; // Windows Style
ShowCursor(FALSE); // Hide Mouse Pointer
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
}
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
// Create The Window
if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
"OpenGL", // Class Name
title, // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
NULL, // No Parent Window
NULL, // No Menu
hInstance, // Instance
NULL))) // Dont Pass Anything To WM_CREATE
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
pfd.cColorBits = bits;
if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
ShowWindow(hWnd,SW_SHOW); // Show The Window
SetForegroundWindow(hWnd); // Slightly Higher Priority
SetFocus(hWnd); // Sets Keyboard Focus To The Window
ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen
if (!InitGL()) // Initialize Our Newly Created GL Window
{
KillGLWindow(); // Reset The Display
MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // Return FALSE
}
return TRUE; // Success
}
/**
* name: Button_WndProc
* desc: window procedure for the button class
* param: hwndBtn - window handle to the button
* uMsg - message to handle
* wParam - message specific parameter
* lParam - message specific parameter
* return: message specific
**/
static LRESULT CALLBACK Button_WndProc(HWND hwndBtn, UINT uMsg, WPARAM wParam, LPARAM lParam) {
LPBTNCTRL bct = (LPBTNCTRL)GetWindowLongPtr(hwndBtn, 0);
switch (uMsg) {
case WM_NCCREATE:
{
LPCREATESTRUCT cs = (LPCREATESTRUCT)lParam;
cs->style |= BS_OWNERDRAW;
if (!(bct = (LPBTNCTRL)mir_alloc(sizeof(BTNCTRL))))
return FALSE;
ZeroMemory(bct, sizeof(BTNCTRL));
bct->hwnd = hwndBtn;
bct->stateId = PBS_NORMAL;
bct->hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
bct->dwStyle = cs->style;
if (cs->style & MBS_DOWNARROW)
bct->arrow = Skin_GetIcon(ICO_BTN_DOWNARROW);
LoadTheme(bct);
SetWindowLongPtr(hwndBtn, 0, (LONG_PTR)bct);
if (cs->lpszName) SetWindowText(hwndBtn, cs->lpszName);
return TRUE;
}
case WM_DESTROY:
if (bct) {
EnterCriticalSection(&csTips);
if (hwndToolTips) {
TOOLINFO ti;
ZeroMemory(&ti, sizeof(ti));
ti.cbSize = sizeof(ti);
ti.uFlags = TTF_IDISHWND;
ti.hwnd = bct->hwnd;
ti.uId = (UINT_PTR)bct->hwnd;
if (SendMessage(hwndToolTips, TTM_GETTOOLINFO, 0, (LPARAM)&ti)) {
SendMessage(hwndToolTips, TTM_DELTOOL, 0, (LPARAM)&ti);
}
if (SendMessage(hwndToolTips, TTM_GETTOOLCOUNT, 0, (LPARAM)&ti) == 0) {
DestroyWindow(hwndToolTips);
hwndToolTips = NULL;
}
}
LeaveCriticalSection(&csTips);
DestroyTheme(bct);
mir_free(bct);
}
SetWindowLongPtr(hwndBtn, 0, NULL);
break;
case WM_SETTEXT:
bct->cHot = 0;
if ((LPTSTR)lParam) {
LPTSTR tmp = (LPTSTR)lParam;
while (*tmp) {
if (*tmp == '&' && *(tmp + 1)) {
bct->cHot = _totlower(*(tmp + 1));
break;
}
tmp++;
}
InvalidateRect(bct->hwnd, NULL, TRUE);
}
break;
case WM_SYSKEYUP:
if (bct->stateId != PBS_DISABLED && bct->cHot && bct->cHot == _totlower((TCHAR)wParam)) {
if (bct->dwStyle & MBS_PUSHBUTTON) {
if (bct->pbState) bct->pbState = 0;
else bct->pbState = 1;
InvalidateRect(bct->hwnd, NULL, TRUE);
}
else
SetFocus(hwndBtn);
SendMessage(GetParent(hwndBtn), WM_COMMAND, MAKELONG(GetDlgCtrlID(hwndBtn), BN_CLICKED), (LPARAM)hwndBtn);
return 0;
}
break;
case WM_THEMECHANGED:
// themed changed, reload theme object
LoadTheme(bct);
InvalidateRect(bct->hwnd, NULL, TRUE); // repaint it
break;
case WM_SETFONT: // remember the font so we can use it later
bct->hFont = (HFONT)wParam; // maybe we should redraw?
break;
case WM_NCPAINT:
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdcPaint;
HDC hdcMem;
HBITMAP hbmMem;
HDC hOld;
RECT rcClient;
if (hdcPaint = BeginPaint(hwndBtn, &ps)) {
GetClientRect(bct->hwnd, &rcClient);
hdcMem = CreateCompatibleDC(hdcPaint);
hbmMem = CreateCompatibleBitmap(hdcPaint, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top);
hOld = (HDC)SelectObject(hdcMem, hbmMem);
// If its a push button, check to see if it should stay pressed
if ((bct->dwStyle & MBS_PUSHBUTTON) && bct->pbState) bct->stateId = PBS_PRESSED;
if ((bct->dwStyle & MBS_FLAT) && bct->hThemeToolbar || bct->hThemeButton)
PaintThemeButton(bct, hdcMem, &rcClient);
else
PaintButton(bct, hdcMem, &rcClient);
BitBlt(hdcPaint, 0, 0, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top, hdcMem, 0, 0, SRCCOPY);
SelectObject(hdcMem, hOld);
DeleteObject(hbmMem);
DeleteDC(hdcMem);
EndPaint(hwndBtn, &ps);
}
}
return 0;
case BM_SETIMAGE:
if (wParam == IMAGE_ICON) {
bct->hIcon = (HICON)lParam;
bct->hBitmap = NULL;
InvalidateRect(bct->hwnd, NULL, TRUE);
}
else if (wParam == IMAGE_BITMAP) {
bct->hIcon = NULL;
bct->hBitmap = (HBITMAP)lParam;
InvalidateRect(bct->hwnd, NULL, TRUE);
}
else if (wParam == NULL && lParam == NULL) {
bct->hIcon = NULL;
bct->hBitmap = NULL;
InvalidateRect(bct->hwnd, NULL, TRUE);
}
break;
case BM_SETCHECK:
if (!(bct->dwStyle & MBS_PUSHBUTTON)) break;
if (wParam == BST_CHECKED) {
bct->pbState = 1;
bct->stateId = PBS_PRESSED;
}
else if (wParam == BST_UNCHECKED) {
bct->pbState = 0;
bct->stateId = PBS_NORMAL;
}
InvalidateRect(bct->hwnd, NULL, TRUE);
break;
case BM_GETCHECK:
if (bct->dwStyle & MBS_PUSHBUTTON) return bct->pbState ? BST_CHECKED : BST_UNCHECKED;
return 0;
case BUTTONSETDEFAULT:
bct->defbutton = (wParam != 0);
InvalidateRect(bct->hwnd, NULL, TRUE);
break;
case BUTTONADDTOOLTIP:
if (wParam) {
EnterCriticalSection(&csTips);
if (!hwndToolTips)
hwndToolTips = CreateWindowEx(WS_EX_TOPMOST, TOOLTIPS_CLASS, NULL, WS_POPUP, 0, 0, 0, 0, NULL, NULL, GetModuleHandle(NULL), NULL);
if (lParam == MBBF_UNICODE) {
TOOLINFOW ti;
ZeroMemory(&ti, sizeof(TOOLINFOW));
ti.cbSize = sizeof(TOOLINFOW);
ti.uFlags = TTF_IDISHWND;
ti.hwnd = bct->hwnd;
ti.uId = (UINT_PTR)bct->hwnd;
if (SendMessage(hwndToolTips, TTM_GETTOOLINFOW, 0, (LPARAM)&ti)) {
SendMessage(hwndToolTips, TTM_DELTOOLW, 0, (LPARAM)&ti);
}
ti.uFlags = TTF_IDISHWND|TTF_SUBCLASS;
ti.uId = (UINT_PTR)bct->hwnd;
ti.lpszText=(LPWSTR)wParam;
SendMessage(hwndToolTips, TTM_ADDTOOLW, 0, (LPARAM)&ti);
}
else {
TOOLINFOA ti;
ZeroMemory(&ti, sizeof(TOOLINFOA));
ti.cbSize = sizeof(TOOLINFOA);
ti.uFlags = TTF_IDISHWND;
ti.hwnd = bct->hwnd;
ti.uId = (UINT_PTR)bct->hwnd;
if (SendMessage(hwndToolTips, TTM_GETTOOLINFOA, 0, (LPARAM)&ti)) {
SendMessage(hwndToolTips, TTM_DELTOOLA, 0, (LPARAM)&ti);
}
ti.uFlags = TTF_IDISHWND|TTF_SUBCLASS;
ti.uId = (UINT_PTR)bct->hwnd;
ti.lpszText=(LPSTR)wParam;
SendMessage(hwndToolTips, TTM_ADDTOOLA, 0, (LPARAM)&ti);
}
LeaveCriticalSection(&csTips);
}
break;
case BUTTONTRANSLATE:
{
TCHAR szButton[MAX_PATH];
GetWindowText(bct->hwnd, szButton, MAX_PATH);
SetWindowText(bct->hwnd, TranslateTS(szButton));
}
break;
case WM_SETFOCUS: // set keybord bFocus and redraw
bct->bFocus = 1;
InvalidateRect(bct->hwnd, NULL, TRUE);
break;
case WM_KILLFOCUS: // kill bFocus and redraw
bct->bFocus = 0;
InvalidateRect(bct->hwnd, NULL, TRUE);
break;
case WM_WINDOWPOSCHANGED:
InvalidateRect(bct->hwnd, NULL, TRUE);
break;
case WM_ENABLE: // windows tells us to enable/disable
bct->stateId = wParam ? PBS_NORMAL : PBS_DISABLED;
InvalidateRect(bct->hwnd, NULL, TRUE);
break;
case WM_MOUSELEAVE: // faked by the WM_TIMER
if (bct->stateId != PBS_DISABLED) { // don't change states if disabled
bct->stateId = PBS_NORMAL;
InvalidateRect(bct->hwnd, NULL, TRUE);
}
break;
case WM_LBUTTONDOWN:
if (bct->stateId != PBS_DISABLED) { // don't change states if disabled
bct->stateId = PBS_PRESSED;
InvalidateRect(bct->hwnd, NULL, TRUE);
}
break;
case WM_LBUTTONUP:
if (bct->stateId != PBS_DISABLED) { // don't change states if disabled
BYTE bPressed = bct->stateId == PBS_PRESSED;
if (bct->dwStyle & MBS_PUSHBUTTON) {
if (bct->pbState) bct->pbState = 0;
else bct->pbState = 1;
}
bct->stateId = PBS_HOT;
// Tell your daddy you got clicked, if mouse is still over the button.
if ((bct->dwStyle & MBS_PUSHBUTTON) || bPressed)
SendMessage(GetParent(hwndBtn), WM_COMMAND, MAKELONG(GetDlgCtrlID(hwndBtn), BN_CLICKED), (LPARAM)hwndBtn);
InvalidateRect(bct->hwnd, NULL, TRUE);
}
break;
case WM_MOUSEMOVE:
if (bct->stateId == PBS_NORMAL) {
bct->stateId = PBS_HOT;
InvalidateRect(bct->hwnd, NULL, TRUE);
}
// Call timer, used to start cheesy TrackMouseEvent faker
SetTimer(hwndBtn, BUTTON_POLLID, BUTTON_POLLDELAY, NULL);
break;
case WM_TIMER: // use a timer to check if they have did a mouseout
if (wParam == BUTTON_POLLID) {
RECT rc;
POINT pt;
GetWindowRect(hwndBtn, &rc);
GetCursorPos(&pt);
if (!PtInRect(&rc, pt)) { // mouse must be gone, trigger mouse leave
PostMessage(hwndBtn, WM_MOUSELEAVE, 0, 0L);
KillTimer(hwndBtn, BUTTON_POLLID);
}
}
break;
case WM_ERASEBKGND:
return 1;
}
return DefWindowProc(hwndBtn, uMsg, wParam, lParam);
}
