CString PropVariantToString(const PROPVARIANT& propVar)
{
	USES_CONVERSION;
	CString sPropValue;
	variant_t varPropValue;
   CStdString val;
	if (SUCCEEDED(VariantChangeType(&varPropValue, (VARIANTARG*)&propVar, VARIANT_LOCALBOOL, VT_BSTR)))
		sPropValue = varPropValue.bstrVal;
	else
	{
		//VT_BLOB and VT_LPSTR are uncommon co-ercions
		switch(propVar.vt)
		{
		case VT_BLOB:
			sPropValue.Format(_T("%s"), CW2T((LPCWSTR)propVar.blob.pBlobData).operator LPWSTR());
			break;
		case VT_LPSTR:
         val = MultiByteSupport::ACPToWide(propVar.pszVal);
         sPropValue = val;
			break;
		case VT_LPWSTR:
			sPropValue.Format(_T("%s"), CW2T(propVar.pwszVal).operator LPWSTR());
      	break;
		case VT_FILETIME:
			sPropValue = FiletimeAsString(propVar.filetime);
			break;
		}
	}
	return sPropValue;
}
Beispiel #2
0
VARIANT CBoxEncoding::StrToBin(VARIANT& var, VARIANT &varCP)
{
	CBoxBinPtr varString(var, VT_BSTR);
	UINT nCodePage;

	if(varCP.vt == VT_ERROR)
		nCodePage = _AtlGetConversionACP();
	else
	{
		CComVariant varTemp;

		varTemp.ChangeType(VT_I4, &varCP);
		if(varTemp.vt == VT_I4)
			nCodePage = varTemp.lVal;
		else
			AfxThrowOleException(TYPE_E_TYPEMISMATCH);
	}

	int _nTempCount = ::WideCharToMultiByte(nCodePage, 0, LPWSTR(varString.m_pData), varString.m_nSize, NULL, 0, NULL, NULL);
	CBoxBinPtr varPtr(_nTempCount);

	::WideCharToMultiByte(nCodePage, 0, LPWSTR(varString.m_pData), varString.m_nSize, varPtr, _nTempCount, NULL, NULL);

	return varPtr;
}
void PropertyPageHandler_BaseReloc::OnInitDialog()
{
	// Insert Tabs
	TCITEM item;

	for (int i = 0; i < m_PEReaderWriter.getNoOfBaseRelocationTables(); ++i)
	{
		item.mask = TCIF_TEXT;
		item.pszText = LPWSTR(_wcsdup(wstring(L"Table " + DWORD_toString(i + 1)).c_str()));

		TabCtrl_InsertItem(m_hTabsBaseReloc, i, &item);
		free(item.pszText);
	}

	// Insert ListView columns
	LV_COLUMN column;
	ZeroMemory(&column, sizeof(LV_COLUMN));

	for (size_t i = 0; i < ARRAYSIZE(szGenericColumnText); ++i)
	{
		column.mask = LVCF_TEXT;
		column.pszText = szGenericColumnText[i];

		ListView_InsertColumn(m_hListViewBaseRelocTable, i, &column);
	}

	tabsBaseRelocations_OnTabChanged(m_hWnd, 0);
}
Beispiel #4
0
bool CertStore::add( const QSslCertificate &cert, const QString &card )
{
	if( !d->s )
		return false;

	SslCertificate c( cert );
	DWORD keyCode = c.keyUsage().contains( SslCertificate::NonRepudiation ) ? AT_SIGNATURE : AT_KEYEXCHANGE;
	QString cardStr = card + (keyCode == AT_SIGNATURE ? "_SIG" : "_AUT" );
	cardStr = QCryptographicHash::hash( cardStr.toUtf8(), QCryptographicHash::Md5 ).toHex();

	PCCERT_CONTEXT context = d->certContext( cert );

	QString str = QString( "%1 %2" )
		.arg( keyCode == AT_SIGNATURE ? "Signature" : "Authentication" )
		.arg( c.toString( "SN, GN" ).toUpper() );
	CRYPT_DATA_BLOB DataBlob = { (str.length() + 1) * sizeof(QChar), (BYTE*)str.utf16() };
	CertSetCertificateContextProperty( context, CERT_FRIENDLY_NAME_PROP_ID, 0, &DataBlob );

	CRYPT_KEY_PROV_INFO KeyProvInfo =
	{ LPWSTR(cardStr.utf16()), L"Microsoft Base Smart Card Crypto Provider", PROV_RSA_FULL, 0, 0, 0, keyCode };
	CertSetCertificateContextProperty( context, CERT_KEY_PROV_INFO_PROP_ID, 0, &KeyProvInfo );

	bool result = CertAddCertificateContextToStore( d->s, context, CERT_STORE_ADD_REPLACE_EXISTING, 0 );
	CertFreeCertificateContext( context );
	return result;
}
void LoadBitmaps()
{
	//Getting the address(es) of bitmaps
	OPENFILENAME ofn;
	char szFile[10000];//Large allocation for selection of many files
	ZeroMemory(&ofn, sizeof(ofn));
	ofn.lStructSize = sizeof(ofn);
	ofn.hwndOwner = NULL;
	ofn.lpstrFile = LPWSTR(szFile);
	ofn.lpstrFile[0] = '\0';
	ofn.nMaxFile = sizeof(szFile);
	ofn.lpstrFilter = L"Bitmap file (*.bmp)\0*.bmp\0\0";//Filter to only bitmap files
	ofn.nFilterIndex = 1;
	ofn.lpstrFileTitle = NULL;
	ofn.nMaxFileTitle = 0;
	ofn.lpstrInitialDir = NULL;
	ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_EXPLORER;
	GetOpenFileName(&ofn);
	
	//Newly loaded bitmaps will replace existing ones
	for (unsigned int i = 0; i < bitmapsToDraw.size(); i++)
	{
		DeleteObject(bitmapsToDraw[i]);
	}
	bitmapsToDraw.clear();


	//To break up the files into each individual name
	wchar_t* _wsfileStr = ofn.lpstrFile;
	std::wstring directory = _wsfileStr;
	_wsfileStr += (directory.length() + 1);
	//Used if one file is selected
	if (!*_wsfileStr)
	{
		fileNamesBit.push(ofn.lpstrFile);
		threads.push_back(std::thread(Load));
	}
	else
	{
		//Continues to go through until all bitmaps have been loaded
		while (*_wsfileStr)
		{			
			std::wstring filename = _wsfileStr;
			_wsfileStr += (filename.length() + 1);			
			fileNamesBit.push(filename);
		}
		//Only necessary number of threads created
		for (unsigned int i = 0; i < _iNumThreads; i++)
		{
			threads.push_back(std::thread(Load));
		}
	}

	//Joining threads
	for (unsigned int i = 0; i < threads.size(); i++)
	{
		threads[i].join();
	}
	threads.clear();
}
Beispiel #6
0
void CAddCamDlg::OnBnClickedAddSetcampathBt()
{
	// TODO: 在此添加控件通知处理程序代码
	memset(Campath, 0, sizeof(Campath));
	CString strDir;
	wchar_t mPath[MAX_PATH];
	BROWSEINFO bi;
	char buffer[MAX_PATH];
	ZeroMemory(buffer, MAX_PATH);
	bi.hwndOwner = GetSafeHwnd();
	bi.pidlRoot = NULL;
	bi.pszDisplayName = LPWSTR(buffer);
	bi.lpszTitle = L"选择一个文件夹";
	bi.ulFlags = BIF_EDITBOX;
	bi.lpfn = NULL;
	bi.lParam = 0;
	bi.iImage = 0;
	LPITEMIDLIST pList = NULL;
	if ((pList = SHBrowseForFolder(&bi)) != NULL)
	{
		SHGetPathFromIDList(pList, mPath);
		CStatic*pSt = (CStatic*)this->GetDlgItem(IDC_ADD_CAMPATH_ST);
		pSt->SetWindowTextW(mPath);
		CCommonFunc::UnicodeToAnsi(mPath, Campath, sizeof(mPath));
	}
	else
	{
		return;
	}
}
Beispiel #7
0
QByteArray QCNG::deriveConcatKDF(const QByteArray &publicKey, const QString &digest, int keySize,
	const QByteArray &algorithmID, const QByteArray &partyUInfo, const QByteArray &partyVInfo) const
{
	d->err = PinUnknown;
	QByteArray derived;
	NCRYPT_PROV_HANDLE prov = 0;
	if(NCryptOpenStorageProvider(&prov, LPCWSTR(d->selected.provider.utf16()), 0))
		return derived;
	NCRYPT_KEY_HANDLE key = 0;
	if(NCryptOpenKey(prov, &key, LPWSTR(d->selected.key.utf16()), d->selected.spec, 0))
	{
		NCryptFreeObject(prov);
		return derived;
	}
	int err = derive(prov, key, publicKey, digest, keySize, algorithmID, partyUInfo, partyVInfo, derived);
	NCryptFreeObject(key);
	switch(err)
	{
	case ERROR_SUCCESS:
		d->err = PinOK;
		return derived;
	case SCARD_W_CANCELLED_BY_USER:
		d->err = PinCanceled;
	default:
		return derived;
	}
}
Beispiel #8
0
EXTERN_C LRESULT WINAPI PluginProc(HWND hwnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
	wchar_t szName[] = L"基本的なサンプル";
	wchar_t szVersion[] = L"Version 2.0.0.0";
	switch(nMsg)
	{
	case MP_GET_NAME:
		if(lParam != 0)
			lstrcpynW(LPWSTR(lParam), szName, wParam);
		return wcslen(szName);
	case MP_GET_VERSION:
		if(lParam != 0)
			lstrcpynW(LPWSTR(lParam), szVersion, wParam);
		return wcslen(szVersion);
	}
	return	0;
}
Beispiel #9
0
void bootiniUndo(QString uninstPathL)
{
	if (!QFile::copy(QDir::toNativeSeparators(QString("%1unetbtin/boot.ini").arg(uninstPathL)), QDir::toNativeSeparators(QString("%1boot.ini").arg(uninstPathL))))
		{
			QFile::remove(QDir::toNativeSeparators(QString("%1boot.ini").arg(uninstPathL)));
			QFile::copy(QDir::toNativeSeparators(QString("%1unetbtin/boot.ini").arg(uninstPathL)), QDir::toNativeSeparators(QString("%1boot.ini").arg(uninstPathL)));
		}
	SetFileAttributesW(LPWSTR(QDir::toNativeSeparators(QString("%1boot.ini").arg(uninstPathL)).utf16()), FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_ARCHIVE);
}
Beispiel #10
0
bool CWAVFileWriter::open()
{
	m_handle = ::mmioOpen(LPWSTR(m_fileName.c_str()), 0, MMIO_WRITE | MMIO_CREATE | MMIO_ALLOCBUF);
	if (m_handle == NULL) {
		wxLogError(wxT("WAVFileWriter: could not open the file %s\n"), m_fileName.c_str());
		return false;
	}

	m_parent.fccType = mmioFOURCC('W', 'A', 'V', 'E');
	m_parent.cksize  = 0;

	MMRESULT res = ::mmioCreateChunk(m_handle, &m_parent, MMIO_CREATERIFF);
	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("WAVFileWriter: could not write to file %s\n"), m_fileName.c_str());
		return false;
	}

	m_child.ckid   = mmioFOURCC('f', 'm', 't', ' ');
	m_child.cksize = sizeof(WAVEFORMATEX);

	res = ::mmioCreateChunk(m_handle, &m_child, 0);
	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("WAVFileWriter: could not write to the file %s\n"), m_fileName.c_str());
		return false;
	}

	WAVEFORMATEX format;
	format.wBitsPerSample  = m_sampleWidth;
	if (m_sampleWidth == 8U || m_sampleWidth == 16U)
		format.wFormatTag = WAVE_FORMAT_PCM;
	else
		format.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
	format.nChannels       = m_channels;
	format.nSamplesPerSec  = m_sampleRate;
	format.nAvgBytesPerSec = m_sampleRate * m_channels * m_sampleWidth / 8;
	format.nBlockAlign     = m_channels * m_sampleWidth / 8;
	format.cbSize          = 0;

	LONG n = ::mmioWrite(m_handle, (CHAR *)&format, sizeof(WAVEFORMATEX));
	if (n != sizeof(WAVEFORMATEX)) {
		wxLogError(wxT("WAVFileWriter: could not write to the file %s\n"), m_fileName.c_str());
		return false;
	}

	::mmioAscend(m_handle, &m_child, 0);

	m_child.ckid   = mmioFOURCC('d', 'a', 't', 'a');
	m_child.cksize = 0;

	res = ::mmioCreateChunk(m_handle, &m_child, 0);
	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("WAVFileWriter: could not write to the file %s\n"), m_fileName.c_str());
		return false;
	}

	return true;
}
Beispiel #11
0
NCRYPT_KEY_HANDLE QCNG::Private::key() const
{
	NCRYPT_PROV_HANDLE prov = 0;
	NCryptOpenStorageProvider( &prov, LPCWSTR(selected.provider.utf16()), 0 );
	NCRYPT_KEY_HANDLE key = 0;
	NCryptOpenKey( prov, &key, LPWSTR(selected.key.utf16()), selected.spec, 0 );
	NCryptFreeObject( prov );
	return key;
}
Beispiel #12
0
void GlobalHelper::GetLastErrorWrapper()
{
    LPVOID lpMsgBuf;
    FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),(LPTSTR) &lpMsgBuf,0, NULL );

    MessageBox( NULL, (LPWSTR)lpMsgBuf, LPWSTR("GetLastError"), MB_OK|MB_ICONINFORMATION );
    LocalFree( lpMsgBuf );

}
void LoadSounds()
{
	//Getting addresses of sound(s) to play
	OPENFILENAME ofn;
	char szFile[1028];
	ZeroMemory(&ofn, sizeof(ofn));
	ofn.lStructSize = sizeof(ofn);
	ofn.hwndOwner = NULL;
	ofn.lpstrFile = LPWSTR(szFile);
	ofn.lpstrFile[0] = '\0';
	ofn.nMaxFile = sizeof(szFile);
	ofn.lpstrFilter = L"WAV file (*.wav)\0*.wav\0\0";//Restricted to WAV files only
	ofn.nFilterIndex = 1;
	ofn.lpstrFileTitle = NULL;
	ofn.nMaxFileTitle = 0;
	ofn.lpstrInitialDir = NULL;
	ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_EXPLORER;
	GetOpenFileName(&ofn);	
	
	//Breaking up into individual addresses
	wchar_t* _wsfileStr = ofn.lpstrFile;
	std::wstring directory = _wsfileStr;

	_wsfileStr += (directory.length() + 1);	

	//Used for an individual sound
	if (!*_wsfileStr)
	{		
		fileNamesSounds.push(directory);
		threads.push_back(std::thread(Play));
	}
	else
	{
		while (*_wsfileStr)
		{
			std::wstring filename = _wsfileStr;
			_wsfileStr += (filename.length() + 1);
			fileNamesSounds.push(filename);			
		}
		//Only creating necessary number of threads
		for (unsigned int i = 0; i < _iNumThreads; i++)
		{
			threads.push_back(std::thread(Play));
		}

	}
	for (unsigned int i = 0; i < threads.size(); i++)
	{
		threads[i].join();
	}

	threads.clear();
}
Beispiel #14
0
		void MenuAdapter::update(Action& action)
		{
			MENUITEMINFO info = { 0 };

			// Set the new menu item information.
			info.cbSize     = sizeof(info);
			info.fMask      = MIIM_STRING | MIIM_STATE | MIIM_FTYPE;
			info.fState     = MFS_ENABLED;
			info.fType      = MFT_STRING;
			info.dwTypeData = LPWSTR(action.getText().toArray());

			if (::SetMenuItemInfo(HMENU(getHandle()), UINT(action.getId()), FALSE, &info) == 0)
				throw UserInterfaceException("SetMenuItemInfo() failed");
		}
