src/mac/carbon/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 ;
    if( wxApp::s_macDefaultEncodingIsPC )
        m_label = wxMacMakeMacStringFromPC( text ) ;
 	else
        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 )
	{
#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;
  		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)
  			{
#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	if( wxApp::s_macDefaultEncodingIsPC )
	194	m_label = wxMacMakeMacStringFromPC( text ) ;
	195	else
	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	#if TARGET_CARBON
	226	/*
	227	if ( HMDisplayTag != (void*) kUnresolvedCFragSymbolAddress )
	228	{
	229	HMDisplayTag(
	230	}
	231	else
	232	*/
	233	#endif
	234	{
	235	wxMacPortStateHelper help( (GrafPtr) GetWindowPort( m_window ) );
	236	#if TARGET_CARBON
	237	bool useDrawThemeText = ( DrawThemeTextBox != (void*) kUnresolvedCFragSymbolAddress ) ;
	238	#endif
	239	m_shown = true ;
	240
	241	FontFamilyID fontId ;
	242	Str255 fontName ;
	243	SInt16 fontSize ;
	244	Style fontStyle ;
	245	GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
	246	GetFNum( fontName, &fontId );
	247
	248	TextFont( fontId ) ;
	249	TextSize( fontSize ) ;
	250	TextFace( fontStyle ) ;
	251	FontInfo fontInfo;
	252	::GetFontInfo(&fontInfo);
	253	short lineh = fontInfo.ascent + fontInfo.descent + fontInfo.leading;
	254	short height = 0 ;
	255	// short width = TextWidth( m_label , 0 ,m_label.Length() ) ;
	256
	257	int i = 0 ;
	258	int length = m_label.Length() ;
	259	int width = 0 ;
	260	int thiswidth = 0 ;
	261	int laststop = 0 ;
	262	const char *text = m_label ;
	263	while( i < length )
	264	{
	265	if( text[i] == 13 \|\| text[i] == 10)
	266	{
	267	thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
	268	if ( thiswidth > width )
	269	width = thiswidth ;
	270
	271	height += lineh ;
	272	laststop = i+1 ;
	273	}
	274	i++ ;
	275	}
	276	if ( i - laststop > 0 )
	277	{
	278	thiswidth = ::TextWidth( text , laststop , i - laststop ) ;
	279	if ( thiswidth > width )
	280	width = thiswidth ;
	281	height += lineh ;
	282	}
	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	#if TARGET_CARBON
	289	if ( useDrawThemeText )
	290	m_rect.right += kTipBorder ;
	291	#endif
	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	#if TARGET_CARBON
	358	if ( useDrawThemeText )
	359	{
	360	Rect frame ;
	361	frame.top = m_rect.top + kTipBorder + height ;
	362	frame.left = m_rect.left + kTipBorder ;
	363	frame.bottom = frame.top + 1000 ;
	364	frame.right = frame.left + 1000 ;
	365	CFStringRef mString = CFStringCreateWithBytes( NULL , (UInt8*) text + laststop , i - laststop , CFStringGetSystemEncoding(), false ) ;
	366	::DrawThemeTextBox( mString,
	367	kThemeCurrentPortFont,
	368	kThemeStateActive,
	369	true,
	370	&frame,
	371	teJustLeft,
	372	nil );
	373	CFRelease( mString ) ;
	374	height += lineh ;
	375	}
	376	else
	377	#endif
	378	{
	379	::DrawText( text , laststop , i - laststop ) ;
	380	height += lineh ;
	381	::MoveTo( m_rect.left + kTipBorder , m_rect.top + fontInfo.ascent + kTipBorder + height );
	382	}
	383	laststop = i+1 ;
	384	}
	385	i++ ;
	386	}
	387	#if TARGET_CARBON
	388	if ( useDrawThemeText )
	389	{
	390	Rect frame ;
	391	frame.top = m_rect.top + kTipBorder + height ;
	392	frame.left = m_rect.left + kTipBorder ;
	393	frame.bottom = frame.top + 1000 ;
	394	frame.right = frame.left + 1000 ;
	395	CFStringRef mString = CFStringCreateWithCString( NULL , text + laststop , kCFStringEncodingMacRoman ) ;
	396	::DrawThemeTextBox( mString,
	397	kThemeCurrentPortFont,
	398	kThemeStateActive,
	399	true,
	400	&frame,
	401	teJustLeft,
	402	nil );
	403	CFRelease( mString ) ;
	404	}
	405	else
	406	#endif
	407	{
	408	::DrawText( text , laststop , i - laststop ) ;
	409	}
	410	::TextMode( srcOr ) ;
	411	}
	412	}
	413	}
	414
	415	void wxToolTip::NotifyWindowDelete( WXHWND win )
	416	{
	417	if ( win == s_ToolTipWindowRef )
	418	{
	419	s_ToolTipWindowRef = NULL ;
	420	}
	421	}
	422
	423	void wxMacToolTip::Clear()
	424	{
	425	m_mark++ ;
	426	if ( m_timer )
	427	{
	428	delete m_timer ;
	429	m_timer = NULL ;
	430	}
	431	if ( !m_shown )
	432	return ;
	433
	434	if ( m_window == s_ToolTipWindowRef && m_backpict )
	435	{
	436	wxMacPortStateHelper help( (GrafPtr) GetWindowPort(m_window) ) ;
	437
	438	m_shown = false ;
	439
	440	BackColor( whiteColor ) ;
	441	ForeColor(blackColor ) ;
	442	DrawPicture(m_backpict, &m_rect);
	443	KillPicture(m_backpict);
	444	m_backpict = NULL ;
	445	}
	446	}
	447
	448	#endif
	449