Пример #1
0
VOID
PerflogReadModuleLevel(
    HINSTANCE hInstance
)
{
    LONG lReturn;                   // Create key return value
    TCHAR szInfo[iDEBUGINFO];       // Constructs key names
    TCHAR szFullName[iDEBUGINFO];   // Load the full path and module name
    HKEY hModuleKey;                // Module key handle
    LPTSTR pName;                   // Searches from the end for a backslash
    DWORD dwKeySize, dwKeyType, dwKeyValue;

    DWORD dwSize = GetModuleFileName(
                       (hInstance ? hInstance : GetModuleHandle(NULL)),
                       szFullName,
                       iDEBUGINFO);

    if(0 == dwSize || iDEBUGINFO == dwSize)
    {
        return;
    }

    pName = _tcsrchr(szFullName, '\\');
    if(pName == NULL)
    {
        pName = szFullName;
    }
    else
    {
        pName++;
    }

    /* Construct the base key name */
    (void)StringCchPrintf(szInfo, NUMELMS(szInfo), TEXT("SOFTWARE\\Debug\\%s"), pName);

    /* Open the key for this module */
    lReturn =
        RegOpenKeyEx(
            HKEY_LOCAL_MACHINE,   // Handle of an open key
            szInfo,               // Address of subkey name
            (DWORD) 0,            // Reserved value
            KEY_QUERY_VALUE,      // Desired security access
            &hModuleKey);         // Opened handle buffer

    if(lReturn != ERROR_SUCCESS)
    {
        return;
    }

    dwKeySize = sizeof(DWORD);
    lReturn = RegQueryValueEx(
                  hModuleKey,                 // Handle to an open key
                  TEXT("PERFLOG"),
                  NULL,                       // Reserved field
                  &dwKeyType,                 // Returns the field type
                  (LPBYTE) &dwKeyValue,       // Returns the field's value
                  &dwKeySize);                // Number of bytes transferred

    if((lReturn == ERROR_SUCCESS) && (dwKeyType == REG_DWORD))
    {
        PerflogModuleLevel = dwKeyValue;
    }

    RegCloseKey(hModuleKey);
}
Пример #2
0
INT_PTR CALLBACK DlgProc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
	switch (msg)
	{
		case WM_INITDIALOG:
		{
#ifndef _APP_NO_DARKTHEME
			_r_wnd_setdarktheme (hwnd);
#endif // _APP_NO_DARKTHEME

			// configure listview
			_r_listview_setstyle (hwnd, IDC_LISTVIEW, LVS_EX_DOUBLEBUFFER | LVS_EX_FULLROWSELECT | LVS_EX_INFOTIP | LVS_EX_LABELTIP);

			_r_listview_addcolumn (hwnd, IDC_LISTVIEW, 1, nullptr, 39, LVCFMT_LEFT);
			_r_listview_addcolumn (hwnd, IDC_LISTVIEW, 2, nullptr, 61, LVCFMT_RIGHT);

			for (UINT i = 0; i < TypeMax; i++)
				_r_listview_additem (hwnd, IDC_LISTVIEW, i, 0, nullptr);

			// configure datetime format
			{
				WCHAR date_format[MAX_PATH] = {0};
				WCHAR time_format[MAX_PATH] = {0};

				if (
					GetLocaleInfo (LOCALE_SYSTEM_DEFAULT, LOCALE_SLONGDATE, date_format, _countof (date_format)) &&
					GetLocaleInfo (LOCALE_SYSTEM_DEFAULT, LOCALE_STIMEFORMAT, time_format, _countof (time_format))
					)
				{
					WCHAR buffer[MAX_PATH] = {0};
					StringCchPrintf (buffer, _countof (buffer), L"%s %s", date_format, time_format);

					SendDlgItemMessage (hwnd, IDC_INPUT, DTM_SETFORMAT, 0, (LPARAM)buffer);
				}
			}

			// print latest timestamp
			{
				SYSTEMTIME st = {0};

				current_timestamp_utc = app.ConfigGet (L"LatestTimestamp", _r_unixtime_now ()).AsLonglong ();

				//_app_gettime (current_timestamp_utc, 0, &st);
				//_app_printdate (hwnd, &st);
			}

			_r_ctrl_settip (hwnd, IDC_CURRENT, LPSTR_TEXTCALLBACK);

			break;
		}

		case WM_DESTROY:
		{
			// save latest timestamp
			{
				SYSTEMTIME st = {0};
				//SendDlgItemMessage (hwnd, IDC_INPUT, DTM_GETSYSTEMTIME, 0, (LPARAM)&st);

				_app_gettime (current_timestamp_utc, 0, &st);

				app.ConfigSet (L"LatestTimestamp", _r_unixtime_from_systemtime (&st));
			}

			PostQuitMessage (0);

			break;
		}

		case RM_INITIALIZE:
		{
			// configure menu
			CheckMenuItem (GetMenu (hwnd), IDM_ALWAYSONTOP_CHK, MF_BYCOMMAND | (app.ConfigGet (L"AlwaysOnTop", false).AsBool () ? MF_CHECKED : MF_UNCHECKED));
			CheckMenuItem (GetMenu (hwnd), IDM_CHECKUPDATES_CHK, MF_BYCOMMAND | (app.ConfigGet (L"CheckUpdates", true).AsBool () ? MF_CHECKED : MF_UNCHECKED));
			CheckMenuItem (GetMenu (hwnd), IDM_CLASSICUI_CHK, MF_BYCOMMAND | (app.ConfigGet (L"ClassicUI", _APP_CLASSICUI).AsBool () ? MF_CHECKED : MF_UNCHECKED));

			// configure timezone
			{
				const HMENU submenu_timezone = GetSubMenu (GetSubMenu (GetMenu (hwnd), 1), TIMEZONE_MENU);

				// clear menu
				for (UINT i = 0;; i++)
				{
					if (!DeleteMenu (submenu_timezone, TIMEZONE_MENU + i, MF_BYCOMMAND))
					{
						DeleteMenu (submenu_timezone, 0, MF_BYPOSITION); // delete separator
						break;
					}
				}

				const LONG current_bias = _app_getcurrentbias ();
				const LONG default_bias = _app_getdefaultbias ();

				for (size_t i = 0; i < _countof (int_timezones); i++)
				{
					const LONG bias = int_timezones[i];

					MENUITEMINFO mii = {0};

					WCHAR menu_title[32] = {0};
					StringCchPrintf (menu_title, _countof (menu_title), L"GMT %s", _app_timezone2string (bias, true, L"+00:00 (UTC)").GetString ());

					if (bias == default_bias)
						StringCchCat (menu_title, _countof (menu_title), SYSTEM_BIAS);

					mii.cbSize = sizeof (mii);
					mii.fMask = MIIM_ID | MIIM_STRING;
					mii.fType = MFT_STRING;
					mii.fState = MFS_DEFAULT;
					mii.dwTypeData = menu_title;
					mii.wID = IDX_TIMEZONE + UINT (i);

					InsertMenuItem (submenu_timezone, mii.wID, FALSE, &mii);

					if (bias == current_bias)
					{
						current_bias_idx = i;

						CheckMenuRadioItem (submenu_timezone, IDX_TIMEZONE, IDX_TIMEZONE + UINT (_countof (int_timezones) - 1), mii.wID, MF_BYCOMMAND);
					}
				}

				SYSTEMTIME st = {0};

				_app_gettime (current_timestamp_utc, current_bias, &st);
				_app_printdate (hwnd, &st);
			}

			break;
		}

		case RM_LOCALIZE:
		{
			// configure menu
			const HMENU menu = GetMenu (hwnd);

			app.LocaleMenu (menu, IDS_FILE, 0, true, nullptr);
			app.LocaleMenu (menu, IDS_EXIT, IDM_EXIT, false, L"\tEsc");
			app.LocaleMenu (menu, IDS_SETTINGS, 1, true, nullptr);
			app.LocaleMenu (menu, IDS_ALWAYSONTOP_CHK, IDM_ALWAYSONTOP_CHK, false, nullptr);
			app.LocaleMenu (menu, IDS_CHECKUPDATES_CHK, IDM_CHECKUPDATES_CHK, false, nullptr);
			app.LocaleMenu (menu, IDS_CLASSICUI_CHK, IDM_CLASSICUI_CHK, false, nullptr);
			app.LocaleMenu (GetSubMenu (menu, 1), IDS_TIMEZONE, TIMEZONE_MENU, true, nullptr);
			app.LocaleMenu (GetSubMenu (menu, 1), IDS_LANGUAGE, LANG_MENU, true, L" (Language)");
			app.LocaleMenu (menu, IDS_HELP, 2, true, nullptr);
			app.LocaleMenu (menu, IDS_WEBSITE, IDM_WEBSITE, false, nullptr);
			app.LocaleMenu (menu, IDS_CHECKUPDATES, IDM_CHECKUPDATES, false, nullptr);
			app.LocaleMenu (menu, IDS_ABOUT, IDM_ABOUT, false, L"\tF1");

			app.LocaleEnum ((HWND)GetSubMenu (menu, 1), LANG_MENU, true, IDX_LANGUAGE); // enum localizations

			// configure listview
			for (UINT i = 0; i < TypeMax; i++)
				_r_listview_setitem (hwnd, IDC_LISTVIEW, i, 0, _app_gettimedescription ((EnumDateType)i, false));

			_r_wnd_addstyle (hwnd, IDC_CURRENT, app.IsClassicUI () ? WS_EX_STATICEDGE : 0, WS_EX_STATICEDGE, GWL_EXSTYLE);

			RedrawWindow (hwnd, nullptr, nullptr, RDW_ERASENOW | RDW_INVALIDATE);

			break;
		}

		case WM_CONTEXTMENU:
		{
			if (GetDlgCtrlID ((HWND)wparam) == IDC_LISTVIEW)
			{
				const HMENU menu = LoadMenu (nullptr, MAKEINTRESOURCE (IDM_LISTVIEW));
				const HMENU submenu = GetSubMenu (menu, 0);

				// localize
				app.LocaleMenu (submenu, IDS_COPY, IDM_COPY, false, L"\tCtrl+C");

				if (!SendDlgItemMessage (hwnd, IDC_LISTVIEW, LVM_GETSELECTEDCOUNT, 0, 0))
					EnableMenuItem (submenu, IDM_COPY, MF_BYCOMMAND | MF_DISABLED);

				POINT pt = {0};
				GetCursorPos (&pt);

				TrackPopupMenuEx (submenu, TPM_RIGHTBUTTON | TPM_LEFTBUTTON, pt.x, pt.y, hwnd, nullptr);

				DestroyMenu (menu);
			}

			break;
		}

		case WM_NOTIFY:
		{
			switch (LPNMHDR (lparam)->code)
			{
				case DTN_USERSTRING:
				{
					LPNMDATETIMESTRING lpds = (LPNMDATETIMESTRING)lparam;

					if (lpds)
					{
						const rstring datetime = lpds->pszUserString;

						if (datetime.IsNumeric ())
							_r_unixtime_to_systemtime (datetime.AsLonglong (), &lpds->st);
					}

					break;
				}

				case DTN_DATETIMECHANGE:
				{
					LPNMDATETIMECHANGE lpnmdtc = (LPNMDATETIMECHANGE)lparam;

					current_timestamp_utc = _r_unixtime_from_systemtime (&lpnmdtc->st); // store position of current time (utc)

					_app_printdate (hwnd, &lpnmdtc->st);

					break;
				}

				case LVN_GETINFOTIP:
				{
					LPNMLVGETINFOTIP lpnmlv = (LPNMLVGETINFOTIP)lparam;

					StringCchCopy (lpnmlv->pszText, lpnmlv->cchTextMax, _app_gettimedescription ((EnumDateType)lpnmlv->iItem, true));

					break;
				}

				case TTN_GETDISPINFO:
				{
					LPNMTTDISPINFO lpnmdi = (LPNMTTDISPINFO)lparam;

					if ((lpnmdi->uFlags & TTF_IDISHWND) != 0)
					{
						WCHAR buffer[1024] = {0};
						const UINT ctrl_id = GetDlgCtrlID ((HWND)lpnmdi->hdr.idFrom);

						if (ctrl_id == IDC_CURRENT)
							StringCchCopy (buffer, _countof (buffer), app.LocaleString (IDS_CURRENT, nullptr));

						if (buffer[0])
							lpnmdi->lpszText = buffer;
					}

					break;
				}
			}

			break;
		}

		case WM_COMMAND:
		{
			if (HIWORD (wparam) == 0 && LOWORD (wparam) >= IDX_LANGUAGE && LOWORD (wparam) <= IDX_LANGUAGE + app.LocaleGetCount ())
			{
				app.LocaleApplyFromMenu (GetSubMenu (GetSubMenu (GetMenu (hwnd), 1), LANG_MENU), LOWORD (wparam), IDX_LANGUAGE);

				return FALSE;
			}
			else if ((LOWORD (wparam) >= IDX_TIMEZONE && LOWORD (wparam) <= IDX_TIMEZONE + (_countof (int_timezones) - 1)))
			{
				const UINT idx = LOWORD (wparam) - IDX_TIMEZONE;
				const LONG bias = int_timezones[idx];

				current_bias_idx = idx;
				app.ConfigSet (L"TimezoneBias", bias);

				const HMENU submenu_timezone = GetSubMenu (GetSubMenu (GetMenu (hwnd), 1), TIMEZONE_MENU);
				CheckMenuRadioItem (submenu_timezone, IDX_TIMEZONE, IDX_TIMEZONE + UINT (_countof (int_timezones) - 1), LOWORD (wparam), MF_BYCOMMAND);

				SYSTEMTIME st = {0};

				_app_gettime (current_timestamp_utc, bias, &st);
				_app_printdate (hwnd, &st);

				return FALSE;
			}

			switch (LOWORD (wparam))
			{
				case IDCANCEL: // process Esc key
				case IDM_EXIT:
				{
					DestroyWindow (hwnd);
					break;
				}

				case IDM_ALWAYSONTOP_CHK:
				{
					const bool new_val = !app.ConfigGet (L"AlwaysOnTop", false).AsBool ();

					CheckMenuItem (GetMenu (hwnd), LOWORD (wparam), MF_BYCOMMAND | (new_val ? MF_CHECKED : MF_UNCHECKED));
					app.ConfigSet (L"AlwaysOnTop", new_val);

					_r_wnd_top (hwnd, new_val);

					break;
				}

				case IDM_CHECKUPDATES_CHK:
				{
					const bool new_val = !app.ConfigGet (L"CheckUpdates", true).AsBool ();

					CheckMenuItem (GetMenu (hwnd), LOWORD (wparam), MF_BYCOMMAND | (new_val ? MF_CHECKED : MF_UNCHECKED));
					app.ConfigSet (L"CheckUpdates", new_val);

					break;
				}

				case IDM_CLASSICUI_CHK:
				{
					const bool new_val = !app.ConfigGet (L"ClassicUI", _APP_CLASSICUI).AsBool ();

					CheckMenuItem (GetMenu (hwnd), LOWORD (wparam), MF_BYCOMMAND | (new_val ? MF_CHECKED : MF_UNCHECKED));
					app.ConfigSet (L"ClassicUI", new_val);

					break;
				}

				case IDM_WEBSITE:
				{
					ShellExecute (hwnd, nullptr, _APP_WEBSITE_URL, nullptr, nullptr, SW_SHOWDEFAULT);
					break;
				}

				case IDM_CHECKUPDATES:
				{
					app.UpdateCheck (true);
					break;
				}

				case IDM_ABOUT:
				{
					app.CreateAboutWindow (hwnd);
					break;
				}

				case IDM_COPY:
				{
					rstring buffer;

					size_t item = LAST_VALUE;

					while ((item = (size_t)SendDlgItemMessage (hwnd, IDC_LISTVIEW, LVM_GETNEXTITEM, item, LVNI_SELECTED)) != LAST_VALUE)
					{
						buffer.AppendFormat (L"%s\r\n", _r_listview_getitemtext (hwnd, IDC_LISTVIEW, item, 1).GetString ());
					}

					if (!buffer.IsEmpty ())
					{
						buffer.Trim (L"\r\n");

						_r_clipboard_set (hwnd, buffer, buffer.GetLength ());
					}

					break;
				}

				case IDC_CURRENT:
				{
					SYSTEMTIME st = {0};

					_app_gettime (_r_unixtime_now (), _app_getcurrentbias (), &st);
					_app_printdate (hwnd, &st);

					break;
				}

				case IDM_SELECT_ALL:
				{
					ListView_SetItemState (GetDlgItem (hwnd, IDC_LISTVIEW), -1, LVIS_SELECTED, LVIS_SELECTED);
					break;
				}

				case IDM_TIMEZONE_NEXT:
				case IDM_TIMEZONE_PREV:
				{
					if (LOWORD (wparam) == IDM_TIMEZONE_NEXT)
						current_bias_idx = ((current_bias_idx == (_countof (int_timezones) - 1)) ? 0 : ++current_bias_idx);

					else
						current_bias_idx = (!current_bias_idx ? (_countof (int_timezones) - 1) : --current_bias_idx);

					SendMessage (hwnd, WM_COMMAND, MAKEWPARAM (IDX_TIMEZONE + current_bias_idx, 0), 0);

					break;
				}
			}
		}
	}

	return FALSE;
}
Пример #3
0
int RunDebugger()
{
	if (!gpSrv->DbgInfo.pDebugTreeProcesses)
	{
		gpSrv->DbgInfo.pDebugTreeProcesses = (MMap<DWORD,CEDebugProcessInfo>*)calloc(1,sizeof(*gpSrv->DbgInfo.pDebugTreeProcesses));
		gpSrv->DbgInfo.pDebugTreeProcesses->Init(1024);
	}

	UpdateDebuggerTitle();

	// Если это новая консоль - увеличить ее размер, для удобства
	if (IsWindowVisible(ghConWnd))
	{
		HANDLE hCon = ghConOut;
		CONSOLE_SCREEN_BUFFER_INFO csbi = {};
		GetConsoleScreenBufferInfo(hCon, &csbi);
		if (csbi.dwSize.X < 260)
		{
			COORD crNewSize = {260, 9999};
			SetConsoleScreenBufferSize(ghConOut, crNewSize);
		}
		//if ((csbi.srWindow.Right - csbi.srWindow.Left + 1) < 120)
		//{
		//	COORD crMax = GetLargestConsoleWindowSize(hCon);
		//	if ((crMax.X - 10) > (csbi.srWindow.Right - csbi.srWindow.Left + 1))
		//	{
		//		COORD crSize = {((int)((crMax.X - 15)/10))*10, min(crMax.Y, (csbi.srWindow.Bottom - csbi.srWindow.Top + 1))};
		//		SMALL_RECT srWnd = {0, csbi.srWindow.Top, crSize.X - 1, csbi.srWindow.Bottom};
		//		MONITORINFO mi = {sizeof(mi)};
		//		GetMonitorInfo(MonitorFromWindow(ghConWnd, MONITOR_DEFAULTTONEAREST), &mi);
		//		RECT rcWnd = {}; GetWindowRect(ghConWnd, &rcWnd);
		//		SetWindowPos(ghConWnd, NULL, min(rcWnd.left,(mi.rcWork.left+50)), rcWnd.top, 0,0, SWP_NOSIZE|SWP_NOZORDER);
		//		SetConsoleSize(9999, crSize, srWnd, "StartDebugger");
		//	}
		//}
	}

	// Вывести в консоль информацию о версии.
	PrintVersion();
	#ifdef SHOW_DEBUG_STARTED_MSGBOX
	wchar_t szInfo[128];
	StringCchPrintf(szInfo, countof(szInfo), L"Attaching debugger...\nConEmuC PID = %u\nDebug PID = %u",
	                GetCurrentProcessId(), gpSrv->dwRootProcess);
	MessageBox(GetConEmuHWND(2), szInfo, L"ConEmuC.Debugger", 0);
	#endif

	//if (!DebugActiveProcess(gpSrv->dwRootProcess))
	//{
	//	DWORD dwErr = GetLastError();
	//	_printf("Can't start debugger! ErrCode=0x%08X\n", dwErr);
	//	return CERR_CANTSTARTDEBUGGER;
	//}
	//// Дополнительная инициализация, чтобы закрытие дебагера (наш процесс) не привело
	//// к закрытию "отлаживаемой" программы
	//pfnDebugActiveProcessStop = (FDebugActiveProcessStop)GetProcAddress(GetModuleHandle(L"kernel32.dll"),"DebugActiveProcessStop");
	//pfnDebugSetProcessKillOnExit = (FDebugSetProcessKillOnExit)GetProcAddress(GetModuleHandle(L"kernel32.dll"),"DebugSetProcessKillOnExit");
	//if (pfnDebugSetProcessKillOnExit)
	//	pfnDebugSetProcessKillOnExit(FALSE/*KillOnExit*/);
	//gpSrv->DbgInfo.bDebuggerActive = TRUE;
	//PrintDebugInfo();

	if (gpSrv->DbgInfo.pszDebuggingCmdLine == NULL)
	{
		int iAttachRc = AttachRootProcessHandle();
		if (iAttachRc != 0)
			return iAttachRc;
	}
	else
	{
		_ASSERTE(!gpSrv->DbgInfo.bDebuggerActive);
	}

	_ASSERTE(((gpSrv->hRootProcess!=NULL) || (gpSrv->DbgInfo.pszDebuggingCmdLine!=NULL)) && "Process handle must be opened");

	gpSrv->DbgInfo.hDebugReady = CreateEvent(NULL, FALSE, FALSE, NULL);
	// Перенес обработку отладочных событий в отдельную нить, чтобы случайно не заблокироваться с главной
	gpSrv->DbgInfo.hDebugThread = CreateThread(NULL, 0, DebugThread, NULL, 0, &gpSrv->DbgInfo.dwDebugThreadId);
	HANDLE hEvents[2] = {gpSrv->DbgInfo.hDebugReady, gpSrv->DbgInfo.hDebugThread};
	DWORD nReady = WaitForMultipleObjects(countof(hEvents), hEvents, FALSE, INFINITE);

	if (nReady != WAIT_OBJECT_0)
	{
		DWORD nExit = 0;
		GetExitCodeThread(gpSrv->DbgInfo.hDebugThread, &nExit);
		return nExit;
	}

	gpszRunCmd = (wchar_t*)calloc(1,2);

	if (!gpszRunCmd)
	{
		_printf("Can't allocate 1 wchar!\n");
		return CERR_NOTENOUGHMEM1;
	}

	gpszRunCmd[0] = 0;
	gpSrv->DbgInfo.bDebuggerActive = TRUE;

	// And wait for debugger thread completion
	_ASSERTE(gnRunMode == RM_UNDEFINED);
	DWORD nDebugThread = WaitForSingleObject(gpSrv->DbgInfo.hDebugThread, INFINITE);
	_ASSERTE(nDebugThread == WAIT_OBJECT_0); UNREFERENCED_PARAMETER(nDebugThread);

	gbInShutdown = TRUE;
	return 0;
}
Пример #4
0
BOOL MainWindow::OpenProjData()
{
	RootDicomObj *DCMinfo = NULL;
	char filename[MAX_PATH];
	char projFolder[MAX_PATH];

	BROWSEINFO bi = {0};
	PIDLIST_ABSOLUTE pidl;

	WCHAR szDisplayName[MAX_PATH];
	WCHAR szTitle[] = L"Select a folder containing projection data.";

	HANDLE hFindFile;
	WCHAR szFileName[MAX_PATH];
	WIN32_FIND_DATA findData = {0};

	if(m_Recon && !m_ReconSaved)
		if(MessageBox(m_hwnd,
			L"Reconstruction has not been saved. Do you wish to continue?",
			L"WinCone CT",
			MB_ICONWARNING | MB_YESNO) == IDNO)
			return FALSE;

	bi.hwndOwner = m_hwnd;
	bi.pidlRoot = NULL;
	bi.pszDisplayName = szDisplayName;
	bi.lpszTitle = szTitle;
	bi.ulFlags = BIF_NEWDIALOGSTYLE | BIF_NONEWFOLDERBUTTON | BIF_RETURNONLYFSDIRS;
	bi.lpfn = NULL;

	if(!(pidl = SHBrowseForFolder(&bi)))
		return FALSE;

	SHGetPathFromIDList(pidl, szDisplayName);

	// do _findfirst() stuff with current directory
	StringCchPrintf(szFileName,MAX_PATH,L"%s\\%s",szDisplayName,L"1.3.6.1.4.1*");
	hFindFile = FindFirstFile(szFileName,&findData);

	if(hFindFile == INVALID_HANDLE_VALUE)
	{
		MessageBox(m_hwnd,
			L"The selected folder does not contain valid DICOM projection data.",
			L"Load Projection Data",
			MB_OK);
		return FALSE;
	}

	FindClose(hFindFile);

	sprintf_s(filename,sizeof(filename),"%S\\%S",szDisplayName,findData.cFileName);
	DCMinfo = new RootDicomObj(filename,true);
	// confirm that DICOM files are legit here

	if(m_Recon)
	{
		delete m_Recon;
		m_Recon = NULL;
	}
	if(m_Proj)
	{
		delete m_Proj;
		m_Proj = NULL;
	}

	// Update the current folder field
	SendMessage(m_hCurrentFolder,WM_SETTEXT,NULL,(LPARAM)szDisplayName);

	// Enable the reconstruction controls

	delete DCMinfo;

	WideCharToMultiByte(1251,WC_NO_BEST_FIT_CHARS,szDisplayName,MAX_PATH,projFolder,sizeof(projFolder),0,NULL);
	m_Proj = new Projection(projFolder);
	SendMessage(m_hProgress,PBM_SETRANGE,MAKEWPARAM(0,0),MAKELPARAM(0,m_Proj->GetNumProj()));

	return TRUE;
}
Пример #5
0
void CResourceMapDoc::Serialize(CArchive& ar)
{
    if (ar.IsStoring())
    {
        // There is nothing to save.
        int x = 0;
    }
    else
    {
        CFile *pFile = ar.GetFile();

        // Set the current directory, so we know where to look for the resource files.
        // If not, clicking on an item in the recent documents list won't work
        CString path = pFile->GetFilePath();
        path.MakeLower();
        int iFileOffset = path.Find(TEXT("\\resource.map"));
        if (iFileOffset > 0)
        {
            path.SetAt(iFileOffset, 0); // Null terminate it

            // Set this folder as our new game folder
            CResourceMap &map = theApp.GetResourceMap();
            map.SetGameFolder(path);

            // Close it.  We only wanted the path.
            pFile->Close();

            // Clear the current view.
            _DeleteAllResourceData();
            _DeleteAllPics();

            CResourceEnumerator *pEnum;
            if (SUCCEEDED(map.CreateEnumerator(RTF_PIC, &pEnum)))
            {
                CResourceData *pData;
                while (S_OK == pEnum->Next(&pData))
                {
                    // TODO: try catch, and free pData?

                    // Add these resource datas.
                    _resources.Add(pData);

                    // And create a pic from them.
                    CPic *ppic = new CPic();
                    if (ppic)
                    {
                        if (SUCCEEDED(ppic->InitFromResource(pData)))
                        {
                            _pics.Add(ppic);
                        }
                        else
                        {
                            delete ppic;
                        }
                    }
                }

#ifdef DEBUG
                INT_PTR iSizeMemory = 0;
                for (INT_PTR i = 0; i < _pics.GetSize(); i++)
                {
                    CPic *ppic = _pics.GetAt(i);
                    iSizeMemory += ppic->GetMemorySize();
                }
                TCHAR sz[MAX_PATH];
                StringCchPrintf(sz, ARRAYSIZE(sz), TEXT("Memory size of pics: %d"), iSizeMemory);
                OutputDebugString(sz);
#endif 

                SetModifiedFlag(TRUE);
                UpdateAllViews(NULL, VIEWUPDATEHINT_RESOURCEMAPCHANGED);

                delete pEnum;
            }

        }
        else
        {
            AfxMessageBox(TEXT("SCI game resources must be called resource.map"), MB_OK | MB_ICONEXCLAMATION);
        }
    }
}
Пример #6
0
NTSTATUS JpqlpcCreatePort(
	__in PWSTR Name,
	__in PSECURITY_ATTRIBUTES SecurityAttributes,
	__in ULONG SharedMemorySize,
	__out JPQLPC_PORT_HANDLE *PortHandle,
	__out PBOOL OpenedExisting
	)
{
	NTSTATUS Status = STATUS_UNSUCCESSFUL;
	PJPQLPC_PORT Port = NULL;
	WCHAR ServerEventName[ JPQLPC_MAX_PORT_NAME_CCH + 10 ];
	WCHAR ClientEventName[ JPQLPC_MAX_PORT_NAME_CCH + 10 ];
	size_t NameLen;

	ULONG AllocGranularity = JpqlpcsGetAllocationGranularity();

	if ( ! Name ||
		 SharedMemorySize == 0 ||
		 ! PortHandle ||
		 ( SharedMemorySize % AllocGranularity ) != 0 ||
		 ! OpenedExisting )
	{
		return STATUS_INVALID_PARAMETER;
	}

	if ( FAILED( StringCchLength(
		Name,
		JPQLPC_MAX_PORT_NAME_CCH,
		&NameLen ) ) ||
		NameLen == 0 ||
		NameLen >= JPQLPC_MAX_PORT_NAME_CCH )
	{
		return STATUS_INVALID_PARAMETER;
	}

	*OpenedExisting = FALSE;

	//
	// Generate names for events.
	//
	if ( FAILED( StringCchPrintf(
		ServerEventName,
		_countof( ServerEventName ),
		L"%s_Server",
		Name ) ) )
	{
		return NTSTATUS_QLPC_CANNOT_CREATE_PORT;
	}

	if ( FAILED( StringCchPrintf(
		ClientEventName,
		_countof( ClientEventName ),
		L"%s_Client",
		Name ) ) )
	{
		return NTSTATUS_QLPC_CANNOT_CREATE_PORT;
	}

	//
	// Allocate port struct.
	//
	Port = ( PJPQLPC_PORT ) malloc( sizeof( JPQLPC_PORT ) );
	if ( ! Port )
	{
		return STATUS_NO_MEMORY;
	}

	ZeroMemory( Port, sizeof( JPQLPC_PORT ) );

	//
	// Allocate pagefile-backed shared memory.
	//
	Port->SharedMemory.Size = SharedMemorySize;
	Port->SharedMemory.FileMapping = CreateFileMapping(
		INVALID_HANDLE_VALUE,
		SecurityAttributes,
		PAGE_READWRITE,
		0,
		SharedMemorySize,
		Name );
	if ( Port->SharedMemory.FileMapping == NULL )
	{
		switch ( GetLastError() )
		{
		case ERROR_ACCESS_DENIED:
			Status = STATUS_ACCESS_VIOLATION;
		case ERROR_INVALID_HANDLE:
			Status = STATUS_OBJECT_NAME_COLLISION;
		default:
			Status = NTSTATUS_QLPC_CANNOT_CREATE_PORT;
		}

		goto Cleanup;
	}
	else
	{
		if ( ERROR_ALREADY_EXISTS == GetLastError() )
		{
			*OpenedExisting = TRUE;
		}
		else
		{
			//
			// Ok.
			//
		}
	}

	Port->SharedMemory.SharedMessage = MapViewOfFile(
		Port->SharedMemory.FileMapping,
		FILE_MAP_WRITE,
		0,
		0,
		SharedMemorySize );
	if ( Port->SharedMemory.SharedMessage == NULL )
	{
		Status = NTSTATUS_QLPC_CANNOT_MAP_PORT;
		goto Cleanup;
	}

	Port->SharedMemory.SharedMessage->TotalSize = SharedMemorySize;

	if ( *OpenedExisting )
	{
		//
		// Client port.
		//
		Port->Type = JpqlpcClientPortType;
	}
	else
	{
		//
		// Server port.
		//
		Port->Type = JpqlpcServerPortType;

		Port->InitialReceiveDone = FALSE;
	}

	//
	// Create pair of events. The server event is initially sinalled,
	// the client event is not.
	//
	Port->EventPair.Host = CreateEvent(
		SecurityAttributes,
		FALSE,
		FALSE,
		*OpenedExisting ? ClientEventName : ServerEventName );
	if ( Port->EventPair.Host == NULL )
	{
		Status = NTSTATUS_QLPC_CANNOT_CREATE_EVPAIR;
		goto Cleanup;
	}
	else if ( GetLastError() == ERROR_ALREADY_EXISTS )
	{
		if ( ! *OpenedExisting )
		{
			//
			// Inconsistency: a new section was created, yet the
			// event already existed. Fail.
			//
			Status = STATUS_OBJECT_NAME_COLLISION;
			goto Cleanup;
		}
		else
		{
			*OpenedExisting = TRUE;
		}
	}

	Port->EventPair.Peer = CreateEvent(
		SecurityAttributes,
		FALSE,
		FALSE,
		*OpenedExisting ? ServerEventName : ClientEventName );
	if ( Port->EventPair.Peer == NULL )
	{
		Status = NTSTATUS_QLPC_CANNOT_CREATE_EVPAIR;
		goto Cleanup;
	}
	else if ( GetLastError() == ERROR_ALREADY_EXISTS )
	{
		if ( ! *OpenedExisting )
		{
			//
			// Inconsistency: a new section was created, yet the
			// event already existed. Fail.
			//
			Status = STATUS_OBJECT_NAME_COLLISION;
			goto Cleanup;
		}
		else
		{
			*OpenedExisting = TRUE;
		}
	}

	*PortHandle = Port;
	Status = STATUS_SUCCESS;

Cleanup:
	if ( Port && ! NT_SUCCESS( Status ) )
	{
		( VOID ) JpqlpcClosePort( Port );
	}

	return Status;
}
Пример #7
0
NDUPDATE_API
BOOL
WINAPI
NdasUpdateGetUpdateInfo(
	IN IBindStatusCallback* pBSC,
	IN LPCTSTR szBaseURL,
	IN PNDUPDATE_SYSTEM_INFO pSystemInformation,
	OUT PNDUPDATE_UPDATE_INFO_V2 pUpdateInformation)
{
	BOOL  fSuccess = FALSE;
	HRESULT hr = E_FAIL;

	DBGPRT_INFO(_FT("BaseURL: %s\n"), szBaseURL);

	TCHAR szUpdateURL[NDUPDATE_MAX_URL];

	if (IsBadReadPtr(pSystemInformation, sizeof(NDUPDATE_SYSTEM_INFO)) ||
		IsBadWritePtr(pUpdateInformation, sizeof(NDUPDATE_UPDATE_INFO_V2)))
	{
		SetLastError(ERROR_INVALID_PARAMETER);
		return FALSE;
	}

	// create URL
	hr = StringCchPrintf(
		szUpdateURL,
		NDUPDATE_MAX_URL,
		_T("%s?REV=%d&PLATFORM=%d&MAJOR=%d&MINOR=%d&BUILD=%d&PRIV=%d&VENDOR=%d&LANGUAGESET=%d&CT=%08X"),
		szBaseURL,
		NDAS_UPDATE_REV,
		pSystemInformation->dwPlatform,
		pSystemInformation->ProductVersion.wMajor,
		pSystemInformation->ProductVersion.wMinor,
		pSystemInformation->ProductVersion.wBuild,
		pSystemInformation->ProductVersion.wPrivate,
		pSystemInformation->dwVendor,
		pSystemInformation->dwLanguageSet,
		GetTickCount());

	if (FAILED(hr)) {
		DBGPRT_ERR_EX(_FT("Making URL failed, too long?, hr=%08X: "), hr);
		return FALSE;
	}

	DBGPRT_INFO(_FT("UpdateURL: %s\n"), szUpdateURL);

	TCHAR szDownloadedFileName[MAX_PATH] = {0};
	hr = ::URLDownloadToCacheFile(
		NULL,
		szUpdateURL,
		szDownloadedFileName,
		sizeof(szDownloadedFileName),
		0,
		pBSC);

	if (FAILED(hr)) {
		DBGPRT_ERR_EX(_FT("Downloading a file failed.\n"));
		::SetLastError(hr);
		return FALSE;
	}

	DBGPRT_INFO(_FT("Downloaded to %s.\n"), szDownloadedFileName);

	TCHAR szINIFileName[MAX_PATH];
	TCHAR szINIString[NDUPDATE_STRING_SIZE] = {0};  
	UINT uiINIValue;

	GetPrivateProfileString(
		UPDATER_SECTION, 
		_T("CLASS"), 
		_T(""), 
		szINIString, 
		NDUPDATE_STRING_SIZE, 
		szDownloadedFileName);

	DBGPRT_INFO(_T("UPDATER CLASS: %s\n"), szINIString);

	if (0 != lstrcmpi(szINIString, UPDATE_CLASS_STRING)) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	uiINIValue = ::GetPrivateProfileInt(
		UPDATER_SECTION, 
		_T("REVISION"), 
		0, 
		szDownloadedFileName);

	DBGPRT_INFO(_T("UPDATER REVISION: %d\n"), uiINIValue);

	if (NDAS_UPDATE_REV != uiINIValue) {
		SetLastError(NDUPDATE_ERROR_INVALID_UPDATE_VERSION_FROM_SERVER);
		return FALSE;
	}

	// read patch information
	uiINIValue = ::GetPrivateProfileInt(
		UPDATE_SECTION, 
		_T("NEED_UPDATE"), 
		0xFFFFFFFF,
		szDownloadedFileName);

	DBGPRT_INFO(_T("UPDATE NEED_UPDATE: %d\n"), uiINIValue);

	if (0xFFFFFFFF == uiINIValue) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	//
	// we should return TRUE even if update is not required!
	//
	if (0 == uiINIValue) {
		pUpdateInformation->fNeedUpdate = FALSE;
		return TRUE;
	}

	//
	// Update!
	//

	pUpdateInformation->fNeedUpdate = TRUE;

	uiINIValue = GetPrivateProfileInt(
		UPDATE_SECTION, 
		_T("PRODUCT_VERSION_MAJOR"),
		0xFFFFFFFF, 
		szDownloadedFileName);

	if (0xFFFFFFFF == uiINIValue) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	pUpdateInformation->ProductVersion.wMajor = (WORD) uiINIValue;

	uiINIValue = GetPrivateProfileInt(
		UPDATE_SECTION, 
		_T("PRODUCT_VERSION_MINOR"), 
		0xFFFFFFFF, 
		szDownloadedFileName);

	if (0xFFFFFFFF == uiINIValue) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	pUpdateInformation->ProductVersion.wMinor = (WORD) uiINIValue;

	uiINIValue = GetPrivateProfileInt(
		UPDATE_SECTION, 
		_T("PRODUCT_VERSION_BUILD"), 
		0xFFFFFFFF, 
		szDownloadedFileName);

	if (0xFFFFFFFF == uiINIValue) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	pUpdateInformation->ProductVersion.wBuild = (WORD) uiINIValue;

	uiINIValue = GetPrivateProfileInt(
		UPDATE_SECTION, 
		_T("PRODUCT_VERSION_PRIVATE"), 
		0xFFFFFFFF, 
		szDownloadedFileName);

	if (0xFFFFFFFF == uiINIValue) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	pUpdateInformation->ProductVersion.wPrivate = (WORD) uiINIValue;

	//
	// Update File URL
	//

	uiINIValue = GetPrivateProfileInt(
		UPDATE_SECTION, _T("FILESIZE"), 
		0xFFFFFFFF, szDownloadedFileName);

	if (0xFFFFFFFF == uiINIValue) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	pUpdateInformation->dwFullSetupFileSize = (DWORD) uiINIValue;

	pUpdateInformation->szFullSetupFileURL[0] = _T('\0');

	(VOID) GetPrivateProfileString(
		UPDATE_SECTION, _T("FILE_URL"), _T(""), 
		pUpdateInformation->szFullSetupFileURL, 
		NDUPDATE_MAX_URL, szDownloadedFileName);

	if (_T('\0') == pUpdateInformation->szFullSetupFileURL[0]) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	(VOID) GetPrivateProfileString(
		UPDATE_SECTION,	_T("FILENAME"),	_T(""),
		pUpdateInformation->szFullSetupFileName, 
		MAX_PATH, szDownloadedFileName);

	if (_T('\0') == pUpdateInformation->szFullSetupFileName[0]) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	//
	// Update Reference File URL
	//
	pUpdateInformation->szRefURL[0] = _T('\0');

	GetPrivateProfileString(
		UPDATE_SECTION, 
		_T("REF_URL"), 
		_T(""), 
		pUpdateInformation->szRefURL, 
		NDUPDATE_MAX_URL, 
		szDownloadedFileName);

	if (_T('\0') == pUpdateInformation->szRefURL[0]) {
		SetLastError(NDUPDATE_ERROR_INVALID_SERVER_RESPONSE);
		return FALSE;
	}

	//
	// Patch File URL if available
	//

	GetPrivateProfileString(
		UPDATE_SECTION, _T("PATCH_FILE_URL"), _T(""), 
		pUpdateInformation->szPatchFileURL, 
		NDUPDATE_MAX_URL, szDownloadedFileName);

	GetPrivateProfileString(
		UPDATE_SECTION, _T("PATCH_FILE_NAME"), _T(""),
		pUpdateInformation->szPatchFileName,
		MAX_PATH, szDownloadedFileName);

	pUpdateInformation->dwPatchFileSize = GetPrivateProfileInt(
		UPDATE_SECTION, _T("PATCH_FILE_SIZE"), 
		0, szDownloadedFileName);

	if (0 == pUpdateInformation->dwPatchFileSize) 
	{
		// ignorable error
		pUpdateInformation->szPatchFileURL[0] = _T('\0');
		pUpdateInformation->szPatchFileName[0] = _T('\0');
		pUpdateInformation->dwPatchFileSize = 0;
	}

	//
	// SmallSetup File URL
	//

	// URL
	GetPrivateProfileString(
		UPDATE_SECTION, _T("SMALL_SETUP_FILE_URL"), _T(""), 
		pUpdateInformation->szSmallSetupFileURL, 
		NDUPDATE_MAX_URL, szDownloadedFileName);

	// FileName
	GetPrivateProfileString(
		UPDATE_SECTION, _T("SMALL_SETUP_FILE_NAME"), _T(""),
		pUpdateInformation->szSmallSetupFileName,
		MAX_PATH, szDownloadedFileName);

	// FileSize
	pUpdateInformation->dwPatchFileSize = (DWORD) GetPrivateProfileInt(
		UPDATE_SECTION, _T("SMALL_SETUP_FILE_SIZE"), 
		0, szDownloadedFileName);

	if (0 == pUpdateInformation->dwPatchFileSize) {
		// ignorable error
		pUpdateInformation->szSmallSetupFileURL[0] = _T('\0');
		pUpdateInformation->szSmallSetupFileName[0] = _T('\0');
	}

	// Failure will retain the downloaded file to check error!
	// Ignore error on delete

	(VOID) DeleteUrlCacheEntry(szDownloadedFileName);

	return TRUE;
}
Пример #8
0
VOID
PerfUpdateCountersReport(
	IN HWND hWndCounters,
	IN PPERF_TASK_CONTEXT TaskContext 
	)
{
	PPERF_INFORMATION Perf;
	LVITEM item = {0};
	WCHAR Buffer[MAX_PATH];
	double IoTotal;
	double Value;

	Perf = &TaskContext->Information;

	//
	// PerfCounterCpuTotal
	//

	item.mask = LVIF_TEXT;
	item.iItem = PerfCounterCpuTotal;

	item.iSubItem = PerfColumnValue;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f", Perf->CpuTotalUsage * 100); 
	StringCchCat(Buffer, MAX_PATH - 1, L"%");
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnAverage;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f", TaskContext->CpuHistory.Average); 
	StringCchCat(Buffer, MAX_PATH - 1, L"%");
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnMaximum;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f", TaskContext->CpuHistory.MaximumValue);
	StringCchCat(Buffer, MAX_PATH - 1, L"%");
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	//
	// PerfCounterPrivateBytes
	//

	item.iItem = PerfCounterPrivateBytes;

	item.iSubItem = PerfColumnValue;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f MB", 
		           (Perf->PrivateDelta.Value * 1.0) / (1024 * 1024 * 1.0)); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnAverage;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f MB", 
		            (TaskContext->MemoryHistory.Average * 1.0) / (1024 * 1024 * 1.0)); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnMaximum;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f MB", 
		            (TaskContext->MemoryHistory.MaximumValue * 1.0) / (1024 * 1024 * 1.0)); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	//
	// PerfCounterWorkingSet
	//

	item.iItem = PerfCounterWorkingSet;

	item.iSubItem = PerfColumnValue;
	Value = (Perf->WorkingSetDelta.Value * 1.0) / ((1024 * 1024) * 1.0);
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f MB", Value); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnAverage;
	item.pszText = L"N/A";
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnMaximum;
	Value = (Perf->WorkingSetPeak * 1.0) / ((1024 * 1024) * 1.0);
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f MB", Value); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	//
	// PerfCounterKernelHandles
	//

	item.iItem = PerfCounterKernelHandles;

	item.iSubItem = PerfColumnValue;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%u", Perf->KernelHandles); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnAverage;
	item.pszText = L"N/A";
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnMaximum;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%u", Perf->KernelHandlesPeak); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	//
	// PerfCounterUserHandles
	//

	item.iItem = PerfCounterUserHandles;

	item.iSubItem = PerfColumnValue;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%u", Perf->UserHandles); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnAverage;
	item.pszText = L"N/A";
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnMaximum;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%u", Perf->UserHandlesPeak); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	//
	// PerfCounterGdiHandles
	//

	item.iItem = PerfCounterGdiHandles;

	item.iSubItem = PerfColumnValue;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%u", Perf->GdiHandles); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnAverage;
	item.pszText = L"N/A";
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnMaximum;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%u", Perf->GdiHandlesPeak); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	//
	// PerfCounterIoTotal
	//

	item.iItem = PerfCounterIoTotal;

	item.iSubItem = PerfColumnValue;
	IoTotal = (FLOAT)(Perf->IoReadDelta.Delta + Perf->IoWriteDelta.Delta + Perf->IoOtherDelta.Delta) / (1024 * 1024);
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f MB/Sec", IoTotal); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnAverage;
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f MB/Sec", TaskContext->IoHistory.Average / (1024 * 1024)); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

	item.iSubItem = PerfColumnMaximum;
	IoTotal = (FLOAT)TaskContext->IoHistory.MaximumValue / (1024 * 1024);
	StringCchPrintf(Buffer, MAX_PATH - 1, L"%.2f MB/Sec", IoTotal); 
	item.pszText = Buffer;
	ListView_SetItem(hWndCounters, &item);

}
Пример #9
0
/*
 * return the text associated with a given column of a given row.
 * Return a pointer that does not need to be freed after use - ie
 * a pointer into our data somewhere, not a copy
 */
