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__
wxChar *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
{
    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;

    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) + 1;
    wxChar *s = new wxChar[len];
    wxStrlcpy(s, theText, len);

    // 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 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
// ----------------------------------------------------------------------------

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
}


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