]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/utilscmn.cpp
fix a few typos
[wxWidgets.git] / src / common / utilscmn.cpp
index fad395b80079a8df48bd3eb997964541ec88b14b..02befc3f4381b7239c687fcadc762e401d20984b 100644 (file)
@@ -54,7 +54,7 @@
 #include "wx/config.h"
 
 #if defined(__WXWINCE__) && wxUSE_DATETIME
-#include "wx/datetime.h"
+    #include "wx/datetime.h"
 #endif
 
 #include <ctype.h>
 
 #ifndef __WXPALMOS5__
 #ifndef __WXWINCE__
-#include <time.h>
+    #include <time.h>
 #else
-#include "wx/msw/wince/time.h"
+    #include "wx/msw/wince/time.h"
 #endif
 #endif // ! __WXPALMOS5__
 
 #ifdef __WXMAC__
-#include "wx/osx/private.h"
+    #include "wx/osx/private.h"
 #endif
 
 #ifndef __WXPALMOS5__
@@ -96,8 +96,7 @@
 
 #if defined(__WXMSW__)
     #include "wx/msw/private.h"
-    #include "wx/msw/registry.h"
-    #include <shellapi.h> // needed for SHELLEXECUTEINFO
+    #include "wx/filesys.h"
 #endif
 
 #if wxUSE_GUI && defined(__WXGTK__)
 
 #if wxUSE_BASE
 
-// ----------------------------------------------------------------------------
-// common data
-// ----------------------------------------------------------------------------
-
 // ============================================================================
 // implementation
 // ============================================================================
@@ -125,7 +120,7 @@ int wxHexToDec(const wxString& buf)
     if (buf.GetChar(0) >= wxT('A'))
         firstDigit = buf.GetChar(0) - wxT('A') + 10;
     else
-       firstDigit = buf.GetChar(0) - wxT('0');
+        firstDigit = buf.GetChar(0) - wxT('0');
 
     if (buf.GetChar(1) >= wxT('A'))
         secondDigit = buf.GetChar(1) - wxT('A') + 10;
@@ -166,6 +161,16 @@ wxString wxDecToHex(int dec)
 // misc functions
 // ----------------------------------------------------------------------------
 
+// Don't synthesize KeyUp events holding down a key and producing KeyDown
+// events with autorepeat. On by default and always on in wxMSW. wxGTK version
+// in utilsgtk.cpp.
+#ifndef __WXGTK__
+bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
+{
+    return true;    // detectable auto-repeat is the only mode MSW supports
+}
+#endif // !wxGTK
+
 // Return the current date/time
 wxString wxNow()
 {
@@ -177,17 +182,19 @@ wxString wxNow()
     return wxEmptyString;
 #endif
 #else
-    time_t now = time((time_t *) NULL);
+    time_t now = time(NULL);
     char *date = ctime(&now);
     date[24] = '\0';
     return wxString::FromAscii(date);
 #endif
 }
 
+#if WXWIN_COMPATIBILITY_2_8
 void wxUsleep(unsigned long milliseconds)
 {
     wxMilliSleep(milliseconds);
 }
+#endif
 
 const wxChar *wxGetInstallPrefix()
 {
@@ -224,6 +231,10 @@ bool wxIsPlatformLittleEndian()
 }
 
 
+// ----------------------------------------------------------------------------
+// wxPlatform
+// ----------------------------------------------------------------------------
+
 /*
  * Class to make it easier to specify platform-dependent values
  */
@@ -436,8 +447,7 @@ bool wxGetEmailAddress(wxChar *address, int maxSize)
     if ( !email )
         return false;
 
-    wxStrncpy(address, email, maxSize - 1);
-    address[maxSize - 1] = wxT('\0');
+    wxStrlcpy(address, email.t_str(), maxSize);
 
     return true;
 }
@@ -645,19 +655,9 @@ long wxExecute(const wxString& command,
 }
 
 // ----------------------------------------------------------------------------
-// wxApp::Yield() wrappers for backwards compatibility
+// Id functions
 // ----------------------------------------------------------------------------
 
-bool wxYield()
-{
-    return wxTheApp && wxTheApp->Yield();
-}
-
-bool wxYieldIfNeeded()
-{
-    return wxTheApp && wxTheApp->Yield(true);
-}
-
 // Id generation
 static long wxCurrentId = 100;
 
@@ -711,16 +711,16 @@ Thanks,
 
 /* Byte-wise swap two items of size SIZE. */
 #define SWAP(a, b, size)                                                      \
