// Create a DX11 context
//-----------------------------------------------------------------------------
CPUTResult CPUT_DX11::CreateDXContext(CPUTContextCreation ContextParams )
{

    HRESULT hr = S_OK;
    CPUTResult result = CPUT_SUCCESS;

    // window params
    RECT rc;
    HWND hWnd = mpWindow->GetHWnd();
    GetClientRect( hWnd, &rc );
    UINT width = rc.right - rc.left;
    UINT height = rc.bottom - rc.top;

    // set up DirectX creation parameters
    mdriverType = D3D_DRIVER_TYPE_NULL;
    mfeatureLevel = D3D_FEATURE_LEVEL_11_0;
    mpD3dDevice = NULL;
    mpContext = NULL;
    mpSwapChain = NULL;
    mSwapChainBufferCount = ContextParams.swapChainBufferCount;
    mpBackBufferRTV = NULL;
    UINT createDeviceFlags = 0;
#ifdef _DEBUG
    createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif

    D3D_DRIVER_TYPE driverTypes[] =
    {
        D3D_DRIVER_TYPE_HARDWARE,
        D3D_DRIVER_TYPE_WARP,
        D3D_DRIVER_TYPE_REFERENCE,
    };
    UINT numDriverTypes = ARRAYSIZE( driverTypes );

    // SRV's (shader resource views) require Structured Buffer
    // usage (D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) which was 
    // introduced in shader model 5 (directx 11.0)
    //
    D3D_FEATURE_LEVEL featureLevels[] =
    {
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0
    };
    UINT numFeatureLevels = ARRAYSIZE( featureLevels );

    // swap chain information
    DXGI_SWAP_CHAIN_DESC sd;
    ZeroMemory( &sd, sizeof( sd ) );
    sd.BufferCount = mSwapChainBufferCount;
    sd.BufferDesc.Width = width;
    sd.BufferDesc.Height = height;

    mSwapChainFormat = ContextParams.swapChainFormat;
    sd.BufferDesc.Format = ContextParams.swapChainFormat;
    sd.BufferDesc.RefreshRate.Numerator = ContextParams.refreshRate;
    sd.BufferDesc.RefreshRate.Denominator = 1;
    sd.BufferUsage = ContextParams.swapChainUsage;
    sd.OutputWindow = hWnd;
    sd.SampleDesc.Count = 1;  // Number of MSAA samples
    sd.SampleDesc.Quality = 0;
    sd.Windowed = TRUE;
    sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

    // set the vsync parameter
    if(0 != ContextParams.refreshRate)
    {
        mSyncInterval = 1;
    }

    // walk devices and create device and swap chain on best matching piece of hardware
    bool functionalityTestPassed = false;
    for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
    {
        mdriverType = driverTypes[driverTypeIndex];
        hr = D3D11CreateDeviceAndSwapChain(
            NULL,
            mdriverType,
            NULL,
            createDeviceFlags,
            featureLevels,
            numFeatureLevels,
            D3D11_SDK_VERSION,
            &sd,
            &mpSwapChain,
            &mpD3dDevice,
            &mfeatureLevel,
            &mpContext
        );
        if( SUCCEEDED( hr ) )
        {
            functionalityTestPassed = TestContextForRequiredFeatures();
            if(true == functionalityTestPassed)
            {
                break;
            }
            else
            {
                // context was created, but failed to have required features
                // release and destroy this context and created resources
                SAFE_RELEASE(mpSwapChain);
                SAFE_RELEASE(mpContext);
                SAFE_RELEASE(mpD3dDevice);
            }
        }
    }
    ASSERT( (SUCCEEDED(hr) && (true==functionalityTestPassed)), _L("Failed creating device and swap chain.") );
    if(!SUCCEEDED(hr) || !functionalityTestPassed)
    {
        CPUTOSServices::GetOSServices()->OpenMessageBox(_L("Required DirectX hardware support not present"), _L("Your system does not support the DirectX feature levels required for this sample."));
        exit(1); // exit app directly
    }
   
    // If the WARP or Reference rasterizer is being used, the performance is probably terrible.
    // we throw up a dialog right after drawing the loading screen in CPUTCreateWindowAndContext
    // warning about that perf problem

    // call the DeviceCreated callback/backbuffer/etc creation
    result = CreateContext();

    CPUTRenderStateBlock *pBlock = new CPUTRenderStateBlockDX11();
    pBlock->CreateNativeResources();
    CPUTRenderStateBlock::SetDefaultRenderStateBlock( pBlock );

    // Create the per-frame constant buffer.
    D3D11_BUFFER_DESC bd = {0};
    bd.ByteWidth = sizeof(CPUTFrameConstantBuffer);
    bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    bd.Usage = D3D11_USAGE_DYNAMIC;
    bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;

    ID3D11Buffer *pPerFrameConstantBuffer;
    hr = (CPUT_DX11::GetDevice())->CreateBuffer( &bd, NULL, &pPerFrameConstantBuffer );
    ASSERT( !FAILED( hr ), _L("Error creating constant buffer.") );
    CPUTSetDebugName( pPerFrameConstantBuffer, _L("Per-Frame Constant buffer") );
    cString name = _L("$cbPerFrameValues");
    mpPerFrameConstantBuffer = new CPUTBufferDX11( name, pPerFrameConstantBuffer );
    CPUTAssetLibrary::GetAssetLibrary()->AddConstantBuffer( name, mpPerFrameConstantBuffer );
    SAFE_RELEASE(pPerFrameConstantBuffer); // We're done with it.  The CPUTBuffer now owns it.

    return result;
}
BOOL UpdateValidationX509::ValidateUpdate( MFUpdate* pUpdate, UINT8* pValidation, INT32 validationLen )
{
    CK_MECHANISM_TYPE mechs[] = { CKM_RSA_PKCS };
    CK_SLOT_ID slotID;
    CK_SESSION_HANDLE session;
    CK_OBJECT_CLASS ckoCert = CKO_CERTIFICATE;
    CK_OBJECT_HANDLE hCACert;
    CK_MECHANISM_TYPE sha1Mech = CKM_SHA_1;
    CK_MECHANISM mech = { CKM_RSA_PKCS, &sha1Mech, sizeof(sha1Mech) };
    BOOL retVal = FALSE;
    UINT8* caCert;
    UINT32 certLen = 0;

    if(g_DebuggerPortSslConfig.GetCertificateAuthority == NULL)
    {
        return FALSE;
    }
    
    g_DebuggerPortSslConfig.GetCertificateAuthority( &caCert, &certLen );

    CK_ATTRIBUTE attribs[] =
    {
        { CKA_CLASS   , &ckoCert, sizeof(ckoCert) },
        { CKA_VALUE   , caCert  , certLen         }
    };

    if(pUpdate->Providers->Storage == NULL) return FALSE;
    if(certLen == 0 || caCert == NULL     ) return FALSE;
    if(pValidation == NULL                ) return FALSE;

    C_Initialize(NULL);

    slotID = Cryptoki_FindSlot(NULL, mechs, ARRAYSIZE(mechs));  if(CK_SLOT_ID_INVALID == slotID) return FALSE;
    
    if(CKR_OK == C_OpenSession(slotID, CKF_SERIAL_SESSION, NULL, NULL, &session) && (CK_SESSION_HANDLE_INVALID != session))
    {
        if(CKR_OK == C_CreateObject(session, attribs, ARRAYSIZE(attribs), &hCACert) && hCACert != CK_OBJECT_HANDLE_INVALID)
        {
            if(CKR_OK == C_VerifyInit(session, &mech, hCACert)) 
            {
                UINT8 buff[512];
                INT32 len = sizeof(buff);
                INT32 updateSize = pUpdate->Header.UpdateSize;
                INT32 offset = 0;

                while(offset < updateSize)
                {
                    if((offset + len) > updateSize)
                    {
                        len = updateSize - offset;
                    }
                    
                    if(!pUpdate->Providers->Storage->Read(pUpdate->StorageHandle, offset, buff, len)) break;

                    C_VerifyUpdate(session, buff, len);

                    offset += len;
                }
                retVal = CKR_OK == C_VerifyFinal(session, pValidation, (CK_ULONG)validationLen);
            }

            C_DestroyObject(session, hCACert);
        }
        
        C_CloseSession(session);
    }

    return retVal;    
}
Example #3
0
void KyraEngine_MR::freeSceneShapes() {
	for (uint i = 0; i < ARRAYSIZE(_sceneShapes); ++i) {
		delete[] _sceneShapes[i];
		_sceneShapes[i] = 0;
	}
}
RemoteDesktop::EventLog::EventLog(std::wstring name){
	Name = name;
	auto key_path(L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\" + name);

	HKEY key;

	DWORD last_error = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
		key_path.c_str(),
		0,
		0,
		REG_OPTION_NON_VOLATILE,
		KEY_SET_VALUE,
		0,
		&key,
		0);
	if (ERROR_SUCCESS == last_error)
	{
		wchar_t szPath[MAX_PATH];
		bool ret = false;

		GetModuleFileName(NULL, szPath, ARRAYSIZE(szPath));

		const DWORD types_supported = EVENTLOG_ERROR_TYPE |
			EVENTLOG_WARNING_TYPE |
			EVENTLOG_INFORMATION_TYPE;

		RegSetValueEx(key,
			L"EventMessageFile",
			0,
			REG_SZ,
			(BYTE*)szPath,
			wcsnlen_s(szPath, MAX_PATH) * 2);

		RegSetValueEx(key,
			L"CategoryMessageFile",
			0,
			REG_SZ,
			(BYTE*)szPath,
			wcsnlen_s(szPath, MAX_PATH) * 2);

		RegSetValueEx(key,
			L"ParameterMessageFile",
			0,
			REG_SZ,
			(BYTE*)szPath,
			wcsnlen_s(szPath, MAX_PATH) * 2);

		RegSetValueEx(key,
			L"TypesSupported",
			0,
			REG_DWORD,
			(LPBYTE)&types_supported,
			sizeof(types_supported));
		DWORD catcount = 3;
		RegSetValueEx(key,
			L"CategoryCount",
			0,
			REG_DWORD,
			(LPBYTE)&catcount,
			sizeof(catcount));
		RegCloseKey(key);
	}
	else
	{
		std::cerr << "Failed to install source: " << last_error << "\n";
	}

	_EventSource = RegisterEventSource(NULL, name.c_str());
}
Example #5
0
void DoWrap(BOOL abWordWrap, EditorInfo &ei, int iMaxWidth)
{
	INT_PTR iRc = 0;
	INT_PTR cchMax = 0;
	TCHAR* pszCopy = NULL;
	TCHAR szEOL[4];
	INT_PTR iFrom, iTo, iEnd, iFind;
	bool bWasModifed = (ei.CurState & ECSTATE_MODIFIED) && !(ei.CurState & ECSTATE_SAVED);

	gbLastWrap = TRUE;
	
	for (INT_PTR i = 0; i < ei.TotalLines; i++)
	{
		//bool lbCurLine = (i == ei.CurLine);
		
		EditorGetString egs = {FARSTRUCTSIZE(egs)};
		egs.StringNumber = i;
		iRc = EditCtrl(ECTL_GETSTRING, &egs);
		if (!iRc)
		{
			_ASSERTE(iRc!=0);
			goto wrap;
		}
		_ASSERTE(egs.StringText!=NULL);
		
		if ((egs.StringLength <= iMaxWidth)
			&& ((egs.StringLength <= 0) || !(egs.StringText && wcschr(egs.StringText, L'\t'))))
		{
			// Эту строку резать не нужно
			continue;
		}
		
		lstrcpyn(szEOL, egs.StringEOL?egs.StringEOL:_T(""), ARRAYSIZE(szEOL));
		
		if (egs.StringLength >= cchMax || !pszCopy)
		{
			if (pszCopy)
				free(pszCopy);
			cchMax = egs.StringLength + 255;
			pszCopy = (TCHAR*)malloc(cchMax*sizeof(*pszCopy));
			if (!pszCopy)
			{
				_ASSERTE(pszCopy!=NULL);
				goto wrap;
			}
		}
		// Делаем копию, над которой можем издеваться
		memmove(pszCopy, egs.StringText, egs.StringLength*sizeof(*pszCopy));
		pszCopy[egs.StringLength] = 0; // на всякий случай, хотя вроде должен быть ASCIIZ
		
		bool lbFirst = 0;
		iFrom = 0; iEnd = egs.StringLength;
		while (iFrom < iEnd)
		{
			//iTo = min(iEnd,(iFrom+iMaxWidth));
			iTo = FindExceed(pszCopy, i, iFrom, min(iEnd/*+1*/,(iFrom+iMaxWidth)), iMaxWidth, ei.TabSize);
			iFind = iTo;
			if (iFind >= iEnd)
			{
				iFind = iTo = iEnd;
			}
			else if (abWordWrap
				/*&& (((egs.StringLength - iFrom) > iMaxWidth) || IsExceed(pszCopy, i, iFrom, iFind, iMaxWidth, ei.TabSize))*/
				)
			{
				while (iFind > iFrom)
				{
					if (IsSpaceOrNull(pszCopy[iFind-1]))
						break;
					//{
					//	// Если есть табы - нужно учитывать их ширину
					//	//TODO: Optimize, по хорошему, если есть табы, нужно оптимизировать расчет экранной позиции
					//	bool bExceed = IsExceed(pszCopy, i, iFrom, iFind, iMaxWidth, ei.TabSize);

					//	if (!bExceed)
					//		break;
					//}
					iFind--;
				}
				// Если по пробелам порезать не удалось, попробуем по другим знакам?
				if (iFind == iFrom)
				{
					iFind = iTo;
					while (iFind > iFrom)
					{
						if (_tcschr(gsPuctuators, pszCopy[iFind]) && !_tcschr(gsWordDiv, pszCopy[iFind-1]))
							break;
						//{
						//	// Если есть табы - нужно учитывать их ширину
						//	//TODO: Optimize, по хорошему, если есть табы, нужно оптимизировать расчет экранной позиции
						//	bool bExceed = IsExceed(pszCopy, i, iFrom, iFind, iMaxWidth, ei.TabSize);

						//	if (!bExceed)
						//		break;
						//}
						iFind--;
					}
					if (iFind == iFrom)
					{
						iFind = iTo;
						while (iFind > iFrom)
						{
							if (_tcschr(gsWordDiv, pszCopy[iFind]) && !_tcschr(gsWordDiv, pszCopy[iFind-1]))
								break;
							//{
							//	// Если есть табы - нужно учитывать их ширину
							//	//TODO: Optimize, по хорошему, если есть табы, нужно оптимизировать расчет экранной позиции
							//	bool bExceed = IsExceed(pszCopy, i, iFrom, iFind, iMaxWidth, ei.TabSize);

							//	if (!bExceed)
							//		break;
							//}
							iFind--;
						}
					}
				}
			}
			if (iFind == iFrom)
				iFind = iTo;

			if (iFind < iEnd)
			{
				// Для ECTL_INSERTSTRING нужно установить курсор
				EditorSetPosition eset = {FARSTRUCTSIZE(eset)};
				eset.CurLine = i;
				eset.TopScreenLine = -1;
				EditCtrl(ECTL_SETPOSITION, &eset);
				// Теперь можно разорвать строку
				EditCtrl(ECTL_INSERTSTRING, NULL);
				// Чтобы вернуть курсор на исходную строку
				if (i < ei.CurLine)
					ei.CurLine++;
			}
			// И менять ее данные
			EditorSetString esset = {FARSTRUCTSIZE(esset)};
			esset.StringNumber = i;
			esset.StringText = pszCopy+iFrom;
			esset.StringEOL = (iFind == iEnd) ? szEOL : _T("");
			esset.StringLength = (iFind - iFrom);
			EditCtrl(ECTL_SETSTRING, &esset);

			// Накрутить счетчики
			if (iFind < iEnd)
			{
				i++; ei.TotalLines++; // т.к. вставили строку
			}
			
			// Следующая часть строки
			iFrom = iFind;
		}
	}

	// Обновить позицию курсора
	{
		EditorSetPosition eset = {FARSTRUCTSIZE(eset)};
		eset.CurLine = ei.CurLine;
		eset.TopScreenLine = -1;
		EditCtrl(ECTL_SETPOSITION, &eset);
	}
	
wrap:
	if (pszCopy)
		free(pszCopy);

#ifdef _UNICODE
	// Сброс флага "редактирован"
	//TODO: bis-сборка?
	if (!bWasModifed)
		EditCtrl(ECTL_DROPMODIFEDFLAG, NULL);
#endif
}
Example #6
0
static struct Rotation3AnimData r3ad_104E1AA8[] =
{
    { 0, { 0, 3345, -5139 } },
    { 15, { 0, 3345, -5139 } }
};

