| 1 | ///////////////////////////////////////////////////////////////////////////// |
| 2 | // Name: src/msw/utils.cpp |
| 3 | // Purpose: Various utilities |
| 4 | // Author: Julian Smart |
| 5 | // Modified by: |
| 6 | // Created: 04/01/98 |
| 7 | // Copyright: (c) Julian Smart |
| 8 | // Licence: wxWindows licence |
| 9 | ///////////////////////////////////////////////////////////////////////////// |
| 10 | |
| 11 | // ============================================================================ |
| 12 | // declarations |
| 13 | // ============================================================================ |
| 14 | |
| 15 | // ---------------------------------------------------------------------------- |
| 16 | // headers |
| 17 | // ---------------------------------------------------------------------------- |
| 18 | |
| 19 | // For compilers that support precompilation, includes "wx.h". |
| 20 | #include "wx/wxprec.h" |
| 21 | |
| 22 | #ifdef __BORLANDC__ |
| 23 | #pragma hdrstop |
| 24 | #endif |
| 25 | |
| 26 | #ifndef WX_PRECOMP |
| 27 | #include "wx/utils.h" |
| 28 | #include "wx/app.h" |
| 29 | #include "wx/intl.h" |
| 30 | #include "wx/log.h" |
| 31 | #endif //WX_PRECOMP |
| 32 | |
| 33 | #include "wx/msw/registry.h" |
| 34 | #include "wx/apptrait.h" |
| 35 | #include "wx/dynlib.h" |
| 36 | #include "wx/dynload.h" |
| 37 | #include "wx/scopeguard.h" |
| 38 | #include "wx/filename.h" |
| 39 | |
| 40 | #include "wx/confbase.h" // for wxExpandEnvVars() |
| 41 | |
| 42 | #include "wx/msw/private.h" // includes <windows.h> |
| 43 | #include "wx/msw/private/hiddenwin.h" |
| 44 | #include "wx/msw/missing.h" // for CHARSET_HANGUL |
| 45 | |
| 46 | #if defined(__CYGWIN__) |
| 47 | //CYGWIN gives annoying warning about runtime stuff if we don't do this |
| 48 | # define USE_SYS_TYPES_FD_SET |
| 49 | # include <sys/types.h> |
| 50 | #endif |
| 51 | |
| 52 | // Doesn't work with Cygwin at present |
| 53 | #if wxUSE_SOCKETS && (defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) || defined(__CYGWIN32__)) |
| 54 | // apparently we need to include winsock.h to get WSADATA and other stuff |
| 55 | // used in wxGetFullHostName() with the old mingw32 versions |
| 56 | #include <winsock.h> |
| 57 | #endif |
| 58 | |
| 59 | #if !defined(__GNUWIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__) |
| 60 | #include <direct.h> |
| 61 | |
| 62 | #include <dos.h> |
| 63 | #endif //GNUWIN32 |
| 64 | |
| 65 | #if defined(__CYGWIN__) |
| 66 | #include <sys/unistd.h> |
| 67 | #include <sys/stat.h> |
| 68 | #include <sys/cygwin.h> // for cygwin_conv_path() |
| 69 | // and cygwin_conv_to_full_win32_path() |
| 70 | #include <cygwin/version.h> |
| 71 | #endif //GNUWIN32 |
| 72 | |
| 73 | #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs |
| 74 | // this (3.1 I believe) and how to test for it. |
| 75 | // If this works for Borland 4.0 as well, then no worries. |
| 76 | #include <dir.h> |
| 77 | #endif |
| 78 | |
| 79 | // VZ: there is some code using NetXXX() functions to get the full user name: |
| 80 | // I don't think it's a good idea because they don't work under Win95 and |
| 81 | // seem to return the same as wxGetUserId() under NT. If you really want |
| 82 | // to use them, just #define USE_NET_API |
| 83 | #undef USE_NET_API |
| 84 | |
| 85 | #ifdef USE_NET_API |
| 86 | #include <lm.h> |
| 87 | #endif // USE_NET_API |
| 88 | |
| 89 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__) |
| 90 | #ifndef __UNIX__ |
| 91 | #include <io.h> |
| 92 | #endif |
| 93 | |
| 94 | #ifndef __GNUWIN32__ |
| 95 | #include <shellapi.h> |
| 96 | #endif |
| 97 | #endif |
| 98 | |
| 99 | #ifndef __WATCOMC__ |
| 100 | #if !(defined(_MSC_VER) && (_MSC_VER > 800)) |
| 101 | #include <errno.h> |
| 102 | #endif |
| 103 | #endif |
| 104 | |
| 105 | // For wxKillAllChildren |
| 106 | #include <tlhelp32.h> |
| 107 | |
| 108 | // ---------------------------------------------------------------------------- |
| 109 | // constants |
| 110 | // ---------------------------------------------------------------------------- |
| 111 | |
| 112 | // In the WIN.INI file |
| 113 | #if (!defined(USE_NET_API) && !defined(__WXWINCE__)) || defined(__WXMICROWIN__) |
| 114 | static const wxChar WX_SECTION[] = wxT("wxWindows"); |
| 115 | #endif |
| 116 | |
| 117 | #if (!defined(USE_NET_API) && !defined(__WXWINCE__)) |
| 118 | static const wxChar eUSERNAME[] = wxT("UserName"); |
| 119 | #endif |
| 120 | |
| 121 | WXDLLIMPEXP_DATA_BASE(const wxChar *) wxUserResourceStr = wxT("TEXT"); |
| 122 | |
| 123 | // ============================================================================ |
| 124 | // implementation |
| 125 | // ============================================================================ |
| 126 | |
| 127 | // ---------------------------------------------------------------------------- |
| 128 | // get host name and related |
| 129 | // ---------------------------------------------------------------------------- |
| 130 | |
| 131 | // Get hostname only (without domain name) |
| 132 | bool wxGetHostName(wxChar *buf, int maxSize) |
| 133 | { |
| 134 | #if defined(__WXWINCE__) |
| 135 | // GetComputerName() is not supported but the name seems to be stored in |
| 136 | // this location in the registry, at least for PPC2003 and WM5 |
| 137 | wxString hostName; |
| 138 | wxRegKey regKey(wxRegKey::HKLM, wxT("Ident")); |
| 139 | if ( !regKey.HasValue(wxT("Name")) || |
| 140 | !regKey.QueryValue(wxT("Name"), hostName) ) |
| 141 | return false; |
| 142 | |
| 143 | wxStrlcpy(buf, hostName.t_str(), maxSize); |
| 144 | #else // !__WXWINCE__ |
| 145 | DWORD nSize = maxSize; |
| 146 | if ( !::GetComputerName(buf, &nSize) ) |
| 147 | { |
| 148 | wxLogLastError(wxT("GetComputerName")); |
| 149 | |
| 150 | return false; |
| 151 | } |
| 152 | #endif // __WXWINCE__/!__WXWINCE__ |
| 153 | |
| 154 | return true; |
| 155 | } |
| 156 | |
| 157 | // get full hostname (with domain name if possible) |
| 158 | bool wxGetFullHostName(wxChar *buf, int maxSize) |
| 159 | { |
| 160 | #if !defined( __WXMICROWIN__) && wxUSE_DYNLIB_CLASS && wxUSE_SOCKETS |
| 161 | // TODO should use GetComputerNameEx() when available |
| 162 | |
| 163 | // we don't want to always link with Winsock DLL as we might not use it at |
| 164 | // all, so load it dynamically here if needed (and don't complain if it is |
| 165 | // missing, we handle this) |
| 166 | wxLogNull noLog; |
| 167 | |
| 168 | wxDynamicLibrary dllWinsock(wxT("ws2_32.dll"), wxDL_VERBATIM); |
| 169 | if ( dllWinsock.IsLoaded() ) |
| 170 | { |
| 171 | typedef int (PASCAL *WSAStartup_t)(WORD, WSADATA *); |
| 172 | typedef int (PASCAL *gethostname_t)(char *, int); |
| 173 | typedef hostent* (PASCAL *gethostbyname_t)(const char *); |
| 174 | typedef hostent* (PASCAL *gethostbyaddr_t)(const char *, int , int); |
| 175 | typedef int (PASCAL *WSACleanup_t)(void); |
| 176 | |
| 177 | #define LOAD_WINSOCK_FUNC(func) \ |
| 178 | func ## _t \ |
| 179 | pfn ## func = (func ## _t)dllWinsock.GetSymbol(wxT(#func)) |
| 180 | |
| 181 | LOAD_WINSOCK_FUNC(WSAStartup); |
| 182 | |
| 183 | WSADATA wsa; |
| 184 | if ( pfnWSAStartup && pfnWSAStartup(MAKEWORD(1, 1), &wsa) == 0 ) |
| 185 | { |
| 186 | LOAD_WINSOCK_FUNC(gethostname); |
| 187 | |
| 188 | wxString host; |
| 189 | if ( pfngethostname ) |
| 190 | { |
| 191 | char bufA[256]; |
| 192 | if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 ) |
| 193 | { |
| 194 | // gethostname() won't usually include the DNS domain name, |
| 195 | // for this we need to work a bit more |
| 196 | if ( !strchr(bufA, '.') ) |
| 197 | { |
| 198 | LOAD_WINSOCK_FUNC(gethostbyname); |
| 199 | |
| 200 | struct hostent *pHostEnt = pfngethostbyname |
| 201 | ? pfngethostbyname(bufA) |
| 202 | : NULL; |
| 203 | |
| 204 | if ( pHostEnt ) |
| 205 | { |
| 206 | // Windows will use DNS internally now |
| 207 | LOAD_WINSOCK_FUNC(gethostbyaddr); |
| 208 | |
| 209 | pHostEnt = pfngethostbyaddr |
| 210 | ? pfngethostbyaddr(pHostEnt->h_addr, |
| 211 | 4, AF_INET) |
| 212 | : NULL; |
| 213 | } |
| 214 | |
| 215 | if ( pHostEnt ) |
| 216 | { |
| 217 | host = wxString::FromAscii(pHostEnt->h_name); |
| 218 | } |
| 219 | } |
| 220 | } |
| 221 | } |
| 222 | |
| 223 | LOAD_WINSOCK_FUNC(WSACleanup); |
| 224 | if ( pfnWSACleanup ) |
| 225 | pfnWSACleanup(); |
| 226 | |
| 227 | |
| 228 | if ( !host.empty() ) |
| 229 | { |
| 230 | wxStrlcpy(buf, host.c_str(), maxSize); |
| 231 | |
| 232 | return true; |
| 233 | } |
| 234 | } |
| 235 | } |
| 236 | #endif // !__WXMICROWIN__ |
| 237 | |
| 238 | return wxGetHostName(buf, maxSize); |
| 239 | } |
| 240 | |
| 241 | // Get user ID e.g. jacs |
| 242 | bool wxGetUserId(wxChar *WXUNUSED_IN_WINCE(buf), |
| 243 | int WXUNUSED_IN_WINCE(maxSize)) |
| 244 | { |
| 245 | #if defined(__WXWINCE__) |
| 246 | // TODO-CE |
| 247 | return false; |
| 248 | #else |
| 249 | DWORD nSize = maxSize; |
| 250 | if ( ::GetUserName(buf, &nSize) == 0 ) |
| 251 | { |
| 252 | // actually, it does happen on Win9x if the user didn't log on |
| 253 | DWORD res = ::GetEnvironmentVariable(wxT("username"), buf, maxSize); |
| 254 | if ( res == 0 ) |
| 255 | { |
| 256 | // not found |
| 257 | return false; |
| 258 | } |
| 259 | } |
| 260 | |
| 261 | return true; |
| 262 | #endif |
| 263 | } |
| 264 | |
| 265 | // Get user name e.g. Julian Smart |
| 266 | bool wxGetUserName(wxChar *buf, int maxSize) |
| 267 | { |
| 268 | wxCHECK_MSG( buf && ( maxSize > 0 ), false, |
| 269 | wxT("empty buffer in wxGetUserName") ); |
| 270 | #if defined(__WXWINCE__) && wxUSE_REGKEY |
| 271 | wxLogNull noLog; |
| 272 | wxRegKey key(wxRegKey::HKCU, wxT("ControlPanel\\Owner")); |
| 273 | if(!key.Open(wxRegKey::Read)) |
| 274 | return false; |
| 275 | wxString name; |
| 276 | if(!key.QueryValue(wxT("Owner"),name)) |
| 277 | return false; |
| 278 | wxStrlcpy(buf, name.c_str(), maxSize); |
| 279 | return true; |
| 280 | #elif defined(USE_NET_API) |
| 281 | CHAR szUserName[256]; |
| 282 | if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) ) |
| 283 | return false; |
| 284 | |
| 285 | // TODO how to get the domain name? |
| 286 | CHAR *szDomain = ""; |
| 287 | |
| 288 | // the code is based on the MSDN example (also see KB article Q119670) |
| 289 | WCHAR wszUserName[256]; // Unicode user name |
| 290 | WCHAR wszDomain[256]; |
| 291 | LPBYTE ComputerName; |
| 292 | |
| 293 | USER_INFO_2 *ui2; // User structure |
| 294 | |
| 295 | // Convert ANSI user name and domain to Unicode |
| 296 | MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1, |
| 297 | wszUserName, WXSIZEOF(wszUserName) ); |
| 298 | MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1, |
| 299 | wszDomain, WXSIZEOF(wszDomain) ); |
| 300 | |
| 301 | // Get the computer name of a DC for the domain. |
| 302 | if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success ) |
| 303 | { |
| 304 | wxLogError(wxT("Cannot find domain controller")); |
| 305 | |
| 306 | goto error; |
| 307 | } |
| 308 | |
| 309 | // Look up the user on the DC |
| 310 | NET_API_STATUS status = NetUserGetInfo( (LPWSTR)ComputerName, |
| 311 | (LPWSTR)&wszUserName, |
| 312 | 2, // level - we want USER_INFO_2 |
| 313 | (LPBYTE *) &ui2 ); |
| 314 | switch ( status ) |
| 315 | { |
| 316 | case NERR_Success: |
| 317 | // ok |
| 318 | break; |
| 319 | |
| 320 | case NERR_InvalidComputer: |
| 321 | wxLogError(wxT("Invalid domain controller name.")); |
| 322 | |
| 323 | goto error; |
| 324 | |
| 325 | case NERR_UserNotFound: |
| 326 | wxLogError(wxT("Invalid user name '%s'."), szUserName); |
| 327 | |
| 328 | goto error; |
| 329 | |
| 330 | default: |
| 331 | wxLogSysError(wxT("Can't get information about user")); |
| 332 | |
| 333 | goto error; |
| 334 | } |
| 335 | |
| 336 | // Convert the Unicode full name to ANSI |
| 337 | WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1, |
| 338 | buf, maxSize, NULL, NULL ); |
| 339 | |
| 340 | return true; |
| 341 | |
| 342 | error: |
| 343 | wxLogError(wxT("Couldn't look up full user name.")); |
| 344 | |
| 345 | return false; |
| 346 | #else // !USE_NET_API |
| 347 | // Could use NIS, MS-Mail or other site specific programs |
| 348 | // Use wxWidgets configuration data |
| 349 | bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0; |
| 350 | if ( !ok ) |
| 351 | { |
| 352 | ok = wxGetUserId(buf, maxSize); |
| 353 | } |
| 354 | |
| 355 | if ( !ok ) |
| 356 | { |
| 357 | wxStrlcpy(buf, wxT("Unknown User"), maxSize); |
| 358 | } |
| 359 | |
| 360 | return true; |
| 361 | #endif // Win32/16 |
| 362 | } |
| 363 | |
| 364 | const wxChar* wxGetHomeDir(wxString *pstr) |
| 365 | { |
| 366 | wxString& strDir = *pstr; |
| 367 | |
| 368 | // first branch is for Cygwin |
| 369 | #if defined(__UNIX__) && !defined(__WINE__) |
| 370 | const wxChar *szHome = wxGetenv(wxT("HOME")); |
| 371 | if ( szHome == NULL ) { |
| 372 | // we're homeless... |
| 373 | wxLogWarning(_("can't find user's HOME, using current directory.")); |
| 374 | strDir = wxT("."); |
| 375 | } |
| 376 | else |
| 377 | strDir = szHome; |
| 378 | |
| 379 | // add a trailing slash if needed |
| 380 | if ( strDir.Last() != wxT('/') ) |
| 381 | strDir << wxT('/'); |
| 382 | |
| 383 | #ifdef __CYGWIN__ |
| 384 | // Cygwin returns unix type path but that does not work well |
| 385 | static wxChar windowsPath[MAX_PATH]; |
| 386 | #if CYGWIN_VERSION_DLL_MAJOR >= 1007 |
| 387 | cygwin_conv_path(CCP_POSIX_TO_WIN_W, strDir, windowsPath, MAX_PATH); |
| 388 | #else |
| 389 | cygwin_conv_to_full_win32_path(strDir, windowsPath); |
| 390 | #endif |
| 391 | strDir = windowsPath; |
| 392 | #endif |
| 393 | #elif defined(__WXWINCE__) |
| 394 | strDir = wxT("\\"); |
| 395 | #else |
| 396 | strDir.clear(); |
| 397 | |
| 398 | // If we have a valid HOME directory, as is used on many machines that |
| 399 | // have unix utilities on them, we should use that. |
| 400 | const wxChar *szHome = wxGetenv(wxT("HOME")); |
| 401 | |
| 402 | if ( szHome != NULL ) |
| 403 | { |
| 404 | strDir = szHome; |
| 405 | } |
| 406 | else // no HOME, try HOMEDRIVE/PATH |
| 407 | { |
| 408 | szHome = wxGetenv(wxT("HOMEDRIVE")); |
| 409 | if ( szHome != NULL ) |
| 410 | strDir << szHome; |
| 411 | szHome = wxGetenv(wxT("HOMEPATH")); |
| 412 | |
| 413 | if ( szHome != NULL ) |
| 414 | { |
| 415 | strDir << szHome; |
| 416 | |
| 417 | // the idea is that under NT these variables have default values |
| 418 | // of "%systemdrive%:" and "\\". As we don't want to create our |
| 419 | // config files in the root directory of the system drive, we will |
| 420 | // create it in our program's dir. However, if the user took care |
| 421 | // to set HOMEPATH to something other than "\\", we suppose that he |
| 422 | // knows what he is doing and use the supplied value. |
| 423 | if ( wxStrcmp(szHome, wxT("\\")) == 0 ) |
| 424 | strDir.clear(); |
| 425 | } |
| 426 | } |
| 427 | |
| 428 | if ( strDir.empty() ) |
| 429 | { |
| 430 | // If we have a valid USERPROFILE directory, as is the case in |
| 431 | // Windows NT, 2000 and XP, we should use that as our home directory. |
| 432 | szHome = wxGetenv(wxT("USERPROFILE")); |
| 433 | |
| 434 | if ( szHome != NULL ) |
| 435 | strDir = szHome; |
| 436 | } |
| 437 | |
| 438 | if ( !strDir.empty() ) |
| 439 | { |
| 440 | // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the |
| 441 | // value once again, it shouldn't hurt anyhow |
| 442 | strDir = wxExpandEnvVars(strDir); |
| 443 | } |
| 444 | else // fall back to the program directory |
| 445 | { |
| 446 | // extract the directory component of the program file name |
| 447 | wxFileName::SplitPath(wxGetFullModuleName(), &strDir, NULL, NULL); |
| 448 | } |
| 449 | #endif // UNIX/Win |
| 450 | |
| 451 | return strDir.c_str(); |
| 452 | } |
| 453 | |
| 454 | wxString wxGetUserHome(const wxString& user) |
| 455 | { |
| 456 | wxString home; |
| 457 | |
| 458 | if ( user.empty() || user == wxGetUserId() ) |
| 459 | wxGetHomeDir(&home); |
| 460 | |
| 461 | return home; |
| 462 | } |
| 463 | |
| 464 | bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path), |
| 465 | wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal), |
| 466 | wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree)) |
| 467 | { |
| 468 | #ifdef __WXWINCE__ |
| 469 | // TODO-CE |
| 470 | return false; |
| 471 | #else |
| 472 | if ( path.empty() ) |
| 473 | return false; |
| 474 | |
| 475 | // old w32api don't have ULARGE_INTEGER |
| 476 | #if defined(__WIN32__) && \ |
| 477 | (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 )) |
| 478 | // GetDiskFreeSpaceEx() is not available under original Win95, check for |
| 479 | // it |
| 480 | typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR, |
| 481 | PULARGE_INTEGER, |
| 482 | PULARGE_INTEGER, |
| 483 | PULARGE_INTEGER); |
| 484 | |
| 485 | GetDiskFreeSpaceEx_t |
| 486 | pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress |
| 487 | ( |
| 488 | ::GetModuleHandle(wxT("kernel32.dll")), |
| 489 | #if wxUSE_UNICODE |
| 490 | "GetDiskFreeSpaceExW" |
| 491 | #else |
| 492 | "GetDiskFreeSpaceExA" |
| 493 | #endif |
| 494 | ); |
| 495 | |
| 496 | if ( pGetDiskFreeSpaceEx ) |
| 497 | { |
| 498 | ULARGE_INTEGER bytesFree, bytesTotal; |
| 499 | |
| 500 | // may pass the path as is, GetDiskFreeSpaceEx() is smart enough |
| 501 | if ( !pGetDiskFreeSpaceEx(path.t_str(), |
| 502 | &bytesFree, |
| 503 | &bytesTotal, |
| 504 | NULL) ) |
| 505 | { |
| 506 | wxLogLastError(wxT("GetDiskFreeSpaceEx")); |
| 507 | |
| 508 | return false; |
| 509 | } |
| 510 | |
| 511 | // ULARGE_INTEGER is a union of a 64 bit value and a struct containing |
| 512 | // two 32 bit fields which may be or may be not named - try to make it |
| 513 | // compile in all cases |
| 514 | #if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT) |
| 515 | #define UL(ul) ul.u |
| 516 | #else // anon union |
| 517 | #define UL(ul) ul |
| 518 | #endif |
| 519 | if ( pTotal ) |
| 520 | { |
| 521 | #if wxUSE_LONGLONG |
| 522 | *pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart); |
| 523 | #else |
| 524 | *pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart); |
| 525 | #endif |
| 526 | } |
| 527 | |
| 528 | if ( pFree ) |
| 529 | { |
| 530 | #if wxUSE_LONGLONG |
| 531 | *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart); |
| 532 | #else |
| 533 | *pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart); |
| 534 | #endif |
| 535 | } |
| 536 | } |
| 537 | else |
| 538 | #endif // Win32 |
| 539 | { |
| 540 | // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx() |
| 541 | // should be used instead - but if it's not available, fall back on |
| 542 | // GetDiskFreeSpace() nevertheless... |
| 543 | |
| 544 | DWORD lSectorsPerCluster, |
| 545 | lBytesPerSector, |
| 546 | lNumberOfFreeClusters, |
| 547 | lTotalNumberOfClusters; |
| 548 | |
| 549 | // FIXME: this is wrong, we should extract the root drive from path |
| 550 | // instead, but this is the job for wxFileName... |
| 551 | if ( !::GetDiskFreeSpace(path.t_str(), |
| 552 | &lSectorsPerCluster, |
| 553 | &lBytesPerSector, |
| 554 | &lNumberOfFreeClusters, |
| 555 | &lTotalNumberOfClusters) ) |
| 556 | { |
| 557 | wxLogLastError(wxT("GetDiskFreeSpace")); |
| 558 | |
| 559 | return false; |
| 560 | } |
| 561 | |
| 562 | wxDiskspaceSize_t lBytesPerCluster = (wxDiskspaceSize_t) lSectorsPerCluster; |
| 563 | lBytesPerCluster *= lBytesPerSector; |
| 564 | |
| 565 | if ( pTotal ) |
| 566 | { |
| 567 | *pTotal = lBytesPerCluster; |
| 568 | *pTotal *= lTotalNumberOfClusters; |
| 569 | } |
| 570 | |
| 571 | if ( pFree ) |
| 572 | { |
| 573 | *pFree = lBytesPerCluster; |
| 574 | *pFree *= lNumberOfFreeClusters; |
| 575 | } |
| 576 | } |
| 577 | |
| 578 | return true; |
| 579 | #endif |
| 580 | // __WXWINCE__ |
| 581 | } |
| 582 | |
| 583 | // ---------------------------------------------------------------------------- |
| 584 | // env vars |
| 585 | // ---------------------------------------------------------------------------- |
| 586 | |
| 587 | bool wxGetEnv(const wxString& WXUNUSED_IN_WINCE(var), |
| 588 | wxString *WXUNUSED_IN_WINCE(value)) |
| 589 | { |
| 590 | #ifdef __WXWINCE__ |
| 591 | // no environment variables under CE |
| 592 | return false; |
| 593 | #else // Win32 |
| 594 | // first get the size of the buffer |
| 595 | DWORD dwRet = ::GetEnvironmentVariable(var.t_str(), NULL, 0); |
| 596 | if ( !dwRet ) |
| 597 | { |
| 598 | // this means that there is no such variable |
| 599 | return false; |
| 600 | } |
| 601 | |
| 602 | if ( value ) |
| 603 | { |
| 604 | (void)::GetEnvironmentVariable(var.t_str(), |
| 605 | wxStringBuffer(*value, dwRet), |
| 606 | dwRet); |
| 607 | } |
| 608 | |
| 609 | return true; |
| 610 | #endif // WinCE/32 |
| 611 | } |
| 612 | |
| 613 | bool wxDoSetEnv(const wxString& var, const wxChar *value) |
| 614 | { |
| 615 | #ifdef __WXWINCE__ |
| 616 | // no environment variables under CE |
| 617 | wxUnusedVar(var); |
| 618 | wxUnusedVar(value); |
| 619 | return false; |
| 620 | #else // !__WXWINCE__ |
| 621 | // update the CRT environment if possible as people expect getenv() to also |
| 622 | // work and it is not affected by Win32 SetEnvironmentVariable() call (OTOH |
| 623 | // the CRT does use Win32 call to update the process environment block so |
| 624 | // there is no need to call it) |
| 625 | // |
| 626 | // TODO: add checks for the other compilers (and update wxSetEnv() |
| 627 | // documentation in interface/wx/utils.h accordingly) |
| 628 | #if defined(__VISUALC__) || defined(__MINGW32__) |
| 629 | // notice that Microsoft _putenv() has different semantics from POSIX |
| 630 | // function with almost the same name: in particular it makes a copy of the |
| 631 | // string instead of using it as part of environment so we can safely call |
| 632 | // it here without going through all the troubles with wxSetEnvModule as in |
| 633 | // src/unix/utilsunx.cpp |
| 634 | wxString envstr = var; |
| 635 | envstr += '='; |
| 636 | if ( value ) |
| 637 | envstr += value; |
| 638 | if ( _tputenv(envstr.t_str()) != 0 ) |
| 639 | return false; |
| 640 | #else // other compiler |
| 641 | if ( !::SetEnvironmentVariable(var.t_str(), value) ) |
| 642 | { |
| 643 | wxLogLastError(wxT("SetEnvironmentVariable")); |
| 644 | |
| 645 | return false; |
| 646 | } |
| 647 | #endif // compiler |
| 648 | |
| 649 | return true; |
| 650 | #endif // __WXWINCE__/!__WXWINCE__ |
| 651 | } |
| 652 | |
| 653 | bool wxSetEnv(const wxString& variable, const wxString& value) |
| 654 | { |
| 655 | return wxDoSetEnv(variable, value.t_str()); |
| 656 | } |
| 657 | |
| 658 | bool wxUnsetEnv(const wxString& variable) |
| 659 | { |
| 660 | return wxDoSetEnv(variable, NULL); |
| 661 | } |
| 662 | |
| 663 | // ---------------------------------------------------------------------------- |
| 664 | // process management |
| 665 | // ---------------------------------------------------------------------------- |
| 666 | |
| 667 | // structure used to pass parameters from wxKill() to wxEnumFindByPidProc() |
| 668 | struct wxFindByPidParams |
| 669 | { |
| 670 | wxFindByPidParams() { hwnd = 0; pid = 0; } |
| 671 | |
| 672 | // the HWND used to return the result |
| 673 | HWND hwnd; |
| 674 | |
| 675 | // the PID we're looking from |
| 676 | DWORD pid; |
| 677 | |
| 678 | wxDECLARE_NO_COPY_CLASS(wxFindByPidParams); |
| 679 | }; |
| 680 | |
| 681 | // wxKill helper: EnumWindows() callback which is used to find the first (top |
| 682 | // level) window belonging to the given process |
| 683 | BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam) |
| 684 | { |
| 685 | DWORD pid; |
| 686 | (void)::GetWindowThreadProcessId(hwnd, &pid); |
| 687 | |
| 688 | wxFindByPidParams *params = (wxFindByPidParams *)lParam; |
| 689 | if ( pid == params->pid ) |
| 690 | { |
| 691 | // remember the window we found |
| 692 | params->hwnd = hwnd; |
| 693 | |
| 694 | // return FALSE to stop the enumeration |
| 695 | return FALSE; |
| 696 | } |
| 697 | |
| 698 | // continue enumeration |
| 699 | return TRUE; |
| 700 | } |
| 701 | |
| 702 | int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc); |
| 703 | |
| 704 | int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags) |
| 705 | { |
| 706 | if (flags & wxKILL_CHILDREN) |
| 707 | wxKillAllChildren(pid, sig, krc); |
| 708 | |
| 709 | // get the process handle to operate on |
| 710 | DWORD dwAccess = PROCESS_QUERY_INFORMATION | SYNCHRONIZE; |
| 711 | if ( sig == wxSIGKILL ) |
| 712 | dwAccess |= PROCESS_TERMINATE; |
| 713 | |
| 714 | HANDLE hProcess = ::OpenProcess(dwAccess, FALSE, (DWORD)pid); |
| 715 | if ( hProcess == NULL ) |
| 716 | { |
| 717 | if ( krc ) |
| 718 | { |
| 719 | // recognize wxKILL_ACCESS_DENIED as special because this doesn't |
| 720 | // mean that the process doesn't exist and this is important for |
| 721 | // wxProcess::Exists() |
| 722 | *krc = ::GetLastError() == ERROR_ACCESS_DENIED |
| 723 | ? wxKILL_ACCESS_DENIED |
| 724 | : wxKILL_NO_PROCESS; |
| 725 | } |
| 726 | |
| 727 | return -1; |
| 728 | } |
| 729 | |
| 730 | wxON_BLOCK_EXIT1(::CloseHandle, hProcess); |
| 731 | |
| 732 | // Default timeout for waiting for the process termination after killing |
| 733 | // it. It should be long enough to allow the process to terminate even on a |
| 734 | // busy system but short enough to avoid blocking the main thread for too |
| 735 | // long. |
| 736 | DWORD waitTimeout = 500; // ms |
| 737 | |
| 738 | bool ok = true; |
| 739 | switch ( sig ) |
| 740 | { |
| 741 | case wxSIGKILL: |
| 742 | // kill the process forcefully returning -1 as error code |
| 743 | if ( !::TerminateProcess(hProcess, (UINT)-1) ) |
| 744 | { |
| 745 | wxLogSysError(_("Failed to kill process %d"), pid); |
| 746 | |
| 747 | if ( krc ) |
| 748 | { |
| 749 | // this is not supposed to happen if we could open the |
| 750 | // process |
| 751 | *krc = wxKILL_ERROR; |
| 752 | } |
| 753 | |
| 754 | ok = false; |
| 755 | } |
| 756 | break; |
| 757 | |
| 758 | case wxSIGNONE: |
| 759 | // Opening the process handle may succeed for a process even if it |
| 760 | // doesn't run any more (typically because open handles to it still |
| 761 | // exist elsewhere, possibly in this process itself if we're |
| 762 | // killing a child process) so we still need check if it hasn't |
| 763 | // terminated yet but, unlike when killing it, we don't need to |
| 764 | // wait for any time at all. |
| 765 | waitTimeout = 0; |
| 766 | break; |
| 767 | |
| 768 | default: |
| 769 | // any other signal means "terminate" |
| 770 | { |
| 771 | wxFindByPidParams params; |
| 772 | params.pid = (DWORD)pid; |
| 773 | |
| 774 | // EnumWindows() has nice semantics: it returns 0 if it found |
| 775 | // something or if an error occurred and non zero if it |
| 776 | // enumerated all the window |
| 777 | if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)¶ms) ) |
| 778 | { |
| 779 | // did we find any window? |
| 780 | if ( params.hwnd ) |
| 781 | { |
| 782 | // tell the app to close |
| 783 | // |
| 784 | // NB: this is the harshest way, the app won't have an |
| 785 | // opportunity to save any files, for example, but |
| 786 | // this is probably what we want here. If not we |
| 787 | // can also use SendMesageTimeout(WM_CLOSE) |
| 788 | if ( !::PostMessage(params.hwnd, WM_QUIT, 0, 0) ) |
| 789 | { |
| 790 | wxLogLastError(wxT("PostMessage(WM_QUIT)")); |
| 791 | } |
| 792 | } |
| 793 | else // it was an error then |
| 794 | { |
| 795 | wxLogLastError(wxT("EnumWindows")); |
| 796 | |
| 797 | ok = false; |
| 798 | } |
| 799 | } |
| 800 | else // no windows for this PID |
| 801 | { |
| 802 | if ( krc ) |
| 803 | *krc = wxKILL_ERROR; |
| 804 | |
| 805 | ok = false; |
| 806 | } |
| 807 | } |
| 808 | } |
| 809 | |
| 810 | // the return code |
| 811 | if ( ok ) |
| 812 | { |
| 813 | // as we wait for a short time, we can use just WaitForSingleObject() |
| 814 | // and not MsgWaitForMultipleObjects() |
| 815 | switch ( ::WaitForSingleObject(hProcess, waitTimeout) ) |
| 816 | { |
| 817 | case WAIT_OBJECT_0: |
| 818 | // Process terminated: normally this indicates that we |
| 819 | // successfully killed it but when testing for the process |
| 820 | // existence, this means failure. |
| 821 | if ( sig == wxSIGNONE ) |
| 822 | { |
| 823 | if ( krc ) |
| 824 | *krc = wxKILL_NO_PROCESS; |
| 825 | |
| 826 | ok = false; |
| 827 | } |
| 828 | break; |
| 829 | |
| 830 | default: |
| 831 | wxFAIL_MSG( wxT("unexpected WaitForSingleObject() return") ); |
| 832 | // fall through |
| 833 | |
| 834 | case WAIT_FAILED: |
| 835 | wxLogLastError(wxT("WaitForSingleObject")); |
| 836 | // fall through |
| 837 | |
| 838 | case WAIT_TIMEOUT: |
| 839 | // Process didn't terminate: normally this is a failure but not |
| 840 | // when we're just testing for its existence. |
| 841 | if ( sig != wxSIGNONE ) |
| 842 | { |
| 843 | if ( krc ) |
| 844 | *krc = wxKILL_ERROR; |
| 845 | |
| 846 | ok = false; |
| 847 | } |
| 848 | break; |
| 849 | } |
| 850 | } |
| 851 | |
| 852 | |
| 853 | // the return code is the same as from Unix kill(): 0 if killed |
| 854 | // successfully or -1 on error |
| 855 | if ( !ok ) |
| 856 | return -1; |
| 857 | |
| 858 | if ( krc ) |
| 859 | *krc = wxKILL_OK; |
| 860 | |
| 861 | return 0; |
| 862 | } |
| 863 | |
| 864 | typedef HANDLE (WINAPI *CreateToolhelp32Snapshot_t)(DWORD,DWORD); |
| 865 | typedef BOOL (WINAPI *Process32_t)(HANDLE,LPPROCESSENTRY32); |
| 866 | |
| 867 | CreateToolhelp32Snapshot_t lpfCreateToolhelp32Snapshot; |
| 868 | Process32_t lpfProcess32First, lpfProcess32Next; |
| 869 | |
| 870 | static void InitToolHelp32() |
| 871 | { |
| 872 | static bool s_initToolHelpDone = false; |
| 873 | |
| 874 | if (s_initToolHelpDone) |
| 875 | return; |
| 876 | |
| 877 | s_initToolHelpDone = true; |
| 878 | |
| 879 | lpfCreateToolhelp32Snapshot = NULL; |
| 880 | lpfProcess32First = NULL; |
| 881 | lpfProcess32Next = NULL; |
| 882 | |
| 883 | #if wxUSE_DYNLIB_CLASS |
| 884 | |
| 885 | wxDynamicLibrary dllKernel(wxT("kernel32.dll"), wxDL_VERBATIM); |
| 886 | |
| 887 | // Get procedure addresses. |
| 888 | // We are linking to these functions of Kernel32 |
| 889 | // explicitly, because otherwise a module using |
| 890 | // this code would fail to load under Windows NT, |
| 891 | // which does not have the Toolhelp32 |
| 892 | // functions in the Kernel 32. |
| 893 | lpfCreateToolhelp32Snapshot = |
| 894 | (CreateToolhelp32Snapshot_t)dllKernel.RawGetSymbol(wxT("CreateToolhelp32Snapshot")); |
| 895 | |
| 896 | lpfProcess32First = |
| 897 | (Process32_t)dllKernel.RawGetSymbol(wxT("Process32First")); |
| 898 | |
| 899 | lpfProcess32Next = |
| 900 | (Process32_t)dllKernel.RawGetSymbol(wxT("Process32Next")); |
| 901 | |
| 902 | #endif // wxUSE_DYNLIB_CLASS |
| 903 | } |
| 904 | |
| 905 | // By John Skiff |
| 906 | int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc) |
| 907 | { |
| 908 | InitToolHelp32(); |
| 909 | |
| 910 | if (krc) |
| 911 | *krc = wxKILL_OK; |
| 912 | |
| 913 | // If not implemented for this platform (e.g. NT 4.0), silently ignore |
| 914 | if (!lpfCreateToolhelp32Snapshot || !lpfProcess32First || !lpfProcess32Next) |
| 915 | return 0; |
| 916 | |
| 917 | // Take a snapshot of all processes in the system. |
| 918 | HANDLE hProcessSnap = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); |
| 919 | if (hProcessSnap == INVALID_HANDLE_VALUE) { |
| 920 | if (krc) |
| 921 | *krc = wxKILL_ERROR; |
| 922 | return -1; |
| 923 | } |
| 924 | |
| 925 | //Fill in the size of the structure before using it. |
| 926 | PROCESSENTRY32 pe; |
| 927 | wxZeroMemory(pe); |
| 928 | pe.dwSize = sizeof(PROCESSENTRY32); |
| 929 | |
| 930 | // Walk the snapshot of the processes, and for each process, |
| 931 | // kill it if its parent is pid. |
| 932 | if (!lpfProcess32First(hProcessSnap, &pe)) { |
| 933 | // Can't get first process. |
| 934 | if (krc) |
| 935 | *krc = wxKILL_ERROR; |
| 936 | CloseHandle (hProcessSnap); |
| 937 | return -1; |
| 938 | } |
| 939 | |
| 940 | do { |
| 941 | if (pe.th32ParentProcessID == (DWORD) pid) { |
| 942 | if (wxKill(pe.th32ProcessID, sig, krc)) |
| 943 | return -1; |
| 944 | } |
| 945 | } while (lpfProcess32Next (hProcessSnap, &pe)); |
| 946 | |
| 947 | |
| 948 | return 0; |
| 949 | } |
| 950 | |
| 951 | // Execute a program in an Interactive Shell |
| 952 | bool wxShell(const wxString& command) |
| 953 | { |
| 954 | wxString cmd; |
| 955 | |
| 956 | #ifdef __WXWINCE__ |
| 957 | cmd = command; |
| 958 | #else |
| 959 | wxChar *shell = wxGetenv(wxT("COMSPEC")); |
| 960 | if ( !shell ) |
| 961 | shell = (wxChar*) wxT("\\COMMAND.COM"); |
| 962 | |
| 963 | if ( !command ) |
| 964 | { |
| 965 | // just the shell |
| 966 | cmd = shell; |
| 967 | } |
| 968 | else |
| 969 | { |
| 970 | // pass the command to execute to the command processor |
| 971 | cmd.Printf(wxT("%s /c %s"), shell, command.c_str()); |
| 972 | } |
| 973 | #endif |
| 974 | |
| 975 | return wxExecute(cmd, wxEXEC_SYNC) == 0; |
| 976 | } |
| 977 | |
| 978 | // Shutdown or reboot the PC |
| 979 | bool wxShutdown(int WXUNUSED_IN_WINCE(flags)) |
| 980 | { |
| 981 | #ifdef __WXWINCE__ |
| 982 | // TODO-CE |
| 983 | return false; |
| 984 | #elif defined(__WIN32__) |
| 985 | bool bOK = true; |
| 986 | |
| 987 | if ( wxGetOsVersion(NULL, NULL) == wxOS_WINDOWS_NT ) // if is NT or 2K |
| 988 | { |
| 989 | // Get a token for this process. |
| 990 | HANDLE hToken; |
| 991 | bOK = ::OpenProcessToken(GetCurrentProcess(), |
| 992 | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, |
| 993 | &hToken) != 0; |
| 994 | if ( bOK ) |
| 995 | { |
| 996 | TOKEN_PRIVILEGES tkp; |
| 997 | |
| 998 | // Get the LUID for the shutdown privilege. |
| 999 | bOK = ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, |
| 1000 | &tkp.Privileges[0].Luid) != 0; |
| 1001 | |
| 1002 | if ( bOK ) |
| 1003 | { |
| 1004 | tkp.PrivilegeCount = 1; // one privilege to set |
| 1005 | tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; |
| 1006 | |
| 1007 | // Get the shutdown privilege for this process. |
| 1008 | ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, |
| 1009 | (PTOKEN_PRIVILEGES)NULL, 0); |
| 1010 | |
| 1011 | // Cannot test the return value of AdjustTokenPrivileges. |
| 1012 | bOK = ::GetLastError() == ERROR_SUCCESS; |
| 1013 | } |
| 1014 | |
| 1015 | ::CloseHandle(hToken); |
| 1016 | } |
| 1017 | } |
| 1018 | |
| 1019 | if ( bOK ) |
| 1020 | { |
| 1021 | UINT wFlags = 0; |
| 1022 | if ( flags & wxSHUTDOWN_FORCE ) |
| 1023 | { |
| 1024 | wFlags = EWX_FORCE; |
| 1025 | flags &= ~wxSHUTDOWN_FORCE; |
| 1026 | } |
| 1027 | |
| 1028 | switch ( flags ) |
| 1029 | { |
| 1030 | case wxSHUTDOWN_POWEROFF: |
| 1031 | wFlags |= EWX_POWEROFF; |
| 1032 | break; |
| 1033 | |
| 1034 | case wxSHUTDOWN_REBOOT: |
| 1035 | wFlags |= EWX_REBOOT; |
| 1036 | break; |
| 1037 | |
| 1038 | case wxSHUTDOWN_LOGOFF: |
| 1039 | wFlags |= EWX_LOGOFF; |
| 1040 | break; |
| 1041 | |
| 1042 | default: |
| 1043 | wxFAIL_MSG( wxT("unknown wxShutdown() flag") ); |
| 1044 | return false; |
| 1045 | } |
| 1046 | |
| 1047 | bOK = ::ExitWindowsEx(wFlags, 0) != 0; |
| 1048 | } |
| 1049 | |
| 1050 | return bOK; |
| 1051 | #endif // WinCE/!WinCE |
| 1052 | } |
| 1053 | |
| 1054 | // ---------------------------------------------------------------------------- |
| 1055 | // misc |
| 1056 | // ---------------------------------------------------------------------------- |
| 1057 | |
| 1058 | // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX) |
| 1059 | wxMemorySize wxGetFreeMemory() |
| 1060 | { |
| 1061 | #if defined(__WIN64__) |
| 1062 | MEMORYSTATUSEX memStatex; |
| 1063 | memStatex.dwLength = sizeof (memStatex); |
| 1064 | ::GlobalMemoryStatusEx (&memStatex); |
| 1065 | return (wxMemorySize)memStatex.ullAvailPhys; |
| 1066 | #else /* if defined(__WIN32__) */ |
| 1067 | MEMORYSTATUS memStatus; |
| 1068 | memStatus.dwLength = sizeof(MEMORYSTATUS); |
| 1069 | ::GlobalMemoryStatus(&memStatus); |
| 1070 | return (wxMemorySize)memStatus.dwAvailPhys; |
| 1071 | #endif |
| 1072 | } |
| 1073 | |
| 1074 | unsigned long wxGetProcessId() |
| 1075 | { |
| 1076 | return ::GetCurrentProcessId(); |
| 1077 | } |
| 1078 | |
| 1079 | bool wxIsDebuggerRunning() |
| 1080 | { |
| 1081 | #if wxUSE_DYNLIB_CLASS |
| 1082 | // IsDebuggerPresent() is not available under Win95, so load it dynamically |
| 1083 | wxDynamicLibrary dll(wxT("kernel32.dll"), wxDL_VERBATIM); |
| 1084 | |
| 1085 | typedef BOOL (WINAPI *IsDebuggerPresent_t)(); |
| 1086 | if ( !dll.HasSymbol(wxT("IsDebuggerPresent")) ) |
| 1087 | { |
| 1088 | // no way to know, assume no |
| 1089 | return false; |
| 1090 | } |
| 1091 | |
| 1092 | return (*(IsDebuggerPresent_t)dll.GetSymbol(wxT("IsDebuggerPresent")))() != 0; |
| 1093 | #else |
| 1094 | return false; |
| 1095 | #endif |
| 1096 | } |
| 1097 | |
| 1098 | // ---------------------------------------------------------------------------- |
| 1099 | // working with MSW resources |
| 1100 | // ---------------------------------------------------------------------------- |
| 1101 | |
| 1102 | bool |
| 1103 | wxLoadUserResource(const void **outData, |
| 1104 | size_t *outLen, |
| 1105 | const wxString& resourceName, |
| 1106 | const wxChar* resourceType, |
| 1107 | WXHINSTANCE instance) |
| 1108 | { |
| 1109 | wxCHECK_MSG( outData && outLen, false, "output pointers can't be NULL" ); |
| 1110 | |
| 1111 | HRSRC hResource = ::FindResource(instance, |
| 1112 | resourceName.t_str(), |
| 1113 | resourceType); |
| 1114 | if ( !hResource ) |
| 1115 | return false; |
| 1116 | |
| 1117 | HGLOBAL hData = ::LoadResource(instance, hResource); |
| 1118 | if ( !hData ) |
| 1119 | { |
| 1120 | wxLogSysError(_("Failed to load resource \"%s\"."), resourceName); |
| 1121 | return false; |
| 1122 | } |
| 1123 | |
| 1124 | *outData = ::LockResource(hData); |
| 1125 | if ( !*outData ) |
| 1126 | { |
| 1127 | wxLogSysError(_("Failed to lock resource \"%s\"."), resourceName); |
| 1128 | return false; |
| 1129 | } |
| 1130 | |
| 1131 | *outLen = ::SizeofResource(instance, hResource); |
| 1132 | |
| 1133 | // Notice that we do not need to call neither UnlockResource() (which is |
| 1134 | // obsolete in Win32) nor GlobalFree() (resources are freed on process |
| 1135 | // termination only) |
| 1136 | |
| 1137 | return true; |
| 1138 | } |
| 1139 | |
| 1140 | char * |
| 1141 | wxLoadUserResource(const wxString& resourceName, |
| 1142 | const wxChar* resourceType, |
| 1143 | int* pLen, |
| 1144 | WXHINSTANCE instance) |
| 1145 | { |
| 1146 | const void *data; |
| 1147 | size_t len; |
| 1148 | if ( !wxLoadUserResource(&data, &len, resourceName, resourceType, instance) ) |
| 1149 | return NULL; |
| 1150 | |
| 1151 | char *s = new char[len + 1]; |
| 1152 | memcpy(s, data, len); |
| 1153 | s[len] = '\0'; // NUL-terminate in case the resource itself wasn't |
| 1154 | |
| 1155 | if (pLen) |
| 1156 | *pLen = len; |
| 1157 | |
| 1158 | return s; |
| 1159 | } |
| 1160 | |
| 1161 | // ---------------------------------------------------------------------------- |
| 1162 | // OS version |
| 1163 | // ---------------------------------------------------------------------------- |
| 1164 | |
| 1165 | // check if we're running under a server or workstation Windows system: it |
| 1166 | // returns true or false with obvious meaning as well as -1 if the system type |
| 1167 | // couldn't be determined |
| 1168 | // |
| 1169 | // this function is currently private but we may want to expose it later if |
| 1170 | // it's really useful |
| 1171 | namespace |
| 1172 | { |
| 1173 | |
| 1174 | int wxIsWindowsServer() |
| 1175 | { |
| 1176 | #ifdef VER_NT_WORKSTATION |
| 1177 | OSVERSIONINFOEX info; |
| 1178 | wxZeroMemory(info); |
| 1179 | |
| 1180 | info.dwOSVersionInfoSize = sizeof(info); |
| 1181 | if ( ::GetVersionEx(reinterpret_cast<OSVERSIONINFO *>(&info)) ) |
| 1182 | { |
| 1183 | switch ( info.wProductType ) |
| 1184 | { |
| 1185 | case VER_NT_WORKSTATION: |
| 1186 | return false; |
| 1187 | |
| 1188 | case VER_NT_SERVER: |
| 1189 | case VER_NT_DOMAIN_CONTROLLER: |
| 1190 | return true; |
| 1191 | } |
| 1192 | } |
| 1193 | #endif // VER_NT_WORKSTATION |
| 1194 | |
| 1195 | return -1; |
| 1196 | } |
| 1197 | |
| 1198 | } // anonymous namespace |
| 1199 | |
| 1200 | wxString wxGetOsDescription() |
| 1201 | { |
| 1202 | wxString str; |
| 1203 | |
| 1204 | OSVERSIONINFO info; |
| 1205 | wxZeroMemory(info); |
| 1206 | |
| 1207 | info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); |
| 1208 | if ( ::GetVersionEx(&info) ) |
| 1209 | { |
| 1210 | switch ( info.dwPlatformId ) |
| 1211 | { |
| 1212 | #ifdef VER_PLATFORM_WIN32_CE |
| 1213 | case VER_PLATFORM_WIN32_CE: |
| 1214 | str.Printf(_("Windows CE (%d.%d)"), |
| 1215 | info.dwMajorVersion, |
| 1216 | info.dwMinorVersion); |
| 1217 | break; |
| 1218 | #endif |
| 1219 | case VER_PLATFORM_WIN32s: |
| 1220 | str = _("Win32s on Windows 3.1"); |
| 1221 | break; |
| 1222 | |
| 1223 | case VER_PLATFORM_WIN32_WINDOWS: |
| 1224 | switch (info.dwMinorVersion) |
| 1225 | { |
| 1226 | case 0: |
| 1227 | if ( info.szCSDVersion[1] == 'B' || |
| 1228 | info.szCSDVersion[1] == 'C' ) |
| 1229 | { |
| 1230 | str = _("Windows 95 OSR2"); |
| 1231 | } |
| 1232 | else |
| 1233 | { |
| 1234 | str = _("Windows 95"); |
| 1235 | } |
| 1236 | break; |
| 1237 | case 10: |
| 1238 | if ( info.szCSDVersion[1] == 'B' || |
| 1239 | info.szCSDVersion[1] == 'C' ) |
| 1240 | { |
| 1241 | str = _("Windows 98 SE"); |
| 1242 | } |
| 1243 | else |
| 1244 | { |
| 1245 | str = _("Windows 98"); |
| 1246 | } |
| 1247 | break; |
| 1248 | case 90: |
| 1249 | str = _("Windows ME"); |
| 1250 | break; |
| 1251 | default: |
| 1252 | str.Printf(_("Windows 9x (%d.%d)"), |
| 1253 | info.dwMajorVersion, |
| 1254 | info.dwMinorVersion); |
| 1255 | break; |
| 1256 | } |
| 1257 | if ( !wxIsEmpty(info.szCSDVersion) ) |
| 1258 | { |
| 1259 | str << wxT(" (") << info.szCSDVersion << wxT(')'); |
| 1260 | } |
| 1261 | break; |
| 1262 | |
| 1263 | case VER_PLATFORM_WIN32_NT: |
| 1264 | switch ( info.dwMajorVersion ) |
| 1265 | { |
| 1266 | case 5: |
| 1267 | switch ( info.dwMinorVersion ) |
| 1268 | { |
| 1269 | case 0: |
| 1270 | str = _("Windows 2000"); |
| 1271 | break; |
| 1272 | |
| 1273 | case 2: |
| 1274 | // we can't distinguish between XP 64 and 2003 |
| 1275 | // as they both are 5.2, so examine the product |
| 1276 | // type to resolve this ambiguity |
| 1277 | if ( wxIsWindowsServer() == 1 ) |
| 1278 | { |
| 1279 | str = _("Windows Server 2003"); |
| 1280 | break; |
| 1281 | } |
| 1282 | //else: must be XP, fall through |
| 1283 | |
| 1284 | case 1: |
| 1285 | str = _("Windows XP"); |
| 1286 | break; |
| 1287 | } |
| 1288 | break; |
| 1289 | |
| 1290 | case 6: |
| 1291 | switch ( info.dwMinorVersion ) |
| 1292 | { |
| 1293 | case 0: |
| 1294 | str = wxIsWindowsServer() == 1 |
| 1295 | ? _("Windows Server 2008") |
| 1296 | : _("Windows Vista"); |
| 1297 | break; |
| 1298 | |
| 1299 | case 1: |
| 1300 | str = wxIsWindowsServer() == 1 |
| 1301 | ? _("Windows Server 2008 R2") |
| 1302 | : _("Windows 7"); |
| 1303 | break; |
| 1304 | } |
| 1305 | break; |
| 1306 | } |
| 1307 | |
| 1308 | if ( str.empty() ) |
| 1309 | { |
| 1310 | str.Printf(_("Windows NT %lu.%lu"), |
| 1311 | info.dwMajorVersion, |
| 1312 | info.dwMinorVersion); |
| 1313 | } |
| 1314 | |
| 1315 | str << wxT(" (") |
| 1316 | << wxString::Format(_("build %lu"), info.dwBuildNumber); |
| 1317 | if ( !wxIsEmpty(info.szCSDVersion) ) |
| 1318 | { |
| 1319 | str << wxT(", ") << info.szCSDVersion; |
| 1320 | } |
| 1321 | str << wxT(')'); |
| 1322 | |
| 1323 | if ( wxIsPlatform64Bit() ) |
| 1324 | str << _(", 64-bit edition"); |
| 1325 | break; |
| 1326 | } |
| 1327 | } |
| 1328 | else |
| 1329 | { |
| 1330 | wxFAIL_MSG( wxT("GetVersionEx() failed") ); // should never happen |
| 1331 | } |
| 1332 | |
| 1333 | return str; |
| 1334 | } |
| 1335 | |
| 1336 | bool wxIsPlatform64Bit() |
| 1337 | { |
| 1338 | #if defined(_WIN64) |
| 1339 | return true; // 64-bit programs run only on Win64 |
| 1340 | #elif wxUSE_DYNLIB_CLASS // Win32 |
| 1341 | // 32-bit programs run on both 32-bit and 64-bit Windows so check |
| 1342 | typedef BOOL (WINAPI *IsWow64Process_t)(HANDLE, BOOL *); |
| 1343 | |
| 1344 | wxDynamicLibrary dllKernel32(wxT("kernel32.dll")); |
| 1345 | IsWow64Process_t pfnIsWow64Process = |
| 1346 | (IsWow64Process_t)dllKernel32.RawGetSymbol(wxT("IsWow64Process")); |
| 1347 | |
| 1348 | BOOL wow64 = FALSE; |
| 1349 | if ( pfnIsWow64Process ) |
| 1350 | { |
| 1351 | pfnIsWow64Process(::GetCurrentProcess(), &wow64); |
| 1352 | } |
| 1353 | //else: running under a system without Win64 support |
| 1354 | |
| 1355 | return wow64 != FALSE; |
| 1356 | #else |
| 1357 | return false; |
| 1358 | #endif // Win64/Win32 |
| 1359 | } |
| 1360 | |
| 1361 | wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin) |
| 1362 | { |
| 1363 | static struct |
| 1364 | { |
| 1365 | // this may be false, true or -1 if we tried to initialize but failed |
| 1366 | int initialized; |
| 1367 | |
| 1368 | wxOperatingSystemId os; |
| 1369 | |
| 1370 | int verMaj, |
| 1371 | verMin; |
| 1372 | } s_version; |
| 1373 | |
| 1374 | // query the OS info only once as it's not supposed to change |
| 1375 | if ( !s_version.initialized ) |
| 1376 | { |
| 1377 | OSVERSIONINFO info; |
| 1378 | wxZeroMemory(info); |
| 1379 | info.dwOSVersionInfoSize = sizeof(info); |
| 1380 | if ( ::GetVersionEx(&info) ) |
| 1381 | { |
| 1382 | s_version.initialized = true; |
| 1383 | |
| 1384 | #if defined(__WXWINCE__) |
| 1385 | s_version.os = wxOS_WINDOWS_CE; |
| 1386 | #elif defined(__WXMICROWIN__) |
| 1387 | s_version.os = wxOS_WINDOWS_MICRO; |
| 1388 | #else // "normal" desktop Windows system, use run-time detection |
| 1389 | switch ( info.dwPlatformId ) |
| 1390 | { |
| 1391 | case VER_PLATFORM_WIN32_NT: |
| 1392 | s_version.os = wxOS_WINDOWS_NT; |
| 1393 | break; |
| 1394 | |
| 1395 | case VER_PLATFORM_WIN32_WINDOWS: |
| 1396 | s_version.os = wxOS_WINDOWS_9X; |
| 1397 | break; |
| 1398 | } |
| 1399 | #endif // Windows versions |
| 1400 | |
| 1401 | s_version.verMaj = info.dwMajorVersion; |
| 1402 | s_version.verMin = info.dwMinorVersion; |
| 1403 | } |
| 1404 | else // GetVersionEx() failed |
| 1405 | { |
| 1406 | s_version.initialized = -1; |
| 1407 | } |
| 1408 | } |
| 1409 | |
| 1410 | if ( s_version.initialized == 1 ) |
| 1411 | { |
| 1412 | if ( verMaj ) |
| 1413 | *verMaj = s_version.verMaj; |
| 1414 | if ( verMin ) |
| 1415 | *verMin = s_version.verMin; |
| 1416 | } |
| 1417 | |
| 1418 | // this works even if we were not initialized successfully as the initial |
| 1419 | // values of this field is 0 which is wxOS_UNKNOWN and exactly what we need |
| 1420 | return s_version.os; |
| 1421 | } |
| 1422 | |
| 1423 | wxWinVersion wxGetWinVersion() |
| 1424 | { |
| 1425 | int verMaj, |
| 1426 | verMin; |
| 1427 | switch ( wxGetOsVersion(&verMaj, &verMin) ) |
| 1428 | { |
| 1429 | case wxOS_WINDOWS_9X: |
| 1430 | if ( verMaj == 4 ) |
| 1431 | { |
| 1432 | switch ( verMin ) |
| 1433 | { |
| 1434 | case 0: |
| 1435 | return wxWinVersion_95; |
| 1436 | |
| 1437 | case 10: |
| 1438 | return wxWinVersion_98; |
| 1439 | |
| 1440 | case 90: |
| 1441 | return wxWinVersion_ME; |
| 1442 | } |
| 1443 | } |
| 1444 | break; |
| 1445 | |
| 1446 | case wxOS_WINDOWS_NT: |
| 1447 | switch ( verMaj ) |
| 1448 | { |
| 1449 | case 3: |
| 1450 | return wxWinVersion_NT3; |
| 1451 | |
| 1452 | case 4: |
| 1453 | return wxWinVersion_NT4; |
| 1454 | |
| 1455 | case 5: |
| 1456 | switch ( verMin ) |
| 1457 | { |
| 1458 | case 0: |
| 1459 | return wxWinVersion_2000; |
| 1460 | |
| 1461 | case 1: |
| 1462 | return wxWinVersion_XP; |
| 1463 | |
| 1464 | case 2: |
| 1465 | return wxWinVersion_2003; |
| 1466 | } |
| 1467 | break; |
| 1468 | |
| 1469 | case 6: |
| 1470 | return wxWinVersion_NT6; |
| 1471 | } |
| 1472 | break; |
| 1473 | |
| 1474 | default: |
| 1475 | // Do nothing just to silence GCC warning |
| 1476 | break; |
| 1477 | } |
| 1478 | |
| 1479 | return wxWinVersion_Unknown; |
| 1480 | } |
| 1481 | |
| 1482 | // ---------------------------------------------------------------------------- |
| 1483 | // sleep functions |
| 1484 | // ---------------------------------------------------------------------------- |
| 1485 | |
| 1486 | void wxMilliSleep(unsigned long milliseconds) |
| 1487 | { |
| 1488 | ::Sleep(milliseconds); |
| 1489 | } |
| 1490 | |
| 1491 | void wxMicroSleep(unsigned long microseconds) |
| 1492 | { |
| 1493 | wxMilliSleep(microseconds/1000); |
| 1494 | } |
| 1495 | |
| 1496 | void wxSleep(int nSecs) |
| 1497 | { |
| 1498 | wxMilliSleep(1000*nSecs); |
| 1499 | } |
| 1500 | |
| 1501 | // ---------------------------------------------------------------------------- |
| 1502 | // font encoding <-> Win32 codepage conversion functions |
| 1503 | // ---------------------------------------------------------------------------- |
| 1504 | |
| 1505 | extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding) |
| 1506 | { |
| 1507 | switch ( encoding ) |
| 1508 | { |
| 1509 | // although this function is supposed to return an exact match, do do |
| 1510 | // some mappings here for the most common case of "standard" encoding |
| 1511 | case wxFONTENCODING_SYSTEM: |
| 1512 | return DEFAULT_CHARSET; |
| 1513 | |
| 1514 | case wxFONTENCODING_ISO8859_1: |
| 1515 | case wxFONTENCODING_ISO8859_15: |
| 1516 | case wxFONTENCODING_CP1252: |
| 1517 | return ANSI_CHARSET; |
| 1518 | |
| 1519 | #if !defined(__WXMICROWIN__) |
| 1520 | // The following four fonts are multi-byte charsets |
| 1521 | case wxFONTENCODING_CP932: |
| 1522 | return SHIFTJIS_CHARSET; |
| 1523 | |
| 1524 | case wxFONTENCODING_CP936: |
| 1525 | return GB2312_CHARSET; |
| 1526 | |
| 1527 | #ifndef __WXWINCE__ |
| 1528 | case wxFONTENCODING_CP949: |
| 1529 | return HANGUL_CHARSET; |
| 1530 | #endif |
| 1531 | |
| 1532 | case wxFONTENCODING_CP950: |
| 1533 | return CHINESEBIG5_CHARSET; |
| 1534 | |
| 1535 | // The rest are single byte encodings |
| 1536 | case wxFONTENCODING_CP1250: |
| 1537 | return EASTEUROPE_CHARSET; |
| 1538 | |
| 1539 | case wxFONTENCODING_CP1251: |
| 1540 | return RUSSIAN_CHARSET; |
| 1541 | |
| 1542 | case wxFONTENCODING_CP1253: |
| 1543 | return GREEK_CHARSET; |
| 1544 | |
| 1545 | case wxFONTENCODING_CP1254: |
| 1546 | return TURKISH_CHARSET; |
| 1547 | |
| 1548 | case wxFONTENCODING_CP1255: |
| 1549 | return HEBREW_CHARSET; |
| 1550 | |
| 1551 | case wxFONTENCODING_CP1256: |
| 1552 | return ARABIC_CHARSET; |
| 1553 | |
| 1554 | case wxFONTENCODING_CP1257: |
| 1555 | return BALTIC_CHARSET; |
| 1556 | |
| 1557 | case wxFONTENCODING_CP874: |
| 1558 | return THAI_CHARSET; |
| 1559 | #endif // !__WXMICROWIN__ |
| 1560 | |
| 1561 | case wxFONTENCODING_CP437: |
| 1562 | return OEM_CHARSET; |
| 1563 | |
| 1564 | default: |
| 1565 | // no way to translate this encoding into a Windows charset |
| 1566 | return -1; |
| 1567 | } |
| 1568 | } |
| 1569 | |
| 1570 | // we have 2 versions of wxCharsetToCodepage(): the old one which directly |
| 1571 | // looks up the vlaues in the registry and the new one which is more |
| 1572 | // politically correct and has more chances to work on other Windows versions |
| 1573 | // as well but the old version is still needed for !wxUSE_FONTMAP case |
| 1574 | #if wxUSE_FONTMAP |
| 1575 | |
| 1576 | #include "wx/fontmap.h" |
| 1577 | |
| 1578 | extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding) |
| 1579 | { |
| 1580 | // There don't seem to be symbolic names for |
| 1581 | // these under Windows so I just copied the |
| 1582 | // values from MSDN. |
| 1583 | |
| 1584 | unsigned int ret; |
| 1585 | |
| 1586 | switch (encoding) |
| 1587 | { |
| 1588 | case wxFONTENCODING_ISO8859_1: ret = 28591; break; |
| 1589 | case wxFONTENCODING_ISO8859_2: ret = 28592; break; |
| 1590 | case wxFONTENCODING_ISO8859_3: ret = 28593; break; |
| 1591 | case wxFONTENCODING_ISO8859_4: ret = 28594; break; |
| 1592 | case wxFONTENCODING_ISO8859_5: ret = 28595; break; |
| 1593 | case wxFONTENCODING_ISO8859_6: ret = 28596; break; |
| 1594 | case wxFONTENCODING_ISO8859_7: ret = 28597; break; |
| 1595 | case wxFONTENCODING_ISO8859_8: ret = 28598; break; |
| 1596 | case wxFONTENCODING_ISO8859_9: ret = 28599; break; |
| 1597 | case wxFONTENCODING_ISO8859_10: ret = 28600; break; |
| 1598 | case wxFONTENCODING_ISO8859_11: ret = 874; break; |
| 1599 | // case wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it |
| 1600 | case wxFONTENCODING_ISO8859_13: ret = 28603; break; |
| 1601 | // case wxFONTENCODING_ISO8859_14: ret = 28604; break; // no correspondence on Windows |
| 1602 | case wxFONTENCODING_ISO8859_15: ret = 28605; break; |
| 1603 | |
| 1604 | case wxFONTENCODING_KOI8: ret = 20866; break; |
| 1605 | case wxFONTENCODING_KOI8_U: ret = 21866; break; |
| 1606 | |
| 1607 | case wxFONTENCODING_CP437: ret = 437; break; |
| 1608 | case wxFONTENCODING_CP850: ret = 850; break; |
| 1609 | case wxFONTENCODING_CP852: ret = 852; break; |
| 1610 | case wxFONTENCODING_CP855: ret = 855; break; |
| 1611 | case wxFONTENCODING_CP866: ret = 866; break; |
| 1612 | case wxFONTENCODING_CP874: ret = 874; break; |
| 1613 | case wxFONTENCODING_CP932: ret = 932; break; |
| 1614 | case wxFONTENCODING_CP936: ret = 936; break; |
| 1615 | case wxFONTENCODING_CP949: ret = 949; break; |
| 1616 | case wxFONTENCODING_CP950: ret = 950; break; |
| 1617 | case wxFONTENCODING_CP1250: ret = 1250; break; |
| 1618 | case wxFONTENCODING_CP1251: ret = 1251; break; |
| 1619 | case wxFONTENCODING_CP1252: ret = 1252; break; |
| 1620 | case wxFONTENCODING_CP1253: ret = 1253; break; |
| 1621 | case wxFONTENCODING_CP1254: ret = 1254; break; |
| 1622 | case wxFONTENCODING_CP1255: ret = 1255; break; |
| 1623 | case wxFONTENCODING_CP1256: ret = 1256; break; |
| 1624 | case wxFONTENCODING_CP1257: ret = 1257; break; |
| 1625 | |
| 1626 | case wxFONTENCODING_EUC_JP: ret = 20932; break; |
| 1627 | |
| 1628 | case wxFONTENCODING_MACROMAN: ret = 10000; break; |
| 1629 | case wxFONTENCODING_MACJAPANESE: ret = 10001; break; |
| 1630 | case wxFONTENCODING_MACCHINESETRAD: ret = 10002; break; |
| 1631 | case wxFONTENCODING_MACKOREAN: ret = 10003; break; |
| 1632 | case wxFONTENCODING_MACARABIC: ret = 10004; break; |
| 1633 | case wxFONTENCODING_MACHEBREW: ret = 10005; break; |
| 1634 | case wxFONTENCODING_MACGREEK: ret = 10006; break; |
| 1635 | case wxFONTENCODING_MACCYRILLIC: ret = 10007; break; |
| 1636 | case wxFONTENCODING_MACTHAI: ret = 10021; break; |
| 1637 | case wxFONTENCODING_MACCHINESESIMP: ret = 10008; break; |
| 1638 | case wxFONTENCODING_MACCENTRALEUR: ret = 10029; break; |
| 1639 | case wxFONTENCODING_MACCROATIAN: ret = 10082; break; |
| 1640 | case wxFONTENCODING_MACICELANDIC: ret = 10079; break; |
| 1641 | case wxFONTENCODING_MACROMANIAN: ret = 10009; break; |
| 1642 | |
| 1643 | case wxFONTENCODING_ISO2022_JP: ret = 50222; break; |
| 1644 | |
| 1645 | case wxFONTENCODING_UTF7: ret = 65000; break; |
| 1646 | case wxFONTENCODING_UTF8: ret = 65001; break; |
| 1647 | |
| 1648 | default: return -1; |
| 1649 | } |
| 1650 | |
| 1651 | if (::IsValidCodePage(ret) == 0) |
| 1652 | return -1; |
| 1653 | |
| 1654 | CPINFO info; |
| 1655 | if (::GetCPInfo(ret, &info) == 0) |
| 1656 | return -1; |
| 1657 | |
| 1658 | return (long) ret; |
| 1659 | } |
| 1660 | |
| 1661 | extern long wxCharsetToCodepage(const char *name) |
| 1662 | { |
| 1663 | // first get the font encoding for this charset |
| 1664 | if ( !name ) |
| 1665 | return -1; |
| 1666 | |
| 1667 | wxFontEncoding enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false); |
| 1668 | if ( enc == wxFONTENCODING_SYSTEM ) |
| 1669 | return -1; |
| 1670 | |
| 1671 | // the use the helper function |
| 1672 | return wxEncodingToCodepage(enc); |
| 1673 | } |
| 1674 | |
| 1675 | #else // !wxUSE_FONTMAP |
| 1676 | |
| 1677 | #include "wx/msw/registry.h" |
| 1678 | |
| 1679 | // this should work if Internet Exploiter is installed |
| 1680 | extern long wxCharsetToCodepage(const char *name) |
| 1681 | { |
| 1682 | if (!name) |
| 1683 | return GetACP(); |
| 1684 | |
| 1685 | long CP = -1; |
| 1686 | |
| 1687 | #if wxUSE_REGKEY |
| 1688 | wxString path(wxT("MIME\\Database\\Charset\\")); |
| 1689 | wxString cn(name); |
| 1690 | |
| 1691 | // follow the alias loop |
| 1692 | for ( ;; ) |
| 1693 | { |
| 1694 | wxRegKey key(wxRegKey::HKCR, path + cn); |
| 1695 | |
| 1696 | if (!key.Exists()) |
| 1697 | break; |
| 1698 | |
| 1699 | // two cases: either there's an AliasForCharset string, |
| 1700 | // or there are Codepage and InternetEncoding dwords. |
| 1701 | // The InternetEncoding gives us the actual encoding, |
| 1702 | // the Codepage just says which Windows character set to |
| 1703 | // use when displaying the data. |
| 1704 | if (key.HasValue(wxT("InternetEncoding")) && |
| 1705 | key.QueryValue(wxT("InternetEncoding"), &CP)) |
| 1706 | break; |
| 1707 | |
| 1708 | // no encoding, see if it's an alias |
| 1709 | if (!key.HasValue(wxT("AliasForCharset")) || |
| 1710 | !key.QueryValue(wxT("AliasForCharset"), cn)) |
| 1711 | break; |
| 1712 | } |
| 1713 | #endif // wxUSE_REGKEY |
| 1714 | |
| 1715 | return CP; |
| 1716 | } |
| 1717 | |
| 1718 | #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP |
| 1719 | |
| 1720 | extern "C" WXDLLIMPEXP_BASE HWND |
| 1721 | wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc) |
| 1722 | { |
| 1723 | wxCHECK_MSG( classname && pclassname && wndproc, NULL, |
| 1724 | wxT("NULL parameter in wxCreateHiddenWindow") ); |
| 1725 | |
| 1726 | // register the class fi we need to first |
| 1727 | if ( *pclassname == NULL ) |
| 1728 | { |
| 1729 | WNDCLASS wndclass; |
| 1730 | wxZeroMemory(wndclass); |
| 1731 | |
| 1732 | wndclass.lpfnWndProc = wndproc; |
| 1733 | wndclass.hInstance = wxGetInstance(); |
| 1734 | wndclass.lpszClassName = classname; |
| 1735 | |
| 1736 | if ( !::RegisterClass(&wndclass) ) |
| 1737 | { |
| 1738 | wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow")); |
| 1739 | |
| 1740 | return NULL; |
| 1741 | } |
| 1742 | |
| 1743 | *pclassname = classname; |
| 1744 | } |
| 1745 | |
| 1746 | // next create the window |
| 1747 | HWND hwnd = ::CreateWindow |
| 1748 | ( |
| 1749 | *pclassname, |
| 1750 | NULL, |
| 1751 | 0, 0, 0, 0, |
| 1752 | 0, |
| 1753 | (HWND) NULL, |
| 1754 | (HMENU)NULL, |
| 1755 | wxGetInstance(), |
| 1756 | (LPVOID) NULL |
| 1757 | ); |
| 1758 | |
| 1759 | if ( !hwnd ) |
| 1760 | { |
| 1761 | wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow")); |
| 1762 | } |
| 1763 | |
| 1764 | return hwnd; |
| 1765 | } |