+ wxCHECK_RET(Ok(), wxT("Invalid DC"));
+ wxMacFastPortSetter helper(this) ;
+ wxCoord x1, x2 , y1 , y2 ;
+ if ( m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT )
+ return ;
+ PolyHandle polygon = OpenPoly();
+ x2 = x1 = XLOG2DEVMAC(points[0].x + xoffset);
+ y2 = y1 = YLOG2DEVMAC(points[0].y + yoffset);
+ ::MoveTo(x1,y1);
+ for (int i = 1; i < n; i++)
+ {
+ x2 = XLOG2DEVMAC(points[i].x + xoffset);
+ y2 = YLOG2DEVMAC(points[i].y + yoffset);
+ ::LineTo(x2, y2);
+ }
+ // close the polyline if necessary
+ if ( x1 != x2 || y1 != y2 )
+ {
+ ::LineTo(x1,y1 ) ;
+ }
+ ClosePoly();
+ if (m_brush.GetStyle() != wxTRANSPARENT)
+ {
+ MacInstallBrush();
+ ::PaintPoly( polygon );
+ }
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ {
+ MacInstallPen() ;
+ ::FramePoly( polygon ) ;
+ }
+ KillPoly( polygon );
+}
+
+void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+{
+ wxCHECK_RET(Ok(), wxT("Invalid DC"));
+ wxMacFastPortSetter helper(this) ;
+ wxCoord xx = XLOG2DEVMAC(x);
+ wxCoord yy = YLOG2DEVMAC(y);
+ wxCoord ww = m_signX * XLOG2DEVREL(width);
+ wxCoord hh = m_signY * YLOG2DEVREL(height);
+ // CMB: draw nothing if transformed w or h is 0
+ if (ww == 0 || hh == 0)
+ return;
+ // CMB: handle -ve width and/or height
+ if (ww < 0)
+ {
+ ww = -ww;
+ xx = xx - ww;
+ }
+ if (hh < 0)
+ {
+ hh = -hh;
+ yy = yy - hh;
+ }
+ Rect rect = { yy , xx , yy + hh , xx + ww } ;
+ if (m_brush.GetStyle() != wxTRANSPARENT)
+ {
+ MacInstallBrush() ;
+ ::PaintRect( &rect ) ;
+ }
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ {
+ MacInstallPen() ;
+ ::FrameRect( &rect ) ;
+ }
+}
+
+void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y,
+ wxCoord width, wxCoord height,
+ double radius)
+{
+ wxCHECK_RET(Ok(), wxT("Invalid DC"));
+ wxMacFastPortSetter helper(this) ;
+ if (radius < 0.0)
+ radius = - radius * ((width < height) ? width : height);
+ wxCoord xx = XLOG2DEVMAC(x);
+ wxCoord yy = YLOG2DEVMAC(y);
+ wxCoord ww = m_signX * XLOG2DEVREL(width);
+ wxCoord hh = m_signY * YLOG2DEVREL(height);
+ // CMB: draw nothing if transformed w or h is 0
+ if (ww == 0 || hh == 0)
+ return;
+ // CMB: handle -ve width and/or height
+ if (ww < 0)
+ {
+ ww = -ww;
+ xx = xx - ww;
+ }
+ if (hh < 0)
+ {
+ hh = -hh;
+ yy = yy - hh;
+ }
+ Rect rect = { yy , xx , yy + hh , xx + ww } ;
+ if (m_brush.GetStyle() != wxTRANSPARENT)
+ {
+ MacInstallBrush() ;
+ ::PaintRoundRect( &rect , int(radius * 2) , int(radius * 2) ) ;
+ }
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ {
+ MacInstallPen() ;
+ ::FrameRoundRect( &rect , int(radius * 2) , int(radius * 2) ) ;
+ }
+}
+
+void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+{
+ wxCHECK_RET(Ok(), wxT("Invalid DC"));
+ wxMacFastPortSetter helper(this) ;
+ wxCoord xx = XLOG2DEVMAC(x);
+ wxCoord yy = YLOG2DEVMAC(y);
+ wxCoord ww = m_signX * XLOG2DEVREL(width);
+ wxCoord hh = m_signY * YLOG2DEVREL(height);
+ // CMB: draw nothing if transformed w or h is 0
+ if (ww == 0 || hh == 0)
+ return;
+ // CMB: handle -ve width and/or height
+ if (ww < 0)
+ {
+ ww = -ww;
+ xx = xx - ww;
+ }
+ if (hh < 0)
+ {
+ hh = -hh;
+ yy = yy - hh;
+ }
+ Rect rect = { yy , xx , yy + hh , xx + ww } ;
+ if (m_brush.GetStyle() != wxTRANSPARENT)
+ {
+ MacInstallBrush() ;
+ ::PaintOval( &rect ) ;
+ }
+ if (m_pen.GetStyle() != wxTRANSPARENT)
+ {
+ MacInstallPen() ;
+ ::FrameOval( &rect ) ;
+ }
+}
+
+bool wxDC::CanDrawBitmap(void) const
+{
+ return true ;
+}
+
+bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
+ wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func , bool useMask,
+ wxCoord xsrcMask, wxCoord ysrcMask )
+{
+ wxCHECK_MSG(Ok(), false, wxT("wxDC::DoBlit Illegal dc"));
+ wxCHECK_MSG(source->Ok(), false, wxT("wxDC::DoBlit Illegal source DC"));
+ if ( logical_func == wxNO_OP )
+ return true ;
+ if (xsrcMask == -1 && ysrcMask == -1)
+ {
+ xsrcMask = xsrc; ysrcMask = ysrc;
+ }
+ // correct the parameter in case this dc does not have a mask at all
+ if ( useMask && !source->m_macMask )
+ useMask = false ;
+ Rect srcrect , dstrect ;
+ srcrect.top = source->YLOG2DEVMAC(ysrc) ;
+ srcrect.left = source->XLOG2DEVMAC(xsrc) ;
+ srcrect.right = source->XLOG2DEVMAC(xsrc + width ) ;
+ srcrect.bottom = source->YLOG2DEVMAC(ysrc + height) ;
+ dstrect.top = YLOG2DEVMAC(ydest) ;
+ dstrect.left = XLOG2DEVMAC(xdest) ;
+ dstrect.bottom = YLOG2DEVMAC(ydest + height ) ;
+ dstrect.right = XLOG2DEVMAC(xdest + width ) ;
+ short mode = kUnsupportedMode ;
+ bool invertDestinationFirst = false ;
+ switch ( logical_func )
+ {
+ case wxAND: // src AND dst
+ mode = adMin ; // ok
+ break ;
+ case wxAND_INVERT: // (NOT src) AND dst
+ mode = notSrcOr ; // ok
+ break ;
+ case wxAND_REVERSE:// src AND (NOT dst)
+ invertDestinationFirst = true ;
+ mode = srcOr ;
+ break ;
+ case wxCLEAR: // 0
+ mode = kEmulatedMode ;
+ break ;
+ case wxCOPY: // src
+ mode = srcCopy ; // ok
+ break ;
+ case wxEQUIV: // (NOT src) XOR dst
+ mode = srcXor ; // ok
+ break ;
+ case wxINVERT: // NOT dst
+ mode = kEmulatedMode ; //or hilite ;
+ break ;
+ case wxNAND: // (NOT src) OR (NOT dst)
+ invertDestinationFirst = true ;
+ mode = srcBic ;
+ break ;
+ case wxNOR: // (NOT src) AND (NOT dst)
+ invertDestinationFirst = true ;
+ mode = notSrcOr ;
+ break ;
+ case wxNO_OP: // dst
+ mode = kEmulatedMode ; // this has already been handled upon entry
+ break ;
+ case wxOR: // src OR dst
+ mode = notSrcBic ;
+ break ;
+ case wxOR_INVERT: // (NOT src) OR dst
+ mode = srcBic ;
+ break ;
+ case wxOR_REVERSE: // src OR (NOT dst)
+ invertDestinationFirst = true ;
+ mode = notSrcBic ;
+ break ;
+ case wxSET: // 1
+ mode = kEmulatedMode ;
+ break ;
+ case wxSRC_INVERT: // (NOT src)
+ mode = notSrcCopy ; // ok
+ break ;
+ case wxXOR: // src XOR dst
+ mode = notSrcXor ; // ok
+ break ;
+ default :
+ break ;
+ }
+ if ( mode == kUnsupportedMode )
+ {
+ wxFAIL_MSG(wxT("unsupported blitting mode" ));
+ return false ;
+ }
+ CGrafPtr sourcePort = (CGrafPtr) source->m_macPort ;
+ PixMapHandle bmappixels = GetGWorldPixMap( sourcePort ) ;
+ if ( LockPixels(bmappixels) )
+ {
+ wxMacFastPortSetter helper(this) ;
+ if ( source->GetDepth() == 1 )
+ {
+ RGBForeColor( &MAC_WXCOLORREF(m_textForegroundColour.GetPixel()) ) ;
+ RGBBackColor( &MAC_WXCOLORREF(m_textBackgroundColour.GetPixel()) ) ;
+ }
+ else
+ {
+ // the modes need this, otherwise we'll end up having really nice colors...
+ RGBColor white = { 0xFFFF, 0xFFFF,0xFFFF} ;
+ RGBColor black = { 0,0,0} ;
+ RGBForeColor( &black ) ;
+ RGBBackColor( &white ) ;
+ }
+ if ( useMask && source->m_macMask )
+ {
+ if ( mode == srcCopy )
+ {
+ if ( LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) )
+ {
+ CopyMask( GetPortBitMapForCopyBits( sourcePort ) ,
+ GetPortBitMapForCopyBits( MAC_WXHBITMAP(source->m_macMask) ) ,
+ GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ) ,
+ &srcrect, &srcrect , &dstrect ) ;
+ UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
+ }
+ }
+ else
+ {
+ RgnHandle clipRgn = NewRgn() ;
+ LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
+ BitMapToRegion( clipRgn , (BitMap*) *GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
+ UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
+ OffsetRgn( clipRgn , -srcrect.left + dstrect.left, -srcrect.top + dstrect.top ) ;
+ if ( mode == kEmulatedMode )
+ {
+ Pattern pat ;
+ ::PenPat(GetQDGlobalsBlack(&pat));
+ if ( logical_func == wxSET )
+ {
+ RGBColor col= { 0xFFFF, 0xFFFF, 0xFFFF } ;
+ ::RGBForeColor( &col ) ;
+ ::PaintRgn( clipRgn ) ;
+ }
+ else if ( logical_func == wxCLEAR )
+ {
+ RGBColor col= { 0x0000, 0x0000, 0x0000 } ;
+ ::RGBForeColor( &col ) ;
+ ::PaintRgn( clipRgn ) ;
+ }
+ else if ( logical_func == wxINVERT )
+ {
+ MacInvertRgn( clipRgn ) ;
+ }
+ else
+ {
+ for ( int y = 0 ; y < srcrect.right - srcrect.left ; ++y )
+ {
+ for ( int x = 0 ; x < srcrect.bottom - srcrect.top ; ++x )
+ {
+ Point dstPoint = { dstrect.top + y , dstrect.left + x } ;
+ Point srcPoint = { srcrect.top + y , srcrect.left + x } ;
+ if ( PtInRgn( dstPoint , clipRgn ) )
+ {
+ RGBColor srcColor ;
+ RGBColor dstColor ;
+ SetPort( (GrafPtr) sourcePort ) ;
+ GetCPixel( srcPoint.h , srcPoint.v , &srcColor) ;
+ SetPort( (GrafPtr) m_macPort ) ;
+ GetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
+ wxMacCalculateColour( logical_func , srcColor , dstColor ) ;
+ SetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ if ( invertDestinationFirst )
+ {
+ MacInvertRgn( clipRgn ) ;
+ }
+ CopyBits( GetPortBitMapForCopyBits( sourcePort ) ,
+ GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ) ,
+ &srcrect, &dstrect, mode, clipRgn ) ;
+ }
+ DisposeRgn( clipRgn ) ;
+ }
+ }
+ else
+ {
+ RgnHandle clipRgn = NewRgn() ;
+ SetRectRgn( clipRgn , dstrect.left , dstrect.top , dstrect.right , dstrect.bottom ) ;
+ if ( mode == kEmulatedMode )
+ {
+ Pattern pat ;
+ ::PenPat(GetQDGlobalsBlack(&pat));
+ if ( logical_func == wxSET )
+ {
+ RGBColor col= { 0xFFFF, 0xFFFF, 0xFFFF } ;
+ ::RGBForeColor( &col ) ;
+ ::PaintRgn( clipRgn ) ;
+ }
+ else if ( logical_func == wxCLEAR )
+ {
+ RGBColor col= { 0x0000, 0x0000, 0x0000 } ;
+ ::RGBForeColor( &col ) ;
+ ::PaintRgn( clipRgn ) ;
+ }
+ else if ( logical_func == wxINVERT )
+ {
+ MacInvertRgn( clipRgn ) ;
+ }
+ else
+ {
+ for ( int y = 0 ; y < srcrect.right - srcrect.left ; ++y )
+ {
+ for ( int x = 0 ; x < srcrect.bottom - srcrect.top ; ++x )
+ {
+ Point dstPoint = { dstrect.top + y , dstrect.left + x } ;
+ Point srcPoint = { srcrect.top + y , srcrect.left + x } ;
+ {
+ RGBColor srcColor ;
+ RGBColor dstColor ;
+ SetPort( (GrafPtr) sourcePort ) ;
+ GetCPixel( srcPoint.h , srcPoint.v , &srcColor) ;
+ SetPort( (GrafPtr) m_macPort ) ;
+ GetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
+ wxMacCalculateColour( logical_func , srcColor , dstColor ) ;
+ SetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ if ( invertDestinationFirst )
+ {
+ MacInvertRgn( clipRgn ) ;
+ }
+ CopyBits( GetPortBitMapForCopyBits( sourcePort ) ,
+ GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ) ,
+ &srcrect, &dstrect, mode, NULL ) ;
+ }
+ DisposeRgn( clipRgn ) ;
+ }
+ UnlockPixels( bmappixels ) ;
+ }
+ m_macPenInstalled = false ;
+ m_macBrushInstalled = false ;
+ m_macFontInstalled = false ;
+ return true;
+}
+
+void wxDC::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
+ double angle)
+{
+ // TODO support text background color (only possible by hand, ATSUI does not support it)
+ wxCHECK_RET( Ok(), wxT("wxDC::DoDrawRotatedText Invalid window dc") );
+
+ if ( str.Length() == 0 )
+ return ;
+
+ wxMacFastPortSetter helper(this) ;
+ MacInstallFont() ;
+
+ if ( 0 )
+ {
+ m_macFormerAliasState = IsAntiAliasedTextEnabled(&m_macFormerAliasSize);
+ SetAntiAliasedTextEnabled(true, SInt16(m_scaleY * m_font.MacGetFontSize()));
+ m_macAliasWasEnabled = true ;
+ }
+ OSStatus status = noErr ;
+ ATSUTextLayout atsuLayout ;
+ UniCharCount chars = str.Length() ;
+ UniChar* ubuf = NULL ;
+#if SIZEOF_WCHAR_T == 4
+ wxMBConvUTF16BE converter ;
+#if wxUSE_UNICODE
+ size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
+ ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
+ converter.WC2MB( (char*) ubuf , str.wc_str(), unicharlen + 2 ) ;
+#else
+ const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
+ size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
+ ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
+ converter.WC2MB( (char*) ubuf , wchar.data() , unicharlen + 2 ) ;
+#endif
+ chars = unicharlen / 2 ;
+#else
+#if wxUSE_UNICODE
+ ubuf = (UniChar*) str.wc_str() ;
+#else
+ wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
+ chars = wxWcslen( wchar.data() ) ;
+ ubuf = (UniChar*) wchar.data() ;
+#endif
+#endif
+
+ status = ::ATSUCreateTextLayoutWithTextPtr( (UniCharArrayPtr) ubuf , 0 , chars , chars , 1 ,
+ &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
+
+ wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") );
+ int iAngle = int( angle );
+ int drawX = XLOG2DEVMAC(x) ;
+ int drawY = YLOG2DEVMAC(y) ;
+
+ ATSUTextMeasurement textBefore ;
+ ATSUTextMeasurement textAfter ;
+ ATSUTextMeasurement ascent ;
+ ATSUTextMeasurement descent ;
+
+
+ if ( abs(iAngle) > 0 )
+ {
+ Fixed atsuAngle = IntToFixed( iAngle ) ;
+ ATSUAttributeTag atsuTags[] =
+ {
+ kATSULineRotationTag ,
+ } ;
+ ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ sizeof( Fixed ) ,
+ } ;
+ ATSUAttributeValuePtr atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ &atsuAngle ,
+ } ;
+ status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags)/sizeof(ATSUAttributeTag),
+ atsuTags, atsuSizes, atsuValues ) ;
+ }
+ status = ::ATSUMeasureText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
+ &textBefore , &textAfter, &ascent , &descent );
+
+ drawX += (int)(sin(angle/RAD2DEG) * FixedToInt(ascent));
+ drawY += (int)(cos(angle/RAD2DEG) * FixedToInt(ascent));
+ status = ::ATSUDrawText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
+ IntToFixed(drawX) , IntToFixed(drawY) );
+ wxASSERT_MSG( status == noErr , wxT("couldn't draw the rotated text") );
+ Rect rect ;
+ status = ::ATSUMeasureTextImage( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
+ IntToFixed(drawX) , IntToFixed(drawY) , &rect );
+ wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
+ OffsetRect( &rect , -m_macLocalOrigin.x , -m_macLocalOrigin.y ) ;
+ CalcBoundingBox(XDEV2LOG(rect.left), YDEV2LOG(rect.top) );
+ CalcBoundingBox(XDEV2LOG(rect.right), YDEV2LOG(rect.bottom) );
+ ::ATSUDisposeTextLayout(atsuLayout);
+#if SIZEOF_WCHAR_T == 4
+ free( ubuf ) ;
+#endif
+}
+
+void wxDC::DoDrawText(const wxString& strtext, wxCoord x, wxCoord y)
+{
+ wxCHECK_RET(Ok(), wxT("wxDC::DoDrawText Invalid DC"));
+
+ wxMacFastPortSetter helper(this) ;
+ long xx = XLOG2DEVMAC(x);
+ long yy = YLOG2DEVMAC(y);
+#if TARGET_CARBON
+ bool useDrawThemeText = ( DrawThemeTextBox != (void*) kUnresolvedCFragSymbolAddress ) ;
+ if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC ) ) || m_font.GetNoAntiAliasing() )
+ useDrawThemeText = false ;
+#endif
+ MacInstallFont() ;
+
+ FontInfo fi ;
+ ::GetFontInfo( &fi ) ;
+#if TARGET_CARBON
+ if ( !useDrawThemeText )
+#endif
+ yy += fi.ascent ;
+ ::MoveTo( xx , yy );
+ if ( m_backgroundMode == wxTRANSPARENT )
+ {
+ ::TextMode( srcOr) ;
+ }
+ else
+ {
+ ::TextMode( srcCopy ) ;
+ }
+ int line = 0 ;
+ {
+ wxString linetext = strtext ;
+#if TARGET_CARBON
+ if ( useDrawThemeText )
+ {
+ Rect frame = { yy + line*(fi.descent + fi.ascent + fi.leading) ,xx , yy + (line+1)*(fi.descent + fi.ascent + fi.leading) , xx + 10000 } ;
+ wxMacCFStringHolder mString( linetext , m_font.GetEncoding()) ;
+
+ if ( m_backgroundMode != wxTRANSPARENT )
+ {
+ Point bounds={0,0} ;
+ Rect background = frame ;
+ SInt16 baseline ;
+ ::GetThemeTextDimensions( mString,
+ m_font.MacGetThemeFontID() ,
+ kThemeStateActive,
+ false,
+ &bounds,
+ &baseline );
+ background.right = background.left + bounds.h ;
+ background.bottom = background.top + bounds.v ;
+ ::EraseRect( &background ) ;
+ }
+ ::DrawThemeTextBox( mString,
+ m_font.MacGetThemeFontID() ,
+ kThemeStateActive,
+ false,
+ &frame,
+ teJustLeft,
+ nil );
+ }
+ else
+#endif
+ {
+ wxCharBuffer text = linetext.mb_str(wxConvLocal) ;
+ ::DrawText( text , 0 , strlen(text) ) ;
+ }
+ }
+ ::TextMode( srcOr ) ;
+}
+
+bool wxDC::CanGetTextExtent() const
+{
+ wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
+ return true ;
+}
+
+void wxDC::DoGetTextExtent( const wxString &strtext, wxCoord *width, wxCoord *height,
+ wxCoord *descent, wxCoord *externalLeading ,
+ wxFont *theFont ) const
+{
+ wxCHECK_RET(Ok(), wxT("Invalid DC"));
+ wxMacFastPortSetter helper(this) ;
+ wxFont formerFont = m_font ;
+ if ( theFont )
+ {
+ // work around the constness
+ *((wxFont*)(&m_font)) = *theFont ;
+ }
+ MacInstallFont() ;
+ FontInfo fi ;
+ ::GetFontInfo( &fi ) ;
+#if TARGET_CARBON
+ bool useGetThemeText = ( GetThemeTextDimensions != (void*) kUnresolvedCFragSymbolAddress ) ;
+ if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC ) ) || ((wxFont*)&m_font)->GetNoAntiAliasing() )
+ useGetThemeText = false ;
+#endif
+ if ( height )
+ *height = YDEV2LOGREL( fi.descent + fi.ascent ) ;
+ if ( descent )
+ *descent =YDEV2LOGREL( fi.descent );
+ if ( externalLeading )
+ *externalLeading = YDEV2LOGREL( fi.leading ) ;
+
+ int curwidth = 0 ;
+ if ( width )
+ {
+ *width = 0 ;
+ wxString linetext = strtext ;
+
+ if ( useGetThemeText )
+ {
+ Point bounds={0,0} ;
+ SInt16 baseline ;
+ wxMacCFStringHolder mString( linetext , m_font.GetEncoding() ) ;
+ ThemeFontID themeFont = m_font.MacGetThemeFontID() ;
+ ::GetThemeTextDimensions( mString,
+ themeFont ,
+ kThemeStateActive,
+ false,
+ &bounds,
+ &baseline );
+ curwidth = bounds.h ;
+ }
+ else
+ {
+ wxCharBuffer text = linetext.mb_str(wxConvLocal) ;
+ curwidth = ::TextWidth( text , 0 , strlen(text) ) ;
+ }
+ if ( curwidth > *width )
+ *width = XDEV2LOGREL( curwidth ) ;
+ }
+ if ( theFont )
+ {
+ // work around the constness
+ *((wxFont*)(&m_font)) = formerFont ;
+ m_macFontInstalled = false ;
+ }
+}
+
+
+bool wxDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
+{
+ wxCHECK_MSG(Ok(), false, wxT("Invalid DC"));
+
+ widths.Empty();
+ widths.Add(0, text.Length());
+
+ if (text.Length() == 0)
+ return false;
+
+ wxMacFastPortSetter helper(this) ;
+ MacInstallFont() ;
+#if TARGET_CARBON
+ bool useGetThemeText = ( GetThemeTextDimensions != (void*) kUnresolvedCFragSymbolAddress ) ;
+ if ( UMAGetSystemVersion() < 0x1000 || IsKindOf(CLASSINFO( wxPrinterDC ) ) || ((wxFont*)&m_font)->GetNoAntiAliasing() )
+ useGetThemeText = false ;
+
+ if ( useGetThemeText )
+ {
+ // If anybody knows how to do this more efficiently yet still handle
+ // the fractional glyph widths that may be present when using AA
+ // fonts, please change it. Currently it is measuring from the
+ // begining of the string for each succeding substring, which is much
+ // slower than this should be.
+ for (size_t i=0; i<text.Length(); i++)
+ {
+ wxString str(text.Left(i+1));
+ Point bounds = {0,0};
+ SInt16 baseline ;
+ wxMacCFStringHolder mString(str, m_font.GetEncoding());
+ ::GetThemeTextDimensions( mString,
+ m_font.MacGetThemeFontID(),
+ kThemeStateActive,
+ false,
+ &bounds,
+ &baseline );
+ widths[i] = XDEV2LOGREL(bounds.h);
+ }
+ }
+ else
+#endif
+ {
+ wxCharBuffer buff = text.mb_str(wxConvLocal);
+ size_t len = strlen(buff);
+ short* measurements = new short[len+1];
+ MeasureText(len, buff.data(), measurements);
+
+ // Copy to widths, starting at measurements[1]
+ // NOTE: this doesn't take into account any multi-byte characters
+ // in buff, it probabkly should...
+ for (size_t i=0; i<text.Length(); i++)
+ widths[i] = XDEV2LOGREL(measurements[i+1]);
+
+ delete [] measurements;
+ }
+
+ return true;
+}
+
+
+
+wxCoord wxDC::GetCharWidth(void) const
+{
+ wxCHECK_MSG(Ok(), 1, wxT("Invalid DC"));
+ wxMacFastPortSetter helper(this) ;
+ MacInstallFont() ;
+ int width = 0 ;
+#if TARGET_CARBON
+ bool useGetThemeText = ( GetThemeTextDimensions != (void*) kUnresolvedCFragSymbolAddress ) ;
+ if ( UMAGetSystemVersion() < 0x1000 || ((wxFont*)&m_font)->GetNoAntiAliasing() )
+ useGetThemeText = false ;
+#endif
+ char text[] = "g" ;
+#if TARGET_CARBON
+ if ( useGetThemeText )
+ {
+ Point bounds={0,0} ;
+ SInt16 baseline ;
+ CFStringRef mString = CFStringCreateWithBytes( NULL , (UInt8*) text , 1 , CFStringGetSystemEncoding(), false ) ;
+ ::GetThemeTextDimensions( mString,
+ m_font.MacGetThemeFontID(),
+ kThemeStateActive,
+ false,
+ &bounds,
+ &baseline );
+ CFRelease( mString ) ;
+ width = bounds.h ;
+ }
+ else
+#endif
+ {
+ width = ::TextWidth( text , 0 , 1 ) ;
+ }
+ return YDEV2LOGREL(width) ;
+}
+
+wxCoord wxDC::GetCharHeight(void) const
+{
+ wxCHECK_MSG(Ok(), 1, wxT("Invalid DC"));
+ wxMacFastPortSetter helper(this) ;
+ MacInstallFont() ;
+ FontInfo fi ;
+ ::GetFontInfo( &fi ) ;
+ return YDEV2LOGREL( fi.descent + fi.ascent );
+}
+
+void wxDC::Clear(void)
+{
+ wxCHECK_RET(Ok(), wxT("Invalid DC"));
+ wxMacFastPortSetter helper(this) ;
+ Rect rect = { -31000 , -31000 , 31000 , 31000 } ;
+ if ( m_backgroundBrush.Ok() && m_backgroundBrush.GetStyle() != wxTRANSPARENT)
+ {
+ ::PenNormal() ;
+ MacSetupBackgroundForCurrentPort( m_backgroundBrush ) ;
+ ::EraseRect( &rect ) ;
+ }
+}
+
+void wxDC::MacInstallFont() const
+{
+ wxCHECK_RET(Ok(), wxT("Invalid DC"));
+ // if ( m_macFontInstalled )
+ // return ;
+ Pattern blackColor ;
+ MacSetupBackgroundForCurrentPort(m_backgroundBrush) ;
+ if ( m_backgroundMode != wxTRANSPARENT )
+ {
+ Pattern whiteColor ;
+ ::BackPat(GetQDGlobalsWhite(&whiteColor));
+ }
projects / wxWidgets.git / blobdiff