LPSTR
view_gettext(VIEW view, long row, int col)
{
    int line;
    int state;
    LPSTR pstr;
    HRESULT hr;

    pstr = NULL;   /* kill spurious diagnostic */
    if (view == NULL) {
        return(NULL);
    }

    ViewEnter();

    if ((0 > row) || (row >= view->rows)) {
        ViewLeave();
        return(NULL);
    }

    if (view->bExpand) {
        /* we are in expand mode */

        state = section_getstate(view->pLines[row].section);

        switch (col) {
        case 0:
            /* row nr */

            /* line numbers can be from either original file
             * this is a menu-selectable option
             */
            line = 0;
            switch (line_numbers) {
            case IDM_NONRS:
                pstr = NULL;
                break;

            case IDM_LNRS:
                line = view->pLines[row].nr_left;
                if (state == STATE_MOVEDRIGHT
                    || state == STATE_SIMILARRIGHT) {
                    line = -line;
                }
                break;

            case IDM_RNRS:
                line = view->pLines[row].nr_right;
                if (state == STATE_MOVEDLEFT
                    || state == STATE_SIMILARLEFT) {
                    line = -line;
                }
                break;
            }
            if (line == 0) {
                ViewLeave();
                return(NULL);
            }

            if (line < 0) {
                /* lines that are moved appear twice.
                 * show the correct-sequence line nr
                 * for the out-of-seq. copy in brackets.
                 */
                hr = StringCchPrintf(view->nrtext, 12, "(%d)", abs(line));
                if (FAILED(hr)) {
                    OutputError(hr, IDS_SAFE_PRINTF);
                    return(NULL);
                }

            } else {
                hr = StringCchPrintf(view->nrtext, 12, "%d", line);
                if (FAILED(hr)) {
                    OutputError(hr, IDS_SAFE_PRINTF);
                    return(NULL);
                }
            }
            pstr = view->nrtext;
            break;

        case 1:
            /* tag text - represents the state of the line */


            switch (state) {
            case STATE_SAME:
                pstr = "    ";
                break;

            case STATE_LEFTONLY:
            case STATE_SIMILARLEFT:
                pstr = " <! ";
                break;

            case STATE_RIGHTONLY:
            case STATE_SIMILARRIGHT:
                pstr = " !> ";
                break;

            case STATE_MOVEDLEFT:
                pstr = " <- ";
                break;

            case STATE_MOVEDRIGHT:
                pstr = " -> ";
                break;
            }
            break;

        case 2:
            /* main text - line */
            pstr = line_gettext(view->pLines[row].line);
            break;
        }
    } else {
        /* outline mode */
        switch (col) {
        case 0:
            /* row number - just the line number */
            hr = StringCchPrintf(view->nrtext, 12, "%d", row+1);
            if (FAILED(hr)) {
                OutputError(hr, IDS_SAFE_PRINTF);
                return(NULL);
            }
            pstr = view->nrtext;
            break;

        case 1:
            /* tag */
            pstr = compitem_gettext_tag(view->pItems[row]);
            break;

        case 2:
            /* result text */
            pstr = compitem_gettext_result(view->pItems[row]);
            break;
        }
    }
    ViewLeave();
    return(pstr);
}
Пример #10
0
STDAPI
AMovieSetupRegisterServer( CLSID   clsServer
                         , LPCWSTR szDescription
                         , LPCWSTR szFileName
                         , LPCWSTR szThreadingModel = L"Both"
                         , LPCWSTR szServerType     = L"InprocServer32" )
{
  // temp buffer
  //
  TCHAR achTemp[MAX_PATH];

  // convert CLSID uuid to string and write
  // out subkey as string - CLSID\{}
  //
  OLECHAR szCLSID[CHARS_IN_GUID];
  HRESULT hr = StringFromGUID2( clsServer
                              , szCLSID
                              , CHARS_IN_GUID );
  ASSERT( SUCCEEDED(hr) );

  // create key
  //
  HKEY hkey;

  (void)StringCchPrintf( achTemp, NUMELMS(achTemp), CLSID_KEY_FORMAT_STRING, szCLSID );
  
  LONG lreturn = RegCreateKey( HKEY_CLASSES_ROOT
                             , (LPCTSTR)achTemp
                             , &hkey              );
  if( ERROR_SUCCESS != lreturn )
  {
    return AmHresultFromWin32(lreturn);
  }

  // set description string
  //

  (void)ConvertUnicodeStringToTCHARString( achTemp, NUMELMS(achTemp), szDescription );
  lreturn = RegSetValue( hkey
                       , (LPCTSTR)NULL
                       , REG_SZ
                       , achTemp
                       , sizeof(achTemp) );
  if( ERROR_SUCCESS != lreturn )
  {
    RegCloseKey( hkey );
    return AmHresultFromWin32(lreturn);
  }

  // create CLSID\\{"CLSID"}\\"ServerType" key,
  // using key to CLSID\\{"CLSID"} passed back by
  // last call to RegCreateKey().
  //
  HKEY hsubkey;

  (void)ConvertUnicodeStringToTCHARString( achTemp, NUMELMS(achTemp), szServerType );
  lreturn = RegCreateKey( hkey
                        , achTemp
                        , &hsubkey     );
  if( ERROR_SUCCESS != lreturn )
  {
    RegCloseKey( hkey );
    return AmHresultFromWin32(lreturn);
  }

  // set Server string
  //
  (void)ConvertUnicodeStringToTCHARString( achTemp, NUMELMS(achTemp), szFileName );
  lreturn = RegSetValue( hsubkey
                       , (LPCTSTR)NULL
                       , REG_SZ
                       , (LPCTSTR)achTemp
                       , sizeof(TCHAR) * (lstrlen(achTemp)+1) );
  if( ERROR_SUCCESS != lreturn )
  {
    RegCloseKey( hkey );
    RegCloseKey( hsubkey );
    return AmHresultFromWin32(lreturn);
  }

  (void)ConvertUnicodeStringToTCHARString( achTemp, NUMELMS(achTemp), szThreadingModel );
  lreturn = RegSetValueEx( hsubkey
                         , TEXT("ThreadingModel")
                         , 0L
                         , REG_SZ
                         , (CONST BYTE *)achTemp
                         , sizeof(TCHAR) * (lstrlen(achTemp)+1) );

  // close hkeys
  //
  RegCloseKey( hkey );
  RegCloseKey( hsubkey );

  // and return
  //
  return HRESULT_FROM_WIN32(lreturn);

}
Пример #11
0
void CExtentMonitorTextService::_DumpExtent(TfEditCookie ec, ITfContext *pContext, UINT nEventId)
{
    if (!_pMemStream)
        return;

    ClearStream(_pMemStream);

    switch (nEventId)
    {
        case DE_EVENTID_ACTIVATE:        
            AddStringToStream(_pMemStream, L"Event: Activate\r\n"); 
            break;
        case DE_EVENTID_ONSETFOCUS:
            AddStringToStream(_pMemStream, L"Event: OnSetFocus\r\n"); 
            break;
        case DE_EVENTID_ONENDEDIT:
            AddStringToStream(_pMemStream, L"Event: OnEndEdit\r\n"); 
            break;
        case DE_EVENTID_ONLAYOUTCHANGE:
            AddStringToStream(_pMemStream, L"Event: OnLayoutChange\r\n"); 
            break;
        case DE_EVENTID_FROMLANGUAGEBAR:
            AddStringToStream(_pMemStream, L"Event: From LanguageBar\r\n"); 
            break;
        default:
            AddStringToStream(_pMemStream, L"Event: Unknoen\r\n"); 
            break;
    }

    WCHAR sz[512];
    ITfContextView *pView = NULL;
    TF_SELECTION sel;

    memset(&_rcStartPos , 0, sizeof(RECT));
    memset(&_rcEndPos , 0, sizeof(RECT));
    memset(&_rcSelection , 0, sizeof(RECT));
    memset(&_rcView , 0, sizeof(RECT));

    if (SUCCEEDED(pContext->GetActiveView(&pView)))
    {
         ITfRange *pRange;
         RECT rc;
         BOOL fClipped;
         HWND hwnd;

         AddStringToStream(_pMemStream, L"Wnd Handle - ");
         if (SUCCEEDED(pView->GetWnd(&hwnd)))
         {
             WCHAR szWndClass[32];
             if (IsWindow(hwnd)) 
             {
                 GetClassNameW(hwnd, szWndClass, ARRAYSIZE(szWndClass));
                 StringCchPrintf(sz, ARRAYSIZE(sz), L"%08x %s\r\n", (DWORD)(ULONG_PTR)hwnd, szWndClass);
                 AddStringToStream(_pMemStream, sz);
             }
             else
             {
                 AddStringToStream(_pMemStream, L"null window handle\r\n");
             }
         }

         AddStringToStream(_pMemStream, L"Screen Ext\r\n");
         if (SUCCEEDED(pView->GetScreenExt(&rc)))
         {
             StringCchPrintf(sz, ARRAYSIZE(sz), L"    (%d, %d, %d, %d) - (%d, %d)\r\n", rc.left, rc.top, rc.right, rc.bottom, rc.right - rc.left, rc.bottom - rc.top);
             AddStringToStream(_pMemStream, sz);
             _rcView = rc;
         }

         AddStringToStream(_pMemStream, L"Start Pos\r\n");
         if (SUCCEEDED(pContext->GetStart(ec, &pRange)))
         {
             if (SUCCEEDED(pView->GetTextExt(ec, pRange, &rc, &fClipped)))
             {
                 StringCchPrintf(sz, ARRAYSIZE(sz), L"    (%d, %d, %d, %d) - (%d, %d) %s\r\n", rc.left, rc.top, rc.right, rc.bottom, rc.right - rc.left, rc.bottom - rc.top, fClipped ? L"Clipped" : L"");

                 AddStringToStream(_pMemStream, sz);
                 _rcStartPos = rc;
             }

             pRange->Release();
         }

         AddStringToStream(_pMemStream, L"End Pos\r\n");
         if (SUCCEEDED(pContext->GetEnd(ec, &pRange)))
         {
             if (SUCCEEDED(pView->GetTextExt(ec, pRange, &rc, &fClipped)))
             {
                 StringCchPrintf(sz, ARRAYSIZE(sz), L"    (%d, %d, %d, %d) - (%d, %d) %s\r\n", rc.left, rc.top, rc.right, rc.bottom, rc.right - rc.left, rc.bottom - rc.top, fClipped ? L"Clipped" : L"");

                 AddStringToStream(_pMemStream, sz);
                 _rcEndPos = rc;
             }

             pRange->Release();
         }

         AddStringToStream(_pMemStream, L"Selection Pos\r\n");
         ULONG cFetched;
         if (SUCCEEDED(pContext->GetSelection(ec, 0, 1, &sel, &cFetched)))
         {
             if (sel.range)
             {
                 if (SUCCEEDED(pView->GetTextExt(ec, sel.range, &rc, &fClipped)))
                 {
                     StringCchPrintf(sz, ARRAYSIZE(sz), L"    (%d, %d, %d, %d) - (%d, %d) %s\r\n", rc.left, rc.top, rc.right, rc.bottom, rc.right - rc.left, rc.bottom - rc.top, fClipped ? L"Clipped" : L"");

                     AddStringToStream(_pMemStream, sz);
                     _rcSelection = rc;
                 }
                 AddStringToStream(_pMemStream, L"    ");
                 _DumpRange(ec, sel.range);
                 AddStringToStream(_pMemStream, L"\r\n");
                 sel.range->Release();
             }
         }

         AddStringToStream(_pMemStream, L"Char Pos\r\n");
         if (SUCCEEDED(pContext->GetStart(ec, &pRange)))
         {
             LONG cch;
             memset(&_rcRanges[0] , 0, sizeof(RECT) * ARRAYSIZE(_rcRanges));
             if (SUCCEEDED(pRange->ShiftEnd(ec, 1, &cch, NULL)) && cch)
             {
                 for (int i = 0; i < ARRAYSIZE(_rcRanges); i++)
                 {
                     if (SUCCEEDED(pView->GetTextExt(ec, pRange, &rc, &fClipped)))
                     {
                         StringCchPrintf(sz, ARRAYSIZE(sz), L"    (%d, %d, %d, %d) - (%d, %d) %s", rc.left, rc.top, rc.right, rc.bottom, rc.right - rc.left, rc.bottom - rc.top, fClipped ? L"Clipped" : L"");
                         AddStringToStream(_pMemStream, sz);

                         AddStringToStream(_pMemStream, L" ");
                         ITfRange *pRangeTmp;
                         if (SUCCEEDED(pRange->Clone(&pRangeTmp)))
                         {
                             _DumpRange(ec, pRangeTmp);
                             pRangeTmp->Release();
                         }
                         AddStringToStream(_pMemStream, L"\r\n");

                         OffsetRect(&rc, 0 - _rcView.left, 0 - _rcView.top);
                         _rcRanges[i] = rc;
                     }

                     if (FAILED(pRange->ShiftEnd(ec, 1, &cch, NULL)) || !cch)
                         break;

                     if (FAILED(pRange->ShiftStart(ec, 1, &cch, NULL)) || !cch)
                         break;
                 }

             }
             pRange->Release();
         }

         pView->Release();
    }

    _EnsurePopupWindow();

    if (IsShownExtentVisualWindows())
        _UpdateExtentVisualWindows();

    if (IsShownRangeExtentViewer())
        _UpdateRangeExtentViewer();

    return;
}
Пример #12
0
/**
 * @brief Computer::GetOsDisplayString
 *
 * Recupera string do Sistema Operacional
 * Fonte: http://forum.codecall.net/topic/60159-how-to-determine-windows-operating-system-version-information-using-visual-c/
 *
 * @param pszOS
 * @return Verdadeiro se identificou ou falso se não conseguiu
 */
