[wxWidgets.git] / 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 licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// 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/dynlib.h"

#include "wx/msw/private.h"     // includes <windows.h>
#include "wx/msw/registry.h"
#include <shellapi.h> // needed for SHELLEXECUTEINFO


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

// ---------------------------------------------------------------------------
// 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(const 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__
char *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType, int* pLen /* = NULL */)
{
    HRSRC hResource = ::FindResource(wxGetInstance(),
                                     resourceName.wx_str(),
                                     resourceType.wx_str());
    if ( hResource == 0 )
        return NULL;

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

    void *theText = ::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);
    char *s = new char[len + 1];
    memcpy(s, theText, len);
    s[len] = '\0'; // NUL-terminate in case the resource itself wasn't

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

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

    if (pLen)
      *pLen = len;

    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 doing 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(__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;
}

int WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
{
    return ::GetWindowLong((HWND)hWnd, GWL_ID);
}

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

void PixelToHIMETRIC(LONG *x, LONG *y, HDC 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;
}

void HIMETRICToPixel(LONG *x, LONG *y, HDC 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 HIMETRICToPixel(LONG *x, LONG *y)
{
    HIMETRICToPixel(x, y, ScreenHDC());
}

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

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
}


// ----------------------------------------------------------------------------
// Shell API wrappers
// ----------------------------------------------------------------------------

extern bool wxEnableFileNameAutoComplete(HWND hwnd)
{
#if wxUSE_DYNLIB_CLASS
    typedef HRESULT (WINAPI *SHAutoComplete_t)(HWND, DWORD);

    static SHAutoComplete_t s_pfnSHAutoComplete = NULL;
    static bool s_initialized = false;

    if ( !s_initialized )
    {
        s_initialized = true;

        wxLogNull nolog;
        wxDynamicLibrary dll(wxT("shlwapi.dll"));
        if ( dll.IsLoaded() )
        {
            s_pfnSHAutoComplete =
                (SHAutoComplete_t)dll.GetSymbol(wxT("SHAutoComplete"));
            if ( s_pfnSHAutoComplete )
            {
                // won't be unloaded until the process termination, no big deal
                dll.Detach();
            }
        }
    }

    if ( !s_pfnSHAutoComplete )
        return false;

    HRESULT hr = s_pfnSHAutoComplete(hwnd, 0x10 /* SHACF_FILESYS_ONLY */);
    if ( FAILED(hr) )
    {
        wxLogApiError(wxT("SHAutoComplete"), hr);
        return false;
    }

    return true;
#else
    wxUnusedVar(hwnd);
    return false;
#endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
}

// ----------------------------------------------------------------------------
// Launch document with default app
// ----------------------------------------------------------------------------

bool wxLaunchDefaultApplication(const wxString& document, int flags)
{
    wxUnusedVar(flags);

    WinStruct<SHELLEXECUTEINFO> sei;
    sei.lpFile = document.wx_str();
    sei.lpVerb = wxT("open");
#ifdef __WXWINCE__
    sei.nShow = SW_SHOWNORMAL; // SW_SHOWDEFAULT not defined under CE (#10216)
#else
    sei.nShow = SW_SHOWDEFAULT;
#endif

    // avoid Windows message box in case of error for consistency with
    // wxLaunchDefaultBrowser() even if don't show the error ourselves in this
    // function
    sei.fMask = SEE_MASK_FLAG_NO_UI;

    if ( ::ShellExecuteEx(&sei) )
        return true;

    return false;
}

// ----------------------------------------------------------------------------
// Launch default browser
// ----------------------------------------------------------------------------

