src/msw/utilsgui.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        msw/utilsgui.cpp
// Purpose:     Various utility functions only available in GUI
// Author:      Vadim Zeitlin
// Modified by:
// Created:     21.06.2003 (extracted from msw/utils.cpp)
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// License:     wxWindows license
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/cursor.h"
    #include "wx/window.h"
    #include "wx/utils.h"
#endif //WX_PRECOMP

#include "wx/msw/private.h"     // includes <windows.h>

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// functions to work with .INI files
// ----------------------------------------------------------------------------

// Reading and writing resources (eg WIN.INI, .Xdefaults)
#if wxUSE_RESOURCES
bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
{
  if (file != wxEmptyString)
// Don't know what the correct cast should be, but it doesn't
// compile in BC++/16-bit without this cast.
#if !defined(__WIN32__)
    return (WritePrivateProfileString((const char*) section, (const char*) entry, (const char*) value, (const char*) file) != 0);
#else
    return (WritePrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)value, (LPCTSTR)WXSTRINGCAST file) != 0);
#endif
  else
    return (WriteProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)WXSTRINGCAST value) != 0);
}

bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
{
    wxString buf;
    buf.Printf(wxT("%.4f"), value);

    return wxWriteResource(section, entry, buf, file);
}

bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
{
    wxString buf;
    buf.Printf(wxT("%ld"), value);

    return wxWriteResource(section, entry, buf, file);
}

bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
{
    wxString buf;
    buf.Printf(wxT("%d"), value);

    return wxWriteResource(section, entry, buf, file);
}

bool wxGetResource(const wxString& section, const wxString& entry, wxChar **value, const wxString& file)
{
    static const wxChar defunkt[] = wxT("$$default");

    wxChar buf[1024];
    if (file != wxEmptyString)
    {
        int n = GetPrivateProfileString(section, entry, defunkt,
                                        buf, WXSIZEOF(buf), file);
        if (n == 0 || wxStrcmp(buf, defunkt) == 0)
            return FALSE;
    }
    else
    {
        int n = GetProfileString(section, entry, defunkt, buf, WXSIZEOF(buf));
        if (n == 0 || wxStrcmp(buf, defunkt) == 0)
            return FALSE;
    }
    if (*value) delete[] (*value);
    *value = wxStrcpy(new wxChar[wxStrlen(buf) + 1], buf);
    return TRUE;
}

bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
{
    wxChar *s = NULL;
    bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
    if (succ)
    {
        *value = (float)wxStrtod(s, NULL);
        delete[] s;
        return TRUE;
    }
    else return FALSE;
}

bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
{
    wxChar *s = NULL;
    bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
    if (succ)
    {
        *value = wxStrtol(s, NULL, 10);
        delete[] s;
        return TRUE;
    }
    else return FALSE;
}

bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
{
    wxChar *s = NULL;
    bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
    if (succ)
    {
        *value = (int)wxStrtol(s, NULL, 10);
        delete[] s;
        return TRUE;
    }
    else return FALSE;
}
#endif // wxUSE_RESOURCES

// ---------------------------------------------------------------------------
// helper functions for showing a "busy" cursor
// ---------------------------------------------------------------------------

static HCURSOR gs_wxBusyCursor = 0;     // new, busy cursor
static HCURSOR gs_wxBusyCursorOld = 0;  // old cursor
static int gs_wxBusyCursorCount = 0;

extern HCURSOR wxGetCurrentBusyCursor()
{
    return gs_wxBusyCursor;
}

// Set the cursor to the busy cursor for all windows
void wxBeginBusyCursor(wxCursor *cursor)
{
    if ( gs_wxBusyCursorCount++ == 0 )
    {
        gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
#ifndef __WXMICROWIN__
        gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
#endif
    }
    //else: nothing to do, already set
}

// Restore cursor to normal
void wxEndBusyCursor()
{
    wxCHECK_RET( gs_wxBusyCursorCount > 0,
                 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );

    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;
}

// Check whether this window wants to process messages, e.g. Stop button
// in long calculations.
bool wxCheckForInterrupt(wxWindow *wnd)
{
    wxCHECK( wnd, FALSE );

    MSG msg;
    while ( ::PeekMessage(&msg, GetHwndOf(wnd), 0, 0, PM_REMOVE) )
    {
        ::TranslateMessage(&msg);
        ::DispatchMessage(&msg);
    }

    return TRUE;
}