BOOL Computer::GetOsDisplayString(LPTSTR pszOS)
{
    OSVERSIONINFOEX osvi;
    SYSTEM_INFO si;
    PGETSYSTEMINFO pGetSystemInfo;
    PGETPRODUCTINFO pGetProductInfo;
    BOOL bOsVersionInfoEx;
    DWORD dwType;

    ZeroMemory(&si, sizeof(SYSTEM_INFO));
    ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));

    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

    if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
       return 1;

    // Call GetNativeSystemInfo if supported or GetSystemInfo otherwise.

    pGetSystemInfo = (PGETSYSTEMINFO ) GetProcAddress(
       GetModuleHandle(TEXT("kernel32.dll")),
       "GetNativeSystemInfo");
    if(NULL != pGetSystemInfo)
       pGetSystemInfo(&si);
    else GetSystemInfo(&si);

    if ( VER_PLATFORM_WIN32_NT==osvi.dwPlatformId &&
         osvi.dwMajorVersion > 4 )
    {
       StringCchCopy(pszOS, BUFSIZE, TEXT("Microsoft "));

       // Test for the specific product.

       if ( osvi.dwMajorVersion == 6 )
       {
          if( osvi.dwMinorVersion == 0 )
          {
             if( osvi.wProductType == VER_NT_WORKSTATION )
                 StringCchCat(pszOS, BUFSIZE, TEXT("Windows Vista "));
             else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2008 " ));
          }

          if ( osvi.dwMinorVersion == 1 )
          {
             if( osvi.wProductType == VER_NT_WORKSTATION )
                 StringCchCat(pszOS, BUFSIZE, TEXT("Windows 7 "));
             else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2008 R2 " ));
          }

          pGetProductInfo = (PGETPRODUCTINFO) GetProcAddress(
             GetModuleHandle(TEXT("kernel32.dll")),
             "GetProductInfo");

          pGetProductInfo( osvi.dwMajorVersion, osvi.dwMinorVersion, 0, 0, &dwType);

          switch( dwType )
          {
             case PRODUCT_ULTIMATE:
                StringCchCat(pszOS, BUFSIZE, TEXT("Ultimate" ));
                break;
             case 0x00000030:
                StringCchCat(pszOS, BUFSIZE, TEXT("Professional" ));
                break;
             case PRODUCT_HOME_PREMIUM:
                StringCchCat(pszOS, BUFSIZE, TEXT("Home Premium" ));
                break;
             case PRODUCT_HOME_BASIC:
                StringCchCat(pszOS, BUFSIZE, TEXT("Home Basic" ));
                break;
             case PRODUCT_ENTERPRISE:
                StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise" ));
                break;
             case PRODUCT_BUSINESS:
                StringCchCat(pszOS, BUFSIZE, TEXT("Business" ));
                break;
             case PRODUCT_STARTER:
                StringCchCat(pszOS, BUFSIZE, TEXT("Starter" ));
                break;
             case PRODUCT_CLUSTER_SERVER:
                StringCchCat(pszOS, BUFSIZE, TEXT("Cluster Server" ));
                break;
             case PRODUCT_DATACENTER_SERVER:
                StringCchCat(pszOS, BUFSIZE, TEXT("Datacenter" ));
                break;
             case PRODUCT_DATACENTER_SERVER_CORE:
                StringCchCat(pszOS, BUFSIZE, TEXT("Datacenter(core installation)" ));
                break;
             case PRODUCT_ENTERPRISE_SERVER:
                StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise" ));
                break;
             case PRODUCT_ENTERPRISE_SERVER_CORE:
                StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise (core installation)" ));
                break;
             case PRODUCT_ENTERPRISE_SERVER_IA64:
                StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise for Itanium-based Systems" ));
                break;
             case PRODUCT_SMALLBUSINESS_SERVER:
                StringCchCat(pszOS, BUFSIZE, TEXT("Small Business Server" ));
                break;
             case PRODUCT_SMALLBUSINESS_SERVER_PREMIUM:
                StringCchCat(pszOS, BUFSIZE, TEXT("Small Business Server Premium" ));
                break;
             case PRODUCT_STANDARD_SERVER:
                StringCchCat(pszOS, BUFSIZE, TEXT("Standard" ));
                break;
             case PRODUCT_STANDARD_SERVER_CORE:
                StringCchCat(pszOS, BUFSIZE, TEXT("Standard (core installation)" ));
                break;
             case PRODUCT_WEB_SERVER:
                StringCchCat(pszOS, BUFSIZE, TEXT("Web Server" ));
                break;
          }
       }

       if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
       {
          if( GetSystemMetrics(SM_SERVERR2) )
             StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Server 2003 R2, "));
          else if ( osvi.wSuiteMask & VER_SUITE_STORAGE_SERVER )
             StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Storage Server 2003"));
          else if ( osvi.wSuiteMask & 0x00008000  )
             StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Home Server"));
          else if( osvi.wProductType == VER_NT_WORKSTATION &&
                   si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)
          {
             StringCchCat(pszOS, BUFSIZE, TEXT( "Windows XP Professional x64 Edition"));
          }
          else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2003, "));

          // Test for the server type.
          if ( osvi.wProductType != VER_NT_WORKSTATION )
          {
             if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_IA64 )
             {
                 if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                    StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Edition for Itanium-based Systems" ));
                 else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                    StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise Edition for Itanium-based Systems" ));
             }

             else if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64 )
             {
                 if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                    StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter x64 Edition" ));
                 else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                    StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise x64 Edition" ));
                 else StringCchCat(pszOS, BUFSIZE, TEXT( "Standard x64 Edition" ));
             }

             else
             {
                 if ( osvi.wSuiteMask & VER_SUITE_COMPUTE_SERVER )
                    StringCchCat(pszOS, BUFSIZE, TEXT( "Compute Cluster Edition" ));
                 else if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                    StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Edition" ));
                 else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                    StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise Edition" ));
                 else if ( osvi.wSuiteMask & VER_SUITE_BLADE )
                    StringCchCat(pszOS, BUFSIZE, TEXT( "Web Edition" ));
                 else StringCchCat(pszOS, BUFSIZE, TEXT( "Standard Edition" ));
             }
          }
       }

       if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
       {
          StringCchCat(pszOS, BUFSIZE, TEXT("Windows XP "));
          if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
             StringCchCat(pszOS, BUFSIZE, TEXT( "Home Edition" ));
          else StringCchCat(pszOS, BUFSIZE, TEXT( "Professional" ));
       }

       if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
       {
          StringCchCat(pszOS, BUFSIZE, TEXT("Windows 2000 "));

          if ( osvi.wProductType == VER_NT_WORKSTATION )
          {
             StringCchCat(pszOS, BUFSIZE, TEXT( "Professional" ));
          }
          else
          {
             if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Server" ));
             else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                StringCchCat(pszOS, BUFSIZE, TEXT( "Advanced Server" ));
             else StringCchCat(pszOS, BUFSIZE, TEXT( "Server" ));
          }
       }

       // Eduardo: 2015-05-29
       // Remove essas informações que são desnecessárias
       return TRUE;

       // Include service pack (if any) and build number.

       //if( _tcslen(osvi.szCSDVersion) > 0 )
       if( size_t(wcslen(osvi.szCSDVersion)) > 0 )
       {
           StringCchCat(pszOS, BUFSIZE, TEXT(" ") );
           StringCchCat(pszOS, BUFSIZE, osvi.szCSDVersion);
       }

       TCHAR buf[80];

       StringCchPrintf( buf, 80, TEXT(" (build %d)"), osvi.dwBuildNumber);
       StringCchCat(pszOS, BUFSIZE, buf);

       if ( osvi.dwMajorVersion >= 6 )
       {
          if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64 )
             StringCchCat(pszOS, BUFSIZE, TEXT( ", 64-bit" ));
          else if (si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_INTEL )
             StringCchCat(pszOS, BUFSIZE, TEXT(", 32-bit"));
       }

       _tprintf(_T("OS Version Information %s\n"), pszOS);
       return TRUE;
    }

    else
    {
       printf( "This sample does not support this version of Windows.\n");
       return FALSE;
    }
}
Пример #13
0
void CSearchDialog::StartSearching()
{
	ShowWindow(GetDlgItem(m_hDlg, IDC_LINK_STATUS), SW_HIDE);
	ShowWindow(GetDlgItem(m_hDlg, IDC_STATIC_STATUS), SW_SHOW);

	m_AwaitingSearchItems.clear();
	m_SearchItemsMapInternal.clear();

	ListView_DeleteAllItems(GetDlgItem(m_hDlg, IDC_LISTVIEW_SEARCHRESULTS));

	TCHAR szBaseDirectory[MAX_PATH];
	TCHAR szSearchPattern[MAX_PATH];

	/* Get the directory and name, and remove leading and
	trailing whitespace. */
	/* TODO: Verify fields. */
	GetDlgItemText(m_hDlg, IDC_COMBO_DIRECTORY, szBaseDirectory,
		SIZEOF_ARRAY(szBaseDirectory));
	PathRemoveBlanks(szBaseDirectory);
	GetDlgItemText(m_hDlg, IDC_COMBO_NAME, szSearchPattern,
		SIZEOF_ARRAY(szSearchPattern));
	PathRemoveBlanks(szSearchPattern);

	BOOL bSearchSubFolders = IsDlgButtonChecked(m_hDlg, IDC_CHECK_SEARCHSUBFOLDERS) ==
		BST_CHECKED;

	BOOL bUseRegularExpressions = IsDlgButtonChecked(m_hDlg, IDC_CHECK_USEREGULAREXPRESSIONS) ==
		BST_CHECKED;

	BOOL bCaseInsensitive = IsDlgButtonChecked(m_hDlg, IDC_CHECK_CASEINSENSITIVE) ==
		BST_CHECKED;

	/* Turn search patterns of the form '???' into '*???*', and
	use this modified string to search. */
	if(!bUseRegularExpressions && lstrlen(szSearchPattern) > 0)
	{
		if(szSearchPattern[0] != '*' &&
			szSearchPattern[lstrlen(szSearchPattern) - 1] != '*')
		{
			TCHAR szTemp[MAX_PATH];

			StringCchPrintf(szTemp, SIZEOF_ARRAY(szTemp), _T("*%s*"),
				szSearchPattern);
			StringCchCopy(szSearchPattern, SIZEOF_ARRAY(szSearchPattern),
				szTemp);
		}
	}

	DWORD dwAttributes = 0;

	if(IsDlgButtonChecked(m_hDlg, IDC_CHECK_ARCHIVE) == BST_CHECKED)
		dwAttributes |= FILE_ATTRIBUTE_ARCHIVE;

	if(IsDlgButtonChecked(m_hDlg, IDC_CHECK_HIDDEN) == BST_CHECKED)
		dwAttributes |= FILE_ATTRIBUTE_HIDDEN;

	if(IsDlgButtonChecked(m_hDlg, IDC_CHECK_READONLY) == BST_CHECKED)
		dwAttributes |= FILE_ATTRIBUTE_READONLY;

	if(IsDlgButtonChecked(m_hDlg, IDC_CHECK_SYSTEM) == BST_CHECKED)
		dwAttributes |= FILE_ATTRIBUTE_SYSTEM;

	m_pSearch = new CSearch(m_hDlg, szBaseDirectory, szSearchPattern,
		dwAttributes, bUseRegularExpressions, bCaseInsensitive, bSearchSubFolders);
	m_pSearch->AddRef();

	/* Save the search directory and search pattern (only if they are not
	the same as the most recent entry). */
	BOOL bSaveEntry = FALSE;

	if(m_sdps->m_pSearchDirectories->empty() ||
		lstrcmp(szBaseDirectory, m_sdps->m_pSearchDirectories->begin()->c_str()) != 0)
	{
		bSaveEntry = TRUE;
	}

	if(bSaveEntry)
	{
		SaveEntry(IDC_COMBO_DIRECTORY, *m_sdps->m_pSearchDirectories);
	}

	bSaveEntry = FALSE;

	if(m_sdps->m_pSearchPatterns->empty() ||
		lstrcmp(szSearchPattern, m_sdps->m_pSearchPatterns->begin()->c_str()) != 0)
	{
		bSaveEntry = TRUE;
	}

	if(bSaveEntry)
	{
		SaveEntry(IDC_COMBO_NAME, *m_sdps->m_pSearchPatterns);
	}

	GetDlgItemText(m_hDlg, IDSEARCH, m_szSearchButton, SIZEOF_ARRAY(m_szSearchButton));

	TCHAR szTemp[64];

	LoadString(GetInstance(), IDS_STOP, szTemp, SIZEOF_ARRAY(szTemp));
	SetDlgItemText(m_hDlg, IDSEARCH, szTemp);

	m_bSearching = TRUE;

	/* Create a background thread, and search using it... */
	HANDLE hThread = CreateThread(NULL, 0, NSearchDialog::SearchThread,
		reinterpret_cast<LPVOID>(m_pSearch), 0, NULL);
	CloseHandle(hThread);
}
Пример #14
0
static BOOL pOpenDevice(IN LPCTSTR DriverName, HANDLE * lphDevice )
{
	TCHAR    completeDeviceName[MAX_PATH];
	HANDLE   hDevice;

	HRESULT hr = S_FALSE;

	//
	// Create a \\.\XXX device name that CreateFile can use
	//
	// NOTE: We're making an assumption here that the driver
	//       has created a symbolic link using it's own name
	//       (i.e. if the driver has the name "XXX" we assume
	//       that it used IoCreateSymbolicLink to create a
	//       symbolic link "\DosDevices\XXX". Usually, there
	//       is this understanding between related apps/drivers.
	//
	//       An application might also peruse the DEVICEMAP
	//       section of the registry, or use the QueryDosDevice
	//       API to enumerate the existing symbolic links in the
	//       system.
	//

	if( (GetVersion() & 0xFF) >= 5 ) {

		//
		// We reference the global name so that the application can
		// be executed in Terminal Services sessions on Win2K
		//
		hr = StringCchPrintf(completeDeviceName, RTL_NUMBER_OF(completeDeviceName),
			TEXT("\\\\.\\Global\\%s"), DriverName);

		_ASSERTE(SUCCEEDED(hr));

	} else {

		hr = StringCchPrintf(completeDeviceName, RTL_NUMBER_OF(completeDeviceName),
			TEXT("\\\\.\\%s"), DriverName );

		_ASSERTE(SUCCEEDED(hr));

	}

	hDevice = CreateFile(
		completeDeviceName,
		GENERIC_READ,
		0,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL);

	if ( INVALID_HANDLE_VALUE == hDevice) {
		return FALSE;
	}

	// If user wants handle, give it to them.  Otherwise, just close it.
	if ( lphDevice ) {
		*lphDevice = hDevice;
	} else {
		DWORD err = GetLastError();
		CloseHandle(hDevice);
		SetLastError(err);
	}

	return TRUE;
}
Пример #15
0
VOID ShowProcessInfo(HWND hwnd, DWORD dwProcessID) {

   SetWindowText(hwnd, TEXT(""));   // Clear the output box

   CToolhelp th(TH32CS_SNAPALL, dwProcessID);

   // Show Process details
   PROCESSENTRY32 pe = { sizeof(pe) };
   BOOL fOk = th.ProcessFirst(&pe);
   for (; fOk; fOk = th.ProcessNext(&pe)) {
      if (pe.th32ProcessID == dwProcessID) {
         TCHAR szCmdLine[1024];
         if (GetProcessCmdLine(dwProcessID, szCmdLine, _countof(szCmdLine))) {
            AddText(hwnd, 
               TEXT("Command line: %s %s\r\n"), pe.szExeFile, szCmdLine);
         } else {
            AddText(hwnd, TEXT("Filename: %s\r\n"), pe.szExeFile);
         }
         AddText(hwnd, TEXT("   PID=%08X, ParentPID=%08X, ")
            TEXT("PriorityClass=%d, Threads=%d, Heaps=%d\r\n"),
            pe.th32ProcessID, pe.th32ParentProcessID, 
            pe.pcPriClassBase, pe.cntThreads,
            th.HowManyHeaps());
         TCHAR szOwner[MAX_PATH+1];
         if (GetProcessOwner(dwProcessID, szOwner, MAX_PATH)) {
            AddText(hwnd, TEXT("Owner: %s\r\n"), szOwner);
         }

         break;   // No need to continue looping
      }
   }


   // Show Modules in the Process
   // Number of characters to display an address
   AddText(hwnd, TEXT("\r\nModules Information:\r\n")
      TEXT("  Usage  %-*s(%-*s)  %10s  Module\r\n"),
      s_cchAddress, TEXT("BaseAddr"),
      s_cchAddress, TEXT("ImagAddr"), TEXT("Size"));

   MODULEENTRY32 me = { sizeof(me) };
   fOk = th.ModuleFirst(&me);
   for (; fOk; fOk = th.ModuleNext(&me)) {
      if (me.ProccntUsage == 65535) {
         // Module was implicitly loaded and cannot be unloaded
         AddText(hwnd, TEXT("  Fixed"));
      } else {
         AddText(hwnd, TEXT("  %5d"), me.ProccntUsage);
      }

      // Try to format the size in kb.
      TCHAR szFormattedSize[64];
      if (StrFormatKBSize(me.modBaseSize, szFormattedSize, 
         _countof(szFormattedSize)) == NULL)
      {
         StringCchPrintf(szFormattedSize, _countof(szFormattedSize), 
            TEXT("%10u"), me.modBaseSize); 
      }
      
      PVOID pvPreferredBaseAddr = 
         GetModulePreferredBaseAddr(pe.th32ProcessID, me.modBaseAddr);
      if (me.modBaseAddr == pvPreferredBaseAddr) {
         AddText(hwnd, TEXT("  %p %*s   %10s  %s\r\n"), 
            me.modBaseAddr, s_cchAddress, TEXT(""), 
            szFormattedSize, me.szExePath);
      } else {
         AddText(hwnd, TEXT("  %p(%p)  %10s  %s\r\n"), 
            me.modBaseAddr, pvPreferredBaseAddr, 
            szFormattedSize, me.szExePath);
      }
   }

   // Show threads in the process
   AddText(hwnd, TEXT("\r\nThread Information:\r\n")
      TEXT("      TID     Priority\r\n"));
   THREADENTRY32 te = { sizeof(te) };
   fOk = th.ThreadFirst(&te);
   for (; fOk; fOk = th.ThreadNext(&te)) {
      if (te.th32OwnerProcessID == dwProcessID) {
         int nPriority = te.tpBasePri + te.tpDeltaPri;
         if ((te.tpBasePri < 16) && (nPriority > 15)) nPriority = 15;
         if ((te.tpBasePri > 15) && (nPriority > 31)) nPriority = 31;
         if ((te.tpBasePri < 16) && (nPriority <  1)) nPriority =  1;
         if ((te.tpBasePri > 15) && (nPriority < 16)) nPriority = 16;
         AddText(hwnd, TEXT("   %08X       %2d\r\n"), 
            te.th32ThreadID, nPriority);
      }
   }
}
Пример #16
0
int Entrance(const wchar_t *CurDir, const wchar_t *PackName)
{
	int ret = 0;
	DWORD BytesRead;
	HANDLE hPack;
	struct ARC_HEADER ah;
	struct IDX idx;
	wchar_t MsgBuf[MAX_PATH], FileName[MAX_PATH];
	
	hPack = CreateFile(PackName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
	if (hPack == INVALID_HANDLE_VALUE)
	{
		StringCchPrintf(MsgBuf, MAX_PATH, L"无法打开文件%s\r\n", PackName);
		AppendMsg(MsgBuf);
		return -1;
	}

	DWORD idx_pointer = sizeof(ARC_HEADER);		
	DWORD end_of_idx;
	DWORD extract_file_num = 0;

	ReadFile(hPack, &ah.file_num, 4, &BytesRead, NULL);
	ReadFile(hPack, &ah.idx_length, 4, &BytesRead, NULL);

	end_of_idx = ah.idx_length + sizeof(ARC_HEADER);

	while (idx_pointer < end_of_idx)
	{
		SetFilePointer(hPack, idx_pointer, NULL, FILE_BEGIN);

		ReadFile(hPack, &idx.DataSize, 4, &BytesRead, NULL);
		ReadFile(hPack, &idx.DataOffset, 4, &BytesRead, NULL);
		idx.DataOffset += end_of_idx;			// 修正偏移地址

		int i = -1;
		do
		{
			ReadFile(hPack, &FileName[++i], 2, &BytesRead, NULL);
		}while (i<MAX_PATH-1 && FileName[i] != '\0');
		FileName[i] = 0;

		idx_pointer += sizeof(struct IDX) + 2 * (1 + wcslen(FileName));

		PVOID Data = VirtualAlloc(NULL, idx.DataSize, MEM_COMMIT, PAGE_READWRITE);
		if (!Data)
		{
			AppendMsg(L"内存不足!\r\n");
			CloseHandle(hPack);
			return -2;
		}

		SetFilePointer(hPack, idx.DataOffset, NULL, FILE_BEGIN);
		ReadFile(hPack, Data, idx.DataSize, &BytesRead, NULL);
		
		if (IsPnaFile((unsigned char*)Data))
		{
			ExtractPNAPFile((unsigned char*)Data, CurDir, FileName);
			++extract_file_num;
		}
		else if (!SplitFileNameAndSave(CurDir, FileName, Data, idx.DataSize))
			++extract_file_num;

		VirtualFree(Data, 0, MEM_RELEASE);
	}
	StringCchPrintf(MsgBuf, MAX_PATH, L"共提取文件(%d/%d)个   --   %s\r\n",
			extract_file_num, ah.file_num, PackName);
	AppendMsg(MsgBuf);
	return 0;
}
Пример #17
0
/*!
	ツリーのテーブルの存在を確認して、なかったら作成
	@param[in]	ptProfName	なにか
	@return		HRESULT		終了状態コード
*/
HRESULT SqlTreeTableCreate( LPTSTR ptProfName )
{
	//	プロフ情報
	CONST CHAR	cacProfilesTable[] = { ("CREATE TABLE Profiles ( id INTEGER PRIMARY KEY, profname TEXT NOT NULL, rootpath TEXT NULL)") };
	//	初期プロフ名作成
	CONST TCHAR	catProfInsFmt[] = { TEXT("INSERT INTO Profiles ( profname ) VALUES( '%s' )") };
	//	ツリー情報
	CONST CHAR	cacTreeNodeTable[] = { ("CREATE TABLE TreeNode ( id INTEGER PRIMARY KEY, type INTEGER NOT NULL, parentid INTEGER NOT NULL, nodename TEXT NOT NULL )") };
	//	副タブ情報
	CONST CHAR	cacMultiTabTable[] = { ("CREATE TABLE MultiTab ( id INTEGER PRIMARY KEY, filepath TEXT NOT NULL, basename TEXT NOT NULL, dispname TEXT )") };	//	20120613	表示名称追加
	//	使用AA情報
	CONST CHAR	cacArtListTable[]  = { ("CREATE TABLE ArtList ( id INTEGER PRIMARY KEY, count INTEGER NOT NULL, folder TEXT NOT NULL, lastuse  REAL NOT NULL, hash INTEGER NOT NULL, conts BLOB NOT NULL )") };

	CHAR	acBuildVer[SUB_STRING], acText[MAX_PATH];
	TCHAR	atStr[MAX_STRING];
	SYSTEMTIME	stSysTime;

	BYTE	yMode = FALSE;	//	Tableあったとかなかったとか
	INT		rslt;

	UINT	dVersion;
	CHAR	acQuery[MAX_PATH];

#ifdef _DEBUG
	INT		i;
#endif
	sqlite3_stmt	*statement;

	ZeroMemory( acText, sizeof(acText) );

	//	テーブルの存在を確認する
	rslt = sqlite3_prepare( gpDataBase, cacDetectTable, -1, &statement, NULL );
	if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}

	rslt = sqlite3_step( statement );
	if( SQLITE_ROW == rslt )
	{
#ifdef _DEBUG
		for( i = 0; 10 > i; i++ )
		{
			TRACE( TEXT("[TREE] %s"), (LPCTSTR)sqlite3_column_text16( statement, 0 ) );
			rslt = sqlite3_step( statement );
			if( SQLITE_DONE == rslt ){	break;	}
		}
#endif
		rslt = sqlite3_finalize( statement );
		yMode = TRUE;
	}
	//	まず、てーぶりょが有るか無いかについて

	if( !(yMode) )
	{

		TRACE( TEXT("ツリー用テーブルが見つからなかった") );

		rslt = sqlite3_finalize( statement );	//	どっちにしても解除


	//VERSION番号テーブル作成<表には出ない
		rslt = sqlite3_prepare( gpDataBase, cacVersionTable, -1, &statement, NULL );
		if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_step( statement );	//	実行
		if( SQLITE_DONE != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_finalize(statement);

		//VERSION内容を作成	20120613変更
		GetLocalTime( &stSysTime );
		StringCchPrintfA( acBuildVer, SUB_STRING, ("%d.%02d%02d.%02d%02d.%d"), stSysTime.wYear, stSysTime.wMonth, stSysTime.wDay, stSysTime.wHour, stSysTime.wMinute, SUBTAB_NAME_VER );
		StringCchPrintfA( acText, MAX_PATH, cacVerStrInsFmt, SUBTAB_NAME_VER, acBuildVer );
		//	初期データぶち込む
		rslt = sqlite3_prepare( gpDataBase, acText, -1, &statement, NULL );
		if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		sqlite3_reset( statement );
		rslt = sqlite3_step( statement );
		sqlite3_finalize(statement);


	//プロフテーブルを作成
		rslt = sqlite3_prepare( gpDataBase, cacProfilesTable, -1, &statement, NULL );
		if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_step( statement );	//	実行
		if( SQLITE_DONE != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_finalize(statement);

		//初期値を作成
		ZeroMemory( atStr, sizeof(atStr) );
		StringCchPrintf( atStr, MAX_STRING, catProfInsFmt, ptProfName );
		rslt = sqlite3_prepare16( gpDataBase, atStr, -1, &statement, NULL );
		if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		sqlite3_reset( statement );
		rslt = sqlite3_step( statement );
		sqlite3_finalize(statement);

	//ツリーテーブルを生成
		rslt = sqlite3_prepare( gpDataBase, cacTreeNodeTable, -1, &statement, NULL );
		if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_step( statement );	//	実行
		if( SQLITE_DONE != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_finalize(statement);

	//副タブテーブルを作成
		rslt = sqlite3_prepare( gpDataBase, cacMultiTabTable, -1, &statement, NULL );
		if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_step( statement );	//	実行
		if( SQLITE_DONE != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_finalize(statement);

	//使用AAテーブルを作成	
		rslt = sqlite3_prepare( gpDataBase, cacArtListTable, -1, &statement, NULL );
		if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_step( statement );	//	実行
		if( SQLITE_DONE != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_finalize(statement);

	}
	else	//	存在してるなら、ヴァージョンを確かめてーテーボーを変更
	{
		dVersion = 0;
		rslt = sqlite3_prepare( gpDataBase, cacVersionNumGet, -1, &statement, NULL );
		if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
		rslt = sqlite3_step( statement );
		if( SQLITE_ROW == rslt ){	dVersion = sqlite3_column_int( statement, 0 );	}
		sqlite3_finalize( statement );
		TRACE( TEXT("PROFILE VERSION[%d]"), dVersion );



		//	副タブの表示名称を追加
		if( TREE_TBL_VER == dVersion )
		{
			//	テーブルに追加
			rslt = sqlite3_prepare( gpDataBase, ("ALTER TABLE MultiTab ADD COLUMN dispname TEXT DEFAULT \"\" "), -1, &statement, NULL );
			if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
			rslt = sqlite3_step( statement );	//	実行
			if( SQLITE_DONE != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}
			rslt = sqlite3_finalize( statement );

			//バージョン情報を書き換え
			GetLocalTime( &stSysTime  );	//	更新日時とバージョン
			StringCchPrintfA( acBuildVer, SUB_STRING, ("%d.%02d%02d.%02d%02d.%d"),
				stSysTime.wYear, stSysTime.wMonth, stSysTime.wDay,
				stSysTime.wHour, stSysTime.wMinute, SUBTAB_NAME_VER );

			//	Query文字列作って
			StringCchPrintfA( acQuery, MAX_PATH, cacVersionUpdate, SUBTAB_NAME_VER, acBuildVer );

			//	情報書き換える
			rslt = sqlite3_prepare( gpDataBase, acQuery, -1, &statement, NULL);
			if( SQLITE_OK != rslt ){	SQL_DEBUG( gpDataBase );	return E_ACCESSDENIED;	}

			sqlite3_reset( statement );
			rslt = sqlite3_step( statement );
			sqlite3_finalize( statement );

			dVersion = SUBTAB_NAME_VER;
		}
	}


	return S_OK;
}
Пример #18
0
static int SplitFileNameAndSave(const wchar_t *cur_dir, const wchar_t *file_name, void* unpack, unsigned long  file_length)
{
	DWORD ByteWrite;
	wchar_t buf[MAX_PATH] = {0}, buf2[MAX_PATH];

	StringCchCopy(buf, MAX_PATH, cur_dir);
	StringCchCat (buf, MAX_PATH, L"\\");
	StringCchCat (buf, MAX_PATH, file_name);

	int len = wcslen(buf);
	int i = wcslen(cur_dir) + 1;
	wchar_t *p = buf, *end = buf + len;
	while (p <= end && i < len)
	{
		while(buf[i] != '\\' && buf[i] != '/' && buf[i] != '\0') ++i;
		if (buf[i] == '/') buf[i] = '\\';
		if (i<len)
		{
			wchar_t tmp = buf[i];
			buf[i] = '\0';

			CreateDirectoryW(p, 0);
			buf[i] = tmp;
			++i;
		}
	}

	HANDLE hFile;
	int ret = 0;
	do{
		hFile = CreateFile(buf, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
		if (hFile == INVALID_HANDLE_VALUE)
		{
			StringCchPrintf(buf2, MAX_PATH, L"[文件创建错误]%s\r\n", file_name);
			ret = -1;
			break;
		}

		WriteFile(hFile, unpack, file_length, &ByteWrite, NULL);

		if (ByteWrite != file_length)
		{
			StringCchPrintf(buf2, MAX_PATH, L"[文件写入错误]%s\r\n", file_name);
			ret = -2;
			break;
		}
		
		int t = GetLastError();
		if (!t || t == ERROR_ALREADY_EXISTS)
			StringCchPrintf(buf2, MAX_PATH, L"[已保存]%s\r\n", file_name);
		else
		{
			StringCchPrintf(buf2, MAX_PATH, L"[无法保存]%s\r\n", file_name);
			ret = -3;
		}
	}while(0);

	AppendMsg(buf2);
	CloseHandle(hFile);
	return ret;
}
static bool
patch_registry(const BLUETOOTH_ADDRESS *move_addr, const BLUETOOTH_ADDRESS *radio_addr)
{
    bool success= true;

    TCHAR sub_key[1024];
    HRESULT res = StringCchPrintf(
        sub_key,
        1024,
        _T("SYSTEM\\CurrentControlSet\\Services\\HidBth\\Parameters\\Devices\\" \
           "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"),
        radio_addr->rgBytes[5], radio_addr->rgBytes[4], radio_addr->rgBytes[3],
        radio_addr->rgBytes[2], radio_addr->rgBytes[1], radio_addr->rgBytes[0],
        move_addr->rgBytes[5], move_addr->rgBytes[4], move_addr->rgBytes[3],
        move_addr->rgBytes[2], move_addr->rgBytes[1], move_addr->rgBytes[0] );

    if (FAILED(res)) 
    {
        SERVER_MT_LOG_ERROR("AsyncBluetoothPairDeviceRequest") << "Failed to build registry subkey";
        success= false;
    }

    HKEY hKey;
    if (success)
    {
        LONG result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, sub_key, 0, KEY_READ | KEY_QUERY_VALUE | KEY_WOW64_64KEY | KEY_ALL_ACCESS, &hKey);
        if (result != ERROR_SUCCESS) 
        {
            if (result == ERROR_FILE_NOT_FOUND) 
            {
                SERVER_MT_LOG_ERROR("AsyncBluetoothPairDeviceRequest") << "Failed to open registry key, it does not yet exist";
            }
            else
            {
                SERVER_MT_LOG_ERROR("AsyncBluetoothPairDeviceRequest") << "Failed to open registry key";
            }

            success= false;
        }
    }

    if (success)
    {
        {
            LONG result;

            do
            {
                DWORD pvData;
                DWORD dwData;
                DWORD pdwType;

                result = RegQueryValueEx(hKey, _T("VirtuallyCabled"), 0, &pdwType, (LPBYTE)&pvData, &dwData);

                if(result == ERROR_SUCCESS)
                {
                   SERVER_MT_LOG_INFO("AsyncBluetoothPairDeviceRequest") << "Get VirtuallyCabled: " << pvData;
                }
                else if( result != ERROR_MORE_DATA )
                {
                    SERVER_MT_LOG_WARNING("AsyncBluetoothPairDeviceRequest") << "Failed to get registry value. Error Code: " << result;
                    // Ignore and continue
                }
            }
            while(result == ERROR_MORE_DATA);
        }

        {
            DWORD data = 1;        
            LONG result = RegSetValueEx(hKey, _T("VirtuallyCabled"), 0, REG_DWORD, (const BYTE *)&data, sizeof(data));
            if (result != ERROR_SUCCESS) 
            {
                SERVER_MT_LOG_ERROR("AsyncBluetoothPairDeviceRequest") << "Failed to set 'VirtuallyCabled'";
                success= false;
            }
        }

        RegCloseKey(hKey);
    }

    return success;
}
Пример #20
0
HRESULT World::frameMove( double dTime, float fElapsedTime )
{
    EpCamera& camera = GetG().m_camera;
    HRESULT hr = S_OK;
    if ( m_bNotEntered )
    {
        enter();
        m_bNotEntered = false;
    }
    m_pic.frameMove(fElapsedTime);
    m_avatar.frameMove(fElapsedTime);
    //camera.frameMove(fElapsedTime);

    if ( m_sound )
        m_sound->UpdateAudio();

    DialogList::iterator itDialog = m_scriptedDialog.begin();
    for ( ; itDialog != m_scriptedDialog.end(); ++itDialog )
    {
        (*itDialog)->frameMove( dTime, fElapsedTime );
    }

    //GetG().m_camera.frameMove( fElapsedTime );

    m_sampleTeapotMeshRot += fElapsedTime * D3DXToRadian(35); // 35 degrees per second

    GetWorldStateManager().transit( dTime );
    GetWorldStateManager().getCurState()->frameMove(dTime, fElapsedTime);

    m_modelSg->getSceneRoot()->update(dTime, fElapsedTime);

    WCHAR msg[128];

    StringCchPrintf( msg, 128, L"Hero Pos : (%.2f, %.2f, %.2f)\n",
                     m_heroUnit->getPos().x,
                     m_heroUnit->getPos().y,
                     m_heroUnit->getPos().z );
    g_debugBuffer.append( msg );

    StringCchPrintf( msg, 128, L"Hero TilePos : (%d, %d)\n",
                     m_heroUnit->getTilePosX(),
                     m_heroUnit->getTilePosY() );
    g_debugBuffer.append( msg );

    ArnVec3 diff = m_heroUnit->getPos() - *GetG().m_camera.GetEyePt();
    StringCchPrintf( msg, 128, L"Hero - Camera Pos : (%.4f, %.4f, %.4f)\n",
                     diff.x, diff.y, diff.z );
    g_debugBuffer.append( msg );


    if ( D3DXVec2Length( (const D3DXVECTOR2*)&diff ) > 0.001f)
    {
        // Check for camera and character move inconsistency when field state
        //DebugBreak();
    }

    if ( ((Hero*)getHeroUnit())->isEncounterEnemy() && GetWorldStateManager().curStateEnum() != GAME_WORLD_STATE_BATTLE )
        battleEventCheck();

    wannaTalkingEventCheck();

    // Incidents update
    IncidentList::iterator itInc = m_incidents.begin();
    for ( ; itInc != m_incidents.end(); ++itInc )
    {
        (*itInc)->update( dTime, fElapsedTime );
    }

    UnitSet::iterator it2 = m_unitSet.begin();
    for ( ; it2 != m_unitSet.end(); ++it2 )
    {
        (*it2)->frameMove( dTime, fElapsedTime );

        // TODO:
        // Any registered units will not be deallocated automatically
        // until the world destructed.
    }
    return hr;
}
Пример #21
0
        // the semaphore will be signaled when it is non-empty
        WaitForSingleObject(m_hSem, INFINITE);
    }
    // copy fields to caller's CMsg
    *msg = *pmsg;

    // this CMsg was allocated by the 'new' in PutThreadMsg
    delete pmsg;

}

// Helper function - convert int to WSTR
void WINAPI IntToWstr(int i, __out_ecount(12) LPWSTR wstr)
{
#ifdef UNICODE
    if (FAILED(StringCchPrintf(wstr, 12, L"%d", i))) {
        wstr[0] = 0;
    }
#else
    TCHAR temp[12];
    if (FAILED(StringCchPrintf(temp, NUMELMS(temp), "%d", i))) {
        wstr[0] = 0;
    } else {
        MultiByteToWideChar(CP_ACP, 0, temp, -1, wstr, 12);
    }
#endif
} // IntToWstr


#define MEMORY_ALIGNMENT        4
#define MEMORY_ALIGNMENT_LOG2   2
Пример #22
0
static void _w_i(char *name, int d)
{
	char str[120];
	StringCchPrintf(str, _countof(str), "%d",d);
	WritePrivateProfileString(app_name,name,str,ini_file);
}
Пример #23
0
LONG WINAPI MyExceptionCrashFunc(struct _EXCEPTION_POINTERS *pExceptionPointers)
{
	SetErrorMode( SEM_NOGPFAULTERRORBOX );   

	//收集信息   
	CString strBuild;   
	strBuild.Format("Build: %s %s", __DATE__, __TIME__);   
	CString strError;   
	HMODULE hModule;   
	CHAR szModuleName[MAX_PATH] = "";   
	GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCSTR)pExceptionPointers->ExceptionRecord->ExceptionAddress, &hModule);   
	GetModuleFileName(hModule, szModuleName, ARRAYSIZE(szModuleName));   
	strError.AppendFormat("%s %d , %d ,%d.", szModuleName,pExceptionPointers->ExceptionRecord->ExceptionCode, pExceptionPointers->ExceptionRecord->ExceptionFlags, pExceptionPointers->ExceptionRecord->ExceptionAddress);   
	CString strAppFile = szModuleName;
	int nFind = strAppFile.ReverseFind('\\');
	CString strAppPath = strAppFile.Left(nFind+1);
	strAppPath += "dump";
	CString strAppName = strAppFile.Mid(nFind+1);
	//{add by tian_yx 2011-07-22 09:36
// 	char szMyDir[MAX_PATH];   
// 	ZeroMemory(szMyDir, sizeof(szMyDir));
// 	::SHGetSpecialFolderPath(NULL,szMyDir,CSIDL_LOCAL_APPDATA,0); 
// 	strAppPath = szMyDir;
// 	strAppPath +=TEXT("\\EZworking");
// 	CreateDirectory(strAppPath, NULL);
// 	strAppPath +=TEXT("\\dump");
	CreateDirectory(strAppPath, NULL);
	//}end by tian_yx 2011-07-22 09:36

	//生成 mini crash dump   
	BOOL bMiniDumpSuccessful;   
	CHAR szFileName[512];    
	DWORD dwBufferSize = MAX_PATH;   
	HANDLE hDumpFile;   
	SYSTEMTIME stLocalTime;   
	MINIDUMP_EXCEPTION_INFORMATION ExpParam;   
	GetLocalTime( &stLocalTime );   
	CreateDirectory( strAppPath, NULL );   
	StringCchPrintf( szFileName, MAX_PATH, "%s\\%04d%02d%02d-%02dh%02dm%02ds.dmp",    
		strAppPath,     
		stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,    
		stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond,    
		GetCurrentProcessId(), GetCurrentThreadId());  

	hDumpFile = CreateFile(szFileName, GENERIC_READ|GENERIC_WRITE,    
		FILE_SHARE_WRITE|FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);   

	MINIDUMP_USER_STREAM UserStream[2];   
	MINIDUMP_USER_STREAM_INFORMATION UserInfo;   
	UserInfo.UserStreamCount = 1;   
	UserInfo.UserStreamArray = UserStream;   
	UserStream[0].Type = CommentStreamW;   
	UserStream[0].BufferSize = strBuild.GetLength()*sizeof(WCHAR);   
	UserStream[0].Buffer = strBuild.GetBuffer();   
	UserStream[1].Type = CommentStreamW;   
	UserStream[1].BufferSize = strError.GetLength()*sizeof(WCHAR);   
	UserStream[1].Buffer = strError.GetBuffer();   

	ExpParam.ThreadId = GetCurrentThreadId();   
	ExpParam.ExceptionPointers = pExceptionPointers;   
	ExpParam.ClientPointers = TRUE;   

	MINIDUMP_TYPE MiniDumpWithDataSegs = (MINIDUMP_TYPE)(
		MiniDumpNormal    
		| MiniDumpWithHandleData    
		| MiniDumpWithUnloadedModules    
		| MiniDumpWithIndirectlyReferencedMemory    
		| MiniDumpScanMemory    
		| MiniDumpWithProcessThreadData    
		| MiniDumpWithThreadInfo);   

	bMiniDumpSuccessful = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),    
		hDumpFile, MiniDumpWithDataSegs, &ExpParam, NULL, NULL);  

	return TRUE;
}
Пример #24
0
bool RunProcessing(LPCWSTR fname, int mode, HWND hWnd, int curtrack)
{
	SECURITY_ATTRIBUTES sa;
	STARTUPINFO si;
	PROCESS_INFORMATION pi; 
	HANDLE hReadError, hReadOut, hWriteError, hWriteOut;
	char xxx[1000],tempbuf[1000]; DWORD dd; int i,pos=0;

	sa.nLength = sizeof(sa);
	sa.lpSecurityDescriptor = NULL;
	sa.bInheritHandle = TRUE;

	if (!CreatePipe(&hReadOut, &hWriteOut, &sa, 0)) return 1;
	if (!CreatePipe(&hReadError, &hWriteError, &sa, 0)) return 1;

	memset(&si, 0, sizeof(si));
	memset(&pi, 0, sizeof(pi));

	si.cb = sizeof(si);
	si.dwFlags = STARTF_USESTDHANDLES;
	si.hStdInput = NULL;
	si.hStdOutput = hWriteOut;
	si.hStdError = hWriteError;

	//////////////////////////////////////////////////////////////////////////
	// запуск процесса
	wchar_t cmdline[1000];
	StringCchPrintf(cmdline, 1000, L"aucdtect.exe -m%d -v \"%s\"", mode, fname);
	
	if (!CreateProcess(NULL,cmdline, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, L".", &si, &pi))
	{
		MessageBox(0, L"can not launch aucdtect.exe", NULL, MB_OK);
		return false;
	}
	CloseHandle(hWriteOut);
	CloseHandle(hWriteError);
	int oldpers = -1;

	SendMessage(hWnd, MES_SENDPROCID1, curtrack, GetProcessId(GetCurrentProcess()));
	SendMessage(hWnd, MES_SENDPROCID2, curtrack, pi.dwProcessId);

	while(ReadFile(hReadError,xxx,80,&dd,0))
	{
		for(i=0;i<(int)dd;i++){
			if(xxx[i]==13 || xxx[i]==10){
				if(xxx[i]==13)i++;
				tempbuf[pos] = 0;
				int pers = ParsePercentString(tempbuf);
				// сообщение
				if( pers != oldpers){
					if( !MySendMessage(hWnd, MES_PROGRESS, curtrack, pers) )
						return false;
					oldpers = pers;
				}
				pos=0;
			}else{
				if(xxx[i]==10)continue;
				tempbuf[pos++] = xxx[i]; 
			}
		}
	}
	pos=0;
	while(ReadFile(hReadOut,xxx,80,&dd,0))
	{
		for(int i=0;i<(int)dd;i++){
			if(xxx[i]==13 || xxx[i]==10){
				if(xxx[i]==13)i++;
				tempbuf[pos] = 0;
				StringCchCatA(tempbuf, 1000, "\r\n");
				pos+=2;
			}else{
				if(xxx[i]==10)continue;
				tempbuf[pos++] = xxx[i]; 
			}
		}
	}
	CloseHandle( pi.hProcess );
	CloseHandle( pi.hThread );

	if( !SendStdOut(hWnd, tempbuf, curtrack) )
		return false;

	return true;
}
Пример #25
0
void CCandidateWindow::_DrawList(_In_ HDC dcHandle, _In_ UINT iIndex, _In_ RECT *prc)
{
    int pageCount = 0;
    int candidateListPageCnt = _pIndexRange->Count();

    int cxLine = _TextMetric.tmAveCharWidth;
    int cyLine = max(_cyRow, _TextMetric.tmHeight);
    int cyOffset = (cyLine == _cyRow ? (cyLine-_TextMetric.tmHeight)/2 : 0);

    RECT rc;

    const size_t lenOfPageCount = 16;
    for (;
        (iIndex < _candidateList.Count()) && (pageCount < candidateListPageCnt);
        iIndex++, pageCount++)
    {
        WCHAR pageCountString[lenOfPageCount] = {'\0'};
        CCandidateListItem* pItemList = nullptr;

        rc.top = prc->top + pageCount * cyLine;
        rc.bottom = rc.top + cyLine;

        rc.left = prc->left + PageCountPosition * cxLine;
        rc.right = prc->left + StringPosition * cxLine;

        // Number Font Color And BK
        SetTextColor(dcHandle, CANDWND_NUM_COLOR);
        SetBkColor(dcHandle, GetSysColor(COLOR_3DHIGHLIGHT));

        StringCchPrintf(pageCountString, ARRAYSIZE(pageCountString), L"%d", (LONG)*_pIndexRange->GetAt(pageCount));
        ExtTextOut(dcHandle, PageCountPosition * cxLine, pageCount * cyLine + cyOffset, ETO_OPAQUE, &rc, pageCountString, lenOfPageCount, NULL);

        rc.left = prc->left + StringPosition * cxLine;
        rc.right = prc->right;

        // Candidate Font Color And BK
        if (_currentSelection != iIndex)
        {
            SetTextColor(dcHandle, _crTextColor);
            SetBkColor(dcHandle, GetSysColor(COLOR_3DHIGHLIGHT));
        }
        else
        {
            SetTextColor(dcHandle, CANDWND_SELECTED_ITEM_COLOR);
            SetBkColor(dcHandle, CANDWND_SELECTED_BK_COLOR);
        }

        pItemList = _candidateList.GetAt(iIndex);
        ExtTextOut(dcHandle, StringPosition * cxLine, pageCount * cyLine + cyOffset, ETO_OPAQUE, &rc, pItemList->_ItemString.Get(), (DWORD)pItemList->_ItemString.GetLength(), NULL);
    }
    for (; (pageCount < candidateListPageCnt); pageCount++)
    {
        rc.top    = prc->top + pageCount * cyLine;
        rc.bottom = rc.top + cyLine;

        rc.left   = prc->left + PageCountPosition * cxLine;
        rc.right  = prc->left + StringPosition * cxLine;

        FillRect(dcHandle, &rc, (HBRUSH)(COLOR_3DHIGHLIGHT+1));
    }
}
Пример #26
0
void Dlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) 
{
   static BOOL s_fProcesses = TRUE;

   switch (id) 
   {
      case IDCANCEL:
         EndDialog(hwnd, id);
         break;

      /* Restart the application when we are not running 
       * as Elevated Administrator.
	   */
      case IDC_BTN_SYSTEM_PROCESSES: 
	  {
         /* Hide ourself before trying to start the same application
          * but with elevated privileges.
		  */
         ShowWindow(hwnd, SW_HIDE);

         TCHAR szApplication[MAX_PATH];
         DWORD cchLength = _countof(szApplication);

         /* Retrieves the full name of the executable 
		  * image for the specified process.
		  * hProcess [in]
          *   A handle to the process. 
		  *   This handle must be created with the PROCESS_QUERY_INFORMATION 
		  *   or PROCESS_QUERY_LIMITED_INFORMATION access right. 
		  *   For more information, see Process Security and Access Rights.
		  * dwFlags [in]
          *   This parameter can be one of the following values.
		  *   0 The name should use the Win32 path format.
		  *     The name should use the native system path format.
		  * lpExeName [out]
          *   The path to the executable image. 
		  *   If the function succeeds, this string is null-terminated. 
		  * lpdwSize [in, out]
          *   On input, specifies the size of the lpExeName buffer, in characters. 
		  *   On success, receives the number of characters written to the buffer, 
		  *   not including the null-terminating character.
		  */
         QueryFullProcessImageName(
            GetCurrentProcess(), 
			0, 
			szApplication, 
			&cchLength);

         DWORD dwStatus = StartElevatedProcess(szApplication, NULL);
         if (dwStatus == S_OK) 
		 {
            /* not need to keep on working under lower privileges. */
            ExitProcess(0);
         }
         
         /* In case of error, show up again. */
         ShowWindow(hwnd, SW_SHOWNORMAL);
      }
      break;

      case ID_PROCESSES:
         s_fProcesses = TRUE;
         EnableMenuItem(GetMenu(hwnd), ID_VMMAP, MF_BYCOMMAND | MF_ENABLED);
         DrawMenuBar(hwnd);
         Dlg_PopulateProcessList(hwnd);
         break;

      case ID_MODULES:
         EnableMenuItem(GetMenu(hwnd), ID_VMMAP, MF_BYCOMMAND | MF_GRAYED);
         DrawMenuBar(hwnd);
         s_fProcesses = FALSE;
         Dlg_PopulateModuleList(hwnd);
         break;

      case IDC_PROCESSMODULELIST:
         if (codeNotify == CBN_SELCHANGE) {
            DWORD dw = ComboBox_GetCurSel(hwndCtl);
            if (s_fProcesses) {
               dw = (DWORD) ComboBox_GetItemData(hwndCtl, dw); // Process ID
               ShowProcessInfo(GetDlgItem(hwnd, IDC_RESULTS), dw);
            } else {
               // Index in helper listbox of full path
               dw = (DWORD) ComboBox_GetItemData(hwndCtl, dw); 
               TCHAR szModulePath[1024];
               ListBox_GetText(GetDlgItem(hwnd, IDC_MODULEHELP), 
               dw, szModulePath);
               ShowModuleInfo(GetDlgItem(hwnd, IDC_RESULTS), szModulePath);
            }
         }
         break;

      case ID_VMMAP: {
         TCHAR szCmdLine[32];
         HWND hwndCB = GetDlgItem(hwnd, IDC_PROCESSMODULELIST);
         DWORD dwProcessId = (DWORD)
            ComboBox_GetItemData(hwndCB, ComboBox_GetCurSel(hwndCB));
         StringCchPrintf(szCmdLine, _countof(szCmdLine), TEXT("%d"), 
            dwProcessId);

         DWORD dwStatus = 
            StartElevatedProcess(TEXT("\"14-VMMap.exe\""), szCmdLine);
         if (dwStatus == ERROR_CANCELLED) {
            chMB("Failed to run 14-VMMap.exe: you refused access.");
         }
      }
      break;
   }
}
/* The Display Window Manager (DWM) will only interact with top-level
windows. Therefore, we'll need to create a top-level proxy window for
every tab. This top-level window will be hidden, and will handle the
thumbnail preview for the tab.
References:
http://dotnet.dzone.com/news/windows-7-taskbar-tabbed
http://channel9.msdn.com/learn/courses/Windows7/Taskbar/Win7TaskbarNative/Exercise-Experiment-with-the-New-Windows-7-Taskbar-Features/
*/
void Explorerplusplus::CreateTabProxy(int iTabId,BOOL bSwitchToNewTab)
{
	HWND hTabProxy;
	TabProxyInfo_t tpi;
	TCHAR szClassName[512];
	ATOM aRet;
	BOOL bValue = TRUE;

	/* If we're not running on Windows 7 or later, return without
	doing anything. */
	if((m_dwMajorVersion == WINDOWS_VISTA_SEVEN_MAJORVERSION &&
		m_dwMinorVersion == 0) ||
		m_dwMajorVersion < WINDOWS_VISTA_SEVEN_MAJORVERSION)
	{
		return;
	}

	if(!m_bShowTaskbarThumbnails)
	{
		return;
	}

	static int iCount = 0;

	StringCchPrintf(szClassName,SIZEOF_ARRAY(szClassName),_T("Explorer++TabProxy%d"),iCount++);

	aRet = RegisterTabProxyClass(szClassName);

	if(aRet != 0)
	{
		TabProxy_t *ptp = NULL;

		ptp = (TabProxy_t *)malloc(sizeof(TabProxy_t));

		ptp->pContainer = this;
		ptp->iTabId = iTabId;

		hTabProxy = CreateWindow(szClassName,EMPTY_STRING,WS_OVERLAPPEDWINDOW,
			0,0,0,0,NULL,NULL,GetModuleHandle(0),(LPVOID)ptp);

		if(hTabProxy != NULL)
		{
			HMODULE hDwmapi;
			DwmSetWindowAttributeProc DwmSetWindowAttribute;

			hDwmapi = LoadLibrary(_T("dwmapi.dll"));

			if(hDwmapi != NULL)
			{
				DwmSetWindowAttribute = (DwmSetWindowAttributeProc)GetProcAddress(hDwmapi,"DwmSetWindowAttribute");

				if(DwmSetWindowAttribute != NULL)
				{
					DwmSetWindowAttribute(hTabProxy,DWMWA_FORCE_ICONIC_REPRESENTATION,
						&bValue,sizeof(BOOL));

					DwmSetWindowAttribute(hTabProxy,DWMWA_HAS_ICONIC_BITMAP,
						&bValue,sizeof(BOOL));

					if(m_bTaskbarInitialised)
					{
						RegisterTab(hTabProxy,EMPTY_STRING,bSwitchToNewTab);
					}

					tpi.hProxy		= hTabProxy;
					tpi.iTabId		= iTabId;
					tpi.atomClass	= aRet;

					m_TabProxyList.push_back(tpi);
				}

				FreeLibrary(hDwmapi);
			}
		}
	}
}
Пример #28
0
VOID Dlg_PopulateProcessList(HWND hwnd) 
{
   HWND hwndList = GetDlgItem(hwnd, IDC_PROCESSMODULELIST);
   SetWindowRedraw(hwndList, FALSE);
   ComboBox_ResetContent(hwndList);

   CToolhelp thProcesses(TH32CS_SNAPPROCESS);
   PROCESSENTRY32 pe = { sizeof(pe) };
   BOOL fOk = thProcesses.ProcessFirst(&pe);

   /* Call function Process32Next for each process in the system */
   for (; fOk; fOk = thProcesses.ProcessNext(&pe)) 
   {
      TCHAR sz[1024];

      /* Place the process name (without its path) & ID in the list */
      PCTSTR pszExeFile = _tcsrchr(pe.szExeFile, TEXT('\\'));
      if (pszExeFile == NULL) 
	  {
         pszExeFile = pe.szExeFile;
      } 
	  else 
	  {
		 /* Skip over the slash */
         pszExeFile++; 
      }

      /* Append the code/resource integrity level and policy */
      DWORD dwCodeIntegrityLevel = 0;
      DWORD dwCodePolicy = TOKEN_MANDATORY_POLICY_OFF;
      DWORD dwResourcePolicy = 0;
      DWORD dwResourceIntegrityLevel = 0;

      TCHAR szCodeDetails[256];
      szCodeDetails[0] = TEXT('\0');

      TCHAR szResourceDetails[256];
      szResourceDetails[0] = TEXT('\0');

      if (GetProcessIntegrityLevel(pe.th32ProcessID, &dwCodeIntegrityLevel, 
         &dwCodePolicy, &dwResourceIntegrityLevel, &dwResourcePolicy)) {
         switch (dwCodeIntegrityLevel) {
            case SECURITY_MANDATORY_LOW_RID:
               _tcscpy_s(szCodeDetails, _countof(szCodeDetails), 
                  TEXT("- Low "));
               break;

            case SECURITY_MANDATORY_MEDIUM_RID:
               _tcscpy_s(szCodeDetails, _countof(szCodeDetails), 
                  TEXT("- Medium "));
               break;

            case SECURITY_MANDATORY_HIGH_RID:
               _tcscpy_s(szCodeDetails, _countof(szCodeDetails), 
                  TEXT("- High "));
               break;

            case SECURITY_MANDATORY_SYSTEM_RID:
               _tcscpy_s(szCodeDetails, _countof(szCodeDetails), 
                  TEXT("- System "));
               break;

            default:
               _tcscpy_s(szCodeDetails, _countof(szCodeDetails), 
                  TEXT("- ??? "));
         }

         if (dwCodePolicy == TOKEN_MANDATORY_POLICY_OFF) { // = 0
            _tcscat_s(szCodeDetails, 
               _countof(szCodeDetails), TEXT(" + no policy"));
         } else {
            if ((dwCodePolicy & TOKEN_MANDATORY_POLICY_VALID_MASK) == 0) {
               _tcscat_s(szCodeDetails, _countof(szCodeDetails), 
                  TEXT(" + ???"));
            } else {
               if ((dwCodePolicy & TOKEN_MANDATORY_POLICY_NO_WRITE_UP)
                  == TOKEN_MANDATORY_POLICY_NO_WRITE_UP) { 
                  _tcscat_s(szCodeDetails, _countof(szCodeDetails), 
                     TEXT(" + no write-up"));
               }

               if ((dwCodePolicy & TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN)
                  == TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN) { 
                  _tcscat_s(szCodeDetails, _countof(szCodeDetails), 
                     TEXT(" + new process min"));
               }
            }
         }

         switch (dwResourceIntegrityLevel) {
            case SECURITY_MANDATORY_LOW_RID:
               _tcscpy_s(szResourceDetails, 
                  _countof(szResourceDetails), TEXT("Low"));
               break;

            case SECURITY_MANDATORY_MEDIUM_RID:
               _tcscpy_s(szResourceDetails, 
                  _countof(szResourceDetails), TEXT("Medium"));
               break;

            case SECURITY_MANDATORY_HIGH_RID:
               _tcscpy_s(szResourceDetails, 
                  _countof(szResourceDetails), TEXT("High"));
               break;

            case SECURITY_MANDATORY_SYSTEM_RID:
               _tcscpy_s(szResourceDetails, 
                  _countof(szResourceDetails), TEXT("System"));
               break;

            case 0:
               _tcscpy_s(szResourceDetails, 
                  _countof(szResourceDetails), TEXT("Not set"));
               break;

            default:
               _tcscpy_s(szResourceDetails, 
                  _countof(szResourceDetails), TEXT("???"));
          }


         if (dwResourcePolicy == 0) { // = 0
            _tcscat_s(szResourceDetails, 
               _countof(szResourceDetails), TEXT(" + 0 policy"));
         } else {
            if ((dwResourcePolicy & TOKEN_MANDATORY_POLICY_VALID_MASK) == 0) {
               _tcscat_s(szResourceDetails, 
                  _countof(szResourceDetails), TEXT(" + ???"));
            } else {
               if ((dwResourcePolicy & SYSTEM_MANDATORY_LABEL_NO_WRITE_UP)
                  == SYSTEM_MANDATORY_LABEL_NO_WRITE_UP) { 
                  _tcscat_s(szResourceDetails, 
                     _countof(szResourceDetails), 
                     TEXT(" + no write-up"));
               }

               if ((dwResourcePolicy & SYSTEM_MANDATORY_LABEL_NO_READ_UP)
                  == SYSTEM_MANDATORY_LABEL_NO_READ_UP) { 
                  _tcscat_s(szResourceDetails, 
                     _countof(szResourceDetails), 
                     TEXT(" + no read-up"));
               }
               if ((dwResourcePolicy & SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP)
                  == SYSTEM_MANDATORY_LABEL_NO_EXECUTE_UP) { 
                  _tcscat_s(szResourceDetails, 
                     _countof(szResourceDetails), 
                     TEXT(" + no execute-up"));
               }
            }
         }
      }

      StringCchPrintf(sz, _countof(sz), TEXT("%s     (0x%08X)  %s    [%s]"), 
         pszExeFile, pe.th32ProcessID, szCodeDetails, szResourceDetails);
      int n = ComboBox_AddString(hwndList, sz);

      // Associate the process ID with the added item
      ComboBox_SetItemData(hwndList, n, pe.th32ProcessID);
   }

   ComboBox_SetCurSel(hwndList, 0);  // Select the first entry

   // Simulate the user selecting this first item so that the
   // results pane shows something interesting
   FORWARD_WM_COMMAND(hwnd, IDC_PROCESSMODULELIST, 
      hwndList, CBN_SELCHANGE, SendMessage);

   SetWindowRedraw(hwndList, TRUE);
   InvalidateRect(hwndList, NULL, FALSE);
}
Пример #29
0
int opzoekingWG(HWND hW, HANDLE heap_van_proces, LPCTSTR gemeente, LPCTSTR straat, LPCTSTR huisnr, ADRES **adressen, CHAR debug)
{
	/*opkuis gevraagd?*/
	if(gemeente[0] == TEXT('\0'))
	{
		if(debug)
			fprintf(stderr, "-> ZWG: opkuisaanvraag ontvangen\n");
		DeleteFile(TEXT("wittegids.be.html"));
		return 0;
	}
	/*EINDE opkuis gevraagd?*/

	/* html-bestand van wittegids.be downloaden */	//normaal wordt op de URL '%'-encodering toegepast, maar na tests blijkt dit niet noodzakelijk te zijn	(getest op http://wittegids.be/q/name/address/where/Heist-op-den-Berg/street/Livinus Carr象at/nr/22)
	int aantal=0, i;
	StringCchLength(gemeente, STRSAFE_MAX_CCH, (unsigned int *)&i);
	aantal += i;
	StringCchLength(straat, STRSAFE_MAX_CCH, (unsigned int *)&i);
	aantal += i;
	StringCchLength(huisnr, STRSAFE_MAX_CCH, (unsigned int *)&i);
	aantal += i;
	TCHAR url[57+aantal+1];
	#if (defined UNICODE)||(defined _UNICODE)
	if(FAILED(StringCchPrintf(url, 57+aantal+1+1, L"http://www.wittegids.be/q/name/address/where/%ls/street/%ls/nr/%ls", gemeente, straat, huisnr)))	//URL samenstellen //++ om een onbekende reden mist StringCchPrintf het overzetten van het laatste karakter (zonder fout te geven), dit in tegenstelling tot sprintf_s onder dezelfde omstandigheden
	#else
	if(FAILED(StringCchPrintf(url, 57+aantal+1+1, "http://www.wittegids.be/q/name/address/where/%s/street/%s/nr/%s", gemeente, straat, huisnr)))
	#endif
	{
		*adressen = NULL;
		return ZWG_BUG_1;
	}

	HANDLE *hhtml;
	do
	{
		if((URLDownloadToFile(NULL, url, TEXT("wittegids.be.html"), 0, NULL) != S_OK)||(hhtml = CreateFile(TEXT("wittegids.be.html"), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL), hhtml == INVALID_HANDLE_VALUE))
		{
			aantal = 0;
			StringCchLength(gemeente, STRSAFE_MAX_CCH, (unsigned int *)&i);
			aantal += i;
			StringCchLength(straat, STRSAFE_MAX_CCH, (unsigned int *)&i);
			aantal += i;
			StringCchLength(huisnr, STRSAFE_MAX_CCH, (unsigned int *)&i);
			aantal += i;
			StringCchLength(url, STRSAFE_MAX_CCH, (unsigned int *)&i);
			aantal += i;
			TCHAR temp[231+aantal+1];
			#if (defined UNICODE)||(defined _UNICODE)
			StringCchPrintf(temp, 231+aantal+1, L"De gegevens %ls, %ls en %ls werden omgevormd tot %ls.\n\nEr deed zich een probleem voor met het verkrijgen van deze pagina.\nMogelijke oorzaken zijn:\n- Geen internetverbinding\n- Fout gespeld adres\n\nOpnieuw proberen of dit adres overslaan?", gemeente, straat, huisnr, url);
			#else
			StringCchPrintf(temp, 231+aantal+1, "De gegevens %s, %s en %s werden omgevormd tot %s.\n\nEr deed zich een probleem voor met het verkrijgen van deze pagina.\nMogelijke oorzaken zijn:\n- Geen internetverbinding\n- Fout gespeld adres\n\nOpnieuw proberen of dit adres overslaan?", gemeente, straat, huisnr, url);
			#endif
			aantal = MessageBox(hW, temp, TEXT("opzoekingWG - Fout"), MB_RETRYCANCEL | MB_ICONWARNING | MB_SETFOREGROUND);
		}
		else
			break;
		if(aantal == IDCANCEL)
		{
			*adressen = NULL;
			if(hhtml != INVALID_HANDLE_VALUE)
				CloseHandle(hhtml);
			return ZWG_NOT_DOWNLOADED;
		}
	} while(aantal == IDRETRY);
	/* EINDE download html-bestand */

	LARGE_INTEGER startdata, eindedata;
	eindedata.QuadPart = 150;
	/*bestaat adres in Witte Gids?*/
	if(!SetFPByStr(hhtml, TEXT("503 Service Temporarily Unavailable"), &eindedata, NULL))	//controleer op 503-serverfout
	{
		*adressen = NULL;
		CloseHandle(hhtml);
		return ZWG_SERVER_UNAVAILABLE;
	}
	if(!SetFPByStr(hhtml, TEXT("Er werden geen resultaten gevonden voor "), NULL, NULL))	//controleer of resultaten zijn gevonden volgens de Witte Gids
	{
		*adressen = NULL;
		CloseHandle(hhtml);
		if(debug)
			fprintf(stderr, "-> ZWG: wittegids.be.html geeft \'Er werden geen resultaten gevonden voor \'.\n");
		return ZWG_ADDRESS_NOT_IN_WG;
	}
	if(!SetFPByStr(hhtml, TEXT("Uw zoekopdracht voor het adres "), NULL, NULL))	//controleer of resultaten zijn gevonden volgens de Witte Gids
	{
		*adressen = NULL;
		CloseHandle(hhtml);
		if(debug)
			fprintf(stderr, "-> ZWG: wittegids.be.html geeft \'Uw zoekopdracht voor het adres \'.\n");
		return ZWG_ADDRESS_NOT_IN_WG;
	}
	if(SetFPByStr(hhtml, TEXT("truvo.data['raw']="), NULL, &startdata))	//zet in startdata het begin van de data
	{
		if(debug)
			fprintf(stderr, "-> ZWG: \'truvo.data['raw']=\' niet gevonden in wittegids.be.html.\n");
		*adressen = NULL;
		CloseHandle(hhtml);
		return ZWG_ADDRESS_NOT_IN_WG;
	}
	/*EINDE bestaanscontrole*/

	/*alle relevante gegevens opnemen in geheugen*/
	SetFPByStr(hhtml, TEXT(";truvo.data"), NULL, &eindedata);	//zet in eindedata waar de data stopt
	CHAR *data = HeapAlloc(heap_van_proces, 0, eindedata.QuadPart);
	CHAR *data_begin = data;
	if(data == NULL)
	{
		*adressen = NULL;
		return ZWG_MEMORY_ERROR;
	}
	DWORD b;
	SetFilePointerEx(hhtml, startdata, NULL, FILE_BEGIN);
	ReadFile(hhtml, data, eindedata.QuadPart, &b, NULL);
	CloseHandle(hhtml);
	if(b == 0)
	{
		*adressen = NULL;
		HeapFree(heap_van_proces, 0, data_begin);
		return ZWG_READ_ERROR;
	}
	data[b-1] = '\0';
	/*EINDE gegevens opnemen*/
	if(debug)
		fprintf(stderr, "-> ZWG: data = \'%s\'.\n", data);
	/*aantal telefoonnummers bepalen*/
	{
	CHAR *temp = data;
	for(aantal=0; temp = StrStrA(temp, "phone\":"), temp != NULL; ++aantal, ++temp);	//bepaal het aantal telefoonnummers
	if(aantal == 0)	//geen telefoonnummers
	{
		*adressen = NULL;
		HeapFree(heap_van_proces, 0, data_begin);
		return ZWG_TELEPHONE_NOT_IN_WG;
	}
	}
	/*EINDE bepaal aantal telefoonnummers*/

	/*maak array van door te geven ADRES*/
	ADRES *Padressen = HeapAlloc(heap_van_proces, 0, aantal*sizeof(ADRES));
	if(Padressen == NULL)
	{
		*adressen = NULL;
		HeapFree(heap_van_proces, 0, data_begin);
		return ZWG_MEMORY_ERROR;
	}
	/*EINDE array maken*/

	CHAR dummy[ZWG_MAX_ALL];
	/*GEMEENTENAAM OPNEMEN*/
	if(StrStrA(data, "city\":\"") == NULL)
	{
		*adressen = NULL;
		HeapFree(heap_van_proces, 0, data_begin);
		HeapFree(heap_van_proces, 0, Padressen);
		return ZWG_ADDRESS_NOT_IN_WG;
	}
	{
	CHAR *temp = StrStrA(data, "city\":\"") + sizeof("city\":\"") - 1;
	for(i=0; dummy[i] = temp[i], (dummy[i] != '\"')&&(i < ZWG_MAX_GEMEENTE-1); ++i);
	}
	if(i == ZWG_MAX_GEMEENTE-1)
		dummy[i-1] = '_';
	dummy[i] = '\0';
//	UnicodeStr4CodeToUTF8Str(dummy); //getest op http://www.wittegids.be/q/name/address/where/bierbeek/street/oude%20baan/nr/157
	#if (defined UNICODE)||(defined _UNICODE)
	MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, dummy, -1, Padressen[0].gemeente, ZWG_MAX_GEMEENTE);
	#else
	StringCchCopy(Padressen[aantal].gemeente, ZWG_MAX_GEMEENTE, dummy);
	#endif
	
	/*STRAATNAAM OPNEMEN*/
	if(StrStrA(data, "street\":\"") == NULL)
	{
		*adressen = NULL;
		HeapFree(heap_van_proces, 0, data_begin);
		HeapFree(heap_van_proces, 0, Padressen);
		return ZWG_ADDRESS_NOT_IN_WG;
	}
	{
	CHAR *temp = StrStrA(data, "street\":\"") + sizeof("street\":\"") - 1;
	for(i=0; dummy[i] = temp[i], ((dummy[i] < '0')||(dummy[i] > '9'))&&(dummy[i] != '\"')&&(i < ZWG_MAX_STRAAT-1); ++i);
	}
	if(i == ZWG_MAX_STRAAT-1)
		dummy[i-2] = '_';
	dummy[i-1] = '\0';
