[wxWidgets.git] / src / mac / classic / 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.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
2646f485 SC	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: tooltip.cpp
	3	// Purpose: wxToolTip implementation
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling
65571936	7	// Licence: wxWindows licence
2646f485 SC	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.Assign( m_label , wxFONTENCODING_DEFAULT ) ;
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 = m_label.mb_str( wxConvLocal) ;
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