bool wxDoLaunchDefaultBrowser(const wxString& url, const wxString& scheme, int flags)
{
    wxUnusedVar(flags);

#if wxUSE_IPC
    if ( flags & wxBROWSER_NEW_WINDOW )
    {
        // ShellExecuteEx() opens the URL in an existing window by default so
        // we can't use it if we need a new window
        wxRegKey key(wxRegKey::HKCR, scheme + wxT("\\shell\\open"));
        if ( !key.Exists() )
        {
            // try the default browser, it must be registered at least for http URLs
            key.SetName(wxRegKey::HKCR, wxT("http\\shell\\open"));
        }

        if ( key.Exists() )
        {
            wxRegKey keyDDE(key, wxT("DDEExec"));
            if ( keyDDE.Exists() )
            {
                // we only know the syntax of WWW_OpenURL DDE request for IE,
                // optimistically assume that all other browsers are compatible
                // with it
                static const wxChar *TOPIC_OPEN_URL = wxT("WWW_OpenURL");
                wxString ddeCmd;
                wxRegKey keyTopic(keyDDE, wxT("topic"));
                bool ok = keyTopic.Exists() &&
                            keyTopic.QueryDefaultValue() == TOPIC_OPEN_URL;
                if ( ok )
                {
                    ddeCmd = keyDDE.QueryDefaultValue();
                    ok = !ddeCmd.empty();
                }

                if ( ok )
                {
                    // for WWW_OpenURL, the index of the window to open the URL
                    // in is -1 (meaning "current") by default, replace it with
                    // 0 which means "new" (see KB article 160957)
                    ok = ddeCmd.Replace(wxT("-1"), wxT("0"),
                                        false /* only first occurrence */) == 1;
                }

                if ( ok )
                {
                    // and also replace the parameters: the topic should
                    // contain a placeholder for the URL
                    ok = ddeCmd.Replace(wxT("%1"), url, false) == 1;
                }

                if ( ok )
                {
                    // try to send it the DDE request now but ignore the errors
                    wxLogNull noLog;

                    const wxString ddeServer = wxRegKey(keyDDE, wxT("application"));
                    if ( wxExecuteDDE(ddeServer, TOPIC_OPEN_URL, ddeCmd) )
                        return true;

                    // this is not necessarily an error: maybe browser is
                    // simply not running, but no matter, in any case we're
                    // going to launch it using ShellExecuteEx() below now and
                    // we shouldn't try to open a new window if we open a new
                    // browser anyhow
                }
            }
        }
    }
#endif // wxUSE_IPC

    WinStruct<SHELLEXECUTEINFO> sei;
    sei.lpFile = url.c_str();
    sei.lpVerb = wxT("open");
    sei.nShow = SW_SHOWNORMAL;
    sei.fMask = SEE_MASK_FLAG_NO_UI; // we give error message ourselves

    if ( ::ShellExecuteEx(&sei) )
        return true;

    return false;
}
Commit	Line	Data
e2478fde VZ	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
65571936	9	// License: wxWindows licence
e2478fde VZ	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"
42d54220	29	#include "wx/window.h"
e2478fde VZ	30	#include "wx/utils.h"
	31	#endif //WX_PRECOMP
	32
5f6475c1 VZ	33	#include "wx/dynlib.h"
5f6475c1 VZ	34
e2478fde	35	#include "wx/msw/private.h" // includes <windows.h>
50a2e26f FM	36	#include "wx/msw/registry.h"
	37	#include <shellapi.h> // needed for SHELLEXECUTEINFO
	38
e2478fde VZ	39
	40	// ============================================================================
	41	// implementation
	42	// ============================================================================
	43
e2478fde VZ	44	// ---------------------------------------------------------------------------
	45	// helper functions for showing a "busy" cursor
	46	// ---------------------------------------------------------------------------
	47
	48	static HCURSOR gs_wxBusyCursor = 0; // new, busy cursor
	49	static HCURSOR gs_wxBusyCursorOld = 0; // old cursor
	50	static int gs_wxBusyCursorCount = 0;
	51
	52	extern HCURSOR wxGetCurrentBusyCursor()
	53	{
	54	return gs_wxBusyCursor;
	55	}
	56
	57	// Set the cursor to the busy cursor for all windows
