return radio box own help text when origin is Origin_Unknown to make sure GetHelpText...

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

diff --git a/src/common/stattextcmn.cpp b/src/common/stattextcmn.cpp
index 184c9f1c983832e4230a41ae1d69b4bf7d72c936..9558d2dfdd3531ebf9e4c0922214c157758ffe62 100644 (file)
--- a/src/common/stattextcmn.cpp
+++ b/src/common/stattextcmn.cpp
@@ -30,14 +30,13 @@
     #include "wx/button.h"
     #include "wx/dcclient.h"
     #include "wx/intl.h"
     #include "wx/button.h"
     #include "wx/dcclient.h"
     #include "wx/intl.h"

+    #include "wx/log.h"

     #include "wx/settings.h"
     #include "wx/stattext.h"
     #include "wx/sizer.h"
     #include "wx/containr.h"
 #endif
 
     #include "wx/settings.h"
     #include "wx/stattext.h"
     #include "wx/sizer.h"
     #include "wx/containr.h"
 #endif
 

-#if wxUSE_STATTEXT
-

 const wxChar *wxMarkupEntities[][wxMARKUP_ENTITY_MAX] =
 {
     // the entities handled by SetLabel() when wxST_MARKUP is used and their referenced string
 const wxChar *wxMarkupEntities[][wxMARKUP_ENTITY_MAX] =
 {
     // the entities handled by SetLabel() when wxST_MARKUP is used and their referenced string


@@ -46,6 +45,7 @@ const wxChar *wxMarkupEntities[][wxMARKUP_ENTITY_MAX] =
     { wxT("&"),     wxT("<"),    wxT(">"),    wxT("'"),      wxT("\"")     }
 };
 
     { wxT("&"),     wxT("<"),    wxT(">"),    wxT("'"),      wxT("\"")     }
 };
 

+#if wxUSE_STATTEXT

 
 // ----------------------------------------------------------------------------
 // wxTextWrapper
 
 // ----------------------------------------------------------------------------
 // wxTextWrapper


