Added alpha blending in prep for FreeType text to canvas.

[wxWidgets.git] / src / common / utilscmn.cpp

diff --git a/src/common/utilscmn.cpp b/src/common/utilscmn.cpp
index 3f62793a9eb1930cd8b1b42371f8619e1ff288ed..49c15f328409766841d5ed091a39a822082f497b 100644 (file)
--- a/src/common/utilscmn.cpp
+++ b/src/common/utilscmn.cpp
@@ -48,8 +48,10 @@
     #endif // wxUSE_GUI
 #endif // WX_PRECOMP
 
     #endif // wxUSE_GUI
 #endif // WX_PRECOMP
 

+#ifndef __WIN16__

 #include "wx/process.h"
 #include "wx/txtstrm.h"
 #include "wx/process.h"
 #include "wx/txtstrm.h"

+#endif

 
 #include <ctype.h>
 #include <stdio.h>
 
 #include <ctype.h>
 #include <stdio.h>


@@ -78,7 +80,7 @@
 #endif
 
 #ifdef __WXMSW__
 #endif
 
 #ifdef __WXMSW__

-    #include "windows.h"
+    #include "wx/msw/private.h"

 #endif
 
 // ----------------------------------------------------------------------------
 #endif
 
 // ----------------------------------------------------------------------------


@@ -496,23 +498,32 @@ wxAcceleratorEntry *wxGetAccelFromString(const wxString& label)
                     keyCode = WXK_F1 + n - 1;
                 }
                 else {
                     keyCode = WXK_F1 + n - 1;
                 }
                 else {

-#if 0 // this is not supported by GTK+, apparently

                     // several special cases
                     current.MakeUpper();
                     if ( current == wxT("DEL") ) {
                     // several special cases
                     current.MakeUpper();
                     if ( current == wxT("DEL") ) {

-                        keyCode = VK_DELETE;
+                        keyCode = WXK_DELETE;
+                    }
+                    else if ( current == wxT("DELETE") ) {
+                        keyCode = WXK_DELETE;
+                    }
+                    else if ( current == wxT("INS") ) {
+                        keyCode = WXK_INSERT;

                     }
                     }

+                    else if ( current == wxT("INSERT") ) {
+                        keyCode = WXK_INSERT;
+                    }
+#if 0

                     else if ( current == wxT("PGUP") ) {
                         keyCode = VK_PRIOR;
                     }
                     else if ( current == wxT("PGDN") ) {
                         keyCode = VK_NEXT;
                     }
                     else if ( current == wxT("PGUP") ) {
                         keyCode = VK_PRIOR;
                     }
                     else if ( current == wxT("PGDN") ) {
                         keyCode = VK_NEXT;
                     }

+#endif

                     else
                     else

-#endif // 0

                     {
                     {

-                        wxLogDebug(wxT("Unrecognized accel key '%s', accel "
-                                       "string ignored."), current.c_str());
+                        wxLogDebug(wxT("Unrecognized accel key '%s', accel string ignored."),
+                                   current.c_str());

                     }
                 }
             }
                     }
                 }
             }


@@ -876,10 +887,13 @@ int wxMessageBox(const wxString& message, const wxString& caption, long style,
             return wxYES;
         case wxID_NO:
             return wxNO;
             return wxYES;
         case wxID_NO:
             return wxNO;

-        default:

         case wxID_CANCEL:
             return wxCANCEL;
     }
         case wxID_CANCEL:
             return wxCANCEL;
     }

+
+    wxFAIL_MSG( _T("unexpected return code from wxMessageDialog") );
+
+    return wxCANCEL;

 }
 
 #if wxUSE_TEXTDLG
 }
 
 #if wxUSE_TEXTDLG


@@ -952,7 +966,7 @@ int isascii( int c )
 #endif // __MWERKS__
 
 // ----------------------------------------------------------------------------
 #endif // __MWERKS__
 
 // ----------------------------------------------------------------------------

-// misc functions
+// wxSafeYield and supporting functions

 // ----------------------------------------------------------------------------
 
 void wxEnableTopLevelWindows(bool enable)
 // ----------------------------------------------------------------------------
 
 void wxEnableTopLevelWindows(bool enable)