static struct Rotation3AnimData r3ad_104E1AC8[] =
{
    { 0, { 0, -3159, -5149 } },
    { 15, { 0, -3159, -5149 } }
};

static struct AnimFrame_PosRot afpr_104E1AE8[] =
{
    { v3ad_104E0684, NULL, ARRAYSIZE(v3ad_104E0684), 0 },
    { NULL, r3ad_104E06A8, 0, ARRAYSIZE(r3ad_104E06A8) },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
    { NULL, r3ad_104E07A8, 0, ARRAYSIZE(r3ad_104E07A8) },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
    { NULL, r3ad_104E08A8, 0, ARRAYSIZE(r3ad_104E08A8) },
    { NULL, r3ad_104E09A8, 0, ARRAYSIZE(r3ad_104E09A8) },
    { NULL, r3ad_104E0AA8, 0, ARRAYSIZE(r3ad_104E0AA8) },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
Example #7
0
bool wcePutFile(const char *host_file, const char *wce_file)
{
	TCHAR tszSrcFile[MAX_PATH];
	WCHAR wszDestFile[MAX_PATH];
	BYTE  buffer[5120];
    WIN32_FIND_DATA wfd;
	HRESULT hr;
	DWORD dwAttr, dwNumRead, dwNumWritten;
	HANDLE hSrc, hDest, hFind;
	int nResult;

#ifdef UNICODE
	nResult = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
									host_file, strlen(host_file)+1,
									tszSrcFile, ARRAYSIZE(tszSrcFile));
	if(0 == nResult)
		return false;
#else
	hr = StringCchCopy(tszSrcFile, ARRAYSIZE(tszSrcFile), argv[1]);
	if(FAILED(hr))
		return false;
#endif
	nResult = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
									wce_file, strlen(wce_file)+1,
									wszDestFile, ARRAYSIZE(wszDestFile));
    if(0 == nResult)
        return false;

    hFind = FindFirstFile( tszSrcFile, &wfd);
    if (INVALID_HANDLE_VALUE == hFind) {
        _tprintf(TEXT("Host file does not exist\n"));
        return false;
    }
    FindClose( hFind);
	if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
        _tprintf( TEXT("Host file specifies a directory\n"));
        return false;
    }
	
	if (wceConnect()) {
		dwAttr = CeGetFileAttributes( wszDestFile);
		if (dwAttr & FILE_ATTRIBUTE_DIRECTORY) {
            hr = StringCchCatW(wszDestFile, ARRAYSIZE(wszDestFile), L"\\");
            if(FAILED(hr)) return false;
#ifdef UNICODE
            hr = StringCchCatW(wszDestFile, ARRAYSIZE(wszDestFile), wfd.cFileName);
            if(FAILED(hr)) return false;
#else
            nResult = MultiByteToWideChar(
                        CP_ACP,    
                        MB_PRECOMPOSED,
                        wfd.cFileName,
                        strlen(wfd.cFileName)+1,
                        wszDestFile+wcslen(wszDestFile),
                        ARRAYSIZE(wszDestFile)-wcslen(wszDestFile));
            if(0 == nResult)
            {
                return 1;
            }
#endif
		}
		hSrc = CreateFile(tszSrcFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		if (INVALID_HANDLE_VALUE == hSrc) {
			_tprintf( TEXT("Unable to open host file\n"));
			return false;
		}

		hDest = CeCreateFile(wszDestFile, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		if (INVALID_HANDLE_VALUE == hDest ) {
			_tprintf( TEXT("Unable to open target WinCE file\n"));
			return false;
		}

		//copy file
		do {
			if(ReadFile(hSrc, &buffer, sizeof(buffer), &dwNumRead, NULL)) {
				if (!CeWriteFile(hDest, &buffer, dwNumRead, &dwNumWritten, NULL)) {
					_tprintf( TEXT("Error !!! Writing WinCE file\n"));
					goto FatalError;
				}
			} else {
				_tprintf( TEXT("Error !!! Reading host file\n"));
				goto FatalError;
			}
			_tprintf( TEXT("."));                                        
		} while (dwNumRead);
		//_tprintf( TEXT("\n"));

		CeCloseHandle( hDest);
		CloseHandle (hSrc);
	}
	wceDisconnect();
	return true;

FatalError:
	CeCloseHandle( hDest);
	CloseHandle (hSrc);
	wceDisconnect();
	return false;
}
Example #8
0
BOOL wf_post_connect(freerdp* instance)
{
	rdpGdi* gdi;
	DWORD dwStyle;
	rdpCache* cache;
	wfContext* wfc;
	rdpContext* context;
	WCHAR lpWindowName[64];
	rdpSettings* settings;
	EmbedWindowEventArgs e;

	settings = instance->settings;
	context = instance->context;
	wfc = (wfContext*) instance->context;
	cache = instance->context->cache;

	wfc->dstBpp = 32;
	wfc->width = settings->DesktopWidth;
	wfc->height = settings->DesktopHeight;

	if (wfc->sw_gdi)
	{
		gdi_init(instance, CLRCONV_ALPHA | CLRCONV_INVERT | CLRBUF_32BPP, NULL);
		gdi = instance->context->gdi;
		wfc->hdc = gdi->primary->hdc;
		wfc->primary = wf_image_new(wfc, wfc->width, wfc->height, wfc->dstBpp, gdi->primary_buffer);
	}
	else
	{
		wf_gdi_register_update_callbacks(instance->update);
		wfc->srcBpp = instance->settings->ColorDepth;
		wfc->primary = wf_image_new(wfc, wfc->width, wfc->height, wfc->dstBpp, NULL);

		wfc->hdc = gdi_GetDC();
		wfc->hdc->bitsPerPixel = wfc->dstBpp;
		wfc->hdc->bytesPerPixel = wfc->dstBpp / 8;

		wfc->hdc->alpha = wfc->clrconv->alpha;
		wfc->hdc->invert = wfc->clrconv->invert;

		wfc->hdc->hwnd = (HGDI_WND) malloc(sizeof(GDI_WND));
		wfc->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0);
		wfc->hdc->hwnd->invalid->null = 1;

		wfc->hdc->hwnd->count = 32;
		wfc->hdc->hwnd->cinvalid = (HGDI_RGN) malloc(sizeof(GDI_RGN) * wfc->hdc->hwnd->count);
		wfc->hdc->hwnd->ninvalid = 0;

		if (settings->RemoteFxCodec)
		{
			wfc->tile = wf_image_new(wfc, 64, 64, 32, NULL);
			wfc->rfx_context = rfx_context_new(FALSE);
		}

		if (settings->NSCodec)
		{
			wfc->nsc_context = nsc_context_new();
		}
	}

	if (settings->WindowTitle != NULL)
		_snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"%S", settings->WindowTitle);
	else if (settings->ServerPort == 3389)
		_snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"FreeRDP: %S", settings->ServerHostname);
	else
		_snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"FreeRDP: %S:%d", settings->ServerHostname, settings->ServerPort);

	if (settings->EmbeddedWindow)
		settings->Decorations = FALSE;
	
	if (!settings->Decorations)
		dwStyle = WS_CHILD | WS_BORDER;
	else
		dwStyle = 0;

	if (!wfc->hwnd)
	{
		wfc->hwnd = CreateWindowEx((DWORD) NULL, wfc->wndClassName, lpWindowName, dwStyle,
			0, 0, 0, 0, wfc->hWndParent, NULL, wfc->hInstance, NULL);

		SetWindowLongPtr(wfc->hwnd, GWLP_USERDATA, (LONG_PTR) wfc);	   
	}

	wf_resize_window(wfc);

	wf_add_system_menu(wfc);

	BitBlt(wfc->primary->hdc, 0, 0, wfc->width, wfc->height, NULL, 0, 0, BLACKNESS);
	wfc->drawing = wfc->primary;

	EventArgsInit(&e, "wfreerdp");
	e.embed = FALSE;
	e.handle = (void*) wfc->hwnd;
	PubSub_OnEmbedWindow(context->pubSub, context, &e);		   
	
	ShowWindow(wfc->hwnd, SW_SHOWNORMAL);
	UpdateWindow(wfc->hwnd);

	if (wfc->sw_gdi)
	{											
		instance->update->BeginPaint = (pBeginPaint) wf_sw_begin_paint;
		instance->update->EndPaint = (pEndPaint) wf_sw_end_paint;
		instance->update->DesktopResize = (pDesktopResize) wf_sw_desktop_resize;
	}
	else
	{
		instance->update->BeginPaint = (pBeginPaint) wf_hw_begin_paint;
		instance->update->EndPaint = (pEndPaint) wf_hw_end_paint;
		instance->update->DesktopResize = (pDesktopResize) wf_hw_desktop_resize;
	}

	pointer_cache_register_callbacks(instance->update);

	if (wfc->sw_gdi != TRUE)
	{
		brush_cache_register_callbacks(instance->update);
		bitmap_cache_register_callbacks(instance->update);
		offscreen_cache_register_callbacks(instance->update);
	}

	wf_register_graphics(instance->context->graphics);

	freerdp_channels_post_connect(instance->context->channels, instance);

	wf_cliprdr_init(wfc, instance->context->channels);
	floatbar_window_create(wfc);

	return TRUE;
}
Example #9
0
    { -0.002852f, 0.988813f, 0.149136f },
    { 0.015325f, 0.108138f, -0.994018f }
};