Beispiel #15
0
void CopyToClipboard2(WCHAR *data)
{
	if(OpenClipboard(NULL))
	{
		HGLOBAL clipbuffer;//内存区
		WCHAR *buffer;//内存区缓冲区
		EmptyClipboard();
		clipbuffer = GlobalAlloc(GMEM_DDESHARE, sizeof(WCHAR)*(wcslen(data)+1));//分配内存
		buffer = (WCHAR*)GlobalLock(clipbuffer);
		wcscpy(buffer, LPWSTR(data));
		GlobalUnlock(clipbuffer);
		SetClipboardData(CF_UNICODETEXT,clipbuffer);
		CloseClipboard();
	}
}
	RadioButtonGroup::RadioButtonGroup(HINSTANCE hInst, HWND parent, int x, int y,
		int width, int height, int id, LPCWSTR title, DWORD additionalStyles, LPCWSTR *buttonsText,
		int buttonsCount) : Window(hInst, parent, x, y, width, height, title, L"RadioButtonGroup",
		NULL, WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | additionalStyles)
	{
		Header = nullptr;
		Id = id;
		CheckedButton = 0;
		RadioButtonsCount = buttonsCount > MAX_RADIOBUTTONS ? MAX_RADIOBUTTONS : buttonsCount;
		for (int i = 0; i < RadioButtonsCount; i++)
		{
			RadioButtonsText[i] = LPWSTR(malloc(sizeof(WCHAR)*lstrlen(buttonsText[i])));
			lstrcpy(RadioButtonsText[i], buttonsText[i]);
		}
	}
	BOOL CMSMdxCfgSequence::CreateTree(	CMSMdxTreeNode* pParent, HWND hTree, HTREEITEM hRoot )
	{
		TVINSERTSTRUCT tvInsert;
		ZeroMemory(&tvInsert,sizeof(TVINSERTSTRUCT));

		tvInsert.hInsertAfter = NULL;
		tvInsert.item.mask = TVIF_TEXT|TVIF_PARAM;

		tvInsert.hParent = hRoot;
		tvInsert.item.pszText = LPWSTR( GetText() );
		tvInsert.item.lParam = (LPARAM)this;
		HTREEITEM hSequence = TreeView_InsertItem(hTree,&tvInsert);
		SetItem( hSequence );
		SetParent( pParent );


		tvInsert.hParent = hSequence;
		tvInsert.item.pszText = LPWSTR( m_spAnimName.GetText() );
		tvInsert.item.lParam = (LPARAM)&m_spAnimName;
		HTREEITEM hAnimName = TreeView_InsertItem(hTree,&tvInsert);
		m_spAnimName.SetParent( this );
		m_spAnimName.SetItem( hAnimName );


		tvInsert.hParent = hSequence;
		tvInsert.item.pszText = LPWSTR( m_npStartFrameId.GetText() );
		tvInsert.item.lParam = (LPARAM)&m_npStartFrameId;
		HTREEITEM hStartFrameIdId = TreeView_InsertItem(hTree,&tvInsert);
		m_npStartFrameId.SetParent( this );
		m_npStartFrameId.SetItem( hStartFrameIdId );

		tvInsert.hParent = hSequence;
		tvInsert.item.pszText = LPWSTR( m_npEndFrameId.GetText() );
		tvInsert.item.lParam = (LPARAM)&m_npEndFrameId;
		HTREEITEM hEndFrameIdId = TreeView_InsertItem(hTree,&tvInsert);
		m_npEndFrameId.SetParent( this );
		m_npEndFrameId.SetItem( hEndFrameIdId );

		//m_hitpoints.CreateTree( this, hTree, hSequence );

		tvInsert.hParent = hSequence;
		tvInsert.item.pszText = LPWSTR( m_npRealHitPoint.GetText() );
		tvInsert.item.lParam = (LPARAM)&m_npRealHitPoint;
		HTREEITEM hAttack = TreeView_InsertItem(hTree,&tvInsert);
		m_npRealHitPoint.SetParent( this );
		m_npRealHitPoint.SetItem( hAttack );

		tvInsert.hParent = hSequence;
		tvInsert.item.pszText = LPWSTR( m_npHasLightTrack.GetText() );
		tvInsert.item.lParam = (LPARAM)&m_npHasLightTrack;
		HTREEITEM hLightTrack = TreeView_InsertItem(hTree,&tvInsert);
		m_npHasLightTrack.SetParent( this );
		m_npHasLightTrack.SetItem( hLightTrack );

		return TRUE;
	}