f516d986	58	void wxBeginBusyCursor(const wxCursor *cursor)
e2478fde VZ	59	{
	60	if ( gs_wxBusyCursorCount++ == 0 )
	61	{
	62	gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
	63	#ifndef __WXMICROWIN__
	64	gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
	65	#endif
	66	}
	67	//else: nothing to do, already set
	68	}
	69
	70	// Restore cursor to normal
	71	void wxEndBusyCursor()
	72	{
	73	wxCHECK_RET( gs_wxBusyCursorCount > 0,
	74	wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
	75
	76	if ( --gs_wxBusyCursorCount == 0 )
	77	{
	78	#ifndef __WXMICROWIN__
	79	::SetCursor(gs_wxBusyCursorOld);
	80	#endif
	81	gs_wxBusyCursorOld = 0;
	82	}
	83	}
	84
27d2dbbc	85	// true if we're between the above two calls
e2478fde VZ	86	bool wxIsBusy()
	87	{
	88	return gs_wxBusyCursorCount > 0;
	89	}
	90
	91	// Check whether this window wants to process messages, e.g. Stop button
	92	// in long calculations.
	93	bool wxCheckForInterrupt(wxWindow *wnd)
	94	{
27d2dbbc	95	wxCHECK( wnd, false );
e2478fde VZ	96
	97	MSG msg;
	98	while ( ::PeekMessage(&msg, GetHwndOf(wnd), 0, 0, PM_REMOVE) )
	99	{
	100	::TranslateMessage(&msg);
	101	::DispatchMessage(&msg);
	102	}
	103
27d2dbbc	104	return true;
e2478fde VZ	105	}
	106
	107	// MSW only: get user-defined resource from the .res file.
	108	// Returns NULL or newly-allocated memory, so use delete[] to clean up.
	109
	110	#ifndef __WXMICROWIN__
59d43911	111	char wxLoadUserResource(const wxString& resourceName, const wxString& resourceType, int pLen /* = NULL */)
e2478fde	112	{
e0a050e3 VS	113	HRSRC hResource = ::FindResource(wxGetInstance(),
	114	resourceName.wx_str(),
	115	resourceType.wx_str());
e2478fde VZ	116	if ( hResource == 0 )
	117	return NULL;
	118
	119	HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource);
	120	if ( hData == 0 )
	121	return NULL;
	122
59d43911	123	void *theText = ::LockResource(hData);
e2478fde VZ	124	if ( !theText )
	125	return NULL;
	126
	127	// Not all compilers put a zero at the end of the resource (e.g. BC++ doesn't).
	128	// so we need to find the length of the resource.
59d43911 VZ	129	int len = ::SizeofResource(wxGetInstance(), hResource);
	130	char *s = new char[len + 1];
	131	memcpy(s, theText, len);
	132	s[len] = '\0'; // NUL-terminate in case the resource itself wasn't
e2478fde	133
e2478fde VZ	134	// Obsolete in WIN32
	135	#ifndef __WIN32__
	136	UnlockResource(hData);
	137	#endif
	138
	139	// No need??
	140	// GlobalFree(hData);
	141
59d43911 VZ	142	if (pLen)
	143	*pLen = len;
	144
e2478fde VZ	145	return s;
	146	}
	147	#endif // __WXMICROWIN__
	148
	149	// ----------------------------------------------------------------------------
	150	// get display info
	151	// ----------------------------------------------------------------------------
	152
	153	// See also the wxGetMousePosition in window.cpp
	154	// Deprecated: use wxPoint wxGetMousePosition() instead
	155	void wxGetMousePosition( int* x, int* y )
	156	{
	157	POINT pt;
	158	GetCursorPos( & pt );
	159	if ( x ) *x = pt.x;
	160	if ( y ) *y = pt.y;
259c43f6	161	}
e2478fde	162
27d2dbbc	163	// Return true if we have a colour display
e2478fde VZ	164	bool wxColourDisplay()
	165	{
	166	#ifdef __WXMICROWIN__
	167	// MICROWIN_TODO
27d2dbbc	168	return true;
e2478fde VZ	169	#else
e2478fde VZ	170	// this function is called from wxDC ctor so it is called a lot of times
3103e8a9	171	// hence we optimize it a bit but doing the check only once
e2478fde VZ	172	//
	173	// this should be MT safe as only the GUI thread (holding the GUI mutex)
	174	// can call us
	175	static int s_isColour = -1;
	176
	177	if ( s_isColour == -1 )
	178	{
	179	ScreenHDC dc;
	180	int noCols = ::GetDeviceCaps(dc, NUMCOLORS);
	181
	182	s_isColour = (noCols == -1) \|\| (noCols > 2);
	183	}
	184
	185	return s_isColour != 0;
	186	#endif
	187	}
	188
	189	// Returns depth of screen
	190	int wxDisplayDepth()
	191	{
	192	ScreenHDC dc;
	193	return GetDeviceCaps(dc, PLANES) * GetDeviceCaps(dc, BITSPIXEL);
	194	}
	195
	196	// Get size of display
	197	void wxDisplaySize(int width, int height)
	198	{
	199	#ifdef __WXMICROWIN__
	200	RECT rect;
	201	HWND hWnd = GetDesktopWindow();
	202	::GetWindowRect(hWnd, & rect);
	203
	204	if ( width )
	205	*width = rect.right - rect.left;
	206	if ( height )
	207	*height = rect.bottom - rect.top;
	208	#else // !__WXMICROWIN__
	209	ScreenHDC dc;
	210
	211	if ( width )
	212	*width = ::GetDeviceCaps(dc, HORZRES);
	213	if ( height )
	214	*height = ::GetDeviceCaps(dc, VERTRES);
	215	#endif // __WXMICROWIN__/!__WXMICROWIN__
	216	}
	217
	218	void wxDisplaySizeMM(int width, int height)
	219	{
	220	#ifdef __WXMICROWIN__
	221	// MICROWIN_TODO
	222	if ( width )
	223	*width = 0;
	224	if ( height )
	225	*height = 0;
	226	#else
	227	ScreenHDC dc;
	228
	229	if ( width )
	230	*width = ::GetDeviceCaps(dc, HORZSIZE);
	231	if ( height )
	232	*height = ::GetDeviceCaps(dc, VERTSIZE);
	233	#endif
	234	}
	235