static short unsigned int strips_10681990[] =
{
    10,
    7, 1, 3, 0, 2, 4, 6, 5, 7, 1
};

static struct MESH mesh_106819A8[] =
{
    { 0 | MeshPolyType_StripsB, 1, strips_10681990, 0, NULL, NULL, NULL, 0 }
};

extern struct MATERIAL mat_106804E8[1];

struct ATTACH attach_10681A88 =
{
    vec3_106819C8,
    vec3_10681A28,
    ARRAYSIZE(vec3_106819C8),
    mesh_106819A8,
    mat_106804E8,
    ARRAYSIZE(mesh_106819A8),
    ARRAYSIZE(mat_106804E8),
    { 0.470043f, 0.006634f, -0.017387f },
    0.829958f,
    0
};
Example #10
0
int ExtendFileSystem (HWND hwndDlg , wchar_t *lpszVolume, Password *pVolumePassword, int VolumePkcs5, int VolumePim, uint64 newDataAreaSize)
{
    wchar_t szVolumeGUID[128];
    int driveNo = -1;
    wchar_t rootPath[] = L"A:\\";
    enum EV_FileSystem fs;
    DWORD dwError;
    int nStatus = ERR_SUCCESS;
    DWORD BytesPerSector;

    // mount and resize file system

    DebugAddProgressDlgStatus (hwndDlg, "Mounting volume ...\r\n");

    nStatus=MountVolTemp(hwndDlg, lpszVolume, &driveNo, pVolumePassword, VolumePkcs5, VolumePim);
    if (nStatus!=ERR_SUCCESS)
    {
        driveNo = -1;
        goto error;
    }

    rootPath[0] += driveNo;

    if ( !GetFileSystemType(rootPath,&fs) )
    {
        dwError = GetLastError();
        if (dwError == ERROR_UNRECOGNIZED_VOLUME)
        {
            // raw volume with unrecognized file system -> return with no error
            nStatus = ERR_SUCCESS;
            goto error;
        }
        nStatus = ERR_OS_ERROR;
        goto error;
    }

    if (fs != EV_FS_TYPE_RAW && fs != EV_FS_TYPE_NTFS )
    {
        // FsctlExtendVolume only supports NTFS and RAW -> return with no error
        nStatus = ERR_SUCCESS;
        goto error;
    }

    // Get volume GUID
    if (!GetVolumeNameForVolumeMountPoint(rootPath,szVolumeGUID,ARRAYSIZE(szVolumeGUID)))
    {
        nStatus = ERR_OS_ERROR;
        goto error;
    }
    else
    {
        // strip trailing backslash from volume GUID (otherwise it means root dir)
        size_t len = wcslen(szVolumeGUID);
        if (len>0) --len;
        if (szVolumeGUID[len]==L'\\') szVolumeGUID[len]=0;
    }

    // Get Sector Size
    if ( !GetNtfsNumberOfSectors(rootPath, NULL, &BytesPerSector) )
    {
        nStatus = ERR_OS_ERROR;
        goto error;
    }

    DebugAddProgressDlgStatus (hwndDlg, "Extending file system ...\r\n");

    // extend volume
    nStatus = FsctlExtendVolume(szVolumeGUID, newDataAreaSize/BytesPerSector );

error:

    dwError = GetLastError();

    if (driveNo>=0)
    {
        DebugAddProgressDlgStatus (hwndDlg, "Unmounting volume ...\r\n");
        UnmountVolume (hwndDlg, driveNo, TRUE);
    }

    SetLastError (dwError);

    return nStatus;
}
Example #11
0
static gboolean
PowerOpsStateChange(RpcInData *data)
{
   size_t i;
   PowerOpState *state = data->clientData;

   if (state->pid != INVALID_PID) {
      g_debug("State change already in progress.\n");
      return RPCIN_SETRETVALS(data,  "State change already in progress", FALSE);
   }

   g_debug("State change: %s\n", data->name);

   for (i = 0; i < ARRAYSIZE(stateChangeCmdTable); i++) {
      if (strcmp(data->name, stateChangeCmdTable[i].tcloCmd) == 0) {
         gchar *script;
         const char *result;
         const char *confName;
         Bool ret;

         state->stateChgInProgress = stateChangeCmdTable[i].id;

         /* Check for the toolScripts option. */
         if (!state->scriptEnabled[stateChangeCmdTable[i].id]) {
            PowerOpsStateChangeDone(state, TRUE);
            g_debug("Script for %s not configured to run\n",
                    stateChangeCmdTable[i].tcloCmd);
            return RPCIN_SETRETVALS(data, "", TRUE);
         }

         confName = stateChgConfNames[stateChangeCmdTable[i].id];
         script = g_key_file_get_string(state->ctx->config,
                                        "powerops",
                                        confName,
                                        NULL);

         if (script == NULL) {
            /* Use default script if not set in config file. */
            const char *dfltScript = GuestApp_GetDefaultScript(confName);
            if (dfltScript == NULL) {
               g_debug("No default script to run for state change %s.\n",
                       stateChangeCmdTable[i].name);
               PowerOpsStateChangeDone(state, TRUE);
               return RPCIN_SETRETVALS(data, "", TRUE);
            }
            script = g_strdup(dfltScript);
         } else if (strlen(script) == 0) {
            g_debug("No script to run for state change %s.\n",
                    stateChangeCmdTable[i].name);
            g_free(script);
            PowerOpsStateChangeDone(state, TRUE);
            return RPCIN_SETRETVALS(data, "", TRUE);
         }

         /* If script path is not absolute, assume the Tools install path. */
         if (!g_path_is_absolute(script)) {
            char *dfltPath;
            char *tmp;

            dfltPath = GuestApp_GetInstallPath();
            ASSERT(dfltPath != NULL);

            /*
             * Before the switch to vmtoolsd, the config file was saved with
             * quotes around the script path to make the old VMware dict code
             * happy. Now we need to undo that when modifying the script path.
             *
             * PowerOpsRunScript will "re-quote" the script path.
             */
            if (script[0] == '"') {
                script[strlen(script) - 1] = '\0';
                tmp = g_strdup_printf("%s%c%s", dfltPath, DIRSEPC, script + 1);
            } else {
               tmp = g_strdup_printf("%s%c%s", dfltPath, DIRSEPC, script);
            }

            g_free(script);
            vm_free(dfltPath);
            script = tmp;
         }

         if (PowerOpsRunScript(state, script)) {
            result = "";
            ret = TRUE;
         } else {
            PowerOpsStateChangeDone(state, FALSE);
            result = "Error starting script";
            ret = FALSE;
         }

         g_free(script);
         return RPCIN_SETRETVALS(data, (char *) result, ret);
      }
   }

   g_warning("Invalid state change command.\n");
   return RPCIN_SETRETVALS(data, "Invalid state change command", FALSE);
}
Example #12
0
void FTP::AddToQueque(FAR_FIND_DATA* FileName, LPCSTR Path, BOOL Download)
{
	String  str;
	char   *m;
	int     num;
	FTPUrl* p = new FTPUrl;
	memcpy(&p->Host, &Host, sizeof(Host));
	p->Download = Download;
	p->Next     = NULL;
	p->FileName = *FileName;
	p->Error.Null();
	p->DestPath = Path;

	if(Download)
		m = strrchr(FileName->cFileName, '/');
	else
		m = strrchr(FileName->cFileName, '\\');

	if(m)
	{
		*m = 0;
		p->DestPath.Add(m);
		memmove(FileName->cFileName, m+1, m-FileName->cFileName);
	}

	if(Download)
	{
		GetCurPath(p->SrcPath);
		AddEndSlash(p->SrcPath, '/');
		str.printf("%s%s", p->SrcPath.c_str(), FileName->cFileName);
		FixLocalSlash(p->DestPath);
		AddEndSlash(p->DestPath, '\\');
		num = str.Chr('/');
	}
	else
	{
		PanelInfo pi;
		FP_Info->Control(this, FCTL_GETANOTHERPANELINFO, &pi);
		p->SrcPath = pi.CurDir;
		AddEndSlash(p->SrcPath, '\\');
		str.printf("%s%s", p->SrcPath.c_str(), FileName->cFileName);
		FixLocalSlash(str);
		AddEndSlash(p->DestPath, '/');
		num = str.Chr('\\');
	}

	if(num != -1)
	{
		StrCpy(p->FileName.cFileName, str.c_str()+num+1, ARRAYSIZE(p->FileName.cFileName));
		str.SetLength(num);
		p->SrcPath = str;
	}
	else
	{
		StrCpy(p->FileName.cFileName, str.c_str(), ARRAYSIZE(p->FileName.cFileName));
		p->SrcPath.Null();
	}

	if(!UrlsList) UrlsList = p;

	if(UrlsTail)  UrlsTail->Next = p;

	UrlsTail = p;
	QuequeSize++;
}
Example #13
0
void FTP::QuequeMenu(void)
{
	int              n,
	  num;
	int              Breaks[] = { VK_DELETE, VK_INSERT, VK_F4, VK_RETURN, 0 },
	                            BNumber;
	FarMenuItem     *mi = NULL;
	FTPUrl*          p,*p1;
	char             str1[MAX_PATH],
	   str2[MAX_PATH],
	   str3[MAX_PATH];
	QueueExecOptions exOp;
	SetupQOpt(&exOp);
	num = -1;

	do
	{
		mi = (FarMenuItem *)realloc(mi, (QuequeSize+1)*sizeof(FarMenuItem));
		memset(mi, 0, QuequeSize*sizeof(FarMenuItem));

		for(p = UrlsList,n = 0; p; p = p->Next, n++)
		{
			StrCpy(str1, p->SrcPath.c_str(),    20);
			StrCpy(str2, p->DestPath.c_str(),   20);
			StrCpy(str3, p->FileName.cFileName, 20);
			_snprintf(mi[n].Text, ARRAYSIZE(mi[n].Text),
			          "%c%c %-20s%c%-20s%c%-20s",
			          p->Download ? '-' : '<', p->Download ? '>' : '-',
			          str1, FAR_VERT_CHAR,
			          str2, FAR_VERT_CHAR,
			          str3);

			if(p->Error[0])
				mi[n].Checked = TRUE;
		}

		//Title
		char title[MAX_PATH];
		_snprintf(title, ARRAYSIZE(title), "%s: %d %s", FP_GetMsg(MQMenuTitle), n, FP_GetMsg(MQMenuItems));

		//Menu
		if(num != -1 && num < QuequeSize) mi[num].Selected = TRUE;

		n = FP_Info->Menu(FP_Info->ModuleNumber,-1,-1,0,FMENU_SHOWAMPERSAND,
		                  title,
		                  FP_GetMsg(MQMenuFooter),
		                  "FTPQueue", Breaks, &BNumber, mi, QuequeSize);

		//key ESC
		if(BNumber == -1 &&
		        n == -1)
			goto Done;

		//key Enter
		if(BNumber == -1)
		{
			//??
			goto Done;
		}

		//Set selected
		if(num != -1) mi[num].Selected = FALSE;

		num = n;

		//Process keys
		switch(BNumber)
		{
				/*DEL*/
			case 0:

				if(QuequeSize)
					switch(AskDeleteQueue())
					{
						case -1:
						case  2:
							break;
						case  0:
							p = UrlItem(n, &p1);
							DeleteUrlItem(p, p1);
							break;
						case  1:
							ClearQueue();
							break;
					}

				break;
				/*Ins*/
			case 1:
				InsertToQueue();
				break;
				/*F4*/
			case 2:
				p = UrlItem(n, NULL);

				if(p)
					EditUrlItem(p);

				break;
				/*Return*/
			case 3:

				if(QuequeSize &&
				        WarnExecuteQueue(&exOp))
				{
					ExecuteQueue(&exOp);

					if(!QuequeSize)
						goto Done;
				}

				break;
		}
	}
	while(true);

Done:
	free(mi);
}
Example #14
0
VOID
ProgressSetStep(
    IN PPROGRESSBAR Bar,
    IN ULONG Step)
{
    COORD coPos;
    DWORD Written;
    ULONG NewPos;
    CHAR TextBuffer[256];

    if (Step > Bar->StepCount)
        return;

    Bar->CurrentStep = Step;

    /* Update the progress and redraw it if it has changed */
    if (Bar->UpdateProgressProc &&
        Bar->UpdateProgressProc(Bar, FALSE, TextBuffer, ARRAYSIZE(TextBuffer)))
    {
        coPos.X = Bar->Left + (Bar->Width - strlen(TextBuffer) + 1) / 2;
        coPos.Y = Bar->Top;
        WriteConsoleOutputCharacterA(StdOutput,
                                     TextBuffer,
                                     strlen(TextBuffer),
                                     coPos,
                                     &Written);
    }

    /* Calculate the bar position */
    NewPos = (((Bar->Width - 2) * 2 * Bar->CurrentStep + (Bar->StepCount / 2)) / Bar->StepCount);

    /* Redraw the bar if it has changed */
    if (Bar->Pos != NewPos)
    {
        Bar->Pos = NewPos;

        for (coPos.Y = Bar->Top + 2; coPos.Y <= Bar->Bottom - 1; coPos.Y++)
        {
            coPos.X = Bar->Left + 1;
            FillConsoleOutputCharacterA(StdOutput,
                                        0xDB,
                                        Bar->Pos / 2,
                                        coPos,
                                        &Written);
            coPos.X += Bar->Pos / 2;

            if (NewPos & 1)
            {
                FillConsoleOutputCharacterA(StdOutput,
                                            0xDD,
                                            1,
                                            coPos,
                                            &Written);
                coPos.X++;
            }

            if (coPos.X <= Bar->Right - 1)
            {
                FillConsoleOutputCharacterA(StdOutput,
                                            ' ',
                                            Bar->Right - coPos.X,
                                            coPos,
                                            &Written);
            }
        }
    }
}
Example #15
0
	u32 stuff( AtomicBitSet( &StuffToDo, ~job, 0x00000000 ) );
	if( stuff == 0 )
	{
		Dynarec_ClearedCPUStuffToDo();
	}
}