@@ -962,70 +976,100 @@ void wxEnableTopLevelWindows(bool enable)
         node->GetData()->Enable(enable);
 }
 
         node->GetData()->Enable(enable);
 }
 

-static void wxFindDisabledWindows(wxWindowList& winDisabled, wxWindow *win)
-{
-    wxWindowList::Node *node;
-    for ( node = win->GetChildren().GetFirst(); node; node = node->GetNext() )
-    {
-        wxWindow *child = node->GetData();
-        wxFindDisabledWindows(winDisabled, child);
-
-        if ( child->IsEnabled() )
-        {
-            winDisabled.Append(child);
-            child->Disable();
-        }
-    }
-}
-

 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
 {
 wxWindowDisabler::wxWindowDisabler(wxWindow *winToSkip)
 {

-    // remember all windows we're going to (temporarily) disable
-    m_winDisabled = new wxWindowList;
+#ifdef __WXMSW__
+#ifdef __WIN32__
+    // and the top level window too
+    HWND hwndFG = ::GetForegroundWindow();
+    m_winTop = hwndFG ? wxFindWinFromHandle((WXHWND)hwndFG) : (wxWindow *)NULL;
+#else
+    HWND hwndFG = ::GetTopWindow(0);
+    m_winTop = hwndFG ? wxFindWinFromHandle((WXHWND)hwndFG) : (wxWindow *)NULL;
+#endif
+#endif // MSW
+
+    // remember the top level windows which were already disabled, so that we
+    // don't reenable them later
+    m_winDisabled = NULL;

 
     wxWindowList::Node *node;
     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
     {
         wxWindow *winTop = node->GetData();
 
     wxWindowList::Node *node;
     for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )
     {
         wxWindow *winTop = node->GetData();

+        if ( winTop == winToSkip )
+            continue;
+

         if ( winTop->IsEnabled() )
         {
         if ( winTop->IsEnabled() )
         {

-            wxFindDisabledWindows(*m_winDisabled, winTop);
-
-            m_winDisabled->Append(winTop);

             winTop->Disable();
         }
             winTop->Disable();
         }

-    }
+        else
+        {
+            if ( !m_winDisabled )
+            {
+                m_winDisabled = new wxWindowList;
+            }

 
 

-    if ( winToSkip && m_winDisabled->Find(winToSkip) )
-    {
-        // always enable ourselves
-        m_winDisabled->DeleteObject(winToSkip);
-        winToSkip->Enable();
+            m_winDisabled->Append(winTop);
+        }

     }
 }
 
 wxWindowDisabler::~wxWindowDisabler()
 {
     wxWindowList::Node *node;
     }
 }
 
 wxWindowDisabler::~wxWindowDisabler()
 {
     wxWindowList::Node *node;

-    for ( node = m_winDisabled->GetFirst(); node; node = node->GetNext() )
+    for ( node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() )

     {
     {

-        node->GetData()->Enable();
+        wxWindow *winTop = node->GetData();
+        if ( !m_winDisabled || !m_winDisabled->Find(winTop) )
+        {
+            winTop->Enable();
+        }
+        //else: had been already disabled, don't reenable

     }
 
     delete m_winDisabled;
     }
 
     delete m_winDisabled;

+
+#ifdef __WXMSW__
+#ifdef __WIN32__
+    if ( m_winTop )
+    {
+        if ( !::SetForegroundWindow(GetHwndOf(m_winTop)) )
+        {
+            wxLogLastError(wxT("SetForegroundWindow"));
+        }
+    }
+#else
+    if ( m_winTop )
+    {
+        // 16-bit SetForegroundWindow() replacement
+        RECT reWin;
+        GetWindowRect((HWND) m_winTop, &reWin);
+        SetWindowPos ((HWND) m_winTop, HWND_TOP,
+                             reWin.left, reWin.top, 
+                             reWin.right - reWin.left, reWin.bottom, 
+                             SWP_SHOWWINDOW);
+    }
+#endif
+#endif // MSW

 }
 
 // Yield to other apps/messages and disable user input to all windows except
 // the given one
 bool wxSafeYield(wxWindow *win)
 {
 }
 
 // Yield to other apps/messages and disable user input to all windows except
 // the given one
 bool wxSafeYield(wxWindow *win)
 {

-    wxWindowDisabler wd;
+    wxWindowDisabler wd(win);

 
     bool rc = wxYield();
 
     return rc;
 }
 
 
     bool rc = wxYield();
 
     return rc;
 }
 

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


