bool wxDisplayImplDirectDraw::ChangeMode(const wxVideoMode& mode)
{
wxWindow *winTop = wxTheApp->GetTopWindow();
wxCHECK_MSG( winTop, false, wxT("top level window required for DirectX") );
HRESULT hr = m_pDD2->SetCooperativeLevel
(
GetHwndOf(winTop),
DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN
);
if ( FAILED(hr) )
{
wxLogApiError(wxT("IDirectDraw2::SetCooperativeLevel"), hr);
return false;
}
hr = m_pDD2->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0);
if ( FAILED(hr) )
{
wxLogApiError(wxT("IDirectDraw2::SetDisplayMode"), hr);
return false;
}
return true;
}
bool wxTaskBarButtonImpl::InitOrUpdateThumbBarButtons()
{
THUMBBUTTON buttons[MAX_BUTTON_COUNT];
HRESULT hr;
for ( size_t i = 0; i < MAX_BUTTON_COUNT; ++i )
{
memset(&buttons[i], 0, sizeof buttons[i]);
buttons[i].iId = i;
buttons[i].dwFlags = THBF_HIDDEN;
buttons[i].dwMask = static_cast<THUMBBUTTONMASK>(THB_FLAGS);
}
for ( size_t i = 0; i < m_thumbBarButtons.size(); ++i )
{
buttons[i].hIcon = GetHiconOf(m_thumbBarButtons[i]->GetIcon());
buttons[i].dwFlags = GetNativeThumbButtonFlags(*m_thumbBarButtons[i]);
buttons[i].dwMask = static_cast<THUMBBUTTONMASK>(THB_ICON | THB_FLAGS);
wxString tooltip = m_thumbBarButtons[i]->GetTooltip();
if ( tooltip.empty() )
continue;
// Truncate the tooltip if its length longer than szTip(THUMBBUTTON)
// allowed length (260).
tooltip.Truncate(260);
wxStrlcpy(buttons[i].szTip, tooltip.t_str(), tooltip.length());
buttons[i].dwMask =
static_cast<THUMBBUTTONMASK>(buttons[i].dwMask | THB_TOOLTIP);
}
if ( !m_hasInitThumbnailToolbar )
{
hr = m_taskbarList->ThumbBarAddButtons(m_parent->GetHWND(),
MAX_BUTTON_COUNT,
buttons);
if ( FAILED(hr) )
{
wxLogApiError(wxT("ITaskbarList3::ThumbBarAddButtons"), hr);
}
m_hasInitThumbnailToolbar = true;
}
else
{
hr = m_taskbarList->ThumbBarUpdateButtons(m_parent->GetHWND(),
MAX_BUTTON_COUNT,
buttons);
if ( FAILED(hr) )
{
wxLogApiError(wxT("ITaskbarList3::ThumbBarUpdateButtons"), hr);
}
}
return SUCCEEDED(hr);
}
bool wxTextEntry::AutoCompleteFileNames()
{
#ifdef HAS_AUTOCOMPLETE
typedef HRESULT (WINAPI *SHAutoComplete_t)(HWND, DWORD);
static SHAutoComplete_t s_pfnSHAutoComplete = (SHAutoComplete_t)-1;
static wxDynamicLibrary s_dllShlwapi;
if ( s_pfnSHAutoComplete == (SHAutoComplete_t)-1 )
{
if ( !s_dllShlwapi.Load(wxT("shlwapi.dll"), wxDL_VERBATIM | wxDL_QUIET) )
{
s_pfnSHAutoComplete = NULL;
}
else
{
wxDL_INIT_FUNC(s_pfn, SHAutoComplete, s_dllShlwapi);
}
}
if ( !s_pfnSHAutoComplete )
return false;
HRESULT hr = (*s_pfnSHAutoComplete)(GetEditHwnd(), SHACF_FILESYS_ONLY);
if ( FAILED(hr) )
{
wxLogApiError(wxT("SHAutoComplete()"), hr);
return false;
}
return true;
#else // !HAS_AUTOCOMPLETE
return false;
#endif // HAS_AUTOCOMPLETE/!HAS_AUTOCOMPLETE
}
// Helper wrapping AssocQueryString() Win32 function: returns the value of the
// given associated string for the specified extension (which may or not have
// the leading period).
//
// Returns empty string if the association is not found.
static
wxString wxAssocQueryString(ASSOCSTR assoc,
wxString ext,
const wxString& verb = wxString())
{
typedef HRESULT (WINAPI *AssocQueryString_t)(ASSOCF, ASSOCSTR,
LPCTSTR, LPCTSTR, LPTSTR,
DWORD *);
static AssocQueryString_t s_pfnAssocQueryString = (AssocQueryString_t)-1;
static wxDynamicLibrary s_dllShlwapi;
if ( s_pfnAssocQueryString == (AssocQueryString_t)-1 )
{
if ( !s_dllShlwapi.Load(wxT("shlwapi.dll"), wxDL_VERBATIM | wxDL_QUIET) )
s_pfnAssocQueryString = NULL;
else
wxDL_INIT_FUNC_AW(s_pfn, AssocQueryString, s_dllShlwapi);
}
if ( !s_pfnAssocQueryString )
return wxString();
DWORD dwSize = MAX_PATH;
TCHAR bufOut[MAX_PATH] = { 0 };
if ( ext.empty() || ext[0] != '.' )
ext.Prepend('.');
HRESULT hr = s_pfnAssocQueryString
(
wxASSOCF_NOTRUNCATE,// Fail if buffer is too small.
assoc, // The association to retrieve.
ext.t_str(), // The extension to retrieve it for.
verb.empty() ? NULL
: static_cast<const TCHAR*>(verb.t_str()),
bufOut, // The buffer for output value.
&dwSize // And its size
);
// Do not use SUCCEEDED() here as S_FALSE could, in principle, be returned
// but would still be an error in this context.
if ( hr != S_OK )
{
// The only really expected error here is that no association is
// defined, anything else is not expected. The confusing thing is that
// different errors are returned for this expected error under
// different Windows versions: XP returns ERROR_FILE_NOT_FOUND while 7
// returns ERROR_NO_ASSOCIATION. Just check for both to be sure.
if ( hr != HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION) &&
hr != HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) )
{
wxLogApiError("AssocQueryString", hr);
}
return wxString();
}
return wxString(bufOut);
}
wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
{
wxLongLong curtime = wxGetLocalTimeMillis();
curtime += milliseconds;
wxLongLong temp = curtime / 1000;
int sec = temp.GetLo();
temp *= 1000;
temp = curtime - temp;
int millis = temp.GetLo();
timespec tspec;
tspec.tv_sec = sec;
tspec.tv_nsec = millis * 1000L * 1000L;
int err = pthread_cond_timedwait( &m_cond, GetPMutex(), &tspec );
switch ( err )
{
case ETIMEDOUT:
return wxCOND_TIMEOUT;
case 0:
return wxCOND_NO_ERROR;
default:
wxLogApiError(_T("pthread_cond_timedwait()"), err);
}
return wxCOND_MISC_ERROR;
}
/* static */
wxTaskBarButton* wxTaskBarButton::New(wxWindow* parent)
{
wxITaskbarList3* taskbarList = NULL;
HRESULT hr = CoCreateInstance
(
wxCLSID_TaskbarList,
NULL,
CLSCTX_INPROC_SERVER,
wxIID_ITaskbarList3,
reinterpret_cast<void **>(&taskbarList)
);
if ( FAILED(hr) )
{
// Don't log this error, it may be normal when running under XP.
return NULL;
}
hr = taskbarList->HrInit();
if ( FAILED(hr) )
{
// This is however unexpected.
wxLogApiError(wxT("ITaskbarList3::Init"), hr);
taskbarList->Release();
return NULL;
}
return new wxTaskBarButtonImpl(taskbarList, parent);
}
wxMutexError wxMutexInternal::HandleLockResult(int err)
{
// wxPrintf( "err %d\n", err );
switch ( err )
{
case EDEADLK:
// only error checking mutexes return this value and so it's an
// unexpected situation -- hence use assert, not wxLogDebug
wxFAIL_MSG( _T("mutex deadlock prevented") );
return wxMUTEX_DEAD_LOCK;
case EINVAL:
wxLogDebug(_T("pthread_mutex_[timed]lock(): mutex not initialized"));
break;
case ETIMEDOUT:
return wxMUTEX_TIMEOUT;
case 0:
if (m_type == wxMUTEX_DEFAULT)
m_owningThread = wxThread::GetCurrentId();
return wxMUTEX_NO_ERROR;
default:
wxLogApiError(_T("pthread_mutex_[timed]lock()"), err);
}
return wxMUTEX_MISC_ERROR;
}
wxMutexError wxMutexInternal::TryLock()
{
int err = pthread_mutex_trylock(&m_mutex);
switch ( err )
{
case EBUSY:
// not an error: mutex is already locked, but we're prepared for
// this
return wxMUTEX_BUSY;
case EINVAL:
wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
break;
case 0:
if (m_type == wxMUTEX_DEFAULT)
m_owningThread = wxThread::GetCurrentId();
return wxMUTEX_NO_ERROR;
default:
wxLogApiError(_T("pthread_mutex_trylock()"), err);
}
return wxMUTEX_MISC_ERROR;
}
bool wxClipboard::Flush()
{
#if wxUSE_OLE_CLIPBOARD
if (m_lastDataObject)
{
// don't touch data set by other applications
HRESULT hr = OleIsCurrentClipboard(m_lastDataObject);
m_lastDataObject = NULL;
if (S_OK == hr)
{
hr = OleFlushClipboard();
if ( FAILED(hr) )
{
wxLogApiError(wxT("OleFlushClipboard"), hr);
return false;
}
return true;
}
}
return false;
#else // !wxUSE_OLE_CLIPBOARD
return false;
#endif // wxUSE_OLE_CLIPBOARD/!wxUSE_OLE_CLIPBOARD
}
void wxComboCtrl::OnThemeChange()
{
// there doesn't seem to be any way to get the text colour using themes
// API: TMT_TEXTCOLOR doesn't work neither for EDIT nor COMBOBOX
SetForegroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
#if wxUSE_UXTHEME
wxUxThemeEngine * const theme = wxUxThemeEngine::GetIfActive();
if ( theme )
{
// NB: use EDIT, not COMBOBOX (the latter works in XP but not Vista)
wxUxThemeHandle hTheme(this, L"EDIT");
COLORREF col;
HRESULT hr = theme->GetThemeColor
(
hTheme,
EP_EDITTEXT,
ETS_NORMAL,
TMT_FILLCOLOR,
&col
);
if ( SUCCEEDED(hr) )
{
SetBackgroundColour(wxRGBToColour(col));
// skip the call below
return;
}
wxLogApiError(_T("GetThemeColor(EDIT, ETS_NORMAL, TMT_FILLCOLOR)"), hr);
}
#endif
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
}
void wxClipboard::Clear()
{
#if wxUSE_OLE_CLIPBOARD
HRESULT hr = OleSetClipboard(NULL);
if ( FAILED(hr) )
{
wxLogApiError(wxT("OleSetClipboard(NULL)"), hr);
}
#endif // wxUSE_OLE_CLIPBOARD
}
BOINC_Mutex::~BOINC_Mutex()
{
if ( m_isOk )
{
int err = pthread_mutex_destroy( &m_mutex );
if ( err != 0 )
{
wxLogApiError( wxT("pthread_mutex_destroy()"), err );
}
}
}
wxConditionInternal::~wxConditionInternal()
{
if ( m_isOk )
{
int err = pthread_cond_destroy(&m_cond);
if ( err != 0 )
{
wxLogApiError(_T("pthread_cond_destroy()"), err);
}
}
}
wxMutexInternal::~wxMutexInternal()
{
if ( m_isOk )
{
int err = pthread_mutex_destroy(&m_mutex);
if ( err != 0 )
{
wxLogApiError( wxT("pthread_mutex_destroy()"), err);
}
}
}
wxSize wxDatePickerCtrl::DoGetBestSize() const
{
wxClientDC dc(const_cast<wxDatePickerCtrl *>(this));
// we can't use FormatDate() here as the CRT doesn't always use the same
// format as the date picker control
wxString s;
for ( int len = 100; ; len *= 2 )
{
if ( ::GetDateFormat
(
LOCALE_USER_DEFAULT, // the control should use the same
DATE_SHORTDATE, // the format used by the control
NULL, // use current date (we don't care)
NULL, // no custom format
wxStringBuffer(s, len), // output buffer
len // and its length
) )
{
// success
break;
}
const DWORD rc = ::GetLastError();
if ( rc != ERROR_INSUFFICIENT_BUFFER )
{
wxLogApiError(wxT("GetDateFormat"), rc);
// fall back on wxDateTime, what else to do?
s = wxDateTime::Today().FormatDate();
break;
}
}
// the best size for the control is bigger than just the string
// representation of todays date because the control must accommodate any
// date and while the widths of all digits are usually about the same, the
// width of the month string varies a lot, so try to account for it
s += wxT("WW");
int x, y;
dc.GetTextExtent(s, &x, &y);
// account for the drop-down arrow or spin arrows
x += wxSystemSettings::GetMetric(wxSYS_HSCROLL_ARROW_X);
// and for the checkbox if we have it
if ( HasFlag(wxDP_ALLOWNONE) )
x += 3*GetCharWidth();
wxSize best(x, EDIT_HEIGHT_FROM_CHAR_HEIGHT(y));
CacheBestSize(best);
return best;
}
wxCondError wxConditionInternal::Broadcast()
{
int err = pthread_cond_broadcast(&m_cond);
if ( err != 0 )
{
wxLogApiError(_T("pthread_cond_broadcast()"), err);
return wxCOND_MISC_ERROR;
}
return wxCOND_NO_ERROR;
}
wxCondError wxConditionInternal::Wait()
{
int err = pthread_cond_wait(&m_cond, GetPMutex());
if ( err != 0 )
{
wxLogApiError(_T("pthread_cond_wait()"), err);
return wxCOND_MISC_ERROR;
}
return wxCOND_NO_ERROR;
}
wxConditionInternal::wxConditionInternal(wxMutex& mutex)
: m_mutex(mutex)
{
int err = pthread_cond_init(&m_cond, NULL /* default attributes */);
m_isOk = err == 0;
if ( !m_isOk )
{
wxLogApiError(_T("pthread_cond_init()"), err);
}
}
bool wxSafeArrayBase::Unlock()
{
wxCHECK_MSG( m_array, false, wxS("Uninitialized safe array") );
HRESULT hr = SafeArrayUnlock(m_array);
if ( FAILED(hr) )
{
wxLogApiError(wxS("SafeArrayUnlock()"), hr);
return false;
}
return true;
}
void wxSafeArrayBase::Destroy()
{
if ( m_array )
{
Unlock();
HRESULT hr = SafeArrayDestroy(m_array);
if ( FAILED(hr) )
{
wxLogApiError(wxS("SafeArrayDestroy()"), hr);
}
m_array = NULL;
}
}
bool wxSafeArrayBase::GetUBound(size_t dim, long& bound) const
{
wxCHECK_MSG( m_array, false, wxS("Uninitialized safe array") );
wxCHECK_MSG( dim > 0, false, wxS("Invalid dimension index") );
HRESULT hr = SafeArrayGetUBound(m_array, dim, &bound);
if ( FAILED(hr) )
{
wxLogApiError(wxS("SafeArrayGetUBound()"), hr);
return false;
}
return true;
}
// copy the data from the data source to the target data object
bool wxDropTarget::GetData()
{
wxDataFormat format = MSWGetSupportedFormat(m_pIDataSource);
if ( format == wxDF_INVALID ) {
// this is strange because IsAcceptedData() succeeded previously!
wxFAIL_MSG(wxT("strange - did supported formats list change?"));
return false;
}
STGMEDIUM stm;
FORMATETC fmtMemory;
fmtMemory.cfFormat = format;
fmtMemory.ptd = NULL;
fmtMemory.dwAspect = DVASPECT_CONTENT;
fmtMemory.lindex = -1;
fmtMemory.tymed = TYMED_HGLOBAL; // TODO to add other media
bool rc = false;
HRESULT hr = m_pIDataSource->GetData(&fmtMemory, &stm);
if ( SUCCEEDED(hr) ) {
IDataObject *dataObject = m_dataObject->GetInterface();
hr = dataObject->SetData(&fmtMemory, &stm, TRUE);
if ( SUCCEEDED(hr) ) {
rc = true;
}
else {
wxLogApiError(wxT("IDataObject::SetData()"), hr);
}
}
else {
wxLogApiError(wxT("IDataObject::GetData()"), hr);
}
return rc;
}
wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
{
m_type = mutexType;
m_owningThread = 0;
int err;
switch ( mutexType )
{
case wxMUTEX_RECURSIVE:
// support recursive locks like Win32, i.e. a thread can lock a
// mutex which it had itself already locked
//
// unfortunately initialization of recursive mutexes is non
// portable, so try several methods
#ifdef HAVE_PTHREAD_MUTEXATTR_T
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
err = pthread_mutex_init(&m_mutex, &attr);
}
#elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
// we can use this only as initializer so we have to assign it
// first to a temp var - assigning directly to m_mutex wouldn't
// even compile
{
pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
m_mutex = mutex;
}
#else // no recursive mutexes
err = EINVAL;
#endif // HAVE_PTHREAD_MUTEXATTR_T/...
break;
default:
wxFAIL_MSG( _T("unknown mutex type") );
// fall through
case wxMUTEX_DEFAULT:
err = pthread_mutex_init(&m_mutex, NULL);
break;
}
m_isOk = err == 0;
if ( !m_isOk )
{
wxLogApiError( wxT("pthread_mutex_init()"), err);
}
}
wxDisplayImpl *wxDisplayFactoryDirectDraw::CreateDisplay(unsigned n)
{
wxCHECK_MSG( n < m_displays.size(), NULL, wxT("invalid display index") );
wxDisplayInfoDirectDraw *
info = static_cast<wxDisplayInfoDirectDraw *>(m_displays[n]);
if ( !info->m_pDD2 )
{
IDirectDraw *pDD;
GUID guid(info->m_guid);
HRESULT hr = (*m_pfnDirectDrawCreate)(&guid, &pDD, NULL);
if ( FAILED(hr) || !pDD )
{
// what to do??
wxLogApiError(wxT("DirectDrawCreate"), hr);
return NULL;
}
// we got IDirectDraw, but we need IDirectDraw2
hr = pDD->QueryInterface(wxIID_IDirectDraw2, (void **)&info->m_pDD2);
pDD->Release();
if ( FAILED(hr) || !info->m_pDD2 )
{
wxLogApiError(wxT("IDirectDraw::QueryInterface(IDD2)"), hr);
return NULL;
}
// NB: m_pDD2 will now be only destroyed when m_displays is destroyed
// which is ok as we don't want to recreate DD objects all the time
}
//else: DirectDraw object corresponding to our display already exists
return new wxDisplayImplDirectDraw(n, *info, info->m_pDD2);
}
bool wxDropTarget::Register(WXHWND hwnd)
{
// FIXME
// RegisterDragDrop not available on Windows CE >= 400?
// Or maybe we can dynamically load them from ceshell.dll
// or similar.
#if defined(__WXWINCE__) && _WIN32_WCE >= 400
wxUnusedVar(hwnd);
return false;
#else
HRESULT hr;
// May exist in later WinCE versions
#ifndef __WXWINCE__
hr = ::CoLockObjectExternal(m_pIDropTarget, TRUE, FALSE);
if ( FAILED(hr) ) {
wxLogApiError(wxT("CoLockObjectExternal"), hr);
return false;
}
#endif
hr = ::RegisterDragDrop((HWND) hwnd, m_pIDropTarget);
if ( FAILED(hr) ) {
// May exist in later WinCE versions
#ifndef __WXWINCE__
::CoLockObjectExternal(m_pIDropTarget, FALSE, FALSE);
#endif
wxLogApiError(wxT("RegisterDragDrop"), hr);
return false;
}
// we will need the window handle for coords transformation later
m_pIDropTarget->SetHwnd((HWND)hwnd);
return true;
#endif
}
const void *wxDataObject::GetSizeFromBuffer(const void *buffer,
size_t *size,
const wxDataFormat& WXUNUSED(format))
{
// hack: the third parameter is declared non-const in Wine's headers so
// cast away the const
const size_t realsz = ::HeapSize(::GetProcessHeap(), 0,
const_cast<void*>(buffer));
if ( realsz == (size_t)-1 )
{
// note that HeapSize() does not set last error
wxLogApiError(wxT("HeapSize"), 0);
return NULL;
}
*size = realsz;
return buffer;
}
void wxClipboard::Clear()
{
#if wxUSE_OLE_CLIPBOARD
if (m_lastDataObject)
{
// don't touch data set by other applications
HRESULT hr = OleIsCurrentClipboard(m_lastDataObject);
if (S_OK == hr)
{
hr = OleSetClipboard(NULL);
if ( FAILED(hr) )
{
wxLogApiError(wxT("OleSetClipboard(NULL)"), hr);
}
}
m_lastDataObject = NULL;
}
#endif // wxUSE_OLE_CLIPBOARD
}
extern bool wxEnableFileNameAutoComplete(HWND hwnd)
{
#if wxUSE_DYNLIB_CLASS
typedef HRESULT (WINAPI *SHAutoComplete_t)(HWND, DWORD);
static SHAutoComplete_t s_pfnSHAutoComplete = NULL;
static bool s_initialized = false;
if ( !s_initialized )
{
s_initialized = true;
wxLogNull nolog;
wxDynamicLibrary dll(wxT("shlwapi.dll"));
if ( dll.IsLoaded() )
{
s_pfnSHAutoComplete =
(SHAutoComplete_t)dll.GetSymbol(wxT("SHAutoComplete"));
if ( s_pfnSHAutoComplete )
{
// won't be unloaded until the process termination, no big deal
dll.Detach();
}
}
}
if ( !s_pfnSHAutoComplete )
return false;
HRESULT hr = s_pfnSHAutoComplete(hwnd, 0x10 /* SHACF_FILESYS_ONLY */);
if ( FAILED(hr) )
{
wxLogApiError(wxT("SHAutoComplete"), hr);
return false;
}
return true;
#else
wxUnusedVar(hwnd);
return false;
#endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
}
// Name : DoDragDrop
// Purpose : start drag and drop operation
// Returns : wxDragResult - the code of performed operation
// Params : [in] int flags: specifies if moving is allowe (or only copying)
// Notes : you must call SetData() before if you had used def ctor
wxDragResult wxDropSource::DoDragDrop(int flags)
{
wxCHECK_MSG( m_data != NULL, wxDragNone, wxT("No data in wxDropSource!") );
DWORD dwEffect;
HRESULT hr = ::DoDragDrop(m_data->GetInterface(),
m_pIDropSource,
(flags & wxDrag_AllowMove)
? DROPEFFECT_COPY | DROPEFFECT_MOVE
: DROPEFFECT_COPY,
&dwEffect);
if ( hr == DRAGDROP_S_CANCEL ) {
return wxDragCancel;
}
else if ( hr == DRAGDROP_S_DROP ) {
if ( dwEffect & DROPEFFECT_COPY ) {
return wxDragCopy;
}
else if ( dwEffect & DROPEFFECT_MOVE ) {
// consistency check: normally, we shouldn't get "move" at all
// here if we don't allow it, but in practice it does happen quite often
return (flags & wxDrag_AllowMove) ? wxDragMove : wxDragCopy;
}
else {
// not copy or move
return wxDragNone;
}
}
else {
if ( FAILED(hr) ) {
wxLogApiError(wxT("DoDragDrop"), hr);
wxLogError(wxT("Drag & drop operation failed."));
}
else {
wxLogDebug(wxT("Unexpected success return code %08lx from DoDragDrop."),
hr);
}
return wxDragError;
}
}
// Helper wrapping AssocQueryString() Win32 function: returns the value of the
// given associated string for the specified extension (which may or not have
// the leading period).
//
// Returns empty string if the association is not found.
static
wxString wxAssocQueryString(ASSOCSTR assoc,
wxString ext,
const wxString& verb = wxString())
{
DWORD dwSize = MAX_PATH;
TCHAR bufOut[MAX_PATH] = { 0 };
if ( ext.empty() || ext[0] != '.' )
ext.Prepend('.');
HRESULT hr = ::AssocQueryString
(
wxASSOCF_NOTRUNCATE,// Fail if buffer is too small.
assoc, // The association to retrieve.
ext.t_str(), // The extension to retrieve it for.
verb.empty() ? NULL
: static_cast<const TCHAR*>(verb.t_str()),
bufOut, // The buffer for output value.
&dwSize // And its size
);
// Do not use SUCCEEDED() here as S_FALSE could, in principle, be returned
// but would still be an error in this context.
if ( hr != S_OK )
{
// The only really expected error here is that no association is
// defined, anything else is not expected. The confusing thing is that
// different errors are returned for this expected error under
// different Windows versions: XP returns ERROR_FILE_NOT_FOUND while 7
// returns ERROR_NO_ASSOCIATION. Just check for both to be sure.
if ( hr != HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION) &&
hr != HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) )
{
wxLogApiError("AssocQueryString", hr);
}
return wxString();
}
return wxString(bufOut);
}
