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  , 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 ;
} ;

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  , wxString text , wxPoint localPosition )
{
	m_mark++ ;
	Clear() ;
	m_position = localPosition ;
	m_label = wxMacMakeMacStringFromPC( 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 )
	{
#if TARGET_CARBON
/*
	  if ( HMDisplayTag != (void*) kUnresolvedCFragSymbolAddress )
	  {
	    HMDisplayTag(
	  }
	  else
*/
#endif
	  {
   		wxMacPortStateHelper help( (GrafPtr) GetWindowPort( m_window ) );
#if TARGET_CARBON
  		bool useDrawThemeText =  ( DrawThemeTextBox != (void*) kUnresolvedCFragSymbolAddress ) ;
#endif
  		m_shown = true ;

        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 ;
  	//	short width = TextWidth( m_label , 0 ,m_label.Length() ) ;

  		int i = 0 ;
  		int length = m_label.Length() ;
  		int width = 0 ;
  		int thiswidth = 0 ;
  		int laststop = 0 ;
  		const char *text = 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;
#if TARGET_CARBON
  		if ( useDrawThemeText )
  		    m_rect.right += kTipBorder ;
#endif
  		m_rect.bottom = m_rect.top + height + 2 * kTipBorder;
  		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)
  			{
#if TARGET_CARBON
            	if ( useDrawThemeText )
            	{
    	            Rect frame ;
    	            frame.top = m_rect.top + kTipBorder + height ;
    	            frame.left = m_rect.left + kTipBorder ;
    	            frame.bottom = frame.top + 1000 ;
    	            frame.right = frame.left + 1000 ;
                    CFStringRef mString = CFStringCreateWithBytes( NULL , (UInt8*) text + laststop , i - laststop , CFStringGetSystemEncoding(), false ) ;
            		::DrawThemeTextBox( mString,
            							kThemeCurrentPortFont,
            							kThemeStateActive,
            							true,
            							&frame,
            							teJustLeft,
            							nil );
            	    CFRelease( mString ) ;
   				    height += lineh ;
               }
                else
#endif
                {
  				    ::DrawText( text , laststop , i - laststop ) ;
  				    height += lineh ;
  				    ::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder + height );
  				}
  				laststop = i+1 ;
  			}
  			i++ ;
  		}
#if TARGET_CARBON
        if ( useDrawThemeText )
        {
            Rect frame ;
            frame.top = m_rect.top + kTipBorder + height ;
            frame.left = m_rect.left + kTipBorder ;
            frame.bottom = frame.top + 1000 ;
            frame.right = frame.left + 1000 ;
            CFStringRef mString = CFStringCreateWithCString( NULL , text + laststop , kCFStringEncodingMacRoman ) ;
        	::DrawThemeTextBox( mString,
        						kThemeCurrentPortFont,
        						kThemeStateActive,
        						true,
        						&frame,
        						teJustLeft,
        						nil );
            CFRelease( mString ) ;
        }
        else
