src/common/stattextcmn.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/stattextcmn.cpp
// Purpose:     common (to all ports) wxStaticText functions
// Author:      Vadim Zeitlin, Francesco Montorsi
// Created:     2007-01-07 (extracted from dlgcmn.cpp)
// RCS-ID:      $Id$
// Copyright:   (c) 1999-2006 Vadim Zeitlin
//              (c) 2007 Francesco Montorsi
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/private/stattext.h"

#ifndef WX_PRECOMP
    #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

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

    { wxT("&amp;"), wxT("&lt;"), wxT("&gt;"), wxT("&apos;"), wxT("&quot;") },
    { wxT("&"),     wxT("<"),    wxT(">"),    wxT("'"),      wxT("\"")     }
};

#if wxUSE_STATTEXT

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

void wxTextWrapper::Wrap(wxWindow *win, const wxString& text, int widthMax)
{
    wxString line;

    wxString::const_iterator lastSpace = text.end();
    wxString::const_iterator lineStart = text.begin();
    for ( wxString::const_iterator p = lineStart; ; ++p )
    {
        if ( IsStartOfNewLine() )
        {
            OnNewLine();

            lastSpace = text.end();
            line.clear();
            lineStart = p;
        }

        if ( p == text.end() || *p == _T('\n') )
        {
            DoOutputLine(line);

            if ( p == text.end() )
                break;
        }
        else // not EOL
        {
            if ( *p == _T(' ') )
                lastSpace = p;

            line += *p;

            if ( widthMax >= 0 && lastSpace != text.end() )
            {
                int width;
                win->GetTextExtent(line, &width, NULL);

                if ( width > widthMax )
                {
                    // remove the last word from this line
                    line.erase(lastSpace - lineStart, p + 1 - lineStart);
                    DoOutputLine(line);

                    // go back to the last word of this line which we didn't
                    // output yet
                    p = lastSpace;
                }
            }
            //else: no wrapping at all or impossible to wrap
        }
    }
}


// ----------------------------------------------------------------------------
// wxLabelWrapper: helper class for wxStaticTextBase::Wrap()
// ----------------------------------------------------------------------------

class wxLabelWrapper : public wxTextWrapper
{
public:
    void WrapLabel(wxWindow *text, int widthMax)
    {
        m_text.clear();
        Wrap(text, text->GetLabel(), widthMax);
        text->SetLabel(m_text);
    }

protected:
    virtual void OnOutputLine(const wxString& line)
    {
        m_text += line;
    }

    virtual void OnNewLine()
    {
        m_text += _T('\n');
    }

private:
    wxString m_text;
};


// ----------------------------------------------------------------------------
// wxStaticTextBase
// ----------------------------------------------------------------------------

void wxStaticTextBase::Wrap(int width)
{
    wxLabelWrapper wrapper;
    wrapper.WrapLabel(this, width);
}

wxString wxStaticTextBase::GetLabelText() const
{
    wxString ret(GetLabel());

    if (HasFlag(wxST_MARKUP))
        ret = RemoveMarkup(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)
{
    // strip out of "text" the markup for platforms which don't support it natively
    bool inside_tag = false;

    wxString label;
    for ( wxString::const_iterator source = text.begin();
          source != text.end(); ++source )
    {
        switch ( (*source).GetValue() )
        {
            case wxT('<'):
                if (inside_tag)
                {
                    wxLogDebug(wxT("Invalid markup !"));
                    return wxEmptyString;
                }
                inside_tag = true;
                break;

            case wxT('>'):
                if (!inside_tag)
                {
                    wxLogDebug(wxT("Invalid markup !"));
                    return wxEmptyString;
                }
                inside_tag = false;
                break;

            case wxT('&'):
                {
                    if ( source+1 == text.end() )
                    {
                        wxLogDebug(wxT("Cannot use & as last character of the string '%s'"),
                                   text.c_str());
                        return wxEmptyString;
                    }

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

                        if (distanceFromEnd >= entityLen &&
                            wxString(source, source + entityLen) == entity)
                        {
                            // 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:
                            if (*wxMarkupEntities[wxMARKUP_ELEMENT_VALUE][j] == wxT('&'))
                                label << wxT('&');
                            // the -1 is because main for() loop already
                            // increments i:
                            source += entityLen - 1;
                            isMnemonic = false;
                            break;
                        }
                    }

                    if (isMnemonic)
                        label << *source;
                }
                break;


            default:
                if (!inside_tag)
                    label << *source;
        }
    }

    return label;
}

