int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEX winClass;
HWND hwnd;
MSG msg;
// Process command line
LPWSTR *argv = NULL;
int argc;
int i;
unsigned short tilingMode = DEFAULT_TILING_MODE;
argv = CommandLineToArgvW(GetCommandLineW(), &argc);
for (i = 0; i < argc; i++) {
char arg[128];
wsprintfA(arg, "%S", argv[i]);
if (i < (argc - 1)) {
char nextarg[128];
wsprintfA(nextarg, "%S", argv[i + 1]);
if (!strcmp(arg, "-o")) {
alpha = atoi(nextarg);
} else if (!strcmp(arg, "-i")) {
if (ignoreCount < MAX_IGNORE) {
sprintf(ignoreClasses[ignoreCount++], "%s", nextarg);
}
} else if (!strcmp(arg, "-a")) {
include_mode = 1; // Include mode instead of exclude
if (includeCount < MAX_IGNORE) {
sprintf(includeClasses[includeCount++], "%s", nextarg);
}
} else if (!strcmp(arg, "-m")) {
int y;
modkeys = 0;
for (y = 0; y < strlen(nextarg); y++) {
switch (nextarg[y])
{
case 'c':
modkeys |= MOD_CONTROL;
break;
case 'a':
modkeys |= MOD_ALT;
break;
case 's':
modkeys |= MOD_SHIFT;
break;
case 'w':
modkeys |= MOD_WIN;
break;
}
}
} else if (!strcmp(arg, "-t")) {
tilingMode = atoi(nextarg);
} else if (!strcmp(arg, "-left")) {
screen_x = atoi(nextarg);
} else if (!strcmp(arg, "-top")) {
screen_y = atoi(nextarg);
} else if (!strcmp(arg, "-width")) {
screen_width = atoi(nextarg);
} else if (!strcmp(arg, "-height")) {
screen_height = atoi(nextarg);
}
}
if (!strcmp(arg, "-v")) {
MessageBox(NULL, VERSION, "Version", MB_OK);
LocalFree(argv);
return 1;
} else if (!strcmp(arg, "-l")) {
lockMouse = 1;
} else if (!strcmp(arg, "-x")) {
experimental_mouse = 1;
} else if (!strcmp(arg, "--one-tag")) {
one_tag_per_window = 1;
}
}
// Initialize tags
for (i = 0; i < TAGS; i++) {
tags[i].nodes = NULL;
tags[i].last_node = NULL;
tags[i].current_window = NULL;
tags[i].tilingMode = tilingMode;
tags[i].masterarea_count = 1;
}
LocalFree(argv);
winClass.cbSize = sizeof(WNDCLASSEX);
winClass.style = 0;
winClass.lpfnWndProc = WndProc;
winClass.cbClsExtra = 0;
winClass.cbWndExtra = 0;
winClass.hInstance = hInstance;
winClass.hIcon = NULL;
winClass.hIconSm = NULL;
winClass.hCursor = NULL;
winClass.hbrBackground = NULL;
winClass.lpszMenuName = NULL;
winClass.lpszClassName = NAME;
if (!RegisterClassEx(&winClass)) {
MessageBox(NULL, "Error Registering Window Class", "Error", MB_OK | MB_ICONERROR);
return 0; // Bail
}
hwnd = CreateWindowEx(0, NAME, NAME, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, hInstance, NULL);
if (!hwnd) {
MessageBox(NULL, "Error Creating Window", "Error", MB_OK | MB_ICONERROR);
return 0; // Bail
}
if (!screen_x && !screen_y && !screen_width && !screen_height) { // Screen options aren't being specified from the command line so set some defaults
RECT workarea;
SystemParametersInfo(SPI_GETWORKAREA, 0, &workarea, 0);
screen_x = workarea.left;
screen_y = workarea.top;
screen_width = workarea.right - workarea.left;
screen_height = workarea.bottom - workarea.top;
}
RegisterHotkeys(hwnd);
UpdateMousePos(hwnd);
EnumWindows(EnumWindowsRestore, 0); // Restore windows on startup so they get tiled
EnumWindows(EnumWindowsProc, 0);
ArrangeWindows();
// Get function pointer for RegisterShellHookWindow
if ( RegisterShellHookWindow_ == NULL )
{
RegisterShellHookWindow_ = (BOOL (__stdcall *)(HWND))GetProcAddress(GetModuleHandle("USER32.DLL"), "RegisterShellHookWindow");
if (RegisterShellHookWindow_ == NULL) {
MessageBox(NULL, "Could not find RegisterShellHookWindow", "Error", MB_OK | MB_ICONERROR);
return 0;
}
}
RegisterShellHookWindow_(hwnd);
shellhookid = RegisterWindowMessage("SHELLHOOK"); // Grab a dynamic id for the SHELLHOOK message to be used later
while (GetMessage(&msg, NULL, 0, 0) > 0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
void CDX8Disp::UpdateResList(
unsigned int requested_width, unsigned int requested_height, int requested_cdepth)
{
int selected_sel = -1;
bool standard_match = TRUE;
m_res_list.ResetContent();
if (d3d_interface == NULL)
return;
requested_cdepth = GetCDepth(requested_cdepth);
int selected_adapter = m_adapter_list.GetCurSel();
int num_modes = d3d_interface->GetAdapterModeCount(selected_adapter);
int index = -1;
char mode_string[20] = "";
// Only list different resolutions and bit type NOT different refresh rates
int index_count = 0;
for(int i = 0; i < num_modes; i++)
{
D3DDISPLAYMODE mode;
if(FAILED(d3d_interface->EnumAdapterModes(selected_adapter, i, &mode)))
{
MessageBox("Failed EnumAdapterModes", "Error", MB_ICONERROR);
return;
}
if (d3d8_get_mode_bit(mode.Format) != requested_cdepth)
continue;
// skip anything below the minimum
if( !(mode.Width == 640 && mode.Height == 480) &&
(mode.Width < 800 || mode.Height < 600))
{
continue;
}
/*
// Lets look ahead and get the lowest refresh rate
// Can't assume there will be at least 60 or 0
while(i > 0)
{
D3DDISPLAYMODE next_mode;
if(FAILED(d3d_interface->EnumAdapterModes(selected_adapter, i-1, &next_mode)))
{
MessageBox("Failed EnumAdapterModes", "Fatal Error", MB_ICONERROR);
return;
}
// Modes are the same execpt refresh rate
if( mode.Width == next_mode.Width &&
mode.Height == next_mode.Height &&
d3d8_get_mode_bit(mode.Format) == d3d8_get_mode_bit(next_mode.Format))
{
DBUGFILE_OUTPUT_2("Changing stored mode from %d to %d", i, i-1);
i--;
}
else
{
DBUGFILE_OUTPUT_0("Not the same, next!");
break;
}
}
*/
/*
char new_string[20];
sprintf(new_string, "%dx%dx%d", mode.Width, mode.Height, d3d8_get_mode_bit(mode.Format));
if(stricmp(new_string, mode_string) == 0)
{
continue;
}
strcpy(mode_string,new_string);
*/
// If not the first mode
if(index > -1)
{
bool ignore_this_mode = false;
int count_back = index;
while(count_back > -1)
{
int back_mode_index = m_res_list.GetItemData(count_back);
D3DDISPLAYMODE last_mode;
if(FAILED(d3d_interface->EnumAdapterModes(selected_adapter, back_mode_index, &last_mode)))
{
MessageBox("Failed EnumAdapterModes", "Fatal Error", MB_ICONERROR);
return;
}
// If we already have this mode ignore it
if( mode.Width == last_mode.Width &&
mode.Height == last_mode.Height &&
d3d8_get_mode_bit(mode.Format) == d3d8_get_mode_bit(last_mode.Format))
{
ignore_this_mode = true;
break;
}
count_back--;
}
if(ignore_this_mode)
{
continue;
}
}
sprintf(mode_string, "%d x %d", mode.Width, mode.Height);
index = m_res_list.InsertString(index_count, mode_string);
m_res_list.SetItemData(index, i);
if( requested_width == mode.Width &&
requested_height == mode.Height &&
requested_cdepth == d3d8_get_mode_bit(mode.Format))
{
selected_sel = index_count;
// identify whether this is one of the standard video modes or not
standard_match = ((mode.Width == 1024 && mode.Height == 768) ||
(mode.Width == 640 && mode.Height == 480));
}
// char buffer[100];
// sprintf(buffer,"refresh %d", mode.RefreshRate);
// MessageBox(buffer, "DEBUG", MB_OK);
index_count++;
}
if (selected_sel < 0)
selected_sel = 0;
// show or hide the non-standard video mode text if needed
GetDlgItem(IDC_NSVM_TEXT)->ShowWindow( (standard_match) ? SW_HIDE : SW_SHOW );
m_res_list.SetCurSel(selected_sel);
UpdateAntialiasList();
}
int
WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
if (set_applet_wd() < 0)
return -1;
#ifdef SEAF_LANG_CHINESE
char *seafile_locale_dir = g_build_filename (seafile_bin_dir,
"i18n", NULL);
/* init i18n */
setlocale (LC_ALL, "zh_CN");
bindtextdomain(GETTEXT_PACKAGE, seafile_locale_dir);
bind_textdomain_codeset(GETTEXT_PACKAGE, "GBK");
textdomain(GETTEXT_PACKAGE);
#endif
if (count_process("seafile-applet") > 1) {
MessageBox(NULL, _("Seafile is already running"), "Seafile", MB_OK);
exit(1);
}
int argc;
char **argv;
char cmdbuf[1024];
GError *err = NULL;
WSADATA wsadata;
WSAStartup(0x0101, &wsadata);
UNREFERENCED_PARAMETER(hPrevInstance);
snprintf(cmdbuf, sizeof(cmdbuf), "seafile-applet.exe %s", lpCmdLine);
char *xxx = _("Seafile Initialization");
char tmp[128];
snprintf(tmp, sizeof(tmp), "%s", xxx);
if (!g_shell_parse_argv (cmdbuf, &argc, &argv, &err)) {
if (err)
applet_warning ("parse arguments failed %s\n", err->message);
applet_exit(1);
}
g_type_init();
applet = g_new0 (SeafileApplet, 1);
seafile_applet_init (hInstance);
seafile_applet_start (argc, argv);
MSG msg;
HACCEL hAccelTable;
memset(&msg, 0, sizeof(msg));
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_STARTINTRAY));
while (GetMessage(&msg, NULL, 0, 0)) {
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
MsgAnswer PASCAL _DefMessageHook (MsgKey key, ErrSev sev,
const char *caption, const char *message)
{
MsgAnswer answer = ANS_NONE;
#ifdef OS_MSWIN
if ( !Nlm_HasConsole )
{
static UINT _sev_code[SEV_MAX+1] = {
/* SEV_NONE */ MB_OK,
/* SEV_INFO */ MB_ICONINFORMATION,
/* SEV_WARNING */ MB_ICONASTERISK, /* same as MB_ICONINFORMATION */
/* SEV_ERROR */ MB_ICONEXCLAMATION,
/* SEV_REJECT */ MB_ICONEXCLAMATION,
/* SEV_FATAL */ MB_ICONHAND,
/* SEV_MAX */ MB_ICONHAND
};
UINT flags = MB_TASKMODAL | _sev_code[(int)sev];
if (key > 0)
flags |= (key-1);
answer = (MsgAnswer) MessageBox(NULL,message,caption,flags);
return answer;
}
#endif
#if defined(WIN_DUMB) || defined(OS_MAC)
{{
static char * _key_str [] = {
/* KEY_NONE */ "",
/* KEY_OK */ "Hit Return ",
/* KEY_OKC */ "C = Cancel, Anything else = OK ",
/* KEY_ARI */ "A = abort, R = retry, I = ignore ",
/* KEY_YNC */ "Y = yes, N = no, C = cancel ",
/* KEY_YN */ "Y = yes, N = no ",
/* KEY_RC */ "R = retry, C = Cancel "
};
fflush(stdout);
fprintf(stderr,"[%s] %s\n",
caption ? caption : "NULL_Caption",
message ? message : "NULL_Message");
#if defined(OS_UNIX)
if (isatty(STDIN_FILENO))
#endif
if (key>KEY_NONE && key<KEY_other)
{
int ch;
/* show prompt */
fprintf(stderr,"%s ",_key_str[(int)key]);
/* set default value */
switch (key)
{
case KEY_OK: case KEY_OKC:
answer = ANS_OK; break;
case KEY_ARI: case KEY_RC:
answer = ANS_RETRY; break;
case KEY_YNC: case KEY_YN:
answer = ANS_YES; break;
case KEY_NONE: case KEY_other:
ASSERT_HARD ( FALSE );
}
/* get response */
ch = GetOneChar();
ch = isalpha(ch) ? toupper(ch) : ch;
switch (ch)
{
case 'A' :
answer = ANS_ABORT; break;
case 'C' :
answer = ANS_CANCEL; break;
case 'I' :
answer = ANS_IGNORE; break;
case 'N' :
answer = ANS_NO; break;
}
}
}}
#endif /* WIN_DUMB || OS_MAC */
return answer;
}
void create_wing_dlg::OnOK()
{
CString msg;
int i;
object *ptr;
UpdateData(TRUE);
UpdateData(TRUE);
m_name = drop_white_space((char *)(LPCSTR) m_name);
if (m_name.IsEmpty()) {
MessageBox("You must give a name before you can continue.");
return;
}
for (i=0; i<MAX_WINGS; i++)
if (!stricmp(Wings[i].name, m_name) && Wings[i].wave_count) {
msg.Format("The name \"%s\" is already being used by another wing", m_name);
MessageBox(msg);
return;
}
ptr = GET_FIRST(&obj_used_list);
while (ptr != END_OF_LIST(&obj_used_list)) {
if ((ptr->type == OBJ_SHIP) || (ptr->type == OBJ_START)){
i = ptr->instance;
if (!strnicmp(m_name, Ships[i].ship_name, strlen(m_name))) {
char *namep;
namep = Ships[i].ship_name + strlen(m_name);
if (*namep == ' ') {
namep++;
while (*namep) {
if (!isdigit(*namep))
break;
namep++;
}
}
if (!*namep) {
MessageBox("This wing name is already being used by a ship");
return;
}
}
}
ptr = GET_NEXT(ptr);
}
for (i=0; i<Num_iffs; i++) {
if (!stricmp(m_name, Iff_info[i].iff_name)) {
msg.Format("The name \"%s\" is already being used by a team", m_name);
MessageBox(msg);
return;
}
}
for ( i=0; i < (int)Ai_tp_list.size(); i++) {
if (!stricmp(m_name, Ai_tp_list[i].name)) {
msg.Format("The name \"%s\" is already being used by a target priority group", m_name);
MessageBox(msg);
return;
}
}
for (i=0; i<MAX_WAYPOINT_LISTS; i++) {
if (Waypoint_lists[i].count && !stricmp(Waypoint_lists[i].name, m_name)) {
MessageBox("This wing name is already being used by a waypoint path");
return;
}
}
if (!stricmp(m_name.Left(1), "<")) {
MessageBox("Wing names not allowed to begin with <");
return;
}
CDialog::OnOK();
}
void __fastcall TForm1::actRedesignClassificationsExecute(TObject *Sender)
{
lblStatus->Caption = "";
if(!MakeBackup()) {
Log->Lines->Add("Не удалось создать резервную копию файла");
lblStatus->Caption = "Ошибка: Не удалось создать резервную копию файла";
return;
}
m_strRecomendations = "";
lblStatus->Caption = "Открываю файл на чтение...";
Variant app = Variant::CreateObject("Excel.Application");
app.OlePropertySet("Visible", true);
Variant excel = app.OlePropertyGet("Workbooks").OleFunction("Open", WideString(m_strFileName.c_str()));
Variant vSheets = excel.OlePropertyGet("Worksheets");
Variant vSheet = vSheets.OlePropertyGet("Item",m_nPageClassification);
UnicodeString strPageName = vSheet.OlePropertyGet("Name");
if (strPageName.UpperCase() != UnicodeString("классификации").UpperCase()) {
app.OleProcedure("Quit");
MessageBox (Handle, UnicodeString(L"Не верное имя страницы").c_str(), L"prompt", MB_OK);
lblStatus->Caption = "Ошибка: Не верное имя страницы";
return;
};
std::vector<exlClass> classes;
ReadClassifications(vSheet, classes);
std::vector<exlMonth> months;
for (unsigned int i = 0; i < m_vMonth.size(); i++) {
int nMonthPage = m_vMonth[i].Number;
Variant vSheetMonth = vSheets.OlePropertyGet("Item",nMonthPage);
ReadMonth(vSheetMonth, months);
}
// Log->Lines->Add("Обновляю линки." + IntToStr((int)months.size()));
int nAll = classes.size() * months.size();
Log->Lines->Add("Всего записей в месяцах: " + IntToStr((int)months.size()));
std::vector<exlClass> newclasses;
int nRemovedClasses = 0;
ProgressBar1->Max = nAll;
ProgressBar1->Min = 0;
ProgressBar1->Position = 0;
lblStatus->Caption = "Поиск наименований которые отсутвуют в месяцах...";
Log->Lines->Add("Произвожу поиск наименований которые отсутвуют в месяцах...");
for (unsigned int iC = 0; iC < classes.size(); iC++) {
exlClass cl = classes[iC];
cl.Monthes = "";
UnicodeString name = classes[iC].Name.UpperCase();
int nCount = 0;
for (unsigned int iM = 0; iM < months.size(); iM++) {
ProgressBar1->Position++;
Application->ProcessMessages();
UnicodeString name2 = months[iM].Name.UpperCase();
if (name == name2) {
nCount++;
if (cl.Monthes.Pos(months[iM].Month) < 1) {
cl.Monthes += months[iM].Month + ";";
}
}
}
if (nCount > 0) {
newclasses.push_back(cl);
} else {
nRemovedClasses++;
Log->Lines->Add("\tНаименование '" + cl.Name + "' - нигде не встречается и будет удалено из классификаций");
}
}
Log->Lines->Add(" ** ");
nAll = newclasses.size() * months.size();
ProgressBar1->Max = nAll;
ProgressBar1->Min = 0;
ProgressBar1->Position = 0;
int nAddClasses = 0;
lblStatus->Caption = "Поиск наименований которые отсутвуют в списке классификаций...";
Log->Lines->Add("Произвожу поиск наименований которые отсутвуют в списке классификаций...");
for (unsigned int iM = 0; iM < months.size(); iM++) {
UnicodeString name = months[iM].Name.UpperCase();
int nCount = 0;
for (unsigned int iC = 0; iC < newclasses.size(); iC++) {
ProgressBar1->Position++;
Application->ProcessMessages();
UnicodeString name2 = newclasses[iC].Name.UpperCase();
if (name == name2) {
nCount++;
}
}
if (nCount == 0) {
Log->Lines->Add("\tНаименование '" + months[iM].Name + "' - будет добавлено в классификации");
exlClass cl;
cl.Name = months[iM].Name;
cl.Class = m_sUnknownClass;
cl.Monthes += months[iM].Month + ";";
newclasses.push_back(cl);
nAddClasses++;
nAll = newclasses.size() * months.size();
ProgressBar1->Max = nAll;
}
}
Log->Lines->Add("Будет удалено классификаций: " + IntToStr(nRemovedClasses));
Log->Lines->Add("Будет добавлено классификаций: " + IntToStr(nAddClasses));
Log->Lines->Add("Всего классификаций: " + IntToStr((int)(newclasses.size())));
WriteClassifications(vSheet, newclasses);
lblStatus->Caption = "Сохраняю файл...";
Log->Lines->Add("Сохраняю файл...");
try {
app.OlePropertySet("DisplayAlerts",false);
excel.OleProcedure("SaveAs", WideString(m_strFileName.c_str()));
Log->Lines->Add("Данные сохранены!");
} catch (...) {
lblStatus->Caption = "Ошибка: Пожалуйста закройте все открытые копии файла и повторите операцию";
Log->Lines->Add("Ошибка: Пожалуйста закройте все открытые копии файла и повторите операцию");
}
ProgressBar1->Position = 0;
app.OleProcedure("Quit");
lblStatus->Caption = "";
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
edtFile->Text = "";
m_strFileName = "";
if (OpenDialog1->Execute()) {
m_bBackup = false;
UnicodeString strFileName = OpenDialog1->FileName;
if (! FileExists (strFileName)) {
MessageBox (Handle, UnicodeString(L"Файл '" + strFileName + L"' не существует").c_str(), L"prompt", MB_OK);
edtFile->Text = "";
return;
}
edtFile->Text = strFileName;
// TODO: create backup now or later?
// TODO: INIT OPERATIONS
// TODO: scan month
Variant var_Book,var_Sheet,var_Cell;
Variant app = Variant::CreateObject("Excel.Application");
// app.OlePropertySet("Visible",false);
Variant excel;
try {
excel = app.OlePropertyGet("Workbooks").OleFunction("Open", WideString(strFileName.c_str()));
} catch (...) {
MessageBox (Handle, UnicodeString(L"Не получается открыть файл '" + strFileName + L"' как excel").c_str(), L"prompt", MB_OK);
app.OleProcedure("Quit");
edtFile->Text = "";
return;
}
Log->Lines->Add("Файл загружен производиться анализ");
Variant vSheets = excel.OlePropertyGet("Worksheets");
m_nPageClassification = 0;
m_vMonth.clear();
cmbMonth->Items->Clear();
cmbMonth->Items->Add("");
int nSheets = vSheets.OlePropertyGet("Count");
Log->Lines->Add("Всего листов: " + IntToStr(nSheets));
for (int i = 0; i < nSheets; i++) {
Variant vSheet = vSheets.OlePropertyGet("Item",i+1);
UnicodeString str = vSheet.OlePropertyGet("Name");
if (str.UpperCase() == UnicodeString("классификации").UpperCase()) {
m_nPageClassification = i+1;
};
if (str.UpperCase().Pos("МЕСЯЦ ") > 0) {
cmbMonth->Items->Add(str);
exlSheet s;
s.Number = i+1;
s.Name = str;
m_vMonth.push_back(s);
}
Log->Lines->Add("Лист " + IntToStr(i+1) + ": " + str);
}
if (m_nPageClassification == 0) {
MessageBox (Handle, UnicodeString(L"Не найден лист 'классификации'").c_str(), L"prompt", MB_OK);
app.OleProcedure("Quit");
edtFile->Text = "";
return;
}
if (m_vMonth.size() == 0) {
MessageBox (Handle, UnicodeString(L"Не найден ни один лист с 'месяц xx'").c_str(), L"prompt", MB_OK);
app.OleProcedure("Quit");
edtFile->Text = "";
return;
}
app.OleProcedure("Quit");
m_strFileName = strFileName;
}
}
/*
==================
SNDDM_InitWav
Crappy windows multimedia base
==================
*/
qboolean SNDDMA_InitWav( void ) {
WAVEFORMATEX format;
int i;
HRESULT hr;
Com_Printf( "Initializing wave sound\n" );
snd_sent = 0;
snd_completed = 0;
dma.channels = 2;
dma.samplebits = 16;
if ( s_khz->value == 44 ) {
dma.speed = 44100;
}
if ( s_khz->value == 22 ) {
dma.speed = 22050;
} else {
dma.speed = 11025;
}
memset( &format, 0, sizeof( format ) );
format.wFormatTag = WAVE_FORMAT_PCM;
format.nChannels = dma.channels;
format.wBitsPerSample = dma.samplebits;
format.nSamplesPerSec = dma.speed;
format.nBlockAlign = format.nChannels
* format.wBitsPerSample / 8;
format.cbSize = 0;
format.nAvgBytesPerSec = format.nSamplesPerSec
* format.nBlockAlign;
/* Open a waveform device for output using window callback. */
Com_DPrintf( "...opening waveform device: " );
while ( ( hr = waveOutOpen( (LPHWAVEOUT)&hWaveOut, WAVE_MAPPER,
&format,
0, 0L, CALLBACK_NULL ) ) != MMSYSERR_NOERROR )
{
if ( hr != MMSYSERR_ALLOCATED ) {
Com_Printf( "failed\n" );
return qfalse;
}
if ( MessageBox( NULL,
"The sound hardware is in use by another app.\n\n"
"Select Retry to try to start sound again or Cancel to run Quake 2 with no sound.",
"Sound not available",
MB_RETRYCANCEL | MB_SETFOREGROUND | MB_ICONEXCLAMATION ) != IDRETRY ) {
Com_Printf( "hw in use\n" );
return qfalse;
}
}
Com_DPrintf( "ok\n" );
/*
* Allocate and lock memory for the waveform data. The memory
* for waveform data must be globally allocated with
* GMEM_MOVEABLE and GMEM_SHARE flags.
*/
Com_DPrintf( "...allocating waveform buffer: " );
gSndBufSize = WAV_BUFFERS * WAV_BUFFER_SIZE;
hData = GlobalAlloc( GMEM_MOVEABLE | GMEM_SHARE, gSndBufSize );
if ( !hData ) {
Com_Printf( " failed\n" );
FreeSound();
return qfalse;
}
Com_DPrintf( "ok\n" );
Com_DPrintf( "...locking waveform buffer: " );
lpData = GlobalLock( hData );
if ( !lpData ) {
Com_Printf( " failed\n" );
FreeSound();
return qfalse;
}
memset( lpData, 0, gSndBufSize );
Com_DPrintf( "ok\n" );
/*
* Allocate and lock memory for the header. This memory must
* also be globally allocated with GMEM_MOVEABLE and
* GMEM_SHARE flags.
*/
Com_DPrintf( "...allocating waveform header: " );
hWaveHdr = GlobalAlloc( GMEM_MOVEABLE | GMEM_SHARE,
(DWORD) sizeof( WAVEHDR ) * WAV_BUFFERS );
if ( hWaveHdr == NULL ) {
Com_Printf( "failed\n" );
FreeSound();
return qfalse;
}
Com_DPrintf( "ok\n" );
Com_DPrintf( "...locking waveform header: " );
lpWaveHdr = (LPWAVEHDR) GlobalLock( hWaveHdr );
if ( lpWaveHdr == NULL ) {
Com_Printf( "failed\n" );
FreeSound();
return qfalse;
}
memset( lpWaveHdr, 0, sizeof( WAVEHDR ) * WAV_BUFFERS );
Com_DPrintf( "ok\n" );
/* After allocation, set up and prepare headers. */
Com_DPrintf( "...preparing headers: " );
for ( i = 0 ; i < WAV_BUFFERS ; i++ )
{
lpWaveHdr[i].dwBufferLength = WAV_BUFFER_SIZE;
lpWaveHdr[i].lpData = lpData + i * WAV_BUFFER_SIZE;
if ( waveOutPrepareHeader( hWaveOut, lpWaveHdr + i, sizeof( WAVEHDR ) ) !=
MMSYSERR_NOERROR ) {
Com_Printf( "failed\n" );
FreeSound();
return qfalse;
}
}
Com_DPrintf( "ok\n" );
dma.samples = gSndBufSize / ( dma.samplebits / 8 );
dma.samplepos = 0;
dma.submission_chunk = 512;
dma.buffer = (unsigned char *) lpData;
sample16 = ( dma.samplebits / 8 ) - 1;
wav_init = qtrue;
return qtrue;
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
node *current = NULL;
node *nodes;
unsigned short tag;
switch (msg)
{
case WM_CREATE:
if (experimental_mouse) {
SetTimer(hwnd, TIMER_UPDATE_MOUSE, 500, NULL); // Poll for mouse position
}
break;
case WM_CLOSE:
{
ClipCursor(0); // Release Cursor Lock
DeregisterShellHookWindow(hwnd);
UnregisterHotkeys(hwnd);
if (experimental_mouse) {
KillTimer(hwnd, TIMER_UPDATE_MOUSE); // Mouse Poll Timer
}
for (tag=0; tag<TAGS; tag++) {
nodes = tags[tag].nodes;
for (current = nodes; current;) {
node *next = current->next;
RestoreWindow(current->hwnd);
RemoveNode(current->hwnd, tag);
current = next;
}
DestroyWindow(hwnd);
}
}
break;
case WM_DESTROY:
PostQuitMessage(WM_QUIT);
break;
case WM_HOTKEY:
if (wParam >= KEY_TOGGLE_T1 && wParam < (KEY_TOGGLE_T1 + TAGS)) {
ToggleTag(wParam - KEY_TOGGLE_T1);
break;
} else if (wParam >= KEY_SWITCH_T1 && wParam < (KEY_SWITCH_T1 + TAGS)) {
MinimizeTag(current_tag);
current_tag = wParam - KEY_SWITCH_T1;
ArrangeWindows();
break;
}
current = tags[current_tag].current_window;
switch (wParam)
{
case KEY_SELECT_UP:
if (current) {
tags[current_tag].current_window = GetNextNode();
FocusCurrent();
}
break;
case KEY_SELECT_DOWN:
if (current) {
tags[current_tag].current_window = GetPreviousNode();
FocusCurrent();
}
break;
case KEY_MOVE_MAIN:
SwapWindowWithNode(tags[current_tag].nodes);
ArrangeWindows();
break;
case KEY_EXIT:
PostMessage(hwnd, WM_CLOSE, 0, 0);
break;
case KEY_MARGIN_LEFT:
margin -= 20;
ArrangeWindows();
break;
case KEY_MARGIN_RIGHT:
margin += 20;
ArrangeWindows();
break;
case KEY_IGNORE:
if (!disableNext) {
disableNext = 1;
} else {
disableNext = 0;
}
break;
case KEY_MOUSE_LOCK:
if (lockMouse) {
lockMouse = 0;
ClipCursor(0);
} else {
lockMouse = 1;
FocusCurrent();
}
break;
case KEY_TILING_MODE:
tags[current_tag].tilingMode = (tags[current_tag].tilingMode + 1) % MODE_END;
ArrangeWindows();
break;
case KEY_MOVE_UP:
if (current) {
SwapWindowWithNode(GetNextNode());
ArrangeWindows();
}
break;
case KEY_MOVE_DOWN:
if (current) {
SwapWindowWithNode(GetPreviousNode());
ArrangeWindows();
}
break;
case KEY_DISP_CLASS:
{
LPSTR temp = (LPSTR)malloc(sizeof(TCHAR) * 128);
GetClassName(GetForegroundWindow(), temp, 128);
MessageBox(NULL, temp, "Window Class", MB_OK);
free(temp);
}
break;
case KEY_TILE:
if (IsGoodWindow(GetForegroundWindow())) {
AddNode(GetForegroundWindow(), current_tag);
ArrangeWindows();
}
break;
case KEY_UNTILE:
FullRemoveNode(GetForegroundWindow());
ArrangeWindows();
break;
case KEY_INC_AREA:
SwapWindowWithFirstNonMasterWindow();
tags[current_tag].masterarea_count++;
ArrangeWindows();
break;
case KEY_DEC_AREA:
tags[current_tag].masterarea_count--;
ArrangeWindows();
break;
case KEY_CLOSE_WIN:
PostMessage(GetForegroundWindow(), WM_CLOSE, 0, 0);
break;
case KEY_LEFT:
if(current_tag>0) {
MinimizeTag(current_tag);
current_tag--;
ArrangeWindows();
}
break;
case KEY_RIGHT:
if(current_tag<9) {
MinimizeTag(current_tag);
current_tag++;
ArrangeWindows();
}
break;
}
break;
case WM_TIMER:
switch (wParam)
{
case TIMER_UPDATE_MOUSE:
UpdateMousePos(hwnd);
break;
}
break;
default:
if (msg == shellhookid) { // Handle the Shell Hook message
switch (wParam)
{
case HSHELL_WINDOWCREATED:
if (IsGoodWindow((HWND)lParam)) {
AddNode((HWND)lParam, current_tag);
ArrangeWindows();
FocusCurrent();
}
break;
case HSHELL_WINDOWDESTROYED:
FullRemoveNode((HWND)lParam);
ArrangeWindows();
FocusCurrent();
break;
case HSHELL_RUDEAPPACTIVATED:
case HSHELL_WINDOWACTIVATED:
{
node *found = FindNode((HWND)lParam, current_tag);
if (found) {
tags[current_tag].current_window = current = found;
FocusCurrent();
}
}
break;
}
} else {
return DefWindowProc(hwnd, msg, wParam, lParam);
}
}
return 0;
}
BOOL Window::Create(BOOL fullscreen, const char *title, int width, int height, int bits,LPTSTR menu)
{
if(!Window::RegisterWindow(mHInstance))
return FALSE;
GLuint PixelFormat; // Holds The Results After Searching For A Match
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
RECT ClientRect;
ClientRect.left = (long)0;
ClientRect.right = (long)width;
ClientRect.top = (long)0;
ClientRect.bottom = (long)height;
mFullscreen = fullscreen;
if(mFullscreen)
{
DEVMODE dm; // Device Mode
memset(&dm, 0, sizeof(dm)); // Makes Sure Memory's Cleared
dm.dmSize = sizeof(dm); // Size Of The Devmode Structure
dm.dmPelsHeight = height; // Selected Screen Height
dm.dmPelsWidth = width; // Selected Screen Width
dm.dmBitsPerPel = bits; // Selected Bits Per Pixel
dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
if(ChangeDisplaySettings(&dm, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{
if(MessageBox(NULL, TEXT("ÇöÀçÀÇ ºñµð¿ÀÄ«µå¿¡¼ Ç®½ºÅ©¸°À» Áö¿øÇÏÁö ¾Ê½À´Ï´Ù. º¸ÅëȸéÀ¸·Î º¸½Ã°Ú½À´Ï±î?"), TEXT("¿À·ù"),
MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
{
mFullscreen = FALSE;
}
else
{
MessageBox(NULL, TEXT("ÇÁ·Î±×·¥À» Á¾·áÇÕ´Ï´Ù"), TEXT("¾Ë¸²"), MB_OK | MB_ICONSTOP);
PostQuitMessage(0);
return FALSE; //exit
}
}
}
if(mFullscreen)
{
dwExStyle = WS_EX_APPWINDOW;
dwStyle = WS_POPUP;
//ShowCursor(false);
}
else
{
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle = WS_OVERLAPPEDWINDOW;
}
AdjustWindowRectEx(&ClientRect, dwStyle, false, dwExStyle); // Adjust Window To true Requested Size
mHWnd = CreateWindowEx(
dwExStyle,
"eglWindow",
title,
dwStyle|WS_CLIPSIBLINGS|WS_CLIPCHILDREN,
0, 0,
ClientRect.right-ClientRect.left,
ClientRect.bottom-ClientRect.top,
(HWND)NULL,
(HMENU)((!fullscreen) ? LoadMenu(mHInstance, menu) : NULL),
mHInstance,
(LPVOID)this); //¸Þ¼¼Áö¸ÊÀ» À§ÇÏ¿© this Æ÷ÀÎÅ͸¦ ³Ñ±ä´Ù.
if(!mHWnd)
{
MessageBox(NULL, TEXT("À©µµ¿ì¸¦ »ý¼ºÇϴµ¥ ½ÇÆÐÇß½Àˆ•"), TEXT("¿À·ù"), MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
static PIXELFORMATDESCRIPTOR pfd = {
sizeof(pfd), // 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
UseAccumulationBuffer(), // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
UseStencilBuffer(), // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
// Did We Get A Device Context?
if(!(mDC = GetDC(mHWnd)))
{
DestroyGLWindow();
MessageBox(NULL, TEXT("GL Device Context ¸¦ »ý¼ºÇÒ ¼ö ¾ø½À´Ï´Ù"), TEXT("¿À·ù"), MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
// Did Windows Find A Matching Pixel Format?
if (!(PixelFormat = ChoosePixelFormat(mDC, &pfd)))
{
DestroyGLWindow();
MessageBox(NULL, TEXT("ÀåÄ¡¿¡ ¸Â´Â Çȼ¿Çü½ÄÀ» ãÁö ¸øÇß½À´Ï´Ù"), TEXT("¿À·ù"), MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
// Are We Able To Set The Pixel Format?
if(!SetPixelFormat(mDC, PixelFormat, &pfd))
{
DestroyGLWindow();
MessageBox(NULL, TEXT("Çȼ¿Çü½ÄÀ» ¼³Á¤ÇÒ ¼ö ¾ø½À´Ï´Ù"), TEXT("¿À·ù"), MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
// Are We Able To Get A Rendering Context?
if (!(mRC=wglCreateContext(mDC)))
{
DestroyGLWindow();
MessageBox(NULL, TEXT("GL Rendering Context ¸¦ »ý¼ºÇÒ ¼ö ¾ø½À´Ï´Ù"), TEXT("¿À·ù"), MB_OK | MB_ICONEXCLAMATION);
return FALSE; // Return false
}
// Try To Activate The Rendering Context
if(!wglMakeCurrent(mDC, mRC))
{
DestroyGLWindow();
MessageBox(NULL, TEXT("GL Rendering Context ¸¦ »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù"), TEXT("¿À·ù"), MB_OK | MB_ICONEXCLAMATION);
return FALSE; // Return false
}
ShowWindow(mHWnd, SW_SHOW); // Show The Window
SetForegroundWindow(mHWnd); // Slightly Higher Priority
SetFocus(mHWnd); // Sets Keyboard Focus To The Window
OnSize(0, MAKELPARAM(width, height)); //ÀÌÇÔ¼ö¸¦ È£ÃâÇÏÁö ¾ÊÀ¸¸é FULLSCREEN ¿¡¼ ±×¸²ÀÌ ±×·ÁÁöÁö ¾Ê´Â´Ù.
// Initialize Our Newly Created GL Window
if (!InitGL())
{
DestroyGLWindow();
MessageBox(NULL, TEXT("ÃʱâÈ¿¡ ½ÇÆÐÇß½À´Ï´Ù"), TEXT("¿À·ù"), MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
return TRUE;
}
STDMETHODIMP IECrossfireBHO::displayMessage(OLECHAR* message) {
MessageBox(NULL, message, L"Crossfire Server Error", 0);
return S_OK;
}
/*
* Dialog-box function for the main PuTTYgen dialog box.
*/
static int CALLBACK MainDlgProc(HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam)
{
static const char generating_msg[] =
"Please wait while a key is generated...";
static const char entropy_msg[] =
"Please generate some randomness by moving the mouse over the blank area.";
struct MainDlgState *state;
switch (msg) {
case WM_INITDIALOG:
if (help_path)
SetWindowLong(hwnd, GWL_EXSTYLE,
GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_CONTEXTHELP);
else {
/*
* If we add a Help button, this is where we destroy it
* if the help file isn't present.
*/
}
requested_help = FALSE;
SendMessage(hwnd, WM_SETICON, (WPARAM) ICON_BIG,
(LPARAM) LoadIcon(hinst, MAKEINTRESOURCE(200)));
state = snew(struct MainDlgState);
state->generation_thread_exists = FALSE;
state->collecting_entropy = FALSE;
state->entropy = NULL;
state->key_exists = FALSE;
SetWindowLong(hwnd, GWL_USERDATA, (LONG) state);
{
HMENU menu, menu1;
menu = CreateMenu();
menu1 = CreateMenu();
AppendMenu(menu1, MF_ENABLED, IDC_LOAD, "&Load private key");
AppendMenu(menu1, MF_ENABLED, IDC_SAVEPUB, "Save p&ublic key");
AppendMenu(menu1, MF_ENABLED, IDC_SAVE, "&Save private key");
AppendMenu(menu1, MF_SEPARATOR, 0, 0);
AppendMenu(menu1, MF_ENABLED, IDC_QUIT, "E&xit");
AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&File");
state->filemenu = menu1;
menu1 = CreateMenu();
AppendMenu(menu1, MF_ENABLED, IDC_GENERATE, "&Generate key pair");
AppendMenu(menu1, MF_SEPARATOR, 0, 0);
AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH1, "SSH&1 key (RSA)");
AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2RSA, "SSH2 &RSA key");
AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2DSA, "SSH2 &DSA key");
AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Key");
state->keymenu = menu1;
menu1 = CreateMenu();
AppendMenu(menu1, MF_ENABLED, IDC_IMPORT, "&Import key");
AppendMenu(menu1, MF_SEPARATOR, 0, 0);
AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_OPENSSH,
"Export &OpenSSH key");
AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_SSHCOM,
"Export &ssh.com key");
AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1,
"Con&versions");
state->cvtmenu = menu1;
menu1 = CreateMenu();
AppendMenu(menu1, MF_ENABLED, IDC_ABOUT, "&About");
if (help_path)
AppendMenu(menu1, MF_ENABLED, IDC_GIVEHELP, "&Help");
AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Help");
SetMenu(hwnd, menu);
}
/*
* Centre the window.
*/
{ /* centre the window */
RECT rs, rd;
HWND hw;
hw = GetDesktopWindow();
if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
MoveWindow(hwnd,
(rs.right + rs.left + rd.left - rd.right) / 2,
(rs.bottom + rs.top + rd.top - rd.bottom) / 2,
rd.right - rd.left, rd.bottom - rd.top, TRUE);
}
{
struct ctlpos cp, cp2;
/* Accelerators used: acglops1rbd */
ctlposinit(&cp, hwnd, 4, 4, 4);
beginbox(&cp, "Key", IDC_BOX_KEY);
cp2 = cp;
statictext(&cp2, "No key.", 1, IDC_NOKEY);
cp2 = cp;
statictext(&cp2, "", 1, IDC_GENERATING);
progressbar(&cp2, IDC_PROGRESS);
bigeditctrl(&cp,
"&Public key for pasting into authorized_keys file:",
IDC_PKSTATIC, IDC_KEYDISPLAY, 5);
SendDlgItemMessage(hwnd, IDC_KEYDISPLAY, EM_SETREADONLY, 1, 0);
staticedit(&cp, "Key f&ingerprint:", IDC_FPSTATIC,
IDC_FINGERPRINT, 75);
SendDlgItemMessage(hwnd, IDC_FINGERPRINT, EM_SETREADONLY, 1,
0);
staticedit(&cp, "Key &comment:", IDC_COMMENTSTATIC,
IDC_COMMENTEDIT, 75);
staticpassedit(&cp, "Key p&assphrase:", IDC_PASSPHRASE1STATIC,
IDC_PASSPHRASE1EDIT, 75);
staticpassedit(&cp, "C&onfirm passphrase:",
IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT, 75);
endbox(&cp);
beginbox(&cp, "Actions", IDC_BOX_ACTIONS);
staticbtn(&cp, "Generate a public/private key pair",
IDC_GENSTATIC, "&Generate", IDC_GENERATE);
staticbtn(&cp, "Load an existing private key file",
IDC_LOADSTATIC, "&Load", IDC_LOAD);
static2btn(&cp, "Save the generated key", IDC_SAVESTATIC,
"Save p&ublic key", IDC_SAVEPUB,
"&Save private key", IDC_SAVE);
endbox(&cp);
beginbox(&cp, "Parameters", IDC_BOX_PARAMS);
radioline(&cp, "Type of key to generate:", IDC_TYPESTATIC, 3,
"SSH&1 (RSA)", IDC_KEYSSH1,
"SSH2 &RSA", IDC_KEYSSH2RSA,
"SSH2 &DSA", IDC_KEYSSH2DSA, NULL);
staticedit(&cp, "Number of &bits in a generated key:",
IDC_BITSSTATIC, IDC_BITS, 20);
endbox(&cp);
}
CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA, IDC_KEYSSH2RSA);
CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
IDC_KEYSSH2RSA, MF_BYCOMMAND);
SetDlgItemInt(hwnd, IDC_BITS, DEFAULT_KEYSIZE, FALSE);
/*
* Initially, hide the progress bar and the key display,
* and show the no-key display. Also disable the Save
* buttons, because with no key we obviously can't save
* anything.
*/
ui_set_state(hwnd, state, 0);
/*
* Load a key file if one was provided on the command line.
*/
if (cmdline_keyfile)
load_key_file(hwnd, state, filename_from_str(cmdline_keyfile), 0);
return 1;
case WM_MOUSEMOVE:
state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
if (state->collecting_entropy &&
state->entropy && state->entropy_got < state->entropy_required) {
state->entropy[state->entropy_got++] = lParam;
state->entropy[state->entropy_got++] = GetMessageTime();
SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS,
state->entropy_got, 0);
if (state->entropy_got >= state->entropy_required) {
struct rsa_key_thread_params *params;
DWORD threadid;
/*
* Seed the entropy pool
*/
random_add_heavynoise(state->entropy, state->entropy_size);
memset(state->entropy, 0, state->entropy_size);
sfree(state->entropy);
state->collecting_entropy = FALSE;
SetDlgItemText(hwnd, IDC_GENERATING, generating_msg);
SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
MAKELPARAM(0, PROGRESSRANGE));
SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
params = snew(struct rsa_key_thread_params);
params->progressbar = GetDlgItem(hwnd, IDC_PROGRESS);
params->dialog = hwnd;
params->keysize = state->keysize;
params->is_dsa = state->is_dsa;
params->key = &state->key;
params->dsskey = &state->dsskey;
if (!CreateThread(NULL, 0, generate_rsa_key_thread,
params, 0, &threadid)) {
MessageBox(hwnd, "Out of thread resources",
"Key generation error",
MB_OK | MB_ICONERROR);
sfree(params);
} else {
state->generation_thread_exists = TRUE;
}
}
}
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_KEYSSH1:
case IDC_KEYSSH2RSA:
case IDC_KEYSSH2DSA:
{
state = (struct MainDlgState *)
GetWindowLong(hwnd, GWL_USERDATA);
if (!IsDlgButtonChecked(hwnd, LOWORD(wParam)))
CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA,
LOWORD(wParam));
CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
LOWORD(wParam), MF_BYCOMMAND);
}
break;
case IDC_QUIT:
PostMessage(hwnd, WM_CLOSE, 0, 0);
break;
case IDC_COMMENTEDIT:
if (HIWORD(wParam) == EN_CHANGE) {
state = (struct MainDlgState *)
GetWindowLong(hwnd, GWL_USERDATA);
if (state->key_exists) {
HWND editctl = GetDlgItem(hwnd, IDC_COMMENTEDIT);
int len = GetWindowTextLength(editctl);
if (*state->commentptr)
sfree(*state->commentptr);
*state->commentptr = snewn(len + 1, char);
GetWindowText(editctl, *state->commentptr, len + 1);
if (state->ssh2) {
setupbigedit2(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
&state->ssh2key);
} else {
setupbigedit1(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
&state->key);
}
}
}
void load_key_file(HWND hwnd, struct MainDlgState *state,
Filename filename, int was_import_cmd)
{
char passphrase[PASSPHRASE_MAXLEN];
int needs_pass;
int type, realtype;
int ret;
char *comment;
struct PassphraseProcStruct pps;
struct RSAKey newkey1;
struct ssh2_userkey *newkey2 = NULL;
type = realtype = key_type(&filename);
if (type != SSH_KEYTYPE_SSH1 &&
type != SSH_KEYTYPE_SSH2 &&
!import_possible(type)) {
char msg[256];
sprintf(msg, "Couldn't load private key (%s)",
key_type_to_str(type));
MessageBox(NULL, msg,
"PuTTYgen Error", MB_OK | MB_ICONERROR);
return;
}
if (type != SSH_KEYTYPE_SSH1 &&
type != SSH_KEYTYPE_SSH2) {
realtype = type;
type = import_target_type(type);
}
comment = NULL;
if (realtype == SSH_KEYTYPE_SSH1)
needs_pass = rsakey_encrypted(&filename, &comment);
else if (realtype == SSH_KEYTYPE_SSH2)
needs_pass =
ssh2_userkey_encrypted(&filename, &comment);
else
needs_pass = import_encrypted(&filename, realtype,
&comment);
pps.passphrase = passphrase;
pps.comment = comment;
do {
if (needs_pass) {
int dlgret;
dlgret = DialogBoxParam(hinst,
MAKEINTRESOURCE(210),
NULL, PassphraseProc,
(LPARAM) & pps);
if (!dlgret) {
ret = -2;
break;
}
} else
*passphrase = '\0';
if (type == SSH_KEYTYPE_SSH1) {
if (realtype == type)
ret = loadrsakey(&filename, &newkey1,
passphrase, NULL);
else
ret = import_ssh1(&filename, realtype,
&newkey1, passphrase);
} else {
if (realtype == type)
newkey2 = ssh2_load_userkey(&filename,
passphrase, NULL);
else
newkey2 = import_ssh2(&filename, realtype,
passphrase);
if (newkey2 == SSH2_WRONG_PASSPHRASE)
ret = -1;
else if (!newkey2)
ret = 0;
else
ret = 1;
}
} while (ret == -1);
if (comment)
sfree(comment);
if (ret == 0) {
MessageBox(NULL, "Couldn't load private key.",
"PuTTYgen Error", MB_OK | MB_ICONERROR);
} else if (ret == 1) {
/*
* Now update the key controls with all the
* key data.
*/
{
SetDlgItemText(hwnd, IDC_PASSPHRASE1EDIT,
passphrase);
SetDlgItemText(hwnd, IDC_PASSPHRASE2EDIT,
passphrase);
if (type == SSH_KEYTYPE_SSH1) {
char buf[128];
char *savecomment;
state->ssh2 = FALSE;
state->commentptr = &state->key.comment;
state->key = newkey1;
/*
* Set the key fingerprint.
*/
savecomment = state->key.comment;
state->key.comment = NULL;
rsa_fingerprint(buf, sizeof(buf),
&state->key);
state->key.comment = savecomment;
SetDlgItemText(hwnd, IDC_FINGERPRINT, buf);
/*
* Construct a decimal representation
* of the key, for pasting into
* .ssh/authorized_keys on a Unix box.
*/
setupbigedit1(hwnd, IDC_KEYDISPLAY,
IDC_PKSTATIC, &state->key);
} else {
char *fp;
char *savecomment;
state->ssh2 = TRUE;
state->commentptr =
&state->ssh2key.comment;
state->ssh2key = *newkey2; /* structure copy */
sfree(newkey2);
savecomment = state->ssh2key.comment;
state->ssh2key.comment = NULL;
fp =
state->ssh2key.alg->
fingerprint(state->ssh2key.data);
state->ssh2key.comment = savecomment;
SetDlgItemText(hwnd, IDC_FINGERPRINT, fp);
sfree(fp);
setupbigedit2(hwnd, IDC_KEYDISPLAY,
IDC_PKSTATIC, &state->ssh2key);
}
SetDlgItemText(hwnd, IDC_COMMENTEDIT,
*state->commentptr);
}
/*
* Finally, hide the progress bar and show
* the key data.
*/
ui_set_state(hwnd, state, 2);
state->key_exists = TRUE;
/*
* If the user has imported a foreign key
* using the Load command, let them know.
* If they've used the Import command, be
* silent.
*/
if (realtype != type && !was_import_cmd) {
char msg[512];
sprintf(msg, "Successfully imported foreign key\n"
"(%s).\n"
"To use this key with PuTTY, you need to\n"
"use the \"Save private key\" command to\n"
"save it in PuTTY's own format.",
key_type_to_str(realtype));
MessageBox(NULL, msg, "PuTTYgen Notice",
MB_OK | MB_ICONINFORMATION);
}
}
}
/**
* Generate textfile version of D3D8 caps
* Allow user to save it where they want then open it
*/
void CDX8Disp::OnGenCaps()
{
if(d3d_interface == NULL) return;
int selected_adapter = m_adapter_list.GetCurSel();
char mass_buffer[50000];
int i = 0;
// OS
char os_string[100];
os_get_type_text(os_string);
i += sprintf(mass_buffer + i, "Operating System: %s\n", os_string);
i += sprintf(mass_buffer + i, "Memory: %d MB\n", memory_get_ammount() / 1048576);
// Adapter data
D3DADAPTER_IDENTIFIER8 identifier;
if(FAILED(d3d_interface->GetAdapterIdentifier(selected_adapter, D3DENUM_NO_WHQL_LEVEL, &identifier)))
{
MessageBox("Failed GetAdapterIdentifier in OnGenCaps", "Fatal Error", MB_ICONERROR);
return;
}
// Lets get the all mode data
int num_modes = d3d_interface->GetAdapterModeCount(selected_adapter);
i += sprintf(mass_buffer + i, "Adapter: %s\n\n", identifier.Description);
i += sprintf(mass_buffer + i, "Modes:\n\n");
for(int j = num_modes - 1; j >= 0; j--)
{
D3DDISPLAYMODE mode;
if(FAILED(d3d_interface->EnumAdapterModes(selected_adapter, j, &mode)))
{
MessageBox("Failed EnumAdapterModes in OnGenCaps", "Fatal Error", MB_ICONERROR);
return;
}
i += sprintf(mass_buffer + i,
"%d: (%dx%d)x%d bit, %d rr\n",
j, mode.Width, mode.Height,
d3d8_get_mode_bit(mode.Format),
mode.RefreshRate);
}
// Now output the caps
D3DCAPS8 caps;
HRESULT hr = d3d_interface->GetDeviceCaps(selected_adapter, D3DDEVTYPE_HAL, &caps);
// Don't quit, continue on; sometimes it doesn't matter!
if(FAILED(hr))
{
char buffer[100];
sprintf(buffer, "Failed to generate caps, please report to coder");
MessageBox(buffer, "Error", MB_ICONERROR);
}
else
{
char *temp;
// Internal MACRO, only for use in this function
#define SPRINTF_FLAG(cap, flag) \
temp = #cap "." #flag ":"; \
i += sprintf(mass_buffer + i, "%-63s %s\n", temp, (cap & flag) ? "yes" : "no");
// Internal MACRO, only for use in this function
#define SPRINTF_NL() i += sprintf(mass_buffer + i, "\n")
// This outputs all the DX8 caps to text
i += sprintf(mass_buffer + i, "\n\nD3D8 Caps:\n\n");
SPRINTF_FLAG(caps.Caps, D3DCAPS_READ_SCANLINE);
SPRINTF_NL();
SPRINTF_FLAG(caps.Caps2, D3DCAPS2_CANCALIBRATEGAMMA);
SPRINTF_FLAG(caps.Caps2, D3DCAPS2_CANRENDERWINDOWED);
SPRINTF_FLAG(caps.Caps2, D3DCAPS2_CANMANAGERESOURCE);
SPRINTF_FLAG(caps.Caps2, D3DCAPS2_DYNAMICTEXTURES);
SPRINTF_FLAG(caps.Caps2, D3DCAPS2_FULLSCREENGAMMA);
SPRINTF_FLAG(caps.Caps2, D3DCAPS2_NO2DDURING3DSCENE);
SPRINTF_NL();
SPRINTF_FLAG(caps.Caps3, D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD);
SPRINTF_NL();
SPRINTF_FLAG(caps.PresentationIntervals, D3DPRESENT_INTERVAL_IMMEDIATE);
SPRINTF_FLAG(caps.PresentationIntervals, D3DPRESENT_INTERVAL_ONE);
SPRINTF_FLAG(caps.PresentationIntervals, D3DPRESENT_INTERVAL_TWO);
SPRINTF_FLAG(caps.PresentationIntervals, D3DPRESENT_INTERVAL_THREE);
SPRINTF_FLAG(caps.PresentationIntervals, D3DPRESENT_INTERVAL_FOUR);
SPRINTF_NL();
SPRINTF_FLAG(caps.CursorCaps, D3DCURSORCAPS_COLOR);
SPRINTF_FLAG(caps.CursorCaps, D3DCURSORCAPS_LOWRES);
SPRINTF_NL();
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_CANBLTSYSTONONLOCAL);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_CANRENDERAFTERFLIP);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_DRAWPRIMTLVERTEX);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_EXECUTESYSTEMMEMORY);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_EXECUTEVIDEOMEMORY);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_HWRASTERIZATION);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_HWTRANSFORMANDLIGHT);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_NPATCHES);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_PUREDEVICE);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_QUINTICRTPATCHES);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_RTPATCHES);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_RTPATCHHANDLEZERO);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_SEPARATETEXTUREMEMORIES);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_TEXTURENONLOCALVIDMEM);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_TEXTURESYSTEMMEMORY);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_TEXTUREVIDEOMEMORY);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_TLVERTEXSYSTEMMEMORY);
SPRINTF_FLAG(caps.DevCaps, D3DDEVCAPS_TLVERTEXVIDEOMEMORY);
SPRINTF_NL();
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_BLENDOP);
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_CLIPPLANESCALEDPOINTS);
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_CLIPTLVERTS);
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_COLORWRITEENABLE);
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_CULLCCW);
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_CULLCW);
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_CULLNONE);
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_LINEPATTERNREP);
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_MASKZ);
SPRINTF_FLAG(caps.PrimitiveMiscCaps, D3DPMISCCAPS_TSSARGTEMP);
SPRINTF_NL();
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_ANISOTROPY);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_ANTIALIASEDGES);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_COLORPERSPECTIVE);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_DITHER);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_FOGRANGE);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_FOGTABLE);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_FOGVERTEX);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_MIPMAPLODBIAS);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_PAT);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_STRETCHBLTMULTISAMPLE);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_WBUFFER);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_WFOG);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_ZBIAS);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_ZBUFFERLESSHSR);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_ZFOG);
SPRINTF_FLAG(caps.RasterCaps, D3DPRASTERCAPS_ZTEST);
SPRINTF_NL();
SPRINTF_FLAG(caps.ZCmpCaps, D3DPCMPCAPS_ALWAYS);
SPRINTF_FLAG(caps.ZCmpCaps, D3DPCMPCAPS_EQUAL);
SPRINTF_FLAG(caps.ZCmpCaps, D3DPCMPCAPS_GREATER);
SPRINTF_FLAG(caps.ZCmpCaps, D3DPCMPCAPS_GREATEREQUAL);
SPRINTF_FLAG(caps.ZCmpCaps, D3DPCMPCAPS_LESS);
SPRINTF_FLAG(caps.ZCmpCaps, D3DPCMPCAPS_LESSEQUAL);
SPRINTF_FLAG(caps.ZCmpCaps, D3DPCMPCAPS_NEVER);
SPRINTF_FLAG(caps.ZCmpCaps, D3DPCMPCAPS_NOTEQUAL);
SPRINTF_NL();
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_BOTHINVSRCALPHA);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_BOTHSRCALPHA);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_DESTALPHA);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_DESTCOLOR);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_INVDESTALPHA);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_INVDESTCOLOR);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_INVSRCALPHA);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_INVSRCCOLOR);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_ONE);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_SRCALPHA);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_SRCALPHASAT);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_SRCCOLOR);
SPRINTF_FLAG(caps.SrcBlendCaps,D3DPBLENDCAPS_ZERO);
SPRINTF_NL();
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_BOTHINVSRCALPHA);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_BOTHSRCALPHA);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_DESTALPHA);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_DESTCOLOR);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_INVDESTALPHA);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_INVDESTCOLOR);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_INVSRCALPHA);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_INVSRCCOLOR);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_ONE);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_SRCALPHA);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_SRCALPHASAT);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_SRCCOLOR);
SPRINTF_FLAG(caps.DestBlendCaps,D3DPBLENDCAPS_ZERO);
SPRINTF_NL();
SPRINTF_FLAG(caps.AlphaCmpCaps, D3DPCMPCAPS_ALWAYS);
SPRINTF_FLAG(caps.AlphaCmpCaps, D3DPCMPCAPS_EQUAL);
SPRINTF_FLAG(caps.AlphaCmpCaps, D3DPCMPCAPS_GREATER);
SPRINTF_FLAG(caps.AlphaCmpCaps, D3DPCMPCAPS_GREATEREQUAL);
SPRINTF_FLAG(caps.AlphaCmpCaps, D3DPCMPCAPS_LESS);
SPRINTF_FLAG(caps.AlphaCmpCaps, D3DPCMPCAPS_LESSEQUAL);
SPRINTF_FLAG(caps.AlphaCmpCaps, D3DPCMPCAPS_NEVER);
SPRINTF_FLAG(caps.AlphaCmpCaps, D3DPCMPCAPS_NOTEQUAL);
SPRINTF_NL();
SPRINTF_FLAG(caps.ShadeCaps,D3DPSHADECAPS_ALPHAGOURAUDBLEND);
SPRINTF_FLAG(caps.ShadeCaps,D3DPSHADECAPS_COLORGOURAUDRGB);
SPRINTF_FLAG(caps.ShadeCaps,D3DPSHADECAPS_FOGGOURAUD);
SPRINTF_FLAG(caps.ShadeCaps,D3DPSHADECAPS_SPECULARGOURAUDRGB);
SPRINTF_NL();
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_ALPHA);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_ALPHAPALETTE);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_CUBEMAP);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_CUBEMAP_POW2);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_MIPCUBEMAP);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_MIPMAP);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_MIPVOLUMEMAP);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_NONPOW2CONDITIONAL);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_PERSPECTIVE);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_POW2);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_PROJECTED);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_SQUAREONLY);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_VOLUMEMAP);
SPRINTF_FLAG(caps.TextureCaps, D3DPTEXTURECAPS_VOLUMEMAP_POW2);
SPRINTF_NL();
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MAGFAFLATCUBIC);
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MAGFANISOTROPIC);
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MAGFLINEAR);
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MAGFPOINT);
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MINFANISOTROPIC);
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MINFLINEAR);
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MINFPOINT);
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MIPFLINEAR);
SPRINTF_FLAG(caps.TextureFilterCaps, D3DPTFILTERCAPS_MIPFPOINT);
SPRINTF_NL();
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MAGFAFLATCUBIC);
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MAGFANISOTROPIC);
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MAGFLINEAR);
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MAGFPOINT);
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MINFANISOTROPIC);
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MINFLINEAR);
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MINFPOINT);
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MIPFLINEAR);
SPRINTF_FLAG(caps.CubeTextureFilterCaps, D3DPTFILTERCAPS_MIPFPOINT);
SPRINTF_NL();
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MAGFAFLATCUBIC);
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MAGFANISOTROPIC);
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MAGFLINEAR);
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MAGFPOINT);
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MINFANISOTROPIC);
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MINFLINEAR);
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MINFPOINT);
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MIPFLINEAR);
SPRINTF_FLAG(caps.VolumeTextureFilterCaps, D3DPTFILTERCAPS_MIPFPOINT);
SPRINTF_NL();
SPRINTF_FLAG(caps.TextureAddressCaps, D3DPTADDRESSCAPS_BORDER);
SPRINTF_FLAG(caps.TextureAddressCaps, D3DPTADDRESSCAPS_CLAMP);
SPRINTF_FLAG(caps.TextureAddressCaps, D3DPTADDRESSCAPS_INDEPENDENTUV);
SPRINTF_FLAG(caps.TextureAddressCaps, D3DPTADDRESSCAPS_MIRROR);
SPRINTF_FLAG(caps.TextureAddressCaps, D3DPTADDRESSCAPS_MIRRORONCE);
SPRINTF_FLAG(caps.TextureAddressCaps, D3DPTADDRESSCAPS_WRAP);
SPRINTF_NL();
SPRINTF_FLAG(caps.VolumeTextureAddressCaps, D3DPTADDRESSCAPS_BORDER);
SPRINTF_FLAG(caps.VolumeTextureAddressCaps, D3DPTADDRESSCAPS_CLAMP);
SPRINTF_FLAG(caps.VolumeTextureAddressCaps, D3DPTADDRESSCAPS_INDEPENDENTUV);
SPRINTF_FLAG(caps.VolumeTextureAddressCaps, D3DPTADDRESSCAPS_MIRROR);
SPRINTF_FLAG(caps.VolumeTextureAddressCaps, D3DPTADDRESSCAPS_MIRRORONCE);
SPRINTF_FLAG(caps.VolumeTextureAddressCaps, D3DPTADDRESSCAPS_WRAP);
SPRINTF_NL();
SPRINTF_FLAG(caps.LineCaps, D3DLINECAPS_ALPHACMP);
SPRINTF_FLAG(caps.LineCaps, D3DLINECAPS_BLEND);
SPRINTF_FLAG(caps.LineCaps, D3DLINECAPS_FOG);
SPRINTF_FLAG(caps.LineCaps, D3DLINECAPS_TEXTURE);
SPRINTF_FLAG(caps.LineCaps, D3DLINECAPS_ZTEST);
SPRINTF_NL();
i += sprintf(mass_buffer + i, "Max texture width: %d\n", caps.MaxTextureWidth);
i += sprintf(mass_buffer + i, "Max texture height: %d\n", caps.MaxTextureHeight);
i += sprintf(mass_buffer + i, "Max volume extent: %d\n", caps.MaxVolumeExtent);
SPRINTF_NL();
i += sprintf(mass_buffer + i, "Max texture repeat: %d\n", caps.MaxTextureRepeat);
i += sprintf(mass_buffer + i, "Max texture aspect: %d\n", caps.MaxTextureAspectRatio);
i += sprintf(mass_buffer + i, "Max anisotropy: %d\n", caps.MaxAnisotropy);
i += sprintf(mass_buffer + i, "Max vertex W: %f\n", caps.MaxVertexW);
SPRINTF_NL();
i += sprintf(mass_buffer + i, "Guard band (l,t,r,b): %f %f %f %f\n",
caps.GuardBandLeft,
caps.GuardBandTop,
caps.GuardBandRight,
caps.GuardBandBottom);
SPRINTF_NL();
i += sprintf(mass_buffer + i, "Extents adjust: %d\n", caps.ExtentsAdjust);
SPRINTF_NL();
SPRINTF_FLAG(caps.StencilCaps, D3DSTENCILCAPS_DECR);
SPRINTF_FLAG(caps.StencilCaps, D3DSTENCILCAPS_DECRSAT);
SPRINTF_FLAG(caps.StencilCaps, D3DSTENCILCAPS_INCR);
SPRINTF_FLAG(caps.StencilCaps, D3DSTENCILCAPS_INCRSAT);
SPRINTF_FLAG(caps.StencilCaps, D3DSTENCILCAPS_INVERT);
SPRINTF_FLAG(caps.StencilCaps, D3DSTENCILCAPS_KEEP);
SPRINTF_FLAG(caps.StencilCaps, D3DSTENCILCAPS_REPLACE);
SPRINTF_FLAG(caps.StencilCaps, D3DSTENCILCAPS_ZERO);
SPRINTF_NL();
SPRINTF_FLAG(caps.FVFCaps, D3DFVFCAPS_DONOTSTRIPELEMENTS);
SPRINTF_FLAG(caps.FVFCaps, D3DFVFCAPS_PSIZE);
SPRINTF_FLAG(caps.FVFCaps, D3DFVFCAPS_TEXCOORDCOUNTMASK);
SPRINTF_NL();
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_ADD);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_ADDSIGNED);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_ADDSIGNED2X);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_ADDSMOOTH);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_BLENDCURRENTALPHA);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_BLENDDIFFUSEALPHA);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_BLENDFACTORALPHA);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_BLENDTEXTUREALPHA);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_BLENDTEXTUREALPHAPM);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_BUMPENVMAP);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_BUMPENVMAPLUMINANCE);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_DISABLE);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_DOTPRODUCT3);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_LERP);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_MODULATE);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_MODULATE2X);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_MODULATE4X);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_MULTIPLYADD);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_PREMODULATE);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_SELECTARG1);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_SELECTARG2);
SPRINTF_FLAG(caps.TextureOpCaps, D3DTEXOPCAPS_SUBTRACT);
SPRINTF_NL();
i += sprintf(mass_buffer + i, "Max texture blend stages: %d\n", caps.MaxTextureBlendStages);
i += sprintf(mass_buffer + i, "Max simultaneous textures: %d\n", caps.MaxSimultaneousTextures);
SPRINTF_NL();
SPRINTF_FLAG(caps.VertexProcessingCaps, D3DVTXPCAPS_DIRECTIONALLIGHTS);
SPRINTF_FLAG(caps.VertexProcessingCaps, D3DVTXPCAPS_LOCALVIEWER);
SPRINTF_FLAG(caps.VertexProcessingCaps, D3DVTXPCAPS_MATERIALSOURCE7);
SPRINTF_FLAG(caps.VertexProcessingCaps, D3DVTXPCAPS_POSITIONALLIGHTS);
SPRINTF_FLAG(caps.VertexProcessingCaps, D3DVTXPCAPS_TEXGEN);
SPRINTF_FLAG(caps.VertexProcessingCaps, D3DVTXPCAPS_TWEENING);
SPRINTF_FLAG(caps.VertexProcessingCaps, D3DVTXPCAPS_NO_VSDT_UBYTE4);
SPRINTF_NL();
i += sprintf(mass_buffer + i, "Max active lights: %d\n", caps.MaxActiveLights);
i += sprintf(mass_buffer + i, "Max user clip planes: %d\n", caps.MaxUserClipPlanes);
i += sprintf(mass_buffer + i, "Max vertex blend matrices: %d\n", caps.MaxVertexBlendMatrices);
i += sprintf(mass_buffer + i, "Max vertex blend matrix index: %d\n", caps.MaxVertexBlendMatrixIndex);
SPRINTF_NL();
i += sprintf(mass_buffer + i, "Max point size: %f\n", caps.MaxPointSize);
i += sprintf(mass_buffer + i, "Max Prim count: %d\n", caps.MaxPrimitiveCount);
i += sprintf(mass_buffer + i, "Max Vertrx index: %d\n", caps.MaxVertexIndex);
i += sprintf(mass_buffer + i, "Max Streams: %d\n", caps.MaxStreams);
i += sprintf(mass_buffer + i, "Max Stream stride: %d\n", caps.MaxStreamStride);
SPRINTF_NL();
i += sprintf(mass_buffer + i, "Vertex shader version: %d.%d\n", HIBYTE(caps.VertexShaderVersion), LOBYTE(caps.VertexShaderVersion));
i += sprintf(mass_buffer + i, "Max vertex shader const: %d\n", caps.MaxVertexShaderConst);
SPRINTF_NL();
i += sprintf(mass_buffer + i, "Pixel shader version: %d.%d\n", HIBYTE(caps.PixelShaderVersion), LOBYTE(caps.PixelShaderVersion));
i += sprintf(mass_buffer + i, "Max pixel shader value: %d\n", caps.MaxPixelShaderValue);
SPRINTF_NL();
}
char filename[MAX_PATH] = {"D3D8 CAPS "};
unsigned long len = MAX_PATH - strlen(filename);
GetUserName(filename + strlen(filename), &len);
FILE *fp = browse_for_and_open_save_file(this->GetSafeHwnd(), filename, "txt", "Save D3D8 CAPS textfile");
if(fp == NULL)
{
MessageBox("Cancelled D3D cap file save", "Warning", MB_ICONWARNING);
return;
}
fwrite(mass_buffer, strlen(mass_buffer), 1, fp);
fclose(fp);
#ifdef _DEBUG
char sys_command[MAX_PATH] = "notepad \"";
strcat(sys_command, filename);
strcat(sys_command, "\"");
system(sys_command);
#endif
}
void CDX8Disp::UpdateAntialiasList(int select)
{
m_antialias_list.ResetContent();
if(d3d_interface == NULL)
{
DBUGFILE_OUTPUT_0("d3d_interface == NULL");
return;
}
int selected_adapter = m_adapter_list.GetCurSel();
int selected_mode = m_res_list.GetItemData(m_res_list.GetCurSel());
D3DDISPLAYMODE mode;
if(FAILED(d3d_interface->EnumAdapterModes(selected_adapter, selected_mode, &mode)))
{
MessageBox("Failed EnumAdapterModes in UpdateAntialiasList", "Fatal Error", MB_ICONERROR);
return;
}
{
// do a quick standard res check while we're here...
// identify whether this is one of the standard video modes or not
bool standard_match = ((mode.Width == 1024 && mode.Height == 768) ||
(mode.Width == 640 && mode.Height == 480));
// show or hide the non-standard video mode text if needed
GetDlgItem(IDC_NSVM_TEXT)->ShowWindow( (standard_match) ? SW_HIDE : SW_SHOW );
}
// Now fill the avaliable anti aliasing for this mode
typedef struct {
int type;
char *text;
} MultisampleInfo;
const int MAX_MULTISAMPLE = 16;
const MultisampleInfo multisample_info[MAX_MULTISAMPLE] =
{
D3DMULTISAMPLE_NONE, "D3DMULTISAMPLE_NONE",
D3DMULTISAMPLE_2_SAMPLES,"D3DMULTISAMPLE_2_SAMPLES",
D3DMULTISAMPLE_3_SAMPLES,"D3DMULTISAMPLE_3_SAMPLES",
D3DMULTISAMPLE_4_SAMPLES,"D3DMULTISAMPLE_4_SAMPLES",
D3DMULTISAMPLE_5_SAMPLES,"D3DMULTISAMPLE_5_SAMPLES",
D3DMULTISAMPLE_6_SAMPLES,"D3DMULTISAMPLE_6_SAMPLES",
D3DMULTISAMPLE_7_SAMPLES,"D3DMULTISAMPLE_7_SAMPLES",
D3DMULTISAMPLE_8_SAMPLES,"D3DMULTISAMPLE_8_SAMPLES",
D3DMULTISAMPLE_9_SAMPLES,"D3DMULTISAMPLE_9_SAMPLES",
D3DMULTISAMPLE_10_SAMPLES,"D3DMULTISAMPLE_10_SAMPLES",
D3DMULTISAMPLE_11_SAMPLES,"D3DMULTISAMPLE_11_SAMPLES",
D3DMULTISAMPLE_12_SAMPLES,"D3DMULTISAMPLE_12_SAMPLES",
D3DMULTISAMPLE_13_SAMPLES,"D3DMULTISAMPLE_13_SAMPLES",
D3DMULTISAMPLE_14_SAMPLES,"D3DMULTISAMPLE_14_SAMPLES",
D3DMULTISAMPLE_15_SAMPLES,"D3DMULTISAMPLE_15_SAMPLES",
D3DMULTISAMPLE_16_SAMPLES,"D3DMULTISAMPLE_16_SAMPLES"
};
for(int i = 0; i < MAX_MULTISAMPLE; i++)
{
if( FAILED( d3d_interface->CheckDeviceMultiSampleType(
selected_adapter,
D3DDEVTYPE_HAL ,
mode.Format, FALSE,
(D3DMULTISAMPLE_TYPE) multisample_info[i].type ) ) ) {
break;
}
m_antialias_list.InsertString(i, multisample_info[i].text);
}
if(select > MAX_MULTISAMPLE)
select = 0;
m_antialias_list.SetCurSel(select);
}
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
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) // 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 (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
}
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?
{
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
}
int WINAPI WinMain( HINSTANCE hInstance, // Instance
HINSTANCE hPrevInstance, // Previous Instance
LPSTR lpCmdLine, // Command Line Parameters
int nCmdShow) // Window Show State
{
MSG msg; // Windows Message Structure
BOOL done=FALSE; // Bool Variable To Exit Loop
// Ask The User Which Screen Mode They Prefer
if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
{
fullscreen=FALSE; // Windowed Mode
}
// Create Our OpenGL Window
if (!CreateGLWindow("NeHe's Outline Font Tutorial",640,480,16,fullscreen))
{
return 0; // Quit If Window Was Not Created
}
while(!done) // Loop That Runs While done=FALSE
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?
{
if (msg.message==WM_QUIT) // Have We Received A Quit Message?
{
done=TRUE; // If So done=TRUE
}
else // If Not, Deal With Window Messages
{
TranslateMessage(&msg); // Translate The Message
DispatchMessage(&msg); // Dispatch The Message
}
}
else // If There Are No Messages
{
// Draw The Scene. Watch For ESC Key And Quit Messages From DrawGLScene()
if ((active && !DrawGLScene()) || keys[VK_ESCAPE]) // Active? Was There A Quit Received?
{
done=TRUE; // ESC or DrawGLScene Signalled A Quit
}
else // Not Time To Quit, Update Screen
{
SwapBuffers(hDC); // Swap Buffers (Double Buffering)
}
if (keys[VK_F1]) // Is F1 Being Pressed?
{
keys[VK_F1]=FALSE; // If So Make Key FALSE
KillGLWindow(); // Kill Our Current Window
fullscreen=!fullscreen; // Toggle Fullscreen / Windowed Mode
// Recreate Our OpenGL Window
if (!CreateGLWindow("NeHe's Outline Font Tutorial",640,480,16,fullscreen))
{
return 0; // Quit If Window Was Not Created
}
}
}
}
// Shutdown
KillGLWindow(); // Kill The Window
return (msg.wParam); // Exit The Program
}
////////////////////////////////////////////////////////////////////////////////////////////
// Proc: General options dialog
static INT_PTR CALLBACK gg_genoptsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_INITDIALOG:
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
if (num = DBGetContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, 0))
{
SetDlgItemText(hwndDlg, IDC_UIN, ditoa(num));
ShowWindow(GetDlgItem(hwndDlg, IDC_CREATEACCOUNT), SW_HIDE);
}
else
{
ShowWindow(GetDlgItem(hwndDlg, IDC_CHPASS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_REMOVEACCOUNT), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_LOSTPASS), SW_HIDE);
}
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, &dbv)) {
CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal) + 1, (LPARAM) dbv.pszVal);
SetDlgItemText(hwndDlg, IDC_PASSWORD, dbv.pszVal);
DBFreeVariant(&dbv);
}
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, &dbv)) {
SetDlgItemText(hwndDlg, IDC_EMAIL, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
{
ShowWindow(GetDlgItem(hwndDlg, IDC_LOSTPASS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_CHPASS), SW_HIDE);
}
CheckDlgButton(hwndDlg, IDC_FRIENDSONLY, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_FRIENDSONLY, GG_KEYDEF_FRIENDSONLY));
CheckDlgButton(hwndDlg, IDC_SHOWINVISIBLE, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWINVISIBLE, GG_KEYDEF_SHOWINVISIBLE));
CheckDlgButton(hwndDlg, IDC_LEAVESTATUSMSG, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_LEAVESTATUSMSG, GG_KEYDEF_LEAVESTATUSMSG));
if(gg->gc_enabled)
CheckDlgButton(hwndDlg, IDC_IGNORECONF, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_IGNORECONF, GG_KEYDEF_IGNORECONF));
else
{
EnableWindow(GetDlgItem(hwndDlg, IDC_IGNORECONF), FALSE);
CheckDlgButton(hwndDlg, IDC_IGNORECONF, TRUE);
}
CheckDlgButton(hwndDlg, IDC_IMGRECEIVE, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGRECEIVE, GG_KEYDEF_IMGRECEIVE));
CheckDlgButton(hwndDlg, IDC_SHOWLINKS, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWLINKS, GG_KEYDEF_SHOWLINKS));
CheckDlgButton(hwndDlg, IDC_ENABLEAVATARS, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_ENABLEAVATARS, GG_KEYDEF_ENABLEAVATARS));
EnableWindow(GetDlgItem(hwndDlg, IDC_LEAVESTATUS), IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
EnableWindow(GetDlgItem(hwndDlg, IDC_IMGMETHOD), IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("<Last Status>")); // 0
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Online")); // ID_STATUS_ONLINE
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Away")); // ID_STATUS_AWAY
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("DND")); // ID_STATUS_DND
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Free for chat")); // ID_STATUS_FREECHAT
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Invisible")); // ID_STATUS_INVISIBLE
switch(DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, GG_KEYDEF_LEAVESTATUS))
{
case ID_STATUS_ONLINE:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 1, 0);
break;
case ID_STATUS_AWAY:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 2, 0);
break;
case ID_STATUS_DND:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 3, 0);
break;
case ID_STATUS_FREECHAT:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 4, 0);
break;
case ID_STATUS_INVISIBLE:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 5, 0);
break;
default:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 0, 0);
}
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)Translate("System tray icon"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)Translate("Popup window"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)Translate("Message with [img] BBCode"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_SETCURSEL,
DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGMETHOD, GG_KEYDEF_IMGMETHOD), 0);
break;
}
case WM_COMMAND:
{
if ((LOWORD(wParam) == IDC_UIN || LOWORD(wParam) == IDC_PASSWORD || LOWORD(wParam) == IDC_EMAIL)
&& (HIWORD(wParam) != EN_CHANGE || (HWND) lParam != GetFocus()))
return 0;
switch (LOWORD(wParam)) {
case IDC_EMAIL:
case IDC_UIN:
{
gg_optsdlgcheck(hwndDlg);
break;
}
case IDC_LEAVESTATUSMSG:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_LEAVESTATUS), IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
break;
}
case IDC_IMGRECEIVE:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_IMGMETHOD), IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
break;
}
case IDC_LOSTPASS:
{
char email[128];
uin_t uin;
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
GetDlgItemText(hwndDlg, IDC_UIN, email, sizeof(email));
uin = atoi(email);
GetDlgItemText(hwndDlg, IDC_EMAIL, email, sizeof(email));
if(!strlen(email))
MessageBox(
NULL,
Translate("You need to specify your registration e-mail first."),
GG_PROTONAME,
MB_OK | MB_ICONEXCLAMATION);
else if(MessageBox(
NULL,
Translate("Your password will be sent to your registration e-mail.\nDo you want to continue ?"),
GG_PROTONAME,
MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
gg_remindpassword(gg, uin, email);
return FALSE;
}
case IDC_CREATEACCOUNT:
case IDC_REMOVEACCOUNT:
if(gg_isonline((GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA)))
{
if(MessageBox(
NULL,
Translate("You should disconnect before making any permanent changes with your account.\nDo you want to disconnect now ?"),
((GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA))->proto.m_szModuleName,
MB_OKCANCEL | MB_ICONEXCLAMATION) == IDCANCEL)
break;
else
gg_disconnect((GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA));
}
case IDC_CHPASS:
case IDC_CHEMAIL:
{
// Readup data
GGUSERUTILDLGDATA dat;
int ret;
char pass[128], email[128];
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
GetDlgItemText(hwndDlg, IDC_UIN, pass, sizeof(pass));
dat.uin = atoi(pass);
GetDlgItemText(hwndDlg, IDC_PASSWORD, pass, sizeof(pass));
GetDlgItemText(hwndDlg, IDC_EMAIL, email, sizeof(email));
dat.pass = pass;
dat.email = email;
dat.gg = gg;
if(LOWORD(wParam) == IDC_CREATEACCOUNT)
{
dat.mode = GG_USERUTIL_CREATE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CREATEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else if(LOWORD(wParam) == IDC_CHPASS)
{
dat.mode = GG_USERUTIL_PASS;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CHPASS), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else if(LOWORD(wParam) == IDC_CHEMAIL)
{
dat.mode = GG_USERUTIL_EMAIL;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CHEMAIL), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else
{
dat.mode = GG_USERUTIL_REMOVE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_REMOVEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
if(ret == IDOK)
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
// Show reload required window
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
// Update uin
if (num = DBGetContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, 0))
SetDlgItemText(hwndDlg, IDC_UIN, ditoa(num));
else
SetDlgItemText(hwndDlg, IDC_UIN, "");
// Update password
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, &dbv)) {
CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal) + 1, (LPARAM) dbv.pszVal);
SetDlgItemText(hwndDlg, IDC_PASSWORD, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
SetDlgItemText(hwndDlg, IDC_PASSWORD, "");
// Update e-mail
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, &dbv)) {
SetDlgItemText(hwndDlg, IDC_EMAIL, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
SetDlgItemText(hwndDlg, IDC_EMAIL, "");
// Update links
gg_optsdlgcheck(hwndDlg);
// Remove details
if(LOWORD(wParam) != IDC_CHPASS && LOWORD(wParam) != IDC_CHEMAIL)
{
DBDeleteContactSetting(NULL, GG_PROTO, GG_KEY_NICK);
DBDeleteContactSetting(NULL, GG_PROTO, "NickName");
DBDeleteContactSetting(NULL, GG_PROTO, "City");
DBDeleteContactSetting(NULL, GG_PROTO, "FirstName");
DBDeleteContactSetting(NULL, GG_PROTO, "LastName");
DBDeleteContactSetting(NULL, GG_PROTO, "FamilyName");
DBDeleteContactSetting(NULL, GG_PROTO, "CityOrigin");
DBDeleteContactSetting(NULL, GG_PROTO, "Age");
DBDeleteContactSetting(NULL, GG_PROTO, "BirthYear");
DBDeleteContactSetting(NULL, GG_PROTO, "Gender");
}
}
}
break;
}
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
case WM_NOTIFY:
{
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
{
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
int status_flags = GG_STATUS_FLAG_UNKNOWN;
char str[128];
uin_t uin;
// Write Gadu-Gadu number & password
GetDlgItemText(hwndDlg, IDC_UIN, str, sizeof(str));
uin = atoi(str);
GetDlgItemText(hwndDlg, IDC_PASSWORD, str, sizeof(str));
CallService(MS_DB_CRYPT_ENCODESTRING, sizeof(str), (LPARAM) str);
gg_checknewuser(gg, uin, str);
DBWriteContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, uin);
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, str);
// Write Gadu-Gadu email
GetDlgItemText(hwndDlg, IDC_EMAIL, str, sizeof(str));
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, str);
// Write checkboxes
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_FRIENDSONLY, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_FRIENDSONLY));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWINVISIBLE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWINVISIBLE));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_LEAVESTATUSMSG, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
if (gg->gc_enabled)
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_IGNORECONF, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_IGNORECONF));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGRECEIVE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWLINKS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWLINKS));
if (IsDlgButtonChecked(hwndDlg, IDC_SHOWLINKS))
status_flags |= GG_STATUS_FLAG_SPAM;
EnterCriticalSection(&gg->sess_mutex);
gg_change_status_flags(gg->sess, status_flags);
LeaveCriticalSection(&gg->sess_mutex);
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_ENABLEAVATARS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_ENABLEAVATARS));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGMETHOD,
(BYTE)SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_GETCURSEL, 0, 0));
// Write leave status
switch(SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_GETCURSEL, 0, 0))
{
case 1:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_ONLINE);
break;
case 2:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_AWAY);
break;
case 3:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_DND);
break;
case 4:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_FREECHAT);
break;
case 5:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_INVISIBLE);
break;
default:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, GG_KEYDEF_LEAVESTATUS);
}
break;
}
}
break;
}
}
return FALSE;
}
void CFileView::OnFileRead()
{
/* FILE *pFile=fopen("1.txt","r");
char ch[100];
memset(ch,0,100);
fread(ch,1,100,pFile);
fclose(pFile);
MessageBox(ch);*/
/* char *pBuf;
fseek(pFile,0,SEEK_END);
int len=ftell(pFile);
pBuf=new char[len+1];
rewind(pFile);
fread(pBuf,1,len,pFile);
pBuf[len]=0;
fclose(pFile);
MessageBox(pBuf);
*/
/* FILE *pFile=fopen("2.txt","rb");
char ch[100];
fread(ch,1,3,pFile);
ch[3]=0;
MessageBox(ch);
fclose(pFile);*/
/* ifstream ifs("4.txt");
char ch[100];
memset(ch,0,100);
ifs.read(ch,100);
ifs.close();
MessageBox(ch);*/
/* HANDLE hFile;
hFile=CreateFile("5.txt",GENERIC_READ,0,NULL,OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,NULL);
char ch[100];
DWORD dwReads;
ReadFile(hFile,ch,100,&dwReads,NULL);
ch[dwReads]=0;
CloseHandle(hFile);
MessageBox(ch);*/
/* CFile file("6.txt",CFile::modeRead);
char *pBuf;
DWORD dwFileLen;
dwFileLen=file.GetLength();
pBuf=new char[dwFileLen+1];
pBuf[dwFileLen]=0;
file.Read(pBuf,dwFileLen);
file.Close();
MessageBox(pBuf);*/
CFileDialog fileDlg(TRUE);
fileDlg.m_ofn.lpstrTitle="我的文件打开对话框";
fileDlg.m_ofn.lpstrFilter="Text Files(*.txt)\0*.txt\0All Files(*.*)\0*.*\0\0";
if(IDOK==fileDlg.DoModal())
{
CFile file(fileDlg.GetFileName(),CFile::modeRead);
char *pBuf;
DWORD dwFileLen;
dwFileLen=file.GetLength();
pBuf=new char[dwFileLen+1];
pBuf[dwFileLen]=0;
file.Read(pBuf,dwFileLen);
file.Close();
MessageBox(pBuf);
}
}
////////////////////////////////////////////////////////////////////////////////
// Info Page : Proc
static INT_PTR CALLBACK gg_detailsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
struct GGDETAILSDLGDATA *dat = (struct GGDETAILSDLGDATA *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
switch(msg)
{
case WM_INITDIALOG:
{
TranslateDialogDefault(hwndDlg);
dat = (struct GGDETAILSDLGDATA *)mir_alloc(sizeof(struct GGDETAILSDLGDATA));
dat->hContact=(HANDLE)lParam;
dat->disableUpdate = FALSE;
dat->updating = FALSE;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)dat);
// Add genders
if(!dat->hContact)
{
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_ADDSTRING, 0, (LPARAM)_T("")); // 0
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_ADDSTRING, 0, (LPARAM)Translate("Female")); // 1
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_ADDSTRING, 0, (LPARAM)Translate("Male")); // 2
}
break;
}
case WM_NOTIFY:
switch (((LPNMHDR)lParam)->idFrom)
{
case 0:
switch (((LPNMHDR)lParam)->code)
{
case PSN_PARAMCHANGED:
{
dat->gg = (GGPROTO *)((LPPSHNOTIFY)lParam)->lParam;
break;
}
case PSN_INFOCHANGED:
{
char *szProto;
HANDLE hContact = (HANDLE)((LPPSHNOTIFY)lParam)->lParam;
GGPROTO *gg = dat->gg;
// Show updated message
if(dat && dat->updating)
{
MessageBox(
NULL,
Translate("Your details has been uploaded to the public directory."),
GG_PROTONAME,
MB_OK | MB_ICONINFORMATION
);
dat->updating = FALSE;
break;
}
if (hContact == NULL)
szProto = GG_PROTO;
else
szProto = (char*)CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hContact, 0);
if (szProto == NULL)
break;
// Disable when updating
if(dat) dat->disableUpdate = TRUE;
SetValue(hwndDlg, IDC_UIN, hContact, szProto, GG_KEY_UIN, 0, hContact != NULL);
SetValue(hwndDlg, IDC_REALIP, hContact, szProto, GG_KEY_CLIENTIP, SVS_IP, hContact != NULL);
SetValue(hwndDlg, IDC_PORT, hContact, szProto, GG_KEY_CLIENTPORT, SVS_ZEROISUNSPEC, hContact != NULL);
SetValue(hwndDlg, IDC_VERSION, hContact, szProto, GG_KEY_CLIENTVERSION, SVS_GGVERSION, hContact != NULL);
SetValue(hwndDlg, IDC_FIRSTNAME, hContact, szProto, "FirstName", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_LASTNAME, hContact, szProto, "LastName", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_NICKNAME, hContact, szProto, "NickName", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_BIRTHYEAR, hContact, szProto, "BirthYear", SVS_ZEROISUNSPEC, hContact != NULL);
SetValue(hwndDlg, IDC_CITY, hContact, szProto, "City", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_FAMILYNAME, hContact, szProto, "FamilyName", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_CITYORIGIN, hContact, szProto, "CityOrigin", SVS_NORMAL, hContact != NULL);
if (hContact)
{
SetValue(hwndDlg, IDC_GENDER, hContact, szProto, "Gender", SVS_GENDER, hContact != NULL);
SetValue(hwndDlg, IDC_STATUSDESCR, hContact, "CList", GG_KEY_STATUSDESCR, SVS_NORMAL, hContact != NULL);
}
else switch((char)DBGetContactSettingByte(hContact, GG_PROTO, "Gender", (BYTE)'?'))
{
case 'F':
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_SETCURSEL, 1, 0);
break;
case 'M':
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_SETCURSEL, 2, 0);
break;
default:
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_SETCURSEL, 0, 0);
}
// Disable when updating
if(dat) dat->disableUpdate = FALSE;
break;
}
}
break;
}
break;
case WM_COMMAND:
if (dat && !dat->hContact && LOWORD(wParam) == IDC_SAVE && HIWORD(wParam) == BN_CLICKED)
{
// Save user data
char text[256];
gg_pubdir50_t req;
GGPROTO *gg = dat->gg;
if (!gg_isonline(gg))
{
MessageBox(NULL,
Translate("You have to be logged in before you can change your details."),
GG_PROTONAME, MB_OK | MB_ICONSTOP
);
break;
}
EnableWindow(GetDlgItem(hwndDlg, IDC_SAVE), FALSE);
req = gg_pubdir50_new(GG_PUBDIR50_WRITE);
GetDlgItemText(hwndDlg, IDC_FIRSTNAME, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_FIRSTNAME, text);
GetDlgItemText(hwndDlg, IDC_LASTNAME, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_LASTNAME, text);
GetDlgItemText(hwndDlg, IDC_NICKNAME, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_NICKNAME, text);
GetDlgItemText(hwndDlg, IDC_CITY, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_CITY, text);
// Gadu-Gadu Female <-> Male
switch(SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_GETCURSEL, 0, 0))
{
case 1:
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, GG_PUBDIR50_GENDER_SET_FEMALE);
break;
case 2:
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, GG_PUBDIR50_GENDER_SET_MALE);
break;
default:
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, "");
}
GetDlgItemText(hwndDlg, IDC_BIRTHYEAR, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_BIRTHYEAR, text);
GetDlgItemText(hwndDlg, IDC_FAMILYNAME, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_FAMILYNAME, text);
GetDlgItemText(hwndDlg, IDC_CITYORIGIN, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_FAMILYCITY, text);
// Run update
gg_pubdir50_seq_set(req, GG_SEQ_CHINFO);
EnterCriticalSection(&gg->sess_mutex);
gg_pubdir50(gg->sess, req);
LeaveCriticalSection(&gg->sess_mutex);
dat->updating = TRUE;
gg_pubdir50_free(req);
}
if(dat && !dat->hContact && !dat->disableUpdate && (HIWORD(wParam) == EN_CHANGE && (
LOWORD(wParam) == IDC_NICKNAME || LOWORD(wParam) == IDC_FIRSTNAME || LOWORD(wParam) == IDC_LASTNAME || LOWORD(wParam) == IDC_FAMILYNAME ||
LOWORD(wParam) == IDC_CITY || LOWORD(wParam) == IDC_CITYORIGIN || LOWORD(wParam) == IDC_BIRTHYEAR) ||
HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_GENDER))
EnableWindow(GetDlgItem(hwndDlg, IDC_SAVE), TRUE);
switch(LOWORD(wParam))
{
case IDCANCEL:
SendMessage(GetParent(hwndDlg),msg,wParam,lParam);
break;
}
break;
case WM_DESTROY:
if(dat) mir_free(dat);
break;
}
return FALSE;
}
void __fastcall TForm1::actCalcClassificationExecute(TObject *Sender)
{
if(!MakeBackup()) {
Log->Lines->Add("Не удалось создать резервную копию файла");
return;
}
Variant app = Variant::CreateObject("Excel.Application");
app.OlePropertySet("Visible", true);
Variant excel = app.OlePropertyGet("Workbooks").OleFunction("Open", WideString(m_strFileName.c_str()));
Variant vSheets = excel.OlePropertyGet("Worksheets");
Variant vSheet = vSheets.OlePropertyGet("Item",m_nPageClassification);
UnicodeString strPageName = vSheet.OlePropertyGet("Name");
if (strPageName.UpperCase() != UnicodeString("классификации").UpperCase()) {
app.OleProcedure("Quit");
MessageBox (Handle, UnicodeString(L"Не верное имя страницы").c_str(), L"prompt", MB_OK);
return;
};
std::vector<exlClass> classes;
ReadClassifications(vSheet, classes);
std::vector<exlMonth> months;
Variant vSheetMonth;
double fSumSum = 0;
for (unsigned int i = 0; i < m_vMonth.size(); i++) {
if (cmbMonth->Text == m_vMonth[i].Name) {
int nMonthPage = m_vMonth[i].Number;
vSheetMonth = vSheets.OlePropertyGet("Item", nMonthPage);
ReadMonth(vSheetMonth, months);
ReadMonthSum(vSheetMonth, fSumSum);
}
}
Log->Lines->Add("Произвожу расчет...");
ProgressBar1->Max = months.size();
ProgressBar1->Min = 0;
double nSumHand = 0;
std::vector<exlSumClass> vSumClasses;
for (unsigned int i = 0; i < months.size(); i++) {
ProgressBar1->Position = i;
int nFound = 0;
nSumHand += months[i].Price;
for (unsigned int iC = 0; iC < classes.size(); iC++) {
if (nFound == 0 && classes[iC].Name.UpperCase() == months[i].Name.UpperCase()) {
months[i].Class = classes[iC].Class;
months[i].LinkToClassification = createHyperLinkToClassification(classes, iC);
nFound++;
}
}
if (nFound == 0) {
months[i].Class = m_sUnknownClass;
}
nFound = 0;
for (unsigned int iC = 0; iC < vSumClasses.size(); iC++) {
if (vSumClasses[iC].Name.UpperCase() == months[i].Class.UpperCase()) {
vSumClasses[iC].Sum += months[i].Price;
nFound++;
}
}
if (nFound == 0) {
exlSumClass sm;
sm.Name = months[i].Class;
sm.Sum = months[i].Price;
vSumClasses.push_back(sm);
}
}
/*for (unsigned int i = 0; i < vSumClasses.size(); i++) {
Log->Lines->Add(vSumClasses[i].Name + " = " + FloatToStr(vSumClasses[i].Sum));
}*/
Log->Lines->Add("Готово.");
Log->Lines->Add("Сортирую классификации...");
ProgressBar1->Max = 100;
ProgressBar1->Min = 0;
{
int nPermutation = 1;
while (nPermutation > 0) {
nPermutation = 0;
for (unsigned int iC = 0; iC < vSumClasses.size()-1; iC++) {
ProgressBar1->Position = (ProgressBar1->Position+1) % ProgressBar1->Max;
Application->ProcessMessages();
if (vSumClasses[iC].Name.UpperCase() > vSumClasses[iC+1].Name.UpperCase()) {
exlSumClass buf = vSumClasses[iC];
vSumClasses[iC] = vSumClasses[iC+1];
vSumClasses[iC+1] = buf;
nPermutation++;
}
}
}
ProgressBar1->Position = 0;
}
Log->Lines->Add("Готово.");
Log->Lines->Add("Очистка старых данных");
ProgressBar1->Max = 100;
ProgressBar1->Min = 0;
// clear sum classes, 11,12
{
bool b = true;
int nRow = 1;
while (b) {
b = false;
nRow++;
ProgressBar1->Position = (ProgressBar1->Position+1) % ProgressBar1->Max;
Application->ProcessMessages();
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,11).OleProcedure("ClearFormats");
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OleProcedure("ClearFormats");
UnicodeString sValue11 = vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,11).OlePropertyGet("Value");
UnicodeString sValue12 = vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OlePropertyGet("Value");
clearCell(vSheetMonth, nRow, 11);
clearCell(vSheetMonth, nRow, 12);
if (sValue12.Trim().Length() > 0 || sValue11.Trim().Length() > 0) {
b = true;
}
}
ProgressBar1->Position = 0;
}
// clear 14,15,16,17
{
bool b = true;
int nRow = 1;
while (b) {
b = false;
nRow++;
ProgressBar1->Position = (ProgressBar1->Position+1) % ProgressBar1->Max;
Application->ProcessMessages();
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,14).OleProcedure("ClearFormats");
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,15).OleProcedure("ClearFormats");
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,16).OleProcedure("ClearFormats");
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,17).OleProcedure("ClearFormats");
UnicodeString sValue14 = vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,14).OlePropertyGet("Value");
UnicodeString sValue15 = vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,15).OlePropertyGet("Value");
UnicodeString sValue16 = vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,16).OlePropertyGet("Value");
UnicodeString sValue17 = vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,17).OlePropertyGet("Value");
clearCell(vSheetMonth, nRow, 14);
clearCell(vSheetMonth, nRow, 15);
clearCell(vSheetMonth, nRow, 16);
clearCell(vSheetMonth, nRow, 17);
if (
sValue14.Trim().Length() > 0
|| sValue15.Trim().Length() > 0
|| sValue16.Trim().Length() > 0
|| sValue17.Trim().Length() > 0
) {
b = true;
}
}
ProgressBar1->Position = 0;
}
Log->Lines->Add("Запись новых данных");
{
double nSum = 0;
int nRow = 2;
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,11).OlePropertySet("Value", WideString("Класс"));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OlePropertySet("Value", WideString("Сумма"));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,11).OlePropertyGet("Font").OlePropertySet("Bold", true);
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OlePropertyGet("Font").OlePropertySet("Bold", true);
vSheetMonth.OlePropertyGet("Columns", WideString("K")).OlePropertySet("ColumnWidth", 20);
vSheetMonth.OlePropertyGet("Columns", WideString("L")).OlePropertySet("ColumnWidth", 15);
setBorders(vSheetMonth, nRow, 11);
setBorders(vSheetMonth, nRow, 12);
setColor(vSheetMonth, nRow, 11, RGBToInt(240, 230, 140));
setColor(vSheetMonth, nRow, 12, RGBToInt(240, 230, 140));
ProgressBar1->Max = vSumClasses.size();
ProgressBar1->Min = 0;
for (unsigned int i = 0; i < vSumClasses.size(); i++) {
nRow++;
ProgressBar1->Position = i;
nSum += vSumClasses[i].Sum;
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,11).OlePropertySet("Value", WideString(vSumClasses[i].Name));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OlePropertySet("Value", WideString(vSumClasses[i].Sum));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OlePropertySet("NumberFormat", WideString(m_strNumberFormat));
setBorders(vSheetMonth, nRow, 11);
setBorders(vSheetMonth, nRow, 12);
}
nRow++;
ProgressBar1->Position = 0;
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,11).OlePropertySet("Value", WideString("Итого:"));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OlePropertySet("Value", WideString(nSum));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OlePropertySet("NumberFormat", WideString(m_strNumberFormat));
nRow++;
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,11).OlePropertySet("Value", WideString("Сумма сумм по дням:"));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OlePropertySet("Value", WideString(fSumSum));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,12).OlePropertySet("NumberFormat", WideString(m_strNumberFormat));
}
{
double nSum = 0;
int nRow = 2;
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,14).OlePropertySet("Value", WideString("Класс"));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,15).OlePropertySet("Value", WideString("Наименование"));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,16).OlePropertySet("Value", WideString("Цена"));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,17).OlePropertySet("Value", WideString("Ссылка"));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,14).OlePropertyGet("Font").OlePropertySet("Bold", true);
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,15).OlePropertyGet("Font").OlePropertySet("Bold", true);
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,16).OlePropertyGet("Font").OlePropertySet("Bold", true);
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,17).OlePropertyGet("Font").OlePropertySet("Bold", true);
vSheetMonth.OlePropertyGet("Columns", WideString("N")).OlePropertySet("ColumnWidth", 20);
vSheetMonth.OlePropertyGet("Columns", WideString("O")).OlePropertySet("ColumnWidth", 50);
vSheetMonth.OlePropertyGet("Columns", WideString("P")).OlePropertySet("ColumnWidth", 15);
vSheetMonth.OlePropertyGet("Columns", WideString("Q")).OlePropertySet("ColumnWidth", 50);
setBorders(vSheetMonth, nRow, 14);
setBorders(vSheetMonth, nRow, 15);
setBorders(vSheetMonth, nRow, 16);
setBorders(vSheetMonth, nRow, 17);
setColor(vSheetMonth, nRow, 14, RGBToInt(240, 230, 140));
setColor(vSheetMonth, nRow, 15, RGBToInt(240, 230, 140));
setColor(vSheetMonth, nRow, 16, RGBToInt(240, 230, 140));
setColor(vSheetMonth, nRow, 17, RGBToInt(240, 230, 140));
ProgressBar1->Max = months.size();
ProgressBar1->Min = 0;
for (unsigned int i = 0; i < months.size(); i++) {
nRow++;
ProgressBar1->Position = i;
nSum += months[i].Price;
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,14).OlePropertySet("Value", WideString(months[i].Class));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,15).OlePropertySet("Value", WideString(months[i].Name));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,16).OlePropertySet("Value", WideString(months[i].Price));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,16).OlePropertySet("NumberFormat", WideString(m_strNumberFormat));
if (months[i].Price < 0) {
setColor(vSheetMonth, nRow, 16, RGBToInt(240, 230, 140));
}
// TODO: check linkt to classification
// vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,17).OlePropertySet("Value", WideString(months[i].LinkToClassification.c_str()));
setBorders(vSheetMonth, nRow, 14);
setBorders(vSheetMonth, nRow, 15);
setBorders(vSheetMonth, nRow, 16);
setBorders(vSheetMonth, nRow, 17);
}
nRow++;
ProgressBar1->Position = 0;
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,14).OlePropertySet("Value", WideString("Итого:"));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,16).OlePropertySet("Value", WideString(nSum));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,16).OlePropertySet("NumberFormat", WideString(m_strNumberFormat));
vSheetMonth.OlePropertyGet("Cells").OlePropertyGet("Item",nRow,17).OlePropertySet("NumberFormat", WideString(m_strNumberFormat));
}
Log->Lines->Add("Сохраняю файл...");
try {
app.OlePropertySet("DisplayAlerts",false);
excel.OleProcedure("SaveAs", WideString(m_strFileName.c_str()));
Log->Lines->Add("Данные сохранены!");
} catch (...) {
Log->Lines->Add("Ошибка: Пожалуйста закройте все открытые копии файла и повторите операцию");
}
ProgressBar1->Position = 0;
app.OleProcedure("Quit");
}
BOOL CTroubleShootDlg::ChangeNetDeviceIP(CString strIP){
BOOL ret=FALSE;
CString strlog;
int nRet = 0;
short nmsgType=UPD_BROADCAST_QRY_MSG;
const DWORD END_FLAG = 0x00000000;
TIMEVAL time;
time.tv_sec =3;
time.tv_usec = 1000;
fd_set fdSocket;
BYTE buffer[512] = {0};
BYTE pSendBuf[1024];
ZeroMemory(pSendBuf, 255);
pSendBuf[0] = 0x66;
memcpy(pSendBuf + 1, (BYTE*)&END_FLAG, 4);
int nSendLen = 17;
int time_out=0;
USES_CONVERSION;
CString stroldipaddress,strnewipadress,strlocalipaddress,strnewsubnet,strnewgateway;
stroldipaddress=strIP;
SOCKET sListen=NULL;
// for (int i=0;i<allsubnets.size();i++)
// {
m_edit_newip.GetWindowTextW(strnewipadress);
for (int i = 0;i<g_Vector_Subnet.size ();i++)
{
if (CheckTheSameSubnet(g_Vector_Subnet.at(i).StrIP,strnewipadress))
{
strnewgateway = g_Vector_Subnet.at(i).StrGetway;
strnewsubnet = g_Vector_Subnet.at(i).StrMask;
break;
}
}
//GetNewIP(strnewipadress,allsubnets[i].StrIP);
if (strnewipadress.Find(_T("0.0.0"))!=-1)//对0.0.0.0的过滤掉
{
return FALSE;
}
#pragma region new_socket
SOCKET h_scan_Broad=NULL;
SOCKADDR_IN h_scan_bcast;
SOCKADDR_IN h_scan_siBind;
h_scan_Broad=::socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
BOOL bBroadcast=TRUE;
::setsockopt(h_scan_Broad,SOL_SOCKET,SO_BROADCAST,(char*)&bBroadcast,sizeof(BOOL));
int iMode=1;
ioctlsocket(h_scan_Broad,FIONBIO, (u_long FAR*) &iMode);
BOOL bDontLinger = FALSE;
setsockopt( h_scan_Broad, SOL_SOCKET, SO_DONTLINGER, ( const char* )&bDontLinger, sizeof( BOOL ) );
//SOCKADDR_IN bcast;
h_scan_bcast.sin_family=AF_INET;
//bcast.sin_addr.s_addr=nBroadCastIP;
h_scan_bcast.sin_addr.s_addr=INADDR_BROADCAST;
h_scan_bcast.sin_port=htons(UDP_BROADCAST_PORT);
h_scan_siBind.sin_family=AF_INET;
h_scan_siBind.sin_addr.s_addr = INADDR_ANY;
#pragma endregion new_socket
local_enthernet_ip=m_net_product_node.NetworkCard_Address;
WideCharToMultiByte( CP_ACP, 0, local_enthernet_ip.GetBuffer(), -1, local_network_ip, 255, NULL, NULL );
h_siBind.sin_family=AF_INET;
h_siBind.sin_addr.s_addr = inet_addr(local_network_ip);
if( -1 == bind(h_scan_Broad,(SOCKADDR*)&h_siBind,sizeof(h_siBind)))//把网卡地址强行绑定到Socket
{
//MessageBox(_T("Network Initial Fail"));
ret= FALSE;
}
LPCSTR szIP = W2A(stroldipaddress);
DWORD dwIP = inet_addr(szIP);
IN_ADDR ia;
ia.S_un.S_addr = dwIP;
//////////////////Old IP////////////////////////////////////
pSendBuf[1]=ia.S_un.S_un_b.s_b1;
pSendBuf[2]=ia.S_un.S_un_b.s_b2;
pSendBuf[3]=ia.S_un.S_un_b.s_b3;
pSendBuf[4]=ia.S_un.S_un_b.s_b4;
///////////////////New IP///////////////////////////////////////////
szIP = W2A(strnewipadress);
dwIP = inet_addr(szIP);
ia.S_un.S_addr = dwIP;
///////////////////////////////////////////////////////////
pSendBuf[5]=ia.S_un.S_un_b.s_b1;
pSendBuf[6]=ia.S_un.S_un_b.s_b2;
pSendBuf[7]=ia.S_un.S_un_b.s_b3;
pSendBuf[8]=ia.S_un.S_un_b.s_b4;
////////////////////////////////////////////////////////////////////
szIP = W2A(strnewsubnet);
dwIP = inet_addr(szIP);
ia.S_un.S_addr = dwIP;
pSendBuf[9]=ia.S_un.S_un_b.s_b1;
pSendBuf[10]=ia.S_un.S_un_b.s_b2;
pSendBuf[11]=ia.S_un.S_un_b.s_b3;
pSendBuf[12]=ia.S_un.S_un_b.s_b4;
////////////////////////////////////////////////////////////////////
szIP = W2A(strnewgateway);
dwIP = inet_addr(szIP);
ia.S_un.S_addr = dwIP;
pSendBuf[13]=ia.S_un.S_un_b.s_b1;
pSendBuf[14]=ia.S_un.S_un_b.s_b2;
pSendBuf[15]=ia.S_un.S_un_b.s_b3;
pSendBuf[16]=ia.S_un.S_un_b.s_b4;
FD_ZERO(&fdSocket);
FD_SET(h_scan_Broad, &fdSocket);
// fd_set fdSocket;
// FD_ZERO(&fdSocket);
// FD_SET(h_scan_Broad, &fdSocket);
nRet = ::sendto(h_scan_Broad,(char*)pSendBuf,nSendLen,0,(sockaddr*)&h_bcast,sizeof(h_bcast));
if (nRet == SOCKET_ERROR)
{
int nError = WSAGetLastError();
ret= FALSE ;
goto END_CHANGEIP_SCAN;
}
int nLen = sizeof(h_siBind);
//while(pScanner->IsComScanRunning())
// Sleep(3000);
fd_set fdRead = fdSocket;
int nSelRet = ::select(0, &fdRead, NULL, NULL, &time);
if (nSelRet == SOCKET_ERROR)
{
int nError = WSAGetLastError();
ret= FALSE ;
goto END_CHANGEIP_SCAN;
}
if(nSelRet > 0)
{
ZeroMemory(buffer, 512);
//Sleep(3000);
do
{
int nRet = ::recvfrom(h_scan_Broad,(char*)buffer, 512, 0, (sockaddr*)&h_siBind, &nLen);
// int nRet = ::recvfrom(hBroad,(char*)&buffer[0], nsize, 0, (sockaddr*)&addrRemote, &nLen);
BYTE szIPAddr[4] = {0};
if(nRet > 0)
{
FD_ZERO(&fdSocket);
if(buffer[0]==0x67)//收到正确的回复了
{
SaveNewIPAddress(strnewipadress,stroldipaddress);
ret=TRUE;
MessageBox(_T("Successfull"));
CString strSql;
CppSQLite3DB SqliteDBBuilding;
CppSQLite3Table table;
CppSQLite3Query q;
SqliteDBBuilding.open((UTF8MBSTR)g_strCurBuildingDatabasefilePath);
CString temp_serial_cs;
temp_serial_cs.Format(_T("%u"),g_selected_serialnumber);
strSql.Format(_T("select * from ALL_NODE where Serial_ID = '%s' "),temp_serial_cs);
//m_pRs->Open((_variant_t)strSql,_variant_t((IDispatch *)m_pCon,true),adOpenStatic,adLockOptimistic,adCmdText);
q = SqliteDBBuilding.execQuery((UTF8MBSTR)strSql);
while(!q.eof())
{
strSql.Format(_T("update ALL_NODE set Bautrate='%s' where Serial_ID= '%s'"),strnewipadress,temp_serial_cs);
SqliteDBBuilding.execDML((UTF8MBSTR)strSql);
q.nextRow();
}
CMainFrame* pFrame=(CMainFrame*)(AfxGetApp()->m_pMainWnd);
::PostMessage(pFrame->m_hWnd, WM_MYMSG_REFRESHBUILDING,0,0);
//Sleep(8000);
// SetCommunicationType(1);
// if (!Open_Socket2(strnewipadress,_wtoi(m_net_product_node.BuildingInfo.strIpPort)))
// {
// stroldipaddress=strnewipadress;
// MessageBox(_T("Fail!"));
// ret= FALSE;
// }
// else
// {
// close_com();
// }
//m_flexGrid.put_TextMatrix(row_flags,NEW_IPADRESS,strnewipadress);
//AfxMessageBox(_T("Change the ip successfully!"));
//ret=TRUE;
//return TRUE;
break;
}
SHOW_TX_RX_TS
FD_ZERO(&fdSocket);
FD_SET(h_scan_Broad, &fdSocket);
nLen = sizeof(h_scan_siBind);
fdRead = fdSocket;
nSelRet = ::select(0, &fdRead, NULL, NULL, &time);
}
} while (nSelRet>0);
}
else
{
MessageBox(_T("Fail!"));
ret=FALSE;
}
END_CHANGEIP_SCAN:
closesocket(h_scan_Broad);
h_scan_Broad=NULL;
//{
// //SOCKET soAck =::socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
// h_scan_Broad=::socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
// BOOL bBroadcast=TRUE;
// ::setsockopt(h_scan_Broad,SOL_SOCKET,SO_BROADCAST,(char*)&bBroadcast,sizeof(BOOL));
// int iMode=1;
// ioctlsocket(h_scan_Broad,FIONBIO, (u_long FAR*) &iMode);
// BOOL bDontLinger = FALSE;
// setsockopt( h_scan_Broad, SOL_SOCKET, SO_DONTLINGER, ( const char* )&bDontLinger, sizeof( BOOL ) );
// //SOCKADDR_IN bcast;
// h_bcast.sin_family=AF_INET;
// //bcast.sin_addr.s_addr=nBroadCastIP;
// h_bcast.sin_addr.s_addr=INADDR_BROADCAST;
// h_bcast.sin_port=htons(UDP_BROADCAST_PORT);
// //SOCKADDR_IN siBind;
// h_siBind.sin_family=AF_INET;
// h_siBind.sin_addr.s_addr=INADDR_ANY;
// h_siBind.sin_port=htons(RECV_RESPONSE_PORT);
// ::bind(h_scan_Broad, (sockaddr*)&h_siBind,sizeof(h_siBind));
//}
return ret;
}
bool FileReceiver::operator()()
{
DWORD nrParts = 0;
LARGE_INTEGER liSize;
//we first receive the size of the file and calculate its parts
m_dataTransferer.ReceiveDataShort(&liSize.QuadPart, sizeof(LONGLONG));
nrParts = (DWORD)liSize.QuadPart / BLOCKSIZE;
if (liSize.QuadPart % BLOCKSIZE) nrParts++;
//only if we've been notified that this should be a repair:
if (m_bModeRepair)
{
bool bExists = false;
//we need to check whether this file is ok or not:
if (PathFileExistsW(m_fileName.data())) bExists = true;
if (false == m_dataTransferer.SendDataShort(&bExists, sizeof(bool))) return false;
//if the file is ok, we skip it:
if (bExists)
{
m_transferProgress.EndFile(true, nrParts);
}
}
if (FALSE == m_file.Create(m_fileName.data(), liSize))
{
return false;
}
//we get all but the last piece:
m_transferProgress.BeginFile(m_fileName, nrParts);
//transfering the file
for (DWORD i = 1; i < nrParts; i++)
{
if (bOrderEnd) return false;
//RECEIVING DATA
if (false == m_dataTransferer.ReceiveData(m_file.m_pCurrentPos, BLOCKSIZE)) return false;
//write the data into the file
if (false == m_file.WriteBlock(BLOCKSIZE))
{
return false;
}
m_transferProgress.IncreaseProgress(1);
m_transferProgress.UpdateFileTransferring();
}
//now, receive the last piece. we do not know how large it is, so we have to read its size first.
//RECEIVING THE SIZE OF THE LAST PIECE
DWORD len;
if (false == m_dataTransferer.ReceiveDataShort(&len, sizeof(DWORD))) return false;
if (len > BLOCKSIZE)
{
MessageBox(theApp->GetMainWindow(), L"len > 10240!", L"ERROR!", 0);
#ifdef _DEBUG
DebugBreak();
#endif
return false;
}
//NOW WE RECEIVE THE LAST PIECE
if (false == m_dataTransferer.ReceiveData(m_file.m_pCurrentPos, len)) return false;
//we write the last piece to the file
if (false == m_file.WriteBlock(len)) return false;
m_file.Close();
m_transferProgress.EndFile(false);
return true;
}
LONG APIENTRY MyFunction (HWND hwnd, LPLONG lpIValue, LPSTR lpszValue)
{
return MessageBox(hwnd,lpszValue,"DEBUG", MB_OK);
}
BOOL CSampleApp::InitInstance()
{
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.
// initialized OLE 2.0 libraries
if (!AfxOleInit())
{
AfxMessageBox(IDS_OLE_INIT_FAILED);
return FALSE;
}
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
// Change the registry key under which our settings are stored.
// You should modify this string to be something appropriate
// such as the name of your company or organization.
SetRegistryKey(_T("RenderSoft TextCalc"));
LoadStdProfileSettings(10); // Load standard INI file options (including MRU)
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
CMultiDocTemplate* pDocTemplate;
pDocTemplate = new CMultiDocTemplate(
IDR_SAMPLETYPE,
RUNTIME_CLASS(CSampleDoc),
RUNTIME_CLASS(CChildFrame), // custom MDI child frame
RUNTIME_CLASS(CSampleView));
AddDocTemplate(pDocTemplate);
// create main MDI Frame window
CMainFrame* pMainFrame = new CMainFrame;
if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
return FALSE;
m_pMainWnd = pMainFrame;
// Enable drag/drop open
m_pMainWnd->DragAcceptFiles();
// Enable DDE Execute open
// EnableShellOpen();
// RegisterShellFileTypes(TRUE);
// Parse command line for standard shell commands, DDE, file open
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
/*
//if (cmdInfo!=NULL)
if (cmdInfo.m_strFileName!=NULL)
if (cmdInfo.m_strFileName!="")
*/
if (cmdInfo.m_nShellCommand==CCommandLineInfo::FileOpen)
m_nCmdShow=SW_SHOWMAXIMIZED;
// Dispatch commands specified on the command line
if (!ProcessShellCommand(cmdInfo))
return FALSE;
// The main window has been initialized, so show and update it.
pMainFrame->ShowWindow(m_nCmdShow);
//pMainFrame->ShowWindow(SW_SHOWMAXIMIZED);
pMainFrame->UpdateWindow();
if (IsFirstLoad()) {
int rt=MessageBox(NULL,"This is the first time you are running TextCalc.\n\nDo you want to load the help file?", "Invoke Help?", MB_YESNO | MB_ICONQUESTION);
CString px=GetProgPath();
CString filex=px+"\\"+"progdata.nfo";
FILE *fp;
fp=fopen(filex,"w");
if (fp!=NULL) {
fprintf(fp,"<Not first load> = true");
if (fp!=NULL) fclose(fp);
}
if (rt==IDNO) return TRUE;
POSITION x=GetFirstDocTemplatePosition( );
if (x==NULL) return TRUE;
CDocTemplate* tp=GetNextDocTemplate(x);
CSampleDoc* doc=NULL;
if (tp!=NULL) {
POSITION z=tp->GetFirstDocPosition( );
if (z!=NULL)
doc=(CSampleDoc* ) tp->GetNextDoc(z);
}
CSampleView * dview=NULL;
if (doc!=NULL) {
POSITION y=doc->GetFirstViewPosition();
if (y!=NULL)
dview=(CSampleView *) doc->GetNextView(y);
if (dview!=NULL) {
dview->insertFile("Help.txt",101);
pMainFrame->ShowWindow(SW_SHOWMAXIMIZED);
//pMainFrame->UpdateWindow();
}
}
}
return TRUE;
}
void CGUIFaceInVideoView::OnDraw(CDC* pDC)
{
CGUIFaceInVideoDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
if (pDoc == NULL)
return;
CIplImage *pImgIn;
CvPoint *pPointL, *pPointR;
int nNameTag, nBestMatch;
char strMessage[200];
CPerceptualVisionSystem *pPVS = pDoc->getPVS();
bool bRes = pPVS->initializeNextFrame();
if (bRes == false)
return; // if want to show it but not process it, change it.
sprintf(strMessage, "%i msec", pPVS->m_tBetweenFrames);
OnDraw_LogWindow(pDC, strMessage, set_window(0,0), 0);
pDoc->m_gui.check_start = pDoc->m_gui.check_start;
if (pDoc->m_gui.check_start == true)
{
int z;
for (z=0; z < pPVS->m_pianoPlaying.m_nNumHands; z++)
pPVS->m_pianoPlaying.m_Hand[z].destroy();
pPVS->m_pianoPlaying.m_nNumHands = 0;
}
////////////AVI RECORDING//////////////////
if (pDoc->m_recordCheck == true) // For saving video file made of video frames
{
pPVS->m_imgIn.draw(pDC->m_hDC, set_window(0,3), false, false);
OnDraw_LogWindow(pDC, "Start recording..", set_window(0,3), 1);
pPVS->m_bRecording = true;
if (pPVS->m_bRecordingStarted == false)
{
// open a dialog box.
TCHAR szFilter[] = _T ( "Movie Files (*.avi)" );
CFileDialog *dlg = new CFileDialog( FALSE, _T("avi"), _T("*.avi"), OFN_ENABLESIZING | OFN_OVERWRITEPROMPT, szFilter, (CWnd*)this);
char strAviFullName[200], strAviLocalName[200];
if(dlg->DoModal() == IDOK)
strcpy(strAviFullName, dlg->GetPathName());
pPVS->m_pCvVideoWriter = NULL;
pPVS->m_pCvVideoWriter = cvCreateVideoWriter(strAviFullName,
// Uncompressed
CV_FOURCC('D','I','B',' '), 10.0, cvSize(160,120) );
pPVS->m_bRecordingStarted = true;// Open AVI file
}
//Add frame to AVI
if (pPVS->m_pCvVideoWriter)
cvWriteFrame( pPVS->m_pCvVideoWriter, pPVS->m_imgIn.getIplImage() );
return;
}
else
{
pPVS->m_bRecording = false;
if (pPVS->m_bRecordingStarted == true)
{
pPVS->m_bRecordingStarted = false; // Close AVI
if (pPVS->m_pCvVideoWriter)
cvReleaseVideoWriter( &pPVS->m_pCvVideoWriter );
}
}
////////////////END AVI RECORDING////////////////
///////////////////////
// return; //////// debuging.....
///////////////////////
/***************************************************************************************/
/*** Grab data from MIDI **************************************************/
/***************************************************************************************/
int q, keyValue, octave;
bool keyChange[200]; // bKeyChanged[nTotalPianoKeys] //To indicate Changes only
//For printing Purposes
if (m_bMidiCheck==false)
{
m_Midi->clearAllEvents();
}
//DO MIDI INFORMATION
if (USING_MIDI == 1 && m_bMidiCheck==true)
{
//Get MIDI Events
m_Midi->getAllEvents();
//Update User Selected Offsets
pPVS->m_pianoPlaying.m_Piano.UpdateOctave(m_nKeyOffset, m_nOctave);
//No Changes to Start
for (q=0; q < 200; q++)
keyChange[q] = false;
//Go Through All MIDI events
for (q=0; q < m_Midi->numNotes; q++)
{
//If Key Has Been Pressed, set it as True
if (keyDown[int(m_Midi->noteArray[q])] == true)
{
keyDown[int(m_Midi->noteArray[q])] = false;
keyChange[int(m_Midi->noteArray[q])] = true; //Indicate Change
}
//Vice Versa
else
{
keyDown[int(m_Midi->noteArray[q])] = true;
keyChange[int(m_Midi->noteArray[q])] = true; //Indicate Change
}
}
}//END MIDI
/***************************************************************************************/
/*** Grab data from video camera / AVI **************************************************/
/***************************************************************************************/
sprintf(strMessage, "%i: %i (%i) msec ", pPVS->m_nFrame, pPVS->m_tBetweenFrames, pPVS->m_tBetweenFramesNow);
// OnDraw_LogWindow(pDC, strMessage, set_window(0,2), 1);
//Motion Channel Calculations
pPVS->m_chanMotion.updateImages(&pPVS->m_imgIn);
pPVS->m_chanMotion.compute_dI();
pPVS->m_chanMotion.compute_FG(3, 0);
//////////////////////////PIANO PLAYING SECTION////////////////////////////
//Update Images
pPVS->m_pianoPlaying.updateImages(&pPVS->m_imgIn);
//Do Backgorund Initialization && Piano Key (width) Calibration
if (runOnce == 0)
{
pPVS->m_pianoPlaying.setBackgroundImage(&pPVS->m_imgIn);
runOnce++;
}
//Image Adjustment, based on Piano Orientation and Positioning
pPVS->m_pianoPlaying.AdjustImages();
//Update Control Values from GUI
UpdateControlValues(&(pPVS->m_pianoPlaying));
//Main Piano Playing Function
pPVS->m_pianoPlaying.createHandsImage();
m_bDetectHands = false; //Reset Hand Detecting Flag
/*
// no Filter2D
CIplImage img1; // , img2;
img1.initializeAs(&pPVS->m_imgBW);
// img2.initializeAs(&pPVS->m_imgBW);
IplImage *ipl;
ipl = cvCreateImage( cvGetSize(pPVS->m_imgBW.getIplImage()), IPL_DEPTH_16S , 1 );
cvAnd(pPVS->m_imgBW.getIplImage(), pPVS->m_pianoPlaying.m_imb_handsImage.getIplImage(), img1.getIplImage());
cvSobel(img1.getIplImage(), ipl, 1,0,3);
cvConvert (&ipl, img1.getIplImage());
img1.draw(pDC->m_hDC, set_window(0,3));
img1.destroy();
cvReleaseImage(&ipl);
// img2.destroy();
*/
#if 1 //<< Clustering
CIplImage imc, imcClusters;
imc.initializeAs(&pPVS->m_imgIn);
imcClusters.initializeAs(&pPVS->m_imgBW);
cvZero( imc.getIplImage() );
pImgIn = & pPVS->m_pianoPlaying.m_imb_handsImage; // m_chanColour.m_imbSkinYCrCb; // ;
CIplImage *pImgOut = & imcClusters;
cvZero( pImgOut->getIplImage());
// pImgIn->draw(pDC->m_hDC, set_window(0,3));
int nClustersDetected, nMaxClusters;
// a)
PVI_BLOB *blobs = new PVI_BLOB[5];
nMaxClusters = 4;
nClustersDetected = detectClusters_wKmeans( pImgIn, pImgOut, nMaxClusters, &nClustersDetected, &blobs);
delete blobs;
colourizeClusters(*pImgOut, imc, nClustersDetected);
imc.draw(pDC->m_hDC, set_window(0,1));
sprintf(strMessage, "%i hands", nClustersDetected);
OnDraw_LogWindow(pDC,strMessage, set_window(0,1), 0);
/*
// nClustersDetected = clusterize_wKmeans( pImgIn, pImgOut, 2, 1, &imc);
// imc.draw(pDC->m_hDC, set_window(1,iActiveCamera+1));
// b)
int nXclose=4, nYclose=4, nCosine=0;
nClustersDetected = detectClusters_wProximity( pImgIn, pImgOut, nXclose, nYclose, nCosine, &imc);
imc.draw(pDC->m_hDC, set_window(4,0));
sprintf(strMessage, "%i", nClustersDetected);
OnDraw_LogWindow(pDC,strMessage, set_window(4,0), 0);
imc.destroy();
imcClusters.destroy();
// if (nClustersDetected > pPVS->m_pianoPlaying.m_nNumHands)
// m_bDetectHands = true;
*/
#endif //>> Clustering
/***************************************************************************************/
/*** Use MIDI data do detect hand/finger **************************************************/
/***************************************************************************************/
CvFont cvFont;
cvInitFont( &cvFont, CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0.0, 2 );
CvPoint ptBtmLeft;
// To do : midi for hand blob detection
//DO MIDI INFORMATION
if (USING_MIDI == 1 && m_bMidiCheck==true)
{
char keyPressString[200]; //Printable String
int i=0; //Print Counter
numStrings=0;
//FOR each possible MIDI Key
for (q=0; q < 200; q++)
{
//Calculate Key and Octave Values
keyValue = (q) % 12;
octave = (q - keyValue)/12;
//IF Key is ON
if (keyDown[q] == true)
{
//Get Bounding Box of Key
CvRect myRect = pPVS->m_pianoPlaying.m_Piano.ReturnKeyBounds(keyValue, octave);
//Select Hand that this Key intersects with
int selectedHand = pPVS->m_pianoPlaying.SelectHand(&myRect);
//Highlight Selected Key
pPVS->m_pianoPlaying.DrawBox(pPVS->m_pianoPlaying.m_imc_displayImage.getIplImage(), myRect.x, myRect.y, myRect.x + myRect.width, myRect.y + myRect.height, 3);
//Put Information to String
if (selectedHand != -1)
{
int selectedFinger = pPVS->m_pianoPlaying.m_Hand[selectedHand].SelectFinger(&myRect);
if (selectedFinger == -1)
sprintf(keyPressString, "MIDI: %d -> Octave: %d, Key: %d -> Hand: %d", q, octave, keyValue, selectedHand);
else
{
sprintf(keyPressString, "MIDI: %d -> Octave: %d, Key: %d -> Hand: %d, Finger: %d", q, octave, keyValue, selectedHand, selectedFinger+1);
sprintf(strMessage, "%i", selectedFinger);
ptBtmLeft = cvPoint(myRect.x, myRect.y-5);
cvPutText( pPVS->m_pianoPlaying.m_imc_displayImage.getIplImage(), strMessage, ptBtmLeft, &cvFont, CV_RGB(0, 200, 200));
}
}
else
sprintf(keyPressString, "MIDI: %d -> Octave: %d, Key: %d", q, octave, keyValue);
//IF Key Was JUST Pressed
if (keyChange[q] == true)
{
//Write Information to File
fprintf(pPVS->m_pianoPlaying.fDataFile, "%s\n", keyPressString);
}
//Add String To List
if (numStrings < 200)
{
sprintf(MIDIString[numStrings], "%s", keyPressString);
numStrings++;
}
}//END IF
//IF Key is OFF
else
{
//Put Information to String
sprintf(keyPressString, "Key Value: %d -> Octave: %d, Key: %d - RELEASED", q, octave, keyValue);
//IF Key Was JUST Released
if (keyChange[q] == true)
//Write Information to File
fprintf(pPVS->m_pianoPlaying.fDataFile, "%s\n", keyPressString);
}//END ELSE
}//END FOR Each Key
}//END MIDI
/***************************************************************************************/
/*** Draw all **************************************************/
/***************************************************************************************/
//DRAW IMAGES
pPVS->m_pianoPlaying.m_imc_displayImage.draw(pDC->m_hDC, set_window(1, 0));
pPVS->m_pianoPlaying.m_imc_backgroundImage.draw(pDC->m_hDC, set_window(2,0));
// pPVS->m_pianoPlaying.m_imb_handsImage.draw(pDC->m_hDC, set_window(3,0));
// pPVS->m_pianoPlaying.m_imb_edgeDetectedImage.draw(pDC->m_hDC, set_window(4,0));
/* pPVS->m_pianoPlaying.m_imb_fingerDetectedImage.
draw(pDC->m_hDC, set_window(1,1));
pPVS->m_pianoPlaying.m_imc_displayImage.
draw(pDC->m_hDC, set_window(2,1));
pPVS->m_pianoPlaying.m_imc_backgroundImage.
draw(pDC->m_hDC, set_window(3,1));
*/
pPVS->m_pianoPlaying.m_Piano.boxes.draw(pDC->m_hDC, set_window(1, 1));
pPVS->m_pianoPlaying.m_Piano.polarizedImage.draw(pDC->m_hDC, set_window(2, 1));
//pPVS->m_pianoPlaying.m_ORIMAGE.draw(pDC->m_hDC, set_window(3, 1));
//pPVS->m_pianoPlaying.m_Hand[0].m_edgeImage.draw(pDC->m_hDC, set_window(3, 1));
int f, h;
if (pPVS->m_pianoPlaying.m_nNumHands > 0)
{
h=0;
if (pPVS->m_pianoPlaying.m_Hand[h].ready == true)
{
// pPVS->m_pianoPlaying.m_Hand[h].m_fingImg[f].draw(pDC->m_hDC, set_window(f, h+2));
for (f=0; f < 5; f++)
{
pPVS->m_pianoPlaying.m_Hand[h].m_fingImg[f].draw(pDC->m_hDC, set_window(f, h+2));
//cvSet( (pPVS->m_imgOut.getIplImage()), CV_RGB(0, 100*h, f*50),
// (pPVS->m_pianoPlaying.m_Hand[h].m_fingImg[f].getIplImage()));
}
}
}
char clearString[150];
int i;
for (i=0; i < 150; i++)
clearString[i] = ' ';
//////////////////////////END ARJUN////////////////////////////
//
// pPVS->m_imgIn.draw(pDC->m_hDC, set_window(0,0), false, false);
pPVS->m_imgOut.draw(pDC->m_hDC, set_window(0,0), false, false);
nNameTag = pDoc->m_gui.slider4;//-1;
// ************************************************************************************************
if (!pDoc->m_gui.check_start) // It has to be checked to start the video processing
return;
// ************************************************************************************************
pDoc->m_bWorkWithFiles = false;
if (m_bTraceMode == true && pDoc->m_gui.check2) // if scenario, wait to continue
if (MessageBox("Proceed to next face?",NULL,MB_OKCANCEL) != IDOK)
exit(1);
}
int DoInjectRemote(LPWSTR asCmdArg, bool abDefTermOnly)
{
gbInShutdown = TRUE; // чтобы не возникло вопросов при выходе
gnRunMode = RM_SETHOOK64;
LPWSTR pszNext = asCmdArg;
LPWSTR pszEnd = NULL;
DWORD nRemotePID = wcstoul(pszNext, &pszEnd, 10);
wchar_t szStr[16];
wchar_t szTitle[128];
wchar_t szInfo[120];
wchar_t szParentPID[32];
#ifdef SHOW_INJECTREM_MSGBOX
wchar_t szDbgMsg[512], szTitle[128];
PROCESSENTRY32 pinf;
GetProcessInfo(nRemotePID, &pinf);
_wsprintf(szTitle, SKIPLEN(countof(szTitle)) L"ConEmuCD PID=%u", GetCurrentProcessId());
_wsprintf(szDbgMsg, SKIPLEN(countof(szDbgMsg)) L"Hooking PID=%s {%s}\nConEmuCD PID=%u. Continue with injects?", asCmdArg ? asCmdArg : L"", pinf.szExeFile, GetCurrentProcessId());
if (MessageBoxW(NULL, szDbgMsg, szTitle, MB_SYSTEMMODAL|MB_OKCANCEL) != IDOK)
{
return CERR_HOOKS_FAILED;
}
#endif
if (nRemotePID)
{
#if defined(SHOW_ATTACH_MSGBOX)
if (!IsDebuggerPresent())
{
wchar_t szTitle[100]; _wsprintf(szTitle, SKIPLEN(countof(szTitle)) L"%s PID=%u /INJECT", gsModuleName, gnSelfPID);
const wchar_t* pszCmdLine = GetCommandLineW();
MessageBox(NULL,pszCmdLine,szTitle,MB_SYSTEMMODAL);
}
#endif
CEStr lsName, lsPath;
{
CProcessData processes;
processes.GetProcessName(nRemotePID, lsName.GetBuffer(MAX_PATH), MAX_PATH, lsPath.GetBuffer(MAX_PATH*2), MAX_PATH*2, NULL);
CEStr lsLog(L"Remote: PID=", _ultow(nRemotePID, szStr, 10), L" Name=`", lsName, L"` Path=`", lsPath, L"`");
LogString(lsLog);
}
// Go to hook
// InjectRemote waits for thread termination
DWORD nErrCode = 0;
CINFILTRATE_EXIT_CODES iHookRc = InjectRemote(nRemotePID, abDefTermOnly, &nErrCode);
_wsprintf(szInfo, SKIPCOUNT(szInfo) L"InjectRemote result: %i (%s)", iHookRc,
(iHookRc == CIR_OK) ? L"CIR_OK" :
(iHookRc == CIR_AlreadyInjected) ? L"CIR_AlreadyInjected" :
L"?");
LogString(szInfo);
if (iHookRc == CIR_OK/*0*/ || iHookRc == CIR_AlreadyInjected/*1*/)
{
return iHookRc ? CERR_HOOKS_WAS_ALREADY_SET : CERR_HOOKS_WAS_SET;
}
else if ((iHookRc == CIR_ProcessWasTerminated) || (iHookRc == CIR_OpenProcess))
{
// Don't show error message to user. These codes are logged to file only.
return CERR_HOOKS_FAILED;
}
DWORD nSelfPID = GetCurrentProcessId();
PROCESSENTRY32 self = {sizeof(self)}, parent = {sizeof(parent)};
// Not optimal, needs refactoring
if (GetProcessInfo(nSelfPID, &self))
GetProcessInfo(self.th32ParentProcessID, &parent);
// Ошибку (пока во всяком случае) лучше показать, для отлова возможных проблем
//_ASSERTE(iHookRc == 0); -- ассерт не нужен, есть MsgBox
_wsprintf(szTitle, SKIPLEN(countof(szTitle))
L"%s %s, PID=%u", gsModuleName, gsVersion, nSelfPID);
_wsprintf(szInfo, SKIPCOUNT(szInfo)
L"Injecting remote FAILED, code=%i:0x%08X\n"
L"%s %s, PID=%u\n"
L"RemotePID=%u ",
iHookRc, nErrCode, gsModuleName, gsVersion, nSelfPID, nRemotePID);
_wsprintf(szParentPID, SKIPCOUNT(szParentPID)
L"\n"
L"ParentPID=%u ",
self.th32ParentProcessID);
CEStr lsError(lstrmerge(
szInfo,
lsPath.IsEmpty() ? lsName.IsEmpty() ? L"<Unknown>" : lsName.ms_Val : lsPath.ms_Val,
szParentPID,
parent.szExeFile));
LogString(lsError);
MessageBoxW(NULL, lsError, szTitle, MB_SYSTEMMODAL);
}
else
{
//_ASSERTE(pi.hProcess && pi.hThread && pi.dwProcessId && pi.dwThreadId);
wchar_t szDbgMsg[512], szTitle[128];
_wsprintf(szTitle, SKIPLEN(countof(szTitle)) L"ConEmuC, PID=%u", GetCurrentProcessId());
_wsprintf(szDbgMsg, SKIPLEN(countof(szDbgMsg)) L"ConEmuC.X, PID=%u\nCmdLine parsing FAILED (%u)!\n%s",
GetCurrentProcessId(), nRemotePID,
asCmdArg);
LogString(szDbgMsg);
MessageBoxW(NULL, szDbgMsg, szTitle, MB_SYSTEMMODAL);
}
return CERR_HOOKS_FAILED;
}
int audio_play_samples(struct audio_info_struct *ai,unsigned char *buf,int len)
{
HGLOBAL hg, hg2;
LPWAVEHDR wh;
MMRESULT res;
void *b;
///////////////////////////////////////////////////////
// Wait for a few FREE blocks...
///////////////////////////////////////////////////////
while(nBlocks > MAX_BLOCKS)
Sleep(77);
////////////////////////////////////////////////////////
// FIRST allocate some memory for a copy of the buffer!
////////////////////////////////////////////////////////
hg2 = GlobalAlloc(GMEM_MOVEABLE, len);
if(!hg2)
{
MessageBox(NULL, "GlobalAlloc failed!", "Error...", MB_OK);
return(-1);
}
b = GlobalLock(hg2);
//////////////////////////////////////////////////////////
// Here we can call any modification output functions we want....
///////////////////////////////////////////////////////////
CopyMemory(b, buf, len);
///////////////////////////////////////////////////////////
// now make a header and WRITE IT!
///////////////////////////////////////////////////////////
hg = GlobalAlloc (GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof (WAVEHDR));
if(!hg)
{
return -1;
}
wh = GlobalLock(hg);
wh->dwBufferLength = len;
wh->lpData = b;
EnterCriticalSection( &cs );
res = waveOutPrepareHeader(dev, wh, sizeof (WAVEHDR));
if(res)
{
GlobalUnlock(hg);
GlobalFree(hg);
LeaveCriticalSection( &cs );
return -1;
}
res = waveOutWrite(dev, wh, sizeof (WAVEHDR));
if(res)
{
GlobalUnlock(hg);
GlobalFree(hg);
LeaveCriticalSection( &cs );
return (-1);
}
nBlocks++;
LeaveCriticalSection( &cs );
return(len);
}
void CtrlRegisterList::editRegisterValue()
{
if (!Core_IsStepping())
{
MessageBox(wnd,"Can't change registers while the core is running.","Error",MB_OK);
return;
}
int cat = category;
int reg = selection;
u32 val;
if (selection >= cpu->GetNumRegsInCategory(cat))
{
if (cat != 0 || selection >= REGISTERS_END)
return;
switch (selection)
{
case REGISTER_PC:
val = cpu->GetPC();
break;
case REGISTER_HI:
val = cpu->GetHi();
break;
case REGISTER_LO:
val = cpu->GetLo();
break;
}
} else {
val = cpu->GetRegValue(cat,reg);
}
char temp[256];
sprintf(temp,"%08X",val);
if (InputBox_GetString(GetModuleHandle(NULL),wnd,"Set new value",temp,temp))
{
if (parseExpression(temp,cpu,val) == false)
{
displayExpressionError(wnd);
} else {
switch (reg)
{
case REGISTER_PC:
cpu->SetPC(val);
break;
case REGISTER_HI:
cpu->SetHi(val);
break;
case REGISTER_LO:
cpu->SetLo(val);
break;
default:
cpu->SetRegValue(cat,reg,val);
break;
}
redraw();
SendMessage(GetParent(wnd),WM_DEB_UPDATE,0,0); // registers changed -> disassembly needs to be updated
}
}
}
HWND CDongbuAPIClientDlg::FindDRCM( CString szUserName)
{
BOOL bAlreayRun ;
bAlreayRun = FALSE;
CString szRoot, szWinName, szFileName, szTmpWinName ;
GetDRCMInfo (szRoot, szFileName, szWinName);
szTmpWinName.Format( "%s[%s]", szWinName, szUserName ) ;
szRoot = szRoot + "\\Bin";
HANDLE hSyncEvent=NULL;
HWND hDrcmHandle = ::FindWindow(NULL, szTmpWinName);
if ( hDrcmHandle == NULL )
{
ShellExecute(NULL, "open", szFileName, szUserName, szRoot, SW_SHOWNORMAL);
while(1)
{
::WaitForSingleObject(hSyncEvent, INFINITE);
DWORD dwWait = 0;
do
{
dwWait = ::WaitForSingleObject(hSyncEvent, 3000);
}
while(dwWait == WAIT_OBJECT_0);
// timed out
hDrcmHandle = ::FindWindow(NULL, szWinName);
if ( hDrcmHandle != NULL )
break;
}
}
else
{
if ( m_chkMultiConn == FALSE )
{
bAlreayRun = TRUE ;
hDrcmHandle = NULL ;
}
else
{
ShellExecute(NULL, "open", szFileName, szUserName, szRoot, SW_SHOWNORMAL);
while(1)
{
::WaitForSingleObject(hSyncEvent, INFINITE);
DWORD dwWait = 0;
do
{
dwWait = ::WaitForSingleObject(hSyncEvent, 3000);
}
while(dwWait == WAIT_OBJECT_0);
// timed out
hDrcmHandle = ::FindWindow(NULL, szWinName);
if ( hDrcmHandle != NULL )
break;
}
}
}
if ( hDrcmHandle == NULL )
{
if ( bAlreayRun )
{
CString strMsg ;
strMsg = "이미 같은 ID 가 동부 DRCM에 로그되어 있습니다." ;
strMsg += "\n 프로그램을 종료합니다! " ;
MessageBox (strMsg, "동부DRCM", MB_ICONINFORMATION|MB_OK) ;
}
else
MessageBox ( "동부 DRCM을 찾을 수 없습니다" , "동부DRCM", MB_ICONINFORMATION|MB_OK) ;
}
return hDrcmHandle;
}
