src/mac/carbon/tooltip.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        tooltip.cpp
// Purpose:     wxToolTip implementation
// Author:      Stefan Csomor
// Id:          $Id$
// Copyright:   (c) Stefan Csomor
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
    #pragma implementation "tooltip.h"
#endif

#include "wx/wxprec.h"

#if wxUSE_TOOLTIPS

#include "wx/app.h"
#include "wx/dc.h"
#include "wx/window.h"
#include "wx/tooltip.h"
#include "wx/timer.h"
#include "wx/geometry.h"
#include "wx/mac/uma.h"

//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------

class wxMacToolTipTimer ;

class wxMacToolTip
{
    public :
        wxMacToolTip( ) ;
        ~wxMacToolTip() ;

        void            Setup( WindowRef window  , const wxString& text , wxPoint localPosition ) ;
        long            GetMark() { return m_mark ; }
        void             Draw() ;
        void            Clear() ;
        bool            IsShown() { return m_shown  ; }
    private :

        wxString    m_label ;
        wxPoint m_position ;
        Rect            m_rect ;
        WindowRef    m_window ;
        PicHandle    m_backpict ;
        bool        m_shown ;
        long        m_mark ;
        wxMacToolTipTimer* m_timer ;
#if TARGET_CARBON
        wxMacCFStringHolder m_helpTextRef ;
#endif
} ;

class wxMacToolTipTimer : public wxTimer
{
public:
    wxMacToolTipTimer() {} ;
    wxMacToolTipTimer(wxMacToolTip* tip, int iMilliseconds) ;
    virtual ~wxMacToolTipTimer() {} ;
    void Notify()
    {
        if ( m_mark == m_tip->GetMark() )
            m_tip->Draw() ;
    }
protected:
    wxMacToolTip*     m_tip;
    long        m_mark ;
};

//-----------------------------------------------------------------------------
// wxToolTip
//-----------------------------------------------------------------------------
static long s_ToolTipDelay = 500 ;
static bool s_ShowToolTips = true ;
static wxMacToolTip s_ToolTip ;
static wxWindow* s_LastWindowEntered = NULL ;
static wxRect2DInt s_ToolTipArea ;
static WindowRef s_ToolTipWindowRef = NULL ;

IMPLEMENT_ABSTRACT_CLASS(wxToolTip, wxObject)

wxToolTip::wxToolTip( const wxString &tip )
{
    m_text = tip;
    m_window = (wxWindow*) NULL;
}

wxToolTip::~wxToolTip()
{
}

void wxToolTip::SetTip( const wxString &tip )
{
    m_text = tip;

    if ( m_window )
    {
    /*
    // update it immediately
    wxToolInfo ti(GetHwndOf(m_window));
    ti.lpszText = (wxChar *)m_text.c_str();

      (void)SendTooltipMessage(GetToolTipCtrl(), TTM_UPDATETIPTEXT, 0, &ti);
        */
    }
}

void wxToolTip::SetWindow( wxWindow *win )
{
    m_window = win ;
}

void wxToolTip::Enable( bool flag )
{
    if ( s_ShowToolTips != flag )
    {
        s_ShowToolTips = flag ;
        if ( s_ShowToolTips )
        {
        }
        else
        {
            s_ToolTip.Clear() ;
        }
    }
}

void wxToolTip::SetDelay( long msecs )
{
    s_ToolTipDelay = msecs ;
}

void wxToolTip::RelayEvent( wxWindow *win , wxMouseEvent &event )
{
    if ( s_ShowToolTips )
    {
        if ( event.GetEventType() == wxEVT_LEAVE_WINDOW )
        {
            s_ToolTip.Clear() ;
        }
        else if (event.GetEventType() == wxEVT_ENTER_WINDOW || event.GetEventType() == wxEVT_MOTION )
        {
            wxPoint2DInt where( event.m_x , event.m_y ) ;
            if ( s_LastWindowEntered == win && s_ToolTipArea.Contains( where ) )
            {
            }
            else
            {
                s_ToolTip.Clear() ;
                s_ToolTipArea = wxRect2DInt( event.m_x - 2 , event.m_y - 2 , 4 , 4 ) ;
                s_LastWindowEntered = win ;

                WindowRef window = MAC_WXHWND( win->MacGetTopLevelWindowRef() ) ;
                int x = event.m_x ;
                int y = event.m_y ;
                wxPoint local( x , y ) ;
                win->MacClientToRootWindow( &x, &y ) ;
                wxPoint windowlocal( x , y ) ;
                s_ToolTip.Setup( window , win->MacGetToolTipString( local ) , windowlocal ) ;
            }
        }
    }
}