/* static */
wxString wxStaticTextBase::EscapeMarkup(const wxString& text)
{
    wxString ret;

    for (wxString::const_iterator source = text.begin();
         source != text.end(); ++source)
    {
        bool isEntity = false;

        // search in the list of the entities and eventually escape this character
        for (size_t j=0; j < wxMARKUP_ENTITY_MAX; j++)
        {
            if (*source == *wxMarkupEntities[wxMARKUP_ELEMENT_VALUE][j])
            {
                ret << wxMarkupEntities[wxMARKUP_ELEMENT_NAME][j];
                isEntity = true;
                break;
            }
        }

        if (!isEntity)
            ret << *source;     // this character does not need to be escaped
    }

    return ret;
}


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

void wxStaticTextBase::UpdateLabel()
{
    if (!IsEllipsized())
        return;

    wxString newlabel = GetEllipsizedLabelWithoutMarkup();

    // 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
    // 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())
        return;
    DoSetLabel(newlabel);
}

wxString wxStaticTextBase::GetEllipsizedLabelWithoutMarkup() const
{
    // this function should be used only by ports which do not support
    // ellipsis in static texts: we first remove markup (which cannot
    // be handled safely by Ellipsize()) and then ellipsize the result.

    wxString ret(m_labelOrig);

    // the order of the following two blocks is important!

    if (HasFlag(wxST_MARKUP))
        ret = RemoveMarkup(ret);

    if (IsEllipsized())
        ret = Ellipsize(ret);

    return ret;
}

#define wxELLIPSE_REPLACEMENT       wxT("...")

wxString wxStaticTextBase::Ellipsize(const wxString& label) const
{
    wxSize sz(GetSize());
    if (sz.GetWidth() < 2 || sz.GetHeight() < 2)
    {
        // the size of this window is not valid (yet)
        return label;
    }

    wxClientDC dc(const_cast<wxStaticTextBase*>(this));
    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 ( wxString::const_iterator pc = label.begin(); ; ++pc )
    {
        if ( pc == label.end() || *pc == _T('\n') )
        {
            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++)
                            ;

                        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;
            if ( pc == label.end() )
            {
                return ret;
            }
            else
            {
                ret << *pc;
                curLine.clear();
            }
        }
        // we need to remove mnemonics from the label for correct calculations
        else if ( *pc == _T('&') )
        {
            // pc+1 is safe: at worst we'll be at end()
            wxString::const_iterator next = pc + 1;
            if ( next != label.end() && *next == _T('&') )
                curLine += _T('&');          // && becomes &
            //else: remove this ampersand
        }
        // we need also to expand tabs to properly calc their size
        else if ( *pc == _T('\t') )
        {
            // Windows natively expands the TABs to 6 spaces. Do the same:
            curLine += wxT("      ");
        }
        else
        {
            curLine += *pc;
        }
    }

    //return ret;
}