-  do                                                                              \
-    {                                                                              \
-      register size_t __size = (size);                                              \
-      register char *__a = (a), *__b = (b);                                      \
+  do                                                                          \
+    {                                                                         \
+      register size_t __size = (size);                                        \
+      register char *__a = (a), *__b = (b);                                   \
       do                                                                      \
-        {                                                                      \
-          char __tmp = *__a;                                                      \
+        {                                                                     \
+          char __tmp = *__a;                                                  \
           *__a++ = *__b;                                                      \
-          *__b++ = __tmp;                                                      \
-        } while (--__size > 0);                                                      \
+          *__b++ = __tmp;                                                     \
+        } while (--__size > 0);                                               \
     } while (0)
 
 /* Discontinue quicksort algorithm when partition gets below this size.
@@ -923,9 +923,9 @@ void wxQsort(void *const pbase, size_t total_elems,
   }
 }
 
+#endif // wxUSE_BASE
 
 
-#endif // wxUSE_BASE
 
 // ============================================================================
 // GUI-only functions from now on
@@ -933,210 +933,27 @@ void wxQsort(void *const pbase, size_t total_elems,
 
 #if wxUSE_GUI
 
-// ----------------------------------------------------------------------------
-// Launch document with default app
-// ----------------------------------------------------------------------------
-
-bool wxLaunchDefaultApplication(const wxString &document, int flags)
-{
-    wxUnusedVar(flags);
-    
-#ifdef __UNIX__
-    // Our best best is to use xdg-open from freedesktop.org cross-desktop
-    // compatibility suite xdg-utils
-    // (see http://portland.freedesktop.org/wiki/) -- this is installed on
-    // most modern distributions and may be tweaked by them to handle
-    // distribution specifics.
-    wxString path, xdg_open;
-    if ( wxGetEnv("PATH", &path) &&
-         wxFindFileInPath(&xdg_open, path, "xdg-open") )
-    {
-        if ( wxExecute(xdg_open + " " + document) )
-            return true;
-    }
-#endif
-
-   return false;
-}
-
 // ----------------------------------------------------------------------------
 // Launch default browser
 // ----------------------------------------------------------------------------
 
-#ifdef __WXCOCOA__
-// Private method in Objective-C++ source file.
-bool wxCocoaLaunchDefaultBrowser(const wxString& url, int flags);
-#endif
-
-bool wxLaunchDefaultBrowser(const wxString& urlOrig, int flags)
-{
-    wxUnusedVar(flags);
-
-    // set the scheme of url to http if it does not have one
-    // RR: This doesn't work if the url is just a local path
-    wxString url(urlOrig);
-    wxURI uri(url);
-    if ( !uri.HasScheme() )
-    {
-        if (wxFileExists(urlOrig))
-            url.Prepend( wxT("file://") );
-        else
-            url.Prepend(wxT("http://"));
-    }
-
-
 #if defined(__WXMSW__)
 
-#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, uri.GetScheme() + _T("\\shell\\open"));
-        if ( !key.Exists() )
-        {
-            // try 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() )
-            {
-                const wxString ddeTopic = wxRegKey(keyDDE, wxT("topic"));
-
-                // we only know the syntax of WWW_OpenURL DDE request for IE,
-                // optimistically assume that all other browsers are compatible
-                // with it
-                wxString ddeCmd;
-                bool ok = ddeTopic == wxT("WWW_OpenURL");
-                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 occurence */) == 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, ddeTopic, 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;
+// implemented in a port-specific utils source file:
+bool wxDoLaunchDefaultBrowser(const wxString& url, const wxString& scheme, int flags);
 
-    ::ShellExecuteEx(&sei);
+#elif defined(__WXX11__) || defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXCOCOA__) || \
+      (defined(__WXMAC__) && !defined(__WXOSX_IPHONE__))
 
-    const INT_PTR nResult = (INT_PTR)sei.hInstApp;
+// implemented in a port-specific utils source file:
+bool wxDoLaunchDefaultBrowser(const wxString& url, int flags);
 
-    // Firefox returns file not found for some reason, so make an exception
-    // for it
-    if ( nResult > 32 || nResult == SE_ERR_FNF )
-    {
-#ifdef __WXDEBUG__
-        // Log something if SE_ERR_FNF happens
-        if ( nResult == SE_ERR_FNF )
-            wxLogDebug(wxT("SE_ERR_FNF from ShellExecute -- maybe FireFox?"));
-#endif // __WXDEBUG__
-        return true;
-    }
-#elif defined(__WXCOCOA__)
-    // NOTE: We need to call the real implementation from src/cocoa/utils.mm
-    // because the code must use Objective-C features.
-    return wxCocoaLaunchDefaultBrowser(url, flags);
-#elif defined(__WXMAC__) && !defined(__WXOSX_IPHONE__)
-    wxCFRef< CFURLRef > curl( CFURLCreateWithString( kCFAllocatorDefault,
-            wxCFStringRef( url ), NULL ) );
-    OSStatus err = LSOpenCFURLRef( curl , NULL );
-
-    if (err == noErr)
-    {
-        return true;
-    }
-    else
-    {
-        wxLogDebug(wxT("Browser Launch error %d"), (int) err);
-        return false;
-    }
 #else