void wxToolTip::RemoveToolTips()
{
    s_ToolTip.Clear() ;
}
// --- mac specific

wxMacToolTipTimer::wxMacToolTipTimer( wxMacToolTip *tip , int msec )
{
    m_tip = tip;
    m_mark = tip->GetMark() ;
    Start(msec, true);
}

wxMacToolTip::wxMacToolTip()
{
    m_window = NULL ;
    m_backpict = NULL ;
    m_mark = 0 ;
    m_shown = false ;
    m_timer = NULL ;
}

void wxMacToolTip::Setup( WindowRef win  , const wxString& text , wxPoint localPosition )
{
    m_mark++ ;
    Clear() ;
    m_position = localPosition ;
    m_label = text ;
    m_window =win;
    s_ToolTipWindowRef = m_window ;
    m_backpict = NULL ;
    if ( m_timer )
        delete m_timer ;
    m_timer = new wxMacToolTipTimer( this , s_ToolTipDelay ) ;
}

wxMacToolTip::~wxMacToolTip()
{
    if ( m_timer ) {
        delete m_timer ;
        m_timer = NULL;
    }
    if ( m_backpict )
        Clear() ;
}

const short kTipBorder = 2 ;
const short kTipOffset = 5 ;

void wxMacToolTip::Draw()
{
    if ( m_label.Length() == 0 )
        return ;

    if ( m_window == s_ToolTipWindowRef )
    {
        m_shown = true ;
#if TARGET_CARBON
        HMHelpContentRec tag ;
        tag.version = kMacHelpVersion;
        SetRect( &tag.absHotRect , m_position.x - 2 , m_position.y - 2 , m_position.x + 2 , m_position.y + 2 ) ;

        QDLocalToGlobalRect( GetWindowPort( m_window ) , &tag.absHotRect ) ;

        m_helpTextRef.Assign( m_label  , wxFONTENCODING_DEFAULT ) ;
        tag.content[kHMMinimumContentIndex].contentType = kHMCFStringContent ;
        tag.content[kHMMinimumContentIndex].u.tagCFString = m_helpTextRef ;
        tag.content[kHMMaximumContentIndex].contentType = kHMCFStringContent ;
        tag.content[kHMMaximumContentIndex].u.tagCFString = m_helpTextRef ;
        tag.tagSide = kHMDefaultSide;
        HMDisplayTag( &tag );
#else
        wxMacPortStateHelper help( (GrafPtr) GetWindowPort( m_window ) );
        FontFamilyID fontId ;
        Str255 fontName ;
        SInt16 fontSize ;
        Style fontStyle ;
        GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
        GetFNum( fontName, &fontId );

        TextFont( fontId ) ;
        TextSize( fontSize ) ;
        TextFace( fontStyle ) ;
        FontInfo fontInfo;
        ::GetFontInfo(&fontInfo);
        short lineh = fontInfo.ascent + fontInfo.descent + fontInfo.leading;
        short height = 0 ;

        int i = 0 ;
        int length = m_label.Length() ;
        int width = 0 ;
        int thiswidth = 0 ;
        int laststop = 0 ;
        wxCharBuffer text = m_label.mb_str( wxConvLocal)  ;

        while( i < length )
        {
            if( text[i] == 13 || text[i] == 10)
            {
                thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
                if ( thiswidth > width )
                    width = thiswidth ;

                height += lineh ;
                laststop = i+1 ;
            }
            i++ ;
        }
        if ( i - laststop > 0 )
        {
            thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
            if ( thiswidth > width )
                width = thiswidth ;
            height += lineh ;
        }

        m_rect.left = m_position.x + kTipOffset;
        m_rect.top = m_position.y + kTipOffset;
        m_rect.right = m_rect.left + width + 2 * kTipBorder;

        m_rect.bottom = m_rect.top + height + 2 * kTipBorder;
        Rect r ;
        GetPortBounds( GetWindowPort( m_window ) , &r ) ;
        if ( m_rect.top < 0 )
        {
            m_rect.bottom += -m_rect.top ;
            m_rect.top = 0 ;
        }
        if ( m_rect.left < 0 )
        {
            m_rect.right += -m_rect.left ;
            m_rect.left = 0 ;
        }
        if ( m_rect.right > r.right )
        {
            m_rect.left -= (m_rect.right - r.right ) ;
            m_rect.right = r.right ;
        }
        if ( m_rect.bottom > r.bottom )
        {
            m_rect.top -= (m_rect.bottom - r.bottom) ;
            m_rect.bottom = r.bottom ;
        }
        ClipRect( &m_rect ) ;
        BackColor( whiteColor ) ;
        ForeColor(blackColor ) ;
        GWorldPtr port ;
        NewGWorld( &port , wxDisplayDepth() , &m_rect , NULL , NULL , 0 ) ;
        CGrafPtr    origPort ;
        GDHandle    origDevice ;

        GetGWorld( &origPort , &origDevice ) ;
        SetGWorld( port , NULL ) ;

        m_backpict = OpenPicture(&m_rect);

        CopyBits(GetPortBitMapForCopyBits(GetWindowPort(m_window)),
            GetPortBitMapForCopyBits(port),
            &m_rect,
            &m_rect,
            srcCopy,
            NULL);
        ClosePicture();
        SetGWorld( origPort , origDevice ) ;
        DisposeGWorld( port ) ;
        PenNormal() ;

        RGBColor tooltipbackground = { 0xFFFF , 0xFFFF , 0xC000 } ;
        BackColor( whiteColor ) ;
        RGBForeColor( &tooltipbackground ) ;

        PaintRect( &m_rect ) ;
        ForeColor(blackColor ) ;
        FrameRect( &m_rect ) ;
        SetThemeTextColor(kThemeTextColorNotification,wxDisplayDepth(),true) ;
        ::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder);

        i = 0 ;
        laststop = 0 ;
        height = 0 ;

        while( i < length )
        {
            if( text[i] == 13 || text[i] == 10)
            {
                ::DrawText( text , laststop , i - laststop ) ;
                height += lineh ;
                ::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder + height );
                laststop = i+1 ;
            }
            i++ ;
        }
        ::DrawText( text , laststop , i - laststop ) ;
        ::TextMode( srcOr ) ;
