static bool wxCheckWin32Permission(const wxString& path, DWORD access)
{
// quoting the MSDN: "To obtain a handle to a directory, call the
// CreateFile function with the FILE_FLAG_BACKUP_SEMANTICS flag"
const DWORD dwAttr = ::GetFileAttributes(path.t_str());
if ( dwAttr == INVALID_FILE_ATTRIBUTES )
{
// file probably doesn't exist at all
return false;
}
HANDLE h = ::CreateFile
(
path.t_str(),
access,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL,
OPEN_EXISTING,
dwAttr & FILE_ATTRIBUTE_DIRECTORY
? FILE_FLAG_BACKUP_SEMANTICS
: 0,
NULL
);
if ( h != INVALID_HANDLE_VALUE )
CloseHandle(h);
return h != INVALID_HANDLE_VALUE;
}
// 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);
}
// This form is deprecated
wxPrinterDC::wxPrinterDC(const wxString& driver_name,
const wxString& device_name,
const wxString& file,
bool interactive,
wxPrintOrientation orientation)
{
m_isInteractive = interactive;
if ( !file.empty() )
m_printData.SetFilename(file);
#if wxUSE_COMMON_DIALOGS
if ( interactive )
{
PRINTDLG pd;
pd.lStructSize = sizeof( PRINTDLG );
pd.hwndOwner = (HWND) NULL;
pd.hDevMode = (HANDLE)NULL;
pd.hDevNames = (HANDLE)NULL;
pd.Flags = PD_RETURNDC | PD_NOSELECTION | PD_NOPAGENUMS;
pd.nFromPage = 0;
pd.nToPage = 0;
pd.nMinPage = 0;
pd.nMaxPage = 0;
pd.nCopies = 1;
pd.hInstance = (HINSTANCE)NULL;
m_ok = PrintDlg( &pd ) != 0;
if ( m_ok )
{
m_hDC = (WXHDC) pd.hDC;
}
}
else
#endif // wxUSE_COMMON_DIALOGS
{
if ( !driver_name.empty() && !device_name.empty() && !file.empty() )
{
m_hDC = (WXHDC) CreateDC(driver_name.t_str(),
device_name.t_str(),
file.fn_str(),
NULL);
}
else // we don't have all parameters, ask the user
{
wxPrintData printData;
printData.SetOrientation(orientation);
m_hDC = wxGetPrinterDC(printData);
}
m_ok = m_hDC ? true: false;
// as we created it, we must delete it as well
m_bOwnsDC = true;
}
Init();
}
void wxSafeShowMessage(const wxString& title, const wxString& text)
{
#ifdef __WINDOWS__
::MessageBox(NULL, text.t_str(), title.t_str(), MB_OK | MB_ICONSTOP);
#else
wxFprintf(stderr, wxS("%s: %s\n"), title.c_str(), text.c_str());
fflush(stderr);
#endif
}
void wxEnhMetaFileDCImpl::Create(HDC hdcRef,
const wxString& filename,
int width, int height,
const wxString& description)
{
m_width = width;
m_height = height;
RECT rect;
RECT *pRect;
if ( width && height )
{
rect.top =
rect.left = 0;
rect.right = width;
rect.bottom = height;
// CreateEnhMetaFile() wants them in HIMETRIC
PixelToHIMETRIC(&rect.right, &rect.bottom, hdcRef);
pRect = ▭
}
else
{
// GDI will try to find out the size for us (not recommended)
pRect = (LPRECT)NULL;
}
m_hDC = (WXHDC)::CreateEnhMetaFile(hdcRef, GetMetaFileName(filename),
pRect, description.t_str());
if ( !m_hDC )
{
wxLogLastError(wxT("CreateEnhMetaFile"));
}
}
bool wxPrinterDCImpl::StartDoc(const wxString& message)
{
DOCINFO docinfo;
docinfo.cbSize = sizeof(DOCINFO);
docinfo.lpszDocName = message.t_str();
wxString filename(m_printData.GetFilename());
if (filename.empty())
docinfo.lpszOutput = NULL;
else
docinfo.lpszOutput = filename.t_str();
docinfo.lpszDatatype = NULL;
docinfo.fwType = 0;
if (!m_hDC)
return false;
if ( ::StartDoc(GetHdc(), &docinfo) <= 0 )
{
wxLogLastError(wxT("StartDoc"));
return false;
}
return true;
}
bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
{
WXHMENU submenu = menu ? menu->GetHMenu() : 0;
wxCHECK_MSG( submenu, false, wxT("can't append invalid menu to menubar") );
if ( !wxMenuBarBase::Append(menu, title) )
return false;
menu->wxMenuBase::SetTitle(title);
if (GetHmenu())
{
if ( !::AppendMenu(GetHmenu(), MF_POPUP | MF_STRING,
(UINT_PTR)submenu, title.t_str()) )
{
wxLogLastError(wxT("AppendMenu"));
}
#if wxUSE_ACCEL
if ( menu->HasAccels() )
{
// need to rebuild accelerator table
RebuildAccelTable();
}
#endif // wxUSE_ACCEL
if (IsAttached())
Refresh();
}
return true;
}
bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
{
// Find out which MSW item before which we'll be inserting before
// wxMenuBarBase::Insert is called and GetMenu(pos) is the new menu.
// If IsAttached() is false this won't be used anyway
bool isAttached =
(GetHmenu() != 0);
if ( !wxMenuBarBase::Insert(pos, menu, title) )
return false;
menu->wxMenuBase::SetTitle(title);
if ( isAttached )
{
// We have a problem with the index if there is an extra "Window" menu
// in this menu bar, which is added by wxMDIParentFrame to it directly
// using Windows API (so that it remains invisible to the user code),
// but which does affect the indices of the items we insert after it.
// So we check if any of the menus before the insertion position is a
// foreign one and adjust the insertion index accordingly.
int mswExtra = 0;
// Skip all this if the total number of menus matches (notice that the
// internal menu count has already been incremented by wxMenuBarBase::
// Insert() call above, hence -1).
int mswCount = ::GetMenuItemCount(GetHmenu());
if ( mswCount != -1 &&
static_cast<unsigned>(mswCount) != GetMenuCount() - 1 )
{
wxMenuList::compatibility_iterator node = m_menus.GetFirst();
for ( size_t n = 0; n < pos; n++ )
{
if ( ::GetSubMenu(GetHmenu(), n) != GetHmenuOf(node->GetData()) )
mswExtra++;
else
node = node->GetNext();
}
}
if ( !::InsertMenu(GetHmenu(), pos + mswExtra,
MF_BYPOSITION | MF_POPUP | MF_STRING,
(UINT_PTR)GetHmenuOf(menu), title.t_str()) )
{
wxLogLastError(wxT("InsertMenu"));
}
#if wxUSE_ACCEL
if ( menu->HasAccels() )
{
// need to rebuild accell table
RebuildAccelTable();
}
#endif // wxUSE_ACCEL
if (IsAttached())
Refresh();
}
return true;
}
void wxMessageOutputBest::Output(const wxString& str)
{
#ifdef __WINDOWS__
// decide whether to use console output or not
wxAppTraits * const traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
const bool hasStderr = traits ? traits->CanUseStderr() : false;
if ( !(m_flags & wxMSGOUT_PREFER_MSGBOX) )
{
if ( hasStderr && traits->WriteToStderr(AppendLineFeedIfNeeded(str)) )
return;
}
wxString title;
if ( wxTheApp )
title = wxTheApp->GetAppDisplayName();
else // Use some title to avoid default "Error"
title = _("Message");
::MessageBox(NULL, str.t_str(), title.t_str(), MB_ICONINFORMATION | MB_OK);
#else // !__WINDOWS__
wxUnusedVar(m_flags);
// TODO: use the native message box for the other ports too
wxMessageOutputStderr::Output(str);
#endif // __WINDOWS__/!__WINDOWS__
}
bool KeyExists(WXHKEY hRootKey,
const wxString& szKey,
wxRegKey::WOW64ViewMode viewMode)
{
// don't close this key itself for the case of empty szKey!
if ( szKey.empty() )
return true;
HKEY hkeyDummy;
if ( ::RegOpenKeyEx
(
(HKEY)hRootKey,
szKey.t_str(),
RESERVED,
// we might not have enough rights for rw access
GetMSWAccessFlags(wxRegKey::Read, viewMode),
&hkeyDummy
) == ERROR_SUCCESS )
{
::RegCloseKey(hkeyDummy);
return true;
}
return false;
}
int RunProcess(const wxString& cmd, const wxArrayString& params)
{
wxString paramstring;
for (wxString param: params) {
if (!paramstring.empty()) {
paramstring += _T(" ");
}
paramstring += escapeStr(param);
}
#ifdef __WXMSW__
SHELLEXECUTEINFO ShExecInfo;
DWORD exitCode = 0;
ShExecInfo.cbSize = sizeof(SHELLEXECUTEINFO);
ShExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
ShExecInfo.hwnd = NULL;
ShExecInfo.lpVerb = NULL;
ShExecInfo.lpFile = cmd.t_str();
ShExecInfo.lpParameters = paramstring.t_str();
ShExecInfo.lpDirectory = NULL;
ShExecInfo.nShow = SW_SHOW;
ShExecInfo.hInstApp = NULL;
ShellExecuteEx(&ShExecInfo);
WaitForSingleObject(ShExecInfo.hProcess,INFINITE);
GetExitCodeProcess(ShExecInfo.hProcess, &exitCode);
return exitCode;
#else
wxString realcmd = escapeStr(cmd);
if (!paramstring.empty()) {
realcmd += _T(" ") + paramstring;
}
return system( realcmd.mb_str( wxConvUTF8 ) );
#endif
}
bool wxDoSetEnv(const wxString& var, const wxChar *value)
{
// update the CRT environment if possible as people expect getenv() to also
// work and it is not affected by Win32 SetEnvironmentVariable() call (OTOH
// the CRT does use Win32 call to update the process environment block so
// there is no need to call it)
//
// TODO: add checks for the other compilers (and update wxSetEnv()
// documentation in interface/wx/utils.h accordingly)
#if defined(__VISUALC__) || defined(__MINGW32__)
// notice that Microsoft _putenv() has different semantics from POSIX
// function with almost the same name: in particular it makes a copy of the
// string instead of using it as part of environment so we can safely call
// it here without going through all the troubles with wxSetEnvModule as in
// src/unix/utilsunx.cpp
wxString envstr = var;
envstr += '=';
if ( value )
envstr += value;
if ( _tputenv(envstr.t_str()) != 0 )
return false;
#else // other compiler
if ( !::SetEnvironmentVariable(var.t_str(), value) )
{
wxLogLastError(wxT("SetEnvironmentVariable"));
return false;
}
#endif // compiler
return true;
}
bool wxTextMeasure::DoGetPartialTextExtents(const wxString& text,
wxArrayInt& widths,
double scaleX)
{
if ( !m_hdc )
return wxTextMeasureBase::DoGetPartialTextExtents(text, widths, scaleX);
int fit = 0;
SIZE sz = {0,0};
if ( !::GetTextExtentExPoint(m_hdc,
text.t_str(), // string to check
text.length(),
INT_MAX, // max allowable width
&fit, // [out] count of chars
// that will fit
&widths[0], // array to fill
&sz) )
{
wxLogLastError(wxT("GetTextExtentExPoint"));
return false;
}
return true;
}
bool wxMDIParentFrame::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
// this style can be used to prevent a window from having the standard MDI
// "Window" menu
if ( !(style & wxFRAME_NO_WINDOW_MENU) )
{
// normal case: we have the window menu, so construct it
m_windowMenu = new wxMenu;
m_windowMenu->Append(wxID_MDI_WINDOW_CASCADE, _("&Cascade"));
m_windowMenu->Append(wxID_MDI_WINDOW_TILE_HORZ, _("Tile &Horizontally"));
m_windowMenu->Append(wxID_MDI_WINDOW_TILE_VERT, _("Tile &Vertically"));
m_windowMenu->AppendSeparator();
m_windowMenu->Append(wxID_MDI_WINDOW_ARRANGE_ICONS, _("&Arrange Icons"));
m_windowMenu->Append(wxID_MDI_WINDOW_NEXT, _("&Next"));
m_windowMenu->Append(wxID_MDI_WINDOW_PREV, _("&Previous"));
}
if (!parent)
wxTopLevelWindows.Append(this);
SetName(name);
m_windowStyle = style;
if ( parent )
parent->AddChild(this);
if ( id != wxID_ANY )
m_windowId = id;
else
m_windowId = NewControlId();
WXDWORD exflags;
WXDWORD msflags = MSWGetCreateWindowFlags(&exflags);
msflags &= ~WS_VSCROLL;
msflags &= ~WS_HSCROLL;
if ( !wxWindow::MSWCreate(wxApp::GetRegisteredClassName(wxT("wxMDIFrame")),
title.t_str(),
pos, size,
msflags,
exflags) )
{
return false;
}
SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
// unlike (almost?) all other windows, frames are created hidden
m_isShown = false;
return true;
}
bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
{
WXHMENU submenu = menu ? menu->GetHMenu() : 0;
wxCHECK_MSG( submenu, false, wxT("can't append invalid menu to menubar") );
if ( !wxMenuBarBase::Append(menu, title) )
return false;
menu->wxMenuBase::SetTitle(title);
#if defined(WINCE_WITHOUT_COMMANDBAR)
if (IsAttached())
#else
if (GetHmenu())
#endif
{
#if defined(WINCE_WITHOUT_COMMANDBAR)
if (!GetToolBar())
return false;
TBBUTTON tbButton;
memset(&tbButton, 0, sizeof(TBBUTTON));
tbButton.iBitmap = I_IMAGENONE;
tbButton.fsState = TBSTATE_ENABLED;
tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
size_t pos = GetMenuCount();
HMENU hPopupMenu = (HMENU) menu->GetHMenu() ;
tbButton.dwData = (DWORD)hPopupMenu;
wxString label = wxStripMenuCodes(title);
tbButton.iString = (int) wxMSW_CONV_LPCTSTR(label);
tbButton.idCommand = NewControlId();
if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_INSERTBUTTON, pos, (LPARAM)&tbButton))
{
wxLogLastError(wxT("TB_INSERTBUTTON"));
return false;
}
#else
if ( !::AppendMenu(GetHmenu(), MF_POPUP | MF_STRING,
(UINT_PTR)submenu, title.t_str()) )
{
wxLogLastError(wxT("AppendMenu"));
}
#endif
#if wxUSE_ACCEL
if ( menu->HasAccels() )
{
// need to rebuild accelerator table
RebuildAccelTable();
}
#endif // wxUSE_ACCEL
if (IsAttached())
Refresh();
}
return true;
}
void wxDataFormat::SetId(const wxString& format)
{
m_format = (wxDataFormat::NativeFormat)::RegisterClipboardFormat(format.t_str());
if ( !m_format )
{
wxLogError(_("Couldn't register clipboard format '%s'."), format);
}
}
bool
wxTaskBarIcon::ShowBalloon(const wxString& title,
const wxString& text,
unsigned msec,
int flags)
{
wxCHECK_MSG( m_iconAdded, false,
wxT("can't be used before the icon is created") );
const HWND hwnd = GetHwndOf(m_win);
// we need to enable version 5.0 behaviour to receive notifications about
// the balloon disappearance
NotifyIconData notifyData(hwnd);
notifyData.uFlags = 0;
notifyData.uVersion = 3 /* NOTIFYICON_VERSION for Windows 2000/XP */;
if ( !Shell_NotifyIcon(NIM_SETVERSION, ¬ifyData) )
{
wxLogLastError(wxT("Shell_NotifyIcon(NIM_SETVERSION)"));
}
// do show the balloon now
notifyData = NotifyIconData(hwnd);
notifyData.uFlags |= NIF_INFO;
notifyData.uTimeout = msec;
wxStrlcpy(notifyData.szInfo, text.t_str(), WXSIZEOF(notifyData.szInfo));
wxStrlcpy(notifyData.szInfoTitle, title.t_str(),
WXSIZEOF(notifyData.szInfoTitle));
if ( flags & wxICON_INFORMATION )
notifyData.dwInfoFlags |= NIIF_INFO;
else if ( flags & wxICON_WARNING )
notifyData.dwInfoFlags |= NIIF_WARNING;
else if ( flags & wxICON_ERROR )
notifyData.dwInfoFlags |= NIIF_ERROR;
bool ok = Shell_NotifyIcon(NIM_MODIFY, ¬ifyData) != 0;
if ( !ok )
{
wxLogLastError(wxT("Shell_NotifyIcon(NIM_MODIFY)"));
}
return ok;
}
bool TFlybotAPI::SendPM(const wxString& cid, const wxString& msg)
{
if (m_botAPI.SendMessage2 && !cid.empty() && !msg.empty())
{
return m_botAPI.SendMessage2(BotInit::SEND_PM, cid.c_str(), msg.t_str(),
(unsigned int)msg.size() + sizeof(wxChar));
}
return false;
}
void wxMenuBar::SetMenuLabel(size_t pos, const wxString& label)
{
wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
m_menus[pos]->wxMenuBase::SetTitle(label);
if ( !IsAttached() )
{
return;
}
//else: have to modify the existing menu
int mswpos = MSWPositionForWxMenu(GetMenu(pos),pos);
UINT_PTR id;
UINT flagsOld = ::GetMenuState((HMENU)m_hMenu, mswpos, MF_BYPOSITION);
if ( flagsOld == 0xFFFFFFFF )
{
wxLogLastError(wxT("GetMenuState"));
return;
}
if ( flagsOld & MF_POPUP )
{
// HIBYTE contains the number of items in the submenu in this case
flagsOld &= 0xff;
id = (UINT_PTR)::GetSubMenu((HMENU)m_hMenu, mswpos);
}
else
{
id = pos;
}
#ifdef __WXWINCE__
WinStruct<MENUITEMINFO> info;
info.fMask = MIIM_TYPE;
info.fType = MFT_STRING;
info.cch = label.length();
info.dwTypeData = wxMSW_CONV_LPTSTR(label);
if ( !SetMenuItemInfo(GetHmenu(), id, TRUE, &info) )
{
wxLogLastError(wxT("SetMenuItemInfo"));
}
#else
if ( ::ModifyMenu(GetHmenu(), mswpos, MF_BYPOSITION | MF_STRING | flagsOld,
id, label.t_str()) == (int)0xFFFFFFFF )
{
wxLogLastError(wxT("ModifyMenu"));
}
#endif
Refresh();
}
// 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);
}
// Notice we don't check here the font. It is supposed to be OK before the call.
void wxTextMeasure::DoGetTextExtent(const wxString& string,
wxCoord *width,
wxCoord *height,
wxCoord *descent,
wxCoord *externalLeading)
{
SIZE sizeRect;
const size_t len = string.length();
if ( !::GetTextExtentPoint32(m_hdc, string.t_str(), len, &sizeRect) )
{
wxLogLastError(wxT("GetTextExtentPoint32()"));
}
#if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
// the result computed by GetTextExtentPoint32() may be too small as it
// accounts for under/overhang of the first/last character while we want
// just the bounding rect for this string so adjust the width as needed
// (using API not available in 2002 SDKs of WinCE)
if ( len > 0 )
{
ABC widthABC;
const wxChar chFirst = *string.begin();
if ( ::GetCharABCWidths(m_hdc, chFirst, chFirst, &widthABC) )
{
if ( widthABC.abcA < 0 )
sizeRect.cx -= widthABC.abcA;
if ( len > 1 )
{
const wxChar chLast = *string.rbegin();
::GetCharABCWidths(m_hdc, chLast, chLast, &widthABC);
}
//else: we already have the width of the last character
if ( widthABC.abcC < 0 )
sizeRect.cx -= widthABC.abcC;
}
//else: GetCharABCWidths() failed, not a TrueType font?
}
#endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
*width = sizeRect.cx;
*height = sizeRect.cy;
if ( descent || externalLeading )
{
TEXTMETRIC tm;
::GetTextMetrics(m_hdc, &tm);
if ( descent )
*descent = tm.tmDescent;
if ( externalLeading )
*externalLeading = tm.tmExternalLeading;
}
}
bool wxGetEnv(const wxString& var,
wxString *value)
{
// first get the size of the buffer
DWORD dwRet = ::GetEnvironmentVariable(var.t_str(), NULL, 0);
if ( !dwRet )
{
// this means that there is no such variable
return false;
}
if ( value )
{
(void)::GetEnvironmentVariable(var.t_str(),
wxStringBuffer(*value, dwRet),
dwRet);
}
return true;
}
int wxListBox::FindString(const wxString& s, bool bCase) const
{
// back to base class search for not native search type
if (bCase)
return wxItemContainerImmutable::FindString( s, bCase );
int pos = ListBox_FindStringExact(GetHwnd(), -1, s.t_str());
if (pos == LB_ERR)
return wxNOT_FOUND;
else
return pos;
}
bool wxSetWorkingDirectory(const wxString& d)
{
bool success = false;
#if defined(__UNIX__) || defined(__WXMAC__)
success = (chdir(d.fn_str()) == 0);
#elif defined(__WINDOWS__)
success = (SetCurrentDirectory(d.t_str()) != 0);
#endif
if ( !success )
{
wxLogSysError(_("Could not set current working directory"));
}
return success;
}
bool wxTopLevelWindowMSW::CreateFrame(const wxString& title,
const wxPoint& pos,
const wxSize& size)
{
WXDWORD exflags;
WXDWORD flags = MSWGetCreateWindowFlags(&exflags);
const wxSize sz = IsAlwaysMaximized() ? wxDefaultSize : size;
if ( wxApp::MSWGetDefaultLayout(m_parent) == wxLayout_RightToLeft )
exflags |= WS_EX_LAYOUTRTL;
return MSWCreate(MSWGetRegisteredClassName(),
title.t_str(), pos, sz, flags, exflags);
}
bool Create(const wxString& name)
{
m_hMutex = ::CreateMutex(NULL, FALSE, name.t_str());
if ( !m_hMutex )
{
wxLogLastError(wxT("CreateMutex"));
return false;
}
// mutex was either created or opened - see what really happened
m_wasOpened = ::GetLastError() == ERROR_ALREADY_EXISTS;
return true;
}
bool wxGetDiskSpace(const wxString& path,
wxDiskspaceSize_t *pTotal,
wxDiskspaceSize_t *pFree)
{
if ( path.empty() )
return false;
ULARGE_INTEGER bytesFree, bytesTotal;
// may pass the path as is, GetDiskFreeSpaceEx() is smart enough
if ( !::GetDiskFreeSpaceEx(path.t_str(),
&bytesFree,
&bytesTotal,
NULL) )
{
wxLogLastError(wxT("GetDiskFreeSpaceEx"));
return false;
}
// ULARGE_INTEGER is a union of a 64 bit value and a struct containing
// two 32 bit fields which may be or may be not named - try to make it
// compile in all cases
#if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
#define UL(ul) ul.u
#else // anon union
#define UL(ul) ul
#endif
if ( pTotal )
{
#if wxUSE_LONGLONG
*pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
#else
*pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart);
#endif
}
if ( pFree )
{
#if wxUSE_LONGLONG
*pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
#else
*pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);
#endif
}
return true;
}
bool wxRegKey::SetValue(const wxString& szValue, const wxString& strValue)
{
if ( CONST_CAST Open() ) {
m_dwLastError = RegSetValueEx((HKEY) m_hKey,
RegValueStr(szValue),
(DWORD) RESERVED, REG_SZ,
(RegString)strValue.t_str(),
(strValue.Len() + 1)*sizeof(wxChar));
if ( m_dwLastError == ERROR_SUCCESS )
return true;
}
wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
GetFullName(this, szValue));
return false;
}
bool wxCHMHelpController::KeywordSearch(const wxString& k,
wxHelpSearchMode WXUNUSED(mode))
{
if (m_helpFile.IsEmpty())
return false;
HH_AKLINK link;
link.cbStruct = sizeof(HH_AKLINK);
link.fReserved = FALSE;
link.pszKeywords = k.t_str();
link.pszUrl = NULL;
link.pszMsgText = NULL;
link.pszMsgTitle = NULL;
link.pszWindow = NULL;
link.fIndexOnFail = TRUE;
return CallHtmlHelp(HH_KEYWORD_LOOKUP, &link);
}
const wxChar *RegTreeCtrl::TreeNode::FullName() const
{
static wxString s_strName;
if ( IsRoot() )
{
return wxT("Registry Root");
}
else
{
// our own registry key might not (yet) exist or we might be a value,
// so just use the parent's and concatenate
s_strName = Parent()->FullName();
s_strName << wxT('\\') << m_strName;
return s_strName.t_str();
}
}