#endif // wxUSE_STATTEXT
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/stattextcmn.cpp
	3	// Purpose: common (to all ports) wxStaticText functions
	4	// Author: Vadim Zeitlin, Francesco Montorsi
	5	// Created: 2007-01-07 (extracted from dlgcmn.cpp)
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 1999-2006 Vadim Zeitlin
	8	// (c) 2007 Francesco Montorsi
	9	// Licence: 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	#include "wx/private/stattext.h"
	28
	29	#ifndef WX_PRECOMP
	30	#include "wx/button.h"
	31	#include "wx/dcclient.h"
	32	#include "wx/intl.h"
	33	#include "wx/log.h"
	34	#include "wx/settings.h"
	35	#include "wx/stattext.h"
	36	#include "wx/sizer.h"
	37	#include "wx/containr.h"
	38	#endif
	39
	40	const wxChar *wxMarkupEntities[][wxMARKUP_ENTITY_MAX] =
	41	{
	42	// the entities handled by SetLabel() when wxST_MARKUP is used and their referenced string
	43
	44	{ wxT("&"), wxT("<"), wxT(">"), wxT("'"), wxT(""") },
	45	{ wxT("&"), wxT("<"), wxT(">"), wxT("'"), wxT("\"") }
	46	};
	47
	48	#if wxUSE_STATTEXT
	49
	50	// ----------------------------------------------------------------------------
	51	// wxTextWrapper
	52	// ----------------------------------------------------------------------------
	53
	54	void wxTextWrapper::Wrap(wxWindow *win, const wxString& text, int widthMax)
	55	{
	56	wxString line;
	57
	58	wxString::const_iterator lastSpace = text.end();
	59	wxString::const_iterator lineStart = text.begin();
	60	for ( wxString::const_iterator p = lineStart; ; ++p )
	61	{
	62	if ( IsStartOfNewLine() )
	63	{
	64	OnNewLine();
	65
	66	lastSpace = text.end();
	67	line.clear();
	68	lineStart = p;
	69	}
	70
	71	if ( p == text.end() \|\| *p == _T('\n') )
	72	{
	73	DoOutputLine(line);
	74
	75	if ( p == text.end() )
	76	break;
	77	}
	78	else // not EOL
	79	{
	80	if ( *p == _T(' ') )
	81	lastSpace = p;
	82
	83	line += *p;
	84
	85	if ( widthMax >= 0 && lastSpace != text.end() )
	86	{
	87	int width;
	88	win->GetTextExtent(line, &width, NULL);
	89
	90	if ( width > widthMax )
	91	{
	92	// remove the last word from this line
	93	line.erase(lastSpace - lineStart, p + 1 - lineStart);
	94	DoOutputLine(line);
	95
	96	// go back to the last word of this line which we didn't
	97	// output yet
	98	p = lastSpace;
	99	}
	100	}
	101	//else: no wrapping at all or impossible to wrap
	102	}
	103	}
	104	}
	105
	106
	107	// ----------------------------------------------------------------------------
	108	// wxLabelWrapper: helper class for wxStaticTextBase::Wrap()
	109	// ----------------------------------------------------------------------------
	110
	111	class wxLabelWrapper : public wxTextWrapper
	112	{
	113	public:
	114	void WrapLabel(wxWindow *text, int widthMax)
	115	{
	116	m_text.clear();
	117	Wrap(text, text->GetLabel(), widthMax);
	118	text->SetLabel(m_text);
	119	}
	120
	121	protected:
	122	virtual void OnOutputLine(const wxString& line)
	123	{
	124	m_text += line;
	125	}
	126
	127	virtual void OnNewLine()
	128	{
	129	m_text += _T('\n');
	130	}
	131
	132	private:
	133	wxString m_text;
	134	};
	135
	136
	137	// ----------------------------------------------------------------------------
	138	// wxStaticTextBase
	139	// ----------------------------------------------------------------------------
	140
	141	void wxStaticTextBase::Wrap(int width)
	142	{
	143	wxLabelWrapper wrapper;
	144	wrapper.WrapLabel(this, width);
	145	}
	146
	147	wxString wxStaticTextBase::GetLabelText() const
	148	{
	149	wxString ret(GetLabel());
	150
	151	if (HasFlag(wxST_MARKUP))
	152	ret = RemoveMarkup(ret);
	153	return RemoveMnemonics(ret);
	154	}
	155
	156	/static/
	157	wxString wxStaticTextBase::GetLabelText(const wxString& label)
	158	{
	159	// remove markup
	160	wxString ret = RemoveMarkup(label);
	161	return RemoveMnemonics(ret);
	162	}
	163
	164	/static/
	165	wxString wxStaticTextBase::RemoveMarkup(const wxString& text)
	166	{
	167	// strip out of "text" the markup for platforms which don't support it natively
	168	bool inside_tag = false;
	169
	170	wxString label;
	171	for ( wxString::const_iterator source = text.begin();
	172	source != text.end(); ++source )
	173	{
	174	switch ( (*source).GetValue() )
	175	{
	176	case wxT('<'):
	177	if (inside_tag)
	178	{
	179	wxLogDebug(wxT("Invalid markup !"));
	180	return wxEmptyString;
	181	}
	182	inside_tag = true;
	183	break;
	184
	185	case wxT('>'):
	186	if (!inside_tag)
	187	{
	188	wxLogDebug(wxT("Invalid markup !"));
	189	return wxEmptyString;
	190	}
	191	inside_tag = false;
	192	break;
	193
	194	case wxT('&'):
	195	{
	196	if ( source+1 == text.end() )
	197	{
	198	wxLogDebug(wxT("Cannot use & as last character of the string '%s'"),
	199	text.c_str());
	200	return wxEmptyString;
	201	}
	202
	203	// is this ampersand introducing a mnemonic or rather an entity?
	204	bool isMnemonic = true;
	205	size_t distanceFromEnd = text.end() - source;
	206	for (size_t j=0; j < wxMARKUP_ENTITY_MAX; j++)
	207	{
	208	const wxChar *entity = wxMarkupEntities[wxMARKUP_ELEMENT_NAME][j];
	209	size_t entityLen = wxStrlen(entity);
	210
	211	if (distanceFromEnd >= entityLen &&
	212	wxString(source, source + entityLen) == entity)
	213	{
	214	// replace the &entity; string with the entity reference
	215	label << wxMarkupEntities[wxMARKUP_ELEMENT_VALUE][j];
	216	// little exception: when the entity reference is
	217	// "&" (i.e. when entity is "&"), substitute it
	218	// with && instead of a single ampersand:
	219	if (*wxMarkupEntities[wxMARKUP_ELEMENT_VALUE][j] == wxT('&'))
	220	label << wxT('&');
	221	// the -1 is because main for() loop already
	222	// increments i:
	223	source += entityLen - 1;
	224	isMnemonic = false;
	225	break;
	226	}
	227	}
	228
	229	if (isMnemonic)
	230	label << *source;
	231	}
	232	break;
	233
	234
	235	default:
	236	if (!inside_tag)
	237	label << *source;
	238	}
	239	}
	240
	241	return label;
	242	}
	243
	244	/* static */
	245	wxString wxStaticTextBase::EscapeMarkup(const wxString& text)
	246	{
	247	wxString ret;
	248
	249	for (wxString::const_iterator source = text.begin();
	250	source != text.end(); ++source)
	251	{
	252	bool isEntity = false;
	253
	254	// search in the list of the entities and eventually escape this character
	255	for (size_t j=0; j < wxMARKUP_ENTITY_MAX; j++)
	256	{
	257	if (source == wxMarkupEntities[wxMARKUP_ELEMENT_VALUE][j])
	258	{
	259	ret << wxMarkupEntities[wxMARKUP_ELEMENT_NAME][j];
	260	isEntity = true;
	261	break;
	262	}
	263	}
	264
	265	if (!isEntity)
	266	ret << *source; // this character does not need to be escaped
	267	}
	268
	269	return ret;
	270	}
	271
	272
	273
	274	// ----------------------------------------------------------------------------
	275	// wxStaticTextBase - generic implementation for wxST_ELLIPSIZE_* support
	276	// ----------------------------------------------------------------------------
	277
	278	void wxStaticTextBase::UpdateLabel()
	279	{
	280	if (!IsEllipsized())
	281	return;
	282
	283	wxString newlabel = GetEllipsizedLabelWithoutMarkup();
	284
	285	// we need to touch the "real" label (i.e. the text set inside the control,
	286	// using port-specific functions) instead of the string returned by GetLabel().
	287	//
	288	// In fact, we must be careful not to touch the original label passed to
	289	// SetLabel() otherwise GetLabel() will behave in a strange way to the user
	290	// (e.g. returning a "Ver...ing" instead of "Very long string") !
	291	if (newlabel == DoGetLabel())
	292	return;
	293	DoSetLabel(newlabel);
	294	}
	295
	296	wxString wxStaticTextBase::GetEllipsizedLabelWithoutMarkup() const
	297	{
	298	// this function should be used only by ports which do not support
	299	// ellipsis in static texts: we first remove markup (which cannot
	300	// be handled safely by Ellipsize()) and then ellipsize the result.
	301
	302	wxString ret(m_labelOrig);
	303
	304	// the order of the following two blocks is important!
	305
	306	if (HasFlag(wxST_MARKUP))
	307	ret = RemoveMarkup(ret);
	308
	309	if (IsEllipsized())
	310	ret = Ellipsize(ret);
	311
	312	return ret;
	313	}
	314
	315	#define wxELLIPSE_REPLACEMENT wxT("...")
	316
	317	wxString wxStaticTextBase::Ellipsize(const wxString& label) const
	318	{
	319	wxSize sz(GetSize());
	320	if (sz.GetWidth() < 2 \|\| sz.GetHeight() < 2)
	321	{
	322	// the size of this window is not valid (yet)
	323	return label;
	324	}
	325
	326	wxClientDC dc(const_cast<wxStaticTextBase*>(this));
	327	dc.SetFont(GetFont());
	328
	329	wxArrayInt charOffsets;
	330	wxString ret;
	331
	332	// these cannot be cached as they can change because of e.g. a font change
	333	int replacementWidth = dc.GetTextExtent(wxELLIPSE_REPLACEMENT).GetWidth();
	334	int marginWidth = dc.GetCharWidth()*2;
	335
	336	// handle correctly labels with newlines
	337	wxString curLine;
	338	wxSize reqsize;
	339	size_t len;
	340	for ( wxString::const_iterator pc = label.begin(); ; ++pc )
	341	{
	342	if ( pc == label.end() \|\| *pc == _T('\n') )
	343	{
	344	len = curLine.length();
	345	if (len > 0 &&
	346	dc.GetPartialTextExtents(curLine, charOffsets))
	347	{
	348	wxASSERT(charOffsets.GetCount() == len);
	349
	350	size_t totalWidth = charOffsets.Last();
	351	if ( totalWidth > (size_t)sz.GetWidth() )
	352	{
	353	// we need to ellipsize this row
	354	int excessPixels = totalWidth - sz.GetWidth() +
	355	replacementWidth +
	356	marginWidth; // security margin (NEEDED!)
	357
	358	// remove characters in excess
	359	size_t initialChar, // index of first char to erase
	360	nChars; // how many chars do we need to erase?
	361	if (HasFlag(wxST_ELLIPSIZE_START))
	362	{
	363	initialChar = 0;
	364	for (nChars=0;
	365	nChars < len && charOffsets[nChars] < excessPixels;
	366	nChars++)
	367	;
	368	}
	369	else if (HasFlag(wxST_ELLIPSIZE_MIDDLE))
	370	{
	371	// the start & end of the removed span of chars
	372	initialChar = len/2;
	373	size_t endChar = len/2;
	374
	375	int removed = 0;
	376	for ( ; removed < excessPixels; )
	377	{
	378	if (initialChar > 0)
	379	{
	380	// width of the initialChar-th character
	381	int width = charOffsets[initialChar] -
	382	charOffsets[initialChar-1];
	383
	384	// remove the initialChar-th character
	385	removed += width;
	386	initialChar--;
	387	}
	388
	389	if (endChar < len - 1 &&
	390	removed < excessPixels)
	391	{
	392	// width of the (endChar+1)-th character
	393	int width = charOffsets[endChar+1] -
	394	charOffsets[endChar];
	395
	396	// remove the endChar-th character
	397	removed += width;
	398	endChar++;
	399	}
	400
	401	if (initialChar == 0 && endChar == len-1)
	402	{
	403	nChars = len+1;
	404	break;
	405	}
	406	}
	407
	408	initialChar++;
	409	nChars = endChar - initialChar + 1;
	410	}
	411	else
	412	{
	413	wxASSERT(HasFlag(wxST_ELLIPSIZE_END));
	414	wxASSERT(len > 0);
	415
	416	int maxWidth = totalWidth - excessPixels;
	417	for (initialChar=0;
	418	initialChar < len &&
	419	charOffsets[initialChar] < maxWidth;
	420	initialChar++)
	421	;
	422
	423	if (initialChar == 0)
	424	{
	425	nChars = len;
	426	}
	427	else
	428	{
	429	initialChar--; // go back one character
	430	nChars = len - initialChar;
	431	}
	432	}
	433
	434	if (nChars > len)
	435	{
	436	// need to remove the entire row!
	437	curLine.clear();
	438	}
	439	else
	440	{
	441	// erase nChars characters after initialChar (included):
	442	curLine.erase(initialChar, nChars+1);
	443
	444	// if there is space for the replacement dots, add them
	445	if (sz.GetWidth() > replacementWidth)
	446	curLine.insert(initialChar, wxELLIPSE_REPLACEMENT);
	447	}
	448
	449	// if everything was ok, we should have shortened this line
	450	// enough to make it fit in sz.GetWidth():
	451	wxASSERT(dc.GetTextExtent(curLine).GetWidth() < sz.GetWidth());
	452	}
	453	}
	454
	455	// add this (ellipsized) row to the rest of the label
	456	ret << curLine;
	457	if ( pc == label.end() )
	458	{
	459	return ret;
	460	}
	461	else
	462	{
	463	ret << *pc;
	464	curLine.clear();
	465	}
	466	}
	467	// we need to remove mnemonics from the label for correct calculations
	468	else if ( *pc == _T('&') )
	469	{
	470	// pc+1 is safe: at worst we'll be at end()
	471	wxString::const_iterator next = pc + 1;
	472	if ( next != label.end() && *next == _T('&') )
	473	curLine += _T('&'); // && becomes &
	474	//else: remove this ampersand
	475	}
	476	// we need also to expand tabs to properly calc their size
	477	else if ( *pc == _T('\t') )
	478	{
	479	// Windows natively expands the TABs to 6 spaces. Do the same:
	480	curLine += wxT(" ");
	481	}
	482	else
	483	{
	484	curLine += *pc;
	485	}
	486	}
	487
	488	//return ret;
	489	}
	490
	491	#endif // wxUSE_STATTEXT