-    // (non-Mac, non-MSW)
-
-#ifdef __UNIX__
-
-    // Our best best is to use xdg-open from freedesktop.org cross-desktop
-    // compatibility suite xdg-utils
-    // (see http://portland.freedesktop.org/wiki/) -- this is installed on
-    // most modern distributions and may be tweaked by them to handle
-    // distribution specifics. Only if that fails, try to find the right
-    // browser ourselves.
-    wxString path, xdg_open;
-    if ( wxGetEnv("PATH", &path) &&
-         wxFindFileInPath(&xdg_open, path, "xdg-open") )
-    {
-        if ( wxExecute(xdg_open + " " + url) )
-            return true;
-    }
-
-    wxString desktop = wxTheApp->GetTraits()->GetDesktopEnvironment();
 
-    // GNOME and KDE desktops have some applications which should be always installed
-    // together with their main parts, which give us the
-    if (desktop == wxT("GNOME"))
-    {
-        wxArrayString errors;
-        wxArrayString output;
-
-        // gconf will tell us the path of the application to use as browser
-        long res = wxExecute( wxT("gconftool-2 --get /desktop/gnome/applications/browser/exec"),
-                              output, errors, wxEXEC_NODISABLE );
-        if (res >= 0 && errors.GetCount() == 0)
-        {
-            wxString cmd = output[0];
-            cmd << _T(' ') << url;
-            if (wxExecute(cmd))
-                return true;
-        }
-    }
-    else if (desktop == wxT("KDE"))
-    {
-        // kfmclient directly opens the given URL
-        if (wxExecute(wxT("kfmclient openURL ") + url))
-            return true;
-    }
-#endif
+// a "generic" implementation:
+bool wxDoLaunchDefaultBrowser(const wxString& url, int flags)
+{
+    // on other platforms try to use mime types or wxExecute...
 
     bool ok = false;
     wxString cmd;
@@ -1156,8 +973,7 @@ bool wxLaunchDefaultBrowser(const wxString& urlOrig, int flags)
     if ( !ok || cmd.empty() )
     {
         // fallback to checking for the BROWSER environment variable
-        cmd = wxGetenv(wxT("BROWSER"));
-        if ( !cmd.empty() )
+        if ( !wxGetEnv(wxT("BROWSER"), &cmd) || cmd.empty() )
             cmd << _T(' ') << url;
     }
 
@@ -1168,7 +984,86 @@ bool wxLaunchDefaultBrowser(const wxString& urlOrig, int flags)
     // no file type for HTML extension
     wxLogError(_("No default application configured for HTML files."));
 
-#endif // !wxUSE_MIMETYPE && !__WXMSW__
+    return false;
+}
+#endif
+
+static bool DoLaunchDefaultBrowserHelper(const wxString& urlOrig, int flags)
+{
+    // NOTE: we don't have to care about the wxBROWSER_NOBUSYCURSOR flag
+    //       as it was already handled by wxLaunchDefaultBrowser
+
+    wxUnusedVar(flags);
+
+    wxString url(urlOrig), scheme;
+    wxURI uri(url);
+
+    // this check is useful to avoid that wxURI recognizes as scheme parts of
+    // the filename, in case urlOrig is a local filename
+    // (e.g. "C:\\test.txt" when parsed by wxURI reports a scheme == "C")
+    bool hasValidScheme = uri.HasScheme() && 
+            (uri.GetScheme() == "http" || uri.GetScheme() == "file");
+
+#if defined(__WXMSW__)
+
+    // NOTE: when testing wxMSW's wxLaunchDefaultBrowser all possible forms
+    //       of the URL/flags should be tested; e.g.:
+    //
+    // for (int i=0; i<2; i++)
+    // {
+    //   wxLaunchDefaultBrowser("C:\\test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
+    //   wxLaunchDefaultBrowser("wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
+    //   wxLaunchDefaultBrowser("file:/C%3A/test.txt", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
+    //   wxLaunchDefaultBrowser("http://wxwidgets.org", i==0 ? 0 : wxBROWSER_NEW_WINDOW);
+    // }
+    // (assuming you have a C:\test.txt file)
+
+    if ( !hasValidScheme )
+    {
+        if (wxFileExists(urlOrig) || wxDirExists(urlOrig))
+        {
+            scheme = "file";
+            // do not prepend the file scheme to the URL as ShellExecuteEx() doesn't like it
+        }
+        else
+        {
+            url.Prepend(wxS("http://"));
+            scheme = "http";
+        }
+    }
+    else if ( hasValidScheme )
+    {
+        scheme = uri.GetScheme();
+
+        if ( uri.GetScheme() == "file" )
+        {
+            // TODO: extract URLToFileName() to some always compiled in
+            //       function
+#if wxUSE_FILESYSTEM
+            // ShellExecuteEx() doesn't like the "file" scheme when opening local files; 
+            // remove it
+            url = wxFileSystem::URLToFileName(url).GetFullPath();
+#endif // wxUSE_FILESYSTEM
+        }
+    }
+
+    if (wxDoLaunchDefaultBrowser(url, scheme, flags))
+        return true;
+    //else: call wxLogSysError
+#else
+    if ( !hasValidScheme )
+    {
+        // set the scheme of url to "http" or "file" if it does not have one
+        if (wxFileExists(urlOrig) || wxDirExists(urlOrig))
+            url.Prepend(wxS("file://"));
+        else
+            url.Prepend(wxS("http://"));
+    }
+
+    if (wxDoLaunchDefaultBrowser(url, flags))
+        return true;
+    //else: call wxLogSysError
+#endif
 
     wxLogSysError(_("Failed to open URL \"%s\" in default browser."),
                   url.c_str());
@@ -1176,10 +1071,23 @@ bool wxLaunchDefaultBrowser(const wxString& urlOrig, int flags)
     return false;
 }
 