#endif
        {
  		    ::DrawText( text , laststop , i - laststop ) ;
  		}
  		::TextMode( srcOr ) ;
  	 }
	}
}

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 ( 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
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 , 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	} ;
	54
	55	class wxMacToolTipTimer : public wxTimer
	56	{
	57	public:
	58	wxMacToolTipTimer() {} ;
	59	wxMacToolTipTimer(wxMacToolTip* tip, int iMilliseconds) ;
	60	virtual ~wxMacToolTipTimer() {} ;
	61	void Notify()
	62	{
	63	if ( m_mark == m_tip->GetMark() )
	64	m_tip->Draw() ;
	65	}
	66	protected:
	67	wxMacToolTip* m_tip;
	68	long m_mark ;
	69	};
	70
	71	//-----------------------------------------------------------------------------
	72	// wxToolTip
	73	//-----------------------------------------------------------------------------
	74	static long s_ToolTipDelay = 500 ;
	75	static bool s_ShowToolTips = true ;
	76	static wxMacToolTip s_ToolTip ;
	77	static wxWindow* s_LastWindowEntered = NULL ;
	78	static wxRect2DInt s_ToolTipArea ;
	79	static WindowRef s_ToolTipWindowRef = NULL ;
	80
	81	IMPLEMENT_ABSTRACT_CLASS(wxToolTip, wxObject)
	82
	83	wxToolTip::wxToolTip( const wxString &tip )
	84	{
	85	m_text = tip;
	86	m_window = (wxWindow*) NULL;
	87	}
	88
	89	wxToolTip::~wxToolTip()
	90	{
	91	}
	92
	93	void wxToolTip::SetTip( const wxString &tip )
	94	{
	95	m_text = tip;
	96
	97	if ( m_window )
	98	{
	99	/*
	100	// update it immediately
	101	wxToolInfo ti(GetHwndOf(m_window));
	102	ti.lpszText = (wxChar *)m_text.c_str();
	103
	104	(void)SendTooltipMessage(GetToolTipCtrl(), TTM_UPDATETIPTEXT, 0, &ti);
	105	*/
	106	}
	107	}
	108
	109	void wxToolTip::SetWindow( wxWindow *win )
	110	{
	111	m_window = win ;
	112	}
	113
	114	void wxToolTip::Enable( bool flag )
	115	{
	116	if ( s_ShowToolTips != flag )
	117	{
	118	s_ShowToolTips = flag ;
	119	if ( s_ShowToolTips )
	120	{
	121	}
	122	else
	123	{
	124	s_ToolTip.Clear() ;
	125	}
	126	}
	127	}
	128
	129	void wxToolTip::SetDelay( long msecs )
	130	{
	131	s_ToolTipDelay = msecs ;
	132	}
	133
	134	void wxToolTip::RelayEvent( wxWindow *win , wxMouseEvent &event )
	135	{
	136	if ( s_ShowToolTips )
	137	{
	138	if ( event.GetEventType() == wxEVT_LEAVE_WINDOW )
	139	{
	140	s_ToolTip.Clear() ;
	141	}
	142	else if (event.GetEventType() == wxEVT_ENTER_WINDOW \|\| event.GetEventType() == wxEVT_MOTION )
	143	{
	144	wxPoint2DInt where( event.m_x , event.m_y ) ;
	145	if ( s_LastWindowEntered == win && s_ToolTipArea.Contains( where ) )
	146	{
	147	}
	148	else
	149	{
	150	s_ToolTip.Clear() ;
	151	s_ToolTipArea = wxRect2DInt( event.m_x - 2 , event.m_y - 2 , 4 , 4 ) ;
	152	s_LastWindowEntered = win ;
	153
	154	WindowRef window = MAC_WXHWND( win->MacGetRootWindow() ) ;
	155	int x = event.m_x ;
	156	int y = event.m_y ;
	157	wxPoint local( x , y ) ;
	158	win->MacClientToRootWindow( &x, &y ) ;
	159	wxPoint windowlocal( x , y ) ;
	160	s_ToolTip.Setup( window , win->MacGetToolTipString( local ) , windowlocal ) ;
	161	}
	162	}
	163	}
	164	}
	165
	166	void wxToolTip::RemoveToolTips()
	167	{
	168	s_ToolTip.Clear() ;
	169	}
	170	// --- mac specific
	171
	172	wxMacToolTipTimer::wxMacToolTipTimer( wxMacToolTip *tip , int msec )
	173	{
	174	m_tip = tip;
	175	m_mark = tip->GetMark() ;
	176	Start(msec, true);
	177	}
	178
	179	wxMacToolTip::wxMacToolTip()
	180	{
	181	m_window = NULL ;
	182	m_backpict = NULL ;
	183	m_mark = 0 ;
	184	m_shown = false ;
	185	m_timer = NULL ;
	186	}
	187
	188	void wxMacToolTip::Setup( WindowRef win , wxString text , wxPoint localPosition )
	189	{
	190	m_mark++ ;
	191	Clear() ;
	192	m_position = localPosition ;
	193	m_label = wxMacMakeMacStringFromPC( text ) ;
	194	m_window =win;
	195	s_ToolTipWindowRef = m_window ;
	196	m_backpict = NULL ;
	197	if ( m_timer )
	198	delete m_timer ;
	199	m_timer = new wxMacToolTipTimer( this , s_ToolTipDelay ) ;
	200	}
	201
	202	wxMacToolTip::~wxMacToolTip()
	203	{
	204	if ( m_timer ) {
	205	delete m_timer ;
	206	m_timer = NULL;
	207	}
	208	if ( m_backpict )
	209	Clear() ;
	210	}
	211
	212	const short kTipBorder = 2 ;
	213	const short kTipOffset = 5 ;
	214
	215	void wxMacToolTip::Draw()
	216	{
	217	if ( m_label.Length() == 0 )
	218	return ;
	219
	220	if ( m_window == s_ToolTipWindowRef )
	221	{
	222	#if TARGET_CARBON
	223	/*
	224	if ( HMDisplayTag != (void*) kUnresolvedCFragSymbolAddress )
	225	{
	226	HMDisplayTag(
	227	}
	228	else
	229	*/
	230	#endif
	231	{
	232	wxMacPortStateHelper help( (GrafPtr) GetWindowPort( m_window ) );
	233	#if TARGET_CARBON
	234	bool useDrawThemeText = ( DrawThemeTextBox != (void*) kUnresolvedCFragSymbolAddress ) ;
	235	#endif
	236	m_shown = true ;
	237
	238	FontFamilyID fontId ;
	239	Str255 fontName ;
	240	SInt16 fontSize ;
	241	Style fontStyle ;
	242	GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
	243	GetFNum( fontName, &fontId );
	244
	245	TextFont( fontId ) ;
	246	TextSize( fontSize ) ;
	247	TextFace( fontStyle ) ;
	248	FontInfo fontInfo;
	249	::GetFontInfo(&fontInfo);
	250	short lineh = fontInfo.ascent + fontInfo.descent + fontInfo.leading;
	251	short height = 0 ;
	252	// short width = TextWidth( m_label , 0 ,m_label.Length() ) ;
	253
	254	int i = 0 ;
	255	int length = m_label.Length() ;
	256	int width = 0 ;
	257	int thiswidth = 0 ;
	258	int laststop = 0 ;
	259	const char *text = m_label ;
	260	while( i < length )
	261	{
	262	if( text[i] == 13 \|\| text[i] == 10)
	263	{
	264	thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
	265	if ( thiswidth > width )
	266	width = thiswidth ;
	267
	268	height += lineh ;
	269	laststop = i+1 ;
	270	}
	271	i++ ;
	272	}
	273	if ( i - laststop > 0 )
	274	{
	275	thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
	276	if ( thiswidth > width )
	277	width = thiswidth ;
	278	height += lineh ;
	279	}
	280
	281
	282	m_rect.left = m_position.x + kTipOffset;
	283	m_rect.top = m_position.y + kTipOffset;
	284	m_rect.right = m_rect.left + width + 2 * kTipBorder;
	285	#if TARGET_CARBON
	286	if ( useDrawThemeText )
	287	m_rect.right += kTipBorder ;
	288	#endif
	289	m_rect.bottom = m_rect.top + height + 2 * kTipBorder;
	290	ClipRect( &m_rect ) ;
	291	BackColor( whiteColor ) ;
	292	ForeColor(blackColor ) ;
	293	GWorldPtr port ;
	294	NewGWorld( &port , wxDisplayDepth() , &m_rect , NULL , NULL , 0 ) ;
	295	CGrafPtr origPort ;
	296	GDHandle origDevice ;
	297
	298	GetGWorld( &origPort , &origDevice ) ;
	299	SetGWorld( port , NULL ) ;
	300
	301	m_backpict = OpenPicture(&m_rect);
	302
	303	CopyBits(GetPortBitMapForCopyBits(GetWindowPort(m_window)),
	304	GetPortBitMapForCopyBits(port),
	305	&m_rect,
	306	&m_rect,
	307	srcCopy,
	308	NULL);
	309	ClosePicture();
	310	SetGWorld( origPort , origDevice ) ;
	311	DisposeGWorld( port ) ;
	312	PenNormal() ;
	313
	314	RGBColor tooltipbackground = { 0xFFFF , 0xFFFF , 0xC000 } ;
	315	BackColor( whiteColor ) ;
	316	RGBForeColor( &tooltipbackground ) ;
	317
	318	PaintRect( &m_rect ) ;
	319	ForeColor(blackColor ) ;
	320	FrameRect( &m_rect ) ;
	321	SetThemeTextColor(kThemeTextColorNotification,wxDisplayDepth(),true) ;
	322	::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder);
	323
	324	i = 0 ;
	325	laststop = 0 ;
	326	height = 0 ;
	327
	328	while( i < length )
	329	{
	330	if( text[i] == 13 \|\| text[i] == 10)
	331	{
	332	#if TARGET_CARBON
	333	if ( useDrawThemeText )
	334	{
	335	Rect frame ;
	336	frame.top = m_rect.top + kTipBorder + height ;
	337	frame.left = m_rect.left + kTipBorder ;
	338	frame.bottom = frame.top + 1000 ;
	339	frame.right = frame.left + 1000 ;
	340	CFStringRef mString = CFStringCreateWithBytes( NULL , (UInt8*) text + laststop , i - laststop , CFStringGetSystemEncoding(), false ) ;
	341	::DrawThemeTextBox( mString,
	342	kThemeCurrentPortFont,
	343	kThemeStateActive,
	344	true,
	345	&frame,
	346	teJustLeft,
	347	nil );
	348	CFRelease( mString ) ;
	349	height += lineh ;
	350	}
	351	else
	352	#endif
	353	{
	354	::DrawText( text , laststop , i - laststop ) ;
	355	height += lineh ;
	356	::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder + height );
	357	}
	358	laststop = i+1 ;
	359	}
	360	i++ ;
	361	}
	362	#if TARGET_CARBON
	363	if ( useDrawThemeText )
	364	{
	365	Rect frame ;
	366	frame.top = m_rect.top + kTipBorder + height ;
	367	frame.left = m_rect.left + kTipBorder ;
	368	frame.bottom = frame.top + 1000 ;
	369	frame.right = frame.left + 1000 ;
	370	CFStringRef mString = CFStringCreateWithCString( NULL , text + laststop , kCFStringEncodingMacRoman ) ;
	371	::DrawThemeTextBox( mString,
	372	kThemeCurrentPortFont,
	373	kThemeStateActive,
	374	true,
	375	&frame,
	376	teJustLeft,
	377	nil );
	378	CFRelease( mString ) ;
	379	}
	380	else
	381	#endif
	382	{
	383	::DrawText( text , laststop , i - laststop ) ;
	384	}
	385	::TextMode( srcOr ) ;
	386	}
	387	}
	388	}
	389
	390	void wxToolTip::NotifyWindowDelete( WXHWND win )
	391	{
	392	if ( win == s_ToolTipWindowRef )
	393	{
	394	s_ToolTipWindowRef = NULL ;
	395	}
	396	}
	397
	398	void wxMacToolTip::Clear()
	399	{
	400	m_mark++ ;
	401	if ( m_timer )
	402	{
	403	delete m_timer ;
	404	m_timer = NULL ;
	405	}
	406	if ( !m_shown )
	407	return ;
	408
	409	if ( m_window == s_ToolTipWindowRef && m_backpict )
	410	{
	411	wxMacPortStateHelper help( (GrafPtr) GetWindowPort(m_window) ) ;
	412
	413	m_shown = false ;
	414
	415	BackColor( whiteColor ) ;
	416	ForeColor(blackColor ) ;
	417	DrawPicture(m_backpict, &m_rect);
	418	KillPicture(m_backpict);
	419	m_backpict = NULL ;
	420	}
	421	}
	422
	423	#endif
	424