236	void wxClientDisplayRect(int x, int y, int width, int height)
237	{
3a5bcc4d	238	#if defined(__WXMICROWIN__)
e2478fde VZ	239	x = 0; y = 0;
	240	wxDisplaySize(width, height);
	241	#else
	242	// Determine the desktop dimensions minus the taskbar and any other
	243	// special decorations...
	244	RECT r;
	245
	246	SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
	247	if (x) *x = r.left;
	248	if (y) *y = r.top;
	249	if (width) *width = r.right - r.left;
	250	if (height) *height = r.bottom - r.top;
	251	#endif
	252	}
	253
	254	// ---------------------------------------------------------------------------
	255	// window information functions
	256	// ---------------------------------------------------------------------------
	257
	258	wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
	259	{
	260	wxString str;
	261
	262	if ( hWnd )
	263	{
	264	int len = GetWindowTextLength((HWND)hWnd) + 1;
de564874	265	::GetWindowText((HWND)hWnd, wxStringBuffer(str, len), len);
e2478fde VZ	266	}
	267
	268	return str;
	269	}
	270
	271	wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
	272	{
	273	wxString str;
	274
	275	// MICROWIN_TODO
	276	#ifndef __WXMICROWIN__
	277	if ( hWnd )
	278	{
	279	int len = 256; // some starting value
	280
	281	for ( ;; )
	282	{
de564874	283	int count = ::GetClassName((HWND)hWnd, wxStringBuffer(str, len), len);
e2478fde	284
e2478fde VZ	285	if ( count == len )
	286	{
	287	// the class name might have been truncated, retry with larger
	288	// buffer
	289	len *= 2;
	290	}
	291	else
	292	{
	293	break;
	294	}
	295	}
	296	}
	297	#endif // !__WXMICROWIN__
	298
	299	return str;
	300	}
	301
6756a5f8	302	int WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
e2478fde	303	{
6756a5f8	304	return ::GetWindowLong((HWND)hWnd, GWL_ID);
e2478fde VZ	305	}
	306
	307	// ----------------------------------------------------------------------------
	308	// Metafile helpers
	309	// ----------------------------------------------------------------------------
	310