// 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);
    if ( hResource == 0 )
        return NULL;

    HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource);
    if ( hData == 0 )
        return NULL;

    wxChar *theText = (wxChar *)::LockResource(hData);
    if ( !theText )
        return NULL;

    // Not all compilers put a zero at the end of the resource (e.g. BC++ doesn't).
    // so we need to find the length of the resource.
    int len = ::SizeofResource(wxGetInstance(), hResource);
    wxChar  *s = new wxChar[len+1];
    wxStrncpy(s,theText,len);
    s[len]=0;

    // wxChar *s = copystring(theText);

    // Obsolete in WIN32
#ifndef __WIN32__
    UnlockResource(hData);
#endif

    // No need??
    //  GlobalFree(hData);

    return s;
}
#endif // __WXMICROWIN__

// ----------------------------------------------------------------------------
// get display info
// ----------------------------------------------------------------------------

// See also the wxGetMousePosition in window.cpp
// Deprecated: use wxPoint wxGetMousePosition() instead
void wxGetMousePosition( int* x, int* y )
{
    POINT pt;
    GetCursorPos( & pt );
    if ( x ) *x = pt.x;
    if ( y ) *y = pt.y;
};

// 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
    //
    // this should be MT safe as only the GUI thread (holding the GUI mutex)
    // can call us
    static int s_isColour = -1;

    if ( s_isColour == -1 )
    {
        ScreenHDC dc;
        int noCols = ::GetDeviceCaps(dc, NUMCOLORS);

        s_isColour = (noCols == -1) || (noCols > 2);
    }

    return s_isColour != 0;
#endif
}

// Returns depth of screen
int wxDisplayDepth()
{
    ScreenHDC dc;
    return GetDeviceCaps(dc, PLANES) * GetDeviceCaps(dc, BITSPIXEL);
}

// 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);
#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);
#endif
}

void wxClientDisplayRect(int *x, int *y, int *width, int *height)
{
#if defined(__WIN16__) || defined(__WXMICROWIN__)
    *x = 0; *y = 0;
    wxDisplaySize(width, height);
#else
    // Determine the desktop dimensions minus the taskbar and any other
    // special decorations...
    RECT r;

    SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
    if (x)      *x = r.left;
    if (y)      *y = r.top;
    if (width)  *width = r.right - r.left;
    if (height) *height = r.bottom - r.top;
#endif
}

// ---------------------------------------------------------------------------
// window information functions
// ---------------------------------------------------------------------------

wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
{
    wxString str;

    if ( hWnd )
    {
        int len = GetWindowTextLength((HWND)hWnd) + 1;
        ::GetWindowText((HWND)hWnd, wxStringBuffer(str, len), len);
    }

    return str;
}

wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
{
    wxString str;

    // MICROWIN_TODO
#ifndef __WXMICROWIN__
    if ( hWnd )
    {
        int len = 256; // some starting value

        for ( ;; )
        {
            int count = ::GetClassName((HWND)hWnd, wxStringBuffer(str, len), len);

            if ( count == len )
            {
                // the class name might have been truncated, retry with larger
                // buffer
                len *= 2;
            }
            else
            {
                break;
            }
        }
    }
#endif // !__WXMICROWIN__

    return str;
}

WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
{
#ifndef __WIN32__
    return (WXWORD)GetWindowWord((HWND)hWnd, GWW_ID);
#else // Win32
    return (WXWORD)GetWindowLong((HWND)hWnd, GWL_ID);
#endif // Win16/32
}

// ----------------------------------------------------------------------------
// Metafile helpers
// ----------------------------------------------------------------------------

extern void PixelToHIMETRIC(LONG *x, LONG *y)
{
    ScreenHDC hdcRef;

    int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
        iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
        iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
        iHeightPels = GetDeviceCaps(hdcRef, VERTRES);

    *x *= (iWidthMM * 100);
    *x /= iWidthPels;
    *y *= (iHeightMM * 100);
    *y /= iHeightPels;
}

extern void HIMETRICToPixel(LONG *x, LONG *y)
{
    ScreenHDC hdcRef;

    int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
        iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
        iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
        iHeightPels = GetDeviceCaps(hdcRef, VERTRES);

    *x *= iWidthPels;
    *x /= (iWidthMM * 100);
    *y *= iHeightPels;
    *y /= (iHeightMM * 100);
}