+bool wxLaunchDefaultBrowser(const wxString& url, int flags)
+{
+    // NOTE: as documented, "url" may be both a real well-formed URL
+    //       and a local file name
+
+    if ( flags & wxBROWSER_NOBUSYCURSOR )
+        return DoLaunchDefaultBrowserHelper(url, flags);
+
+    wxBusyCursor bc;
+    return DoLaunchDefaultBrowserHelper(url, flags);
+}
+
 // ----------------------------------------------------------------------------
 // Menu accelerators related functions
 // ----------------------------------------------------------------------------
 
+#if WXWIN_COMPATIBILITY_2_6
 wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
 {
 #if wxUSE_MENUS
@@ -1201,6 +1109,7 @@ wxChar *wxStripMenuCodes(const wxChar *in, wxChar *out)
 
     return out;
 }
+#endif
 
 wxString wxStripMenuCodes(const wxString& in, int flags)
 {
@@ -1405,7 +1314,7 @@ void wxInfoMessageBox(wxWindow* parent)
     msg.Printf(_T("wxWidgets Library (%s port)\n")
                _T("Version %d.%d.%d%s%s, compiled at %s %s\n")
                _T("Runtime version of toolkit used is %d.%d.%s\n")
-               _T("Copyright (c) 1995-2007 wxWidgets team"),
+               _T("Copyright (c) 1995-2009 wxWidgets team"),
                wxPlatformInfo::Get().GetPortIdName().c_str(),
                wxMAJOR_VERSION,
                wxMINOR_VERSION,
@@ -1492,8 +1401,8 @@ wxString wxGetPasswordFromUser(const wxString& message,
 
 #if wxUSE_COLOURDLG
 
-wxColour wxGetColourFromUser(wxWindow *parent, 
-                             const wxColour& colInit, 
+wxColour wxGetColourFromUser(wxWindow *parent,
+                             const wxColour& colInit,
                              const wxString& caption,
                              wxColourData *ptrData)
 {
@@ -1661,14 +1570,18 @@ bool wxSafeYield(wxWindow *win, bool onlyIfNeeded)
     return rc;
 }
 
-// Don't synthesize KeyUp events holding down a key and producing KeyDown
-// events with autorepeat. On by default and always on in wxMSW. wxGTK version
-// in utilsgtk.cpp.
-#ifndef __WXGTK__
-bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
+// ----------------------------------------------------------------------------
+// wxApp::Yield() wrappers for backwards compatibility
+// ----------------------------------------------------------------------------
+
+bool wxYield()
 {
-    return true;    // detectable auto-repeat is the only mode MSW supports
+    return wxTheApp && wxTheApp->Yield();
+}
+
+bool wxYieldIfNeeded()
+{
+    return wxTheApp && wxTheApp->Yield(true);
 }
-#endif // !wxGTK
 
 #endif // wxUSE_GUI