cc344571	311	void PixelToHIMETRIC(LONG x, LONG y, HDC hdcRef)
e2478fde	312	{
e2478fde VZ	313	int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
	314	iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
	315	iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
	316	iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
	317
	318	x = (iWidthMM * 100);
	319	*x /= iWidthPels;
	320	y = (iHeightMM * 100);
	321	*y /= iHeightPels;
	322	}
	323
cc344571	324	void HIMETRICToPixel(LONG x, LONG y, HDC hdcRef)
e2478fde	325	{
e2478fde VZ	326	int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
	327	iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
	328	iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
	329	iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
	330
	331	x = iWidthPels;
	332	x /= (iWidthMM 100);
	333	y = iHeightPels;
	334	y /= (iHeightMM 100);
	335	}
	336
cc344571 VS	337	void HIMETRICToPixel(LONG x, LONG y)
	338	{
	339	HIMETRICToPixel(x, y, ScreenHDC());
	340	}
	341
	342	void PixelToHIMETRIC(LONG x, LONG y)
	343	{
	344	PixelToHIMETRIC(x, y, ScreenHDC());
	345	}
	346
4676948b JS	347	void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2)
	348	{
	349	#ifdef __WXWINCE__
	350	POINT points[2];
	351	points[0].x = x1;
	352	points[0].y = y1;
	353	points[1].x = x2;
	354	points[1].y = y2;
	355	Polyline(hdc, points, 2);
	356	#else
	357	MoveToEx(hdc, x1, y1, NULL); LineTo((HDC) hdc, x2, y2);
	358	#endif
	359	}
	360