void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2)
{
#ifdef __WXWINCE__
    POINT points[2];
    points[0].x = x1;
    points[0].y = y1;
    points[1].x = x2;
    points[1].y = y2;
    Polyline(hdc, points, 2);
#else
    MoveToEx(hdc, x1, y1, NULL); LineTo((HDC) hdc, x2, y2);
#endif
}
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: msw/utilsgui.cpp
	3	// Purpose: Various utility functions only available in GUI
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 21.06.2003 (extracted from msw/utils.cpp)
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// License: wxWindows license
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// for compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	#ifndef WX_PRECOMP
	28	#include "wx/cursor.h"
	29	#include "wx/window.h"
	30	#include "wx/utils.h"
	31	#endif //WX_PRECOMP
	32
	33	#include "wx/msw/private.h" // includes <windows.h>
	34
	35	// ============================================================================
	36	// implementation
	37	// ============================================================================
	38
	39	// ----------------------------------------------------------------------------
	40	// functions to work with .INI files
	41	// ----------------------------------------------------------------------------
	42
	43	// Reading and writing resources (eg WIN.INI, .Xdefaults)
	44	#if wxUSE_RESOURCES
	45	bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
	46	{
	47	if (file != wxEmptyString)
	48	// Don't know what the correct cast should be, but it doesn't
	49	// compile in BC++/16-bit without this cast.
	50	#if !defined(__WIN32__)
	51	return (WritePrivateProfileString((const char) section, (const char) entry, (const char) value, (const char) file) != 0);
	52	#else
	53	return (WritePrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)value, (LPCTSTR)WXSTRINGCAST file) != 0);
	54	#endif
	55	else
	56	return (WriteProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)WXSTRINGCAST value) != 0);
	57	}
	58
	59	bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
	60	{
	61	wxString buf;
	62	buf.Printf(wxT("%.4f"), value);
	63
	64	return wxWriteResource(section, entry, buf, file);
	65	}
	66
	67	bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
	68	{
	69	wxString buf;
	70	buf.Printf(wxT("%ld"), value);
	71
	72	return wxWriteResource(section, entry, buf, file);
	73	}
	74
	75	bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
	76	{
	77	wxString buf;
	78	buf.Printf(wxT("%d"), value);
	79
	80	return wxWriteResource(section, entry, buf, file);
	81	}
	82
	83	bool wxGetResource(const wxString& section, const wxString& entry, wxChar **value, const wxString& file)
	84	{
	85	static const wxChar defunkt[] = wxT("$$default");
	86
	87	wxChar buf[1024];
	88	if (file != wxEmptyString)
	89	{
	90	int n = GetPrivateProfileString(section, entry, defunkt,
	91	buf, WXSIZEOF(buf), file);
	92	if (n == 0 \|\| wxStrcmp(buf, defunkt) == 0)
	93	return FALSE;
	94	}
	95	else
	96	{
	97	int n = GetProfileString(section, entry, defunkt, buf, WXSIZEOF(buf));
	98	if (n == 0 \|\| wxStrcmp(buf, defunkt) == 0)
	99	return FALSE;
	100	}
	101	if (value) delete[] (value);
	102	*value = wxStrcpy(new wxChar[wxStrlen(buf) + 1], buf);
	103	return TRUE;
	104	}
	105
	106	bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
	107	{
	108	wxChar *s = NULL;
	109	bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
	110	if (succ)
	111	{
	112	*value = (float)wxStrtod(s, NULL);
	113	delete[] s;
	114	return TRUE;
	115	}
	116	else return FALSE;
	117	}
	118
	119	bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
	120	{
	121	wxChar *s = NULL;
	122	bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
	123	if (succ)
	124	{
	125	*value = wxStrtol(s, NULL, 10);
	126	delete[] s;
	127	return TRUE;
	128	}
	129	else return FALSE;
	130	}
	131
	132	bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
	133	{
	134	wxChar *s = NULL;
	135	bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
	136	if (succ)
	137	{
	138	*value = (int)wxStrtol(s, NULL, 10);
	139	delete[] s;
	140	return TRUE;
	141	}
	142	else return FALSE;
	143	}
	144	#endif // wxUSE_RESOURCES
	145
	146	// ---------------------------------------------------------------------------
	147	// helper functions for showing a "busy" cursor
	148	// ---------------------------------------------------------------------------
	149
	150	static HCURSOR gs_wxBusyCursor = 0; // new, busy cursor
	151	static HCURSOR gs_wxBusyCursorOld = 0; // old cursor
	152	static int gs_wxBusyCursorCount = 0;
	153
	154	extern HCURSOR wxGetCurrentBusyCursor()
	155	{
	156	return gs_wxBusyCursor;
	157	}
	158
	159	// Set the cursor to the busy cursor for all windows
	160	void wxBeginBusyCursor(wxCursor *cursor)
	161	{
	162	if ( gs_wxBusyCursorCount++ == 0 )
	163	{
	164	gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
	165	#ifndef __WXMICROWIN__
	166	gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
	167	#endif
	168	}
	169	//else: nothing to do, already set
	170	}
	171
	172	// Restore cursor to normal
	173	void wxEndBusyCursor()
	174	{
	175	wxCHECK_RET( gs_wxBusyCursorCount > 0,
	176	wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
	177
	178	if ( --gs_wxBusyCursorCount == 0 )
	179	{
	180	#ifndef __WXMICROWIN__
	181	::SetCursor(gs_wxBusyCursorOld);
	182	#endif
	183	gs_wxBusyCursorOld = 0;
	184	}
	185	}
	186
	187	// TRUE if we're between the above two calls
	188	bool wxIsBusy()
	189	{
	190	return gs_wxBusyCursorCount > 0;
	191	}
	192
	193	// Check whether this window wants to process messages, e.g. Stop button
	194	// in long calculations.
	195	bool wxCheckForInterrupt(wxWindow *wnd)
	196	{
	197	wxCHECK( wnd, FALSE );
	198
	199	MSG msg;
	200	while ( ::PeekMessage(&msg, GetHwndOf(wnd), 0, 0, PM_REMOVE) )
	201	{
	202	::TranslateMessage(&msg);
	203	::DispatchMessage(&msg);
	204	}
	205
	206	return TRUE;
	207	}
	208
	209	// MSW only: get user-defined resource from the .res file.
	210	// Returns NULL or newly-allocated memory, so use delete[] to clean up.
	211
	212	#ifndef __WXMICROWIN__
	213	wxChar *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
	214	{
	215	HRSRC hResource = ::FindResource(wxGetInstance(), resourceName, resourceType);
	216	if ( hResource == 0 )
	217	return NULL;
	218
	219	HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource);
	220	if ( hData == 0 )
	221	return NULL;
	222
	223	wxChar theText = (wxChar )::LockResource(hData);
	224	if ( !theText )
	225	return NULL;
	226
	227	// Not all compilers put a zero at the end of the resource (e.g. BC++ doesn't).
	228	// so we need to find the length of the resource.
	229	int len = ::SizeofResource(wxGetInstance(), hResource);
	230	wxChar *s = new wxChar[len+1];
	231	wxStrncpy(s,theText,len);
	232	s[len]=0;
	233
	234	// wxChar *s = copystring(theText);
	235
	236	// Obsolete in WIN32
	237	#ifndef __WIN32__
	238	UnlockResource(hData);
	239	#endif
	240
	241	// No need??
	242	// GlobalFree(hData);
	243
	244	return s;
	245	}
	246	#endif // __WXMICROWIN__
	247
	248	// ----------------------------------------------------------------------------
	249	// get display info
	250	// ----------------------------------------------------------------------------
	251
	252	// See also the wxGetMousePosition in window.cpp
	253	// Deprecated: use wxPoint wxGetMousePosition() instead
	254	void wxGetMousePosition( int* x, int* y )
	255	{
	256	POINT pt;
	257	GetCursorPos( & pt );
	258	if ( x ) *x = pt.x;
	259	if ( y ) *y = pt.y;
	260	};
	261
	262	// Return TRUE if we have a colour display
	263	bool wxColourDisplay()
	264	{
	265	#ifdef __WXMICROWIN__
	266	// MICROWIN_TODO
	267	return TRUE;
	268	#else
	269	// this function is called from wxDC ctor so it is called a lot of times
	270	// hence we optimize it a bit but doign the check only once
	271	//
	272	// this should be MT safe as only the GUI thread (holding the GUI mutex)
	273	// can call us
	274	static int s_isColour = -1;
	275
	276	if ( s_isColour == -1 )
	277	{
	278	ScreenHDC dc;
	279	int noCols = ::GetDeviceCaps(dc, NUMCOLORS);
	280
	281	s_isColour = (noCols == -1) \|\| (noCols > 2);
	282	}
	283
	284	return s_isColour != 0;
	285	#endif
	286	}
	287
	288	// Returns depth of screen
	289	int wxDisplayDepth()
	290	{
	291	ScreenHDC dc;
	292	return GetDeviceCaps(dc, PLANES) * GetDeviceCaps(dc, BITSPIXEL);
	293	}
	294
	295	// Get size of display
	296	void wxDisplaySize(int width, int height)
	297	{
	298	#ifdef __WXMICROWIN__
	299	RECT rect;
	300	HWND hWnd = GetDesktopWindow();
	301	::GetWindowRect(hWnd, & rect);
	302
	303	if ( width )
	304	*width = rect.right - rect.left;
	305	if ( height )
	306	*height = rect.bottom - rect.top;
	307	#else // !__WXMICROWIN__
	308	ScreenHDC dc;
	309
	310	if ( width )
	311	*width = ::GetDeviceCaps(dc, HORZRES);
	312	if ( height )
	313	*height = ::GetDeviceCaps(dc, VERTRES);
	314	#endif // __WXMICROWIN__/!__WXMICROWIN__
	315	}
	316
	317	void wxDisplaySizeMM(int width, int height)
	318	{
	319	#ifdef __WXMICROWIN__
	320	// MICROWIN_TODO
	321	if ( width )
	322	*width = 0;
	323	if ( height )
	324	*height = 0;
	325	#else
	326	ScreenHDC dc;
	327
	328	if ( width )
	329	*width = ::GetDeviceCaps(dc, HORZSIZE);
	330	if ( height )
	331	*height = ::GetDeviceCaps(dc, VERTSIZE);
	332	#endif
	333	}
	334
	335	void wxClientDisplayRect(int x, int y, int width, int height)
	336	{
	337	#if defined(__WIN16__) \|\| defined(__WXMICROWIN__)
	338	x = 0; y = 0;
	339	wxDisplaySize(width, height);
	340	#else
	341	// Determine the desktop dimensions minus the taskbar and any other
	342	// special decorations...
	343	RECT r;
	344
	345	SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
	346	if (x) *x = r.left;
	347	if (y) *y = r.top;
	348	if (width) *width = r.right - r.left;
	349	if (height) *height = r.bottom - r.top;
	350	#endif
	351	}
	352
	353	// ---------------------------------------------------------------------------
	354	// window information functions
	355	// ---------------------------------------------------------------------------
	356
	357	wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
	358	{
	359	wxString str;
	360
	361	if ( hWnd )
	362	{
	363	int len = GetWindowTextLength((HWND)hWnd) + 1;
	364	::GetWindowText((HWND)hWnd, wxStringBuffer(str, len), len);
	365	}
	366
	367	return str;
	368	}
	369
	370	wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
	371	{
	372	wxString str;
	373
	374	// MICROWIN_TODO
	375	#ifndef __WXMICROWIN__
	376	if ( hWnd )
	377	{
	378	int len = 256; // some starting value
	379
	380	for ( ;; )
	381	{
	382	int count = ::GetClassName((HWND)hWnd, wxStringBuffer(str, len), len);
	383
	384	if ( count == len )
	385	{
	386	// the class name might have been truncated, retry with larger
	387	// buffer
	388	len *= 2;
	389	}
	390	else
	391	{
	392	break;
	393	}
	394	}
	395	}
	396	#endif // !__WXMICROWIN__
	397
	398	return str;
	399	}
	400
	401	WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
	402	{
	403	#ifndef __WIN32__
	404	return (WXWORD)GetWindowWord((HWND)hWnd, GWW_ID);
	405	#else // Win32
	406	return (WXWORD)GetWindowLong((HWND)hWnd, GWL_ID);
	407	#endif // Win16/32
	408	}
	409
	410	// ----------------------------------------------------------------------------
	411	// Metafile helpers
	412	// ----------------------------------------------------------------------------
	413
	414	extern void PixelToHIMETRIC(LONG x, LONG y)
	415	{
	416	ScreenHDC hdcRef;
	417
	418	int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
	419	iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
	420	iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
	421	iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
	422
	423	x = (iWidthMM * 100);
	424	*x /= iWidthPels;
	425	y = (iHeightMM * 100);
	426	*y /= iHeightPels;
	427	}
	428
	429	extern void HIMETRICToPixel(LONG x, LONG y)
	430	{
	431	ScreenHDC hdcRef;
	432
	433	int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
	434	iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
	435	iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
	436	iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
	437
	438	x = iWidthPels;
	439	x /= (iWidthMM 100);
	440	y = iHeightPels;
	441	y /= (iHeightMM 100);
	442	}
	443
	444	void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2)
	445	{
	446	#ifdef __WXWINCE__
	447	POINT points[2];
	448	points[0].x = x1;
	449	points[0].y = y1;
	450	points[1].x = x2;
	451	points[1].y = y2;
	452	Polyline(hdc, points, 2);
	453	#else
	454	MoveToEx(hdc, x1, y1, NULL); LineTo((HDC) hdc, x2, y2);
	455	#endif
	456	}
	457
	458