//	UnicodeStr4CodeToUTF8Str(dummy); //getest op http://www.wittegids.be/q/name/address/where/bierbeek/street/oude%20baan/nr/157
	#if (defined UNICODE)||(defined _UNICODE)
	MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, dummy, -1, Padressen[0].straat, ZWG_MAX_STRAAT);
	#else
	StringCchCopy(Padressen[aantal].straat, ZWG_MAX_STRAAT, dummy);
	#endif

	for(aantal=0; data = StrStrA(data, "phone\":\"") + sizeof("phone\":\"") - 1, (unsigned int)data != sizeof("phone\":\"") - 1; ++aantal)
	{
		/*TELEFOONNUMMER OPNEMEN*/
		for(i=0; dummy[i] = data[i], (dummy[i] != '\"')&&(i < ZWG_MAX_TELEFOON-1); ++i);
		if((i == 0)&&(StrStrA(data, "mobile\":\"") != NULL))	//als er geen telefoonnummer is: mobiel telefoonnummer
		{
			data = StrStrA(data, "mobile\":\"") + sizeof("mobile\":\"") - 1;
			for(i=0; dummy[i] = data[i], (dummy[i] != '\"')&&(i < ZWG_MAX_TELEFOON-1); ++i);
		}
		if((i == 0)||((i == ZWG_MAX_TELEFOON-1)&&(dummy[i] != '\"')))	//geen of ongeldig telefoonnummer
			goto NEGEREN;
		dummy[i] = '\0';
		#if (defined UNICODE)||(defined _UNICODE)
		MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, dummy, -1, Padressen[aantal].telefoonnr, ZWG_MAX_TELEFOON);
		#else
		StringCchCopy(Padressen[aantal].telefoonnr, ZWG_MAX_TELEFOON, dummy);
		#endif

		/*NAAM OPNEMEN*/
		if(StrStrA(data, "name\":\"") == NULL)
			goto NEGEREN;
		data = StrStrA(data, "name\":\"") + sizeof("name\":\"") - 1;
		for(i=0; dummy[i] = data[i], (dummy[i] != '\"')&&(i < ZWG_MAX_NAAM-1); ++i);
		if((i == ZWG_MAX_NAAM-1)&&(dummy[i] != '\"'))
			dummy[i-1] = '_';
		dummy[i] = '\0';
