src/msw/utilsgui.cpp

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