src/mac/tooltip.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        tooltip.cpp
// Purpose:     wxToolTip implementation
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
    #pragma implementation "tooltip.h"
#endif

#include "wx/defs.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->MacGetRootWindow() ) ;
                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 ) ;
        GrafPtr port ;
        GetPort( &port ) ;
        SetPortWindowPort(m_window) ;
        LocalToGlobal( (Point *) &tag.absHotRect.top );
        LocalToGlobal( (Point *) &tag.absHotRect.bottom );
        SetPort( port );
        m_helpTextRef = m_label ;
        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 = wxMacStringToCString( m_label ) ;

        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: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	#ifdef __GNUG__
	11	#pragma implementation "tooltip.h"
	12	#endif
	13
	14	#include "wx/defs.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->MacGetRootWindow() ) ;
	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	GrafPtr port ;
	231	GetPort( &port ) ;
	232	SetPortWindowPort(m_window) ;
	233	LocalToGlobal( (Point *) &tag.absHotRect.top );
	234	LocalToGlobal( (Point *) &tag.absHotRect.bottom );
	235	SetPort( port );
	236	m_helpTextRef = m_label ;
	237	tag.content[kHMMinimumContentIndex].contentType = kHMCFStringContent ;
	238	tag.content[kHMMinimumContentIndex].u.tagCFString = m_helpTextRef ;
	239	tag.content[kHMMaximumContentIndex].contentType = kHMCFStringContent ;
	240	tag.content[kHMMaximumContentIndex].u.tagCFString = m_helpTextRef ;
	241	tag.tagSide = kHMDefaultSide;
	242	HMDisplayTag( &tag );
	243	#else
	244	wxMacPortStateHelper help( (GrafPtr) GetWindowPort( m_window ) );
	245	FontFamilyID fontId ;
	246	Str255 fontName ;
	247	SInt16 fontSize ;
	248	Style fontStyle ;
	249	GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
	250	GetFNum( fontName, &fontId );
	251
	252	TextFont( fontId ) ;
	253	TextSize( fontSize ) ;
	254	TextFace( fontStyle ) ;
	255	FontInfo fontInfo;
	256	::GetFontInfo(&fontInfo);
	257	short lineh = fontInfo.ascent + fontInfo.descent + fontInfo.leading;
	258	short height = 0 ;
	259
	260	int i = 0 ;
	261	int length = m_label.Length() ;
	262	int width = 0 ;
	263	int thiswidth = 0 ;
	264	int laststop = 0 ;
	265	wxCharBuffer text = wxMacStringToCString( m_label ) ;
	266
	267	while( i < length )
	268	{
	269	if( text[i] == 13 \|\| text[i] == 10)
	270	{
	271	thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
	272	if ( thiswidth > width )
	273	width = thiswidth ;
	274
	275	height += lineh ;
	276	laststop = i+1 ;
	277	}
	278	i++ ;
	279	}
	280	if ( i - laststop > 0 )
	281	{
	282	thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
	283	if ( thiswidth > width )
	284	width = thiswidth ;
	285	height += lineh ;
	286	}
	287
	288	m_rect.left = m_position.x + kTipOffset;
	289	m_rect.top = m_position.y + kTipOffset;
	290	m_rect.right = m_rect.left + width + 2 * kTipBorder;
	291
	292	m_rect.bottom = m_rect.top + height + 2 * kTipBorder;
	293	Rect r ;
	294	GetPortBounds( GetWindowPort( m_window ) , &r ) ;
	295	if ( m_rect.top < 0 )
	296	{
	297	m_rect.bottom += -m_rect.top ;
	298	m_rect.top = 0 ;
	299	}
	300	if ( m_rect.left < 0 )
	301	{
	302	m_rect.right += -m_rect.left ;
	303	m_rect.left = 0 ;
	304	}
	305	if ( m_rect.right > r.right )
	306	{
	307	m_rect.left -= (m_rect.right - r.right ) ;
	308	m_rect.right = r.right ;
	309	}
	310	if ( m_rect.bottom > r.bottom )
	311	{
	312	m_rect.top -= (m_rect.bottom - r.bottom) ;
	313	m_rect.bottom = r.bottom ;
	314	}
	315	ClipRect( &m_rect ) ;
	316	BackColor( whiteColor ) ;
	317	ForeColor(blackColor ) ;
	318	GWorldPtr port ;
	319	NewGWorld( &port , wxDisplayDepth() , &m_rect , NULL , NULL , 0 ) ;
	320	CGrafPtr origPort ;
	321	GDHandle origDevice ;
	322
	323	GetGWorld( &origPort , &origDevice ) ;
	324	SetGWorld( port , NULL ) ;
	325
	326	m_backpict = OpenPicture(&m_rect);
	327
	328	CopyBits(GetPortBitMapForCopyBits(GetWindowPort(m_window)),
	329	GetPortBitMapForCopyBits(port),
	330	&m_rect,
	331	&m_rect,
	332	srcCopy,
	333	NULL);
	334	ClosePicture();
	335	SetGWorld( origPort , origDevice ) ;
	336	DisposeGWorld( port ) ;
	337	PenNormal() ;
	338
	339	RGBColor tooltipbackground = { 0xFFFF , 0xFFFF , 0xC000 } ;
	340	BackColor( whiteColor ) ;
	341	RGBForeColor( &tooltipbackground ) ;
	342
	343	PaintRect( &m_rect ) ;
	344	ForeColor(blackColor ) ;
	345	FrameRect( &m_rect ) ;
	346	SetThemeTextColor(kThemeTextColorNotification,wxDisplayDepth(),true) ;
	347	::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder);
	348
	349	i = 0 ;
	350	laststop = 0 ;
	351	height = 0 ;
	352
	353	while( i < length )
	354	{
	355	if( text[i] == 13 \|\| text[i] == 10)
	356	{
	357	::DrawText( text , laststop , i - laststop ) ;
	358	height += lineh ;
	359	::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder + height );
	360	laststop = i+1 ;
	361	}
	362	i++ ;
	363	}
	364	::DrawText( text , laststop , i - laststop ) ;
	365	::TextMode( srcOr ) ;
	366	#endif
	367	}
	368	}
	369
	370	void wxToolTip::NotifyWindowDelete( WXHWND win )
	371	{
	372	if ( win == s_ToolTipWindowRef )
	373	{
	374	s_ToolTipWindowRef = NULL ;
	375	}
	376	}
	377
	378	void wxMacToolTip::Clear()
	379	{
	380	m_mark++ ;
	381	if ( m_timer )
	382	{
	383	delete m_timer ;
	384	m_timer = NULL ;
	385	}
	386	if ( !m_shown )
	387	return ;
	388	#if TARGET_CARBON
	389	HMHideTag() ;
	390	m_helpTextRef.Release() ;
	391	#else
	392	if ( m_window == s_ToolTipWindowRef && m_backpict )
	393	{
	394	wxMacPortStateHelper help( (GrafPtr) GetWindowPort(m_window) ) ;
	395
	396	m_shown = false ;
	397
	398	BackColor( whiteColor ) ;
	399	ForeColor(blackColor ) ;
	400	DrawPicture(m_backpict, &m_rect);
	401	KillPicture(m_backpict);
	402	m_backpict = NULL ;
	403	}
	404	#endif
	405	}
	406
	407	#endif
	408