//		UnicodeStr4CodeToUTF8Str(dummy); //getest op http://www.wittegids.be/q/name/address/where/bierbeek/street/oude%20baan/nr/157
		#if (defined UNICODE)||(defined _UNICODE)
		MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, dummy, -1, Padressen[aantal].naam, ZWG_MAX_NAAM);
		#else
		StringCchCopy(Padressen[aantal].naam, ZWG_MAX_NAAM, dummy);
		#endif

		/*STRAATNAAM OVERSLAAN*/
		if(StrStrA(data, "street\":\"") == NULL)
			goto NEGEREN;
		data = StrStrA(data, "street\":\"") + sizeof("street\":\"") - 1;
		for(++data; ((data[0] < '0')||(data[0] > '9'))&&(data[0] != '\"'); ++data);
		if(data[0] == '\"')	//adres zonder huisnummer
			goto NEGEREN;

		/*HUISNUMMER OPNEMEN*/
		for(i=0; dummy[i] = data[i], (dummy[i] != '\"')&&(i < ZWG_MAX_HUISNUMMER-1); ++i);
		dummy[i] = '\0';
		#if (defined UNICODE)||(defined _UNICODE)
		MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, dummy, -1, Padressen[aantal].huisnr, ZWG_MAX_HUISNUMMER);
		#else
		StringCchCopy(Padressen[aantal].huisnr, ZWG_MAX_HUISNUMMER, dummy);
		#endif

		/*CONTROLE of huisnummer van het adres overeenkomt met dat in de Witte Gids*/
		for(i=0; (Padressen[aantal].huisnr[i] != TEXT(' '))&&(Padressen[aantal].huisnr[i] != TEXT('\0')); ++i)
		{
			if(Padressen[aantal].huisnr[i] != huisnr[i])
				break;
		}
		if(((Padressen[aantal].huisnr[i] != TEXT(' '))&&(Padressen[aantal].huisnr[i] != TEXT('\0')))||(huisnr[i] != TEXT('\0')))
			goto NEGEREN;

		/*CONTROLE of combinatie telefoonnummer en naam al gevonden is*/
		for(i=0; i < aantal; ++i)
		{
			if((!StrCmp(Padressen[i].telefoonnr, Padressen[aantal].telefoonnr))&&(!StrCmp(Padressen[i].naam, Padressen[aantal].naam)))
				goto NEGEREN;
		}
		StringCchCopy(Padressen[aantal].gemeente, ZWG_MAX_GEMEENTE, Padressen[0].gemeente);
		StringCchCopy(Padressen[aantal].straat, ZWG_MAX_STRAAT, Padressen[0].straat);
		goto AANNEMEN;

		NEGEREN:
		aantal--;
		AANNEMEN:;
	}
	HeapFree(heap_van_proces, 0, data_begin);
	if(aantal == 0)
	{
		*adressen = NULL;
		HeapFree(heap_van_proces, 0, Padressen);
		return ZWG_TELEPHONE_NOT_IN_WG;
	}
	Padressen = HeapReAlloc(heap_van_proces, 0, Padressen, aantal*sizeof(ADRES));	//verkleint het nodige geheugen in geval van niet-opgenomen elementen
	*adressen = Padressen;
	return aantal;
}
Пример #30
0
int RhoBluetoothManager::DiscoverDevices() {
	LOG(INFO)  + "RhoBluetoothManager::DiscoverDevices() START";
	WSAQUERYSET		wsaq;
	HANDLE			hLookup;
	RhoDeviceList *	tempDevice;

	union {
		CHAR buf[5000];
		double __unused;	// ensure proper alignment
	};

	LPWSAQUERYSET pwsaResults = (LPWSAQUERYSET) buf;
	DWORD dwSize  = sizeof(buf);
	BOOL bHaveName;

	ZeroMemory(&wsaq, sizeof(wsaq));
	wsaq.dwSize = sizeof(wsaq);
	wsaq.dwNameSpace = NS_BTH;
	wsaq.lpcsaBuffer = NULL;

	if (ERROR_SUCCESS != WSALookupServiceBegin (&wsaq, LUP_CONTAINERS, &hLookup))
	{
		LOG(INFO)  + "RhoBluetoothManager::DiscoverDevices() return ERROR";
		return WSAGetLastError();
	}

	ZeroMemory(pwsaResults, sizeof(WSAQUERYSET));
	pwsaResults->dwSize = sizeof(WSAQUERYSET);
	pwsaResults->dwNameSpace = NS_BTH;
	pwsaResults->lpBlob = NULL;

	if(m_pStart)
	{
		for(m_pCurrentDevice=m_pStart;m_pCurrentDevice;)
		{
			RhoDeviceList *temp=m_pCurrentDevice;
			m_pCurrentDevice=m_pCurrentDevice->NextDevice;
			free(temp);
		}
	}
	m_pEnd=m_pStart=NULL;
	m_iNumDevices=0;
	while (true)
	{	
		if(WSALookupServiceNext (hLookup, LUP_RETURN_NAME | LUP_RETURN_ADDR, &dwSize, pwsaResults)!=ERROR_SUCCESS)
			break;
		ASSERT (pwsaResults->dwNumberOfCsAddrs == 1);
		//Populate the link list		
		tempDevice=(RhoDeviceList*)malloc(sizeof(RhoDeviceList));
		tempDevice->NextDevice=NULL;
		if(m_pStart==NULL)
		{
			m_pStart = tempDevice;
			m_pEnd=m_pStart;
		}
		else
		{
			m_pEnd->NextDevice =tempDevice;
			m_pEnd=tempDevice;
		}
		m_iNumDevices++;
		m_pEnd->bthAddress = ((SOCKADDR_BTH *)pwsaResults->lpcsaBuffer->RemoteAddr.lpSockaddr)->btAddr;
		bHaveName = pwsaResults->lpszServiceInstanceName && *(pwsaResults->lpszServiceInstanceName);
		//If device name is available, add to node
		StringCchPrintf(m_pEnd->bthName, ARRAYSIZE(m_pEnd->bthName),L"%s",bHaveName ? pwsaResults->lpszServiceInstanceName : L"");
		{
			char name[1024];
			WideCharToMultiByte(CP_UTF8, 0, m_pEnd->bthName, -1, name, 1024, 0, 0);
			LOG(INFO)  + "RhoBluetoothManager::DiscoverDevices() FOUND = "+name;
		}
	}

	WSALookupServiceEnd(hLookup);
	LOG(INFO)  + "RhoBluetoothManager::DiscoverDevices() FINISH";
	//	LeaveCriticalSection(&criticalSection);
	return 0;
}