Beispiel #18
0
		void MenuAdapter::insert(size_t index, Action& action)
		{
			MENUITEMINFO info = { 0 };

			// Fill out the regular menu item information.
			info.cbSize     = sizeof(info);
			info.fMask      = MIIM_STRING | MIIM_STATE | MIIM_ID;
			info.fState     = MFS_ENABLED;
			info.wID        = UINT(action.getId());
			info.dwTypeData = LPWSTR(action.getText().toArray());

			// Insert the menu item into the menu.
			if (::InsertMenuItem(HMENU(_handle), UINT(index), TRUE, &info) == 0)
				throw UserInterfaceException("InsertMenuItem() failed");
		}
void AudioGroupCollection::populateFiles(VSTEditor& editor, HTREEITEM colHandle, size_t parentIdx) {
  TVINSERTSTRUCT ins = {};
  ins.item.mask = TVIF_TEXT | TVIF_PARAM;
  ins.hParent = colHandle;
  ins.hInsertAfter = TVI_LAST;

  m_iteratorVec.clear();
  m_iteratorVec.reserve(m_groups.size());
  for (auto it = m_groups.begin(); it != m_groups.end(); ++it) {
    ins.item.pszText = LPWSTR(it->first.c_str());
    ins.item.lParam = LPARAM(0x80000000 | (parentIdx << 16) | m_iteratorVec.size());
    HTREEITEM item = TreeView_InsertItem(editor.m_collectionTree, &ins);
    if (editor.m_selCollectionIdx == parentIdx && editor.m_selFileIdx == m_iteratorVec.size())
      editor.m_deferredCollectionSel = item;
    m_iteratorVec.push_back(it);
  }
}
Beispiel #20
0
int main (int argc, char **argv)
{
    char *cl_cmd = getenv(CMD_ENVVAR);
    if (!cl_cmd) {
        fail(CMD_ENVVAR" not set");
    }

    #ifndef WINTEST
    LPWSTR (*CDECL wine_get_dos_file_name_ptr)(LPCSTR);
    wine_get_dos_file_name_ptr = (void *)GetProcAddress(GetModuleHandleA("KERNEL32"), "wine_get_dos_file_name");
    if (!wine_get_dos_file_name_ptr) {
        fail("cannot get wine_get_dos_file_name");
    }
    #endif

    WCHAR cmdline[CMDLINE_BUF_LEN];
    int cmdline_len = 0;

    void append_char (WCHAR c)
    {
        if (1 > MAX_CMDLINE_LEN - cmdline_len) {
            fail("out of command line buffer");
        }

        cmdline[cmdline_len] = c;
        cmdline_len++;
    }

    int arg_writing = 0;

    void start_argument ()
    {
        assert(!arg_writing);

        if (cmdline_len == 0) {
            append_char('"');
        } else {
            append_char(' ');
            append_char('"');
        }

        arg_writing = 1;
    }
Beispiel #21
0
	void MainWindow::SearchRegistry(HKEY root, LPWSTR subkey, ListView *listView)
	{
		HKEY key;
		int resultCode = RegOpenKeyEx(root, subkey, 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &key);
		if (resultCode != 0)
			return;

		int index = 0;
		WCHAR name[10 * MAX_STR];
		while (RegEnumKey(key, index++, name, 10240) != ERROR_NO_MORE_ITEMS && !SearchAgain && ThreadNeeded)
		{
			if (lstrlen(subkey) == 0)
				SearchRegistry(root, name, listView);
			else
			{
				WCHAR path[10 * MAX_STR];
				swprintf(path, 10 * MAX_STR, L"%s\\%s", subkey, name);
				SearchRegistry(root, path, listView);
			}
		}

		index = 0;
		BYTE data[20 * MAX_STR];
		DWORD namesize = 10 * MAX_STR, type, size = 20 * MAX_STR;
		while (RegEnumValue(key, index++, name, &namesize, NULL, &type, data, &size) != ERROR_NO_MORE_ITEMS
			&& !SearchAgain && ThreadNeeded)
		{
			if (type == REG_SZ)
			{
				LPWSTR path = LPWSTR(data);
				WCHAR tmp[MAX_STR];
				lstrcpy(tmp, L":\\");
				if (lstrlen(path) != 0 && tmp[0] == path[1] && tmp[1] == path[2] && PathFileExists(path) == FALSE)
				{
					int newRow = listView->AddItem(subkey, -1, 0);
					listView->AddItem(name, newRow, 1);
					listView->AddItem(path, newRow, 2);
				}
			}
			namesize = size = 1024;
		}
		RegCloseKey(key);
	}
WideCharSeq const
multibyte_to(MultiByteRange const& from)
{
    std::string tmp = from|oven::copied;

#if !(PSTADE_APPLE_ATL_VER < 0x0700)

    return ATL::CA2W(tmp.c_str()).operator LPWSTR()
        | oven::as_c_str
        | oven::copied;

#else

    USES_CONVERSION_EX;
    return A2W_EX(tmp.c_str(), 128)
        | oven::as_c_str
        | oven::copied;

#endif
}
void AudioGroupFilePresenter::populateCollectionColumn(VSTEditor& editor) {
  TreeView_DeleteAllItems(editor.m_collectionTree);
  TVINSERTSTRUCT ins = {};
  ins.hParent = TVI_ROOT;
  ins.hInsertAfter = TVI_LAST;
  ins.item.mask = TVIF_CHILDREN | TVIF_TEXT | TVIF_PARAM;

  m_iteratorVec.clear();
  m_iteratorVec.reserve(m_audioGroupCollections.size());
  for (auto it = m_audioGroupCollections.begin(); it != m_audioGroupCollections.end(); ++it) {
    ins.item.cChildren = it->second->m_groups.size() ? 1 : 0;
    ins.item.pszText = LPWSTR(it->first.c_str());
    ins.item.lParam = LPARAM(m_iteratorVec.size() << 16);
    HTREEITEM item = TreeView_InsertItem(editor.m_collectionTree, &ins);
    it->second->populateFiles(editor, item, m_iteratorVec.size());
    if (editor.m_selCollectionIdx == m_iteratorVec.size() && editor.m_selFileIdx == -1)
      editor.m_deferredCollectionSel = item;
    m_iteratorVec.push_back(it);
  }
}
	BOOL CMSMdxCfgSequences::CreateTree(	CMSMdxTreeNode* pParent, 
		HWND hTree, HTREEITEM hRoot )
	{
		TVINSERTSTRUCT tvInsert;
		ZeroMemory(&tvInsert,sizeof(TVINSERTSTRUCT));

		tvInsert.hParent = hRoot;
		tvInsert.hInsertAfter = NULL;
		tvInsert.item.mask = TVIF_TEXT|TVIF_PARAM;
		tvInsert.item.pszText = LPWSTR(GetText());
		tvInsert.item.lParam = (LPARAM)this;
		HTREEITEM hChild = TreeView_InsertItem(hTree,&tvInsert);
		SetItem( hChild );
		SetParent( pParent );

		for( int i = 0; i < m_vectorSequence.size(); i++ )
			m_vectorSequence[i]->CreateTree( this, hTree, hChild );
		m_hRootItem = hChild;
		return TRUE;
	}
Beispiel #25
0
		void MenuAdapter::insert(size_t index, Menu& menu)
		{
			MENUITEMINFO info = { 0 };

			IMenuAdapter* adapter = menu.getAdapter();

			if (!adapter)
				throw UserInterfaceException("Cannot insert menu without an adapter.");

			// Fill out the regular menu item information.
			info.cbSize     = sizeof(info);
			info.fMask      = MIIM_STRING | MIIM_STATE | MIIM_SUBMENU | MIIM_ID;
			info.fState     = MFS_ENABLED;
			info.wID        = UINT(menu.getId());
			info.hSubMenu   = HMENU(adapter->getHandle());
			info.dwTypeData = LPWSTR(menu.getText().toArray());

			// Insert the menu item into the Menu.
			if (::InsertMenuItem(HMENU(_handle), UINT(index), TRUE, &info) == 0)
				throw UserInterfaceException("InsertMenuItem() failed");
		}
Beispiel #26
0
QStringList QCSP::containers( SslCertificate::KeyUsage usage )
{
	qWarning() << "Start enumerationg providers";
	QHash<QString,QPair<QString,QString> > certs;
	HCRYPTPROV h = 0;
	DWORD index = 0, type = 0, size = 0;
	while( CryptEnumProvidersW( index, 0, 0, &type, 0, &size ) )
	{
		QString provider( size / sizeof(wchar_t) - 1, 0 );
		if( !CryptEnumProvidersW( index++, 0, 0, &type, LPWSTR(provider.data()), &size ) )
			continue;

		qWarning() << "Found provider" << provider << "type" << type;
		if( type != PROV_RSA_FULL )
			continue;

		// its broken and does not play well with pkcs11
		if( provider.toLower().contains( "esteid" ) )
			continue;

		qWarning() << "Acquiring provider" << provider << "context";
		if( h )
			CryptReleaseContext( h, 0 );
		h = 0;
		if( !CryptAcquireContextW( &h, 0, LPCWSTR(provider.utf16()), type, CRYPT_SILENT ) )
			continue;

		qWarning() << "Checking if provider" << provider << "is HW";
		QByteArray imptype = QCSPPrivate::provParam( h, PP_IMPTYPE );
		if( imptype.isEmpty() || !(imptype[0] & CRYPT_IMPL_HARDWARE) )
			continue;

		qWarning() << "Enumerating provider " << provider << "containers";
		QStringList containers;
		QByteArray container = QCSPPrivate::provParam( h, PP_ENUMCONTAINERS, CRYPT_FIRST );
		while( !container.isEmpty() )
		{
			containers << container;
			container = QCSPPrivate::provParam( h, PP_ENUMCONTAINERS, CRYPT_NEXT );
		}
		qWarning() << "Provider" << provider << "containers" << containers;

		Q_FOREACH( const QString &container, containers )
		{
			if( h )
				CryptReleaseContext( h, 0 );
			h = 0;
			qWarning() << "Acquiring provider" << provider << "container" << container << "context";
			if( !CryptAcquireContextW( &h, LPCWSTR(container.utf16()), LPCWSTR(provider.utf16()), type, CRYPT_SILENT ) )
				continue;

			qWarning() << "Geting provider" << provider << "container" << container << "key";
			HCRYPTKEY key = 0;
			if( !CryptGetUserKey( h, usage == SslCertificate::NonRepudiation ? AT_SIGNATURE : AT_KEYEXCHANGE, &key ) )
				continue;

			qWarning() << "Reading provider" << provider << "container" << container << "cert";
			QSslCertificate cert( QCSPPrivate::keyParam( key, KP_CERTIFICATE, 0 ), QSsl::Der );
			CryptDestroyKey( key );

			if( cert.isNull() )
				continue;

			qWarning() << "Adding provider" << provider << "container" << container << "list";
			certs.insert( cert.subjectInfo( QSslCertificate::CommonName ), QPair<QString,QString>( provider, container ) );
		}
	}
	if( h )
		CryptReleaseContext( h, 0 );
	qWarning() << "End enumerationg providers";

	d->certs = certs;
	return d->certs.keys();
}
Beispiel #27
0
/*
 * Main function
 */
int wmain(int argc, WCHAR *argv[])
{
    LPSTR (*CDECL wine_get_unix_file_name_ptr)(LPCWSTR) = NULL;
    LPWSTR (*CDECL wine_get_dos_file_name_ptr)(LPCSTR) = NULL;
    WCHAR dos_pathW[MAX_PATH];
    char path[MAX_PATH];
    int outputformats;
    int i;

    outputformats = parse_options(argv);
    if (outputformats == 0)
        outputformats = UNIXFORMAT;

    if (outputformats & UNIXFORMAT) {
        wine_get_unix_file_name_ptr = (void*)
            GetProcAddress(GetModuleHandleA("KERNEL32"),
                           "wine_get_unix_file_name");
        if (wine_get_unix_file_name_ptr == NULL) {
            fprintf(stderr, "%s: cannot get the address of "
                            "'wine_get_unix_file_name'\n", progname);
            exit(3);
        }
    }

    if (outputformats & WINDOWSFORMAT) {
        wine_get_dos_file_name_ptr = (void*)
            GetProcAddress(GetModuleHandleA("KERNEL32"),
                           "wine_get_dos_file_name");
        if (wine_get_dos_file_name_ptr == NULL) {
            fprintf(stderr, "%s: cannot get the address of "
                            "'wine_get_dos_file_name'\n", progname);
            exit(3);
        }
    }

    for (i = 1; argv[i]; i++)
    {
        *path='\0';
        if (outputformats & LONGFORMAT) {
            if (GetLongPathNameW(argv[i], dos_pathW, MAX_PATH))
                WideCharToMultiByte(CP_UNIXCP, 0, dos_pathW, -1, path, MAX_PATH, NULL, NULL);
            printf("%s\n", path);
        }
        if (outputformats & SHORTFORMAT) {
            if (GetShortPathNameW(argv[i], dos_pathW, MAX_PATH))
                WideCharToMultiByte(CP_UNIXCP, 0, dos_pathW, -1, path, MAX_PATH, NULL, NULL);
            printf("%s\n", path);
        }
        if (outputformats & UNIXFORMAT) {
            WCHAR *ntpath, *tail;
            int ntpathlen=lstrlenW(argv[i]);
            ntpath=HeapAlloc(GetProcessHeap(), 0, sizeof(*ntpath)*(ntpathlen+1));
            lstrcpyW(ntpath, argv[i]);
            tail=NULL;
            while (1)
            {
                char *unix_name;
                WCHAR *slash, *c;

                unix_name = wine_get_unix_file_name_ptr(ntpath);
                if (unix_name)
                {
                    if (tail)
                    {
                        WideCharToMultiByte(CP_UNIXCP, 0, tail+1, -1, path, MAX_PATH, NULL, NULL);
                        printf("%s/%s\n", unix_name, path);
                    }
                    else
                    {
                        printf("%s\n", unix_name);
                    }
                    HeapFree( GetProcessHeap(), 0, unix_name );
                    break;
                }

                slash=(tail ? tail : ntpath+ntpathlen);
                while (slash != ntpath && *slash != '/' && *slash != '\\')
                    slash--;
                if (slash == ntpath)
                {
                    /* This is a complete path conversion failure.
                     * It would typically happen if ntpath == "".
                     */
                    printf("\n");
                    break;
                }
                c=slash+1;
                while (*c != '\0' && *c != '*' && *c != '?' &&
                       *c != '<' && *c != '>' && *c != '|' && *c != '"')
                    c++;
                if (*c != '\0')
                {
                    /* If this is not a valid NT path to start with,
                     * then obviously we cannot convert it.
                     */
                    printf("\n");
                    break;
                }
                if (tail)
                    *tail='/';
                tail=slash;
                *tail='\0';
            }
            HeapFree(GetProcessHeap(), 0, ntpath);
        }
        if (outputformats & WINDOWSFORMAT) {
            WCHAR* windows_name;
            char* unix_name;
            DWORD size;

            size=WideCharToMultiByte(CP_UNIXCP, 0, argv[i], -1, NULL, 0, NULL, NULL);
            unix_name=HeapAlloc(GetProcessHeap(), 0, size);
            WideCharToMultiByte(CP_UNIXCP, 0, argv[i], -1, unix_name, size, NULL, NULL);

            if ((windows_name = wine_get_dos_file_name_ptr(unix_name)))
            {
                WideCharToMultiByte(CP_UNIXCP, 0, windows_name, -1, path, MAX_PATH, NULL, NULL);
                printf("%s\n", path);
                HeapFree( GetProcessHeap(), 0, windows_name );
            }
            else printf( "\n" );
            HeapFree( GetProcessHeap(), 0, unix_name );
        }
    }

    exit(0);
}
bool CDownloadAndSetupThread::SetupBankUsbKey(LPCTSTR lpPath, LPCTSTR lpSetUp) // 银行USBKEY安装
{
	ATLASSERT (NULL != lpPath);
	if (NULL == lpPath)
		return false;

	std::wstring strPath = lpPath;

	if (strPath.rfind (L".exe") == strPath.length () - 4) // 安装exe文件
	{
		OSVERSIONINFO os = { sizeof(OSVERSIONINFO) };
		::GetVersionEx(&os);
		if(os.dwMajorVersion >= 6)
		{
			SHELLEXECUTEINFOW shExecInfo;
			shExecInfo.cbSize = sizeof(SHELLEXECUTEINFO);
			shExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;//SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI; 
			shExecInfo.hwnd = NULL;
			shExecInfo.lpVerb = L"runas";
			shExecInfo.lpFile = LPWSTR(lpPath);
			shExecInfo.lpParameters = NULL;
			shExecInfo.lpDirectory = NULL;
			shExecInfo.nShow = SW_SHOWNORMAL;
			shExecInfo.hInstApp = NULL;

			// 用户取消
			if (true == m_bCancled)
			{
				return true;
			}

			if (!ShellExecuteExW(&shExecInfo))
			{			
				int err = GetLastError();
				CRecordProgram::GetInstance()->FeedbackError(MY_ERROR_PRO_CORE, err,
					CRecordProgram::GetInstance()->GetRecordInfo(L"SetupBankUsbKey创建安装进程%s失败!", lpPath));
			}
			else
				WaitForSingleObject (shExecInfo.hProcess, INFINITE); // 等待usbkey.exe安装完成才返回

			while (!CBkInfoDownloadManager::GetInterfaceInstance ()->USBFinalTest (m_dlUSBParam.nVid, m_dlUSBParam.nPid, m_dlUSBParam.nMid, m_bSetupFinish))
			{	
				if (!ShellExecuteExW(&shExecInfo))
				{
					CRecordProgram::GetInstance()->FeedbackError(MY_ERROR_PRO_CORE, GetLastError(),
					CRecordProgram::GetInstance()->GetRecordInfo(L"SetupBankUsbKey创建安装进程%s失败!", lpPath));
				}
				else
					WaitForSingleObject (shExecInfo.hProcess, INFINITE); // 等待usbkey.exe安装完成才返回
			}
		}
		else
		{
			STARTUPINFOW si;
			memset (&si, 0, sizeof (STARTUPINFOW));
			si.wShowWindow = SW_HIDE;
			si.cb = sizeof (STARTUPINFOW);
			PROCESS_INFORMATION pi;
			memset (&pi, 0, sizeof (PROCESS_INFORMATION));	

			// 用户取消
			if (true == m_bCancled)
			{
				return true;
			}

			if (!CreateProcess(NULL, LPWSTR(lpPath), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
			{
				CRecordProgram::GetInstance()->FeedbackError(MY_ERROR_PRO_CORE, ERR_CREATEPROCESS,
					CRecordProgram::GetInstance()->GetRecordInfo(L"SetupBankUsbKey创建安装进程失败!", lpPath));
				m_bSetupFinish = true;
				return false;
			}
			else
				WaitForSingleObject (pi.hProcess, INFINITE); // 等待usbkey.exe安装完成才返回

			while (!CBkInfoDownloadManager::GetInterfaceInstance ()->USBFinalTest (m_dlUSBParam.nVid, m_dlUSBParam.nPid, m_dlUSBParam.nMid, m_bSetupFinish))
			{
				memset (&si, 0, sizeof (STARTUPINFOW));
				memset (&pi, 0, sizeof (PROCESS_INFORMATION));	
				if (!CreateProcess(NULL, LPWSTR(lpPath), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
				{
					CRecordProgram::GetInstance()->FeedbackError(MY_ERROR_PRO_CORE, ERR_CREATEPROCESS,
						CRecordProgram::GetInstance()->GetRecordInfo(L"SetupBankUsbKey创建安装进程失败!", lpPath));
					m_bSetupFinish = true;
					return false;
				}
				else
					WaitForSingleObject (pi.hProcess, INFINITE); // 等待usbkey.exe安装完成才返回
			}
			CloseHandle (pi.hThread);
			CloseHandle (pi.hProcess);
		}
		

		m_bSetupFinish = true; // 标记安装完成

		return true;
	}
	
	return false;
}
Beispiel #29
0
bool CSoundFileReader::open(float sampleRate, unsigned int blockSize)
{
	m_blockSize = blockSize;

	m_handle = ::mmioOpen(LPWSTR(m_fileName.c_str()), 0, MMIO_READ | MMIO_ALLOCBUF);

	if (m_handle == NULL) {
		wxLogError(wxT("SoundFileReader: could not open the WAV file %s."), m_fileName.c_str());
		return false;
	}

	MMCKINFO parent;
	parent.fccType = mmioFOURCC('W', 'A', 'V', 'E');

	MMRESULT res = ::mmioDescend(m_handle, &parent, 0, MMIO_FINDRIFF);

	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("SoundFileReader: %s has no \"WAVE\" header."), m_fileName.c_str());
		return false;
	}

	MMCKINFO child;
	child.ckid = mmioFOURCC('f', 'm', 't', ' ');

	res = ::mmioDescend(m_handle, &child, &parent, MMIO_FINDCHUNK);

	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("SoundFileReader: %s has no \"fmt \" chunk."), m_fileName.c_str());
		return false;
	}

	WAVEFORMATEX format;

	LONG len = ::mmioRead(m_handle, (char *)&format, child.cksize);

	if (len != LONG(child.cksize)) {
		wxLogError(wxT("SoundFileReader: %s is corrupt, cannot read the WAVEFORMATEX structure."), m_fileName.c_str());
		return false;
	}
	
	if (format.wFormatTag != WAVE_FORMAT_PCM && format.wFormatTag != WAVE_FORMAT_IEEE_FLOAT) {
		wxLogError(wxT("SoundFileReader: %s is not PCM or IEEE Float format, is %u."), m_fileName.c_str(), format.wFormatTag);
		return false;
	}

	if (format.nSamplesPerSec != DWORD(sampleRate)) {
		wxLogError(wxT("SoundFileReader: %s has sample rate %lu, not %.0f"), m_fileName.c_str(), format.nSamplesPerSec, sampleRate);
		return false;
	}

	m_channels = format.nChannels;
	if (m_channels > 2U) {
		wxLogError(wxT("SoundFileReader: %s has %u channels, more than 2."), m_fileName.c_str(), m_channels);
		return false;
	}

	if (format.wBitsPerSample == 8U && format.wFormatTag == WAVE_FORMAT_PCM) {
		m_format = FORMAT_8BIT;
	} else if (format.wBitsPerSample == 16U && format.wFormatTag == WAVE_FORMAT_PCM) {
		m_format = FORMAT_16BIT;
	} else if (format.wBitsPerSample == 32U && format.wFormatTag == WAVE_FORMAT_IEEE_FLOAT) {
		m_format = FORMAT_32BIT;
	} else {
		wxLogError(wxT("SoundFileReader: %s has sample width %u and format %u."), m_fileName.c_str(), format.wBitsPerSample, format.wFormatTag);
		return false;
	}

	res = ::mmioAscend(m_handle, &child, 0);

	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("SoundFileReader: %s is corrupt, cannot ascend."), m_fileName.c_str());
		return false;
	}

	child.ckid = mmioFOURCC('d', 'a', 't', 'a');

	res = ::mmioDescend(m_handle, &child, &parent, MMIO_FINDCHUNK);

	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("SoundFileReader: %s has no \"data\" chunk."), m_fileName.c_str());
		return false;
	}

	// Get the current location so we can rewind if needed
	m_offset = ::mmioSeek(m_handle, 0L, SEEK_CUR);

	switch (m_format) {
		case FORMAT_8BIT:
			m_buffer8 =  new wxUint8[m_blockSize * m_channels];
			break;
		case FORMAT_16BIT:
			m_buffer16 = new wxInt16[m_blockSize * m_channels];
			break;
		case FORMAT_32BIT:
			m_buffer32 = new wxFloat32[m_blockSize * m_channels];
			break;
	}

	m_buffer = new float[m_blockSize * 2U];

	return CThreadReader::open(sampleRate, blockSize);
}
Beispiel #30
0
bool CWAVFileReader::open()
{
	m_handle = ::mmioOpen(LPWSTR(m_fileName.c_str()), 0, MMIO_READ | MMIO_ALLOCBUF);
	if (m_handle == NULL) {
		wxLogError(wxT("WAVFileReader: could not open the WAV file %s\n"), m_fileName.c_str());
		return false;
	}

	MMCKINFO parent;
	parent.fccType = mmioFOURCC('W', 'A', 'V', 'E');

	MMRESULT res = ::mmioDescend(m_handle, &parent, 0, MMIO_FINDRIFF);
	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("WAVFileReader: %s has no \"WAVE\" header\n"), m_fileName.c_str());
		::mmioClose(m_handle, 0U);
		m_handle = NULL;
		return false;
	}

	MMCKINFO child;
	child.ckid = mmioFOURCC('f', 'm', 't', ' ');

	res = ::mmioDescend(m_handle, &child, &parent, MMIO_FINDCHUNK);
	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("WAVFileReader: %s has no \"fmt \" chunk\n"), m_fileName.c_str());
		::mmioClose(m_handle, 0U);
		m_handle = NULL;
		return false;
	}

	WAVEFORMATEX format;

	LONG len = ::mmioRead(m_handle, (char *)&format, child.cksize);
	if (len != LONG(child.cksize)) {
		wxLogError(wxT("WAVFileReader: %s is corrupt, cannot read the WAVEFORMATEX structure\n"), m_fileName.c_str());
		::mmioClose(m_handle, 0U);
		m_handle = NULL;
		return false;
	}
        
	if (format.wFormatTag != WAVE_FORMAT_PCM && format.wFormatTag != WAVE_FORMAT_IEEE_FLOAT) {
		wxLogError(wxT("WAVFileReader: %s is not PCM or IEEE Float format, is %u\n"), m_fileName.c_str(), format.wFormatTag);
		::mmioClose(m_handle, 0U);
		m_handle = NULL;
		return false;
	}

	m_sampleRate = format.nSamplesPerSec;

	m_channels = format.nChannels;
	if (m_channels > 2U) {
		wxLogError(wxT("WAVFileReader: %s has %u channels, more than 2\n"), m_fileName.c_str(), m_channels);
		::mmioClose(m_handle, 0U);
		m_handle = NULL;
		return false;
	}

	if (format.wBitsPerSample == 8U && format.wFormatTag == WAVE_FORMAT_PCM) {
		m_format = FORMAT_8BIT;
	} else if (format.wBitsPerSample == 16U && format.wFormatTag == WAVE_FORMAT_PCM) {
		m_format = FORMAT_16BIT;
	} else if (format.wBitsPerSample == 32U && format.wFormatTag == WAVE_FORMAT_IEEE_FLOAT) {
		m_format = FORMAT_32BIT;
	} else {
		wxLogError(wxT("WAVFileReader: %s has sample width %u and format %u\n"), m_fileName.c_str(), format.wBitsPerSample, format.wFormatTag);
		::mmioClose(m_handle, 0U);
		m_handle = NULL;
		return false;
	}

	res = ::mmioAscend(m_handle, &child, 0);
	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("WAVFileReader: %s is corrupt, cannot ascend\n"), m_fileName.c_str());
		::mmioClose(m_handle, 0U);
		m_handle = NULL;
		return false;
	}

	child.ckid = mmioFOURCC('d', 'a', 't', 'a');

	res = ::mmioDescend(m_handle, &child, &parent, MMIO_FINDCHUNK);
	if (res != MMSYSERR_NOERROR) {
		wxLogError(wxT("WAVFileReader: %s has no \"data\" chunk\n"), m_fileName.c_str());
		::mmioClose(m_handle, 0U);
		m_handle = NULL;
		return false;
	}

	// Get the current location so we can rewind if needed
	m_offset = ::mmioSeek(m_handle, 0L, SEEK_CUR);

	return true;
}