@@ -1059,14 +1103,13 @@ wxString wxGetEmailAddress()
 {
     wxString email;
 
 {
     wxString email;
 

-    wxString host = wxGetHostName();
+    wxString host = wxGetFullHostName();

     if ( !!host )
     {
         wxString user = wxGetUserId();
         if ( !!user )
         {
     if ( !!host )
     {
         wxString user = wxGetUserId();
         if ( !!user )
         {

-            wxString email(user);
-            email << wxT('@') << host;
+            email << user << wxT('@') << host;

         }
     }
 
         }
     }
 


@@ -1177,26 +1220,89 @@ wxString wxGetCurrentDir()
 // wxExecute
 // ----------------------------------------------------------------------------
 
 // wxExecute
 // ----------------------------------------------------------------------------
 

-long wxExecute(const wxString& command, wxArrayString& output)
+// this is a private function because it hasn't a clean interface: the first
+// array is passed by reference, the second by pointer - instead we have 2
+// public versions of wxExecute() below
+static long wxDoExecuteWithCapture(const wxString& command,
+                                   wxArrayString& output,
+                                   wxArrayString* error)

 {
 {

+#ifdef __WIN16__
+    wxFAIL_MSG("Sorry, this version of wxExecute not implemented on WIN16.");
+
+    return 0;
+#else // !Win16

     // create a wxProcess which will capture the output
     wxProcess *process = new wxProcess;
     process->Redirect();
 
     long rc = wxExecute(command, TRUE /* sync */, process);
     // create a wxProcess which will capture the output
     wxProcess *process = new wxProcess;
     process->Redirect();
 
     long rc = wxExecute(command, TRUE /* sync */, process);

+
+#if wxUSE_STREAMS

     if ( rc != -1 )
     {
     if ( rc != -1 )
     {

-        wxInputStream& is = *process->GetInputStream();
-        wxTextInputStream tis(is);
-        while ( !is.Eof() )
+        wxInputStream* is = process->GetInputStream();
+        wxCHECK_MSG( is, -1, _T("if wxExecute() succeded, stream can't be NULL") );
+        wxTextInputStream tis(*is);
+
+        wxTextInputStream *tes = NULL;
+        wxInputStream *es = NULL;
+        if ( error )

         {
         {

-            wxString line = tis.ReadLine();
-            if ( is.LastError() )
-                break;
+            es = process->GetErrorStream();
+
+            wxCHECK_MSG( es, -1, _T("stderr can't be NULL") );
+
+            tes = new wxTextInputStream(*es);
+        }

 
 

-            output.Add(line);
+        bool cont;
+        do
+        {
+            cont = FALSE;
+
+            if ( !is->Eof() && is->IsOk() )
+            {
+                wxString line = tis.ReadLine();
+                if ( is->LastError() )
+                    break;
+
+                cont = TRUE;
+
+                output.Add(line);
+            }
+
+            if ( error && !es->Eof() && es->IsOk() )
+            {
+                wxString line = tes->ReadLine();
+                if ( es->LastError() )
+                    break;
+
+                cont = TRUE;
+
+                error->Add(line);
+            }

         }
         }

+        while ( cont );
+
+        delete tes;

     }
     }

+#endif // wxUSE_STREAMS
+
+    delete process;

 
     return rc;
 
     return rc;

+#endif // IO redirection supoprted
+}
+
+long wxExecute(const wxString& command, wxArrayString& output)
+{
+    return wxDoExecuteWithCapture(command, output, NULL);
+}
+
+long wxExecute(const wxString& command,
+               wxArrayString& output,
+               wxArrayString& error)
+{
+    return wxDoExecuteWithCapture(command, output, &error);

 }
 }