#endif
    }
}

void wxToolTip::NotifyWindowDelete( WXHWND win )
{
    if ( win == s_ToolTipWindowRef )
    {
        s_ToolTipWindowRef = NULL ;
    }
}

void wxMacToolTip::Clear()
{
    m_mark++ ;
    if ( m_timer )
    {
        delete m_timer ;
        m_timer = NULL ;
    }
    if ( !m_shown )
        return ;
#if TARGET_CARBON
    HMHideTag() ;
    m_helpTextRef.Release() ;
#else
    if ( m_window == s_ToolTipWindowRef && m_backpict )
    {
        wxMacPortStateHelper help( (GrafPtr) GetWindowPort(m_window) ) ;

        m_shown = false ;

        BackColor( whiteColor ) ;
        ForeColor(blackColor ) ;
        DrawPicture(m_backpict, &m_rect);
        KillPicture(m_backpict);
        m_backpict = NULL ;
    }
#endif
}

#endif
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: tooltip.cpp
	3	// Purpose: wxToolTip implementation
	4	// Author: Stefan Csomor
	5	// Id: $Id$
	6	// Copyright: (c) Stefan Csomor
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	11	#pragma implementation "tooltip.h"
	12	#endif
	13
	14	#include "wx/wxprec.h"
	15
	16	#if wxUSE_TOOLTIPS
	17
	18	#include "wx/app.h"
	19	#include "wx/dc.h"
	20	#include "wx/window.h"
	21	#include "wx/tooltip.h"
	22	#include "wx/timer.h"
	23	#include "wx/geometry.h"
	24	#include "wx/mac/uma.h"
	25
	26	//-----------------------------------------------------------------------------
	27	// global data
	28	//-----------------------------------------------------------------------------
	29
	30	class wxMacToolTipTimer ;
	31
	32	class wxMacToolTip
	33	{
	34	public :
	35	wxMacToolTip( ) ;
	36	~wxMacToolTip() ;
	37
	38	void Setup( WindowRef window , const wxString& text , wxPoint localPosition ) ;
	39	long GetMark() { return m_mark ; }
	40	void Draw() ;
	41	void Clear() ;
	42	bool IsShown() { return m_shown ; }
	43	private :
	44
	45	wxString m_label ;
	46	wxPoint m_position ;
	47	Rect m_rect ;
	48	WindowRef m_window ;
	49	PicHandle m_backpict ;
	50	bool m_shown ;
	51	long m_mark ;
	52	wxMacToolTipTimer* m_timer ;
	53	#if TARGET_CARBON
	54	wxMacCFStringHolder m_helpTextRef ;
	55	#endif
	56	} ;
	57
	58	class wxMacToolTipTimer : public wxTimer
	59	{
	60	public:
	61	wxMacToolTipTimer() {} ;
	62	wxMacToolTipTimer(wxMacToolTip* tip, int iMilliseconds) ;
	63	virtual ~wxMacToolTipTimer() {} ;
	64	void Notify()
	65	{
	66	if ( m_mark == m_tip->GetMark() )
	67	m_tip->Draw() ;
	68	}
	69	protected:
	70	wxMacToolTip* m_tip;
	71	long m_mark ;
	72	};
	73
	74	//-----------------------------------------------------------------------------
	75	// wxToolTip
	76	//-----------------------------------------------------------------------------
	77	static long s_ToolTipDelay = 500 ;
	78	static bool s_ShowToolTips = true ;
	79	static wxMacToolTip s_ToolTip ;
	80	static wxWindow* s_LastWindowEntered = NULL ;
	81	static wxRect2DInt s_ToolTipArea ;
	82	static WindowRef s_ToolTipWindowRef = NULL ;
	83
	84	IMPLEMENT_ABSTRACT_CLASS(wxToolTip, wxObject)
	85
	86	wxToolTip::wxToolTip( const wxString &tip )
	87	{
	88	m_text = tip;
	89	m_window = (wxWindow*) NULL;
	90	}
	91
	92	wxToolTip::~wxToolTip()
	93	{
	94	}
	95
	96	void wxToolTip::SetTip( const wxString &tip )
	97	{
	98	m_text = tip;
	99
	100	if ( m_window )
	101	{
	102	/*
	103	// update it immediately
	104	wxToolInfo ti(GetHwndOf(m_window));
	105	ti.lpszText = (wxChar *)m_text.c_str();
	106
	107	(void)SendTooltipMessage(GetToolTipCtrl(), TTM_UPDATETIPTEXT, 0, &ti);
	108	*/
	109	}
	110	}
	111
	112	void wxToolTip::SetWindow( wxWindow *win )
	113	{
	114	m_window = win ;
	115	}
	116
	117	void wxToolTip::Enable( bool flag )
	118	{
	119	if ( s_ShowToolTips != flag )
	120	{
	121	s_ShowToolTips = flag ;
	122	if ( s_ShowToolTips )
	123	{
	124	}
	125	else
	126	{
	127	s_ToolTip.Clear() ;
	128	}
	129	}
	130	}
	131
	132	void wxToolTip::SetDelay( long msecs )
	133	{
	134	s_ToolTipDelay = msecs ;
	135	}
	136
	137	void wxToolTip::RelayEvent( wxWindow *win , wxMouseEvent &event )
	138	{
	139	if ( s_ShowToolTips )
	140	{
	141	if ( event.GetEventType() == wxEVT_LEAVE_WINDOW )
	142	{
	143	s_ToolTip.Clear() ;
	144	}
	145	else if (event.GetEventType() == wxEVT_ENTER_WINDOW \|\| event.GetEventType() == wxEVT_MOTION )
	146	{
	147	wxPoint2DInt where( event.m_x , event.m_y ) ;
	148	if ( s_LastWindowEntered == win && s_ToolTipArea.Contains( where ) )
	149	{
	150	}
	151	else
	152	{
	153	s_ToolTip.Clear() ;
	154	s_ToolTipArea = wxRect2DInt( event.m_x - 2 , event.m_y - 2 , 4 , 4 ) ;
	155	s_LastWindowEntered = win ;
	156
	157	WindowRef window = MAC_WXHWND( win->MacGetTopLevelWindowRef() ) ;
	158	int x = event.m_x ;
	159	int y = event.m_y ;
	160	wxPoint local( x , y ) ;
	161	win->MacClientToRootWindow( &x, &y ) ;
	162	wxPoint windowlocal( x , y ) ;
	163	s_ToolTip.Setup( window , win->MacGetToolTipString( local ) , windowlocal ) ;
	164	}
	165	}
	166	}
	167	}
	168
	169	void wxToolTip::RemoveToolTips()
	170	{
	171	s_ToolTip.Clear() ;
	172	}
	173	// --- mac specific
	174
	175	wxMacToolTipTimer::wxMacToolTipTimer( wxMacToolTip *tip , int msec )
	176	{
	177	m_tip = tip;
	178	m_mark = tip->GetMark() ;
	179	Start(msec, true);
	180	}
	181
	182	wxMacToolTip::wxMacToolTip()
	183	{
	184	m_window = NULL ;
	185	m_backpict = NULL ;
	186	m_mark = 0 ;
	187	m_shown = false ;
	188	m_timer = NULL ;
	189	}
	190
	191	void wxMacToolTip::Setup( WindowRef win , const wxString& text , wxPoint localPosition )
	192	{
	193	m_mark++ ;
	194	Clear() ;
	195	m_position = localPosition ;
	196	m_label = text ;
	197	m_window =win;
	198	s_ToolTipWindowRef = m_window ;
	199	m_backpict = NULL ;
	200	if ( m_timer )
	201	delete m_timer ;
	202	m_timer = new wxMacToolTipTimer( this , s_ToolTipDelay ) ;
	203	}
	204
	205	wxMacToolTip::~wxMacToolTip()
	206	{
	207	if ( m_timer ) {
	208	delete m_timer ;
	209	m_timer = NULL;
	210	}
	211	if ( m_backpict )
	212	Clear() ;
	213	}
	214
	215	const short kTipBorder = 2 ;
	216	const short kTipOffset = 5 ;
	217
	218	void wxMacToolTip::Draw()
	219	{
	220	if ( m_label.Length() == 0 )
	221	return ;
	222
	223	if ( m_window == s_ToolTipWindowRef )
	224	{
	225	m_shown = true ;
	226	#if TARGET_CARBON
	227	HMHelpContentRec tag ;
	228	tag.version = kMacHelpVersion;
	229	SetRect( &tag.absHotRect , m_position.x - 2 , m_position.y - 2 , m_position.x + 2 , m_position.y + 2 ) ;
	230
	231	QDLocalToGlobalRect( GetWindowPort( m_window ) , &tag.absHotRect ) ;
	232
	233	m_helpTextRef.Assign( m_label , wxFONTENCODING_DEFAULT ) ;
	234	tag.content[kHMMinimumContentIndex].contentType = kHMCFStringContent ;
	235	tag.content[kHMMinimumContentIndex].u.tagCFString = m_helpTextRef ;
	236	tag.content[kHMMaximumContentIndex].contentType = kHMCFStringContent ;
	237	tag.content[kHMMaximumContentIndex].u.tagCFString = m_helpTextRef ;
	238	tag.tagSide = kHMDefaultSide;
	239	HMDisplayTag( &tag );
	240	#else
	241	wxMacPortStateHelper help( (GrafPtr) GetWindowPort( m_window ) );
	242	FontFamilyID fontId ;
	243	Str255 fontName ;
	244	SInt16 fontSize ;
	245	Style fontStyle ;
	246	GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
	247	GetFNum( fontName, &fontId );
	248
	249	TextFont( fontId ) ;
	250	TextSize( fontSize ) ;
	251	TextFace( fontStyle ) ;
	252	FontInfo fontInfo;
	253	::GetFontInfo(&fontInfo);
	254	short lineh = fontInfo.ascent + fontInfo.descent + fontInfo.leading;
	255	short height = 0 ;
	256
	257	int i = 0 ;
	258	int length = m_label.Length() ;
	259	int width = 0 ;
	260	int thiswidth = 0 ;
	261	int laststop = 0 ;
	262	wxCharBuffer text = m_label.mb_str( wxConvLocal) ;
	263
	264	while( i < length )
	265	{
	266	if( text[i] == 13 \|\| text[i] == 10)
	267	{
	268	thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
	269	if ( thiswidth > width )
	270	width = thiswidth ;
	271
	272	height += lineh ;
	273	laststop = i+1 ;
	274	}
	275	i++ ;
	276	}
	277	if ( i - laststop > 0 )
	278	{
	279	thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
	280	if ( thiswidth > width )
	281	width = thiswidth ;
	282	height += lineh ;
	283	}
	284
	285	m_rect.left = m_position.x + kTipOffset;
	286	m_rect.top = m_position.y + kTipOffset;
	287	m_rect.right = m_rect.left + width + 2 * kTipBorder;
	288
	289	m_rect.bottom = m_rect.top + height + 2 * kTipBorder;
	290	Rect r ;
	291	GetPortBounds( GetWindowPort( m_window ) , &r ) ;
	292	if ( m_rect.top < 0 )
	293	{
	294	m_rect.bottom += -m_rect.top ;
	295	m_rect.top = 0 ;
	296	}
	297	if ( m_rect.left < 0 )
	298	{
	299	m_rect.right += -m_rect.left ;
	300	m_rect.left = 0 ;
	301	}
	302	if ( m_rect.right > r.right )
	303	{
	304	m_rect.left -= (m_rect.right - r.right ) ;
	305	m_rect.right = r.right ;
	306	}
	307	if ( m_rect.bottom > r.bottom )
	308	{
	309	m_rect.top -= (m_rect.bottom - r.bottom) ;
	310	m_rect.bottom = r.bottom ;
	311	}
	312	ClipRect( &m_rect ) ;
	313	BackColor( whiteColor ) ;
	314	ForeColor(blackColor ) ;
	315	GWorldPtr port ;
	316	NewGWorld( &port , wxDisplayDepth() , &m_rect , NULL , NULL , 0 ) ;
	317	CGrafPtr origPort ;
	318	GDHandle origDevice ;
	319
	320	GetGWorld( &origPort , &origDevice ) ;
	321	SetGWorld( port , NULL ) ;
	322
	323	m_backpict = OpenPicture(&m_rect);
	324
	325	CopyBits(GetPortBitMapForCopyBits(GetWindowPort(m_window)),
	326	GetPortBitMapForCopyBits(port),
	327	&m_rect,
	328	&m_rect,
	329	srcCopy,
	330	NULL);
	331	ClosePicture();
	332	SetGWorld( origPort , origDevice ) ;
	333	DisposeGWorld( port ) ;
	334	PenNormal() ;
	335
	336	RGBColor tooltipbackground = { 0xFFFF , 0xFFFF , 0xC000 } ;
	337	BackColor( whiteColor ) ;
	338	RGBForeColor( &tooltipbackground ) ;
	339
	340	PaintRect( &m_rect ) ;
	341	ForeColor(blackColor ) ;
	342	FrameRect( &m_rect ) ;
	343	SetThemeTextColor(kThemeTextColorNotification,wxDisplayDepth(),true) ;
	344	::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder);
	345
	346	i = 0 ;
	347	laststop = 0 ;
	348	height = 0 ;
	349
	350	while( i < length )
	351	{
	352	if( text[i] == 13 \|\| text[i] == 10)
	353	{
	354	::DrawText( text , laststop , i - laststop ) ;
	355	height += lineh ;
	356	::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder + height );
	357	laststop = i+1 ;
	358	}
	359	i++ ;
	360	}
	361	::DrawText( text , laststop , i - laststop ) ;
	362	::TextMode( srcOr ) ;
	363	#endif
	364	}
	365	}
	366
	367	void wxToolTip::NotifyWindowDelete( WXHWND win )
	368	{
	369	if ( win == s_ToolTipWindowRef )
	370	{
	371	s_ToolTipWindowRef = NULL ;
	372	}
	373	}
	374
	375	void wxMacToolTip::Clear()
	376	{
	377	m_mark++ ;
	378	if ( m_timer )
	379	{
	380	delete m_timer ;
	381	m_timer = NULL ;
	382	}
	383	if ( !m_shown )
	384	return ;
	385	#if TARGET_CARBON
	386	HMHideTag() ;
	387	m_helpTextRef.Release() ;
	388	#else
	389	if ( m_window == s_ToolTipWindowRef && m_backpict )
	390	{
	391	wxMacPortStateHelper help( (GrafPtr) GetWindowPort(m_window) ) ;
	392
	393	m_shown = false ;
	394
	395	BackColor( whiteColor ) ;
	396	ForeColor(blackColor ) ;
	397	DrawPicture(m_backpict, &m_rect);
	398	KillPicture(m_backpict);
	399	m_backpict = NULL ;
	400	}
	401	#endif
	402	}
	403
	404	#endif
	405