#ifndef WX_PRECOMP
#include "wx/utils.h"
#include "wx/app.h"
- #include "wx/cursor.h"
#include "wx/intl.h"
#include "wx/log.h"
+#if wxUSE_GUI
+ #include "wx/cursor.h"
+#endif
#endif //WX_PRECOMP
// In some mingws there is a missing extern "C" int the winsock header,
// #include "wx/msw/private.h" which itself includes <windows.h>, as this
// one in turn includes <winsock.h> unless we define WIN32_LEAN_AND_MEAN.
//
-#if defined(__WIN32__) && !defined(__TWIN32__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
+#if defined(__WIN32__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
extern "C" {
#include <winsock.h> // we use socket functions in wxGetFullHostName()
}
#include "wx/timer.h"
-#if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__)
+#if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__)
#include <direct.h>
#ifndef __MWERKS__
#endif
#endif //GNUWIN32
-#if defined(__GNUWIN32__) && !defined(__TWIN32__)
+#if defined(__CYGWIN__) && !defined(__TWIN32__)
#include <sys/unistd.h>
#include <sys/stat.h>
+ #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()
#endif //GNUWIN32
#ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
#include <lm.h>
#endif // USE_NET_API
-#if defined(__WIN32__) && !defined(__WXWINE__)
+#if defined(__WIN32__) && !defined(__WXWINE__) && !defined(__WXMICROWIN__)
#include <io.h>
#ifndef __GNUWIN32__
#include "wx/ioswrap.h"
-#include "wx/ioswrap.h"
-
/* Need to undef new if including crtdbg.h */
# ifdef new
# undef new
static const wxChar eUSERNAME[] = wxT("UserName");
// these are only used under Win16
-#ifndef __WIN32__
+#if !defined(__WIN32__) && !defined(__WXMICROWIN__)
static const wxChar eHOSTNAME[] = wxT("HostName");
static const wxChar eUSERID[] = wxT("UserId");
#endif // !Win32
+#ifndef __WXMICROWIN__
+
// ============================================================================
// implementation
// ============================================================================
// Get hostname only (without domain name)
bool wxGetHostName(wxChar *buf, int maxSize)
{
-#if defined(__WIN32__) && !defined(__TWIN32__)
+#if defined(__WIN32__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__)
DWORD nSize = maxSize;
if ( !::GetComputerName(buf, &nSize) )
{
// get full hostname (with domain name if possible)
bool wxGetFullHostName(wxChar *buf, int maxSize)
{
-#if defined(__WIN32__) && !defined(__TWIN32__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
+#if defined(__WIN32__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
// TODO should use GetComputerNameEx() when available
WSADATA wsa;
if ( WSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
// Get user ID e.g. jacs
bool wxGetUserId(wxChar *buf, int maxSize)
{
-#if defined(__WIN32__) && !defined(__win32s__) && !defined(__TWIN32__)
+#if defined(__WIN32__) && !defined(__win32s__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__)
DWORD nSize = maxSize;
if ( ::GetUserName(buf, &nSize) == 0 )
{
// add a trailing slash if needed
if ( strDir.Last() != wxT('/') )
strDir << wxT('/');
+
+ #ifdef __CYGWIN__
+ // Cygwin returns unix type path but that does not work well
+ static wxChar windowsPath[MAX_PATH];
+ cygwin_conv_to_full_win32_path(strDir, windowsPath);
+ strDir = windowsPath;
+ #endif
#else // Windows
#ifdef __WIN32__
- const wxChar *szHome = wxGetenv(wxT("HOMEDRIVE"));
+ strDir.clear();
+
+ // If we have a valid HOME directory, as is used on many machines that
+ // have unix utilities on them, we should use that.
+ const wxChar *szHome = wxGetenv(wxT("HOME"));
+
if ( szHome != NULL )
- strDir << szHome;
- szHome = wxGetenv(wxT("HOMEPATH"));
- if ( szHome != NULL ) {
- strDir << szHome;
-
- // the idea is that under NT these variables have default values
- // of "%systemdrive%:" and "\\". As we don't want to create our
- // config files in the root directory of the system drive, we will
- // create it in our program's dir. However, if the user took care
- // to set HOMEPATH to something other than "\\", we suppose that he
- // knows what he is doing and use the supplied value.
- if ( wxStrcmp(szHome, wxT("\\")) != 0 )
- return strDir.c_str();
+ {
+ strDir = szHome;
+ }
+ else // no HOME, try HOMEDRIVE/PATH
+ {
+ szHome = wxGetenv(wxT("HOMEDRIVE"));
+ if ( szHome != NULL )
+ strDir << szHome;
+ szHome = wxGetenv(wxT("HOMEPATH"));
+
+ if ( szHome != NULL )
+ {
+ strDir << szHome;
+
+ // the idea is that under NT these variables have default values
+ // of "%systemdrive%:" and "\\". As we don't want to create our
+ // config files in the root directory of the system drive, we will
+ // create it in our program's dir. However, if the user took care
+ // to set HOMEPATH to something other than "\\", we suppose that he
+ // knows what he is doing and use the supplied value.
+ if ( wxStrcmp(szHome, wxT("\\")) == 0 )
+ strDir.clear();
+ }
+ }
+
+ if ( strDir.empty() )
+ {
+ // If we have a valid USERPROFILE directory, as is the case in
+ // Windows NT, 2000 and XP, we should use that as our home directory.
+ szHome = wxGetenv(wxT("USERPROFILE"));
+
+ if ( szHome != NULL )
+ strDir = szHome;
}
+ if ( !strDir.empty() )
+ {
+ return strDir.c_str();
+ }
+ //else: fall back to the prograrm directory
#else // Win16
- // Win16 has no idea about home, so use the working directory instead
+ // Win16 has no idea about home, so use the executable directory instead
#endif // WIN16/32
// 260 was taken from windef.h
bool wxDirExists(const wxString& dir)
{
-#if defined(__WIN32__)
+#ifdef __WXMICROWIN__
+ return wxPathExist(dir);
+#elif defined(__WIN32__)
DWORD attribs = GetFileAttributes(dir);
return ((attribs != (DWORD)-1) && (attribs & FILE_ATTRIBUTE_DIRECTORY));
#else // Win16
#endif // Win32/16
}
+bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
+{
+ if ( path.empty() )
+ return FALSE;
+
+// old w32api don't have ULARGE_INTEGER
+#if defined(__WIN32__) && \
+ (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
+ // GetDiskFreeSpaceEx() is not available under original Win95, check for
+ // it
+ typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
+ PULARGE_INTEGER,
+ PULARGE_INTEGER,
+ PULARGE_INTEGER);
+
+ GetDiskFreeSpaceEx_t
+ pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
+ (
+ ::GetModuleHandle(_T("kernel32.dll")),
+#if wxUSE_UNICODE
+ "GetDiskFreeSpaceExW"
+#else
+ "GetDiskFreeSpaceExA"
+#endif
+ );
+
+ if ( pGetDiskFreeSpaceEx )
+ {
+ ULARGE_INTEGER bytesFree, bytesTotal;
+
+ // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
+ if ( !pGetDiskFreeSpaceEx(path,
+ &bytesFree,
+ &bytesTotal,
+ NULL) )
+ {
+ wxLogLastError(_T("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 )
+ {
+ *pTotal = wxLongLong(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
+ }
+
+ if ( pFree )
+ {
+ *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
+ }
+ }
+ else
+#endif // Win32
+ {
+ // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
+ // should be used instead - but if it's not available, fall back on
+ // GetDiskFreeSpace() nevertheless...
+
+ DWORD lSectorsPerCluster,
+ lBytesPerSector,
+ lNumberOfFreeClusters,
+ lTotalNumberOfClusters;
+
+ // FIXME: this is wrong, we should extract the root drive from path
+ // instead, but this is the job for wxFileName...
+ if ( !::GetDiskFreeSpace(path,
+ &lSectorsPerCluster,
+ &lBytesPerSector,
+ &lNumberOfFreeClusters,
+ &lTotalNumberOfClusters) )
+ {
+ wxLogLastError(_T("GetDiskFreeSpace"));
+
+ return FALSE;
+ }
+
+ wxLongLong lBytesPerCluster = lSectorsPerCluster;
+ lBytesPerCluster *= lBytesPerSector;
+
+ if ( pTotal )
+ {
+ *pTotal = lBytesPerCluster;
+ *pTotal *= lTotalNumberOfClusters;
+ }
+
+ if ( pFree )
+ {
+ *pFree = lBytesPerCluster;
+ *pFree *= lNumberOfFreeClusters;
+ }
+ }
+
+ return TRUE;
+}
+
// ----------------------------------------------------------------------------
// env vars
// ----------------------------------------------------------------------------
int wxGetOsVersion(int *majorVsn, int *minorVsn)
{
#if defined(__WIN32__) && !defined(__SC__)
- OSVERSIONINFO info;
- wxZeroMemory(info);
+ static int ver = -1, major = -1, minor = -1;
- info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
- if ( ::GetVersionEx(&info) )
+ if ( ver == -1 )
{
- if (majorVsn)
- *majorVsn = info.dwMajorVersion;
- if (minorVsn)
- *minorVsn = info.dwMinorVersion;
+ OSVERSIONINFO info;
+ wxZeroMemory(info);
- switch ( info.dwPlatformId )
+ ver = wxWINDOWS;
+ info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+ if ( ::GetVersionEx(&info) )
{
- case VER_PLATFORM_WIN32s:
- return wxWIN32S;
+ major = info.dwMajorVersion;
+ minor = info.dwMinorVersion;
- case VER_PLATFORM_WIN32_WINDOWS:
- return wxWIN95;
+ switch ( info.dwPlatformId )
+ {
+ case VER_PLATFORM_WIN32s:
+ ver = wxWIN32S;
+ break;
- case VER_PLATFORM_WIN32_NT:
- return wxWINDOWS_NT;
+ case VER_PLATFORM_WIN32_WINDOWS:
+ ver = wxWIN95;
+ break;
+
+ case VER_PLATFORM_WIN32_NT:
+ ver = wxWINDOWS_NT;
+ break;
+ }
}
}
- return wxWINDOWS; // error if we get here, return generic value
+ if (majorVsn && major != -1)
+ *majorVsn = major;
+ if (minorVsn && minor != -1)
+ *minorVsn = minor;
+
+ return ver;
#else // Win16
int retValue = wxWINDOWS;
#ifdef __WINDOWS_386__
}
#endif // wxUSE_GUI/!wxUSE_GUI
+#endif // __WXMICROWIN__
// ----------------------------------------------------------------------------
// deprecated (in favour of wxLog) log functions
// ----------------------------------------------------------------------------
-#if wxUSE_GUI
+#if WXWIN_COMPATIBILITY_2_2
// Output a debug mess., in a system dependent fashion.
+#ifndef __WXMICROWIN__
void wxDebugMsg(const wxChar *fmt ...)
{
va_list ap;
wxSprintf(wxBuffer, wxT("%s: %s"), WXSTRINGCAST title, WXSTRINGCAST msg);
FatalAppExit(0, (LPCTSTR)wxBuffer);
}
+#endif // __WXMICROWIN__
+
+#endif // WXWIN_COMPATIBILITY_2_2
+
+#if wxUSE_GUI
// ----------------------------------------------------------------------------
// functions to work with .INI files
if ( gs_wxBusyCursorCount++ == 0 )
{
gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
+#ifndef __WXMICROWIN__
gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
+#endif
}
//else: nothing to do, already set
}
if ( --gs_wxBusyCursorCount == 0 )
{
+#ifndef __WXMICROWIN__
::SetCursor(gs_wxBusyCursorOld);
-
+#endif
gs_wxBusyCursorOld = 0;
}
}
// TRUE if we're between the above two calls
bool wxIsBusy()
{
- return (gs_wxBusyCursorCount > 0);
+ return gs_wxBusyCursorCount > 0;
}
// Check whether this window wants to process messages, e.g. Stop button
// MSW only: get user-defined resource from the .res file.
// Returns NULL or newly-allocated memory, so use delete[] to clean up.
+#ifndef __WXMICROWIN__
wxChar *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
{
HRSRC hResource = ::FindResource(wxGetInstance(), resourceName, resourceType);
return s;
}
+#endif // __WXMICROWIN__
// ----------------------------------------------------------------------------
// get display info
// Return TRUE if we have a colour display
bool wxColourDisplay()
{
+#ifdef __WXMICROWIN__
+ // MICROWIN_TODO
+ return TRUE;
+#else
// this function is called from wxDC ctor so it is called a *lot* of times
// hence we optimize it a bit but doign the check only once
//
}
return s_isColour != 0;
+#endif
}
// Returns depth of screen
// Get size of display
void wxDisplaySize(int *width, int *height)
{
+#ifdef __WXMICROWIN__
+ RECT rect;
+ HWND hWnd = GetDesktopWindow();
+ ::GetWindowRect(hWnd, & rect);
+
+ if ( width )
+ *width = rect.right - rect.left;
+ if ( height )
+ *height = rect.bottom - rect.top;
+#else // !__WXMICROWIN__
ScreenHDC dc;
- if ( width ) *width = GetDeviceCaps(dc, HORZRES);
- if ( height ) *height = GetDeviceCaps(dc, VERTRES);
+ if ( width )
+ *width = ::GetDeviceCaps(dc, HORZRES);
+ if ( height )
+ *height = ::GetDeviceCaps(dc, VERTRES);
+#endif // __WXMICROWIN__/!__WXMICROWIN__
}
void wxDisplaySizeMM(int *width, int *height)
{
+#ifdef __WXMICROWIN__
+ // MICROWIN_TODO
+ if ( width )
+ *width = 0;
+ if ( height )
+ *height = 0;
+#else
ScreenHDC dc;
- if ( width ) *width = GetDeviceCaps(dc, HORZSIZE);
- if ( height ) *height = GetDeviceCaps(dc, VERTSIZE);
+ if ( width )
+ *width = ::GetDeviceCaps(dc, HORZSIZE);
+ if ( height )
+ *height = ::GetDeviceCaps(dc, VERTSIZE);
+#endif
}
void wxClientDisplayRect(int *x, int *y, int *width, int *height)
{
-#ifdef __WIN16__
+#if defined(__WIN16__) || defined(__WXMICROWIN__)
*x = 0; *y = 0;
wxDisplaySize(width, height);
#else
#endif
}
-
// ---------------------------------------------------------------------------
// window information functions
// ---------------------------------------------------------------------------
wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
{
wxString str;
- int len = GetWindowTextLength((HWND)hWnd) + 1;
- GetWindowText((HWND)hWnd, str.GetWriteBuf(len), len);
- str.UngetWriteBuf();
+
+ if ( hWnd )
+ {
+ int len = GetWindowTextLength((HWND)hWnd) + 1;
+ ::GetWindowText((HWND)hWnd, str.GetWriteBuf(len), len);
+ str.UngetWriteBuf();
+ }
return str;
}
{
wxString str;
- int len = 256; // some starting value
-
- for ( ;; )
+ // MICROWIN_TODO
+#ifndef __WXMICROWIN__
+ if ( hWnd )
{
- // as we've #undefined GetClassName we must now manually choose the
- // right function to call
- int count =
-
- #ifndef __WIN32__
- GetClassName
- #else // Win32
- #ifdef UNICODE
- GetClassNameW
- #else // !Unicode
- #ifdef __TWIN32__
- GetClassName
- #else // !Twin32
- GetClassNameA
- #endif // Twin32/!Twin32
- #endif // Unicode/ANSI
- #endif // Win16/32
- ((HWND)hWnd, str.GetWriteBuf(len), len);
+ int len = 256; // some starting value
- str.UngetWriteBuf();
- if ( count == len )
+ for ( ;; )
{
- // the class name might have been truncated, retry with larger
- // buffer
- len *= 2;
- }
- else
- {
- break;
+ int count = ::GetClassName((HWND)hWnd, str.GetWriteBuf(len), len);
+
+ str.UngetWriteBuf();
+ if ( count == len )
+ {
+ // the class name might have been truncated, retry with larger
+ // buffer
+ len *= 2;
+ }
+ else
+ {
+ break;
+ }
}
}
+#endif // !__WXMICROWIN__
return str;
}
#endif // Win16/32
}
-#endif // wxUSE_GUI
-
-#if wxUSE_GUI
-
// ----------------------------------------------------------------------------
// Metafile helpers
// ----------------------------------------------------------------------------
#endif // wxUSE_GUI
-#if 0
-//------------------------------------------------------------------------
-// wild character routines
-//------------------------------------------------------------------------
-
-bool wxIsWild( const wxString& pattern )
+#ifdef __WXMICROWIN__
+int wxGetOsVersion(int *majorVsn, int *minorVsn)
{
- wxString tmp = pattern;
- char *pat = WXSTRINGCAST(tmp);
- while (*pat) {
- switch (*pat++) {
- case '?': case '*': case '[': case '{':
- return TRUE;
- case '\\':
- if (!*pat++)
- return FALSE;
- }
- }
- return FALSE;
-};
+ // MICROWIN_TODO
+ if (majorVsn) *majorVsn = 0;
+ if (minorVsn) *minorVsn = 0;
+ return wxUNIX;
+}
+#endif // __WXMICROWIN__
+// ----------------------------------------------------------------------------
+// Win32 codepage conversion functions
+// ----------------------------------------------------------------------------
-bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
-{
- wxString tmp1 = pat;
- char *pattern = WXSTRINGCAST(tmp1);
- wxString tmp2 = text;
- char *str = WXSTRINGCAST(tmp2);
- char c;
- char *cp;
- bool done = FALSE, ret_code, ok;
- // Below is for vi fans
- const char OB = '{', CB = '}';
-
- // dot_special means '.' only matches '.'
- if (dot_special && *str == '.' && *pattern != *str)
- return FALSE;
-
- while ((*pattern != '\0') && (!done)
- && (((*str=='\0')&&((*pattern==OB)||(*pattern=='*')))||(*str!='\0'))) {
- switch (*pattern) {
- case '\\':
- pattern++;
- if (*pattern != '\0')
- pattern++;
- break;
- case '*':
- pattern++;
- ret_code = FALSE;
- while ((*str!='\0')
- && (!(ret_code=wxMatchWild(pattern, str++, FALSE))))
- /*loop*/;
- if (ret_code) {
- while (*str != '\0')
- str++;
- while (*pattern != '\0')
- pattern++;
- }
- break;
- case '[':
- pattern++;
- repeat:
- if ((*pattern == '\0') || (*pattern == ']')) {
- done = TRUE;
- break;
- }
- if (*pattern == '\\') {
- pattern++;
- if (*pattern == '\0') {
- done = TRUE;
- break;
- }
- }
- if (*(pattern + 1) == '-') {
- c = *pattern;
- pattern += 2;
- if (*pattern == ']') {
- done = TRUE;
- break;
- }
- if (*pattern == '\\') {
- pattern++;
- if (*pattern == '\0') {
- done = TRUE;
- break;
- }
- }
- if ((*str < c) || (*str > *pattern)) {
- pattern++;
- goto repeat;
- }
- } else if (*pattern != *str) {
- pattern++;
- goto repeat;
- }
- pattern++;
- while ((*pattern != ']') && (*pattern != '\0')) {
- if ((*pattern == '\\') && (*(pattern + 1) != '\0'))
- pattern++;
- pattern++;
- }
- if (*pattern != '\0') {
- pattern++, str++;
- }
- break;
- case '?':
- pattern++;
- str++;
- break;
- case OB:
- pattern++;
- while ((*pattern != CB) && (*pattern != '\0')) {
- cp = str;
- ok = TRUE;
- while (ok && (*cp != '\0') && (*pattern != '\0')
- && (*pattern != ',') && (*pattern != CB)) {
- if (*pattern == '\\')
- pattern++;
- ok = (*pattern++ == *cp++);
- }
- if (*pattern == '\0') {
- ok = FALSE;
- done = TRUE;
- break;
- } else if (ok) {
- str = cp;
- while ((*pattern != CB) && (*pattern != '\0')) {
- if (*++pattern == '\\') {
- if (*++pattern == CB)
- pattern++;
- }
- }
- } else {
- while (*pattern!=CB && *pattern!=',' && *pattern!='\0') {
- if (*++pattern == '\\') {
- if (*++pattern == CB || *pattern == ',')
- pattern++;
- }
- }
- }
- if (*pattern != '\0')
- pattern++;
- }
- break;
- default:
- if (*str == *pattern) {
- str++, pattern++;
- } else {
- done = TRUE;
- }
- }
- }
- while (*pattern == '*')
- pattern++;
- return ((*str == '\0') && (*pattern == '\0'));
-};
+#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+
+// wxGetNativeFontEncoding() doesn't exist neither in wxBase nor in wxUniv
+#if wxUSE_GUI && !defined(__WXUNIVERSAL__)
+
+#include "wx/fontmap.h"
-#endif // 0
+// VZ: the new version of wxCharsetToCodepage() is more politically correct
+// and should work on other Windows versions as well but the old version is
+// still needed for !wxUSE_FONTMAP || !wxUSE_GUI case
+
+extern long wxEncodingToCodepage(wxFontEncoding encoding)
+{
+ // translate encoding into the Windows CHARSET
+ wxNativeEncodingInfo natveEncInfo;
+ if ( !wxGetNativeFontEncoding(encoding, &natveEncInfo) )
+ return -1;
-#if 0
+ // translate CHARSET to code page
+ CHARSETINFO csetInfo;
+ if ( !::TranslateCharsetInfo((DWORD *)(DWORD)natveEncInfo.charset,
+ &csetInfo,
+ TCI_SRCCHARSET) )
+ {
+ wxLogLastError(_T("TranslateCharsetInfo(TCI_SRCCHARSET)"));
-// maximum mumber of lines the output console should have
-static const WORD MAX_CONSOLE_LINES = 500;
+ return -1;
+ }
-BOOL WINAPI MyConsoleHandler( DWORD dwCtrlType ) { // control signal type
- FreeConsole();
- return TRUE;
+ return csetInfo.ciACP;
}
-void wxRedirectIOToConsole()
+#if wxUSE_FONTMAP
+
+extern long wxCharsetToCodepage(const wxChar *name)
{
- int hConHandle;
- long lStdHandle;
- CONSOLE_SCREEN_BUFFER_INFO coninfo;
- FILE *fp;
-
- // allocate a console for this app
- AllocConsole();
-
- // set the screen buffer to be big enough to let us scroll text
- GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),
- &coninfo);
- coninfo.dwSize.Y = MAX_CONSOLE_LINES;
- SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE),
- coninfo.dwSize);
-
- // redirect unbuffered STDOUT to the console
- lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
- hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
- if(hConHandle <= 0) return;
- fp = _fdopen( hConHandle, "w" );
- *stdout = *fp;
- setvbuf( stdout, NULL, _IONBF, 0 );
-
- // redirect unbuffered STDIN to the console
- lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
- hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
- if(hConHandle <= 0) return;
- fp = _fdopen( hConHandle, "r" );
- *stdin = *fp;
- setvbuf( stdin, NULL, _IONBF, 0 );
-
- // redirect unbuffered STDERR to the console
- lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
- hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
- if(hConHandle <= 0) return;
- fp = _fdopen( hConHandle, "w" );
- *stderr = *fp;
- setvbuf( stderr, NULL, _IONBF, 0 );
-
- // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
- // point to console as well
- ios::sync_with_stdio();
-
- SetConsoleCtrlHandler(MyConsoleHandler, TRUE);
+ // first get the font encoding for this charset
+ if ( !name )
+ return -1;
+
+ wxFontEncoding enc = wxTheFontMapper->CharsetToEncoding(name, FALSE);
+ if ( enc == wxFONTENCODING_SYSTEM )
+ return -1;
+
+ // the use the helper function
+ return wxEncodingToCodepage(enc);
}
-#else
-// Not supported
-void wxRedirectIOToConsole()
+
+#endif // wxUSE_FONTMAP
+
+#endif // wxUSE_GUI
+
+// include old wxCharsetToCodepage() by OK if needed
+#if !wxUSE_GUI || !wxUSE_FONTMAP
+
+#include "wx/msw/registry.h"
+
+// this should work if Internet Exploiter is installed
+extern long wxCharsetToCodepage(const wxChar *name)
{
+ if (!name)
+ return GetACP();
+
+ long CP=-1;
+
+ wxString cn(name);
+ do {
+ wxString path(wxT("MIME\\Database\\Charset\\"));
+ path += cn;
+ wxRegKey key(wxRegKey::HKCR, path);
+
+ if (!key.Exists()) break;
+
+ // two cases: either there's an AliasForCharset string,
+ // or there are Codepage and InternetEncoding dwords.
+ // The InternetEncoding gives us the actual encoding,
+ // the Codepage just says which Windows character set to
+ // use when displaying the data.
+ if (key.HasValue(wxT("InternetEncoding")) &&
+ key.QueryValue(wxT("InternetEncoding"), &CP)) break;
+
+ // no encoding, see if it's an alias
+ if (!key.HasValue(wxT("AliasForCharset")) ||
+ !key.QueryValue(wxT("AliasForCharset"), cn)) break;
+ } while (1);
+
+ return CP;
}
-#endif
+#endif // !wxUSE_GUI || !wxUSE_FONTMAP
+
+#endif // Win32
projects / wxWidgets.git / blobdiff