e2478fde	361
5f6475c1 VZ	362	// ----------------------------------------------------------------------------
	363	// Shell API wrappers
	364	// ----------------------------------------------------------------------------
	365
	366	extern bool wxEnableFileNameAutoComplete(HWND hwnd)
	367	{
40e0cf48	368	#if wxUSE_DYNLIB_CLASS
5f6475c1 VZ	369	typedef HRESULT (WINAPI *SHAutoComplete_t)(HWND, DWORD);
	370
	371	static SHAutoComplete_t s_pfnSHAutoComplete = NULL;
	372	static bool s_initialized = false;
	373
	374	if ( !s_initialized )
	375	{
	376	s_initialized = true;
	377
	378	wxLogNull nolog;
9a83f860	379	wxDynamicLibrary dll(wxT("shlwapi.dll"));
5f6475c1 VZ	380	if ( dll.IsLoaded() )
	381	{
	382	s_pfnSHAutoComplete =
9a83f860	383	(SHAutoComplete_t)dll.GetSymbol(wxT("SHAutoComplete"));
5f6475c1 VZ	384	if ( s_pfnSHAutoComplete )
	385	{
	386	// won't be unloaded until the process termination, no big deal
	387	dll.Detach();
	388	}
	389	}
	390	}
	391
	392	if ( !s_pfnSHAutoComplete )
	393	return false;
	394
	395	HRESULT hr = s_pfnSHAutoComplete(hwnd, 0x10 /* SHACF_FILESYS_ONLY */);
	396	if ( FAILED(hr) )
	397	{
9a83f860	398	wxLogApiError(wxT("SHAutoComplete"), hr);
5f6475c1 VZ	399	return false;
	400	}
	401
	402	return true;
40e0cf48 VZ	403	#else
	404	wxUnusedVar(hwnd);
	405	return false;
	406	#endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
5f6475c1 VZ	407	}
5f6475c1 VZ	408
50a2e26f FM	409	// ----------------------------------------------------------------------------
	410	// Launch document with default app
	411	// ----------------------------------------------------------------------------
	412
	413	bool wxLaunchDefaultApplication(const wxString& document, int flags)
	414	{
	415	wxUnusedVar(flags);
	416
	417	WinStruct<SHELLEXECUTEINFO> sei;
	418	sei.lpFile = document.wx_str();
9a83f860	419	sei.lpVerb = wxT("open");
50a2e26f FM	420	#ifdef __WXWINCE__
	421	sei.nShow = SW_SHOWNORMAL; // SW_SHOWDEFAULT not defined under CE (#10216)
	422	#else
	423	sei.nShow = SW_SHOWDEFAULT;
	424	#endif
	425
	426	// avoid Windows message box in case of error for consistency with
	427	// wxLaunchDefaultBrowser() even if don't show the error ourselves in this
	428	// function
	429	sei.fMask = SEE_MASK_FLAG_NO_UI;
	430
	431	if ( ::ShellExecuteEx(&sei) )
	432	return true;
	433
	434	return false;
	435	}
	436
	437	// ----------------------------------------------------------------------------
	438	// Launch default browser
	439	// ----------------------------------------------------------------------------
	440
	441	bool wxDoLaunchDefaultBrowser(const wxString& url, const wxString& scheme, int flags)
	442	{
	443	wxUnusedVar(flags);
03647350	444
50a2e26f FM	445	#if wxUSE_IPC
	446	if ( flags & wxBROWSER_NEW_WINDOW )
	447	{
	448	// ShellExecuteEx() opens the URL in an existing window by default so
	449	// we can't use it if we need a new window
9a83f860	450	wxRegKey key(wxRegKey::HKCR, scheme + wxT("\\shell\\open"));
50a2e26f FM	451	if ( !key.Exists() )
	452	{
	453	// try the default browser, it must be registered at least for http URLs
9a83f860	454	key.SetName(wxRegKey::HKCR, wxT("http\\shell\\open"));
50a2e26f FM	455	}
	456
	457	if ( key.Exists() )
	458	{
	459	wxRegKey keyDDE(key, wxT("DDEExec"));
	460	if ( keyDDE.Exists() )
	461	{
	462	// we only know the syntax of WWW_OpenURL DDE request for IE,
	463	// optimistically assume that all other browsers are compatible
	464	// with it
	465	static const wxChar *TOPIC_OPEN_URL = wxT("WWW_OpenURL");
	466	wxString ddeCmd;
	467	wxRegKey keyTopic(keyDDE, wxT("topic"));
	468	bool ok = keyTopic.Exists() &&
	469	keyTopic.QueryDefaultValue() == TOPIC_OPEN_URL;
	470	if ( ok )
	471	{
	472	ddeCmd = keyDDE.QueryDefaultValue();
	473	ok = !ddeCmd.empty();
	474	}
	475
	476	if ( ok )
	477	{
	478	// for WWW_OpenURL, the index of the window to open the URL
	479	// in is -1 (meaning "current") by default, replace it with
	480	// 0 which means "new" (see KB article 160957)
	481	ok = ddeCmd.Replace(wxT("-1"), wxT("0"),
	482	false /* only first occurrence */) == 1;
	483	}
	484
	485	if ( ok )
	486	{
	487	// and also replace the parameters: the topic should
	488	// contain a placeholder for the URL
	489	ok = ddeCmd.Replace(wxT("%1"), url, false) == 1;
	490	}
	491
	492	if ( ok )
	493	{
	494	// try to send it the DDE request now but ignore the errors
	495	wxLogNull noLog;
	496
	497	const wxString ddeServer = wxRegKey(keyDDE, wxT("application"));
	498	if ( wxExecuteDDE(ddeServer, TOPIC_OPEN_URL, ddeCmd) )
	499	return true;
	500
	501	// this is not necessarily an error: maybe browser is
	502	// simply not running, but no matter, in any case we're
	503	// going to launch it using ShellExecuteEx() below now and
	504	// we shouldn't try to open a new window if we open a new
	505	// browser anyhow
	506	}
	507	}
	508	}
	509	}
	510	#endif // wxUSE_IPC
	511
	512	WinStruct<SHELLEXECUTEINFO> sei;
	513	sei.lpFile = url.c_str();
9a83f860	514	sei.lpVerb = wxT("open");
50a2e26f FM	515	sei.nShow = SW_SHOWNORMAL;
	516	sei.fMask = SEE_MASK_FLAG_NO_UI; // we give error message ourselves
	517
	518	if ( ::ShellExecuteEx(&sei) )
	519	return true;
	520
	521	return false;
	522	}