#ifdef DAEDALUS_ENABLE_SYNCHRONISATION
static const char * const kRegisterNames[] =
{
	"zr", "at", "v0", "v1", "a0", "a1", "a2", "a3",
	"t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
	"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
	"t8", "t9", "k0", "k1", "gp", "sp", "fp", "ra"
};
DAEDALUS_STATIC_ASSERT(ARRAYSIZE(kRegisterNames) == 32);

void SCPUState::Dump()
{
	DBGConsole_Msg(0, "Emulation CPU State:");
	{
		for(int i=0; i<32; i+=4)
		{
			DBGConsole_Msg(0, "%s:%08X %s:%08X %s:%08X %s:%08X",
			kRegisterNames[i+0], gCPUState.CPU[i+0]._u32_0,
			kRegisterNames[i+1], gCPUState.CPU[i+1]._u32_0,
			kRegisterNames[i+2], gCPUState.CPU[i+2]._u32_0,
			kRegisterNames[i+3], gCPUState.CPU[i+3]._u32_0);
		}

		DBGConsole_Msg(0, "TargetPC: %08x", gCPUState.TargetPC);
Example #16
0
#endif
	{ WLC_E_WAKE_EVENT, "WAKE_EVENT" },
	{ WLC_E_DCS_REQUEST, "DCS_REQUEST" },
	{ WLC_E_RM_COMPLETE, "RM_COMPLETE" },
#ifdef WLMEDIA_HTSF
	{ WLC_E_HTSFSYNC, "HTSF_SYNC_EVENT" },
#endif
	{ WLC_E_OVERLAY_REQ, "OVERLAY_REQ_EVENT" },
	{ WLC_E_CSA_COMPLETE_IND, "WLC_E_CSA_COMPLETE_IND"},
	{ WLC_E_EXCESS_PM_WAKE_EVENT, "EXCESS_PM_WAKE_EVENT" },
	{ WLC_E_PFN_SCAN_NONE, "PFN_SCAN_NONE" },
	{ WLC_E_PFN_SCAN_ALLGONE, "PFN_SCAN_ALLGONE" },
#ifdef SOFTAP
	{ WLC_E_GTK_PLUMBED, "GTK_PLUMBED" },
#endif
	{ WLC_E_ASSOC_REQ_IE, "ASSOC_REQ_IE" },
	{ WLC_E_ASSOC_RESP_IE, "ASSOC_RESP_IE" },
#ifdef WLTDLS
	{ WLC_E_TDLS_PEER_EVENT, "TDLS_PEER_EVENT" },
#endif /* WLTDLS */
	{ WLC_E_NATIVE, "NATIVE" },
#ifdef WLPKTDLYSTAT
	{ WLC_E_PKTDELAY_IND, "PKTDELAY_IND" },
#endif /* WLPKTDLYSTAT */
	{ WLC_E_SERVICE_FOUND, "SERVICE_FOUND" },
	{ WLC_E_GAS_FRAGMENT_RX, "GAS_FRAGMENT_RX" },
	{ WLC_E_GAS_COMPLETE, "GAS_COMPLETE" }
};

const int bcmevent_names_size = ARRAYSIZE(bcmevent_names);
// Fail Schedule
//=========================================================
Task_t	tlAssassinFail[] =
{
	{ TASK_STOP_MOVING,			0				},
	{ TASK_SET_ACTIVITY,		(float)ACT_IDLE },
	{ TASK_WAIT_FACE_ENEMY,		(float)2		},
	// { TASK_WAIT_PVS,			(float)0		},
	{ TASK_SET_SCHEDULE,		(float)SCHED_CHASE_ENEMY },
};

Schedule_t	slAssassinFail[] =
{
	{
		tlAssassinFail,
		ARRAYSIZE ( tlAssassinFail ),
		bits_COND_LIGHT_DAMAGE		|
		bits_COND_HEAVY_DAMAGE		|
		bits_COND_PROVOKED			|
		bits_COND_CAN_RANGE_ATTACK1 |
		bits_COND_CAN_RANGE_ATTACK2 |
		bits_COND_CAN_MELEE_ATTACK1 |
		bits_COND_HEAR_SOUND,
	
		bits_SOUND_DANGER |
		bits_SOUND_PLAYER,
		"AssassinFail"
	},
};

Example #18
0
STDAPI SHCoCreateInstance(LPCTSTR pszCLSID, const CLSID * pclsid,
                LPUNKNOWN pUnkOuter, REFIID riid, LPVOID FAR* ppv)
{
    HRESULT hres = ResultFromScode(REGDB_E_CLASSNOTREG);
    CLSID clsidT;
    TCHAR szClass[GUIDSTR_MAX+ARRAYSIZE(c_szInProcServer)];

    if (pclsid)
    {
        if (!pszCLSID)
        {
            StringFromGUID2A(pclsid, szClass, ARRAYSIZE(szClass));
        }
    }
    else
    {
        if (pszCLSID)
        {
            lstrcpy(szClass,pszCLSID);
            if (SUCCEEDED(SHCLSIDFromString(pszCLSID, &clsidT)))
                pclsid=&clsidT;
        }
    }


    if (pclsid)
    {
        LONG err;
        HKEY hkeyDll;
        IClassFactory *pCF;

        Assert(hres == ResultFromScode(REGDB_E_CLASSNOTREG));

        lstrcat(szClass,c_szInProcServer);  // Add "\InProcServer32"

        hres = _FindRegisteredClass(pclsid, &pCF);
        if (SUCCEEDED(hres))
        {
            hres = pCF->lpVtbl->CreateInstance(pCF, pUnkOuter, riid, ppv);
            pCF->lpVtbl->Release(pCF);
        }
        else
        {
            if (g_hkcrCLSID && RegOpenKey(g_hkcrCLSID, szClass, &hkeyDll) == ERROR_SUCCESS)
            {
                TCHAR szDllName[MAX_PATH];
                LONG cbValue = SIZEOF(szDllName);

                //            1         2         3
                //  012345678901234567890123456789012345678  = nul is at 38!
                // "{12345678-1234-1234-1234-123456789012}"
                //
                szClass[38] = TEXT('\0');   // Get rid of "\InProcServer32"

                err = RegQueryValue(hkeyDll, NULL, szDllName, &cbValue);

#ifdef WINNT
                //
                // On NT, we must check to ensure that this CLSID exists in
                // the list of approved CLSIDs that can be used in-process.
                // If not, we fail the creation with ERROR_ACCESS_DENIED.
                // We explicitly allow anything serviced by this DLL
                //

                if (err == ERROR_SUCCESS && NULL != g_hklmApprovedExt)
                {
                    TCHAR szBuf[MAX_PATH];

                    //
                    // Check to see if we are using this DLL
                    //
                    // BUGBUG Assumes no parameters in InProcServer32.  We
                    // should remove this assumption once we lose shellalt,
                    // after which we can just lstrcpyn(,,<length of dll name>);

                    LPCTSTR pszDllName = PathFindFileName(szDllName);

                    if (lstrcmp(pszDllName, TEXT("shell32.dll")) &&
                        lstrcmp(pszDllName, TEXT("shellalt.dll")))
                    {
                        DWORD dwType;
                        TCHAR szValue[MAX_PATH];
                        DWORD cbSize = SIZEOF(szValue);

                        if (ERROR_SUCCESS != RegQueryValueEx(g_hklmApprovedExt,
                                                             szClass,
                                                             0,
                                                             &dwType,
                                                             (LPBYTE) szValue,
                                                             &cbSize))
                        {
                            hres = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
                            return hres;
                        }
                    }
                }
#endif

                if (err == ERROR_SUCCESS)
                {
                    TCHAR szThreadingModel[MAX_PATH];
                    BOOL fMultiThreadAware = FALSE;
                    DWORD dwRegType;
                    DWORD cbRead = SIZEOF(szThreadingModel);

                    err = RegQueryValueEx(hkeyDll, c_szThreadingModel, NULL,
                            &dwRegType, (LPBYTE)szThreadingModel, &cbRead);
                    if (err == ERROR_SUCCESS && dwRegType == REG_SZ)
                    {
                        if (lstrcmpi(szThreadingModel, c_szApartment)==0
                            || lstrcmpi(szThreadingModel, c_szBoth)==0)
                        {
                            fMultiThreadAware = TRUE;
                        }
                    }

// #define HACK_APARTMENT_ONLY_ASSERT
#ifdef HACK_APARTMENT_ONLY_ASSERT
                    if (!fMultiThreadAware)
                    {
                        _asm {
                            int 3;
                        }
                    }
                    Assert(fMultiThreadAware);
                    hres = _CreateInstance(pclsid, szDllName, pUnkOuter, riid, ppv);
#else
                    if (fMultiThreadAware)
                    {
                        hres = _CreateInstance(pclsid, szDllName, pUnkOuter, riid, ppv);
                    }
                    else
                    {
                        Assert(hres == ResultFromScode(REGDB_E_CLASSNOTREG));
                        DebugMsg(DM_ERROR, TEXT("sh TR - SHCoCreateInstance !!! InProcServer32 (%s) does not support multi-threading"), szDllName);
                        Assert(0);
                    }
#endif

                }

                RegCloseKey(hkeyDll);
            }
Example #19
0
static struct Rotation3AnimData r3ad_101C24A0[] =
{
    { 0, { 0, 0, -32767 } },
    { 31, { 0, 0, -32767 } }
};

static struct Rotation3AnimData r3ad_101C24C0[] =
{
    { 0, { 0, -12315, 32735 } },
    { 31, { 0, -12315, 32735 } }
};

static struct AnimFrame_PosRot afpr_101C24E0[] =
{
    { v3ad_101C0A6C, NULL, ARRAYSIZE(v3ad_101C0A6C), 0 },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
    { NULL, r3ad_101C0A8C, 0, ARRAYSIZE(r3ad_101C0A8C) },
    { NULL, r3ad_101C0AAC, 0, ARRAYSIZE(r3ad_101C0AAC) },
    { NULL, r3ad_101C0ACC, 0, ARRAYSIZE(r3ad_101C0ACC) },
    { NULL, NULL, 0, 0 },
    { NULL, r3ad_101C0AF0, 0, ARRAYSIZE(r3ad_101C0AF0) },
    { NULL, r3ad_101C0CF0, 0, ARRAYSIZE(r3ad_101C0CF0) },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
    { NULL, r3ad_101C0EF0, 0, ARRAYSIZE(r3ad_101C0EF0) },
    { NULL, r3ad_101C0F10, 0, ARRAYSIZE(r3ad_101C0F10) },
    { NULL, r3ad_101C0F30, 0, ARRAYSIZE(r3ad_101C0F30) },
    { NULL, NULL, 0, 0 },
    { NULL, NULL, 0, 0 },
Example #20
0
/* <18805> ../engine/cvar.c:198 */
void EXT_FUNC Cvar_DirectSet_internal(struct cvar_s *var, const char *value)
{
	if (!var || !value)
	{
		return;
	}

	const char *pszValue = value;
	char szNew[MAX_CVAR_VALUE];
	szNew[0] = 0;

	if (var->flags & FCVAR_PRINTABLEONLY)
	{
		if (Q_UnicodeValidate(value))
		{
			Q_strncpy(szNew, value, ARRAYSIZE(szNew) - 1);
			szNew[ARRAYSIZE(szNew) - 1] = 0;
		}
		else
		{
			// Copy only printable chars
			// TODO: Why not UTF-8 too?
			const char *pS = pszValue;
			char *pD = szNew;

			while (*pS)
			{
				if (*pS < 32 || *pS > 126)
				{
					pS++;
					continue;
				}
				*pD++ = *pS++;
			}
			*pD = 0;
		}

		if (!Q_UnicodeValidate(szNew))
		{
			// Call the artillery
			Q_UnicodeRepair(szNew);
		}

		if (szNew[0] == 0)
		{
			Q_strcpy(szNew, "empty");
		}

		pszValue = szNew;
	}

	if (var->flags & FCVAR_NOEXTRAWHITEPACE)
	{
		if (pszValue != szNew)
		{
			Q_strncpy(szNew, value, ARRAYSIZE(szNew) - 1);
			szNew[ARRAYSIZE(szNew) - 1] = 0;
		}

		Q_StripUnprintableAndSpace(szNew);

		pszValue = szNew;
	}

	qboolean changed = Q_strcmp(var->string, pszValue);

	if (var->flags & FCVAR_USERINFO)
	{
		if (g_pcls.state == ca_dedicated)
		{
			char *info = Info_Serverinfo();
			Info_SetValueForKey(info, var->name, pszValue, MAX_INFO_STRING);
			SV_BroadcastCommand("fullserverinfo \"%s\"\n", info);
		}
#ifndef SWDS
		else
		{
			Info_SetValueForKey(g_pcls.userinfo, var->name, pszValue, MAX_INFO_STRING);

			if (changed && g_pcls.state >= ca_connected)
			{
				MSG_WriteByte(&g_pcls.netchan.message, clc_stringcmd);
				SZ_Print(&g_pcls.netchan.message, va("setinfo \"%s\" \"%s\"\n", var->name, pszValue));
			}
		}
#endif
	}

	if (changed && var->flags & FCVAR_SERVER)
	{
		if (!(var->flags & FCVAR_UNLOGGED))
		{
			if (var->flags & FCVAR_PROTECTED)
			{
				Log_Printf("Server cvar \"%s\" = \"%s\"\n", var->name, "***PROTECTED***");
				SV_BroadcastPrintf("\"%s\" changed to \"%s\"\n", var->name, "***PROTECTED***");
			}
			else
			{
				Log_Printf("Server cvar \"%s\" = \"%s\"\n", var->name, pszValue);
				SV_BroadcastPrintf("\"%s\" changed to \"%s\"\n", var->name, pszValue);
			}
		}

		if (!(var->flags & FCVAR_PROTECTED))
		{
			Steam_SetCVar(var->name, pszValue);
		}
		else if (pszValue[0] && Q_stricmp(pszValue, "none"))
		{
			Steam_SetCVar(var->name, "1");
		}
		else
		{
			Steam_SetCVar(var->name, "0");
		}
	}

	Z_Free(var->string);
	var->string = (char *)Z_Malloc(Q_strlen(pszValue) + 1);
	Q_strcpy(var->string, pszValue);
	var->value = (float)Q_atof(var->string);
}
Example #21
0
bool wceInvokeCabSetup(const char *wceload_params)
{
	HRESULT hr = S_OK;
	WCHAR wszCabFile[MAX_PATH];

	//convert pathname
	int nResult = 0;
	int len = strlen(wceload_params)+1;
	nResult = MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED, wceload_params, len, wszCabFile, ARRAYSIZE(wszCabFile));
	if(0 == nResult)
		return false;

	wceConnect();

	DWORD dwInSize = sizeof(wszCabFile);
	DWORD dwOutSize = 0;
	BYTE *pInBuff = NULL;
	
	pInBuff = (BYTE *)LocalAlloc(LPTR, dwInSize);
	memcpy(pInBuff, &wszCabFile, dwInSize);

	hr = CeRapiInvoke(TEXT("\\rhosetup"), TEXT("rhoCabSetup"), dwInSize, pInBuff, &dwOutSize, NULL, NULL, 0);
	if(FAILED(hr)) {
		//printf("Failed to setup cab!\r\n");
		return false;
	}
	wceDisconnect();

	return true ;
}
Example #22
0
/* <18d23> ../engine/cvar.c:671 */
void Cmd_CvarList_f(void)
{
	cvar_t *var;
	int iCvars;
	int iArgs;
	const char *partial, *arg1;
	int ipLen;
	qboolean bAOnly;
	qboolean bSOnly;
	char szTemp[MAX_PATH];
	FileHandle_t f;
	FileHandle_t fp;
	qboolean bLogging;

	iCvars = 0;
	partial = NULL;
	bAOnly = FALSE;
	bSOnly = FALSE;
	f = NULL;
	fp = NULL;
	bLogging = FALSE;

	iArgs = Cmd_Argc();
	if (iArgs > 1)
	{
		arg1 = Cmd_Argv(1);

		if (!Q_stricmp(arg1, "?"))
		{
			Con_Printf("CvarList           : List all cvars\nCvarList [Partial] : List cvars starting with 'Partial'\nCvarList log [Partial] : Logs cvars to file \"cvarlist.txt\" in the gamedir.\n");
			return;
		}

		if (!Q_stricmp(arg1, "log"))
		{
			// Open log
			int i;
			for (i = 0; i < 100; i++)
			{
				Q_snprintf(szTemp, ARRAYSIZE(szTemp) - 1, "cvarlist%02d.txt", i);
				szTemp[ARRAYSIZE(szTemp) - 1] = 0;

				fp = FS_Open(szTemp, "r");
				if (!fp)
				{
					break;
				}
				FS_Close(fp);
			}

			if (i >= 100)
			{
				Con_Printf("Can't cvarlist! Too many existing cvarlist output files in the gamedir!\n");
				return;
			}

			f = FS_Open(szTemp, "wt");
			if (!f)
			{
				Con_Printf("Couldn't open \"%s\" for writing!\n", szTemp);
				return;
			}
			bLogging = TRUE;

			// Get next argument into partial, if present
			if (iArgs > 2)
			{
				partial = Cmd_Argv(2);
				ipLen = Q_strlen(partial);
			}
		}
		else if (!Q_stricmp(arg1, "-a"))
		{
			bAOnly = TRUE;
		}
		else if (!Q_stricmp(arg1, "-s"))
		{
			bSOnly = TRUE;
		}
		else
		{
			partial = arg1;
			ipLen = Q_strlen(partial);
		}
	}

	// Print cvars
	Con_Printf("CVar List\n--------------\n");

	for (var = cvar_vars; var; var = var->next)
	{
		if (bAOnly && !(var->flags & FCVAR_ARCHIVE))
		{
			continue;
		}
		if (bSOnly && !(var->flags & FCVAR_SERVER))
		{
			continue;
		}
		if (partial && Q_strnicmp(var->name, partial, ipLen))
		{
			continue;
		}

		Cmd_CvarListPrintCvar(var, f);
		iCvars++;
	}

	if (partial && *partial)
	{
		Con_Printf("--------------\n%3i CVars for [%s]\nCvarList ? for syntax\n", iCvars, partial);
	}
	else
	{
		Con_Printf("--------------\n%3i Total CVars\nCvarList ? for syntax\n", iCvars);
	}

	// Close log
	if (bLogging)
	{
		FS_Close(f);
		Con_Printf("cvarlist logged to %s\n", szTemp);
	}
}
// プログラマブルシェーダ作成
HRESULT MakeShaders( void )
{
    HRESULT hr;
    ID3DBlob* pVertexShaderBuffer = NULL;
    ID3DBlob* pPixelShaderBuffer = NULL;
    ID3DBlob* pError = NULL;

    DWORD dwShaderFlags = 0;
#ifdef _DEBUG
    dwShaderFlags |= D3DCOMPILE_DEBUG;
#endif
    // コンパイル
    hr = D3DX11CompileFromFile( _T( "Basic_2D.fx" ), NULL, NULL, "VS", "vs_4_0_level_9_1",
								dwShaderFlags, 0, NULL, &pVertexShaderBuffer, &pError, NULL );
    if ( FAILED( hr ) ) {
		MessageBox( NULL, _T( "Can't open Basic_2D.fx" ), _T( "Error" ), MB_OK );
        SAFE_RELEASE( pError );
        return hr;
    }
    hr = D3DX11CompileFromFile( _T( "Basic_2D.fx" ), NULL, NULL, "PS", "ps_4_0_level_9_1",
								dwShaderFlags, 0, NULL, &pPixelShaderBuffer, &pError, NULL );
    if ( FAILED( hr ) ) {
        SAFE_RELEASE( pVertexShaderBuffer );
        SAFE_RELEASE( pError );
        return hr;
    }
    SAFE_RELEASE( pError );
    
    // VertexShader作成
    hr = g_pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(),
										   pVertexShaderBuffer->GetBufferSize(),
										   NULL, &g_pVertexShader );
    if ( FAILED( hr ) ) {
        SAFE_RELEASE( pVertexShaderBuffer );
        SAFE_RELEASE( pPixelShaderBuffer );
        return hr;
    }
    // PixelShader作成
    hr = g_pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(),
										  pPixelShaderBuffer->GetBufferSize(),
										  NULL, &g_pPixelShader );
    if ( FAILED( hr ) ) {
        SAFE_RELEASE( pVertexShaderBuffer );
        SAFE_RELEASE( pPixelShaderBuffer );
        return hr;
    }

    // 入力バッファの入力形式
    D3D11_INPUT_ELEMENT_DESC layout[] = {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "COLOR",    0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXTURE",  0, DXGI_FORMAT_R32G32_FLOAT,       0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    };
	UINT numElements = ARRAYSIZE( layout );
	// 入力バッファの入力形式作成
    hr = g_pd3dDevice->CreateInputLayout( layout, numElements,
										  pVertexShaderBuffer->GetBufferPointer(),
										  pVertexShaderBuffer->GetBufferSize(),
										  &g_pInputLayout );
    SAFE_RELEASE( pVertexShaderBuffer );
    SAFE_RELEASE( pPixelShaderBuffer );
    if ( FAILED( hr ) ) {
        return hr;
    }

    // シェーダ定数バッファ作成
    D3D11_BUFFER_DESC bd;
    ZeroMemory( &bd, sizeof( bd ) );
    bd.Usage = D3D11_USAGE_DEFAULT;
    bd.ByteWidth = sizeof( CBNeverChanges );
    bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    bd.CPUAccessFlags = 0;
    hr = g_pd3dDevice->CreateBuffer( &bd, NULL, &g_pCBNeverChanges );
    if( FAILED( hr ) )
        return hr;

	// 変換行列
    CBNeverChanges	cbNeverChanges;
	XMMATRIX		mScreen;
    mScreen = XMMatrixIdentity();
	mScreen._11 =  2.0f / g_nClientWidth;
	mScreen._22 = -2.0f / g_nClientHeight;
	mScreen._41 = -1.0f;
	mScreen._42 =  1.0f;
	cbNeverChanges.mView = XMMatrixTranspose( mScreen );
	g_pImmediateContext->UpdateSubresource( g_pCBNeverChanges, 0, NULL, &cbNeverChanges, 0, 0 );

    return S_OK;
}
};

static struct test_address _addrs[] = {
  {
    .addr = _addr1,
    .plen = 32,
  },
  {
    .addr = _addr2,
    .plen = 32,
  },
  {
    .addr = _addr3,
    .plen = 32,

    .tlv_count = ARRAYSIZE(_addrtlv1),
    .tlvs = _addrtlv1,
  },
  {
    .addr = _addr4,
    .plen = 32,

    .tlv_count = ARRAYSIZE(_addrtlv1),
    .tlvs = _addrtlv1,
  },
  {
    .addr = _addr5,
    .plen = 16,

    .tlv_count = ARRAYSIZE(_addrtlv1),
    .tlvs = _addrtlv1,
Example #25
0
void DoUnwrap(EditorInfo &ei)
{
	INT_PTR iRc = 0;
	INT_PTR cchMax = 0, cchPos = 0;
	TCHAR* pszCopy = NULL;
	TCHAR szEOL[4];
	bool bWasModifed = (ei.CurState & ECSTATE_MODIFIED) && !(ei.CurState & ECSTATE_SAVED);

	gbLastWrap = FALSE;
	
	for (INT_PTR i = 0; i < ei.TotalLines; i++)
	{
		EditorGetString egs = {FARSTRUCTSIZE(egs)};
		egs.StringNumber = i;
		iRc = EditCtrl(ECTL_GETSTRING, &egs);
		if (!iRc)
		{
			_ASSERTE(iRc!=0);
			goto wrap;
		}
		_ASSERTE(egs.StringText!=NULL);
		
		if (egs.StringEOL && *egs.StringEOL)
		{
			// В этой строке есть EOL, ее не сворачивали
			continue;
		}
		
		cchPos = 0;
		szEOL[0] = 0;
		INT_PTR j = i;
		while (j < ei.TotalLines)
		{
			if (!pszCopy || ((egs.StringLength + cchPos + 65536) > cchMax))
			{
				cchMax = egs.StringLength + cchPos + 65536;
				TCHAR* pszNew = (TCHAR*)malloc(cchMax*sizeof(*pszCopy));
				if (!pszNew)
				{
					_ASSERTE(pszNew!=NULL);
					goto wrap;
				}
				if (pszCopy)
				{
					if (cchPos > 0)
						memmove(pszNew, pszCopy, cchPos*sizeof(*pszCopy));
					free(pszCopy);
				}
				pszCopy = pszNew;
			}
			
			if (egs.StringLength > 0)
			{
				memmove(pszCopy+cchPos, egs.StringText, egs.StringLength*sizeof(*pszCopy));
				cchPos += egs.StringLength;
			}

			bool lbApplyAndBreak = false;

			if (*szEOL)
			{
				lbApplyAndBreak = true;
			}

			// Получить следующую строку
			if ((j+1) >= ei.TotalLines)
			{
				lbApplyAndBreak = true;
			}
			else if (!lbApplyAndBreak)
			{
				egs.StringNumber = ++j;
				iRc = EditCtrl(ECTL_GETSTRING, &egs);
				if (!iRc)
				{
					_ASSERTE(iRc!=0);
					goto wrap;
				}
				_ASSERTE(egs.StringText!=NULL);
				if (egs.StringEOL && *egs.StringEOL)
				{
					// В этой строке есть EOL, ее не сворачивали
					lstrcpyn(szEOL, egs.StringEOL?egs.StringEOL:_T(""), ARRAYSIZE(szEOL));
				}
			}
			
			if (lbApplyAndBreak)
			{
				EditorSetString esset = {FARSTRUCTSIZE(esset)};
				esset.StringNumber = i;
				esset.StringText = pszCopy;
				esset.StringEOL = szEOL;
				esset.StringLength = cchPos;
				EditCtrl(ECTL_SETSTRING, &esset);
				
				for (INT_PTR k = i+1; k <= j; k++)
				{
					// Для ECTL_DELETESTRING нужно установить курсор
					EditorSetPosition eset = {FARSTRUCTSIZE(eset)};
					eset.CurLine = i+1;
					eset.TopScreenLine = -1;
					iRc = EditCtrl(ECTL_SETPOSITION, &eset);
					_ASSERTE(iRc);
					// Удаляем "свернутое"
					iRc = EditCtrl(ECTL_DELETESTRING, NULL);
					_ASSERTE(iRc);
					ei.TotalLines--;
					if (ei.CurLine > i)
						ei.CurLine--;
				}
				
				// Выход из while
				break;
			}
		}
	}
	
	// Обновить позицию курсора
	{
		EditorSetPosition eset = {FARSTRUCTSIZE(eset)};
		eset.CurLine = ei.CurLine;
		eset.TopScreenLine = -1;
		EditCtrl(ECTL_SETPOSITION, &eset);
	}
	
wrap:
	if (pszCopy)
		free(pszCopy);

#ifdef _UNICODE
	// Сброс флага "редактирован"
	//TODO: bis-сборка?
	if (!bWasModifed)
		EditCtrl(ECTL_DROPMODIFEDFLAG, NULL);
#endif
}
Example #26
0
void CBreakable::KeyValue( KeyValueData* pkvd )
{
	// UNDONE_WC: explicitly ignoring these fields, but they shouldn't be in the map file!
	if (FStrEq(pkvd->szKeyName, "explosion"))
	{
		if (!stricmp(pkvd->szValue, "directed"))
			m_Explosion = expDirected;
		else if (!stricmp(pkvd->szValue, "random"))
			m_Explosion = expRandom;
		else
			m_Explosion = expRandom;

		pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "material"))
	{
		int i = atoi( pkvd->szValue);

		// 0:glass, 1:metal, 2:flesh, 3:wood

		if ((i < 0) || (i >= matLastMaterial))
			m_Material = matWood;
		else
			m_Material = (Materials)i;

		pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "deadmodel"))
	{
		pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "shards"))
	{
//			m_iShards = atof(pkvd->szValue);
			pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "gibmodel") )
	{
		m_iszGibModel = ALLOC_STRING(pkvd->szValue);
		pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "spawnobject") )
	{
		int object = atoi( pkvd->szValue );
		if ( object > 0 && object < ARRAYSIZE(pSpawnObjects) )
			m_iszSpawnObject = MAKE_STRING( pSpawnObjects[object] );
		pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "explodemagnitude") )
	{
		ExplosionSetMagnitude( atoi( pkvd->szValue ) );
		pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "lip") )
		pkvd->fHandled = TRUE;
	else if (FStrEq(pkvd->szKeyName, "respawn") ) //LRC
	{
		m_iRespawnTime = atoi( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "whenhit") ) //LRC
	{
		m_iszWhenHit = ALLOC_STRING(pkvd->szValue);
		pkvd->fHandled = TRUE;
	}
	else if (FStrEq(pkvd->szKeyName, "m_iClass") )
	{
		m_iClass = atoi( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else
		CBaseDelay::KeyValue( pkvd );
}
Example #27
0
SciEvent EventManager::getScummVMEvent() {
#ifdef ENABLE_SCI32
	SciEvent input = { SCI_EVENT_NONE, 0, 0, Common::Point(), Common::Point() };
	SciEvent noEvent = { SCI_EVENT_NONE, 0, 0, Common::Point(), Common::Point() };
#else
	SciEvent input = { SCI_EVENT_NONE, 0, 0, Common::Point() };
	SciEvent noEvent = { SCI_EVENT_NONE, 0, 0, Common::Point() };
#endif

	Common::EventManager *em = g_system->getEventManager();
	Common::Event ev;

	bool found = em->pollEvent(ev);

	// Don't generate events for mouse movement
	while (found && ev.type == Common::EVENT_MOUSEMOVE)
		found = em->pollEvent(ev);

	// Save the mouse position
	//
	// We call getMousePos of the event manager here, since we also want to
	// store the mouse position in case of keyboard events, which do not feature
	// any mouse position information itself.
	// This should be safe, since the mouse position in the event manager should
	// only be updated when a mouse related event has been taken from the queue
	// via pollEvent.
	// We also adjust the position based on the scaling of the screen.
	Common::Point mousePos = em->getMousePos();

#if ENABLE_SCI32
	if (getSciVersion() >= SCI_VERSION_2) {
		Buffer &screen = g_sci->_gfxFrameout->getCurrentBuffer();

		Common::Point mousePosSci = mousePos;
		mulru(mousePosSci, Ratio(screen.scriptWidth, screen.screenWidth), Ratio(screen.scriptHeight, screen.screenHeight));
		noEvent.mousePosSci = input.mousePosSci = mousePosSci;
	} else {
#endif
		g_sci->_gfxScreen->adjustBackUpscaledCoordinates(mousePos.y, mousePos.x);
#if ENABLE_SCI32
	}
#endif

	noEvent.mousePos = input.mousePos = mousePos;

	if (!found || ev.type == Common::EVENT_MOUSEMOVE) {
		int modifiers = em->getModifierState();
		noEvent.modifiers =
			((modifiers & Common::KBD_ALT) ? SCI_KEYMOD_ALT : 0) |
			((modifiers & Common::KBD_CTRL) ? SCI_KEYMOD_CTRL : 0) |
			((modifiers & Common::KBD_SHIFT) ? SCI_KEYMOD_LSHIFT | SCI_KEYMOD_RSHIFT : 0);

		return noEvent;
	}
	if (ev.type == Common::EVENT_QUIT) {
		input.type = SCI_EVENT_QUIT;
		return input;
	}

	int scummVMKeyFlags;

	switch (ev.type) {
	case Common::EVENT_KEYDOWN:
	case Common::EVENT_KEYUP:
		// Use keyboard modifiers directly in case this is a keyboard event
		scummVMKeyFlags = ev.kbd.flags;
		break;
	default:
		// Otherwise get them from EventManager
		scummVMKeyFlags = em->getModifierState();
		break;
	}

	input.modifiers =
		((scummVMKeyFlags & Common::KBD_ALT) ? SCI_KEYMOD_ALT : 0) |
		((scummVMKeyFlags & Common::KBD_CTRL) ? SCI_KEYMOD_CTRL : 0) |
		((scummVMKeyFlags & Common::KBD_SHIFT) ? SCI_KEYMOD_LSHIFT | SCI_KEYMOD_RSHIFT : 0);
		// Caps lock and Scroll lock have been removed, cause we already handle upper
		// case keys and Scroll lock doesn't seem to be used anywhere
		//((ourModifiers & Common::KBD_CAPS) ? SCI_KEYMOD_CAPSLOCK : 0) |
		//((ourModifiers & Common::KBD_SCRL) ? SCI_KEYMOD_SCRLOCK : 0) |

	// Handle mouse events
	for (int i = 0; i < ARRAYSIZE(mouseEventMappings); i++) {
		if (mouseEventMappings[i].commonType == ev.type) {
			input.type = mouseEventMappings[i].sciType;
			// Sierra passed keyboard modifiers for mouse events, too.

			// Sierra also set certain modifiers within their mouse interrupt handler
			// This whole thing was probably meant for people using a mouse, that only featured 1 button
			// So the user was able to press Ctrl and click the mouse button to create a right click.
			switch (ev.type) {
			case Common::EVENT_RBUTTONDOWN: // right button
			case Common::EVENT_RBUTTONUP:
				input.modifiers |= (SCI_KEYMOD_RSHIFT | SCI_KEYMOD_LSHIFT); // this value was hardcoded in the mouse interrupt handler
				break;
			case Common::EVENT_MBUTTONDOWN: // middle button
			case Common::EVENT_MBUTTONUP:
				input.modifiers |= SCI_KEYMOD_CTRL; // this value was hardcoded in the mouse interrupt handler
				break;
			default:
				break;
			}
			return input;
		}
	}

	// If we reached here, make sure that it's a keydown event
	if (ev.type != Common::EVENT_KEYDOWN)
		return noEvent;

	// Check for Control-Shift-D (debug console)
	if (ev.kbd.hasFlags(Common::KBD_CTRL | Common::KBD_SHIFT) && ev.kbd.keycode == Common::KEYCODE_d) {
		// Open debug console
		Console *con = g_sci->getSciDebugger();
		con->attach();
		return noEvent;
	}

	// Process keyboard events

	bool numlockOn = (ev.kbd.flags & Common::KBD_NUM);

	Common::KeyCode scummVMKeycode = ev.kbd.keycode;

	input.character = ev.kbd.ascii;
	input.type = SCI_EVENT_KEYBOARD;

	if (scummVMKeycode >= Common::KEYCODE_KP0 && scummVMKeycode <= Common::KEYCODE_KP9) {
		if (!(scummVMKeyFlags & Common::KBD_NUM)) {
			// HACK: Num-Lock not enabled
			// We shouldn't get a valid ascii code in these cases. We fix it here, so that cursor keys
			// on the numpad work properly.
			input.character = 0;
		}
	}

	if ((input.character) && (input.character <= 0xFF)) {
		// Directly accept most common keys without conversion
		if ((input.character >= 0x80) && (input.character <= 0xFF)) {
			// If there is no extended font, we will just clear the
			// current event.
			// Sierra SCI actually accepted those characters, but
			// didn't display them inside text edit controls because
			// the characters were missing inside the font(s).
			// We filter them out for non-multilingual games because
			// of that.
			if (!_fontIsExtended)
				return noEvent;
			// Convert 8859-1 characters to DOS (cp850/437) for
			// multilingual SCI01 games
			input.character = codePageMap88591ToDOS[input.character & 0x7f];
		}
		if (scummVMKeycode == Common::KEYCODE_TAB) {
			input.character = SCI_KEY_TAB;
			if (scummVMKeyFlags & Common::KBD_SHIFT)
				input.character = SCI_KEY_SHIFT_TAB;
		}
		if (scummVMKeycode == Common::KEYCODE_DELETE)
			input.character = SCI_KEY_DELETE;
	} else if ((scummVMKeycode >= Common::KEYCODE_F1) && scummVMKeycode <= Common::KEYCODE_F10) {
		// SCI_K_F1 == 59 << 8
		// SCI_K_SHIFT_F1 == 84 << 8
		if (!(scummVMKeyFlags & Common::KBD_SHIFT))
			input.character = SCI_KEY_F1 + ((scummVMKeycode - Common::KEYCODE_F1)<<8);
		else
			input.character = SCI_KEY_SHIFT_F1 + ((scummVMKeycode - Common::KEYCODE_F1)<<8);
	} else {
		// Special keys that need conversion
		for (int i = 0; i < ARRAYSIZE(keyMappings); i++) {
			if (keyMappings[i].scummVMKey == scummVMKeycode) {
				input.character = numlockOn ? keyMappings[i].sciKeyNumlockOn : keyMappings[i].sciKeyNumlockOff;
				break;
			}
		}
	}

	// When Ctrl AND Alt are pressed together with a regular key, Linux will give us control-key, Windows will give
	//  us the actual key. My opinion is that windows is right, because under DOS the keys worked the same, anyway
	//  we support the other case as well
	if ((scummVMKeyFlags & Common::KBD_ALT) && input.character > 0 && input.character < 27)
		input.character += 96; // 0x01 -> 'a'

	// Scancodify if appropriate
	if (scummVMKeyFlags & Common::KBD_ALT)
		input.character = altify(input.character);
	if (getSciVersion() <= SCI_VERSION_1_MIDDLE && (scummVMKeyFlags & Common::KBD_CTRL) && input.character > 0 && input.character < 27)
		input.character += 96; // 0x01 -> 'a'
#ifdef ENABLE_SCI32
	if (getSciVersion() >= SCI_VERSION_2 && (scummVMKeyFlags & Common::KBD_CTRL) && input.character == 'c') {
		input.character = SCI_KEY_ETX;
	}
#endif

	// If no actual key was pressed (e.g. if only a modifier key was pressed),
	// ignore the event
	if (!input.character)
		return noEvent;

	return input;
}
Example #28
0
BOOL
CheckThreads (
    __in DWORD ProcId
    )
/*++

Routine Description:

    Enumerates all threads (or optionally only threads for one
    process) in the system.  It the calls the WCT API on each of them.

Arguments:

    ProcId--Specifies the process ID to analyze.  If '0' all processes
        in the system will be checked.

Return Value:

    TRUE if processes could be checked; FALSE if a general failure
    occurred.

--*/
{
    DWORD processes[1024];
    DWORD numProcesses;
    DWORD i;

    // Try to enable the SE_DEBUG_NAME privilege for this process.  We
    // continue even if this fails--we just won't be able to retrieve
    // wait chains for processes not owned by the current user.
    if (!GrantDebugPrivilege())
    {
        printf("Couldn't enable debug privilege");
    }

    // Get a list of all processes currently running.
    if (EnumProcesses(processes, sizeof(processes), &numProcesses) == FALSE)
    {
        printf("Couldn't enumerate processes");
        return FALSE;
    }

    for (i = 0; i < numProcesses / sizeof(DWORD); i++)
    {
        HANDLE process;
        HANDLE snapshot;

        if (processes[i] == GetCurrentProcessId())
        {
            continue;
        }

        // If the caller specified a Process ID, check if we have a match.
        if (ProcId != 0)
        {
            if (processes[i] != ProcId)
            {
                continue;
            }
        }

        // Get a handle to this process.
        process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processes[i]);
        if (process)
        {
            WCHAR file[MAX_PATH];

            printf("Process 0x%x - ", processes[i]);

            // Retrieve the EXE's name and print it.
            if (GetProcessImageFileName(process, file, ARRAYSIZE(file)) > 0)
            {
                PCWSTR filePart = wcsrchr(file, L'\\');
                if (filePart)
                {
                    filePart++;
                }
                else
                {
                    filePart = file;
                }

                printf("%S", filePart);
            }

            printf("\n----------------------------------\n");

            // Get a snapshot of this process.  This allows us to
            // enumerate its threads.
            snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD,
                                                processes[i]);
            if (snapshot)
            {
                THREADENTRY32 thread;
                thread.dwSize = sizeof(thread);

                // Walk the thread list and print the wait chain
                // for each.
                if (Thread32First(snapshot, &thread))
                {
                    do
                    {
                        if (thread.th32OwnerProcessID == processes[i])
                        {
                            // Open a handle to this specific thread,...
                            HANDLE threadHandle = OpenThread(THREAD_ALL_ACCESS,
                                                             FALSE,
                                                             thread.th32ThreadID);
                            if (threadHandle)
                            {
                                // ...check if it is still running,...
                                DWORD exitCode;
                                GetExitCodeThread(threadHandle, &exitCode);

                                if (exitCode == STILL_ACTIVE)
                                {
                                    // ...and print its wait chain.
                                    PrintWaitChain(thread.th32ThreadID);
                                }

                                CloseHandle(threadHandle);
                            }
                        }
                    } while (Thread32Next(snapshot, &thread));
                }
                CloseHandle(snapshot);
            }

            CloseHandle(process);
            printf("\n");
        }
    }
    return TRUE;
}
Example #29
0
{
    { 0 | MeshPolyType_StripsB, 7, strips_1011D988, 0, NULL, NULL, uv_1011DA08, 0 }
};

static struct MATERIAL mat_1011D974[] =
{
    {
        0xFFB2B2B2,
        0x00FFFFFF,
        11.0f,
        0x00000020,
        0xA400,
        0x29,
        0x94
    }
};

struct ATTACH attach_1011DD40 =
{
    vec3_1011DB00,
    vec3_1011DC20,
    ARRAYSIZE(vec3_1011DB00),
    mesh_1011DAE0,
    mat_1011D974,
    ARRAYSIZE(mesh_1011DAE0),
    ARRAYSIZE(mat_1011D974),
    { 1.479647f, 0.037022f, 0.262757f },
    2.904496f,
    0
};
uint32 EXT_FUNC CGameClient::GetVoiceStream(int stream_id) {
	if (stream_id >= 0 && stream_id < ARRAYSIZE(m_pClient->m_VoiceStreams))
		return m_pClient->m_VoiceStreams[stream_id];
	return 0;
}