@@ -53,26 +53,26 @@ const wxChar *wxMarkupEntities[][wxMARKUP_ENTITY_MAX] =
 
 void wxTextWrapper::Wrap(wxWindow *win, const wxString& text, int widthMax)
 {
 
 void wxTextWrapper::Wrap(wxWindow *win, const wxString& text, int widthMax)
 {

-    const wxChar *lastSpace = NULL;

     wxString line;
 
     wxString line;
 

-    const wxChar *lineStart = text.c_str();
-    for ( const wxChar *p = lineStart; ; p++ )
+    wxString::const_iterator lastSpace = text.end();
+    wxString::const_iterator lineStart = text.begin();
+    for ( wxString::const_iterator p = lineStart; ; ++p )

     {
         if ( IsStartOfNewLine() )
         {
             OnNewLine();
 
     {
         if ( IsStartOfNewLine() )
         {
             OnNewLine();
 

-            lastSpace = NULL;
+            lastSpace = text.end();

             line.clear();
             lineStart = p;
         }
 
             line.clear();
             lineStart = p;
         }
 

-        if ( *p == _T('\n') || *p == _T('\0') )
+        if ( p == text.end() || *p == _T('\n') )

         {
             DoOutputLine(line);
 
         {
             DoOutputLine(line);
 

-            if ( *p == _T('\0') )
+            if ( p == text.end() )

                 break;
         }
         else // not EOL
                 break;
         }
         else // not EOL


@@ -82,7 +82,7 @@ void wxTextWrapper::Wrap(wxWindow *win, const wxString& text, int widthMax)
 
             line += *p;
 
 
             line += *p;
 

-            if ( widthMax >= 0 && lastSpace )
+            if ( widthMax >= 0 && lastSpace != text.end() )

             {
                 int width;
                 win->GetTextExtent(line, &width, NULL);
             {
                 int width;
                 win->GetTextExtent(line, &width, NULL);


@@ -153,6 +153,14 @@ wxString wxStaticTextBase::GetLabelText() const
     return RemoveMnemonics(ret);
 }
 
     return RemoveMnemonics(ret);
 }
 

+/*static*/
+wxString wxStaticTextBase::GetLabelText(const wxString& label)
+{
+    // remove markup
+    wxString ret = RemoveMarkup(label);
+    return RemoveMnemonics(ret);
+}
+

 /*static*/
 wxString wxStaticTextBase::RemoveMarkup(const wxString& text)
 {
 /*static*/
 wxString wxStaticTextBase::RemoveMarkup(const wxString& text)
 {


@@ -160,10 +168,10 @@ wxString wxStaticTextBase::RemoveMarkup(const wxString& text)
     bool inside_tag = false;
 
     wxString label;
     bool inside_tag = false;
 
     wxString label;

-    const wxChar *source = text;
-    for (size_t i=0, max=text.length(); i<max; i++)
+    for ( wxString::const_iterator source = text.begin();
+          source != text.end(); ++source )

     {
     {

-        switch (source[i])
+        switch ( (*source).GetValue() )

         {
             case wxT('<'):
                 if (inside_tag)
         {
             case wxT('<'):
                 if (inside_tag)


@@ -185,7 +193,7 @@ wxString wxStaticTextBase::RemoveMarkup(const wxString& text)
 
             case wxT('&'):
                 {
 
             case wxT('&'):
                 {

-                    if (i == max-1)
+                    if ( source+1 == text.end() )

                     {
                         wxLogDebug(wxT("Cannot use & as last character of the string '%s'"),
                                    text.c_str());
                     {
                         wxLogDebug(wxT("Cannot use & as last character of the string '%s'"),
                                    text.c_str());


@@ -194,38 +202,39 @@ wxString wxStaticTextBase::RemoveMarkup(const wxString& text)
 
                     // is this ampersand introducing a mnemonic or rather an entity?
                     bool isMnemonic = true;
 
                     // is this ampersand introducing a mnemonic or rather an entity?
                     bool isMnemonic = true;

+                    size_t distanceFromEnd = text.end() - source;

                     for (size_t j=0; j < wxMARKUP_ENTITY_MAX; j++)
                     {
                         const wxChar *entity = wxMarkupEntities[wxMARKUP_ELEMENT_NAME][j];
                         size_t entityLen = wxStrlen(entity);
 
                     for (size_t j=0; j < wxMARKUP_ENTITY_MAX; j++)
                     {
                         const wxChar *entity = wxMarkupEntities[wxMARKUP_ELEMENT_NAME][j];
                         size_t entityLen = wxStrlen(entity);
 

-                        if (max - i >= entityLen &&
-                            wxStrncmp(entity, &source[i], entityLen) == 0)
+                        if (distanceFromEnd >= entityLen &&
+                            wxString(source, source + entityLen) == entity)

                         {
                             // replace the &entity; string with the entity reference
                             label << wxMarkupEntities[wxMARKUP_ELEMENT_VALUE][j];
                         {
                             // replace the &entity; string with the entity reference
                             label << wxMarkupEntities[wxMARKUP_ELEMENT_VALUE][j];

-                            
-                            // little exception: when the entity reference is "&"
-                            // (i.e. when entity is "&amp;"), substitute it with &&
-                            // instead of a single ampersand:
+                            // little exception: when the entity reference is
+                            // "&" (i.e. when entity is "&amp;"), substitute it
+                            // with && instead of a single ampersand:

                             if (*wxMarkupEntities[wxMARKUP_ELEMENT_VALUE][j] == wxT('&'))
                                 label << wxT('&');
                             if (*wxMarkupEntities[wxMARKUP_ELEMENT_VALUE][j] == wxT('&'))
                                 label << wxT('&');

-                            i += entityLen - 1;     // the -1 is because main for()
-                                                    // loop already increments i
+                            // the -1 is because main for() loop already
+                            // increments i:
+                            source += entityLen - 1;

                             isMnemonic = false;
                             break;
                         }
                     }
 
                     if (isMnemonic)
                             isMnemonic = false;
                             break;
                         }
                     }
 
                     if (isMnemonic)

-                        label << text[i];
+                        label << *source;

                 }
                 break;
 
 
             default:
                 if (!inside_tag)
                 }
                 break;
 
 
             default:
                 if (!inside_tag)

-                    label << text[i];
+                    label << *source;

         }
     }
 
         }
     }
 


@@ -237,7 +246,8 @@ wxString wxStaticTextBase::EscapeMarkup(const wxString& text)
 {
     wxString ret;
 
 {
     wxString ret;
 

-    for (const wxChar *source = text; *source != wxT('\0'); source++)
+    for (wxString::const_iterator source = text.begin();
+         source != text.end(); ++source)

     {
         bool isEntity = false;
 
     {
         bool isEntity = false;
 


@@ -260,7 +270,6 @@ wxString wxStaticTextBase::EscapeMarkup(const wxString& text)
 }
 
 
 }
 
 

-

 // ----------------------------------------------------------------------------
 // wxStaticTextBase - generic implementation for wxST_ELLIPSIZE_* support
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxStaticTextBase - generic implementation for wxST_ELLIPSIZE_* support
 // ----------------------------------------------------------------------------


@@ -275,7 +284,7 @@ void wxStaticTextBase::UpdateLabel()
     // we need to touch the "real" label (i.e. the text set inside the control,
     // using port-specific functions) instead of the string returned by GetLabel().
     //
     // we need to touch the "real" label (i.e. the text set inside the control,
     // using port-specific functions) instead of the string returned by GetLabel().
     //

-    // In fact, we must be careful not to touch the original label passed to 
+    // In fact, we must be careful not to touch the original label passed to

     // SetLabel() otherwise GetLabel() will behave in a strange way to the user
     // (e.g. returning a "Ver...ing" instead of "Very long string") !
     if (newlabel == DoGetLabel())
     // SetLabel() otherwise GetLabel() will behave in a strange way to the user
     // (e.g. returning a "Ver...ing" instead of "Very long string") !
     if (newlabel == DoGetLabel())


@@ -302,8 +311,6 @@ wxString wxStaticTextBase::GetEllipsizedLabelWithoutMarkup() const
     return ret;
 }
 
     return ret;
 }
 

-#define wxELLIPSE_REPLACEMENT       wxT("...")
-

 wxString wxStaticTextBase::Ellipsize(const wxString& label) const
 {
     wxSize sz(GetSize());
 wxString wxStaticTextBase::Ellipsize(const wxString& label) const
 {
     wxSize sz(GetSize());


@@ -313,168 +320,24 @@ wxString wxStaticTextBase::Ellipsize(const wxString& label) const
         return label;
     }
 
         return label;
     }
 

-    wxClientDC dc(wx_const_cast(wxStaticTextBase*, this));
+    wxClientDC dc(const_cast<wxStaticTextBase*>(this));

     dc.SetFont(GetFont());
 
     dc.SetFont(GetFont());
 

-    wxArrayInt charOffsets;
-    wxString ret;
-
-    // these cannot be cached as they can change because of e.g. a font change
-    int replacementWidth = dc.GetTextExtent(wxELLIPSE_REPLACEMENT).GetWidth();
-    int marginWidth = dc.GetCharWidth()*2;
-
-    // handle correctly labels with newlines
-    wxString curLine;
-    wxSize reqsize;
-    size_t len;
-    for ( const wxChar *pc = label; ; pc++ )
+    wxEllipsizeMode mode;
+    if ( HasFlag(wxST_ELLIPSIZE_START) )
+        mode = wxELLIPSIZE_START;
+    else if ( HasFlag(wxST_ELLIPSIZE_MIDDLE) )
+        mode = wxELLIPSIZE_MIDDLE;
+    else if ( HasFlag(wxST_ELLIPSIZE_END) )
+        mode = wxELLIPSIZE_END;
+    else

     {
     {

-        switch ( *pc )
-        {
-        case _T('\n'):
-        case _T('\0'):
-            len = curLine.length();
-            if (len > 0 &&
-                dc.GetPartialTextExtents(curLine, charOffsets))
-            {
-                wxASSERT(charOffsets.GetCount() == len);
-
-                size_t totalWidth = charOffsets.Last();
-                if ( totalWidth > (size_t)sz.GetWidth() )
-                {
-                    // we need to ellipsize this row
-                    int excessPixels = totalWidth - sz.GetWidth() + 
-                                       replacementWidth +
-                                       marginWidth;     // security margin (NEEDED!)
-
-                    // remove characters in excess
-                    size_t initialChar,     // index of first char to erase
-                           nChars;          // how many chars do we need to erase?
-                    if (HasFlag(wxST_ELLIPSIZE_START))
-                    {
-                        initialChar = 0;
-                        for (nChars=0;
-                             nChars < len && charOffsets[nChars] < excessPixels;
-                             nChars++)
-                            ;
-                    }
-                    else if (HasFlag(wxST_ELLIPSIZE_MIDDLE))
-                    {
-                        // the start & end of the removed span of chars
-                        initialChar = len/2;
-                        size_t endChar = len/2;
-
-                        int removed = 0;
-                        for ( ; removed < excessPixels; )
-                        {
-                            if (initialChar > 0)
-                            {
-                                // width of the initialChar-th character
-                                int width = charOffsets[initialChar] -
-                                            charOffsets[initialChar-1];
-
-                                // remove the initialChar-th character
-                                removed += width;
-                                initialChar--;
-                            }
-
-                            if (endChar < len - 1 &&
-                                removed < excessPixels)
-                            {
-                                // width of the (endChar+1)-th character
-                                int width = charOffsets[endChar+1] -
-                                            charOffsets[endChar];
-
-                                // remove the endChar-th character
-                                removed += width;
-                                endChar++;
-                            }
-
-                            if (initialChar == 0 && endChar == len-1)
-                            {
-                                nChars = len+1;
-                                break;
-                            }
-                        }
-
-                        initialChar++;
-                        nChars = endChar - initialChar + 1;
-                    }
-                    else
-                    {
-                        wxASSERT(HasFlag(wxST_ELLIPSIZE_END));
-                        wxASSERT(len > 0);
-
-                        int maxWidth = totalWidth - excessPixels;
-                        for (initialChar=0; 
-                             initialChar < len && 
-                             charOffsets[initialChar] < maxWidth; 
-                             initialChar++)
-                            ;
+        wxFAIL_MSG( "should only be called if have one of wxST_ELLIPSIZE_XXX" );

 
 

-                        if (initialChar == 0)
-                        {
-                            nChars = len;
-                        }
-                        else
-                        {
-                            initialChar--;      // go back one character 
-                            nChars = len - initialChar;
-                        }
-                    }
-
-                    if (nChars > len)
-                    {
-                        // need to remove the entire row!
-                        curLine.clear();
-                    }
-                    else
-                    {
-                        // erase nChars characters after initialChar (included):
-                        curLine.erase(initialChar, nChars+1);
-
-                        // if there is space for the replacement dots, add them
-                        if (sz.GetWidth() > replacementWidth)
-                            curLine.insert(initialChar, wxELLIPSE_REPLACEMENT);
-                    }
-
-                    // if everything was ok, we should have shortened this line
-                    // enough to make it fit in sz.GetWidth():
-                    wxASSERT(dc.GetTextExtent(curLine).GetWidth() < sz.GetWidth());
-                }
-            }
-
-            // add this (ellipsized) row to the rest of the label
-            ret << curLine << *pc;
-            curLine.clear();
-
-            if ( *pc == _T('\0') )
-                return ret;
-
-            break;
-
-            // we need to remove mnemonics from the label for
-            // correct calculations
-        case _T('&'):
-            // pc+1 is safe: at worst we'll hit the \0
-            if (*(pc+1) == _T('&'))
-                curLine += _T('&');          // && becomes &
-            //else: remove this ampersand
-
-            break;
-
-            // we need also to expand tabs to properly calc their size
-        case _T('\t'):
-            // Windows natively expands the TABs to 6 spaces. Do the same:
-            curLine += wxT("      ");
-            break;
-
-        default:
-            curLine += *pc;
-        }
+        return label;

     }
 
     }
 

-    //return ret;
+    return wxControl::Ellipsize(label, dc, mode, sz.GetWidth());

 }
 
 #endif // wxUSE_STATTEXT
 }
 
 #endif // wxUSE_STATTEXT